git-fs-s3 0.13.0 → 0.15.0

package/dist/ops.js

@@ -1,31 +1,46 @@
 import {
   getObjectSize,
   parseLooseObjectPath
-} from "./chunk-G636FB7W.js";
+} from "./chunk-T5M5EYCZ.js";
 import {
+  HISTORY_WALK_DEPTH,
   assertBranchExists,
   assertSafeBranchName,
   createBranchFrom,
   createSemaphore,
   deleteBranchByName,
+  deleteFromTree,
   encodePack,
+  findTreeEntry,
+  getBlob,
+  getCommit,
+  getCommitHistory,
+  getCommitLog,
+  getFileContent,
+  getTreeFromRef,
   listBranches,
+  listTags,
+  listTreeEntries,
+  peelToCommit,
+  resolveCommit,
   resolveLooseRefFast,
-  storePack
-} from "./chunk-QH3HS7VI.js";
+  resultKeyPrefixes,
+  runStep,
+  storePack,
+  summarizeCommit,
+  upsertTree
+} from "./chunk-IAKZRWBZ.js";
 import {
   GitInvalidRequestError,
-  GitObjectNotFoundError,
   GitPathNotFoundError,
-  GitRefNotFoundError,
   inflate,
   isSafeTreePath,
   qualifyBranchRef,
   readBlobContent
-} from "./chunk-HO6OPXUS.js";
+} from "./chunk-OKBQISUC.js";
 
 // src/ops/commit.ts
-import git2 from "isomorphic-git";
+import git from "isomorphic-git";
 
 // src/ops/packed-writes.ts
 var OBJECT_TYPES = /* @__PURE__ */ new Set(["commit", "tree", "blob", "tag"]);
@@ -109,120 +124,6 @@ async function withPackedWrites(repo, fn) {
   return result;
 }
 
