git-fs-s3 0.3.6 → 0.3.8

package/dist/ops.d.ts

@@ -14,6 +14,18 @@ interface Branch {
  * actually called, not just at an API boundary far above.
  */
 declare function assertSafeBranchName(name: string): void;
+/**
+ * Resolve a fully-qualified ref's oid with one read instead of isomorphic-
+ * git's own `resolveRef`, which does a stat *then* a read for a loose ref
+ * (two round trips against object storage) — wasteful specifically here,
+ * where the caller already knows the ref exists (it came from a directory
+ * listing moments earlier). Reads the loose file directly and falls back to
+ * `git.resolveRef` only when that doesn't pan out (packed-refs, or anything
+ * else the plain-loose-file assumption doesn't cover), so correctness for
+ * those cases is unchanged — this only removes the redundant round trip on
+ * the common path.
+ */
+declare function resolveLooseRefFast(repo: Repo, ref: string): Promise<string>;
 /** All branches with their tip commits; [] for an empty repository. */
 declare function listBranches(repo: Repo): Promise<Branch[]>;
 /** Create `name` pointing at the tip of `startPoint` (no checkout). */
@@ -287,4 +299,4 @@ declare function fastForwardMerge(repo: Repo, sourceBranch: string, targetBranch
     commitSha: string;
 } | null>;
 
-export { BANNER_WALK_DEPTH, type Branch, type CommitAuthor, type CommitInfo, type CommitLogOptions, type DiffFile, type DiffResult, type FileHistoryEntry, type FileHistoryResult, HISTORY_WALK_DEPTH, type LastCommitInfo, type MergeAnalysis, OpsHooks, Repo, type TreeEntry, analyzeMerge, assertBranchExists, assertSafeBranchName, authorNow, commitFilesToBare, createBranchFrom, deleteBranchByName, deleteFileFromBare, deleteFromTree, fastForwardMerge, findTreeEntry, getBlob, getCommit, getCommitDiff, getCommitHistory, getCommitLog, getDiffBetweenRefs, getFileContent, getFileFromRef, getFileHistory, getLastCommitsForTree, getTreeFromRef, listBranches, listTreeEntries, resolveCommit, upsertTree, writeCommitToBare };
+export { BANNER_WALK_DEPTH, type Branch, type CommitAuthor, type CommitInfo, type CommitLogOptions, type DiffFile, type DiffResult, type FileHistoryEntry, type FileHistoryResult, HISTORY_WALK_DEPTH, type LastCommitInfo, type MergeAnalysis, OpsHooks, Repo, type TreeEntry, analyzeMerge, assertBranchExists, assertSafeBranchName, authorNow, commitFilesToBare, createBranchFrom, deleteBranchByName, deleteFileFromBare, deleteFromTree, fastForwardMerge, findTreeEntry, getBlob, getCommit, getCommitDiff, getCommitHistory, getCommitLog, getDiffBetweenRefs, getFileContent, getFileFromRef, getFileHistory, getLastCommitsForTree, getTreeFromRef, listBranches, listTreeEntries, resolveCommit, resolveLooseRefFast, upsertTree, writeCommitToBare };

package/dist/ops.js

@@ -1,68 +1,29 @@
 import {
-  GitInvalidRequestError,
-  GitObjectNotFoundError,
-  GitPathNotFoundError
-} from "./chunk-T5NHPY7U.js";
+  assertBranchExists,
+  assertSafeBranchName,
+  createBranchFrom,
+  deleteBranchByName,
+  listBranches,
+  resolveLooseRefFast
+} from "./chunk-H7IGQRIA.js";
 import {
+  GitObjectNotFoundError,
+  GitPathNotFoundError,
   decodeUtf8,
   hasNullByte,
-  isSafeBranchName,
   qualifyBranchRef,
   readBlobContent,
   toBase64
-} from "./chunk-RUE2NR43.js";
-
-// src/ops/branch.ts
-import git from "isomorphic-git";
-function assertSafeBranchName(name) {
-  if (!isSafeBranchName(name)) {
-    throw new GitInvalidRequestError(`Invalid branch name: ${name}`);
-  }
-}
-async function listBranches(repo) {
-  try {
-    const [branches, currentBranch] = await Promise.all([
-      git.listBranches(repo),
-      git.currentBranch({ ...repo, fullname: false }).catch(() => null)
-    ]);
-    return Promise.all(
-      branches.map(async (branch) => ({
-        name: branch,
-        commit: await git.resolveRef({ ...repo, ref: `refs/heads/${branch}` }),
-        isDefault: branch === currentBranch
-      }))
-    );
-  } catch (err) {
-    if (err.code === "NotFoundError") return [];
-    throw err;
-  }
-}
-async function createBranchFrom(repo, name, startPoint = "main") {
-  assertSafeBranchName(name);
-  assertSafeBranchName(startPoint);
-  const object = await git.resolveRef({
-    ...repo,
-    ref: `refs/heads/${startPoint}`
-  });
-  await git.branch({ ...repo, ref: name, checkout: false, object });
-}
-async function deleteBranchByName(repo, name) {
-  assertSafeBranchName(name);
-  await git.deleteBranch({ ...repo, ref: name });
-}
-async function assertBranchExists(repo, name) {
-  assertSafeBranchName(name);
-  await git.resolveRef({ ...repo, ref: `refs/heads/${name}` });
-}
+} from "./chunk-YQFNY6PG.js";
 
 // src/ops/commit.ts
