git-fs-s3 0.13.0 → 0.15.0

package/dist/chunk-IAKZRWBZ.js

@@ -0,0 +1,598 @@
+import {
+  GitConflictError,
+  GitInvalidRequestError,
+  GitObjectNotFoundError,
+  GitPathNotFoundError,
+  GitRefNotFoundError,
+  concat,
+  deflate,
+  encodeUtf8,
+  fromHex,
+  isSafeBranchName,
+  packFileName,
+  qualifyBranchRef,
+  rawFs,
+  sha1,
+  toHex
+} from "./chunk-OKBQISUC.js";
+
+// src/ops/tree.ts
+import git from "isomorphic-git";
+var joinPath = (prefix, name) => prefix ? `${prefix.replace(/\/+$/, "")}/${name}` : name;
+var BLOB_MODES = /* @__PURE__ */ new Set(["100644", "100755", "120000"]);
+async function upsertTree(repo, treeOid, entries) {
+  const existing = treeOid ? (await git.readTree({ ...repo, oid: treeOid })).tree : [];
+  const byName = new Map(existing.map((e) => [e.path, e]));
+  const direct = /* @__PURE__ */ new Map();
+  const nested = /* @__PURE__ */ new Map();
+  for (const [filePath, blobOid] of entries) {
+    const slash = filePath.indexOf("/");
+    if (slash === -1) {
+      direct.set(filePath, blobOid);
+    } else {
+      const dir = filePath.slice(0, slash);
+      const rest = filePath.slice(slash + 1);
+      if (!nested.has(dir)) nested.set(dir, /* @__PURE__ */ new Map());
+      nested.get(dir)?.set(rest, blobOid);
+    }
+  }
+  for (const [name, blobOid] of direct) {
+    const current = byName.get(name);
+    if (current && current.type !== "blob") {
+      throw new GitInvalidRequestError(`"${name}" is a directory, not a file`);
+    }
+    byName.set(name, {
+      mode: current && BLOB_MODES.has(current.mode) ? current.mode : "100644",
+      path: name,
+      oid: blobOid,
+      type: "blob"
+    });
+  }
+  const nestedResults = await Promise.all(
+    Array.from(nested, async ([dir, subEntries]) => {
+      const entry = byName.get(dir);
+      if (entry && entry.type !== "tree") {
+        throw new GitInvalidRequestError(`"${dir}" is a file, not a directory`);
+      }
+      const subtreeOid = entry?.oid;
+      const newOid = await upsertTree(repo, subtreeOid, subEntries);
+      return [dir, newOid];
+    })
+  );
+  for (const [dir, newOid] of nestedResults) {
+    byName.set(dir, { mode: "040000", path: dir, oid: newOid, type: "tree" });
+  }
+  return git.writeTree({ ...repo, tree: Array.from(byName.values()) });
+}
+async function deleteFromTree(repo, treeOid, filePath) {
+  const result = await deleteFromSubtree(repo, treeOid, filePath, filePath);
+  return result ?? git.writeTree({ ...repo, tree: [] });
+}
+async function deleteFromSubtree(repo, treeOid, filePath, fullPath) {
+  const existing = (await git.readTree({ ...repo, oid: treeOid })).tree;
+  const byName = new Map(existing.map((e) => [e.path, e]));
+  const slash = filePath.indexOf("/");
+  const name = slash === -1 ? filePath : filePath.slice(0, slash);
+  const entry = byName.get(name);
+  if (slash === -1) {
+    if (entry?.type !== "blob") {
+      throw new GitPathNotFoundError(`No such file: ${fullPath}`);
+    }
+    byName.delete(name);
+  } else {
+    if (entry?.type !== "tree") {
+      throw new GitPathNotFoundError(`No such file: ${fullPath}`);
+    }
+    const newOid = await deleteFromSubtree(
+      repo,
+      entry.oid,
+      filePath.slice(slash + 1),
+      fullPath
+    );
+    if (newOid === null) byName.delete(name);
+    else byName.set(name, { ...entry, oid: newOid });
+  }
+  if (byName.size === 0) return null;
+  return git.writeTree({ ...repo, tree: Array.from(byName.values()) });
+}
+async function findTreeEntry(repo, rootTreeOid, treePath) {
+  if (!treePath) {
+    return { path: "", mode: "040000", type: "tree", oid: rootTreeOid };
+  }
+  const parts = treePath.split("/").filter(Boolean);
+  let currentTreeOid = rootTreeOid;
+  let currentPath = "";
+  for (const [index, part] of parts.entries()) {
+    const tree = await git.readTree({ ...repo, oid: currentTreeOid });
+    const entry = tree.tree.find((candidate) => candidate.path === part);
+    if (!entry) return null;
+    currentPath = currentPath ? joinPath(currentPath, entry.path) : entry.path;
+    if (index === parts.length - 1) {
+      return {
+        path: currentPath,
+        mode: entry.mode,
+        type: entry.type,
+        oid: entry.oid
+      };
+    }
+    if (entry.type !== "tree") return null;
+    currentTreeOid = entry.oid;
+  }
+  return null;
+}
+async function listTreeEntries(repo, treeOid, prefix = "") {
+  const tree = await git.readTree({ ...repo, oid: treeOid });
+  return tree.tree.map((entry) => ({
+    path: prefix ? joinPath(prefix, entry.path) : entry.path,
+    mode: entry.mode,
+    type: entry.type,
+    oid: entry.oid
+  }));
+}
+
+// src/ops/types.ts
+var runStep = (hooks, label, fn) => hooks?.step ? hooks.step(label, fn) : fn();
+function resultKeyPrefixes(gitdir) {
+  return [
+    `commitlog:${gitdir}:`,
+    `tree:${gitdir}:`,
+    `last-commits:${gitdir}:`,
+    `file-history:${gitdir}:`
+  ];
+}
+
+// src/ops/history.ts
+import git2 from "isomorphic-git";
+var HISTORY_WALK_DEPTH = 400;
+function summarizeCommit(commit) {
+  return {
+    sha: commit.oid,
+    message: commit.commit.message.trim(),
+    authorName: commit.commit.author.name,
+    authorEmail: commit.commit.author.email,
+    createdAt: new Date(commit.commit.author.timestamp * 1e3).toISOString()
+  };
+}
+var isNotFound = (err) => err?.code === "NotFoundError";
+function wrapMissingObject(promise, context) {
+  return promise.catch((err) => {
+    if (isNotFound(err)) {
+      throw new GitObjectNotFoundError(
+        `Git data for ${context} is missing from storage`
+      );
+    }
+    throw err;
+  });
+}
+async function resolveRefOid(repo, ref) {
+  const qualified = qualifyBranchRef(ref);
+  const candidates = qualified === `refs/heads/${ref}` ? [qualified, `refs/tags/${ref}`] : [qualified];
+  for (const candidate of candidates) {
+    try {
+      return await peelToCommit(
+        repo,
+        await git2.resolveRef({ ...repo, ref: candidate })
+      );
+    } catch (err) {
+      if (!isNotFound(err)) throw err;
+    }
+  }
+  throw new GitRefNotFoundError(`Ref ${ref} does not exist`);
+}
+async function peelToCommit(repo, oid) {
+  let current = oid;
+  for (let depth = 0; depth < 10; depth++) {
+    const { type, object } = await git2.readObject({
+      ...repo,
+      oid: current,
+      format: "parsed"
+    });
+    if (type !== "tag") return current;
+    current = object.object;
+  }
+  throw new GitRefNotFoundError(`Tag chain at ${oid} is too deep`);
+}
+async function resolveCommit(repo, ref) {
+  const oid = await resolveRefOid(repo, ref);
+  const { commit } = await wrapMissingObject(
+    git2.readCommit({ ...repo, oid }),
+    `${repo.gitdir} commit ${oid}`
+  );
+  return { oid, commit };
+}
+async function getBlob(repo, sha) {
+  const { blob } = await wrapMissingObject(
+    git2.readBlob({ ...repo, oid: sha }),
+    `${repo.gitdir} blob ${sha}`
+  );
+  return blob;
+}
+async function getFileContent(repo, filePath, ref, hooks) {
+  if (hooks?.prefetch) await runStep(hooks, "prefetch", hooks.prefetch);
+  const { commit } = await resolveCommit(repo, ref);
+  const context = `${repo.gitdir}@${ref}:${filePath}`;
+  const entry = await wrapMissingObject(
+    findTreeEntry(repo, commit.tree, filePath),
+    context
+  );
+  if (entry?.type !== "blob") {
+    throw new GitPathNotFoundError(`File not found: ${filePath}`);
+  }
+  const { blob } = await wrapMissingObject(
+    git2.readBlob({ ...repo, oid: entry.oid }),
+    context
+  );
+  return blob;
+}
+async function getCommit(repo, sha) {
+  const result = await wrapMissingObject(
+    git2.readCommit({ ...repo, oid: sha }),
+    `${repo.gitdir} commit ${sha}`
+  );
+  return { oid: result.oid, commit: result.commit, payload: result.payload };
+}
+async function getCommitLog(repo, options, hooks) {
+  const { ref } = options;
+  const depth = options.depth ?? 50;
+  let headSha = options.knownHeadSha;
+  if (headSha === void 0) {
+    try {
+      headSha = await resolveRefOid(repo, ref);
+    } catch (err) {
+      if (err instanceof GitRefNotFoundError) return [];
+      throw err;
+    }
+  }
+  const cacheKey = `commitlog:${repo.gitdir}:${headSha}`;
+  const cached = hooks?.resultCache?.get(cacheKey);
+  const fullyWalked = cached?.at(-1)?.commit.parent.length === 0;
+  if (cached && (cached.length >= depth || fullyWalked)) {
+    hooks?.onNote?.(`getCommitLog: cache hit ${cacheKey} (depth=${depth})`);
+    return cached.slice(0, depth);
+  }
+  hooks?.onNote?.(`getCommitLog: cache miss ${cacheKey} (depth=${depth})`);
+  if (hooks?.prefetch) await runStep(hooks, "prefetch", hooks.prefetch);
+  const log = await wrapMissingObject(
+    runStep(
+      hooks,
+      `git.log ${ref} depth=${depth}`,
+      () => git2.log({ ...repo, ref: headSha, depth })
+    ),
+    `${repo.gitdir}@${ref} history`
+  );
+  const result = log.map(({ oid, commit, payload }) => ({
+    oid,
+    commit,
+    payload: payload ?? ""
+  }));
+  if (!cached || result.length > cached.length) {
+    hooks?.resultCache?.set(cacheKey, result);
+  }
+  return result;
+}
+async function getTreeFromRef(repo, options, hooks) {
+  const { ref } = options;
+  const treePath = options.treePath ?? "";
+  const { commit, oid: headSha } = await resolveCommit(repo, ref);
+  const cacheKey = `tree:${repo.gitdir}:${headSha}:${treePath}`;
+  const cached = hooks?.resultCache?.get(cacheKey);
+  if (cached) {
+    hooks?.onNote?.(`getTreeFromRef: cache hit ${cacheKey}`);
+    return cached;
+  }
+  hooks?.onNote?.(`getTreeFromRef: cache miss ${cacheKey}`);
+  if (hooks?.prefetch) await runStep(hooks, "prefetch", hooks.prefetch);
+  const context = `${repo.gitdir}@${ref}:${treePath || "/"}`;
+  const dir = treePath ? await wrapMissingObject(
+    runStep(
+      hooks,
+      `findTreeEntry ${treePath}`,
+      () => findTreeEntry(repo, commit.tree, treePath)
+    ),
+    context
+  ) : { path: "", type: "tree", oid: commit.tree };
+  if (!dir) {
+    throw new GitPathNotFoundError(
+      `Path "${treePath}" does not exist at ${ref}`
+    );
+  }
+  const result = dir.type === "tree" ? await wrapMissingObject(
+    runStep(
+      hooks,
+      `listTreeEntries ${treePath || "/"}`,
+      () => listTreeEntries(repo, dir.oid, dir.path)
+    ),
+    context
+  ) : [];
+  hooks?.resultCache?.set(cacheKey, result);
+  return result;
+}
+async function getCommitHistory(repo, options, hooks) {
+  const limit = options.limit ?? 50;
+  const skip = options.skip ?? 0;
+  const log = await getCommitLog(
+    repo,
+    { ref: options.ref, depth: limit + skip },
+    hooks
+  );
+  return log.slice(skip, skip + limit);
+}
+
+// src/ops/branch.ts
+import git3 from "isomorphic-git";
+function assertSafeBranchName(name) {
+  if (!isSafeBranchName(name)) {
+    throw new GitInvalidRequestError(`Invalid branch name: ${name}`);
+  }
+}
+var FULL_SHA_RE = /^[0-9a-f]{40}$/i;
+function hasRecursiveFileLister(fs) {
+  return typeof fs === "object" && fs !== null && "listFilesRecursively" in fs && typeof fs.listFilesRecursively === "function";
+}
+function getPromisesFs(fs) {
+  const promises = fs.promises;
+  return promises ?? null;
+}
+function decodeFileContent(content) {
+  return typeof content === "string" ? content : new TextDecoder().decode(content);
+}
+async function listLooseBranches(repo) {
+  return listLooseRefNames(repo, "refs/heads");
+}
+async function listLooseRefNames(repo, dir) {
+  if (!hasRecursiveFileLister(repo.fs)) return null;
+  const names = await repo.fs.listFilesRecursively(`${repo.gitdir}/${dir}`);
+  return names.filter(isSafeBranchName);
+}
+async function readPackedBranches(repo) {
+  if (!hasRecursiveFileLister(repo.fs)) return /* @__PURE__ */ new Map();
+  const promisesFs = getPromisesFs(repo.fs);
+  if (!promisesFs) return /* @__PURE__ */ new Map();
+  try {
+    const content = await promisesFs.readFile(
+      `${repo.gitdir}/packed-refs`,
+      "utf8"
+    );
+    const refs = /* @__PURE__ */ new Map();
+    for (const line of decodeFileContent(content).split("\n")) {
+      const match = /^([0-9a-f]{40}) refs\/heads\/(.+)$/i.exec(line);
+      if (match?.[1] && match[2] && isSafeBranchName(match[2])) {
+        refs.set(match[2], match[1]);
+      }
+    }
+    return refs;
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+async function getCurrentLooseBranch(repo) {
+  if (!hasRecursiveFileLister(repo.fs)) return null;
+  const promisesFs = getPromisesFs(repo.fs);
+  if (!promisesFs) return null;
+  try {
+    const content = await promisesFs.readFile(`${repo.gitdir}/HEAD`, "utf8");
+    const head = decodeFileContent(content).trim();
+    const match = /^ref: refs\/heads\/(.+)$/.exec(head);
+    return match?.[1] && isSafeBranchName(match[1]) ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+async function resolveLooseRefFast(repo, ref) {
+  const promisesFs = getPromisesFs(repo.fs);
+  if (promisesFs) {
+    try {
+      const content = await promisesFs.readFile(
+        `${repo.gitdir}/${ref}`,
+        "utf8"
+      );
+      const oid = decodeFileContent(content).trim();
+      if (FULL_SHA_RE.test(oid)) return oid;
+    } catch {
+    }
+  }
+  return git3.resolveRef({ ...repo, ref });
+}
+async function listBranches(repo) {
+  try {
+    const [looseBranches, looseCurrentBranch, packedBranches] = await Promise.all([
+      listLooseBranches(repo),
+      getCurrentLooseBranch(repo),
+      readPackedBranches(repo)
+    ]);
+    const branches = looseBranches === null ? await git3.listBranches(repo) : [.../* @__PURE__ */ new Set([...looseBranches, ...packedBranches.keys()])].sort();
+    const currentBranch = looseBranches === null ? await git3.currentBranch({ ...repo, fullname: false }).catch(() => null) : looseCurrentBranch;
+    return Promise.all(
+      branches.map(async (branch) => {
+        const packedCommit = packedBranches.get(branch);
+        return {
+          name: branch,
+          commit: packedCommit && !looseBranches?.includes(branch) ? packedCommit : await resolveLooseRefFast(repo, `refs/heads/${branch}`),
+          isDefault: branch === currentBranch
+        };
+      })
+    );
+  } catch (err) {
+    if (err.code === "NotFoundError") return [];
+    throw err;
+  }
+}
+async function createBranchFrom(repo, name, startPoint) {
+  assertSafeBranchName(name);
+  assertSafeBranchName(startPoint);
+  const object = await resolveLooseRefFast(repo, `refs/heads/${startPoint}`);
+  try {
+    await git3.branch({ ...repo, ref: name, checkout: false, object });
+  } catch (err) {
+    if (err.code === "AlreadyExistsError") {
+      throw new GitConflictError(`Branch ${name} already exists`);
+    }
+    throw err;
+  }
+}
+async function deleteBranchByName(repo, name) {
+  assertSafeBranchName(name);
+  const current = await getCurrentLooseBranch(repo) ?? await git3.currentBranch({ ...repo, fullname: false }).catch(() => null);
+  if (current === name) {
+    throw new GitInvalidRequestError(
+      `Cannot delete ${name}: it is the default branch`
+    );
+  }
+  await git3.deleteBranch({ ...repo, ref: name });
+}
+async function assertBranchExists(repo, name) {
+  assertSafeBranchName(name);
+  await resolveLooseRefFast(repo, `refs/heads/${name}`);
+}
+async function listTags(repo) {
+  const names = await listLooseRefNames(repo, "refs/tags") ?? [];
+  const all = /* @__PURE__ */ new Set([
+    ...names,
+    ...await git3.listTags(repo).catch(() => [])
+  ]);
+  const tags = await Promise.all(
+    [...all].filter(isSafeBranchName).map(async (name) => {
+      try {
+        const oid = await resolveLooseRefFast(repo, `refs/tags/${name}`);
+        const commit = await peelToCommit(repo, oid);
+        return commit === oid ? { name, commit } : { name, commit, tagObject: oid };
+      } catch {
+        return null;
+      }
+    })
+  );
+  return tags.filter((tag) => tag !== null).sort((a, b) => a.name.localeCompare(b.name, void 0, { numeric: true }));
+}
+
+// src/pack-write.ts
+import git4 from "isomorphic-git";
+var PACK_OBJECT_TYPE_BITS = {
+  commit: 16,
+  tree: 32,
+  blob: 48,
+  tag: 64
+};
+function encodePackObjectHeader(type, length) {
+  const bytes = [];
+  let more = length > 15;
+  bytes.push(
+    (more ? 128 : 0) | PACK_OBJECT_TYPE_BITS[type] | length & 15
+  );
+  let rest = Math.floor(length / 16);
+  while (more) {
+    more = rest > 127;
+    bytes.push((more ? 128 : 0) | rest & 127);
+    rest = Math.floor(rest / 128);
+  }
+  return new Uint8Array(bytes);
+}
+function hashGitObject(type, content) {
+  return sha1(concat(encodeUtf8(`${type} ${content.length}\0`), content));
+}
+async function encodePack(objects) {
+  const header = new Uint8Array(12);
+  const view = new DataView(header.buffer);
+  header.set(encodeUtf8("PACK"), 0);
+  view.setUint32(4, 2, false);
+  view.setUint32(8, objects.length, false);
+  const chunks = [header];
+  const BATCH_SIZE = 100;
+  for (let i = 0; i < objects.length; i += BATCH_SIZE) {
+    const encoded = await Promise.all(
+      objects.slice(i, i + BATCH_SIZE).map(
+        async (object) => concat(
+          encodePackObjectHeader(object.type, object.content.length),
+          await deflate(object.content)
+        )
+      )
+    );
+    chunks.push(...encoded);
+  }
+  const body = concat(...chunks);
+  return concat(body, fromHex(await sha1(body)));
+}
+function packBaseName(pack) {
+  return `pack-${toHex(pack.subarray(pack.length - 20))}`;
+}
+async function storePack(repo, pack) {
+  const fsp = rawFs(repo);
+  const packDir = `${repo.gitdir}/objects/pack`;
+  const base = packBaseName(pack);
+  await fsp.mkdir(packDir, { recursive: true });
+  await fsp.writeFile(`${packDir}/${packFileName(base, "pack")}`, pack);
+  const { oids } = await git4.indexPack({
+    ...repo,
+    dir: packDir,
+    filepath: packFileName(base, "pack")
+  });
+  return { base, oids };
+}
+
+// src/semaphore.ts
+function createSemaphore(limit) {
+  if (!Number.isInteger(limit) || limit < 1) {
+    throw new Error(
+      `createSemaphore: limit must be an integer >= 1, got ${limit}`
+    );
+  }
+  let active = 0;
+  const waiting = [];
+  function release() {
+    const next = waiting.shift();
+    if (next) next();
+    else active--;
+  }
+  function acquire() {
+    if (active < limit) {
+      active++;
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      waiting.push(resolve);
+    });
+  }
+  return {
+    run(fn) {
+      return acquire().then(async () => {
+        try {
+          return await fn();
+        } finally {
+          release();
+        }
+      });
+    }
+  };
+}
+
+export {
+  upsertTree,
+  deleteFromTree,
+  findTreeEntry,
+  listTreeEntries,
+  runStep,
+  resultKeyPrefixes,
+  HISTORY_WALK_DEPTH,
+  summarizeCommit,
+  peelToCommit,
+  resolveCommit,
+  getBlob,
+  getFileContent,
+  getCommit,
+  getCommitLog,
+  getTreeFromRef,
+  getCommitHistory,
+  assertSafeBranchName,
+  listLooseRefNames,
+  resolveLooseRefFast,
+  listBranches,
+  createBranchFrom,
+  deleteBranchByName,
+  assertBranchExists,
+  listTags,
+  hashGitObject,
+  encodePack,
+  packBaseName,
+  storePack,
+  createSemaphore
+};
+//# sourceMappingURL=chunk-IAKZRWBZ.js.map