@meistrari/mise-en-place 2.15.2 → 2.16.0

package/README.md

@@ -35,6 +35,29 @@ By adding the `postinstall` script to run `mise-en-place postinstall`, every tim
 
 This process will add a leading caret (`^`) to the version range if it is not already present. Which means that it will update to the latest minor and patch versions automatically but never the major version.
 
+### Configuration
+
+You can customize the update behaviour through a `miseEnPlace.updateMeistrariLibraries` object in your `package.json`:
+
+```jsonc
+{
+    "miseEnPlace": {
+        "updateMeistrariLibraries": {
+            "enabled": true, // defaults to true. when false, the update is skipped
+            "exact": false, // defaults to false. when true, versions are written exact, without a range operator (^/~)
+            "packages": { // defaults to {}. unlisted @meistrari/* packages use "minor"
+                "@meistrari/package-1": "skip", // never touch this package's version
+                "@meistrari/package-2": "patch", // pin major and minor, update patch (~)
+                "@meistrari/package-3": "minor", // pin major, update minor and patch (^)
+                "@meistrari/package-4": "major" // update to the latest version, even across a major bump
+            }
+        }
+    }
+}
+```
+
+When `exact` is `true`, every updated package is written as an exact version: each package is still updated as far as its strategy allows, but the resulting version is written without a `^` or `~`.
+
 ## Makefile
 The postinstall script does not create a `Makefile` automatically. To use the shared Makefile commands, create a `Makefile` and include this package's `Makefile`.
 

package/dist/cli/cli.mjs

@@ -40,11 +40,36 @@ function getMeistrariLibs(packageJson) {
   }
   return Array.from(libs).sort();
 }
