fyn 2.1.2 → 2.1.3

package/dist/fyn.js

@@ -3907,7 +3907,13 @@ class Fyn {
     } else {
       centralDir = this._fynpo.config.centralDir;
       if (!centralDir) {
-        centralDir = Path.join(this._fynpo.dir, ".fynpo", "_store");
+        const storeBaseDir = await fynTil.resolveGitMainWorktreeDir(this._fynpo.dir);
+        if (storeBaseDir !== this._fynpo.dir) {
+          logger.info(
+            `fynpo monorepo is a git worktree; sharing central store from main worktree ${storeBaseDir}`
+          );
+        }
+        centralDir = Path.join(storeBaseDir, ".fynpo", "_store");
       }
       logger.info(`Enabling central store by fynpo monorepo using dir ${centralDir}`);
     }
@@ -5636,6 +5642,7 @@ const Fs = __webpack_require__("./lib/util/file-ops.ts");
 const _ = __webpack_require__("./node_modules/.f/_/lodash/4.17.21/lodash/lodash.min.js");
 const chalk = __webpack_require__("./node_modules/.f/_/chalk/4.1.2/chalk/source/index.js");
 const simpleSemverCompare = (__webpack_require__("./lib/util/semver.ts").simpleCompare);
+const Semver = __webpack_require__("./node_modules/.f/_/semver/7.8.0/semver/index.js");
 const Yaml = __webpack_require__("./node_modules/.f/_/yamljs/0.3.0/yamljs/lib/Yaml.js");
 const sortObjKeys = __webpack_require__("./lib/util/sort-obj-keys.ts");
 const {
@@ -5830,7 +5837,10 @@ class PkgDepLocker {
       const versions = {};
       _.each(sorted, (version) => {
         const vpkg = locked[version];
-        if (!_.isEmpty(vpkg) && vpkg._valid !== false) {
+        const isLocalVpkg = vpkg && vpkg.$ === "local";
+        const badVersionKey = !isLocalVpkg && !Semver.valid(version);
+        const badDeps = vpkg && vpkg.dependencies && !this._depsResolvable(vpkg.dependencies);
+        if (!_.isEmpty(vpkg) && vpkg._valid !== false && !badVersionKey && !badDeps) {
           if (vpkg.$ === "local") {
             vpkg.local = true;
             vpkg.dist = {
@@ -5853,6 +5863,15 @@ class PkgDepLocker {
           }
           versions[version] = vpkg;
         } else {
+          if (badVersionKey) {
+            logger.error(
+              `lockfile entry for ${item.name} has invalid version key "${version}" - ignoring and re-resolving from registry`
+            );
+          } else if (badDeps) {
+            logger.error(
+              `lockfile entry ${item.name}@${version} has dependencies not satisfiable within the lock (corrupt lock) - ignoring and re-resolving from registry`
+            );
+          }
           valid = false;
         }
       });
@@ -5874,6 +5893,37 @@ class PkgDepLocker {
     }
     return valid && locked;
   }
+  //
+  // Check that every recorded dependency pin can be resolved within the lock data.
+  // A healthy fyn lock is self-contained: every locked package's dependency specs are
+  // satisfied by some version that also has a lock entry. A pin that points at a version
+  // absent from the lock signals corruption (e.g. a version block's deps got swapped
+  // during a rebase/merge), so the entry must be dropped and re-resolved.
+  //
+  _depsResolvable(deps) {
+    for (const depName in deps) {
+      if (!this._isDepResolvable(depName, deps[depName])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  _isDepResolvable(depName, spec) {
+    const depLock = this._lockData[depName];
+    if (!depLock) return true;
+    let versions;
+    let rangeMap;
+    if (depLock.versions) {
+      versions = Object.keys(depLock.versions);
+      rangeMap = depLock[LOCK_RSEMVERS] || {};
+    } else {
+      versions = Object.keys(depLock).filter((k) => !k.startsWith("_"));
+      rangeMap = depLock._ || {};
+    }
+    if (Object.prototype.hasOwnProperty.call(rangeMap, spec)) return true;
+    if (!Semver.validRange(spec)) return true;
+    return versions.some((v) => Semver.valid(v) && Semver.satisfies(v, spec));
+  }
   /**
    * Set the package.json's dependencies items and check if they changed from
    * lock data.
@@ -6044,6 +6094,14 @@ class PkgDepLocker {
       if (!Path.isAbsolute(filename)) filename = Path.resolve(filename);
       const data = (await Fs.readFile(filename)).toString();
       this._shaSum = this.shasum(data);
+      if (/^(<<<<<<<|=======|>>>>>>>)/m.test(data)) {
+        logger.error(
+          `lockfile ${filename} has git conflict markers - ignoring it and re-resolving from registry`
+        );
+        this._shaSum = Date.now();
+        this._lockData = {};
+        return false;
+      }
       this._lockData = Yaml.parse(data);
       const basedir = Path.dirname(filename);
       this._fullLocalPath(basedir);
@@ -9402,6 +9460,67 @@ const fyntil = {
       return fyntil.fynpoConfig = {};
     }
   },
+  /**
+   * Detect if `dir` lives inside a git linked worktree and, if so, resolve the
+   * equivalent directory in the repo's main worktree.
+   *
+   * fynpo uses `<monorepo>/.fynpo/_store` as the central package store. When the
+   * monorepo is checked out as a git linked worktree, each worktree would
+   * otherwise get its own `.fynpo` store - wasteful and slow. Pointing them at
+   * the main worktree's store lets all worktrees share one central store.
+   *
+   * @param dir directory to resolve (typically the fynpo monorepo top dir)
+   * @returns the equivalent directory in the main worktree, or `dir` unchanged
+   *          when it's not in a git repo or already in the main worktree.
+   */
+  async resolveGitMainWorktreeDir(dir) {
+    const startDir = Path.resolve(dir);
+    let treeTop = startDir;
+    let gitPath;
+    let gitStat;
+    for (; ; ) {
+      try {
+        const p = Path.join(treeTop, ".git");
+        gitStat = await Fs.stat(p);
+        gitPath = p;
+        break;
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+          throw err;
+        }
+      }
+      const parent = Path.dirname(treeTop);
+      if (parent === treeTop) {
+        break;
+      }
+      treeTop = parent;
+    }
+    if (!gitPath || gitStat.isDirectory()) {
+      return dir;
+    }
+    try {
+      const gitFile = await Fs.readFile(gitPath, "utf8");
+      const m = gitFile.match(/^gitdir:\s*(.+)$/m);
+      if (!m) {
+        return dir;
+      }
+      let worktreeGitDir = m[1].trim();
+      if (!Path.isAbsolute(worktreeGitDir)) {
+        worktreeGitDir = Path.resolve(treeTop, worktreeGitDir);
+      }
+      const commondir = (await Fs.readFile(Path.join(worktreeGitDir, "commondir"), "utf8")).trim();
+      const commonGitDir = Path.isAbsolute(commondir) ? commondir : Path.resolve(worktreeGitDir, commondir);
+      if (Path.basename(commonGitDir) !== ".git") {
+        return dir;
+      }
+      const mainTreeTop = Path.dirname(commonGitDir);
+      const rel = Path.relative(treeTop, startDir);
+      return Path.join(mainTreeTop, rel);
+    } catch (err) {
+      logger.debug(`resolveGitMainWorktreeDir failed for ${dir}: ${err.message}`);
+      return dir;
+    }
+  },
   removeAuthInfo(rcObj) {
     const rmObj = {};
     for (const key in rcObj) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fyn",
-  "version": "2.1.2",
+  "version": "2.1.3",
   "description": "fyn is the NPM for fynpo -- a zero setup monorepo tool",
   "main": "./bin/fyn.js",
   "homepage": "https://jchip.github.io/fynpo/",