isomorphic-git 1.41.1 → 1.41.2

package/index.cjs

@@ -4,8 +4,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
 
-var AsyncLock = _interopDefault(require('async-lock'));
 var Hash = _interopDefault(require('sha.js/sha1.js'));
+var AsyncLock = _interopDefault(require('async-lock'));
 var crc32 = _interopDefault(require('crc-32'));
 var pako = _interopDefault(require('pako'));
 var crypto$1 = require('crypto');
@@ -964,10 +964,43 @@ function compareStats(entry, stats, filemode = true, trustino = true) {
   return staleness
 }
 
-// import Lock from '../utils.js'
+// A single process-wide lock shared by everything that serializes file
+// operations (the index, refs, the shallow file, blob writes). It is keyed by
+// path, so unrelated resources never contend. Centralizing it here also means
+// there is exactly one place to reset it (see `_resetLock`).
+//
+// Created lazily (not at module load) so this module has no top-level side
+// effect and stays tree-shakeable.
+let lock;
+
+function getLock() {
+  if (lock === undefined) lock = new AsyncLock({ maxPending: Infinity });
+  return lock
+}
+
+/**
+ * Run `callback` while holding the shared lock for `key`, then release it.
+ *
+ * @template T
+ * @param {string | string[]} key - Resource key(s) to lock (usually a filepath).
+ * @param {() => (Promise<T> | T)} callback
+ * @returns {Promise<T>}
+ */
+function acquireLock(key, callback) {
+  return getLock().acquire(key, callback)
+}
 
-// const lm = new LockManager()
-let lock = null;
+/**
+ * Discard the shared lock so the next `acquireLock` starts a fresh one. Intended
+ * for test harnesses that run many independent scenarios inside one long-lived
+ * module instance: if a scenario leaves an operation stalled (e.g. a filesystem
+ * that hangs), its still-held lock would otherwise block every later scenario
+ * that touches the same path. Resetting abandons that stalled queue so the next
+ * scenario starts clean. It is a no-op for normal library use.
+ */
+function _resetLock() {
+  lock = undefined;
+}
 
 const IndexCache = Symbol('IndexCache');
 
@@ -1038,10 +1071,9 @@ class GitIndexManager {
     }
 
     const filepath = `${gitdir}/index`;
-    if (lock === null) lock = new AsyncLock({ maxPending: Infinity });
     let result;
     let unmergedPaths = [];
