বড় repository — monorepo, submodule, subtree আর Git LFS

# Default owners for everything in the repository
*                     @bazar-org/platform-team

# Each team owns its folders; later lines override earlier ones
/services/payments/   @bazar-org/payments-team
/web/                 @bazar-org/web-team
/libs/money/          @bazar-org/payments-team @bazar-org/web-team
/ci/                  @bazar-org/platform-team

// Affected projects in a monorepo: changed files -> owning projects -> every
// project that depends on them, directly or indirectly (reverse dependency BFS).
const deps = {                       // project: the projects it depends on
  "libs/money":        [],
  "libs/auth":         [],
  "libs/ui-kit":       [],
  "services/payments": ["libs/money", "libs/auth"],
  "services/catalog":  ["libs/auth"],
  "web/shop":          ["libs/ui-kit", "libs/money"],
  "web/admin":         ["libs/ui-kit", "services/catalog"],
};
const GLOBAL = ["package-lock.json", "ci/pipeline.yml"]; // shared: affects everyone
const users = {};                    // reverse edges: project -> its dependants
for (const [p, ds] of Object.entries(deps)) for (const d of ds) (users[d] ??= []).push(p);
const owner = f => Object.keys(deps).filter(p => f.startsWith(p + "/"))
                     .sort((a, b) => b.length - a.length)[0];   // longest prefix wins
function affected(changed) {
  if (changed.some(f => GLOBAL.includes(f))) return Object.keys(deps).map(p => p.padEnd(18) + " <- shared file");
  const why = new Map(), queue = [];
  for (const f of changed) { const p = owner(f);
    if (!p) { console.log("  (no project owns " + f + ")"); continue; }
    if (!why.has(p)) { why.set(p, "changed"); queue.push(p); } }
  while (queue.length) { const p = queue.shift();            // breadth-first
    for (const u of users[p] ?? []) if (!why.has(u)) { why.set(u, "<- " + p); queue.push(u); } }
  return [...why].map(([p, w]) => p.padEnd(18) + " " + w);
}
for (const change of [["libs/auth/token.js", "docs/intro.md"],
                      ["web/shop/cart.js"], ["libs/ui-kit/button.css", "package-lock.json"]]) {
  console.log("changed: " + change.join(", "));
  for (const line of affected(change)) console.log("  build+test " + line);
}

$ git clone -q mono.git full
$ git -C full count-objects -v | grep -E '^(count|in-pack)'
count: 67
in-pack: 0
$ git clone --depth 1 mono.git shallow
Cloning into 'shallow'...
warning: --depth is ignored in local clones; use file:// instead.
done.
$ git clone --depth 1 file://$PWD/mono.git shallow
Cloning into 'shallow'...
$ cd shallow
$ git log --oneline --decorate
6799182 (grafted, HEAD -> main, origin/main, origin/HEAD) Release step 6
$ git rev-parse --is-shallow-repository
true
$ git rev-list --count HEAD
1
$ git count-objects -v | grep -E '^(count|in-pack)'
count: 0
in-pack: 12
$ git fetch -q --deepen 2
$ git log --oneline
6799182 Release step 6
335d255 Release step 5
1009df1 Release step 4
$ git fetch -q --unshallow
$ git rev-list --count HEAD
6

$ git clone --filter=blob:none file://$PWD/mono.git partial
Cloning into 'partial'...
warning: filtering not recognized by server, ignoring
$ git -C mono.git config uploadpack.allowFilter true
$ git clone --filter=blob:none file://$PWD/mono.git partial
Cloning into 'partial'...
$ cd partial
$ git config --get remote.origin.promisor
true
$ git config --get remote.origin.partialclonefilter
blob:none
$ git rev-list --objects --all --missing=print | grep -c '^?'
20
$ git checkout -q HEAD~3
$ git rev-list --objects --all --missing=print | grep -c '^?'
16

// Clone-size model. Sizes are raw (no zlib, no delta), so real packs are smaller.
function mulberry32(a) { return function () { a |= 0; a = a + 0x6D2B79F5 | 0;
  let t = Math.imul(a ^ a >>> 15, 1 | a); t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
  return ((t ^ t >>> 14) >>> 0) / 4294967296; }; }