-import git3 from "isomorphic-git";
+import git2 from "isomorphic-git";
 
 // src/ops/tree.ts
-import git2 from "isomorphic-git";
+import git from "isomorphic-git";
 var joinPath = (prefix, name) => prefix ? `${prefix.replace(/\/+$/, "")}/${name}` : name;
 async function upsertTree(repo, treeOid, entries) {
-  const existing = treeOid ? (await git2.readTree({ ...repo, oid: treeOid })).tree : [];
+  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();
@@ -96,10 +57,10 @@ async function upsertTree(repo, treeOid, entries) {
   for (const [dir, newOid] of nestedResults) {
     byName.set(dir, { mode: "040000", path: dir, oid: newOid, type: "tree" });
   }
-  return git2.writeTree({ ...repo, tree: Array.from(byName.values()) });
+  return git.writeTree({ ...repo, tree: Array.from(byName.values()) });
 }
 async function deleteFromTree(repo, treeOid, filePath) {
-  const existing = (await git2.readTree({ ...repo, oid: treeOid })).tree;
+  const existing = (await git.readTree({ ...repo, oid: treeOid })).tree;
   const byName = new Map(existing.map((e) => [e.path, e]));
   const slash = filePath.indexOf("/");
   if (slash === -1) {
@@ -113,7 +74,7 @@ async function deleteFromTree(repo, treeOid, filePath) {
       byName.set(dir, { ...entry, oid: newOid });
     }
   }
-  return git2.writeTree({ ...repo, tree: Array.from(byName.values()) });
+  return git.writeTree({ ...repo, tree: Array.from(byName.values()) });
 }
 async function findTreeEntry(repo, rootTreeOid, treePath) {
   if (!treePath) {
@@ -123,7 +84,7 @@ async function findTreeEntry(repo, rootTreeOid, treePath) {
   let currentTreeOid = rootTreeOid;
   let currentPath = "";
   for (const [index, part] of parts.entries()) {
-    const tree = await git2.readTree({ ...repo, oid: currentTreeOid });
+    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;
@@ -141,7 +102,7 @@ async function findTreeEntry(repo, rootTreeOid, treePath) {
   return null;
 }
 async function listTreeEntries(repo, treeOid, prefix = "") {
-  const tree = await git2.readTree({ ...repo, oid: treeOid });
+  const tree = await git.readTree({ ...repo, oid: treeOid });
   return tree.tree.map((entry) => ({
     path: prefix ? joinPath(prefix, entry.path) : entry.path,
     mode: entry.mode,
@@ -164,11 +125,11 @@ async function writeCommitToBare(repo, options) {
   let parentOid;
   let parentTreeOid;
   try {
-    parentOid = await git3.resolveRef({
+    parentOid = await git2.resolveRef({
       ...repo,
       ref: `refs/heads/${options.branch}`
     });
-    const { commit } = await git3.readCommit({ ...repo, oid: parentOid });
+    const { commit } = await git2.readCommit({ ...repo, oid: parentOid });
     parentTreeOid = commit.tree;
   } catch (err) {
     if (err?.code !== "NotFoundError") {
@@ -176,7 +137,7 @@ async function writeCommitToBare(repo, options) {
     }
   }
   const treeOid = await options.buildTree(parentTreeOid);
-  const commitOid = await git3.writeCommit({
+  const commitOid = await git2.writeCommit({
     ...repo,
     commit: {
       message: options.message,
@@ -186,7 +147,7 @@ async function writeCommitToBare(repo, options) {
       committer: options.author
     }
   });
-  await git3.writeRef({
+  await git2.writeRef({
     ...repo,
     ref: `refs/heads/${options.branch}`,
     value: commitOid,
@@ -204,7 +165,7 @@ function commitFilesToBare(repo, options) {
       await Promise.all(
         options.files.map(async (file) => {
           const content = typeof file.content === "string" ? new TextEncoder().encode(file.content) : file.content;
-          const oid = await git3.writeBlob({ ...repo, blob: content });
+          const oid = await git2.writeBlob({ ...repo, blob: content });
           blobs.set(file.path, oid);
         })
       );
@@ -228,10 +189,10 @@ function deleteFileFromBare(repo, options) {
 
 // src/ops/diff.ts
 import { createTwoFilesPatch } from "diff";
-import git5 from "isomorphic-git";
+import git4 from "isomorphic-git";
 
 // src/ops/history.ts
-import git4 from "isomorphic-git";
+import git3 from "isomorphic-git";
 
 // src/ops/types.ts
 var runStep = (hooks, label, fn) => hooks?.step ? hooks.step(label, fn) : fn();
@@ -258,16 +219,16 @@ function wrapMissingObject(promise, context) {
 }
 var isNotFound = (err) => err?.code === "NotFoundError";
 async function resolveCommit(repo, ref) {
-  const oid = await git4.resolveRef({ ...repo, ref: qualifyBranchRef(ref) });
+  const oid = await git3.resolveRef({ ...repo, ref: qualifyBranchRef(ref) });
   const result = await wrapMissingObject(
-    git4.readCommit({ ...repo, oid }),
+    git3.readCommit({ ...repo, oid }),
     `${repo.gitdir} commit ${oid}`
   );
   return { oid, commit: result.commit };
 }
 async function getBlob(repo, sha) {
   const { blob } = await wrapMissingObject(
-    git4.readBlob({ ...repo, oid: sha }),
+    git3.readBlob({ ...repo, oid: sha }),
     `${repo.gitdir} blob ${sha}`
   );
   return blob;
@@ -283,14 +244,14 @@ async function getFileContent(repo, filePath, ref = "main") {
     throw new GitPathNotFoundError(`File not found: ${filePath}`);
   }
   const { blob } = await wrapMissingObject(
-    git4.readBlob({ ...repo, oid: entry.oid }),
+    git3.readBlob({ ...repo, oid: entry.oid }),
     context
   );
   return blob;
 }
 async function getCommit(repo, sha) {
   const result = await wrapMissingObject(
-    git4.readCommit({ ...repo, oid: sha }),
+    git3.readCommit({ ...repo, oid: sha }),
     `${repo.gitdir} commit ${sha}`
   );
   return { oid: result.oid, commit: result.commit, payload: result.payload };
@@ -307,7 +268,7 @@ async function getCommitLog(repo, options = {}, hooks) {
     headSha = options.knownHeadSha;
   } else {
     try {
-      headSha = await git4.resolveRef({ ...repo, ref: qualifyBranchRef(ref) });
+      headSha = await git3.resolveRef({ ...repo, ref: qualifyBranchRef(ref) });
     } catch (err) {
       if (isNotFound(err)) return [];
       throw err;
@@ -331,7 +292,7 @@ async function getCommitLog(repo, options = {}, hooks) {
     runStep(
       hooks,
       `git.log ${ref} depth=${depth}`,
-      () => git4.log({ ...repo, ref: headSha, depth })
+      () => git3.log({ ...repo, ref: headSha, depth })
     ),
     `${repo.gitdir}@${ref} history`
   );
@@ -417,7 +378,7 @@ async function getTreeFromRef(repo, options = {}, hooks) {
 async function getCommitHistory(repo, options, hooks) {
   const limit = options.limit ?? 50;
   const skip = options.skip ?? 0;
-  const headSha = await git4.resolveRef({ ...repo, ref: qualifyBranchRef(options.ref) }).catch(() => null);
+  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);
@@ -474,15 +435,15 @@ function summarizeDiff(files) {
   };
 }
 async function walkTreeDiff(repo, oldOid, newOid) {
-  const changes = await git5.walk({
+  const changes = await git4.walk({
     ...repo,
-    trees: [git5.TREE({ ref: oldOid }), git5.TREE({ ref: newOid })],
+    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 git5.readBlob({ ...repo, oid: oidA2 });
+        const { blob } = await git4.readBlob({ ...repo, oid: oidA2 });
         const before = detectBlobContent(blob);
         return {
           path: filepath,
@@ -502,7 +463,7 @@ async function walkTreeDiff(repo, oldOid, newOid) {
       }
       if (!typeA && typeB) {
         const oidB2 = B ? await B.oid() : "";
-        const { blob } = await git5.readBlob({ ...repo, oid: oidB2 });
+        const { blob } = await git4.readBlob({ ...repo, oid: oidB2 });
         const after = detectBlobContent(blob);
         return {
           path: filepath,
@@ -526,8 +487,8 @@ async function walkTreeDiff(repo, oldOid, newOid) {
       ]);
       if (oidA !== oidB) {
         const [{ blob: blobA }, { blob: blobB }] = await Promise.all([
-          git5.readBlob({ ...repo, oid: oidA }),
-          git5.readBlob({ ...repo, oid: oidB })
+          git4.readBlob({ ...repo, oid: oidA }),
+          git4.readBlob({ ...repo, oid: oidB })
         ]);
         const before = detectBlobContent(blobA);
         const after = detectBlobContent(blobB);
@@ -567,7 +528,7 @@ async function getCommitDiff(repo, commitSha) {
       ];
       while (stack.length) {
         const { treeOid, prefix } = stack.pop();
-        const { tree } = await git5.readTree({ ...repo, oid: treeOid });
+        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") {
@@ -579,7 +540,7 @@ async function getCommitDiff(repo, commitSha) {
       }
       const files2 = await Promise.all(
         entries.map(async ({ path, oid }) => {
-          const { blob } = await git5.readBlob({ ...repo, oid });
+          const { blob } = await git4.readBlob({ ...repo, oid });
           const after = detectBlobContent(blob);
           return {
             path,
@@ -608,8 +569,8 @@ async function getCommitDiff(repo, commitSha) {
 }
 async function getDiffBetweenRefs(repo, baseRef, compareRef) {
   const [baseOid, compareOid] = await Promise.all([
-    git5.resolveRef({ ...repo, ref: qualifyBranchRef(baseRef) }),
-    git5.resolveRef({ ...repo, ref: qualifyBranchRef(compareRef) })
+    git4.resolveRef({ ...repo, ref: qualifyBranchRef(baseRef) }),
+    git4.resolveRef({ ...repo, ref: qualifyBranchRef(compareRef) })
   ]);
   const files = await walkTreeDiff(repo, baseOid, compareOid);
   return summarizeDiff(files);
@@ -801,16 +762,16 @@ async function getLastCommitsForTree(repo, options, hooks) {
 }
 
 // src/ops/merge.ts
-import git6 from "isomorphic-git";
+import git5 from "isomorphic-git";
 async function analyzeMerge(repo, sourceBranch, targetBranch) {
   assertSafeBranchName(sourceBranch);
   assertSafeBranchName(targetBranch);
   try {
     const [sourceOid, targetOid] = await Promise.all([
-      git6.resolveRef({ ...repo, ref: qualifyBranchRef(sourceBranch) }),
-      git6.resolveRef({ ...repo, ref: qualifyBranchRef(targetBranch) })
+      git5.resolveRef({ ...repo, ref: qualifyBranchRef(sourceBranch) }),
+      git5.resolveRef({ ...repo, ref: qualifyBranchRef(targetBranch) })
     ]);
-    const isDescendant = await git6.isDescendent({
+    const isDescendant = await git5.isDescendent({
       ...repo,
       oid: sourceOid,
       ancestor: targetOid
@@ -837,16 +798,16 @@ async function fastForwardMerge(repo, sourceBranch, targetBranch) {
   assertSafeBranchName(sourceBranch);
   assertSafeBranchName(targetBranch);
   const [sourceOid, targetOid] = await Promise.all([
-    git6.resolveRef({ ...repo, ref: `refs/heads/${sourceBranch}` }),
-    git6.resolveRef({ ...repo, ref: `refs/heads/${targetBranch}` })
+    git5.resolveRef({ ...repo, ref: `refs/heads/${sourceBranch}` }),
+    git5.resolveRef({ ...repo, ref: `refs/heads/${targetBranch}` })
   ]);
-  const isFF = await git6.isDescendent({
+  const isFF = await git5.isDescendent({
     ...repo,
     oid: sourceOid,
     ancestor: targetOid
   });
   if (!isFF) return null;
-  await git6.writeRef({
+  await git5.writeRef({
     ...repo,
     ref: `refs/heads/${targetBranch}`,
     value: sourceOid,
@@ -882,6 +843,7 @@ export {
   listBranches,
   listTreeEntries,
   resolveCommit,
+  resolveLooseRefFast,
   resultKeyPrefixes,
   upsertTree,
   writeCommitToBare