-    await lock.acquire(filepath, async () => {
+    await acquireLock(filepath, async () => {
       // Acquire a file lock while we're reading the index
       // to make sure other processes aren't writing to it
       // simultaneously, which could result in a corrupted index.
@@ -2031,13 +2063,6 @@ function assertWritableRef(ref) {
   }
 }
 
-let lock$1;
-
-async function acquireLock(ref, callback) {
-  if (lock$1 === undefined) lock$1 = new AsyncLock();
-  return lock$1.acquire(ref, callback)
-}
-
 /**
  * A class for managing Git references, including reading, writing, deleting, and resolving refs.
  */
@@ -8348,12 +8373,6 @@ const _TreeMap = {
   workdir: WORKDIR,
 };
 
-let lock$2;
-async function acquireLock$1(ref, callback) {
-  if (lock$2 === undefined) lock$2 = new AsyncLock();
-  return lock$2.acquire(ref, callback)
-}
-
 // make sure filepath, blob type and blob object (from loose objects) plus oid are in sync and valid
 async function checkAndWriteBlob(fs, gitdir, dir, filepath, oid = null) {
   const currentFilepath = join(dir, filepath);
@@ -8370,7 +8389,7 @@ async function checkAndWriteBlob(fs, gitdir, dir, filepath, oid = null) {
     : undefined;
   let retOid = objContent ? oid : undefined;
   if (!objContent) {
-    await acquireLock$1(currentFilepath, async () => {
+    await acquireLock(currentFilepath, async () => {
       const object = stats.isSymbolicLink()
         ? await fs.readlink(currentFilepath).then(posixifyPathBuffer)
         : await fs.read(currentFilepath);
@@ -8585,7 +8604,7 @@ async function applyTreeChanges({
   });
 
   // apply the changes to work dir
-  await acquireLock$1(gitdir, async () => {
+  await acquireLock(gitdir, async () => {
     for (const op of ops) {
       const currentFilepath = join(dir, op.filepath);
       switch (op.method) {
@@ -9539,8 +9558,6 @@ function parseRemoteUrl({ url }) {
   }
 }
 
-let lock$3 = null;
-
 class GitShallowManager {
   /**
    * Reads the `shallow` file in the Git repository and returns a set of object IDs (OIDs).
@@ -9551,10 +9568,9 @@ class GitShallowManager {
    * @returns {Promise<Set<string>>} - A set of shallow object IDs.
    */
   static async read({ fs, gitdir }) {
-    if (lock$3 === null) lock$3 = new AsyncLock();
     const filepath = join(gitdir, 'shallow');
     const oids = new Set();
-    await lock$3.acquire(filepath, async function () {
+    await acquireLock(filepath, async function () {
       const text = await fs.read(filepath, { encoding: 'utf8' });
       if (text === null) return oids // no file
       if (text.trim() === '') return oids // empty file
@@ -9577,18 +9593,17 @@ class GitShallowManager {
    * @returns {Promise<void>}
    */
   static async write({ fs, gitdir, oids }) {
-    if (lock$3 === null) lock$3 = new AsyncLock();
     const filepath = join(gitdir, 'shallow');
     if (oids.size > 0) {
       const text = [...oids].join('\n') + '\n';
-      await lock$3.acquire(filepath, async function () {
+      await acquireLock(filepath, async function () {
         await fs.write(filepath, text, {
           encoding: 'utf8',
         });
       });
     } else {
       // No shallows
-      await lock$3.acquire(filepath, async function () {
+      await acquireLock(filepath, async function () {
         await fs.rm(filepath);
       });
     }
@@ -9685,8 +9700,8 @@ function filterCapabilities(server, client) {
 
 const pkg = {
   name: 'isomorphic-git',
-  version: '1.41.1',
-  agent: 'git/isomorphic-git@1.41.1',
+  version: '1.41.2',
+  agent: 'git/isomorphic-git@1.41.2',
 };
 
 class FIFO {
@@ -16043,7 +16058,7 @@ class GitStashManager {
     );
     const filepath = this.refLogsStashPath;
 
-    await acquireLock$1(filepath, async () => {
+    await acquireLock(filepath, async () => {
       const appendTo = (await this.fs.exists(filepath))
         ? await this.fs.read(filepath, 'utf8')
         : '';
@@ -16237,7 +16252,7 @@ async function _stashDrop({ fs, dir, gitdir, refIdx = 0 }) {
   }
   // remove stash ref first
   const stashRefPath = stashMgr.refStashPath;
-  await acquireLock$1(stashRefPath, async () => {
+  await acquireLock(stashRefPath, async () => {
     if (await fs.exists(stashRefPath)) {
       await fs.rm(stashRefPath);
     }
@@ -16253,7 +16268,7 @@ async function _stashDrop({ fs, dir, gitdir, refIdx = 0 }) {
   reflogEntries.splice(refIdx, 1);
 
   const stashReflogPath = stashMgr.refLogsStashPath;
-  await acquireLock$1(stashReflogPath, async () => {
+  await acquireLock(stashReflogPath, async () => {
     if (reflogEntries.length) {
       await fs.write(
         stashReflogPath,
@@ -16279,7 +16294,7 @@ async function _stashClear({ fs, dir, gitdir }) {
   const stashMgr = new GitStashManager({ fs, dir, gitdir });
   const stashRefPath = [stashMgr.refStashPath, stashMgr.refLogsStashPath];
 
-  await acquireLock$1(stashRefPath, async () => {
+  await acquireLock(stashRefPath, async () => {
     await Promise.all(
       stashRefPath.map(async path => {
         if (await fs.exists(path)) {

package/index.js

@@ -1,5 +1,5 @@
-import AsyncLock from 'async-lock';
 import Hash from 'sha.js/sha1.js';
+import AsyncLock from 'async-lock';
 import crc32 from 'crc-32';
 import pako from 'pako';
 import pify from 'pify';
@@ -957,10 +957,43 @@ function compareStats(entry, stats, filemode = true, trustino = true) {
   return staleness
 }
 
-// import Lock from '../utils.js'
+// A single process-wide lock shared by everything that serializes file
+// operations (the index, refs, the shallow file, blob writes). It is keyed by
+// path, so unrelated resources never contend. Centralizing it here also means
+// there is exactly one place to reset it (see `_resetLock`).
+//
+// Created lazily (not at module load) so this module has no top-level side
+// effect and stays tree-shakeable.
+let lock;
+
+function getLock() {
+  if (lock === undefined) lock = new AsyncLock({ maxPending: Infinity });
+  return lock
+}
+
+/**
+ * Run `callback` while holding the shared lock for `key`, then release it.
+ *
+ * @template T
+ * @param {string | string[]} key - Resource key(s) to lock (usually a filepath).
+ * @param {() => (Promise<T> | T)} callback
+ * @returns {Promise<T>}
+ */
+function acquireLock(key, callback) {
+  return getLock().acquire(key, callback)
+}
 
-// const lm = new LockManager()
-let lock = null;
+/**
+ * Discard the shared lock so the next `acquireLock` starts a fresh one. Intended
+ * for test harnesses that run many independent scenarios inside one long-lived
+ * module instance: if a scenario leaves an operation stalled (e.g. a filesystem
+ * that hangs), its still-held lock would otherwise block every later scenario
+ * that touches the same path. Resetting abandons that stalled queue so the next
+ * scenario starts clean. It is a no-op for normal library use.
+ */
+function _resetLock() {
+  lock = undefined;
+}
 
 const IndexCache = Symbol('IndexCache');
 
@@ -1031,10 +1064,9 @@ class GitIndexManager {
     }
 
     const filepath = `${gitdir}/index`;
-    if (lock === null) lock = new AsyncLock({ maxPending: Infinity });
     let result;
     let unmergedPaths = [];
-    await lock.acquire(filepath, async () => {
+    await acquireLock(filepath, async () => {
       // Acquire a file lock while we're reading the index
       // to make sure other processes aren't writing to it
       // simultaneously, which could result in a corrupted index.
@@ -2024,13 +2056,6 @@ function assertWritableRef(ref) {
   }
 }
 
-let lock$1;
-
-async function acquireLock(ref, callback) {
-  if (lock$1 === undefined) lock$1 = new AsyncLock();
-  return lock$1.acquire(ref, callback)
-}
-
 /**
  * A class for managing Git references, including reading, writing, deleting, and resolving refs.
  */
@@ -8335,12 +8360,6 @@ const _TreeMap = {
   workdir: WORKDIR,
 };
 
-let lock$2;
-async function acquireLock$1(ref, callback) {
-  if (lock$2 === undefined) lock$2 = new AsyncLock();
-  return lock$2.acquire(ref, callback)
-}
-
 // make sure filepath, blob type and blob object (from loose objects) plus oid are in sync and valid
 async function checkAndWriteBlob(fs, gitdir, dir, filepath, oid = null) {
   const currentFilepath = join(dir, filepath);
@@ -8357,7 +8376,7 @@ async function checkAndWriteBlob(fs, gitdir, dir, filepath, oid = null) {
     : undefined;
   let retOid = objContent ? oid : undefined;
   if (!objContent) {
-    await acquireLock$1(currentFilepath, async () => {
+    await acquireLock(currentFilepath, async () => {
       const object = stats.isSymbolicLink()
         ? await fs.readlink(currentFilepath).then(posixifyPathBuffer)
         : await fs.read(currentFilepath);
@@ -8572,7 +8591,7 @@ async function applyTreeChanges({
   });
 
   // apply the changes to work dir
-  await acquireLock$1(gitdir, async () => {
+  await acquireLock(gitdir, async () => {
     for (const op of ops) {
       const currentFilepath = join(dir, op.filepath);
       switch (op.method) {
@@ -9526,8 +9545,6 @@ function parseRemoteUrl({ url }) {
   }
 }
 
-let lock$3 = null;
-
 class GitShallowManager {
   /**
    * Reads the `shallow` file in the Git repository and returns a set of object IDs (OIDs).
@@ -9538,10 +9555,9 @@ class GitShallowManager {
    * @returns {Promise<Set<string>>} - A set of shallow object IDs.
    */
   static async read({ fs, gitdir }) {
-    if (lock$3 === null) lock$3 = new AsyncLock();
     const filepath = join(gitdir, 'shallow');
     const oids = new Set();
-    await lock$3.acquire(filepath, async function () {
+    await acquireLock(filepath, async function () {
       const text = await fs.read(filepath, { encoding: 'utf8' });
       if (text === null) return oids // no file
       if (text.trim() === '') return oids // empty file
@@ -9564,18 +9580,17 @@ class GitShallowManager {
    * @returns {Promise<void>}
    */
   static async write({ fs, gitdir, oids }) {
-    if (lock$3 === null) lock$3 = new AsyncLock();
     const filepath = join(gitdir, 'shallow');
     if (oids.size > 0) {
       const text = [...oids].join('\n') + '\n';
-      await lock$3.acquire(filepath, async function () {
+      await acquireLock(filepath, async function () {
         await fs.write(filepath, text, {
           encoding: 'utf8',
         });
       });
     } else {
       // No shallows
-      await lock$3.acquire(filepath, async function () {
+      await acquireLock(filepath, async function () {
         await fs.rm(filepath);
       });
     }
@@ -9672,8 +9687,8 @@ function filterCapabilities(server, client) {
 
 const pkg = {
   name: 'isomorphic-git',
-  version: '1.41.1',
-  agent: 'git/isomorphic-git@1.41.1',
+  version: '1.41.2',
+  agent: 'git/isomorphic-git@1.41.2',
 };
 
 class FIFO {
@@ -16030,7 +16045,7 @@ class GitStashManager {
     );
     const filepath = this.refLogsStashPath;
 
-    await acquireLock$1(filepath, async () => {
+    await acquireLock(filepath, async () => {
       const appendTo = (await this.fs.exists(filepath))
         ? await this.fs.read(filepath, 'utf8')
         : '';
@@ -16224,7 +16239,7 @@ async function _stashDrop({ fs, dir, gitdir, refIdx = 0 }) {
   }
   // remove stash ref first
   const stashRefPath = stashMgr.refStashPath;
-  await acquireLock$1(stashRefPath, async () => {
+  await acquireLock(stashRefPath, async () => {
     if (await fs.exists(stashRefPath)) {
       await fs.rm(stashRefPath);
     }
@@ -16240,7 +16255,7 @@ async function _stashDrop({ fs, dir, gitdir, refIdx = 0 }) {
   reflogEntries.splice(refIdx, 1);
 
   const stashReflogPath = stashMgr.refLogsStashPath;
-  await acquireLock$1(stashReflogPath, async () => {
+  await acquireLock(stashReflogPath, async () => {
     if (reflogEntries.length) {
       await fs.write(
         stashReflogPath,
@@ -16266,7 +16281,7 @@ async function _stashClear({ fs, dir, gitdir }) {
   const stashMgr = new GitStashManager({ fs, dir, gitdir });
   const stashRefPath = [stashMgr.refStashPath, stashMgr.refLogsStashPath];
 
-  await acquireLock$1(stashRefPath, async () => {
+  await acquireLock(stashRefPath, async () => {
     await Promise.all(
       stashRefPath.map(async path => {
         if (await fs.exists(path)) {