rman 1.0.10 → 1.0.12

package/services/version.service.js

@@ -1,3 +1,4 @@
+import fs from 'node:fs';
 import path from 'node:path';
 import semver from 'semver';
 import { detectChangeHash, expandTag } from '../utils/change-hash.js';
@@ -6,6 +7,7 @@ import { exec } from '../utils/exec.js';
 import { GitHelper } from '../utils/git.js';
 import { filterPackages } from '../utils/package-filter.js';
 import { expandReleaseTag, findLastReleaseVersion, formatCalendarVersion, isCalendarVersion, usesCalendarVersion, } from '../utils/release-version.js';
+import { stampVersionConstant, stampVersionLabel } from '../utils/version-stamp.js';
 import { parseWorkspaceRange } from '../utils/workspace-range.js';
 import { ChangelogService } from './changelog.service.js';
 export var VersionService;
@@ -133,9 +135,13 @@ export var VersionService;
         const isRealEntry = (e) => !(repository.monorepo && e.package === repository.rootPackage);
         const bumped = plan.filter(e => e.status === 'bump' && isRealEntry(e));
         const bumpedByName = new Map(bumped.map(e => [e.package.name, e]));
+        /** Repo-relative paths of every file stamped with the new version below (a Dockerfile label, a
+         *  source constant), so each lands in the same commit as the bump that made it stale - keyed by
+         *  package, the way `changelogFileByPackage` is. */
+        const stampedByPackage = new Map();
         for (const entry of bumped) {
             const pkg = entry.package;
-            await runVersionScript(pkg, 'preScript', 'preversion');
+            await runVersionScript(pkg, 'before', 'preversion');
             pkg.json.version = entry.to;
             for (const depKey of DEPENDENCY_KEYS) {
                 const deps = pkg.json[depKey];
@@ -157,9 +163,14 @@ export var VersionService;
                     deps[depName] = '^' + depEntry.to;
                 }
             }
-            await runVersionScript(pkg, 'script', 'version');
+            await runVersionScript(pkg, 'exec', 'version');
             pkg.writeJson();
-            await runVersionScript(pkg, 'postScript', 'postversion');
+            // Before `postversion`, so a script that reacts to the bump sees the whole new state.
+            const stamped = [stampDockerfile(pkg, entry.to), ...stampSourceFiles(pkg, entry.to)].filter((f) => !!f);
+            if (stamped.length) {
+                stampedByPackage.set(pkg.name, stamped.map(f => path.relative(repository.dirname, f)));
+            }
+            await runVersionScript(pkg, 'after', 'postversion');
         }
         const rootEntry = repository.monorepo ? plan.find(e => e.package === repository.rootPackage) : undefined;
         if (rootEntry?.status === 'bump') {
@@ -218,6 +229,7 @@ export var VersionService;
                 const changelogFile = changelogFileByPackage.get(e.package.name);
                 if (changelogFile)
                     files.push(changelogFile);
+                files.push(...(stampedByPackage.get(e.package.name) ?? []));
             }
             await git.commit(files, buildCommitMessage(repository, groupEntries, options.message));
             const tags = new Set(groupEntries.map(e => expandTag(e.package, e.to)));
@@ -490,3 +502,55 @@ async function runVersionScript(pkg, cfgKey, npmScriptName) {
     if (command)
         await exec(command, { cwd: pkg.dirname, stdio: 'inherit' });
 }