const rnd = mulberry32(19);
const FILES = 400, COMMITS = 1500, CHANGED = 3;  // 3 files change in each commit
const SNAPSHOT_TREES_KB = 900;   // every tree object of one full snapshot
const META_KB = 6;               // one later commit: commit object + changed trees
let size = Array.from({ length: FILES }, () => 2 + Math.floor(rnd() * 198)); // KB
let allBlobsKB = size.reduce((a, b) => a + b, 0);  // commit 1 stores every file
for (let c = 2; c <= COMMITS; c++) {
  for (let k = 0; k < CHANGED; k++) {
    const f = Math.floor(rnd() * FILES);
    size[f] = Math.max(1, Math.round(size[f] * (0.9 + rnd() * 0.3)));
    allBlobsKB += size[f];                          // each new version = a new blob
  }
}
const headKB = size.reduce((a, b) => a + b, 0);
const allMetaKB = SNAPSHOT_TREES_KB + (COMMITS - 1) * META_KB;
const rows = [
  ["full clone",                 allMetaKB + allBlobsKB],
  ["shallow --depth 1",          SNAPSHOT_TREES_KB + headKB],
  ["partial --filter=blob:none", allMetaKB + headKB],
];
const MB = kb => (kb / 1024).toFixed(1).padStart(7) + " MB";
console.log(`${COMMITS} commits, ${FILES} files, ${FILES + (COMMITS - 1) * CHANGED} blob versions`);
console.log(`HEAD snapshot blobs: ${MB(headKB)}   all blobs: ${MB(allBlobsKB)}`);
for (const [name, kb] of rows)
  console.log(name.padEnd(27) + MB(kb) + `  (${(100 * kb / rows[0][1]).toFixed(1)}% of full)`);

$ git clone -q --filter=blob:none --sparse file://$PWD/mono.git sparse
$ cd sparse
$ ls
README.md
$ git sparse-checkout set services/payments
$ ls -R services | head -6
services:
payments

services/payments:
app.txt
$ git sparse-checkout list
services/payments

$ git maintenance start        # register this repo and schedule background tasks
$ git maintenance run --task=commit-graph   # run one task now
$ git maintenance stop         # unregister

$ git submodule add ../ui-kit.git libs/ui-kit
Cloning into '…/work/shop/libs/ui-kit'...
fatal: transport 'file' not allowed
fatal: clone of '…/work/ui-kit.git' into submodule path '…/work/shop/libs/ui-kit' failed
$ git -c protocol.file.allow=always submodule add ../ui-kit.git libs/ui-kit
Cloning into '…/work/shop/libs/ui-kit'...
done.
$ cat .gitmodules
[submodule "libs/ui-kit"]
	path = libs/ui-kit
	url = ../ui-kit.git
$ git status --short
A  .gitmodules
A  libs/ui-kit
$ git ls-files --stage libs/ui-kit
160000 aa11f68fa596ae0a5dd65c17c94ae23e045a971d 0	libs/ui-kit
$ git commit -q -m 'Add ui-kit as a submodule'
$ git ls-tree HEAD libs/
160000 commit aa11f68fa596ae0a5dd65c17c94ae23e045a971d	libs/ui-kit
$ git submodule status
 aa11f68fa596ae0a5dd65c17c94ae23e045a971d libs/ui-kit (heads/main)
$ git log --oneline
0dd4953 Add ui-kit as a submodule
5c36c98 Initial shop app

$ git clone -q shop.git shop-a
$ cd shop-a
$ ls libs/ui-kit | wc -l
0
$ git submodule status
-aa11f68fa596ae0a5dd65c17c94ae23e045a971d libs/ui-kit
$ git -c protocol.file.allow=always submodule update --init --recursive
Submodule 'libs/ui-kit' (…/work/ui-kit.git) registered for path 'libs/ui-kit'
Cloning into '…/work/shop-a/libs/ui-kit'...
done.
Submodule path 'libs/ui-kit': checked out 'aa11f68fa596ae0a5dd65c17c94ae23e045a971d'
$ git submodule status
 aa11f68fa596ae0a5dd65c17c94ae23e045a971d libs/ui-kit (heads/main)
