@aws/nx-plugin 1.0.0-rc.53 → 1.0.0-rc.55

package/src/utils/version-upgrade-migration/migration.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { MigrationReturnObject, Tree } from '@nx/devkit';
+/**
+ * Syncs the workspace's vended versions to those the installed plugin vends.
+ *
+ * Registered `everyMigration`, so it runs on every upgrade and last in the run:
+ * versions come from the installed plugin's own tables, so there is nothing
+ * release-specific to register, and running after the code migrations lets them
+ * add dependencies this then brings up to date.
+ */
+export default function migration(tree: Tree): Promise<MigrationReturnObject>;

package/src/utils/version-upgrade-migration/migration.js

@@ -0,0 +1,16 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */ import { syncVendedVersions } from "./sync-vended-versions.js";
+/**
+ * Syncs the workspace's vended versions to those the installed plugin vends.
+ *
+ * Registered `everyMigration`, so it runs on every upgrade and last in the run:
+ * versions come from the installed plugin's own tables, so there is nothing
+ * release-specific to register, and running after the code migrations lets them
+ * add dependencies this then brings up to date.
+ */ export default async function migration(tree) {
+    return syncVendedVersions(tree);
+}
+
+//# sourceMappingURL=migration.js.map

package/src/utils/version-upgrade-migration/migration.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/nx-plugin/src/utils/version-upgrade-migration/migration.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\nimport type { MigrationReturnObject, Tree } from '@nx/devkit';\nimport { syncVendedVersions } from './sync-vended-versions';\n\n/**\n * Syncs the workspace's vended versions to those the installed plugin vends.\n *\n * Registered `everyMigration`, so it runs on every upgrade and last in the run:\n * versions come from the installed plugin's own tables, so there is nothing\n * release-specific to register, and running after the code migrations lets them\n * add dependencies this then brings up to date.\n */\nexport default async function migration(\n  tree: Tree,\n): Promise<MigrationReturnObject> {\n  return syncVendedVersions(tree);\n}\n"],"names":["syncVendedVersions","migration","tree"],"mappings":"AAAA;;;CAGC,GAED,SAASA,kBAAkB,QAAQ,4BAAyB;AAE5D;;;;;;;CAOC,GACD,eAAe,eAAeC,UAC5BC,IAAU;IAEV,OAAOF,mBAAmBE;AAC5B"}

package/src/utils/version-upgrade-migration/nx-package-updates.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `packageJsonUpdates` for the nx packages a generated workspace pins.
+ *
+ * A migration cannot bump these: `nx migrate` builds its migration list from the
+ * packages it is itself bumping, so an nx version only rewritten by our migration
+ * silently skips Nx's own migrations for that hop. Declaring the bump here pulls
+ * them in.
+ *
+ * It also keeps every nx pin moving together. A workspace nx even a patch apart
+ * from the plugin's `@nx/*` packages hoists a second nested nx, and the two
+ * deadlock `nx sync`.
+ */
+export declare const NX_PACKAGE_UPDATES_NAME = "nx-packages";
+export declare const isNxPackage: (name: string) => boolean;
+/** Indexed to satisfy the open shape `migrations.json` entries carry. */
+export interface PackageJsonUpdate extends Record<string, unknown> {
+    version: string;
+    packages: Record<string, {
+        version: string;
+        alwaysAddToPackageJson: false;
+    }>;
+}
+export type PackageJsonUpdates = Record<string, PackageJsonUpdate>;
+/**
+ * `alwaysAddToPackageJson: false` so only packages already present are updated.
+ *
+ * Keyed by directory rather than version, because the key has to exist before
+ * the version does: an entry is written under `latest` and only re-keyed to
+ * `v<version>` once a release claims it. One release's entry stays behind as the
+ * next is written, so a workspace several releases behind gets each nx bump in
+ * turn — hence `<dir>-<name>`, which keeps every release's entry distinct.
+ *
+ * @param version version `nx migrate` gates the bump on
+ */
+export declare const nxPackageJsonUpdates: (dir: string, version: string, nxVersion?: string) => PackageJsonUpdates;

package/src/utils/version-upgrade-migration/nx-package-updates.js

