@aws/nx-plugin 1.0.0-rc.6 → 1.0.0-rc.60

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

@@ -0,0 +1,116 @@
+/**
+ * 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`.
+ *
+ * @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
+ */
+export declare const stampMigrationVersions: (migrations: MigrationsJson, shippedVersions: Record<string, string>, pendingVersion: string) => 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;
+/** 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.
+ *
+ * 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)
+ */
+export declare const backfillMigrationVersions: (migrations: MigrationsJson, shippedVersions: Record<string, string>) => {
+    migrations: MigrationsJson;
+    backfilled: string[];
+    moves: MigrationDirMove[];
+};

package/src/utils/migration-versions.js

@@ -0,0 +1,186 @@
+/**
+ * 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;
+};
+/**
+ * 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`.
+ *
+ * @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
+ */ export const stampMigrationVersions = (migrations, shippedVersions, pendingVersion)=>({
+        ...migrations,
+        generators: Object.fromEntries(// `nx migrate` sorts the run ascending by version and preserves the
+        // manifest's order among equal versions, so emitting the every-migration
+        // entries last is what makes them run after the release's own migrations.
+        Object.entries(migrations.generators ?? {}).sort(([, a], [, b])=>Number(a.everyMigration ?? false) - Number(b.everyMigration ?? false)).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}-`;
+/**
+ * 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.
+ *
+ * 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)
+ */ export const backfillMigrationVersions = (migrations, shippedVersions)=>{
+    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);
+    for (const [key, entry] of Object.entries(migrations.generators ?? {})){
+        const version = shippedVersions[key];
+        // Pinning an every-migration entry would stop it running on later upgrades.
+        if (entry.version || !version || entry.everyMigration) {
+            generators[key] = entry;
+            continue;
+        }
+        const name = key.startsWith(LATEST_KEY_PREFIX) ? key.slice(LATEST_KEY_PREFIX.length) : key;
+        const versionDir = versionMigrationsDir(version);
+        const latestSegment = `/${LATEST_MIGRATIONS_DIR}/${name}/`;
+        const versionSegment = `/${versionDir}/${name}/`;
+        // 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, name)] = {
+            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 * 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 * @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 */\nexport const stampMigrationVersions = (\n  migrations: MigrationsJson,\n  shippedVersions: Record<string, string>,\n  pendingVersion: string,\n): MigrationsJson => ({\n  ...migrations,\n  generators: Object.fromEntries(\n    // `nx migrate` sorts the run ascending by version and preserves the\n    // manifest's order among equal versions, so emitting the every-migration\n    // entries last is what makes them run after the release's own migrations.\n    Object.entries(migrations.generators ?? {})\n      .sort(\n        ([, a], [, b]) =>\n          Number(a.everyMigration ?? false) - Number(b.everyMigration ?? false),\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/** 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/**\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 * 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 */\nexport const backfillMigrationVersions = (\n  migrations: MigrationsJson,\n  shippedVersions: Record<string, string>,\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  for (const [key, entry] of Object.entries(migrations.generators ?? {})) {\n    const version = shippedVersions[key];\n    // Pinning an every-migration entry would stop it running on later upgrades.\n    if (entry.version || !version || entry.everyMigration) {\n      generators[key] = entry;\n      continue;\n    }\n\n    const name = key.startsWith(LATEST_KEY_PREFIX)\n      ? key.slice(LATEST_KEY_PREFIX.length)\n      : key;\n    const versionDir = versionMigrationsDir(version);\n    const latestSegment = `/${LATEST_MIGRATIONS_DIR}/${name}/`;\n    const versionSegment = `/${versionDir}/${name}/`;\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, name)] = { version, ...repointed };\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","stampMigrationVersions","pendingVersion","fromEntries","sort","a","b","Number","everyMigration","name","sourceVersion","published","stampPackageJsonUpdates","resolvePackageJsonUpdateVersions","versionMigrationsDir","migrationKey","dir","LATEST_KEY_PREFIX","backfillMigrationVersions","backfilled","moves","backfilledUpdates","startsWith","slice","versionDir","latestSegment","versionSegment","repointed","moved","field","value","includes","replace","indexOf","push","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"}

package/src/utils/module-format.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type Tree } from '@nx/devkit';
+/**
+ * The module format for generated TypeScript code and configuration.
+ */
+export type ModuleFormat = 'esm' | 'cjs';
+/**
+ * Whether the workspace targets ES modules, read from the tree so shared
+ * helpers needn't thread it through call sites. An explicit root `type` wins
+ * (`module`/`commonjs`); when absent (e.g. an adopted Nx workspace) infer ESM
+ * from any sibling project declaring `type: "module"`, else CJS. No root
+ * package.json defaults to ESM.
+ */
+export declare const isEsmWorkspace: (tree: Tree) => boolean;
+/**
+ * Returns the `esm` template variable for `generateFiles` substitutions,
+ * inferred from the workspace root package.json. Spread into the substitution
+ * object wherever a template contains `<% if (esm) { %>` conditionals.
+ */
+export declare const esmVars: (tree: Tree) => {
+    esm: boolean;
+};

package/src/utils/module-format.js

@@ -0,0 +1,45 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */ import { getProjects, joinPathFragments, readJson } from "@nx/devkit";
+/**
+ * Whether the workspace targets ES modules, read from the tree so shared
+ * helpers needn't thread it through call sites. An explicit root `type` wins
+ * (`module`/`commonjs`); when absent (e.g. an adopted Nx workspace) infer ESM
+ * from any sibling project declaring `type: "module"`, else CJS. No root
+ * package.json defaults to ESM.
+ */ export const isEsmWorkspace = (tree)=>{
+    if (!tree.exists('package.json')) {
+        return true;
+    }
+    const rootType = readJson(tree, 'package.json').type;
+    if (rootType === 'module') {
+        return true;
+    }
+    if (rootType === 'commonjs') {
+        return false;
+    }
+    // Root `type` is absent: infer from sibling projects' own manifests.
+    return hasEsmProject(tree);
+};
+/** Whether any non-root project declares `type: "module"` in its own manifest. */ const hasEsmProject = (tree)=>{
+    for (const project of getProjects(tree).values()){
+        if (project.root === '.' || project.root === '') {
+            continue;
+        }
+        const packageJsonPath = joinPathFragments(project.root, 'package.json');
+        if (tree.exists(packageJsonPath) && readJson(tree, packageJsonPath).type === 'module') {
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * Returns the `esm` template variable for `generateFiles` substitutions,
+ * inferred from the workspace root package.json. Spread into the substitution
+ * object wherever a template contains `<% if (esm) { %>` conditionals.
+ */ export const esmVars = (tree)=>({
+        esm: isEsmWorkspace(tree)
+    });
+
+//# sourceMappingURL=module-format.js.map

package/src/utils/module-format.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../packages/nx-plugin/src/utils/module-format.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\nimport {\n  getProjects,\n  joinPathFragments,\n  readJson,\n  type Tree,\n} from '@nx/devkit';\n\n/**\n * The module format for generated TypeScript code and configuration.\n */\nexport type ModuleFormat = 'esm' | 'cjs';\n\n/**\n * Whether the workspace targets ES modules, read from the tree so shared\n * helpers needn't thread it through call sites. An explicit root `type` wins\n * (`module`/`commonjs`); when absent (e.g. an adopted Nx workspace) infer ESM\n * from any sibling project declaring `type: \"module\"`, else CJS. No root\n * package.json defaults to ESM.\n */\nexport const isEsmWorkspace = (tree: Tree): boolean => {\n  if (!tree.exists('package.json')) {\n    return true;\n  }\n  const rootType = readJson(tree, 'package.json').type;\n  if (rootType === 'module') {\n    return true;\n  }\n  if (rootType === 'commonjs') {\n    return false;\n  }\n  // Root `type` is absent: infer from sibling projects' own manifests.\n  return hasEsmProject(tree);\n};\n\n/** Whether any non-root project declares `type: \"module\"` in its own manifest. */\nconst hasEsmProject = (tree: Tree): boolean => {\n  for (const project of getProjects(tree).values()) {\n    if (project.root === '.' || project.root === '') {\n      continue;\n    }\n    const packageJsonPath = joinPathFragments(project.root, 'package.json');\n    if (\n      tree.exists(packageJsonPath) &&\n      readJson(tree, packageJsonPath).type === 'module'\n    ) {\n      return true;\n    }\n  }\n  return false;\n};\n\n/**\n * Returns the `esm` template variable for `generateFiles` substitutions,\n * inferred from the workspace root package.json. Spread into the substitution\n * object wherever a template contains `<% if (esm) { %>` conditionals.\n */\nexport const esmVars = (tree: Tree): { esm: boolean } => ({\n  esm: isEsmWorkspace(tree),\n});\n"],"names":["getProjects","joinPathFragments","readJson","isEsmWorkspace","tree","exists","rootType","type","hasEsmProject","project","values","root","packageJsonPath","esmVars","esm"],"mappings":"AAAA;;;CAGC,GACD,SACEA,WAAW,EACXC,iBAAiB,EACjBC,QAAQ,QAEH,aAAa;AAOpB;;;;;;CAMC,GACD,OAAO,MAAMC,iBAAiB,CAACC;IAC7B,IAAI,CAACA,KAAKC,MAAM,CAAC,iBAAiB;QAChC,OAAO;IACT;IACA,MAAMC,WAAWJ,SAASE,MAAM,gBAAgBG,IAAI;IACpD,IAAID,aAAa,UAAU;QACzB,OAAO;IACT;IACA,IAAIA,aAAa,YAAY;QAC3B,OAAO;IACT;IACA,qEAAqE;IACrE,OAAOE,cAAcJ;AACvB,EAAE;AAEF,gFAAgF,GAChF,MAAMI,gBAAgB,CAACJ;IACrB,KAAK,MAAMK,WAAWT,YAAYI,MAAMM,MAAM,GAAI;QAChD,IAAID,QAAQE,IAAI,KAAK,OAAOF,QAAQE,IAAI,KAAK,IAAI;YAC/C;QACF;QACA,MAAMC,kBAAkBX,kBAAkBQ,QAAQE,IAAI,EAAE;QACxD,IACEP,KAAKC,MAAM,CAACO,oBACZV,SAASE,MAAMQ,iBAAiBL,IAAI,KAAK,UACzC;YACA,OAAO;QACT;IACF;IACA,OAAO;AACT;AAEA;;;;CAIC,GACD,OAAO,MAAMM,UAAU,CAACT,OAAkC,CAAA;QACxDU,KAAKX,eAAeC;IACtB,CAAA,EAAG"}

package/src/utils/names.d.ts

@@ -1,3 +1,9 @@
+/**
+ * camelCase that first transliterates accents and strips any character that is
+ * not a valid identifier character, so inputs like `getFoo≠Bar` or `café` yield
+ * valid JS/TS identifiers rather than leaking the raw symbol into generated code.
+ */
+export declare const camelCase: (str: string) => string;
 export declare const toClassName: (str?: string) => string;
 export declare const toKebabCase: (str?: string) => string;
 export declare const toSnakeCase: (str?: string) => string;
@@ -5,4 +11,20 @@ export declare const upperFirst: (str: string) => string;
 export declare const pascalCase: (str: string) => string;
 export declare const snakeCase: (str: string) => string;
 export declare const kebabCase: (str: string) => string;
+/**
+ * Normalise a string to a PEP 503 distribution name.
+ *
+ * PEP 503 (https://peps.python.org/pep-0503/#normalized-names) defines the
+ * canonical form of a Python project distribution name: lower-cased, with any
+ * run of `.`, `_` or `-` collapsed to a single `-`. This is the name uv writes
+ * into `uv.lock` and the form `@nxlv/python` expects when inferring workspace
+ * dependency edges from `[project].dependencies` / `[tool.uv.sources]`.
+ *
+ * Importantly this is NOT kebab-case: it does not split on camelCase humps,
+ * spaces or other punctuation, so a dotted nx id like `scope.my_lib` becomes
+ * `scope-my-lib` (and only those three separators are touched).
+ *
+ * eg. `sojourner.agent_connection` -> `sojourner-agent-connection`
+ */
+export declare const normalizeDistributionName: (str: string) => string;
 export declare const toDotNotation: (str: string) => string;

package/src/utils/names.js

@@ -1,66 +1,62 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toDotNotation = exports.kebabCase = exports.snakeCase = exports.pascalCase = exports.upperFirst = exports.toSnakeCase = exports.toKebabCase = exports.toClassName = void 0;
-const tslib_1 = require("tslib");
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
- */
-const lodash_camelcase_1 = tslib_1.__importDefault(require("lodash.camelcase"));
-const lodash_deburr_1 = tslib_1.__importDefault(require("lodash.deburr"));
-const toClassName = (str) => {
+ */ import lodashCamelCase from "lodash.camelcase";
+import deburr from "lodash.deburr";
+/**
+ * camelCase that first transliterates accents and strips any character that is
+ * not a valid identifier character, so inputs like `getFoo≠Bar` or `café` yield
+ * valid JS/TS identifiers rather than leaking the raw symbol into generated code.
+ */ export const camelCase = (str)=>lodashCamelCase(deburr(str ?? '').replace(/[^a-zA-Z0-9]+/g, ' '));
+export const toClassName = (str)=>{
     if (!str) {
         return str;
     }
     const words = str.replace(/[^a-zA-Z0-9]/g, ' ').split(/\s+/);
-    return words
-        .map((word, index) => {
+    return words.map((word, index)=>{
         if (index === 0 && /^\d/.test(word)) {
             return '_' + word;
         }
         return word.charAt(0).toUpperCase() + word.slice(1);
-    })
-        .join('');
+    }).join('');
 };
-exports.toClassName = toClassName;
-const toKebabCase = (str) => str?.split('/').map(exports.kebabCase).join('/');
-exports.toKebabCase = toKebabCase;
-const toSnakeCase = (str) => str?.split('/').map(exports.snakeCase).join('/');
-exports.toSnakeCase = toSnakeCase;
-const upperFirst = (str) => str.charAt(0).toUpperCase() + str.slice(1);
-exports.upperFirst = upperFirst;
-const pascalCase = (str) => (0, exports.upperFirst)((0, lodash_camelcase_1.default)(str));
-exports.pascalCase = pascalCase;
-const snakeCase = (str) => {
-    return ((0, lodash_deburr_1.default)(str)
-        // Replace series of special characters with underscores
-        .replace(/[^a-zA-Z0-9]+/g, '_')
-        // Replace capital letters preceded by lowercase or numbers with underscore + lowercase
-        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
-        // Convert to lowercase
-        .toLowerCase()
-        // Remove leading/trailing underscores
-        .replace(/^_+|_+$/g, ''));
+export const toKebabCase = (str)=>str?.split('/').map(kebabCase).join('/');
+export const toSnakeCase = (str)=>str?.split('/').map(snakeCase).join('/');
+export const upperFirst = (str)=>str.charAt(0).toUpperCase() + str.slice(1);
+export const pascalCase = (str)=>upperFirst(camelCase(str));
+export const snakeCase = (str)=>{
+    return deburr(str)// Replace series of special characters with underscores
+    .replace(/[^a-zA-Z0-9]+/g, '_')// Replace capital letters preceded by lowercase or numbers with underscore + lowercase
+    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')// Convert to lowercase
+    .toLowerCase()// Remove leading/trailing underscores
+    .replace(/^_+|_+$/g, '');
 };
-exports.snakeCase = snakeCase;
-const kebabCase = (str) => {
-    return ((0, lodash_deburr_1.default)(str)
-        // Replace series of special characters with hyphens
-        .replace(/[^a-zA-Z0-9]+/g, '-')
-        // Replace capital letters preceded by lowercase or numbers with hyphen + lowercase
-        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
-        // Convert to lowercase
-        .toLowerCase()
-        // Remove leading/trailing hyphens
-        .replace(/^-+|-+$/g, ''));
+export const kebabCase = (str)=>{
+    return deburr(str)// Replace series of special characters with hyphens
+    .replace(/[^a-zA-Z0-9]+/g, '-')// Replace capital letters preceded by lowercase or numbers with hyphen + lowercase
+    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')// Convert to lowercase
+    .toLowerCase()// Remove leading/trailing hyphens
+    .replace(/^-+|-+$/g, '');
 };
-exports.kebabCase = kebabCase;
+/**
+ * Normalise a string to a PEP 503 distribution name.
+ *
+ * PEP 503 (https://peps.python.org/pep-0503/#normalized-names) defines the
+ * canonical form of a Python project distribution name: lower-cased, with any
+ * run of `.`, `_` or `-` collapsed to a single `-`. This is the name uv writes
+ * into `uv.lock` and the form `@nxlv/python` expects when inferring workspace
+ * dependency edges from `[project].dependencies` / `[tool.uv.sources]`.
+ *
+ * Importantly this is NOT kebab-case: it does not split on camelCase humps,
+ * spaces or other punctuation, so a dotted nx id like `scope.my_lib` becomes
+ * `scope-my-lib` (and only those three separators are touched).
+ *
+ * eg. `sojourner.agent_connection` -> `sojourner-agent-connection`
+ */ export const normalizeDistributionName = (str)=>str.toLowerCase().replace(/[._-]+/g, '-');
 // Convert a string to a dot notation string (eg. lambda_handler/my_handler.py -> lambda_handler.my_handler)
-const toDotNotation = (str) => str
-    ?.replace(/^\/|\/$/g, '') // Remove leading/trailing slashes
+export const toDotNotation = (str)=>str?.replace(/^\/|\/$/g, '') // Remove leading/trailing slashes
     .replace(/\.[^/.]+$/g, '') // Remove any file extensions
-    .split('/')
-    .filter(Boolean) // Remove empty segments (in case of double slashes)
+    .split('/').filter(Boolean) // Remove empty segments (in case of double slashes)
     .join('.');
-exports.toDotNotation = toDotNotation;
+
 //# sourceMappingURL=names.js.map