-const bareSemverPattern = /^\d+\.\d+\.\d+(?:-[0-9a-z-.]+)?(?:\+[0-9a-z-.]+)?$/i;
-function isBareSemver(value) {
-  return bareSemverPattern.test(value);
+const versionWithOperatorPattern = /^[\^~]?(\d+\.\d+\.\d+(?:-[0-9a-z-.]+)?(?:\+[0-9a-z-.]+)?)$/i;
+function setVersionOperator(value, operator) {
+  const match = versionWithOperatorPattern.exec(value);
+  if (!match) {
+    return value;
+  }
+  return `${operator}${match[1]}`;
+}
+function preUpdateOperator(strategy) {
+  if (strategy === "skip") {
+    return null;
+  }
+  if (strategy === "patch") {
+    return "~";
+  }
+  return "^";
 }
-function addCaretToMeistrariDeps(deps) {
+function postUpdateOperator(strategy, exact) {
+  if (strategy === "skip") {
+    return null;
+  }
+  if (exact) {
+    return "";
+  }
+  if (strategy === "patch") {
+    return "~";
+  }
+  return "^";
+}
+function applyMeistrariRanges(deps, operatorFor) {
   if (!deps)
     return deps;
   const result = { ...deps };
@@ -52,10 +77,11 @@ function addCaretToMeistrariDeps(deps) {
     if (!key.startsWith("@meistrari/")) {
       continue;
     }
-    if (!isBareSemver(value)) {
+    const operator = operatorFor(key);
+    if (operator === null) {
       continue;
     }
-    result[key] = `^${value}`;
+    result[key] = setVersionOperator(value, operator);
   }
   return result;
 }
@@ -82,13 +108,6 @@ function detectPackageManager() {
       file: "bun.lockb"
     });
   }
-  const yarnLockExists = existsSync("yarn.lock");
-  if (yarnLockExists) {
-    detected.push({
-      packageManager: "yarn",
-      file: "yarn.lock"
-    });
-  }
   const npmLockExists = existsSync("package-lock.json");
   if (npmLockExists) {
     detected.push({
@@ -122,7 +141,7 @@ function getWorkspaces(packageManager) {
   const rootPackageJson = readPackageJson("package.json");
   return rootPackageJson.workspaces || [];
 }
-function updateLibraries(packageManager, libs, cwd) {
+function updateLibraries(packageManager, libs, { cwd, latest = false } = {}) {
   const libsStr = libs.join(" ");
   const options = {
     stdio: "inherit",
@@ -130,16 +149,16 @@ function updateLibraries(packageManager, libs, cwd) {
   };
   switch (packageManager) {
     case "pnpm":
-      execSync(`pnpm update ${libsStr} --ignore-scripts -r`, options);
+      execSync(`pnpm update ${latest ? "--latest " : ""}${libsStr} --ignore-scripts -r`, options);
       break;
     case "bun":
-      execSync(`bun update --silent ${libsStr} --ignore-scripts`, options);
-      break;
-    case "yarn":
-      execSync(`yarn up ${libsStr} --ignore-scripts -r`, options);
+      execSync(`bun update --silent ${latest ? "--latest " : ""}${libsStr} --ignore-scripts`, options);
       break;
     case "npm":
-      execSync(`npm update ${libsStr} --ignore-scripts`, options);
+      execSync(
+        latest ? `npm install ${libs.map((lib) => `${lib}@latest`).join(" ")} --ignore-scripts` : `npm update ${libsStr} --ignore-scripts`,
+        options
+      );
       break;
   }
 }
@@ -148,6 +167,15 @@ function updateMeistrariLibraries(args) {
     console.log("No package.json found. Skipping @meistrari/* updates.");
     return;
   }
+  const config = readPackageJson("package.json").miseEnPlace?.updateMeistrariLibraries ?? {};
+  const enabled = config.enabled ?? true;
+  const exact = config.exact ?? false;
+  const strategies = config.packages ?? {};
+  const strategyFor = (lib) => strategies[lib] ?? "minor";
+  if (!enabled) {
+    console.log("miseEnPlace.updateMeistrariLibraries.enabled is false. Skipping @meistrari/* updates.");
+    return;
+  }
   const { packageManager: packageManagerOverride } = args;
   const selectPackageManager = () => {
     if (packageManagerOverride) {
@@ -156,7 +184,7 @@ function updateMeistrariLibraries(args) {
     }
     const detectedPackageManagers = detectPackageManager();
     if (!detectedPackageManagers) {
-      console.log("No recognized lock file found (pnpm-lock.yaml, yarn.lock, package-lock.json)");
+      console.log("No recognized lock file found (pnpm-lock.yaml, bun.lock, package-lock.json)");
       process.exit(1);
     }
     detectedPackageManagers.forEach(({ packageManager, file }) => {
@@ -185,23 +213,27 @@ function updateMeistrariLibraries(args) {
     console.log("No @meistrari/* libraries found in dependencies. Skipping update.");
     return;
   }
+  const libsList = Array.from(allMeistrariLibs).sort();
+  const updatableLibs = libsList.filter((lib) => strategyFor(lib) !== "skip");
+  const skippedLibs = libsList.filter((lib) => strategyFor(lib) === "skip");
+  if (skippedLibs.length > 0) {
+    console.log(`Skipping (config) ${skippedLibs.length} @meistrari/* libraries:`);
+    console.log(skippedLibs.join("\n"));
+  }
+  if (updatableLibs.length === 0) {
+    console.log("All @meistrari/* libraries are configured to be skipped. Nothing to update.");
+    return;
+  }
   for (const pkgJsonPath of packageJsonPaths) {
     if (!existsSync(pkgJsonPath))
       continue;
     const pkgJson = readPackageJson(pkgJsonPath);
-    if (pkgJson.dependencies) {
-      const updated = addCaretToMeistrariDeps(pkgJson.dependencies);
-      pkgJson.dependencies = updated;
-    }
-    if (pkgJson.devDependencies) {
-      const updated = addCaretToMeistrariDeps(pkgJson.devDependencies);
-      pkgJson.devDependencies = updated;
-    }
+    pkgJson.dependencies = applyMeistrariRanges(pkgJson.dependencies, (lib) => preUpdateOperator(strategyFor(lib)));
+    pkgJson.devDependencies = applyMeistrariRanges(pkgJson.devDependencies, (lib) => preUpdateOperator(strategyFor(lib)));
     writePackageJson(pkgJsonPath, pkgJson);
   }
-  const libsList = Array.from(allMeistrariLibs).sort();
-  console.log(`Found ${libsList.length} @meistrari/* libraries to update:`);
-  console.log(libsList.join("\n"));
+  console.log(`Found ${updatableLibs.length} @meistrari/* libraries to update:`);
+  console.log(updatableLibs.join("\n"));
   for (const packageManager of packageManagers) {
     if (packageManager === "bun") {
       for (const pkgJsonPath of packageJsonPaths) {
@@ -209,30 +241,40 @@ function updateMeistrariLibraries(args) {
           continue;
         const pkgJsonDir = dirname(pkgJsonPath);
         const pkgJson = readPackageJson(pkgJsonPath);
-        const localLibs = getMeistrariLibs(pkgJson);
+        const localLibs = getMeistrariLibs(pkgJson).filter((lib) => strategyFor(lib) !== "skip");
         if (localLibs.length === 0) {
-          console.log(`No @meistrari/* libraries found in ${pkgJsonDir}. Skipping.`);
+          console.log(`No updatable @meistrari/* libraries found in ${pkgJsonDir}. Skipping.`);
           continue;
         }
-        console.log(`Updating ${localLibs.join(" ")} libraries in ${pkgJsonDir}`);
-        updateLibraries(packageManager, localLibs, pkgJsonDir === "." ? void 0 : pkgJsonDir);
+        const cwd = pkgJsonDir === "." ? void 0 : pkgJsonDir;
+        const rangedLibs = localLibs.filter((lib) => strategyFor(lib) !== "major");
+        const majorLibs = localLibs.filter((lib) => strategyFor(lib) === "major");
+        if (rangedLibs.length > 0) {
+          console.log(`Updating ${rangedLibs.join(" ")} libraries in ${pkgJsonDir}`);
+          updateLibraries(packageManager, rangedLibs, { cwd });
+        }
+        if (majorLibs.length > 0) {
+          console.log(`Updating ${majorLibs.join(" ")} libraries to latest in ${pkgJsonDir}`);
+          updateLibraries(packageManager, majorLibs, { cwd, latest: true });
+        }
       }
     } else {
-      updateLibraries(packageManager, libsList);
+      const rangedLibs = updatableLibs.filter((lib) => strategyFor(lib) !== "major");
+      const majorLibs = updatableLibs.filter((lib) => strategyFor(lib) === "major");
+      if (rangedLibs.length > 0) {
+        updateLibraries(packageManager, rangedLibs);
+      }
+      if (majorLibs.length > 0) {
+        updateLibraries(packageManager, majorLibs, { latest: true });
+      }
     }
   }
   for (const pkgJsonPath of packageJsonPaths) {
     if (!existsSync(pkgJsonPath))
       continue;
     const pkgJson = readPackageJson(pkgJsonPath);
-    if (pkgJson.dependencies) {
-      const updated = addCaretToMeistrariDeps(pkgJson.dependencies);
-      pkgJson.dependencies = updated;
-    }
-    if (pkgJson.devDependencies) {
-      const updated = addCaretToMeistrariDeps(pkgJson.devDependencies);
-      pkgJson.devDependencies = updated;
-    }
+    pkgJson.dependencies = applyMeistrariRanges(pkgJson.dependencies, (lib) => postUpdateOperator(strategyFor(lib), exact));
+    pkgJson.devDependencies = applyMeistrariRanges(pkgJson.devDependencies, (lib) => postUpdateOperator(strategyFor(lib), exact));
     writePackageJson(pkgJsonPath, pkgJson);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meistrari/mise-en-place",
-  "version": "2.15.2",
+  "version": "2.16.0",
   "description": "",
   "repository": {
     "type": "git",