@@ -0,0 +1,42 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */ import { migrationKey } from "../migration-versions.js";
+import { NX_PACKAGES, NX_VERSION } from "../versions.js";
+/**
+ * `packageJsonUpdates` for the nx packages a generated workspace pins.
+ *
+ * A migration cannot bump these: `nx migrate` builds its migration list from the
+ * packages it is itself bumping, so an nx version only rewritten by our migration
+ * silently skips Nx's own migrations for that hop. Declaring the bump here pulls
+ * them in.
+ *
+ * It also keeps every nx pin moving together. A workspace nx even a patch apart
+ * from the plugin's `@nx/*` packages hoists a second nested nx, and the two
+ * deadlock `nx sync`.
+ */ export const NX_PACKAGE_UPDATES_NAME = 'nx-packages';
+export const isNxPackage = (name)=>NX_PACKAGES.includes(name);
+/**
+ * `alwaysAddToPackageJson: false` so only packages already present are updated.
+ *
+ * Keyed by directory rather than version, because the key has to exist before
+ * the version does: an entry is written under `latest` and only re-keyed to
+ * `v<version>` once a release claims it. One release's entry stays behind as the
+ * next is written, so a workspace several releases behind gets each nx bump in
+ * turn — hence `<dir>-<name>`, which keeps every release's entry distinct.
+ *
+ * @param version version `nx migrate` gates the bump on
+ */ export const nxPackageJsonUpdates = (dir, version, nxVersion = NX_VERSION)=>({
+        [migrationKey(dir, NX_PACKAGE_UPDATES_NAME)]: {
+            version,
+            packages: Object.fromEntries(NX_PACKAGES.map((name)=>[
+                    name,
+                    {
+                        version: nxVersion,
+                        alwaysAddToPackageJson: false
+                    }
+                ]))
+        }
+    });
+
+//# sourceMappingURL=nx-package-updates.js.map

package/src/utils/version-upgrade-migration/nx-package-updates.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/nx-plugin/src/utils/version-upgrade-migration/nx-package-updates.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\nimport { migrationKey } from '../migration-versions';\nimport { NX_PACKAGES, NX_VERSION } from '../versions';\n\n/**\n * `packageJsonUpdates` for the nx packages a generated workspace pins.\n *\n * A migration cannot bump these: `nx migrate` builds its migration list from the\n * packages it is itself bumping, so an nx version only rewritten by our migration\n * silently skips Nx's own migrations for that hop. Declaring the bump here pulls\n * them in.\n *\n * It also keeps every nx pin moving together. A workspace nx even a patch apart\n * from the plugin's `@nx/*` packages hoists a second nested nx, and the two\n * deadlock `nx sync`.\n */\n\nexport const NX_PACKAGE_UPDATES_NAME = 'nx-packages';\n\nexport const isNxPackage = (name: string): boolean =>\n  (NX_PACKAGES as readonly string[]).includes(name);\n\n/** Indexed to satisfy the open shape `migrations.json` entries carry. */\nexport interface PackageJsonUpdate extends Record<string, unknown> {\n  version: string;\n  packages: Record<string, { version: string; alwaysAddToPackageJson: false }>;\n}\n\nexport type PackageJsonUpdates = Record<string, PackageJsonUpdate>;\n\n/**\n * `alwaysAddToPackageJson: false` so only packages already present are updated.\n *\n * Keyed by directory rather than version, because the key has to exist before\n * the version does: an entry is written under `latest` and only re-keyed to\n * `v<version>` once a release claims it. One release's entry stays behind as the\n * next is written, so a workspace several releases behind gets each nx bump in\n * turn — hence `<dir>-<name>`, which keeps every release's entry distinct.\n *\n * @param version version `nx migrate` gates the bump on\n */\nexport const nxPackageJsonUpdates = (\n  dir: string,\n  version: string,\n  nxVersion: string = NX_VERSION,\n): PackageJsonUpdates => ({\n  [migrationKey(dir, NX_PACKAGE_UPDATES_NAME)]: {\n    version,\n    packages: Object.fromEntries(\n      NX_PACKAGES.map((name) => [\n        name,\n        { version: nxVersion, alwaysAddToPackageJson: false as const },\n      ]),\n    ),\n  },\n});\n"],"names":["migrationKey","NX_PACKAGES","NX_VERSION","NX_PACKAGE_UPDATES_NAME","isNxPackage","name","includes","nxPackageJsonUpdates","dir","version","nxVersion","packages","Object","fromEntries","map","alwaysAddToPackageJson"],"mappings":"AAAA;;;CAGC,GACD,SAASA,YAAY,QAAQ,2BAAwB;AACrD,SAASC,WAAW,EAAEC,UAAU,QAAQ,iBAAc;AAEtD;;;;;;;;;;;CAWC,GAED,OAAO,MAAMC,0BAA0B,cAAc;AAErD,OAAO,MAAMC,cAAc,CAACC,OAC1B,AAACJ,YAAkCK,QAAQ,CAACD,MAAM;AAUpD;;;;;;;;;;CAUC,GACD,OAAO,MAAME,uBAAuB,CAClCC,KACAC,SACAC,YAAoBR,UAAU,GACN,CAAA;QACxB,CAACF,aAAaQ,KAAKL,yBAAyB,EAAE;YAC5CM;YACAE,UAAUC,OAAOC,WAAW,CAC1BZ,YAAYa,GAAG,CAAC,CAACT,OAAS;oBACxBA;oBACA;wBAAEI,SAASC;wBAAWK,wBAAwB;oBAAe;iBAC9D;QAEL;IACF,CAAA,EAAG"}

