@jskit-ai/release 0.1.4 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/release",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Selective npm release preparation, publication and dependency pinning for package repositories.",
   "type": "module",
   "files": [

package/src/release.mjs

@@ -59,12 +59,8 @@ function parseArgs(argv = []) {
       else options.from.push(path.resolve(value));
       continue;
     }
-    if (argument === "--registry") {
-      options.registry = normalizeRegistryUrl(args.shift());
-      continue;
-    }
-    if (argument.startsWith("--registry=")) {
-      options.registry = normalizeRegistryUrl(argument.slice("--registry=".length));
+    if (name === "--registry") {
+      options.registry = normalizeRegistryUrl(inline ?? args.shift() ?? "");
       continue;
     }
     throw new Error(`Unknown argument: ${argument}`);
@@ -76,7 +72,7 @@ function parseArgs(argv = []) {
   return options;
 }
 
-function normalizeRegistryUrl(value = DEFAULT_REGISTRY) {
+function normalizeRegistryUrl(value) {
   const registry = String(value || "").trim();
   if (!registry) {
     throw new Error("--registry requires a URL.");
@@ -178,8 +174,10 @@ async function discoverReleasePackages(repoRoot) {
     const name = String(manifest.packageJson.name || "").trim();
     if (!name || manifest.packageJson.private === true) continue;
     if (records.some(record => record.name === name)) throw new Error(`${name} is declared by more than one package directory.`);
-    records.push({ name, ...manifest, localDependencies: new Set() });
+    records.push({ name, ...manifest });
   }
+  const localNames = new Set(records.map(record => record.name));
+  for (const record of records) record.localDependencies = collectPublishDependencies(record.packageJson, localNames);
   return records.sort((left, right) => left.name.localeCompare(right.name));
 }
 
@@ -203,13 +201,6 @@ function collectPublishDependencies(packageJson, localNames) {
   return dependencies;
 }
 
-function hydrateLocalDependencies(records) {
-  const localNames = new Set(records.map((record) => record.name));
-  for (const record of records) {
-    record.localDependencies = collectPublishDependencies(record.packageJson, localNames);
-  }
-}
-
 function currentVersionMap(records) {
   return new Map(records.map((record) => {
     const version = String(record.packageJson.version || "").trim();
@@ -497,7 +488,6 @@ async function prepareRelease({ cwd: repoRoot, dryRun, registry, report = false
       }
     }
     if (!staged.length) throw new Error(`No publishable packages found in ${repoRoot}.`);
-    hydrateLocalDependencies(staged);
     topologicalPublishOrder(staged);
     const current = currentVersionMap(staged);
     const versions = new Map(current);
@@ -660,23 +650,20 @@ function releaseCommitMessage(entries) {
   return `Release ${subject}${names.length > 4 ? `\n\n${names.join("\n")}` : ""}`;
 }
 
-async function publishRelease(records, { cwd: repoRoot, dryRun, registry }) {
-  if (!dryRun) {
-    assertMainReleaseCheckout(repoRoot);
-  }
+async function publishRelease(records, { cwd: repoRoot, registry }) {
+  assertMainReleaseCheckout(repoRoot);
   await validateReleaseState(records, repoRoot);
   const order = topologicalPublishOrder(records);
   const recordsByName = new Map(records.map((record) => [record.name, record]));
   const directory = await mkdtemp(path.join(tmpdir(), "jskit-release-"));
   try {
-    const configPath = !dryRun || String(process.env.NPM_TOKEN || "").trim()
-      ? await createNpmUserConfig(registry, directory, records) : "";
-    if (!dryRun) await runCommand("npm", ["whoami", "--registry", registry, "--userconfig", configPath]);
+    const configPath = await createNpmUserConfig(registry, directory, records);
+    await runCommand("npm", ["whoami", "--registry", registry, "--userconfig", configPath]);
     const inspection = createPublicationInspection({ directory, registry, configPath });
     await assertNoNewerVersions(records, inspection);
     const plan = await planPublication(order.map(name => recordsByName.get(name)), { inspection });
     for (const entry of plan) {
-      if (dryRun || entry.state === "skip") continue;
+      if (entry.state === "skip") continue;
       const args = [
         "publish",
         entry.tarball,
@@ -694,7 +681,7 @@ async function publishRelease(records, { cwd: repoRoot, dryRun, registry }) {
   } finally {
     await rm(directory, { recursive: true, force: true });
   }
-  process.stdout.write(dryRun ? "Publish dry-run complete.\n" : "Publish complete.\n");
+  process.stdout.write("Publish complete.\n");
 }
 
 // publish: prepare the clean, current main checkout, commit and push the
@@ -708,9 +695,28 @@ async function publishCommand(options) {
   assertMainReleaseCheckout(options.cwd);
   const { plan } = await prepareRelease(options);
   commitAndPush(options.cwd, releaseCommitMessage(plan));
-  const records = await discoverReleasePackages(options.cwd);
-  hydrateLocalDependencies(records);
-  await publishRelease(records, options);
+  await publishRelease(await discoverReleasePackages(options.cwd), options);
+}
+
+// npm cannot move exactly pinned packages that require each other in
+// lockstep (assistant-core and assistant-runtime, say): the locked old
+// versions still demand the old peers, and install stops with ERESOLVE.
+// Forgetting only the pinned packages' lock entries lets npm resolve them
+// afresh while every other locked dependency stays as it was.
+async function forgetPinnedLockEntries(repoRoot, names) {
+  const lockPath = path.join(repoRoot, "package-lock.json");
+  let lock;
+  try {
+    lock = JSON.parse(await readFile(lockPath, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
+  }
+  for (const key of Object.keys(lock.packages || {})) {
+    const name = key.split("node_modules/").at(-1);
+    if (key.includes("node_modules/") && names.has(name)) delete lock.packages[key];
+  }
+  await writeFile(lockPath, serializeJson(lock), "utf8");
 }
 
 // npm can take minutes to serve a just-published version everywhere.
@@ -760,6 +766,7 @@ async function pinCommand({ cwd: repoRoot, from, dryRun, noCommit }) {
     process.stdout.write("Pin dry-run complete.\n");
     return;
   }
+  await forgetPinnedLockEntries(repoRoot, new Set(versions.keys()));
   await installReleasedPins(repoRoot);
   if (noCommit) {
     process.stdout.write(`${path.basename(repoRoot)}: pins installed; not committed\n`);