git-fs-s3 0.8.0 → 0.9.0

package/dist/ops.js

@@ -16,13 +16,10 @@ import {
   GitObjectNotFoundError,
   GitPathNotFoundError,
   GitRefNotFoundError,
-  decodeUtf8,
-  hasNullByte,
   inflate,
   isSafeTreePath,
   qualifyBranchRef,
-  readBlobContent,
-  toBase64
+  readBlobContent
 } from "./chunk-PASVUPKR.js";
 
 // src/ops/commit.ts
@@ -332,36 +329,49 @@ function resultKeyPrefixes(gitdir) {
   return [
     `commitlog:${gitdir}:`,
     `tree:${gitdir}:`,
-    `commits:${gitdir}:`,
     `last-commits:${gitdir}:`,
     `file-history:${gitdir}:`
   ];
 }
 
 // src/ops/history.ts
+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 (err?.code === "NotFoundError") {
+    if (isNotFound(err)) {
       throw new GitObjectNotFoundError(
-        `Git data for ${context} is missing from storage. The repository may need to be re-pushed to repair it.`
+        `Git data for ${context} is missing from storage`
       );
     }
     throw err;
   });
 }
-var isNotFound = (err) => err?.code === "NotFoundError";
-async function resolveCommit(repo, ref) {
-  const oid = await git3.resolveRef({ ...repo, ref: qualifyBranchRef(ref) }).catch((err) => {
-    if (isNotFound(err)) {
+async function resolveRefOid(repo, ref) {
+  try {
+    return await git3.resolveRef({ ...repo, ref: qualifyBranchRef(ref) });
+  } catch (err) {
+    if (isNotFound(err))
       throw new GitRefNotFoundError(`Ref ${ref} does not exist`);
-    }
     throw err;
-  });
-  const result = await wrapMissingObject(
+  }
+}
+async function resolveCommit(repo, ref) {
+  const oid = await resolveRefOid(repo, ref);
+  const { commit } = await wrapMissingObject(
     git3.readCommit({ ...repo, oid }),
     `${repo.gitdir} commit ${oid}`
   );
-  return { oid, commit: result.commit };
+  return { oid, commit };
 }
 async function getBlob(repo, sha) {
   const { blob } = await wrapMissingObject(
@@ -371,9 +381,7 @@ async function getBlob(repo, sha) {
   return blob;
 }
 async function getFileContent(repo, filePath, ref, hooks) {
-  if (hooks?.prefetch) {
-    await runStep(hooks, "prefetch", hooks.prefetch);
-  }
+  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(
@@ -396,39 +404,28 @@ async function getCommit(repo, sha) {
   );
   return { oid: result.oid, commit: result.commit, payload: result.payload };
 }
-function isFullyWalked(commits) {
-  const last = commits[commits.length - 1];
-  return !!last && last.commit.parent.length === 0;
-}
 async function getCommitLog(repo, options, hooks) {
   const { ref } = options;
   const depth = options.depth ?? 50;
-  let headSha;
-  if (options.knownHeadSha) {
-    headSha = options.knownHeadSha;
-  } else {
+  let headSha = options.knownHeadSha;
+  if (headSha === void 0) {
     try {
-      headSha = await git3.resolveRef({ ...repo, ref: qualifyBranchRef(ref) });
+      headSha = await resolveRefOid(repo, ref);
     } catch (err) {
-      if (isNotFound(err)) return [];
+      if (err instanceof GitRefNotFoundError) return [];
       throw err;
     }
   }
   const cacheKey = `commitlog:${repo.gitdir}:${headSha}`;
   const cached = hooks?.resultCache?.get(cacheKey);
-  if (cached && (cached.length >= depth || isFullyWalked(cached))) {
-    hooks?.onNote?.(
-      `getCommitLog: result-cache HIT for ${cacheKey} (depth=${depth})`
-    );
+  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: result-cache MISS for ${cacheKey} (depth=${depth})`
-  );
-  if (hooks?.prefetch && depth >= (hooks.prefetchMinDepth ?? 5)) {
-    await runStep(hooks, "prefetch", hooks.prefetch);
-  }
-  const commits = await wrapMissingObject(
+  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}`,
@@ -436,25 +433,16 @@ async function getCommitLog(repo, options, hooks) {
     ),
     `${repo.gitdir}@${ref} history`
   );
-  const result = commits.map((commit) => ({
-    oid: commit.oid,
-    commit: commit.commit,
-    payload: commit.payload || ""
+  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 getFileFromRef(repo, filePath, ref, hooks) {
-  const bytes = await getFileContent(repo, filePath, ref, hooks);
-  const isBinary = hasNullByte(bytes);
-  return {
-    content: isBinary ? toBase64(bytes) : decodeUtf8(bytes),
-    size: bytes.length,
-    isBinary
-  };
-}
 async function getTreeFromRef(repo, options, hooks) {
   const { ref } = options;
   const treePath = options.treePath ?? "";
@@ -462,227 +450,143 @@ async function getTreeFromRef(repo, options, hooks) {
   const cacheKey = `tree:${repo.gitdir}:${headSha}:${treePath}`;
   const cached = hooks?.resultCache?.get(cacheKey);
   if (cached) {
-    hooks?.onNote?.(`getTreeFromRef: result-cache HIT for ${cacheKey}`);
+    hooks?.onNote?.(`getTreeFromRef: cache hit ${cacheKey}`);
     return cached;
   }
-  hooks?.onNote?.(`getTreeFromRef: result-cache MISS for ${cacheKey}`);
-  if (hooks?.prefetch) {
-    await runStep(hooks, "prefetch", hooks.prefetch);
-  }
+  hooks?.onNote?.(`getTreeFromRef: cache miss ${cacheKey}`);
+  if (hooks?.prefetch) await runStep(hooks, "prefetch", hooks.prefetch);
   const context = `${repo.gitdir}@${ref}:${treePath || "/"}`;
-  let result;
-  if (!treePath) {
-    result = await wrapMissingObject(
-      runStep(
-        hooks,
-        "listTreeEntries (root)",
-        () => listTreeEntries(repo, commit.tree)
-      ),
-      context
-    );
-  } else {
-    const entry = await wrapMissingObject(
-      runStep(
-        hooks,
-        `findTreeEntry ${treePath}`,
-        () => findTreeEntry(repo, commit.tree, treePath)
-      ),
-      context
-    );
-    if (!entry) {
-      throw new GitPathNotFoundError(
-        `Path "${treePath}" does not exist at ${ref}`
-      );
-    }
-    result = entry.type !== "tree" ? [] : await wrapMissingObject(
-      runStep(
-        hooks,
-        `listTreeEntries ${treePath}`,
-        () => listTreeEntries(repo, entry.oid, entry.path)
-      ),
-      context
+  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 headSha = await git3.resolveRef({ ...repo, ref: qualifyBranchRef(options.ref) }).catch(() => null);
-  const cacheKey = headSha ? `commits:${repo.gitdir}:${headSha}:${limit}:${skip}` : null;
-  if (cacheKey) {
-    const cached = hooks?.resultCache?.get(cacheKey);
-    if (cached) {
-      hooks?.onNote?.(`getCommitHistory: result-cache HIT for ${cacheKey}`);
-      return cached;
-    }
-  }
-  hooks?.onNote?.(
-    `getCommitHistory: result-cache MISS for ${cacheKey ?? "(no head)"}`
-  );
-  if (!headSha) return [];
-  const all = await getCommitLog(
+  const log = await getCommitLog(
     repo,
-    { ref: options.ref, depth: limit + skip, knownHeadSha: headSha },
+    { ref: options.ref, depth: limit + skip },
     hooks
   );
-  const result = all.slice(skip, skip + limit);
-  if (cacheKey) hooks?.resultCache?.set(cacheKey, result);
-  return result;
+  return log.slice(skip, skip + limit);
 }
 
 // src/ops/diff.ts
 var MAX_DIFF_TEXT_BYTES = 1024 * 1024;
-function detectBlobContent(blob) {
-  return readBlobContent(blob);
-}
 function countContentLines(content) {
   if (content.length === 0) return 0;
   const lines = content.split("\n");
-  if (lines[lines.length - 1] === "") lines.pop();
+  if (lines.at(-1) === "") lines.pop();
   return lines.length;
 }
-function createUnifiedPatch(params) {
-  const oldPath = params.oldPath ?? `a/${params.path}`;
-  const newPath = params.newPath ?? `b/${params.path}`;
-  const patchBody = createTwoFilesPatch(
-    oldPath,
-    newPath,
-    params.before,
-    params.after,
+function unifiedPatch(path, before, after) {
+  const body = createTwoFilesPatch(
+    before ? `a/${path}` : "/dev/null",
+    after ? `b/${path}` : "/dev/null",
+    before?.text ?? "",
+    after?.text ?? "",
     "",
     "",
     { context: 3 }
   ).replace(/^=+\n/, "");
-  return `diff --git a/${params.path} b/${params.path}
-${patchBody}`;
+  return `diff --git a/${path} b/${path}
+${body}`;
 }
-function summarizeDiff(files) {
-  return {
-    files,
-    totalAdditions: files.reduce((sum, f) => sum + f.additions, 0),
-    totalDeletions: files.reduce((sum, f) => sum + f.deletions, 0),
-    totalFiles: files.length
-  };
-}
-function buildDiffFile(path, status, before, after) {
+function buildDiffFile(path, before, after) {
   const kind = before?.isBinary || after?.isBinary ? "binary" : Math.max(before?.bytes.length ?? 0, after?.bytes.length ?? 0) > MAX_DIFF_TEXT_BYTES ? "too-large" : "text";
   const isText = kind === "text";
   return {
     path,
-    status,
+    status: !before ? "added" : !after ? "deleted" : "modified",
     kind,
     additions: isText && after ? countContentLines(after.text) : 0,
     deletions: isText && before ? countContentLines(before.text) : 0,
-    patch: isText ? createUnifiedPatch({
-      path,
-      before: before?.text ?? "",
-      after: after?.text ?? "",
-      oldPath: before ? void 0 : "/dev/null",
-      newPath: after ? void 0 : "/dev/null"
-    }) : "",
+    patch: isText ? unifiedPatch(path, before, after) : "",
     oldSize: before?.bytes.length,
     newSize: after?.bytes.length
   };
 }
-async function walkTreeDiff(repo, oldOid, newOid) {
+async function diffTrees(repo, oldTreeOid, newTreeOid) {
+  const readSide = async (entry) => {
+    if (!entry || await entry.type() !== "blob") return null;
+    const { blob } = await git4.readBlob({ ...repo, oid: await entry.oid() });
+    return readBlobContent(blob);
+  };
+  const trees = oldTreeOid ? [git4.TREE({ ref: oldTreeOid }), git4.TREE({ ref: newTreeOid })] : [git4.TREE({ ref: newTreeOid })];
   const changes = await git4.walk({
     ...repo,
-    trees: [git4.TREE({ ref: oldOid }), git4.TREE({ ref: newOid })],
-    map: async (filepath, [A, B]) => {
-      const [typeA, typeB] = await Promise.all([A?.type(), B?.type()]);
-      if (typeA === "tree" || typeB === "tree") return;
-      if (typeA && !typeB) {
-        const oidA2 = A ? await A.oid() : "";
-        const { blob } = await git4.readBlob({ ...repo, oid: oidA2 });
-        const before = detectBlobContent(blob);
-        return buildDiffFile(filepath, "deleted", before, null);
-      }
-      if (!typeA && typeB) {
-        const oidB2 = B ? await B.oid() : "";
-        const { blob } = await git4.readBlob({ ...repo, oid: oidB2 });
-        const after = detectBlobContent(blob);
-        return buildDiffFile(filepath, "added", null, after);
-      }
-      const [oidA, oidB] = await Promise.all([
-        A ? A.oid() : Promise.resolve(""),
-        B ? B.oid() : Promise.resolve("")
+    trees,
+    map: async (filepath, entries) => {
+      const [oldEntry, newEntry] = oldTreeOid ? [entries[0] ?? null, entries[1] ?? null] : [null, entries[0] ?? null];
+      const [oldType, newType] = await Promise.all([
+        oldEntry?.type(),
+        newEntry?.type()
       ]);
-      if (oidA !== oidB) {
-        const [{ blob: blobA }, { blob: blobB }] = await Promise.all([
-          git4.readBlob({ ...repo, oid: oidA }),
-          git4.readBlob({ ...repo, oid: oidB })
+      if (oldType !== "blob" && newType !== "blob") return void 0;
+      if (oldEntry && newEntry && oldType === newType) {
+        const [oldOid, newOid] = await Promise.all([
+          oldEntry.oid(),
+          newEntry.oid()
         ]);
-        const before = detectBlobContent(blobA);
-        const after = detectBlobContent(blobB);
-        return buildDiffFile(filepath, "modified", before, after);
+        if (oldOid === newOid) return void 0;
       }
-      return null;
+      const [before, after] = await Promise.all([
+        readSide(oldEntry),
+        readSide(newEntry)
+      ]);
+      return before || after ? buildDiffFile(filepath, before, after) : void 0;
     }
   });
-  return (changes ?? []).filter(
-    (c) => c !== null && c !== void 0
-  );
+  const files = (changes ?? []).filter((file) => !!file);
+  return {
+    files,
+    totalAdditions: files.reduce((sum, f) => sum + f.additions, 0),
+    totalDeletions: files.reduce((sum, f) => sum + f.deletions, 0),
+    totalFiles: files.length
+  };
 }
 async function getCommitDiff(repo, commitSha) {
-  try {
-    const commit = await getCommit(repo, commitSha);
-    const parent = commit.commit.parent[0];
-    if (!parent) {
-      const entries = [];
-      const stack = [
-        { treeOid: commit.commit.tree, prefix: "" }
-      ];
-      while (stack.length) {
-        const { treeOid, prefix } = stack.pop();
-        const { tree } = await git4.readTree({ ...repo, oid: treeOid });
-        for (const entry of tree) {
-          const full = prefix ? `${prefix}/${entry.path}` : entry.path;
-          if (entry.type === "tree") {
-            stack.push({ treeOid: entry.oid, prefix: full });
-          } else if (entry.type === "blob") {
-            entries.push({ path: full, oid: entry.oid });
-          }
-        }
-      }
-      const files2 = await Promise.all(
-        entries.map(async ({ path, oid }) => {
-          const { blob } = await git4.readBlob({ ...repo, oid });
-          const after = detectBlobContent(blob);
-          return buildDiffFile(path, "added", null, after);
-        })
-      );
-      return summarizeDiff(files2);
-    }
-    const files = await walkTreeDiff(repo, parent, commitSha);
-    return summarizeDiff(files);
-  } catch (error) {
-    throw new Error(`Failed to get commit diff: ${error}`);
-  }
+  const { commit } = await getCommit(repo, commitSha);
+  const parent = commit.parent[0];
+  const parentTree = parent ? (await getCommit(repo, parent)).commit.tree : null;
+  return diffTrees(repo, parentTree, commit.tree);
 }
 async function getDiffBetweenRefs(repo, baseRef, compareRef) {
-  const [baseOid, compareOid] = await Promise.all([
-    git4.resolveRef({ ...repo, ref: qualifyBranchRef(baseRef) }),
-    git4.resolveRef({ ...repo, ref: qualifyBranchRef(compareRef) })
+  const [base, compare] = await Promise.all([
+    resolveCommit(repo, baseRef),
+    resolveCommit(repo, compareRef)
   ]);
-  const files = await walkTreeDiff(repo, baseOid, compareOid);
-  return summarizeDiff(files);
+  const [mergeBase] = await git4.findMergeBase({
+    ...repo,
+    oids: [base.oid, compare.oid]
+  });
+  const baseTree = mergeBase === void 0 ? null : mergeBase === base.oid ? base.commit.tree : (await getCommit(repo, mergeBase)).commit.tree;
+  return diffTrees(repo, baseTree, compare.commit.tree);
 }
 
 // src/ops/file-history.ts
-var HISTORY_WALK_DEPTH = 400;
 var BANNER_WALK_DEPTH = 60;
 var PREFETCH_WINDOW = 24;
-function toEntry(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()
-  };
-}
 async function getFileHistory(repo, options, hooks) {
   const limit = options.limit ?? 30;
   const maxDepth = options.maxDepth ?? HISTORY_WALK_DEPTH;
@@ -733,7 +637,7 @@ async function getFileHistory(repo, options, hooks) {
         parentCommit ? resolveOid(parentCommit.commit.tree) : Promise.resolve(null)
       ]);
       if (oid !== parentOid) {
-        entries.push(toEntry(commit));
+        entries.push(summarizeCommit(commit));
         if (entries.length >= limit) {
           truncated = i < commits.length - 1;
           break outer;
@@ -747,20 +651,10 @@ async function getFileHistory(repo, options, hooks) {
 }
 
 // src/ops/last-commit.ts
-var HISTORY_WALK_DEPTH2 = 400;
 var PREFETCH_WINDOW2 = 24;
-function toLastCommitInfo(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()
-  };
-}
 async function getLastCommitsForTree(repo, options, hooks) {
   const treePath = options.treePath ?? "";
-  const depth = options.depth ?? HISTORY_WALK_DEPTH2;
+  const depth = options.depth ?? HISTORY_WALK_DEPTH;
   const commits = await runStep(
     hooks,
     `getCommitLog depth=${depth}`,
@@ -840,7 +734,7 @@ async function getLastCommitsForTree(repo, options, hooks) {
       );
       for (const name of remaining) {
         if (childByName.get(name) !== parentChildByName.get(name)) {
-          result[name] = toLastCommitInfo(commit);
+          result[name] = summarizeCommit(commit);
         }
       }
       for (const name of Object.keys(result)) {
@@ -934,7 +828,6 @@ export {
   getCommitLog,
   getDiffBetweenRefs,
   getFileContent,
-  getFileFromRef,
   getFileHistory,
   getLastCommitsForTree,
   getTreeFromRef,
@@ -943,6 +836,7 @@ export {
   resolveCommit,
   resolveLooseRefFast,
   resultKeyPrefixes,
+  summarizeCommit,
   upsertTree,
   withPackedWrites,
   writeCommitToBare