package/src/utils/version-upgrade-migration/owned-dependencies.d.ts

@@ -0,0 +1,50 @@
+import { type Tree } from '@nx/devkit';
+import { type DependencyMetadata } from '../declared-dependencies';
+/** Directory holding `generators.json`, which maps ids to their modules. */
+export declare const PLUGIN_ROOT: string;
+/**
+ * Which vended dependencies this workspace's generators are responsible for.
+ *
+ * Only these are synced, so a package the user added themselves keeps the version
+ * they chose. Ownership is derived from the generators the workspace has run and
+ * the dependencies each declares — nothing extra is recorded in the workspace.
+ */
+export interface OwnedDependencies {
+    readonly ts: ReadonlySet<string>;
+    readonly py: ReadonlySet<string>;
+}
+/**
+ * One recorded run of a generator, with the metadata it wrote.
+ *
+ * The metadata carries the values the generator's dependency conditions read, so
+ * a declaration filters down to the branch this occurrence actually took.
+ */
+export interface GeneratorOccurrence {
+    readonly id: string;
+    readonly metadata: DependencyMetadata;
+}
+/**
+ * Every recorded run of a generator in this workspace, from the metadata
+ * generators record on the projects (and components) they create.
+ *
+ * A generator appears once per project or component it created, since each may
+ * have been run with different options.
+ *
+ * `init` creates no project, so its config file stands in for it.
+ */
+export declare const generatorOccurrences: (tree: Tree) => readonly GeneratorOccurrence[];
+/** Generator ids this workspace has run. */
+export declare const generatorsRun: (tree: Tree) => ReadonlySet<string>;
+/**
+ * Union of the dependencies declared by the generators this workspace has run,
+ * narrowed per occurrence to those whose conditions its recorded metadata
+ * satisfies — a project generated with one protocol does not own another's
+ * packages.
+ *
+ * A `versionOnly` entry is owned like any other: it is declared precisely so the
+ * sync keeps its pinned version current wherever the workspace already holds it.
+ *
+ * Each generator module exports its declaration, so reading one is an import
+ * rather than a run — the generators themselves are never invoked.
+ */
+export declare const ownedDependencies: (tree: Tree) => Promise<OwnedDependencies>;

package/src/utils/version-upgrade-migration/owned-dependencies.js

