@aws/nx-plugin 1.0.0-rc.8 → 1.0.0-rc.80

package/src/utils/migration-manifest.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { MigrationsJson } from './migration-versions.js';
+/**
+ * `migrations.json` is assembled from the plugin's source rather than committed,
+ * so two PRs each adding a migration touch disjoint files and never conflict on
+ * a shared manifest.
+ *
+ * The pieces it is assembled from:
+ * - one folder per migration under `src/migrations/<dir>/<name>/`, where `<dir>`
+ *   is `latest` until a release claims it and `v<version>` after — the folder
+ *   carries a `metadata.json` (its description) beside the code, and its files
+ *   discriminate the kind: a `migration.ts` makes it deterministic, a `prompt.md`
+ *   agentic, both hybrid;
+ * - `packageJsonUpdates.json`, the nx bumps the weekly update maintains, kept in
+ *   its own file so that churn never shares an edit with a migration PR;
+ * - the version sync entry, a fixed `everyMigration` codemod that runs on every
+ *   upgrade and so has no folder.
+ *
+ * The assembled manifest is unversioned — release-time stamping resolves versions
+ * (see `migration-versions.ts`).
+ */
+/** JSON schema the manifest declares, matching what nx expects. */
+export declare const MIGRATIONS_JSON_SCHEMA = "http://json-schema.org/schema";
+/** Key the version sync migration is registered under. */
+export declare const SYNC_VENDED_MIGRATION_KEY = "sync-vended-versions";
+/**
+ * The version sync migration entry. Committed as code rather than a folder: it
+ * carries no release-specific registration and must run on every upgrade, so it
+ * is fixed and can't conflict.
+ */
+export declare const syncVendedMigrationEntry: () => NonNullable<MigrationsJson["generators"]>[string];
+/** A migration folder discovered under `src/migrations`. */
+export interface DiscoveredMigration {
+    /** Folder grouping the migration by release: `latest` or `v<version>`. */
+    dir: string;
+    /** Migration folder name. */
+    name: string;
+    /** Description read from the folder's `metadata.json`. */
+    description: string;
+    /** A `migration.ts` is present, so the migration has a codemod. */
+    hasImplementation: boolean;
+    /** A `prompt.md` is present, so the migration hands off to an agent. */
+    hasPrompt: boolean;
+}
+/**
+ * Assemble the plugin's `migrations.json` from its source pieces: the discovered
+ * migration folders, the version sync entry, and the nx `packageJsonUpdates`.
+ *
+ * Deterministic — keys are sorted — so regenerating always yields the same file.
+ *
+ * @param pluginName the plugin package name the manifest is for
+ * @param migrations migration folders discovered under `src/migrations`
+ * @param packageJsonUpdates parsed `packageJsonUpdates.json`, if present
+ */
+export declare const assembleMigrations: (pluginName: string, migrations: DiscoveredMigration[], packageJsonUpdates?: MigrationsJson["packageJsonUpdates"]) => MigrationsJson;

package/src/utils/migration-manifest.js

@@ -0,0 +1,76 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */ import { isValidVersion, LATEST_MIGRATIONS_DIR, migrationKey } from "./migration-versions.js";
+import { sortObjectKeys } from "./object.js";
+/**
+ * `migrations.json` is assembled from the plugin's source rather than committed,
+ * so two PRs each adding a migration touch disjoint files and never conflict on
+ * a shared manifest.
+ *
+ * The pieces it is assembled from:
+ * - one folder per migration under `src/migrations/<dir>/<name>/`, where `<dir>`
+ *   is `latest` until a release claims it and `v<version>` after — the folder
+ *   carries a `metadata.json` (its description) beside the code, and its files
+ *   discriminate the kind: a `migration.ts` makes it deterministic, a `prompt.md`
+ *   agentic, both hybrid;
+ * - `packageJsonUpdates.json`, the nx bumps the weekly update maintains, kept in
+ *   its own file so that churn never shares an edit with a migration PR;
+ * - the version sync entry, a fixed `everyMigration` codemod that runs on every
+ *   upgrade and so has no folder.
+ *
+ * The assembled manifest is unversioned — release-time stamping resolves versions
+ * (see `migration-versions.ts`).
+ */ /** JSON schema the manifest declares, matching what nx expects. */ export const MIGRATIONS_JSON_SCHEMA = 'http://json-schema.org/schema';
+/** Key the version sync migration is registered under. */ export const SYNC_VENDED_MIGRATION_KEY = 'sync-vended-versions';
+/**
+ * The version sync migration entry. Committed as code rather than a folder: it
+ * carries no release-specific registration and must run on every upgrade, so it
+ * is fixed and can't conflict.
+ */ export const syncVendedMigrationEntry = ()=>({
+        description: 'Sync vended dependency versions and the tracked plugin version to those vended by this release',
+        implementation: './src/utils/version-upgrade-migration/migration',
+        everyMigration: true
+    });
+/** Registration for a single discovered migration folder. */ const migrationEntry = (migration)=>{
+    const path = `./src/migrations/${migration.dir}/${migration.name}`;
+    return {
+        // A migration in a `v<version>` folder has already been claimed by that
+        // release; its version is the folder. One in `latest` is left for stamping.
+        ...migration.dir !== LATEST_MIGRATIONS_DIR && isValidVersion(migration.dir.replace(/^v/, '')) ? {
+            version: migration.dir.replace(/^v/, '')
+        } : {},
+        description: migration.description,
+        ...migration.hasImplementation ? {
+            implementation: `${path}/migration`
+        } : {},
+        ...migration.hasPrompt ? {
+            prompt: `${path}/prompt.md`
+        } : {}
+    };
+};
+/**
+ * Assemble the plugin's `migrations.json` from its source pieces: the discovered
+ * migration folders, the version sync entry, and the nx `packageJsonUpdates`.
+ *
+ * Deterministic — keys are sorted — so regenerating always yields the same file.
+ *
+ * @param pluginName the plugin package name the manifest is for
+ * @param migrations migration folders discovered under `src/migrations`
+ * @param packageJsonUpdates parsed `packageJsonUpdates.json`, if present
+ */ export const assembleMigrations = (pluginName, migrations, packageJsonUpdates)=>({
+        $schema: MIGRATIONS_JSON_SCHEMA,
+        name: pluginName,
+        generators: sortObjectKeys({
+            [SYNC_VENDED_MIGRATION_KEY]: syncVendedMigrationEntry(),
+            ...Object.fromEntries(migrations.map((migration)=>[
+                    migrationKey(migration.dir, migration.name),
+                    migrationEntry(migration)
+                ]))
+        }),
+        ...packageJsonUpdates && Object.keys(packageJsonUpdates).length > 0 ? {
+            packageJsonUpdates
+        } : {}
+    });
+
+//# sourceMappingURL=migration-manifest.js.map