+/**
+ * Keeps a package's Dockerfile `org.opencontainers.image.version` label in step with the version
+ * just written, returning the absolute path when it actually changed (so the caller can fold it
+ * into the same commit) and `undefined` otherwise.
+ *
+ * Here rather than in a build script: the label is a *statement of the package's version*, so it
+ * belongs to whatever writes that version - which keeps it in the bump commit, leaves the tree
+ * clean, and makes it right for anyone building the Dockerfile by hand. A build-time rewrite is
+ * both later than it needs to be and invisible to git.
+ *
+ * The same path `publish --target docker` builds from (`publish.docker.dockerfile`, default
+ * `Dockerfile`), so the two can never disagree about which file this is. Opt out with `.rmanrc
+ * "version": { "stampDockerfile": false }`; a package with no Dockerfile, or one that doesn't
+ * declare the label, is a no-op either way.
+ */
+function stampDockerfile(pkg, version) {
+    if (pkg.config?.version?.stampDockerfile === false)
+        return undefined;
+    const file = path.resolve(pkg.dirname, pkg.config?.publish?.docker?.dockerfile || 'Dockerfile');
+    if (!fs.existsSync(file))
+        return undefined;
+    const stamped = stampVersionLabel(fs.readFileSync(file, 'utf-8'), version);
+    if (stamped === undefined)
+        return undefined;
+    fs.writeFileSync(file, stamped, 'utf-8');
+    return file;
+}
+/**
+ * Keeps every `.rmanrc "version.stamp"` source file's `version` constant in step with the version
+ * just written, returning the absolute paths of the ones that actually changed.
+ *
+ * Explicitly listed rather than discovered: unlike the OCI Dockerfile label there is no standard
+ * saying "this file holds the version", and the assignment this matches is deliberately broad. A
+ * listed file a package doesn't have is a silent no-op, which is what lets one `"[*]"` declaration
+ * cover a repo where only some packages carry one.
+ */
+function stampSourceFiles(pkg, version) {
+    const configured = pkg.config?.version?.stamp;
+    const patterns = typeof configured === 'string' ? [configured] : (configured ?? []);
+    const stamped = [];
+    for (const rel of patterns) {
+        const file = path.resolve(pkg.dirname, rel);
+        if (!fs.existsSync(file))
+            continue;
+        const next = stampVersionConstant(fs.readFileSync(file, 'utf-8'), version);
+        if (next === undefined)
+            continue;
+        fs.writeFileSync(file, next, 'utf-8');
+        stamped.push(file);
+    }
+    return stamped;
+}

package/utils/npm-run-path.d.ts