@@ -0,0 +1,98 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */ import * as path from "node:path";
+import { getProjects } from "@nx/devkit";
+import { AWS_NX_PLUGIN_CONFIG_FILE_NAME } from "../config/utils.js";
+import { ownedDependencyEntries } from "../declared-dependencies.js";
+import { buildGeneratorInfoList } from "../generators.js";
+/** Directory holding `generators.json`, which maps ids to their modules. */ export const PLUGIN_ROOT = path.resolve(import.meta.dirname, '..', '..', '..');
+/**
+ * Every recorded run of a generator in this workspace, from the metadata
+ * generators record on the projects (and components) they create.
+ *
+ * A generator appears once per project or component it created, since each may
+ * have been run with different options.
+ *
+ * `init` creates no project, so its config file stands in for it.
+ */ export const generatorOccurrences = (tree)=>{
+    const occurrences = [];
+    if (tree.exists(AWS_NX_PLUGIN_CONFIG_FILE_NAME)) {
+        occurrences.push({
+            id: 'init',
+            metadata: {}
+        });
+    }
+    for (const [, project] of getProjects(tree)){
+        const metadata = project.metadata;
+        if (metadata?.generator) {
+            const { components, ...ownMetadata } = metadata;
+            occurrences.push({
+                id: metadata.generator,
+                metadata: ownMetadata
+            });
+        }
+        for (const component of metadata?.components ?? []){
+            if (component.generator) {
+                occurrences.push({
+                    id: component.generator,
+                    metadata: component
+                });
+            }
+        }
+    }
+    return occurrences;
+};
+/** Generator ids this workspace has run. */ export const generatorsRun = (tree)=>new Set(generatorOccurrences(tree).map((occurrence)=>occurrence.id));
+/**
+ * Union of the dependencies declared by the generators this workspace has run,
+ * narrowed per occurrence to those whose conditions its recorded metadata
+ * satisfies — a project generated with one protocol does not own another's
+ * packages.
+ *
+ * A `versionOnly` entry is owned like any other: it is declared precisely so the
+ * sync keeps its pinned version current wherever the workspace already holds it.
+ *
+ * Each generator module exports its declaration, so reading one is an import
+ * rather than a run — the generators themselves are never invoked.
+ */ export const ownedDependencies = async (tree)=>{
+    const occurrences = generatorOccurrences(tree);
+    const ts = new Set();
+    const py = new Set();
+    for (const info of buildGeneratorInfoList(PLUGIN_ROOT)){
+        const matching = occurrences.filter((occurrence)=>occurrence.id === info.id);
+        if (matching.length === 0) {
+            continue;
+        }
+        const declaration = await readDeclaration(info.resolvedFactoryPath);
+        if (!declaration) {
+            continue;
+        }
+        for (const { metadata } of matching){
+            for (const entry of ownedDependencyEntries(declaration.ts, metadata)){
+                ts.add(entry.name);
+            }
+            for (const entry of ownedDependencyEntries(declaration.py, metadata)){
+                py.add(entry.name);
+            }
+        }
+    }
+    return {
+        ts,
+        py
+    };
+};
+/**
+ * A generator's `DEPENDENCIES`, or undefined when it declares none.
+ * A generator that fails to load must not fail the upgrade, so its dependencies
+ * are treated as unowned and left as they are.
+ */ const readDeclaration = async (factoryPath)=>{
+    try {
+        const module = await import(`${factoryPath}.js`);
+        return module.DEPENDENCIES;
+    } catch  {
+        return undefined;
+    }
+};
+
+//# sourceMappingURL=owned-dependencies.js.map