package/src/utils/migration-manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../packages/nx-plugin/src/utils/migration-manifest.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\nimport type { MigrationsJson } from './migration-versions.js';\nimport {\n  isValidVersion,\n  LATEST_MIGRATIONS_DIR,\n  migrationKey,\n} from './migration-versions.js';\nimport { sortObjectKeys } from './object.js';\n\n/**\n * `migrations.json` is assembled from the plugin's source rather than committed,\n * so two PRs each adding a migration touch disjoint files and never conflict on\n * a shared manifest.\n *\n * The pieces it is assembled from:\n * - one folder per migration under `src/migrations/<dir>/<name>/`, where `<dir>`\n *   is `latest` until a release claims it and `v<version>` after — the folder\n *   carries a `metadata.json` (its description) beside the code, and its files\n *   discriminate the kind: a `migration.ts` makes it deterministic, a `prompt.md`\n *   agentic, both hybrid;\n * - `packageJsonUpdates.json`, the nx bumps the weekly update maintains, kept in\n *   its own file so that churn never shares an edit with a migration PR;\n * - the version sync entry, a fixed `everyMigration` codemod that runs on every\n *   upgrade and so has no folder.\n *\n * The assembled manifest is unversioned — release-time stamping resolves versions\n * (see `migration-versions.ts`).\n */\n\n/** JSON schema the manifest declares, matching what nx expects. */\nexport const MIGRATIONS_JSON_SCHEMA = 'http://json-schema.org/schema';\n\n/** Key the version sync migration is registered under. */\nexport const SYNC_VENDED_MIGRATION_KEY = 'sync-vended-versions';\n\n/**\n * The version sync migration entry. Committed as code rather than a folder: it\n * carries no release-specific registration and must run on every upgrade, so it\n * is fixed and can't conflict.\n */\nexport const syncVendedMigrationEntry = (): NonNullable<\n  MigrationsJson['generators']\n>[string] => ({\n  description:\n    'Sync vended dependency versions and the tracked plugin version to those vended by this release',\n  implementation: './src/utils/version-upgrade-migration/migration',\n  everyMigration: true,\n});\n\n/** A migration folder discovered under `src/migrations`. */\nexport interface DiscoveredMigration {\n  /** Folder grouping the migration by release: `latest` or `v<version>`. */\n  dir: string;\n  /** Migration folder name. */\n  name: string;\n  /** Description read from the folder's `metadata.json`. */\n  description: string;\n  /** A `migration.ts` is present, so the migration has a codemod. */\n  hasImplementation: boolean;\n  /** A `prompt.md` is present, so the migration hands off to an agent. */\n  hasPrompt: boolean;\n}\n\n/** Registration for a single discovered migration folder. */\nconst migrationEntry = (\n  migration: DiscoveredMigration,\n): NonNullable<MigrationsJson['generators']>[string] => {\n  const path = `./src/migrations/${migration.dir}/${migration.name}`;\n  return {\n    // A migration in a `v<version>` folder has already been claimed by that\n    // release; its version is the folder. One in `latest` is left for stamping.\n    ...(migration.dir !== LATEST_MIGRATIONS_DIR &&\n    isValidVersion(migration.dir.replace(/^v/, ''))\n      ? { version: migration.dir.replace(/^v/, '') }\n      : {}),\n    description: migration.description,\n    ...(migration.hasImplementation\n      ? { implementation: `${path}/migration` }\n      : {}),\n    ...(migration.hasPrompt ? { prompt: `${path}/prompt.md` } : {}),\n  };\n};\n\n/**\n * Assemble the plugin's `migrations.json` from its source pieces: the discovered\n * migration folders, the version sync entry, and the nx `packageJsonUpdates`.\n *\n * Deterministic — keys are sorted — so regenerating always yields the same file.\n *\n * @param pluginName the plugin package name the manifest is for\n * @param migrations migration folders discovered under `src/migrations`\n * @param packageJsonUpdates parsed `packageJsonUpdates.json`, if present\n */\nexport const assembleMigrations = (\n  pluginName: string,\n  migrations: DiscoveredMigration[],\n  packageJsonUpdates?: MigrationsJson['packageJsonUpdates'],\n): MigrationsJson => ({\n  $schema: MIGRATIONS_JSON_SCHEMA,\n  name: pluginName,\n  generators: sortObjectKeys({\n    [SYNC_VENDED_MIGRATION_KEY]: syncVendedMigrationEntry(),\n    ...Object.fromEntries(\n      migrations.map((migration) => [\n        migrationKey(migration.dir, migration.name),\n        migrationEntry(migration),\n      ]),\n    ),\n  }),\n  ...(packageJsonUpdates && Object.keys(packageJsonUpdates).length > 0\n    ? { packageJsonUpdates }\n    : {}),\n});\n"],"names":["isValidVersion","LATEST_MIGRATIONS_DIR","migrationKey","sortObjectKeys","MIGRATIONS_JSON_SCHEMA","SYNC_VENDED_MIGRATION_KEY","syncVendedMigrationEntry","description","implementation","everyMigration","migrationEntry","migration","path","dir","name","replace","version","hasImplementation","hasPrompt","prompt","assembleMigrations","pluginName","migrations","packageJsonUpdates","$schema","generators","Object","fromEntries","map","keys","length"],"mappings":"AAAA;;;CAGC,GAED,SACEA,cAAc,EACdC,qBAAqB,EACrBC,YAAY,QACP,0BAA0B;AACjC,SAASC,cAAc,QAAQ,cAAc;AAE7C;;;;;;;;;;;;;;;;;;CAkBC,GAED,iEAAiE,GACjE,OAAO,MAAMC,yBAAyB,gCAAgC;AAEtE,wDAAwD,GACxD,OAAO,MAAMC,4BAA4B,uBAAuB;AAEhE;;;;CAIC,GACD,OAAO,MAAMC,2BAA2B,IAE1B,CAAA;QACZC,aACE;QACFC,gBAAgB;QAChBC,gBAAgB;IAClB,CAAA,EAAG;AAgBH,2DAA2D,GAC3D,MAAMC,iBAAiB,CACrBC;IAEA,MAAMC,OAAO,CAAC,iBAAiB,EAAED,UAAUE,GAAG,CAAC,CAAC,EAAEF,UAAUG,IAAI,EAAE;IAClE,OAAO;QACL,wEAAwE;QACxE,4EAA4E;QAC5E,GAAIH,UAAUE,GAAG,KAAKZ,yBACtBD,eAAeW,UAAUE,GAAG,CAACE,OAAO,CAAC,MAAM,OACvC;YAAEC,SAASL,UAAUE,GAAG,CAACE,OAAO,CAAC,MAAM;QAAI,IAC3C,CAAC,CAAC;QACNR,aAAaI,UAAUJ,WAAW;QAClC,GAAII,UAAUM,iBAAiB,GAC3B;YAAET,gBAAgB,GAAGI,KAAK,UAAU,CAAC;QAAC,IACtC,CAAC,CAAC;QACN,GAAID,UAAUO,SAAS,GAAG;YAAEC,QAAQ,GAAGP,KAAK,UAAU,CAAC;QAAC,IAAI,CAAC,CAAC;IAChE;AACF;AAEA;;;;;;;;;CASC,GACD,OAAO,MAAMQ,qBAAqB,CAChCC,YACAC,YACAC,qBACoB,CAAA;QACpBC,SAASpB;QACTU,MAAMO;QACNI,YAAYtB,eAAe;YACzB,CAACE,0BAA0B,EAAEC;YAC7B,GAAGoB,OAAOC,WAAW,CACnBL,WAAWM,GAAG,CAAC,CAACjB,YAAc;oBAC5BT,aAAaS,UAAUE,GAAG,EAAEF,UAAUG,IAAI;oBAC1CJ,eAAeC;iBAChB,EACF;QACH;QACA,GAAIY,sBAAsBG,OAAOG,IAAI,CAACN,oBAAoBO,MAAM,GAAG,IAC/D;YAAEP;QAAmB,IACrB,CAAC,CAAC;IACR,CAAA,EAAG"}

package/src/utils/migration-versions.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { compare } from 'semver';
+/**
+ * Version stamping for migrations.
+ *
+ * A new migration is committed with no `version` — releases are calculated from
+ * conventional commits and written only to `dist/` and a git tag, so versions
+ * reach the published `migrations.json` two ways:
+ *
+ * - At release time (`scripts/stamp-migrations.ts`) entries still missing a
+ *   version are stamped into the compiled `migrations.json`: an already shipped
+ *   one gets the earliest release tag registering it, and a net-new one gets the
+ *   version the release is about to publish, which the release job passes in
+ *   after `nx release version` writes it to the dist manifests.
+ * - The weekly `update-versions` PR backfills the version of the release that
+ *   shipped each migration, moving and re-keying it accordingly
+ *   (`scripts/backfill-migration-versions.ts`), so source converges on the
+ *   versions of everything already released. `packageJsonUpdates` entries are
+ *   dated in place there too, since their keys never change.
+ *
+ * A version already in source always wins, so backfilled entries are stable.
+ *
+ * An entry marked `everyMigration: true` is never backfilled or pinned, and is
+ * re-stamped with each pending version, so it runs on every upgrade.
+ */
+export interface MigrationsJson {
+    $schema?: string;
+    name?: string;
+    generators?: Record<string, {
+        version?: string;
+        everyMigration?: boolean;
+    } & Record<string, unknown>>;
+    /**
+     * Declarative dependency bumps `nx migrate` applies to the root manifest.
+     * Keyed by what the bump targets rather than the release that ships it, so an
+     * entry is unique from the moment it is written and one release's bump can sit
+     * beside the next; nx itself gates on the entry's `version`.
+     */
+    packageJsonUpdates?: Record<string, {
+        version: string;
+    } & Record<string, unknown>>;
+}
+/** Ascending semver comparator for `Array.prototype.sort`. */
+export declare const compareVersions: typeof compare;
+/** Whether a string is an exact semver version. */
+export declare const isValidVersion: (version: string) => boolean;
+/**
+ * Map of entry key -> version of the earliest release that registers it, across
+ * both `generators` and `packageJsonUpdates`. Resolved only for the entries still
+ * missing a version (one already recorded in source wins, so its history doesn't
+ * need reading). An entry that hasn't been released is absent.
+ *
+ * Walks releases newest first and stops as soon as every entry is resolved: an
+ * entry that has disappeared from a release's `migrations.json` was first
+ * registered by the release after it, which is the one that shipped it.
+ *
+ * Both sections resolve the same way and share the walk, so the release doesn't
+ * read tag history twice. Keys can't collide: a migration is keyed by its own
+ * name, an nx bump by the nx version it moves to.
+ *
+ * @param migrations parsed source migrations.json
+ * @param versions released versions in descending semver order
+ * @param readReleasedMigrations reads the `migrations.json` published by a given
+ *   version, or undefined if it predates the manifest
+ */
+export declare const readShippedMigrationVersions: (migrations: MigrationsJson, versions: string[], readReleasedMigrations: (version: string) => MigrationsJson | undefined) => Record<string, string>;
+/**
+ * Return a copy of the migrations collection with a `version` stamped onto
+ * every generator entry, preserving any already present, and the pending version
+ * recorded on any `packageJsonUpdates` entry still holding `latest`.
+ *
+ * `nx migrate` sorts the run ascending by version and keeps the manifest's order
+ * among equal versions, so the order entries are emitted in is the run order
+ * within a release. Migrations sharing a version (a batch shipped together, or a
+ * whole `v<x.y.z>` folder replayed on a big version jump) are therefore ordered
+ * here by the commit that added them — an earlier-committed migration runs
+ * first — so a later migration can depend on an earlier one in the same batch.
+ * Every-migration entries are emitted last regardless, so they run after the
+ * release's own migrations (letting one add a dependency this then brings up to
+ * date). Entries with no rank fall back to the manifest's order, which
+ * `assembleMigrations` already sorts by key.
+ *
+ * @param migrations parsed migrations.json to stamp
+ * @param shippedVersions migration key -> version of the earliest release
+ *   tag that registers it (absent for migrations that haven't shipped)
+ * @param pendingVersion version the release is about to publish, stamped onto
+ *   unshipped migrations so their version is one that really shipped
+ * @param commitRanks migration key -> rank of the commit that added it (lower is
+ *   earlier); absent entries fall back to the manifest's order
+ */
+export declare const stampMigrationVersions: (migrations: MigrationsJson, shippedVersions: Record<string, string>, pendingVersion: string, commitRanks?: Record<string, number>) => MigrationsJson;
+/** Directory a newly scaffolded migration lands in, before a release claims it. */
+export declare const LATEST_MIGRATIONS_DIR = "latest";
+/** Directory holding the migrations shipped by a given release. */
+export declare const versionMigrationsDir: (version: string) => string;
+/**
+ * Key a migration is registered under in `migrations.json`. Prefixed with its
+ * directory so reusing a name in a later release can't silently overwrite the
+ * one that already shipped.
+ */
+export declare const migrationKey: (dir: string, name: string) => string;
+/**
+ * Format a 1-based order into the folder-name prefix that beds it in. Backfill
+ * prefixes a released migration's folder with its commit order within the
+ * release (`0001-foo`), so the folder name alone sorts a version's migrations
+ * into commit order — stamping doesn't have to re-read git for them.
+ */
+export declare const orderPrefix: (order: number) => string;
+/** A migration directory move the caller needs to make on disk. */
+export interface MigrationDirMove {
+    name: string;
+    version: string;
+    from: string;
+    to: string;
+}
+/**
+ * Record the release that shipped each migration on entries without a version,
+ * re-keying them and re-pointing their paths at that release's folder, and
+ * return the collection alongside the keys that changed and the directory moves
+ * to make on disk.
+ *
+ * A backfilled migration's new folder name is prefixed with its commit order
+ * within the release (`0001-foo`), so the folder layout beds in the order the
+ * release ran them: `assembleMigrations` sorts by key, so the prefix alone puts
+ * a version's migrations in commit order and stamping never has to re-read git
+ * for a released migration. Migrations sharing a commit (a squashed PR) fall
+ * back to alphabetical order, matching stamping.
+ *
+ * Unlike `stampMigrationVersions` this only records already-released versions,
+ * leaving the release to decide what a net-new migration gets.
+ *
+ * @param migrations parsed migrations.json to backfill
+ * @param shippedVersions migration key -> version of the earliest release tag
+ *   that registers it (absent for migrations that haven't shipped)
+ * @param commitRanks migration key -> rank of the commit that added it (lower is
+ *   earlier), used to order the migrations bedded into each release
+ */
+export declare const backfillMigrationVersions: (migrations: MigrationsJson, shippedVersions: Record<string, string>, commitRanks?: Record<string, number>) => {
+    migrations: MigrationsJson;
+    backfilled: string[];
+    moves: MigrationDirMove[];
+};

package/src/utils/migration-versions.js

@@ -0,0 +1,250 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */ import { compare, valid } from "semver";
+/** Ascending semver comparator for `Array.prototype.sort`. */ export const compareVersions = compare;
+/** Whether a string is an exact semver version. */ export const isValidVersion = (version)=>valid(version) !== null;
+/**
+ * Map of entry key -> version of the earliest release that registers it, across
+ * both `generators` and `packageJsonUpdates`. Resolved only for the entries still
+ * missing a version (one already recorded in source wins, so its history doesn't
+ * need reading). An entry that hasn't been released is absent.
+ *
+ * Walks releases newest first and stops as soon as every entry is resolved: an
+ * entry that has disappeared from a release's `migrations.json` was first
+ * registered by the release after it, which is the one that shipped it.
+ *
+ * Both sections resolve the same way and share the walk, so the release doesn't
+ * read tag history twice. Keys can't collide: a migration is keyed by its own
+ * name, an nx bump by the nx version it moves to.
+ *
+ * @param migrations parsed source migrations.json
+ * @param versions released versions in descending semver order
+ * @param readReleasedMigrations reads the `migrations.json` published by a given
+ *   version, or undefined if it predates the manifest
+ */ export const readShippedMigrationVersions = (migrations, versions, readReleasedMigrations)=>{
+    const shippedVersions = {};
+    // A `packageJsonUpdates` entry records `latest` rather than omitting its
+    // version, since nx requires the field.
+    let unresolved = [
+        ...Object.entries(migrations.generators ?? {}).filter(([, entry])=>!entry.version).map(([key])=>key),
+        ...Object.entries(migrations.packageJsonUpdates ?? {}).filter(([, entry])=>entry.version === LATEST_MIGRATIONS_DIR).map(([key])=>key)
+    ];
+    for (const version of versions){
+        if (unresolved.length === 0) {
+            break;
+        }
+        const released = readReleasedMigrations(version);
+        const registered = new Set([
+            ...Object.keys(released?.generators ?? {}),
+            ...Object.keys(released?.packageJsonUpdates ?? {})
+        ]);
+        // Entries gone at this release keep the version recorded from the release
+        // after it (if any) and stop being looked up.
+        unresolved = unresolved.filter((key)=>registered.has(key));
+        for (const key of unresolved){
+            shippedVersions[key] = version;
+        }
+    }
+    return shippedVersions;
+};
+/**
+ * Rank a migration ships under, lower running first. Unranked entries (no commit
+ * history for them, or an every-migration entry with no folder) sort after every
+ * ranked one, so a ranked migration always precedes an unranked peer.
+ */ const UNRANKED = Number.MAX_SAFE_INTEGER;
+/**
+ * Return a copy of the migrations collection with a `version` stamped onto
+ * every generator entry, preserving any already present, and the pending version
+ * recorded on any `packageJsonUpdates` entry still holding `latest`.
+ *
+ * `nx migrate` sorts the run ascending by version and keeps the manifest's order
+ * among equal versions, so the order entries are emitted in is the run order
+ * within a release. Migrations sharing a version (a batch shipped together, or a
+ * whole `v<x.y.z>` folder replayed on a big version jump) are therefore ordered
+ * here by the commit that added them — an earlier-committed migration runs
+ * first — so a later migration can depend on an earlier one in the same batch.
+ * Every-migration entries are emitted last regardless, so they run after the
+ * release's own migrations (letting one add a dependency this then brings up to
+ * date). Entries with no rank fall back to the manifest's order, which
+ * `assembleMigrations` already sorts by key.
+ *
+ * @param migrations parsed migrations.json to stamp
+ * @param shippedVersions migration key -> version of the earliest release
+ *   tag that registers it (absent for migrations that haven't shipped)
+ * @param pendingVersion version the release is about to publish, stamped onto
+ *   unshipped migrations so their version is one that really shipped
+ * @param commitRanks migration key -> rank of the commit that added it (lower is
+ *   earlier); absent entries fall back to the manifest's order
+ */ export const stampMigrationVersions = (migrations, shippedVersions, pendingVersion, commitRanks = {})=>({
+        ...migrations,
+        generators: Object.fromEntries(Object.entries(migrations.generators ?? {}).sort(([keyA, a], [keyB, b])=>{
+            const everyDiff = Number(a.everyMigration ?? false) - Number(b.everyMigration ?? false);
+            if (everyDiff !== 0) {
+                return everyDiff;
+            }
+            // Equal ranks (same commit, or both unranked) fall through to a stable
+            // sort, keeping the manifest's key order the assembly already imposed.
+            return (commitRanks[keyA] ?? UNRANKED) - (commitRanks[keyB] ?? UNRANKED);
+        }).map(([name, entry])=>{
+            // Source-only marker, stripped from what nx reads.
+            const { everyMigration, version: sourceVersion, ...published } = entry;
+            // Overrides any source version so it stays ahead of what is installed.
+            const version = everyMigration ? pendingVersion : sourceVersion ?? shippedVersions[name] ?? pendingVersion;
+            return [
+                name,
+                {
+                    version,
+                    ...published
+                }
+            ];
+        })),
+        ...migrations.packageJsonUpdates && {
+            packageJsonUpdates: stampPackageJsonUpdates(migrations.packageJsonUpdates, pendingVersion)
+        }
+    });
+/**
+ * Version any `packageJsonUpdates` entry still holding `latest` with the release
+ * about to publish it, so the nx bump ships under a version `nx migrate` gates on.
+ */ const stampPackageJsonUpdates = (packageJsonUpdates, pendingVersion)=>resolvePackageJsonUpdateVersions(packageJsonUpdates, ()=>pendingVersion);
+/** Directory a newly scaffolded migration lands in, before a release claims it. */ export const LATEST_MIGRATIONS_DIR = 'latest';
+/** Directory holding the migrations shipped by a given release. */ export const versionMigrationsDir = (version)=>`v${version}`;
+/**
+ * Key a migration is registered under in `migrations.json`. Prefixed with its
+ * directory so reusing a name in a later release can't silently overwrite the
+ * one that already shipped.
+ */ export const migrationKey = (dir, name)=>`${dir}-${name}`;
+const LATEST_KEY_PREFIX = `${LATEST_MIGRATIONS_DIR}-`;
+/** Digits in the zero-padded order prefix a bedded-in migration folder carries. */ const ORDER_PREFIX_WIDTH = 4;
+/**
+ * Format a 1-based order into the folder-name prefix that beds it in. Backfill
+ * prefixes a released migration's folder with its commit order within the
+ * release (`0001-foo`), so the folder name alone sorts a version's migrations
+ * into commit order — stamping doesn't have to re-read git for them.
+ */ export const orderPrefix = (order)=>String(order).padStart(ORDER_PREFIX_WIDTH, '0');
+/** The base migration name a `latest` key carries, without its folder prefix. */ const latestKeyName = (key)=>key.startsWith(LATEST_KEY_PREFIX) ? key.slice(LATEST_KEY_PREFIX.length) : key;
+/**
+ * Record the release that shipped each migration on entries without a version,
+ * re-keying them and re-pointing their paths at that release's folder, and
+ * return the collection alongside the keys that changed and the directory moves
+ * to make on disk.
+ *
+ * A backfilled migration's new folder name is prefixed with its commit order
+ * within the release (`0001-foo`), so the folder layout beds in the order the
+ * release ran them: `assembleMigrations` sorts by key, so the prefix alone puts
+ * a version's migrations in commit order and stamping never has to re-read git
+ * for a released migration. Migrations sharing a commit (a squashed PR) fall
+ * back to alphabetical order, matching stamping.
+ *
+ * Unlike `stampMigrationVersions` this only records already-released versions,
+ * leaving the release to decide what a net-new migration gets.
+ *
+ * @param migrations parsed migrations.json to backfill
+ * @param shippedVersions migration key -> version of the earliest release tag
+ *   that registers it (absent for migrations that haven't shipped)
+ * @param commitRanks migration key -> rank of the commit that added it (lower is
+ *   earlier), used to order the migrations bedded into each release
+ */ export const backfillMigrationVersions = (migrations, shippedVersions, commitRanks = {})=>{
+    const generators = {};
+    const backfilled = [];
+    const moves = [];
+    // Reported alongside the migrations so the update's PR says an nx bump was
+    // dated, and so the caller knows there is something to commit.
+    const backfilledUpdates = Object.entries(migrations.packageJsonUpdates ?? {}).filter(([key, entry])=>entry.version === LATEST_MIGRATIONS_DIR && shippedVersions[key]).map(([key])=>key);
+    const toBackfill = Object.entries(migrations.generators ?? {}).filter(// Pinning an every-migration entry would stop it running on later upgrades.
+    ([key, entry])=>!entry.version && !entry.everyMigration && shippedVersions[key]);
+    // The order prefix is a migration's position within its release, so number
+    // each version's migrations together, in commit order (alphabetical among a
+    // shared commit). All of a release's migrations are backfilled in one run —
+    // they sat in `latest` until it shipped — so a version is numbered from 1 here.
+    const orderByKey = new Map();
+    const byVersion = new Map();
+    for (const [key] of toBackfill){
+        const version = shippedVersions[key];
+        const keys = byVersion.get(version) ?? [];
+        keys.push(key);
+        byVersion.set(version, keys);
+    }
+    for (const keys of byVersion.values()){
+        const ordered = keys.sort((a, b)=>{
+            const rankDiff = (commitRanks[a] ?? Number.MAX_SAFE_INTEGER) - (commitRanks[b] ?? Number.MAX_SAFE_INTEGER);
+            return rankDiff !== 0 ? rankDiff : latestKeyName(a).localeCompare(latestKeyName(b));
+        });
+        ordered.forEach((key, index)=>{
+            orderByKey.set(key, index + 1);
+        });
+    }
+    for (const [key, entry] of Object.entries(migrations.generators ?? {})){
+        const version = shippedVersions[key];
+        if (entry.version || !version || entry.everyMigration) {
+            generators[key] = entry;
+            continue;
+        }
+        const name = latestKeyName(key);
+        // The commit-order prefix beds the run order into the folder name.
+        const prefixedName = `${orderPrefix(orderByKey.get(key) ?? 1)}-${name}`;
+        const versionDir = versionMigrationsDir(version);
+        const latestSegment = `/${LATEST_MIGRATIONS_DIR}/${name}/`;
+        const versionSegment = `/${versionDir}/${prefixedName}/`;
+        // Re-point each path field at the version folder, recording the move the
+        // caller needs to make on disk the first time one is found.
+        const repointed = {};
+        let moved = false;
+        for (const [field, value] of Object.entries(entry)){
+            if (typeof value !== 'string' || !value.includes(latestSegment)) {
+                repointed[field] = value;
+                continue;
+            }
+            repointed[field] = value.replace(latestSegment, versionSegment);
+            if (!moved) {
+                moved = true;
+                const dir = value.slice(0, value.indexOf(latestSegment));
+                moves.push({
+                    name,
+                    version,
+                    from: `${dir}${latestSegment}`.replace(/^\.\/|\/$/g, ''),
+                    to: `${dir}${versionSegment}`.replace(/^\.\/|\/$/g, '')
+                });
+            }
+        }
+        generators[migrationKey(versionDir, prefixedName)] = {
+            version,
+            ...repointed
+        };
+        backfilled.push(key);
+    }
+    return {
+        migrations: {
+            ...migrations,
+            generators,
+            ...migrations.packageJsonUpdates && {
+                packageJsonUpdates: resolvePackageJsonUpdateVersions(migrations.packageJsonUpdates, (key)=>shippedVersions[key])
+            }
+        },
+        backfilled: [
+            ...backfilled,
+            ...backfilledUpdates
+        ],
+        moves
+    };
+};
+/**
+ * Record the version each `packageJsonUpdates` entry ships under, for those still
+ * holding `latest`.
+ *
+ * The key already identifies the entry — an nx bump is named for the nx version
+ * it moves to — so only the `version` field changes. Nothing is re-keyed, which
+ * is what lets one release's bump sit alongside the next without either being
+ * overwritten before it ships.
+ */ const resolvePackageJsonUpdateVersions = (packageJsonUpdates, resolve)=>Object.fromEntries(Object.entries(packageJsonUpdates).map(([key, entry])=>{
+        const version = entry.version === LATEST_MIGRATIONS_DIR ? resolve(key) : undefined;
+        return [
+            key,
+            version ? {
+                ...entry,
+                version
+            } : entry
+        ];
+    }));
+
+//# sourceMappingURL=migration-versions.js.map

package/src/utils/migration-versions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../packages/nx-plugin/src/utils/migration-versions.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\nimport { compare, valid } from 'semver';\n\n/**\n * Version stamping for migrations.\n *\n * A new migration is committed with no `version` — releases are calculated from\n * conventional commits and written only to `dist/` and a git tag, so versions\n * reach the published `migrations.json` two ways:\n *\n * - At release time (`scripts/stamp-migrations.ts`) entries still missing a\n *   version are stamped into the compiled `migrations.json`: an already shipped\n *   one gets the earliest release tag registering it, and a net-new one gets the\n *   version the release is about to publish, which the release job passes in\n *   after `nx release version` writes it to the dist manifests.\n * - The weekly `update-versions` PR backfills the version of the release that\n *   shipped each migration, moving and re-keying it accordingly\n *   (`scripts/backfill-migration-versions.ts`), so source converges on the\n *   versions of everything already released. `packageJsonUpdates` entries are\n *   dated in place there too, since their keys never change.\n *\n * A version already in source always wins, so backfilled entries are stable.\n *\n * An entry marked `everyMigration: true` is never backfilled or pinned, and is\n * re-stamped with each pending version, so it runs on every upgrade.\n */\n\nexport interface MigrationsJson {\n  $schema?: string;\n  name?: string;\n  generators?: Record<\n    string,\n    { version?: string; everyMigration?: boolean } & Record<string, unknown>\n  >;\n  /**\n   * Declarative dependency bumps `nx migrate` applies to the root manifest.\n   * Keyed by what the bump targets rather than the release that ships it, so an\n   * entry is unique from the moment it is written and one release's bump can sit\n   * beside the next; nx itself gates on the entry's `version`.\n   */\n  packageJsonUpdates?: Record<\n    string,\n    { version: string } & Record<string, unknown>\n  >;\n}\n\n/** Ascending semver comparator for `Array.prototype.sort`. */\nexport const compareVersions = compare;\n\n/** Whether a string is an exact semver version. */\nexport const isValidVersion = (version: string): boolean =>\n  valid(version) !== null;\n\n/**\n * Map of entry key -> version of the earliest release that registers it, across\n * both `generators` and `packageJsonUpdates`. Resolved only for the entries still\n * missing a version (one already recorded in source wins, so its history doesn't\n * need reading). An entry that hasn't been released is absent.\n *\n * Walks releases newest first and stops as soon as every entry is resolved: an\n * entry that has disappeared from a release's `migrations.json` was first\n * registered by the release after it, which is the one that shipped it.\n *\n * Both sections resolve the same way and share the walk, so the release doesn't\n * read tag history twice. Keys can't collide: a migration is keyed by its own\n * name, an nx bump by the nx version it moves to.\n *\n * @param migrations parsed source migrations.json\n * @param versions released versions in descending semver order\n * @param readReleasedMigrations reads the `migrations.json` published by a given\n *   version, or undefined if it predates the manifest\n */\nexport const readShippedMigrationVersions = (\n  migrations: MigrationsJson,\n  versions: string[],\n  readReleasedMigrations: (version: string) => MigrationsJson | undefined,\n): Record<string, string> => {\n  const shippedVersions: Record<string, string> = {};\n  // A `packageJsonUpdates` entry records `latest` rather than omitting its\n  // version, since nx requires the field.\n  let unresolved = [\n    ...Object.entries(migrations.generators ?? {})\n      .filter(([, entry]) => !entry.version)\n      .map(([key]) => key),\n    ...Object.entries(migrations.packageJsonUpdates ?? {})\n      .filter(([, entry]) => entry.version === LATEST_MIGRATIONS_DIR)\n      .map(([key]) => key),\n  ];\n\n  for (const version of versions) {\n    if (unresolved.length === 0) {\n      break;\n    }\n    const released = readReleasedMigrations(version);\n    const registered = new Set([\n      ...Object.keys(released?.generators ?? {}),\n      ...Object.keys(released?.packageJsonUpdates ?? {}),\n    ]);\n    // Entries gone at this release keep the version recorded from the release\n    // after it (if any) and stop being looked up.\n    unresolved = unresolved.filter((key) => registered.has(key));\n    for (const key of unresolved) {\n      shippedVersions[key] = version;\n    }\n  }\n\n  return shippedVersions;\n};\n\n/**\n * Rank a migration ships under, lower running first. Unranked entries (no commit\n * history for them, or an every-migration entry with no folder) sort after every\n * ranked one, so a ranked migration always precedes an unranked peer.\n */\nconst UNRANKED = Number.MAX_SAFE_INTEGER;\n\n/**\n * Return a copy of the migrations collection with a `version` stamped onto\n * every generator entry, preserving any already present, and the pending version\n * recorded on any `packageJsonUpdates` entry still holding `latest`.\n *\n * `nx migrate` sorts the run ascending by version and keeps the manifest's order\n * among equal versions, so the order entries are emitted in is the run order\n * within a release. Migrations sharing a version (a batch shipped together, or a\n * whole `v<x.y.z>` folder replayed on a big version jump) are therefore ordered\n * here by the commit that added them — an earlier-committed migration runs\n * first — so a later migration can depend on an earlier one in the same batch.\n * Every-migration entries are emitted last regardless, so they run after the\n * release's own migrations (letting one add a dependency this then brings up to\n * date). Entries with no rank fall back to the manifest's order, which\n * `assembleMigrations` already sorts by key.\n *\n * @param migrations parsed migrations.json to stamp\n * @param shippedVersions migration key -> version of the earliest release\n *   tag that registers it (absent for migrations that haven't shipped)\n * @param pendingVersion version the release is about to publish, stamped onto\n *   unshipped migrations so their version is one that really shipped\n * @param commitRanks migration key -> rank of the commit that added it (lower is\n *   earlier); absent entries fall back to the manifest's order\n */\nexport const stampMigrationVersions = (\n  migrations: MigrationsJson,\n  shippedVersions: Record<string, string>,\n  pendingVersion: string,\n  commitRanks: Record<string, number> = {},\n): MigrationsJson => ({\n  ...migrations,\n  generators: Object.fromEntries(\n    Object.entries(migrations.generators ?? {})\n      .sort(([keyA, a], [keyB, b]) => {\n        const everyDiff =\n          Number(a.everyMigration ?? false) - Number(b.everyMigration ?? false);\n        if (everyDiff !== 0) {\n          return everyDiff;\n        }\n        // Equal ranks (same commit, or both unranked) fall through to a stable\n        // sort, keeping the manifest's key order the assembly already imposed.\n        return (\n          (commitRanks[keyA] ?? UNRANKED) - (commitRanks[keyB] ?? UNRANKED)\n        );\n      })\n      .map(([name, entry]) => {\n        // Source-only marker, stripped from what nx reads.\n        const { everyMigration, version: sourceVersion, ...published } = entry;\n        // Overrides any source version so it stays ahead of what is installed.\n        const version = everyMigration\n          ? pendingVersion\n          : (sourceVersion ?? shippedVersions[name] ?? pendingVersion);\n        return [name, { version, ...published }];\n      }),\n  ),\n  ...(migrations.packageJsonUpdates && {\n    packageJsonUpdates: stampPackageJsonUpdates(\n      migrations.packageJsonUpdates,\n      pendingVersion,\n    ),\n  }),\n});\n\n/**\n * Version any `packageJsonUpdates` entry still holding `latest` with the release\n * about to publish it, so the nx bump ships under a version `nx migrate` gates on.\n */\nconst stampPackageJsonUpdates = (\n  packageJsonUpdates: NonNullable<MigrationsJson['packageJsonUpdates']>,\n  pendingVersion: string,\n): NonNullable<MigrationsJson['packageJsonUpdates']> =>\n  resolvePackageJsonUpdateVersions(packageJsonUpdates, () => pendingVersion);\n\n/** Directory a newly scaffolded migration lands in, before a release claims it. */\nexport const LATEST_MIGRATIONS_DIR = 'latest';\n\n/** Directory holding the migrations shipped by a given release. */\nexport const versionMigrationsDir = (version: string) => `v${version}`;\n\n/**\n * Key a migration is registered under in `migrations.json`. Prefixed with its\n * directory so reusing a name in a later release can't silently overwrite the\n * one that already shipped.\n */\nexport const migrationKey = (dir: string, name: string) => `${dir}-${name}`;\n\nconst LATEST_KEY_PREFIX = `${LATEST_MIGRATIONS_DIR}-`;\n\n/** Digits in the zero-padded order prefix a bedded-in migration folder carries. */\nconst ORDER_PREFIX_WIDTH = 4;\n\n/**\n * Format a 1-based order into the folder-name prefix that beds it in. Backfill\n * prefixes a released migration's folder with its commit order within the\n * release (`0001-foo`), so the folder name alone sorts a version's migrations\n * into commit order — stamping doesn't have to re-read git for them.\n */\nexport const orderPrefix = (order: number): string =>\n  String(order).padStart(ORDER_PREFIX_WIDTH, '0');\n\n/** A migration directory move the caller needs to make on disk. */\nexport interface MigrationDirMove {\n  name: string;\n  version: string;\n  from: string;\n  to: string;\n}\n\n/** The base migration name a `latest` key carries, without its folder prefix. */\nconst latestKeyName = (key: string): string =>\n  key.startsWith(LATEST_KEY_PREFIX) ? key.slice(LATEST_KEY_PREFIX.length) : key;\n\n/**\n * Record the release that shipped each migration on entries without a version,\n * re-keying them and re-pointing their paths at that release's folder, and\n * return the collection alongside the keys that changed and the directory moves\n * to make on disk.\n *\n * A backfilled migration's new folder name is prefixed with its commit order\n * within the release (`0001-foo`), so the folder layout beds in the order the\n * release ran them: `assembleMigrations` sorts by key, so the prefix alone puts\n * a version's migrations in commit order and stamping never has to re-read git\n * for a released migration. Migrations sharing a commit (a squashed PR) fall\n * back to alphabetical order, matching stamping.\n *\n * Unlike `stampMigrationVersions` this only records already-released versions,\n * leaving the release to decide what a net-new migration gets.\n *\n * @param migrations parsed migrations.json to backfill\n * @param shippedVersions migration key -> version of the earliest release tag\n *   that registers it (absent for migrations that haven't shipped)\n * @param commitRanks migration key -> rank of the commit that added it (lower is\n *   earlier), used to order the migrations bedded into each release\n */\nexport const backfillMigrationVersions = (\n  migrations: MigrationsJson,\n  shippedVersions: Record<string, string>,\n  commitRanks: Record<string, number> = {},\n): {\n  migrations: MigrationsJson;\n  backfilled: string[];\n  moves: MigrationDirMove[];\n} => {\n  const generators: NonNullable<MigrationsJson['generators']> = {};\n  const backfilled: string[] = [];\n  const moves: MigrationDirMove[] = [];\n  // Reported alongside the migrations so the update's PR says an nx bump was\n  // dated, and so the caller knows there is something to commit.\n  const backfilledUpdates = Object.entries(migrations.packageJsonUpdates ?? {})\n    .filter(\n      ([key, entry]) =>\n        entry.version === LATEST_MIGRATIONS_DIR && shippedVersions[key],\n    )\n    .map(([key]) => key);\n\n  const toBackfill = Object.entries(migrations.generators ?? {}).filter(\n    // Pinning an every-migration entry would stop it running on later upgrades.\n    ([key, entry]) =>\n      !entry.version && !entry.everyMigration && shippedVersions[key],\n  );\n\n  // The order prefix is a migration's position within its release, so number\n  // each version's migrations together, in commit order (alphabetical among a\n  // shared commit). All of a release's migrations are backfilled in one run —\n  // they sat in `latest` until it shipped — so a version is numbered from 1 here.\n  const orderByKey = new Map<string, number>();\n  const byVersion = new Map<string, string[]>();\n  for (const [key] of toBackfill) {\n    const version = shippedVersions[key];\n    const keys = byVersion.get(version) ?? [];\n    keys.push(key);\n    byVersion.set(version, keys);\n  }\n  for (const keys of byVersion.values()) {\n    const ordered = keys.sort((a, b) => {\n      const rankDiff =\n        (commitRanks[a] ?? Number.MAX_SAFE_INTEGER) -\n        (commitRanks[b] ?? Number.MAX_SAFE_INTEGER);\n      return rankDiff !== 0\n        ? rankDiff\n        : latestKeyName(a).localeCompare(latestKeyName(b));\n    });\n    ordered.forEach((key, index) => {\n      orderByKey.set(key, index + 1);\n    });\n  }\n\n  for (const [key, entry] of Object.entries(migrations.generators ?? {})) {\n    const version = shippedVersions[key];\n    if (entry.version || !version || entry.everyMigration) {\n      generators[key] = entry;\n      continue;\n    }\n\n    const name = latestKeyName(key);\n    // The commit-order prefix beds the run order into the folder name.\n    const prefixedName = `${orderPrefix(orderByKey.get(key) ?? 1)}-${name}`;\n    const versionDir = versionMigrationsDir(version);\n    const latestSegment = `/${LATEST_MIGRATIONS_DIR}/${name}/`;\n    const versionSegment = `/${versionDir}/${prefixedName}/`;\n\n    // Re-point each path field at the version folder, recording the move the\n    // caller needs to make on disk the first time one is found.\n    const repointed: Record<string, unknown> = {};\n    let moved = false;\n    for (const [field, value] of Object.entries(entry)) {\n      if (typeof value !== 'string' || !value.includes(latestSegment)) {\n        repointed[field] = value;\n        continue;\n      }\n      repointed[field] = value.replace(latestSegment, versionSegment);\n      if (!moved) {\n        moved = true;\n        const dir = value.slice(0, value.indexOf(latestSegment));\n        moves.push({\n          name,\n          version,\n          from: `${dir}${latestSegment}`.replace(/^\\.\\/|\\/$/g, ''),\n          to: `${dir}${versionSegment}`.replace(/^\\.\\/|\\/$/g, ''),\n        });\n      }\n    }\n\n    generators[migrationKey(versionDir, prefixedName)] = {\n      version,\n      ...repointed,\n    };\n    backfilled.push(key);\n  }\n\n  return {\n    migrations: {\n      ...migrations,\n      generators,\n      ...(migrations.packageJsonUpdates && {\n        packageJsonUpdates: resolvePackageJsonUpdateVersions(\n          migrations.packageJsonUpdates,\n          (key) => shippedVersions[key],\n        ),\n      }),\n    },\n    backfilled: [...backfilled, ...backfilledUpdates],\n    moves,\n  };\n};\n\n/**\n * Record the version each `packageJsonUpdates` entry ships under, for those still\n * holding `latest`.\n *\n * The key already identifies the entry — an nx bump is named for the nx version\n * it moves to — so only the `version` field changes. Nothing is re-keyed, which\n * is what lets one release's bump sit alongside the next without either being\n * overwritten before it ships.\n */\nconst resolvePackageJsonUpdateVersions = (\n  packageJsonUpdates: NonNullable<MigrationsJson['packageJsonUpdates']>,\n  resolve: (key: string) => string | undefined,\n): NonNullable<MigrationsJson['packageJsonUpdates']> =>\n  Object.fromEntries(\n    Object.entries(packageJsonUpdates).map(([key, entry]) => {\n      const version =\n        entry.version === LATEST_MIGRATIONS_DIR ? resolve(key) : undefined;\n      return [key, version ? { ...entry, version } : entry];\n    }),\n  );\n"],"names":["compare","valid","compareVersions","isValidVersion","version","readShippedMigrationVersions","migrations","versions","readReleasedMigrations","shippedVersions","unresolved","Object","entries","generators","filter","entry","map","key","packageJsonUpdates","LATEST_MIGRATIONS_DIR","length","released","registered","Set","keys","has","UNRANKED","Number","MAX_SAFE_INTEGER","stampMigrationVersions","pendingVersion","commitRanks","fromEntries","sort","keyA","a","keyB","b","everyDiff","everyMigration","name","sourceVersion","published","stampPackageJsonUpdates","resolvePackageJsonUpdateVersions","versionMigrationsDir","migrationKey","dir","LATEST_KEY_PREFIX","ORDER_PREFIX_WIDTH","orderPrefix","order","String","padStart","latestKeyName","startsWith","slice","backfillMigrationVersions","backfilled","moves","backfilledUpdates","toBackfill","orderByKey","Map","byVersion","get","push","set","values","ordered","rankDiff","localeCompare","forEach","index","prefixedName","versionDir","latestSegment","versionSegment","repointed","moved","field","value","includes","replace","indexOf","from","to","resolve","undefined"],"mappings":"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"}

package/src/utils/mock-project-graph.js

@@ -1,10 +1,7 @@
-"use strict";
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
+ */ /**
  * Mock createProjectGraphAsync to avoid expensive project graph building in tests.
  *
  * This is the vitest equivalent of Nx's own internal testing utility:
@@ -15,13 +12,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * 2. @nx/devkit's exports are wrapped with read-only getters by vitest
  * 3. The CJS module at nx/src/project-graph/project-graph.js is the actual
  *    implementation that @nx/devkit re-exports
- */
-const module_1 = require("module");
-// @ts-expect-error test utility used by vite only
-const _require = (0, module_1.createRequire)(import.meta.url);
+ */ import { createRequire } from "module";
+const _require = createRequire(import.meta.url);
 const projectGraph = _require('nx/src/project-graph/project-graph');
-projectGraph.createProjectGraphAsync = async () => ({
-    nodes: {},
-    dependencies: {},
-});
+projectGraph.createProjectGraphAsync = async ()=>({
+        nodes: {},
+        dependencies: {}
+    });
+
 //# sourceMappingURL=mock-project-graph.js.map

package/src/utils/mock-project-graph.js.map

@@ -1 +1 @@
-{"version":3,"file":"mock-project-graph.js","sourceRoot":"","sources":["../../../../../packages/nx-plugin/src/utils/mock-project-graph.ts"],"names":[],"mappings":";AAAA;;;GAGG;;AAEH;;;;;;;;;;;GAWG;AACH,mCAAuC;AAEvC,kDAAkD;AAClD,MAAM,QAAQ,GAAG,IAAA,sBAAa,EAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAChD,MAAM,YAAY,GAAG,QAAQ,CAAC,oCAAoC,CAAC,CAAC;AACpE,YAAY,CAAC,uBAAuB,GAAG,KAAK,IAAI,EAAE,CAAC,CAAC;IAClD,KAAK,EAAE,EAAE;IACT,YAAY,EAAE,EAAE;CACjB,CAAC,CAAC"}
+{"version":3,"sources":["../../../../../packages/nx-plugin/src/utils/mock-project-graph.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\n\n/**\n * Mock createProjectGraphAsync to avoid expensive project graph building in tests.\n *\n * This is the vitest equivalent of Nx's own internal testing utility:\n * https://github.com/nrwl/nx/blob/master/packages/nx/src/internal-testing-utils/mock-project-graph.ts\n *\n * We patch the underlying nx module directly because:\n * 1. vitest's vi.mock only affects ESM imports within the test file\n * 2. @nx/devkit's exports are wrapped with read-only getters by vitest\n * 3. The CJS module at nx/src/project-graph/project-graph.js is the actual\n *    implementation that @nx/devkit re-exports\n */\nimport { createRequire } from 'module';\n\nconst _require = createRequire(import.meta.url);\nconst projectGraph = _require('nx/src/project-graph/project-graph');\nprojectGraph.createProjectGraphAsync = async () => ({\n  nodes: {},\n  dependencies: {},\n});\n"],"names":["createRequire","_require","url","projectGraph","createProjectGraphAsync","nodes","dependencies"],"mappings":"AAAA;;;CAGC,GAED;;;;;;;;;;;CAWC,GACD,SAASA,aAAa,QAAQ,SAAS;AAEvC,MAAMC,WAAWD,cAAc,YAAYE,GAAG;AAC9C,MAAMC,eAAeF,SAAS;AAC9BE,aAAaC,uBAAuB,GAAG,UAAa,CAAA;QAClDC,OAAO,CAAC;QACRC,cAAc,CAAC;IACjB,CAAA"}