@@ -63,5 +63,5 @@ export declare function npmRunPath(options?: RunPathOptions): string;
  ```
  */
 export declare function npmRunPathEnv(options?: EnvOptions): {
-    [x: string]: string | undefined;
+    [key: string]: string | undefined;
 };

package/utils/version-stamp.d.ts

@@ -0,0 +1,40 @@
+/** Keeping a package's version truthful wherever the package itself declares it - its Dockerfile's
+ *  OCI label, and any source file that hard-codes it as a constant. Both are `version`'s job rather
+ *  than a build step's: a version is being written, these are places it is written, and doing it
+ *  here puts them in the bump commit instead of leaving the repository disagreeing with itself. */
+/** The OCI label whose value is, by specification, "version of the packaged software" - so a
+ *  package's own `package.json` version is the only correct value it can hold, which is what makes
+ *  stamping it automatic rather than something to configure. */
+export declare const OCI_VERSION_LABEL = "org.opencontainers.image.version";
+/**
+ * Rewrites every `org.opencontainers.image.version` value in a Dockerfile's `LABEL` instructions to
+ * `version`, returning the new content - or `undefined` when there was nothing to change (no such
+ * label, or it already holds this version), so a caller can skip writing the file at all.
+ *
+ * Only ever *rewrites*: a Dockerfile that doesn't declare the label is left exactly as it is rather
+ * than having one inserted. Which labels an image carries is the author's decision; keeping one
+ * they already declared truthful is not.
+ *
+ * The existing quoting style is preserved, so the diff is the version and nothing else.
+ */
+export declare function stampVersionLabel(content: string, version: string): string | undefined;
+/**
+ * Rewrites the string assigned to a `name` constant (default `version`) in a source file to
+ * `version`, returning the new content - or `undefined` when there was nothing to change, so a
+ * caller can skip writing the file at all. Both an assignment and an object property are matched:
+ *
+ * ```ts
+ * export const version = '1';   ->   export const version = '6.0.10';
+ * { name: 'app', version: '1' } ->   { name: 'app', version: '6.0.10' }
+ * ```
+ *
+ * Unlike the Dockerfile label there is no standard naming a file as holding the version, so this
+ * only ever runs against files `.rmanrc "version.stamp"` explicitly lists - which is also what
+ * keeps a match this broad safe.
+ *
+ * Stamping the *source* rather than the build output is the point: a build-time rewrite leaves the
+ * checked-in file claiming some placeholder, so anything running from source (tests, ts-node, the
+ * dev loop) reports that placeholder, git never records the released version, and the rewrite has
+ * to be redone on every build.
+ */
+export declare function stampVersionConstant(content: string, version: string, name?: string): string | undefined;

package/utils/version-stamp.js

@@ -0,0 +1,76 @@
+/** Keeping a package's version truthful wherever the package itself declares it - its Dockerfile's
+ *  OCI label, and any source file that hard-codes it as a constant. Both are `version`'s job rather
+ *  than a build step's: a version is being written, these are places it is written, and doing it
+ *  here puts them in the bump commit instead of leaving the repository disagreeing with itself. */
+/** The OCI label whose value is, by specification, "version of the packaged software" - so a
+ *  package's own `package.json` version is the only correct value it can hold, which is what makes
+ *  stamping it automatic rather than something to configure. */
+export const OCI_VERSION_LABEL = 'org.opencontainers.image.version';
+/**
+ * Rewrites every `org.opencontainers.image.version` value in a Dockerfile's `LABEL` instructions to
+ * `version`, returning the new content - or `undefined` when there was nothing to change (no such
+ * label, or it already holds this version), so a caller can skip writing the file at all.
+ *
+ * Only ever *rewrites*: a Dockerfile that doesn't declare the label is left exactly as it is rather
+ * than having one inserted. Which labels an image carries is the author's decision; keeping one
+ * they already declared truthful is not.
+ *
+ * The existing quoting style is preserved, so the diff is the version and nothing else.
+ */
+export function stampVersionLabel(content, version) {
+    const lines = content.split('\n');
+    let changed = false;
+    // A LABEL's key=value pairs can spill over several lines via trailing backslashes, so the
+    // instruction a line belongs to is tracked rather than assumed from the line itself. Anything
+    // outside a LABEL is left alone - the same key in an ARG, an ENV or a comment is not a label.
+    let continuing = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const inLabel = continuing || /^\s*LABEL\b/i.test(line);
+        continuing = inLabel && /\\\s*$/.test(line);
+        if (!inLabel)
+            continue;
+        lines[i] = line.replace(LABEL_VALUE, (whole, key, value) => {
+            const quote = value[0] === '"' || value[0] === "'" ? value[0] : '';
+            const next = `${key}${quote}${version}${quote}`;
+            if (next !== whole)
+                changed = true;
+            return next;
+        });
+    }
+    return changed ? lines.join('\n') : undefined;
+}
+/**
+ * Rewrites the string assigned to a `name` constant (default `version`) in a source file to
+ * `version`, returning the new content - or `undefined` when there was nothing to change, so a
+ * caller can skip writing the file at all. Both an assignment and an object property are matched:
+ *
+ * ```ts
+ * export const version = '1';   ->   export const version = '6.0.10';
+ * { name: 'app', version: '1' } ->   { name: 'app', version: '6.0.10' }
+ * ```
+ *
+ * Unlike the Dockerfile label there is no standard naming a file as holding the version, so this
+ * only ever runs against files `.rmanrc "version.stamp"` explicitly lists - which is also what
+ * keeps a match this broad safe.
+ *
+ * Stamping the *source* rather than the build output is the point: a build-time rewrite leaves the
+ * checked-in file claiming some placeholder, so anything running from source (tests, ts-node, the
+ * dev loop) reports that placeholder, git never records the released version, and the rewrite has
+ * to be redone on every build.
+ */
+export function stampVersionConstant(content, version, name = 'version') {
+    let changed = false;
+    const pattern = new RegExp(`(\\b${escapeRegExp(name)}\\s*[:=]\\s*)(['"\`])([^'"\`\\n]*)\\2`, 'g');
+    const result = content.replace(pattern, (whole, prefix, quote) => {
+        const next = `${prefix}${quote}${version}${quote}`;
+        if (next !== whole)
+            changed = true;
+        return next;
+    });
+    return changed ? result : undefined;
+}
+const LABEL_VALUE = new RegExp(`(${OCI_VERSION_LABEL.replace(/\./g, '\\.')}\\s*=\\s*)("[^"\\n]*"|'[^'\\n]*'|[^\\s\\\\]+)`, 'g');
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}