package/src/utils/version-upgrade-migration/owned-dependencies.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/nx-plugin/src/utils/version-upgrade-migration/owned-dependencies.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\nimport * as path from 'node:path';\nimport { getProjects, type Tree } from '@nx/devkit';\nimport { AWS_NX_PLUGIN_CONFIG_FILE_NAME } from '../config/utils';\nimport {\n  type DependencyDeclaration,\n  type DependencyMetadata,\n  ownedDependencyEntries,\n} from '../declared-dependencies';\nimport { buildGeneratorInfoList } from '../generators';\n\n/** Directory holding `generators.json`, which maps ids to their modules. */\nexport const PLUGIN_ROOT = path.resolve(import.meta.dirname, '..', '..', '..');\n\n/**\n * Which vended dependencies this workspace's generators are responsible for.\n *\n * Only these are synced, so a package the user added themselves keeps the version\n * they chose. Ownership is derived from the generators the workspace has run and\n * the dependencies each declares — nothing extra is recorded in the workspace.\n */\nexport interface OwnedDependencies {\n  readonly ts: ReadonlySet<string>;\n  readonly py: ReadonlySet<string>;\n}\n\n/**\n * One recorded run of a generator, with the metadata it wrote.\n *\n * The metadata carries the values the generator's dependency conditions read, so\n * a declaration filters down to the branch this occurrence actually took.\n */\nexport interface GeneratorOccurrence {\n  readonly id: string;\n  readonly metadata: DependencyMetadata;\n}\n\n/**\n * Every recorded run of a generator in this workspace, from the metadata\n * generators record on the projects (and components) they create.\n *\n * A generator appears once per project or component it created, since each may\n * have been run with different options.\n *\n * `init` creates no project, so its config file stands in for it.\n */\nexport const generatorOccurrences = (\n  tree: Tree,\n): readonly GeneratorOccurrence[] => {\n  const occurrences: GeneratorOccurrence[] = [];\n  if (tree.exists(AWS_NX_PLUGIN_CONFIG_FILE_NAME)) {\n    occurrences.push({ id: 'init', metadata: {} });\n  }\n  for (const [, project] of getProjects(tree)) {\n    const metadata = project.metadata as\n      | {\n          generator?: string;\n          components?: ({ generator?: string } & DependencyMetadata)[];\n        }\n      | undefined;\n    if (metadata?.generator) {\n      const { components, ...ownMetadata } = metadata;\n      occurrences.push({ id: metadata.generator, metadata: ownMetadata });\n    }\n    for (const component of metadata?.components ?? []) {\n      if (component.generator) {\n        occurrences.push({ id: component.generator, metadata: component });\n      }\n    }\n  }\n  return occurrences;\n};\n\n/** Generator ids this workspace has run. */\nexport const generatorsRun = (tree: Tree): ReadonlySet<string> =>\n  new Set(generatorOccurrences(tree).map((occurrence) => occurrence.id));\n\n/**\n * Union of the dependencies declared by the generators this workspace has run,\n * narrowed per occurrence to those whose conditions its recorded metadata\n * satisfies — a project generated with one protocol does not own another's\n * packages.\n *\n * A `versionOnly` entry is owned like any other: it is declared precisely so the\n * sync keeps its pinned version current wherever the workspace already holds it.\n *\n * Each generator module exports its declaration, so reading one is an import\n * rather than a run — the generators themselves are never invoked.\n */\nexport const ownedDependencies = async (\n  tree: Tree,\n): Promise<OwnedDependencies> => {\n  const occurrences = generatorOccurrences(tree);\n  const ts = new Set<string>();\n  const py = new Set<string>();\n\n  for (const info of buildGeneratorInfoList(PLUGIN_ROOT)) {\n    const matching = occurrences.filter(\n      (occurrence) => occurrence.id === info.id,\n    );\n    if (matching.length === 0) {\n      continue;\n    }\n    const declaration = await readDeclaration(info.resolvedFactoryPath);\n    if (!declaration) {\n      continue;\n    }\n    for (const { metadata } of matching) {\n      for (const entry of ownedDependencyEntries(declaration.ts, metadata)) {\n        ts.add(entry.name as string);\n      }\n      for (const entry of ownedDependencyEntries(declaration.py, metadata)) {\n        py.add(entry.name as string);\n      }\n    }\n  }\n\n  return { ts, py };\n};\n\n/**\n * A generator's `DEPENDENCIES`, or undefined when it declares none.\n * A generator that fails to load must not fail the upgrade, so its dependencies\n * are treated as unowned and left as they are.\n */\nconst readDeclaration = async (\n  factoryPath: string,\n): Promise<DependencyDeclaration | undefined> => {\n  try {\n    const module = await import(`${factoryPath}.js`);\n    return module.DEPENDENCIES;\n  } catch {\n    return undefined;\n  }\n};\n"],"names":["path","getProjects","AWS_NX_PLUGIN_CONFIG_FILE_NAME","ownedDependencyEntries","buildGeneratorInfoList","PLUGIN_ROOT","resolve","dirname","generatorOccurrences","tree","occurrences","exists","push","id","metadata","project","generator","components","ownMetadata","component","generatorsRun","Set","map","occurrence","ownedDependencies","ts","py","info","matching","filter","length","declaration","readDeclaration","resolvedFactoryPath","entry","add","name","factoryPath","module","DEPENDENCIES","undefined"],"mappings":"AAAA;;;CAGC,GACD,YAAYA,UAAU,YAAY;AAClC,SAASC,WAAW,QAAmB,aAAa;AACpD,SAASC,8BAA8B,QAAQ,qBAAkB;AACjE,SAGEC,sBAAsB,QACjB,8BAA2B;AAClC,SAASC,sBAAsB,QAAQ,mBAAgB;AAEvD,0EAA0E,GAC1E,OAAO,MAAMC,cAAcL,KAAKM,OAAO,CAAC,YAAYC,OAAO,EAAE,MAAM,MAAM,MAAM;AAyB/E;;;;;;;;CAQC,GACD,OAAO,MAAMC,uBAAuB,CAClCC;IAEA,MAAMC,cAAqC,EAAE;IAC7C,IAAID,KAAKE,MAAM,CAACT,iCAAiC;QAC/CQ,YAAYE,IAAI,CAAC;YAAEC,IAAI;YAAQC,UAAU,CAAC;QAAE;IAC9C;IACA,KAAK,MAAM,GAAGC,QAAQ,IAAId,YAAYQ,MAAO;QAC3C,MAAMK,WAAWC,QAAQD,QAAQ;QAMjC,IAAIA,UAAUE,WAAW;YACvB,MAAM,EAAEC,UAAU,EAAE,GAAGC,aAAa,GAAGJ;YACvCJ,YAAYE,IAAI,CAAC;gBAAEC,IAAIC,SAASE,SAAS;gBAAEF,UAAUI;YAAY;QACnE;QACA,KAAK,MAAMC,aAAaL,UAAUG,cAAc,EAAE,CAAE;YAClD,IAAIE,UAAUH,SAAS,EAAE;gBACvBN,YAAYE,IAAI,CAAC;oBAAEC,IAAIM,UAAUH,SAAS;oBAAEF,UAAUK;gBAAU;YAClE;QACF;IACF;IACA,OAAOT;AACT,EAAE;AAEF,0CAA0C,GAC1C,OAAO,MAAMU,gBAAgB,CAACX,OAC5B,IAAIY,IAAIb,qBAAqBC,MAAMa,GAAG,CAAC,CAACC,aAAeA,WAAWV,EAAE,GAAG;AAEzE;;;;;;;;;;;CAWC,GACD,OAAO,MAAMW,oBAAoB,OAC/Bf;IAEA,MAAMC,cAAcF,qBAAqBC;IACzC,MAAMgB,KAAK,IAAIJ;IACf,MAAMK,KAAK,IAAIL;IAEf,KAAK,MAAMM,QAAQvB,uBAAuBC,aAAc;QACtD,MAAMuB,WAAWlB,YAAYmB,MAAM,CACjC,CAACN,aAAeA,WAAWV,EAAE,KAAKc,KAAKd,EAAE;QAE3C,IAAIe,SAASE,MAAM,KAAK,GAAG;YACzB;QACF;QACA,MAAMC,cAAc,MAAMC,gBAAgBL,KAAKM,mBAAmB;QAClE,IAAI,CAACF,aAAa;YAChB;QACF;QACA,KAAK,MAAM,EAAEjB,QAAQ,EAAE,IAAIc,SAAU;YACnC,KAAK,MAAMM,SAAS/B,uBAAuB4B,YAAYN,EAAE,EAAEX,UAAW;gBACpEW,GAAGU,GAAG,CAACD,MAAME,IAAI;YACnB;YACA,KAAK,MAAMF,SAAS/B,uBAAuB4B,YAAYL,EAAE,EAAEZ,UAAW;gBACpEY,GAAGS,GAAG,CAACD,MAAME,IAAI;YACnB;QACF;IACF;IAEA,OAAO;QAAEX;QAAIC;IAAG;AAClB,EAAE;AAEF;;;;CAIC,GACD,MAAMM,kBAAkB,OACtBK;IAEA,IAAI;QACF,MAAMC,SAAS,MAAM,MAAM,CAAC,GAAGD,YAAY,GAAG,CAAC;QAC/C,OAAOC,OAAOC,YAAY;IAC5B,EAAE,OAAM;QACN,OAAOC;IACT;AACF"}

