rman 0.37.4 → 1.0.1

package/services/publish.service.js

@@ -0,0 +1,199 @@
+import { execFile } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { exec } from '../utils/exec.js';
+import { GitHelper } from '../utils/git.js';
+import { filterPackages } from '../utils/package-filter.js';
+import { parseWorkspaceRange, resolveWorkspaceRange } from '../utils/workspace-range.js';
+import { CiService } from './ci.service.js';
+import { DEPENDENCY_KEYS } from './version.service.js';
+export var PublishService;
+(function (PublishService) {
+    /**
+     * Computes what `publish` *would* do, across every non-private package (topological order,
+     * dependencies before dependents) - never touches the registry to publish anything, just
+     * queries it to decide, so it's safe to call any time, including as the plan a bare `rman
+     * publish` shows before asking for confirmation.
+     *
+     * A `private: true` package is always `'skip'`ped outright. A package with uncommitted local
+     * changes is `'error'` (aborts the whole plan) unless `options.ignoreDirty` downgrades it to
+     * `'skip'` instead - same rule `version` uses, since publishing untracked local edits is worse
+     * than a bad commit. Otherwise, its currently-published registry version (via `npm view`,
+     * queried concurrently across every remaining package) decides the rest: identical to the local
+     * `package.json` version is `'up-to-date'`; anything else (including never having been
+     * published at all) is `'publish'`.
+     *
+     * Deliberately decoupled from `version`: this only ever looks at what's *currently* on disk and
+     * on the registry, never at whether `version` was just run - so it works equally well right
+     * after a version bump, or standing alone in a release pipeline that bumped days earlier.
+     *
+     * A monorepo's root package is never a candidate at all - `repository.getPackages()` already
+     * excludes it for a real monorepo (it only doubles as "the" package in a single-package repo,
+     * where it's a normal candidate like any other).
+     */
+    async function getPlan(repository, options = {}, deps = {}) {
+        const git = new GitHelper({ cwd: repository.dirname });
+        const packages = filterPackages(repository.getPackages({ toposort: true }), options);
+        const dirtyFiles = await git.listDirtyFiles({ absolute: true });
+        const isDirty = (pkg) => dirtyFiles.some(f => !path.relative(pkg.dirname, f).startsWith('..'));
+        const npmViewVersion = deps.npmViewVersion ?? ((name, cwd) => defaultNpmViewVersion(name, cwd, options));
+        const entries = new Map();
+        const toCheck = [];
+        for (const pkg of packages) {
+            if (pkg.isPrivate) {
+                entries.set(pkg.name, { package: pkg, version: pkg.version, status: 'skip', reason: 'private package' });
+            }
+            else if (isDirty(pkg)) {
+                entries.set(pkg.name, {
+                    package: pkg,
+                    version: pkg.version,
+                    status: options.ignoreDirty ? 'skip' : 'error',
+                    reason: 'uncommitted local changes',
+                });
+            }
+            else {
+                toCheck.push(pkg);
+            }
+        }
+        await Promise.all(toCheck.map(async (pkg) => {
+            const registryVersion = await npmViewVersion(pkg.name, pkg.dirname);
+            entries.set(pkg.name, {
+                package: pkg,
+                version: pkg.version,
+                registryVersion,
+                status: registryVersion === pkg.version ? 'up-to-date' : 'publish',
+                reason: registryVersion ? `registry has ${registryVersion}` : 'never published',
+            });
+        }));
+        return packages.map(pkg => entries.get(pkg.name));
+    }
+    PublishService.getPlan = getPlan;
+    /**
+     * Publishes every `'publish'` entry in `plan`, topological order (already `plan`'s own order -
+     * see `getPlan`), via the configured `packageManager`'s own `publish` command. Sequential, not
+     * concurrent: unlike `run`/`build`, a package genuinely needs its own dependencies to have
+     * landed on the registry first, and publishing is rare enough (once per release) that the
+     * simplicity is worth more than the parallelism `run` gets from `power-tasks`.
+     *
+     * If a package fails, every other still-pending entry depending on it (transitively) is marked
+     * `'error'` too and never attempted - publishing a package whose own new dependency range points
+     * at a version that never actually reached the registry would hand consumers a broken install.
+     * A package's own failure doesn't stop unrelated packages elsewhere in the plan, though.
+     */
+    async function applyPlan(repository, plan, options = {}) {
+        const packageManager = CiService.resolvePackageManager(repository, options.packageManager);
+        const failed = new Set();
+        const result = [];
+        const packagesByName = new Map(repository.getPackages().map(p => [p.name, p]));
+        for (const entry of plan) {
+            if (entry.status !== 'publish') {
+                result.push(entry);
+                continue;
+            }
+            const pkg = entry.package;
+            const blocker = pkg.dependencies.find(d => failed.has(d));
+            if (blocker) {
+                failed.add(pkg.name);
+                result.push({ ...entry, status: 'error', reason: `dependency "${blocker}" failed to publish` });
+                continue;
+            }
+            const restore = rewriteWorkspaceRangesForPublish(pkg, packagesByName);
+            try {
+                await exec(buildPublishCommand(packageManager, options), {
+                    cwd: resolvePublishDir(pkg, options.contents),
+                    stdio: 'inherit',
+                });
+                result.push(entry);
+            }
+            catch (e) {
+                failed.add(pkg.name);
+                result.push({ ...entry, status: 'error', reason: e.message });
+            }
+            finally {
+                restore?.();
+            }
+        }
+        return result;
+    }
+    PublishService.applyPlan = applyPlan;
+})(PublishService || (PublishService = {}));
+const execFileAsync = promisify(execFile);
+/** `npm view <name> version`, optionally against a custom registry/`.npmrc` - `undefined` for any
+ *  failure (never published, no network, private/restricted with no access, ...), same
+ *  catch-everything shape as `change-hash.ts`'s own `defaultNpmViewVersion` (kept separate here
+ *  since this one also needs `--registry`/`--userconfig`, which that one has no use for). */
+async function defaultNpmViewVersion(name, cwd, options) {
+    const argv = ['view', name, 'version'];
+    if (options.registry)
+        argv.push('--registry', options.registry);
+    if (options.userconfig)
+        argv.push('--userconfig', options.userconfig);
+    try {
+        const { stdout } = await execFileAsync('npm', argv, { cwd });
+        return stdout.trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** npm's own native `publishConfig.directory` (if the package declares one) always wins over
+ *  `options.contents` - the package's own package.json is the more authoritative, persistent
+ *  statement of "this is where the publishable output lives", `--contents` is just a fallback for
+ *  when it doesn't declare one at all. */
+function resolvePublishDir(pkg, contentsOverride) {
+    const native = pkg.json.publishConfig?.directory;
+    const rel = (typeof native === 'string' && native) || contentsOverride;
+    return rel ? path.resolve(pkg.dirname, rel) : pkg.dirname;
+}
+function buildPublishCommand(packageManager, options) {
+    const args = ['publish'];
+    if (options.access)
+        args.push('--access', options.access);
+    if (options.tag)
+        args.push('--tag', options.tag);
+    if (options.otp)
+        args.push('--otp', options.otp);
+    if (options.registry)
+        args.push('--registry', options.registry);
+    if (options.userconfig)
+        args.push('--userconfig', options.userconfig);
+    return `${packageManager} ${args.join(' ')}`;
+}
+/**
+ * Rewrites every `"workspace:"` dependency range in `pkg`'s `package.json` to a real,
+ * registry-publishable range (the same substitution pnpm/yarn's own publish performs - see
+ * `resolveWorkspaceRange`), just before shelling out to `npm publish` - which reads whatever is
+ * actually on disk, unlike pnpm/yarn's own publish this never packs into a staging tarball first.
+ * Returns a function that restores the file's original bytes (and `pkg`'s in-memory state)
+ * verbatim; always invoke it from a `finally`, so a failed publish never leaves a rewritten
+ * `package.json` behind. Returns `undefined` (nothing to restore, no disk write at all) when `pkg`
+ * has no `"workspace:"` ranges to begin with.
+ */
+function rewriteWorkspaceRangesForPublish(pkg, packagesByName) {
+    const hasWorkspaceRange = DEPENDENCY_KEYS.some(depKey => {
+        const deps = pkg.json[depKey];
+        return deps && Object.values(deps).some(v => parseWorkspaceRange(v));
+    });
+    if (!hasWorkspaceRange)
+        return undefined;
+    const original = fs.readFileSync(pkg.jsonFileName, 'utf-8');
+    for (const depKey of DEPENDENCY_KEYS) {
+        const deps = pkg.json[depKey];
+        if (!deps)
+            continue;
+        for (const depName of Object.keys(deps)) {
+            const parsed = parseWorkspaceRange(deps[depName]);
+            if (!parsed)
+                continue;
+            const depPkg = packagesByName.get(depName);
+            if (depPkg)
+                deps[depName] = resolveWorkspaceRange(parsed, depPkg.version);
+        }
+    }
+    pkg.writeJson();
+    return () => {
+        fs.writeFileSync(pkg.jsonFileName, original, 'utf-8');
+        pkg.reloadJson();
+    };
+}

package/services/run.service.d.ts

@@ -0,0 +1,99 @@
+import type { Package } from '../core/package.js';
+import type { Repository } from '../core/repository.js';
+import { type LogLevel } from '../utils/logger.js';
+import { type PackageFilterOptions } from '../utils/package-filter.js';
+export declare namespace RunService {
+    interface Options extends PackageFilterOptions {
+        /** Max packages built at once: `true`/omitted = CPU count, a number = that many, `false` = serial (1). */
+        parallel?: boolean | number;
+        /** Respect the package dependency graph: a package waits for its dependencies and is skipped
+         *  if one fails. Default true (right for `build`). Set false for scripts like `lint`/`test`
+         *  where packages are independent - order becomes alphabetical and one package's failure
+         *  (or its dependency's) never skips another. */
+        topo?: boolean;
+        bail?: boolean;
+        changed?: boolean;
+        changedSince?: string;
+        /** Show the live progress panel. Default true; auto-disabled when stdout isn't a TTY. */
+        progress?: boolean;
+        /** Verbosity of the classic per-step log (only applies when the live panel is off). Falls back to
+         *  the root's `.rmanrc logLevel`, then 'info' - see `resolveRootLogLevel`. */
+        logLevel?: LogLevel;
+        /** Run across the whole repository even when the current directory is inside a single package
+         *  (which otherwise scopes the run to just that package, and skips the root's own pre/post
+         *  bookend - see `Repository.currentPackage`). Has no effect when already at the repository
+         *  root, or outside any known package. */
+        root?: boolean;
+    }
+    /**
+     * A package's `.rmanrc` (cascaded) can configure `run.<script>.*` - e.g.
+     *   run:
+     *     build:
+     *       concurrency: 2
+     *     lint:
+     *       topo: false
+     *       bail: false
+     * and a package can opt itself out of a script entirely:
+     *   run:
+     *     build:
+     *       skip: true
+     * or supply the command(s) to run when its own package.json doesn't define this script (or its
+     * pre/post hooks) at all - a single string, or an array to run several in sequence - see
+     * `getScriptSteps`:
+     *   run:
+     *     build:
+     *       script: tsc -b
+     *       preScript: [node ./generate.js, node ./validate.js]
+     *       postScript: node ./copy-assets.js
+     *       override: true   # use these even if the package *does* define its own
+     */
+    function getConfig(pkg: Package, script: string): Record<string, unknown>;
+    /**
+     * `.rmanrc` conditional execution, GitHub Actions-`if`-flavored but a small closed grammar
+     * instead of a full expression language (less to get wrong, still covers what's asked for) -
+     * atoms combined with `and`/`or` (`and` binds tighter, same as most languages) and `(...)`:
+     *
+     *   run:
+     *     build:
+     *       if: changed                                    # changed since the last publish
+     *     test:
+     *       if: changed = a1b2c3d                           # changed since a specific commit
+     *       if: changed = {CHANGE_HASH}                     # {NAME} -> process.env.NAME first
+     *       if: (changed or dirty) and not committed
+     */
+    type IfNode = {
+        kind: 'atom';
+        name: string;
+        value?: string;
+    } | {
+        kind: 'not';
+        node: IfNode;
+    } | {
+        kind: 'and';
+        left: IfNode;
+        right: IfNode;
+    } | {
+        kind: 'or';
+        left: IfNode;
+        right: IfNode;
+    };
+    /** Recursive-descent parser over `tokenizeIf`'s output: expr := or ; or := and ('or' and)* ;
+     *  and := unary ('and' unary)* ; unary := 'not' unary | GROUP | NAME ['=' VALUE] */
+    function parseIfExpr(raw: unknown): IfNode | undefined;
+    /** Evaluates a parsed `if` expression for one package. `statusCache` avoids repeat `git` calls
+     *  for the same reference hash across packages/scripts in a single run. */
+    function evaluateIf(repository: Repository, pkg: Package, node: IfNode, statusCache: Map<string, Record<string, Repository.PackageStatus>>): Promise<boolean>;
+    function runScript(repository: Repository, script: string, options?: Options & {
+        commandName?: string;
+    }): Promise<void>;
+}
+/** Resolution order: explicit CLI flag > the package's resolved `.rmanrc` > `fallback`. */
+export declare function resolveBool(cliValue: boolean | undefined, pkg: Package, script: string, key: string, fallback: boolean): boolean;
+/**
+ * Bail is the one setting where a package's own `.rmanrc` outranks even an explicit CLI flag:
+ * "this package's failure must always stop the batch" is a more specific, intentional statement
+ * than a broad `--no-bail` meant for the run as a whole, and shouldn't be silently overridable by it.
+ */
+export declare function resolveBail(cliValue: boolean | undefined, pkg: Package, script: string, fallback: boolean): boolean;
+export declare function resolveNumber(cliValue: number | undefined, pkg: Package, script: string, key: string, fallback: number): number;
+export declare function resolveLogLevel(cliValue: LogLevel | undefined, pkg: Package, script: string, fallback: LogLevel): LogLevel;