-// 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/commit.ts
 function authorNow(name, email) {
   return {
@@ -240,11 +141,11 @@ async function writeCommit(repo, options) {
   let parentOid;
   let parentTreeOid;
   try {
-    parentOid = await git2.resolveRef({
+    parentOid = await git.resolveRef({
       ...repo,
       ref: `refs/heads/${options.branch}`
     });
-    const { commit } = await git2.readCommit({ ...repo, oid: parentOid });
+    const { commit } = await git.readCommit({ ...repo, oid: parentOid });
     parentTreeOid = commit.tree;
   } catch (err) {
     if (err?.code !== "NotFoundError") {
@@ -252,7 +153,7 @@ async function writeCommit(repo, options) {
     }
   }
   const treeOid = await options.buildTree(parentTreeOid, repo);
-  const commitOid = await git2.writeCommit({
+  const commitOid = await git.writeCommit({
     ...repo,
     commit: {
       message: options.message,
@@ -262,7 +163,7 @@ async function writeCommit(repo, options) {
       committer: options.author
     }
   });
-  await git2.writeRef({
+  await git.writeRef({
     ...repo,
     ref: `refs/heads/${options.branch}`,
     value: commitOid,
@@ -293,7 +194,7 @@ async 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 git2.writeBlob({ ...writeRepo, blob: content });
+          const oid = await git.writeBlob({ ...writeRepo, blob: content });
           blobs.set(file.path, oid);
         })
       );
@@ -320,180 +221,7 @@ async function deleteFileFromBare(repo, options) {
 
 // src/ops/diff.ts
 import { createTwoFilesPatch } from "diff";
-import git4 from "isomorphic-git";
-
-// src/ops/history.ts
-import git3 from "isomorphic-git";
-
-// 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
-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) {
-  try {
-    return await git3.resolveRef({ ...repo, ref: qualifyBranchRef(ref) });
-  } catch (err) {
-    if (isNotFound(err))
-      throw new GitRefNotFoundError(`Ref ${ref} does not exist`);
-    throw err;
-  }
-}
-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 };
-}
-async function getBlob(repo, sha) {
-  const { blob } = await wrapMissingObject(
-    git3.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(
-    git3.readBlob({ ...repo, oid: entry.oid }),
-    context
-  );
-  return blob;
-}
-async function getCommit(repo, sha) {
-  const result = await wrapMissingObject(
-    git3.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}`,
-      () => git3.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/diff.ts
+import git2 from "isomorphic-git";
 var MAX_DIFF_TEXT_BYTES = 1024 * 1024;
 var MAX_CONCURRENT_READS = 16;
 function countContentLines(content) {
@@ -570,12 +298,12 @@ async function diffTrees(repo, oldTreeOid, newTreeOid) {
   const readContent = async (side) => {
     if (!side) return null;
     const { blob } = await reads.run(
-      () => git4.readBlob({ ...repo, oid: side.oid })
+      () => git2.readBlob({ ...repo, oid: side.oid })
     );
     return readBlobContent(blob);
   };
-  const trees = oldTreeOid ? [git4.TREE({ ref: oldTreeOid }), git4.TREE({ ref: newTreeOid })] : [git4.TREE({ ref: newTreeOid })];
-  const changes = await git4.walk({
+  const trees = oldTreeOid ? [git2.TREE({ ref: oldTreeOid }), git2.TREE({ ref: newTreeOid })] : [git2.TREE({ ref: newTreeOid })];
+  const changes = await git2.walk({
     ...repo,
     trees,
     map: async (filepath, entries) => {
@@ -645,7 +373,7 @@ async function getDiffBetweenRefs(repo, baseRef, compareRef) {
     resolveCommit(repo, baseRef),
     resolveCommit(repo, compareRef)
   ]);
-  const [mergeBase] = await git4.findMergeBase({
+  const [mergeBase] = await git2.findMergeBase({
     ...repo,
     oids: [base.oid, compare.oid]
   });
@@ -823,16 +551,16 @@ async function getLastCommitsForTree(repo, options, hooks) {
 }
 
 // src/ops/merge.ts
-import git5 from "isomorphic-git";
+import git3 from "isomorphic-git";
 async function analyzeMerge(repo, sourceBranch, targetBranch) {
   assertSafeBranchName(sourceBranch);
   assertSafeBranchName(targetBranch);
   try {
     const [sourceOid, targetOid] = await Promise.all([
-      git5.resolveRef({ ...repo, ref: qualifyBranchRef(sourceBranch) }),
-      git5.resolveRef({ ...repo, ref: qualifyBranchRef(targetBranch) })
+      git3.resolveRef({ ...repo, ref: qualifyBranchRef(sourceBranch) }),
+      git3.resolveRef({ ...repo, ref: qualifyBranchRef(targetBranch) })
     ]);
-    const isDescendant = sourceOid === targetOid || await git5.isDescendent({
+    const isDescendant = sourceOid === targetOid || await git3.isDescendent({
       ...repo,
       oid: sourceOid,
       ancestor: targetOid
@@ -859,19 +587,19 @@ async function fastForwardMerge(repo, sourceBranch, targetBranch) {
   assertSafeBranchName(sourceBranch);
   assertSafeBranchName(targetBranch);
   const [sourceOid, targetOid] = await Promise.all([
-    git5.resolveRef({ ...repo, ref: `refs/heads/${sourceBranch}` }),
-    git5.resolveRef({ ...repo, ref: `refs/heads/${targetBranch}` })
+    git3.resolveRef({ ...repo, ref: `refs/heads/${sourceBranch}` }),
+    git3.resolveRef({ ...repo, ref: `refs/heads/${targetBranch}` })
   ]);
-  if (sourceOid === targetOid || await git5.isDescendent({ ...repo, oid: targetOid, ancestor: sourceOid })) {
+  if (sourceOid === targetOid || await git3.isDescendent({ ...repo, oid: targetOid, ancestor: sourceOid })) {
     return { success: true, commitSha: targetOid };
   }
-  const isFF = await git5.isDescendent({
+  const isFF = await git3.isDescendent({
     ...repo,
     oid: sourceOid,
     ancestor: targetOid
   });
   if (!isFF) return null;
-  await git5.writeRef({
+  await git3.writeRef({
     ...repo,
     ref: `refs/heads/${targetBranch}`,
     value: sourceOid,
@@ -997,8 +725,10 @@ export {
   getSubmodules,
   getTreeFromRef,
   listBranches,
+  listTags,
   listTreeEntries,
   parseGitmodules,
+  peelToCommit,
   resolveCommit,
   resolveLooseRefFast,
   resultKeyPrefixes,