package/src/utils/version-upgrade-migration/register.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type Tree } from '@nx/devkit';
+/**
+ * Register the nx bump a version update needs, in `migrations.json`. Call only
+ * when an nx package actually moved.
+ *
+ * The version sync migration itself is a committed `everyMigration` entry, so
+ * only the nx packages need registering per update: they go through
+ * `packageJsonUpdates` rather than a migration (see `nx-package-updates.ts`).
+ *
+ * Idempotent: re-running before a release claims the entry refreshes it in place.
+ *
+ * @returns paths written, for the update report
+ */
+export declare const registerNxPackageUpdates: (tree: Tree) => string[];

package/src/utils/version-upgrade-migration/register.js

@@ -0,0 +1,33 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */ import { updateJson } from "@nx/devkit";
+import { LATEST_MIGRATIONS_DIR } from "../migration-versions.js";
+import { nxPackageJsonUpdates } from "./nx-package-updates.js";
+const MIGRATIONS_JSON_PATH = 'packages/nx-plugin/migrations.json';
+/**
+ * Register the nx bump a version update needs, in `migrations.json`. Call only
+ * when an nx package actually moved.
+ *
+ * The version sync migration itself is a committed `everyMigration` entry, so
+ * only the nx packages need registering per update: they go through
+ * `packageJsonUpdates` rather than a migration (see `nx-package-updates.ts`).
+ *
+ * Idempotent: re-running before a release claims the entry refreshes it in place.
+ *
+ * @returns paths written, for the update report
+ */ export const registerNxPackageUpdates = (tree)=>{
+    updateJson(tree, MIGRATIONS_JSON_PATH, (migrations)=>({
+            ...migrations,
+            // Recorded under `latest` until stamping resolves the version it ships with.
+            packageJsonUpdates: {
+                ...migrations.packageJsonUpdates,
+                ...nxPackageJsonUpdates(LATEST_MIGRATIONS_DIR, LATEST_MIGRATIONS_DIR)
+            }
+        }));
+    return [
+        MIGRATIONS_JSON_PATH
+    ];
+};
+
+//# sourceMappingURL=register.js.map