$ cd ..
$ git -c protocol.file.allow=always clone --recurse-submodules shop.git shop-b
Cloning into 'shop-b'...
done.
Submodule 'libs/ui-kit' (…/work/ui-kit.git) registered for path 'libs/ui-kit'
Cloning into '…/work/shop-b/libs/ui-kit'...
done.
Submodule path 'libs/ui-kit': checked out 'aa11f68fa596ae0a5dd65c17c94ae23e045a971d'
$ cd shop-b
$ git -C libs/ui-kit status | head -1
HEAD detached at aa11f68

$ cd libs/ui-kit
$ git status | head -1
HEAD detached at aa11f68
$ git pull
From …/work/ui-kit
   aa11f68..cb99720  main       -> origin/main
You are not currently on a branch.
Please specify which branch you want to merge with.
See git-pull(1) for details.

    git pull <remote> <branch>

$ git fetch
$ git switch --detach origin/main
Previous HEAD position was aa11f68 Add card style
HEAD is now at cb99720 Add badge style
$ cd ../..
$ git status --short
 M libs/ui-kit
$ git submodule status
+cb99720ae131e7cbc0d1665223b22493d7302bc8 libs/ui-kit (remotes/origin/HEAD)
$ git diff
diff --git a/libs/ui-kit b/libs/ui-kit
index aa11f68..cb99720 160000
--- a/libs/ui-kit
+++ b/libs/ui-kit
@@ -1 +1 @@
-Subproject commit aa11f68fa596ae0a5dd65c17c94ae23e045a971d
+Subproject commit cb99720ae131e7cbc0d1665223b22493d7302bc8
$ git diff --submodule=log
Submodule libs/ui-kit aa11f68..cb99720:
  > Add badge style
$ git add libs/ui-kit
$ git commit -q -m 'Bump ui-kit to add badge style'
$ git submodule status
 cb99720ae131e7cbc0d1665223b22493d7302bc8 libs/ui-kit (remotes/origin/HEAD)
$ git push -q origin main

$ git submodule update --remote libs/ui-kit
fatal: transport 'file' not allowed
fatal: Unable to fetch in submodule path 'libs/ui-kit'
$ git -c protocol.file.allow=always submodule update --remote libs/ui-kit
From …/work/ui-kit
   cb99720..ab1bba7  main       -> origin/main
Submodule path 'libs/ui-kit': checked out 'ab1bba7148c680202dbef10a29b9835f2b7fc19c'
$ git submodule status
+ab1bba7148c680202dbef10a29b9835f2b7fc19c libs/ui-kit (remotes/origin/HEAD)
$ git status --short
 M libs/ui-kit
$ git diff --submodule=log
Submodule libs/ui-kit cb99720..ab1bba7:
  > Add alert style
$ git submodule foreach 'git log --oneline -1'
Entering 'libs/ui-kit'
ab1bba7 Add alert style

// Submodule pointer model: a superproject commit stores ONLY a commit id for
// libs/ui-kit (a gitlink). Three places can disagree: the checked-out submodule,
// the index of the superproject, and the superproject's last commit (HEAD).
const uiKit = ["u1", "u2", "u3"];                 // ui-kit history, oldest first
const sup = { commits: [], index: null, sub: null };
function status(who, s) {                          // like `git submodule status`
  const head = s.commits.at(-1)?.ptr ?? null;
  const mark = s.sub === null ? "-" : s.sub !== s.index ? "+" : " ";
  const st = s.index !== head ? "staged pointer change" :
             s.sub !== null && s.sub !== head ? "modified: libs/ui-kit (new commits)" : "clean";
  console.log(`${who.padEnd(7)} ${mark}${s.sub ?? s.index} libs/ui-kit   status: ${st}`);
}
function commit(s, msg) { s.commits.push({ msg, ptr: s.index }); }
function clone(s) {                                // clone + submodule update --init
  const ptr = s.commits.at(-1).ptr;
  return { commits: [...s.commits], index: ptr, sub: ptr };
}
sup.sub = sup.index = uiKit[0]; commit(sup, "Add ui-kit at u1"); status("rahim", sup);
sup.sub = uiKit[1];                                // checkout u2 inside the submodule
status("rahim", sup);
let karim = clone(sup);  status("karim", karim);   // Karim still gets u1!
sup.index = sup.sub;     status("rahim", sup);     // git add libs/ui-kit
commit(sup, "Bump ui-kit to u2"); status("rahim", sup);
karim.commits = [...sup.commits]; karim.index = sup.index;  // git pull, no update
status("karim", karim);
karim.sub = karim.index; status("karim", karim);   // git submodule update
console.log(sup.commits.map(c => `${c.msg} -> pins ${c.ptr}`).join("\n"));