package/src/utils/version-upgrade-migration/register.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/nx-plugin/src/utils/version-upgrade-migration/register.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\nimport { type Tree, updateJson } from '@nx/devkit';\nimport {\n  LATEST_MIGRATIONS_DIR,\n  type MigrationsJson,\n} from '../migration-versions';\nimport { nxPackageJsonUpdates } from './nx-package-updates';\n\nconst MIGRATIONS_JSON_PATH = 'packages/nx-plugin/migrations.json';\n\n/**\n * Register the nx bump a version update needs, in `migrations.json`. Call only\n * when an nx package actually moved.\n *\n * The version sync migration itself is a committed `everyMigration` entry, so\n * only the nx packages need registering per update: they go through\n * `packageJsonUpdates` rather than a migration (see `nx-package-updates.ts`).\n *\n * Idempotent: re-running before a release claims the entry refreshes it in place.\n *\n * @returns paths written, for the update report\n */\nexport const registerNxPackageUpdates = (tree: Tree): string[] => {\n  updateJson<MigrationsJson>(tree, MIGRATIONS_JSON_PATH, (migrations) => ({\n    ...migrations,\n    // Recorded under `latest` until stamping resolves the version it ships with.\n    packageJsonUpdates: {\n      ...migrations.packageJsonUpdates,\n      ...nxPackageJsonUpdates(LATEST_MIGRATIONS_DIR, LATEST_MIGRATIONS_DIR),\n    },\n  }));\n\n  return [MIGRATIONS_JSON_PATH];\n};\n"],"names":["updateJson","LATEST_MIGRATIONS_DIR","nxPackageJsonUpdates","MIGRATIONS_JSON_PATH","registerNxPackageUpdates","tree","migrations","packageJsonUpdates"],"mappings":"AAAA;;;CAGC,GACD,SAAoBA,UAAU,QAAQ,aAAa;AACnD,SACEC,qBAAqB,QAEhB,2BAAwB;AAC/B,SAASC,oBAAoB,QAAQ,0BAAuB;AAE5D,MAAMC,uBAAuB;AAE7B;;;;;;;;;;;CAWC,GACD,OAAO,MAAMC,2BAA2B,CAACC;IACvCL,WAA2BK,MAAMF,sBAAsB,CAACG,aAAgB,CAAA;YACtE,GAAGA,UAAU;YACb,6EAA6E;YAC7EC,oBAAoB;gBAClB,GAAGD,WAAWC,kBAAkB;gBAChC,GAAGL,qBAAqBD,uBAAuBA,sBAAsB;YACvE;QACF,CAAA;IAEA,OAAO;QAACE;KAAqB;AAC/B,EAAE"}

package/src/utils/version-upgrade-migration/sync-metrics-version.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Tree } from '@nx/devkit';
+/**
+ * Sync the plugin version the metrics files report, so usage is attributed to
+ * the release the workspace actually runs. The metric id and tags are owned by
+ * the generators and left alone.
+ *
+ * @returns the metrics files that changed
+ */
+export declare const syncMetricsVersion: (tree: Tree) => Promise<string[]>;

package/src/utils/version-upgrade-migration/sync-metrics-version.js

@@ -0,0 +1,33 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */ import { applyGritQL } from "../ast.js";
+import { METRICS_ASPECT_FILE_PATH, TERRAFORM_METRICS_FILE_PATH } from "../metrics.js";
+import { getPackageVersion } from "../nx.js";
+/**
+ * Sync the plugin version the metrics files report, so usage is attributed to
+ * the release the workspace actually runs. The metric id and tags are owned by
+ * the generators and left alone.
+ *
+ * @returns the metrics files that changed
+ */ export const syncMetricsVersion = async (tree)=>{
+    const version = getPackageVersion();
+    const updated = [];
+    if (tree.exists(METRICS_ASPECT_FILE_PATH)) {
+        const changed = await applyGritQL(tree, METRICS_ASPECT_FILE_PATH, `\`const version = $old\` => \`const version = '${version}'\`` + ' where { $old <: within `class MetricsAspect implements $_ { $_ }` }');
+        if (changed) {
+            updated.push(METRICS_ASPECT_FILE_PATH);
+        }
+    }
+    if (tree.exists(TERRAFORM_METRICS_FILE_PATH)) {
+        // GritQL's HCL grammar rejects `within locals { ... }`, so the match is
+        // narrowed to a string value to skip interpolated mentions.
+        const changed = await applyGritQL(tree, TERRAFORM_METRICS_FILE_PATH, `\`metric_version = $old\` => \`metric_version = "${version}"\`` + ' where { $old <: string() }');
+        if (changed) {
+            updated.push(TERRAFORM_METRICS_FILE_PATH);
+        }
+    }
+    return updated;
+};
+
+//# sourceMappingURL=sync-metrics-version.js.map

package/src/utils/version-upgrade-migration/sync-metrics-version.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/nx-plugin/src/utils/version-upgrade-migration/sync-metrics-version.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\nimport type { Tree } from '@nx/devkit';\nimport { applyGritQL } from '../ast';\nimport {\n  METRICS_ASPECT_FILE_PATH,\n  TERRAFORM_METRICS_FILE_PATH,\n} from '../metrics';\nimport { getPackageVersion } from '../nx';\n\n/**\n * Sync the plugin version the metrics files report, so usage is attributed to\n * the release the workspace actually runs. The metric id and tags are owned by\n * the generators and left alone.\n *\n * @returns the metrics files that changed\n */\nexport const syncMetricsVersion = async (tree: Tree): Promise<string[]> => {\n  const version = getPackageVersion();\n  const updated: string[] = [];\n\n  if (tree.exists(METRICS_ASPECT_FILE_PATH)) {\n    const changed = await applyGritQL(\n      tree,\n      METRICS_ASPECT_FILE_PATH,\n      `\\`const version = $old\\` => \\`const version = '${version}'\\`` +\n        ' where { $old <: within `class MetricsAspect implements $_ { $_ }` }',\n    );\n    if (changed) {\n      updated.push(METRICS_ASPECT_FILE_PATH);\n    }\n  }\n\n  if (tree.exists(TERRAFORM_METRICS_FILE_PATH)) {\n    // GritQL's HCL grammar rejects `within locals { ... }`, so the match is\n    // narrowed to a string value to skip interpolated mentions.\n    const changed = await applyGritQL(\n      tree,\n      TERRAFORM_METRICS_FILE_PATH,\n      `\\`metric_version = $old\\` => \\`metric_version = \"${version}\"\\`` +\n        ' where { $old <: string() }',\n    );\n    if (changed) {\n      updated.push(TERRAFORM_METRICS_FILE_PATH);\n    }\n  }\n\n  return updated;\n};\n"],"names":["applyGritQL","METRICS_ASPECT_FILE_PATH","TERRAFORM_METRICS_FILE_PATH","getPackageVersion","syncMetricsVersion","tree","version","updated","exists","changed","push"],"mappings":"AAAA;;;CAGC,GAED,SAASA,WAAW,QAAQ,YAAS;AACrC,SACEC,wBAAwB,EACxBC,2BAA2B,QACtB,gBAAa;AACpB,SAASC,iBAAiB,QAAQ,WAAQ;AAE1C;;;;;;CAMC,GACD,OAAO,MAAMC,qBAAqB,OAAOC;IACvC,MAAMC,UAAUH;IAChB,MAAMI,UAAoB,EAAE;IAE5B,IAAIF,KAAKG,MAAM,CAACP,2BAA2B;QACzC,MAAMQ,UAAU,MAAMT,YACpBK,MACAJ,0BACA,CAAC,+CAA+C,EAAEK,QAAQ,GAAG,CAAC,GAC5D;QAEJ,IAAIG,SAAS;YACXF,QAAQG,IAAI,CAACT;QACf;IACF;IAEA,IAAII,KAAKG,MAAM,CAACN,8BAA8B;QAC5C,wEAAwE;QACxE,4DAA4D;QAC5D,MAAMO,UAAU,MAAMT,YACpBK,MACAH,6BACA,CAAC,iDAAiD,EAAEI,QAAQ,GAAG,CAAC,GAC9D;QAEJ,IAAIG,SAAS;YACXF,QAAQG,IAAI,CAACR;QACf;IACF;IAEA,OAAOK;AACT,EAAE"}

package/src/utils/version-upgrade-migration/sync-vended-versions.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type MigrationReturnObject, type Tree } from '@nx/devkit';
+/**
+ * Sync the versions this release vends, for the dependencies the workspace's
+ * generators own.
+ */
+export declare const syncVendedVersions: (tree: Tree) => Promise<MigrationReturnObject>;