$ cd libs/ui-kit
$ git switch -q -c fix-colors
$ printf '.btn { padding: 8px 16px; color: #0a5; }\n' > button.css
$ git commit -q -am 'Change button colour'
$ cd ../..
$ git add libs/ui-kit
$ git commit -q -m 'Use new button colour'
$ git push --recurse-submodules=check origin main
The following submodule paths contain changes that can
not be found on any remote:
  libs/ui-kit

Please try

	git push --recurse-submodules=on-demand

or cd to the path and use

	git push

to push them to a remote.

fatal: Aborting.
fatal: the remote end hung up unexpectedly
$ git push -q origin main
$ cd ..
$ git -c protocol.file.allow=always clone -q --recurse-submodules shop.git shop-c
fatal: git upload-pack: not our ref b62906ce25790258dfe830b4f0cac7d874fcaaba
fatal: remote error: upload-pack: not our ref b62906ce25790258dfe830b4f0cac7d874fcaaba
fatal: Fetched in submodule path 'libs/ui-kit', but it did not contain b62906ce25790258dfe830b4f0cac7d874fcaaba. Direct fetching of that commit failed.

$ git subtree add --prefix=vendor/ui-kit ../ui-kit.git main
git fetch ../ui-kit.git main
From ../ui-kit
 * branch            main       -> FETCH_HEAD
Added dir 'vendor/ui-kit'
$ git log --oneline --graph
*   e2992c2 Add 'vendor/ui-kit/' from commit 'ab1bba7148c680202dbef10a29b9835f2b7fc19c'
|\
| * ab1bba7 Add alert style
| * cb99720 Add badge style
| * aa11f68 Add card style
| * 6e47256 Add button style
* 707ca54 Start site
$ ls vendor/ui-kit
alert.css
badge.css
button.css
card.css
$ git subtree pull --prefix=vendor/ui-kit ../ui-kit.git main -m 'Update ui-kit subtree'
From ../ui-kit
 * branch            main       -> FETCH_HEAD
Merge made by the 'ort' strategy.
 vendor/ui-kit/modal.css | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 vendor/ui-kit/modal.css
$ git log --oneline --graph
*   539018d Update ui-kit subtree
|\
| * 9dfe5c5 Add modal style
* | e2992c2 Add 'vendor/ui-kit/' from commit 'ab1bba7148c680202dbef10a29b9835f2b7fc19c'
|\|
| * ab1bba7 Add alert style
| * cb99720 Add badge style
| * aa11f68 Add card style
| * 6e47256 Add button style
* 707ca54 Start site

$ git lfs install --local
Updated Git hooks.
Git LFS initialized.
$ git lfs track '*.psd'
Tracking "*.psd"
$ cat .gitattributes
*.psd filter=lfs diff=lfs merge=lfs -text
$ git add .gitattributes design/banner.psd
$ git commit -q -m 'Add banner design'
$ git lfs ls-files
230ed06df4 * design/banner.psd
$ git show HEAD:design/banner.psd
version https://git-lfs.github.com/spec/v1
oid sha256:230ed06df482a77672cd93b6d4024053b380b8563d3a939aa5d25574772ee479
size 300000
$ git cat-file -s HEAD:design/banner.psd
131
$ ls -l design/banner.psd | awk '{print $5}'
300000
$ git check-attr -a design/banner.psd
design/banner.psd: diff: lfs
design/banner.psd: merge: lfs
design/banner.psd: text: unset
design/banner.psd: filter: lfs