@aws/nx-plugin 1.0.0-rc.7 → 1.0.0-rc.71

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

@@ -0,0 +1,29 @@
+/**
+ * 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 `packageJsonUpdates.json`. Call
+ * only when an nx package actually moved.
+ *
+ * The bumps live in their own committed file, assembled into `migrations.json`
+ * at build time, so this weekly-bot edit never conflicts with a migration PR.
+ * 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`).
+ *
+ * A bump already dated by a release stays — a workspace several releases behind
+ * needs each hop in turn. One still waiting for a release is dropped: this bump
+ * supersedes it, and both would otherwise ship under the same version, leaving
+ * which nx a workspace lands on down to the order nx happens to apply them in.
+ *
+ * Idempotent: re-running before a release replaces the pending entry with itself.
+ *
+ * @param nxVersion nx version being moved to. The update script rewrites
+ *   `versions.ts` on the tree, which cannot change the `NX_VERSION` this process
+ *   imported at load — so the caller passes the version it just wrote, or the
+ *   entry would record the one being replaced.
+ * @returns paths written, for the update report
+ */
+export declare const registerNxPackageUpdates: (tree: Tree, nxVersion?: string) => string[];

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

@@ -0,0 +1,42 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */ import { writeJson } from "@nx/devkit";
+import { LATEST_MIGRATIONS_DIR } from "../migration-versions.js";
+import { nxPackageJsonUpdates } from "./nx-package-updates.js";
+const PACKAGE_JSON_UPDATES_PATH = 'packages/nx-plugin/packageJsonUpdates.json';
+/**
+ * Register the nx bump a version update needs, in `packageJsonUpdates.json`. Call
+ * only when an nx package actually moved.
+ *
+ * The bumps live in their own committed file, assembled into `migrations.json`
+ * at build time, so this weekly-bot edit never conflicts with a migration PR.
+ * 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`).
+ *
+ * A bump already dated by a release stays — a workspace several releases behind
+ * needs each hop in turn. One still waiting for a release is dropped: this bump
+ * supersedes it, and both would otherwise ship under the same version, leaving
+ * which nx a workspace lands on down to the order nx happens to apply them in.
+ *
+ * Idempotent: re-running before a release replaces the pending entry with itself.
+ *
+ * @param nxVersion nx version being moved to. The update script rewrites
+ *   `versions.ts` on the tree, which cannot change the `NX_VERSION` this process
+ *   imported at load — so the caller passes the version it just wrote, or the
+ *   entry would record the one being replaced.
+ * @returns paths written, for the update report
+ */ export const registerNxPackageUpdates = (tree, nxVersion)=>{
+    const existing = tree.exists(PACKAGE_JSON_UPDATES_PATH) ? JSON.parse(tree.read(PACKAGE_JSON_UPDATES_PATH, 'utf-8')) : {};
+    writeJson(tree, PACKAGE_JSON_UPDATES_PATH, {
+        // Recorded under `latest` until stamping resolves the version it ships with.
+        ...Object.fromEntries(Object.entries(existing).filter(([, entry])=>entry.version !== LATEST_MIGRATIONS_DIR)),
+        ...nxPackageJsonUpdates(LATEST_MIGRATIONS_DIR, nxVersion)
+    });
+    return [
+        PACKAGE_JSON_UPDATES_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, writeJson } from '@nx/devkit';\nimport { LATEST_MIGRATIONS_DIR } from '../migration-versions';\nimport {\n  nxPackageJsonUpdates,\n  type PackageJsonUpdates,\n} from './nx-package-updates';\n\nconst PACKAGE_JSON_UPDATES_PATH = 'packages/nx-plugin/packageJsonUpdates.json';\n\n/**\n * Register the nx bump a version update needs, in `packageJsonUpdates.json`. Call\n * only when an nx package actually moved.\n *\n * The bumps live in their own committed file, assembled into `migrations.json`\n * at build time, so this weekly-bot edit never conflicts with a migration PR.\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 * A bump already dated by a release stays — a workspace several releases behind\n * needs each hop in turn. One still waiting for a release is dropped: this bump\n * supersedes it, and both would otherwise ship under the same version, leaving\n * which nx a workspace lands on down to the order nx happens to apply them in.\n *\n * Idempotent: re-running before a release replaces the pending entry with itself.\n *\n * @param nxVersion nx version being moved to. The update script rewrites\n *   `versions.ts` on the tree, which cannot change the `NX_VERSION` this process\n *   imported at load — so the caller passes the version it just wrote, or the\n *   entry would record the one being replaced.\n * @returns paths written, for the update report\n */\nexport const registerNxPackageUpdates = (\n  tree: Tree,\n  nxVersion?: string,\n): string[] => {\n  const existing: PackageJsonUpdates = tree.exists(PACKAGE_JSON_UPDATES_PATH)\n    ? JSON.parse(tree.read(PACKAGE_JSON_UPDATES_PATH, 'utf-8'))\n    : {};\n\n  writeJson(tree, PACKAGE_JSON_UPDATES_PATH, {\n    // Recorded under `latest` until stamping resolves the version it ships with.\n    ...Object.fromEntries(\n      Object.entries(existing).filter(\n        ([, entry]) => entry.version !== LATEST_MIGRATIONS_DIR,\n      ),\n    ),\n    ...nxPackageJsonUpdates(LATEST_MIGRATIONS_DIR, nxVersion),\n  });\n\n  return [PACKAGE_JSON_UPDATES_PATH];\n};\n"],"names":["writeJson","LATEST_MIGRATIONS_DIR","nxPackageJsonUpdates","PACKAGE_JSON_UPDATES_PATH","registerNxPackageUpdates","tree","nxVersion","existing","exists","JSON","parse","read","Object","fromEntries","entries","filter","entry","version"],"mappings":"AAAA;;;CAGC,GACD,SAAoBA,SAAS,QAAQ,aAAa;AAClD,SAASC,qBAAqB,QAAQ,2BAAwB;AAC9D,SACEC,oBAAoB,QAEf,0BAAuB;AAE9B,MAAMC,4BAA4B;AAElC;;;;;;;;;;;;;;;;;;;;;;CAsBC,GACD,OAAO,MAAMC,2BAA2B,CACtCC,MACAC;IAEA,MAAMC,WAA+BF,KAAKG,MAAM,CAACL,6BAC7CM,KAAKC,KAAK,CAACL,KAAKM,IAAI,CAACR,2BAA2B,YAChD,CAAC;IAELH,UAAUK,MAAMF,2BAA2B;QACzC,6EAA6E;QAC7E,GAAGS,OAAOC,WAAW,CACnBD,OAAOE,OAAO,CAACP,UAAUQ,MAAM,CAC7B,CAAC,GAAGC,MAAM,GAAKA,MAAMC,OAAO,KAAKhB,uBAEpC;QACD,GAAGC,qBAAqBD,uBAAuBK,UAAU;IAC3D;IAEA,OAAO;QAACH;KAA0B;AACpC,EAAE"}

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

@@ -0,0 +1,26 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Tree } from '@nx/devkit';
+import { type OwnedDependencies } from './owned-dependencies';
+/**
+ * Whether a file is a Dockerfile: exactly `Dockerfile`, or the `<name>.Dockerfile`
+ * form the smithy templates vend as `build.Dockerfile`.
+ *
+ * Deliberately exact rather than a prefix match, which would also claim a
+ * `Dockerfile.bak` or a `Dockerfile.md` the user keeps beside a real one.
+ */
+export declare const isDockerfile: (filePath: string) => boolean;
+/**
+ * Sync the vended versions baked into generated file bodies: `Dockerfile` pins,
+ * the Python pins in Terraform inline scripts, the tooling `project.json` target
+ * commands run, and the Maven coordinates a `smithy-build.json` resolves.
+ *
+ * Reports only the files left for the user: a pin that takes effect the next time
+ * the thing holding it runs needs no follow-up, but one this skipped for holding
+ * more occurrences than it will rewrite at once does.
+ *
+ * @returns paths whose pins were left as they were
+ */
+export declare const syncEmbeddedVersions: (tree: Tree, owned: OwnedDependencies) => Promise<string[]>;

package/src/utils/version-upgrade-migration/sync-embedded-versions.js

@@ -0,0 +1,352 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */ import { getProjects, joinPathFragments, visitNotIgnoredFiles } from "@nx/devkit";
+import { SMITHY_PROJECT_GENERATOR_INFO } from "../../smithy/project/generator.js";
+import { applyGritQL } from "../ast.js";
+import { BASE_IMAGES, CONTAINER_REPOSITORIES, CONTAINER_VERSIONS, JAVA_ARTIFACTS, JAVA_VERSIONS, MISE_VERSIONS, PY_VERSIONS, TS_VERSIONS } from "../versions.js";
+import { ownedForFile } from "./owned-dependencies.js";
+import { isVendedUpgrade } from "./vended-upgrade.js";
+/** Escape a package name or image reference for use inside a regex. */ const escapeRegExp = (value)=>value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/**
+ * Characters that end a pinned version: whitespace, the backslash continuing a
+ * shell line, and the quote closing the string the pin sits in.
+ *
+ * The quote is escaped because the pattern is itself a double-quoted GritQL
+ * regex literal, which a bare quote would terminate.
+ */ const VERSION_TERMINATORS = '\\s\\\\\\"';
+/**
+ * Rewrite the capture group of an anchored regex to the vended version.
+ *
+ * The leading and trailing `[\s\S]*` anchor the match to the whole file, which
+ * is what lets a capture group be rewritten on its own: GritQL binds the group
+ * to a node it can replace, leaving every other byte untouched. Without the
+ * anchors nothing matches.
+ */ const rewriteCapture = (pattern, vended)=>`r"[\\s\\S]*${pattern}[\\s\\S]*"($version) where { $version => \`${vended}\` }`;
+/**
+ * Versions a pin's regex currently matches in the file.
+ *
+ * Read before rewriting so a version the user raised past what this release
+ * vends is left alone, matching how every other surface behaves.
+ */ const declaredVersions = (contents, pattern)=>{
+    const matches = contents.matchAll(new RegExp(pattern, 'g'));
+    return [
+        ...matches
+    ].flatMap((match)=>match[1] ? [
+            match[1]
+        ] : []);
+};
+/**
+ * Occurrences of one pin a single rewrite will handle.
+ *
+ * GritQL rewrites each match separately, so its cost grows with how many a
+ * pattern matches — ~10ms an occurrence, which a hand-authored file with hundreds
+ * of `RUN npm install` lines turns into minutes of an unattended `nx migrate`.
+ * Past this the file is left alone and reported, since a wrong version the user
+ * can see and fix beats an upgrade that appears to hang.
+ */ const MAX_OCCURRENCES_PER_PIN = 100;
+/**
+ * Apply the pins whose declared version this release moves forward.
+ *
+ * A single rewrite covers every occurrence of a pin in the file, so each pin is
+ * applied once. Reports whether anything changed, and whether a pin was left
+ * alone for exceeding {@link MAX_OCCURRENCES_PER_PIN}.
+ */ const applyPins = async (tree, path, pins)=>{
+    // Read once and re-read only after a rewrite: a rewrite parses the whole file,
+    // and there is a pin per owned package, so re-reading per pin would scale the
+    // cost of a large file with the size of the owned set.
+    let contents = tree.read(path, 'utf-8') ?? '';
+    let changed = false;
+    let skipped = false;
+    for (const { pattern, vended, kind = 'version' } of pins){
+        const declared = declaredVersions(contents, pattern);
+        if (declared.length === 0) {
+            continue;
+        }
+        if (declared.length > MAX_OCCURRENCES_PER_PIN) {
+            skipped = true;
+            continue;
+        }
+        const outOfDate = kind === 'tag' ? (tag)=>tag !== vended : (version)=>isVendedUpgrade(vended, version);
+        // A rewrite replaces every occurrence at once, so this must hold for all of
+        // them — a pin already at or beyond the vended version is left as it is.
+        if (!declared.every(outOfDate)) {
+            continue;
+        }
+        if (await applyGritQL(tree, path, rewriteCapture(pattern, vended))) {
+            contents = tree.read(path, 'utf-8') ?? '';
+            changed = true;
+        }
+    }
+    return {
+        changed,
+        skipped
+    };
+};
+/**
+ * The version this release vends for a package, or undefined for one it doesn't
+ * vend at all.
+ *
+ * Ownership is applied by the caller, which only ever passes a name drawn from
+ * the owned set — so a package the user pinned themselves never reaches here and
+ * keeps the version they chose.
+ */ const vendedTsVersion = (name)=>TS_VERSIONS[name];
+/** `PY_VERSIONS` records the `==` operator; a pin holds the bare version. */ const vendedPyVersion = (name)=>PY_VERSIONS[name]?.replace(/^==/, '');
+/**
+ * The ways a generated `Dockerfile` pins a TypeScript package's version, as
+ * regex fragments taking the escaped package name.
+ *
+ * The name is required to run to its delimiter, so a package whose name merely
+ * ends with another's — `some-npm` against `npm` — cannot match, and an
+ * installed version must start with a digit so a `@latest` style tag is left
+ * alone.
+ */ const DOCKERFILE_PIN_SHAPES = [
+    // Installed by the image build. `install` and its `i` alias are both used, as
+    // are `-g` and several packages in one command, so the name only has to follow
+    // an `npm` subcommand rather than sit right after it. The whitespace before it
+    // is matched rather than asserted, since GritQL's regex engine has no
+    // lookbehind — which also keeps `some-npm` from matching `npm`, and unlike a
+    // `\b` boundary still reaches a `@scope/name`.
+    (name)=>`npm (?:install|i|add)[^\\n]*?\\s${name}@([0-9][^${VERSION_TERMINATORS}]*)`,
+    // Held at a fixed version through an `npm pkg set` override, to clear a known
+    // vulnerability in a transitive dependency.
+    (name)=>`overrides\\.${name}=([^${VERSION_TERMINATORS}]+)`
+];
+/**
+ * Every pin a generated `Dockerfile` may carry, for the packages owned where it
+ * sits.
+ *
+ * Driven off the owned packages rather than a list of the ones that happen to be
+ * pinned today: a pin added to a template in a later release is then covered
+ * without this module changing, which is the whole point — the versions baked
+ * into image builds are pinned precisely because they clear a known
+ * vulnerability.
+ *
+ * A package the user pinned themselves is not owned, so it is never matched.
+ */ const dockerfilePins = (owned)=>{
+    const pins = [];
+    for (const name of owned.ts){
+        const vended = vendedTsVersion(name);
+        if (!vended) {
+            continue;
+        }
+        for (const shape of DOCKERFILE_PIN_SHAPES){
+            pins.push({
+                pattern: shape(escapeRegExp(name)),
+                vended
+            });
+        }
+    }
+    for (const image of Object.values(BASE_IMAGES)){
+        const [repository, tag] = splitImageReference(image);
+        pins.push({
+            // Only a `FROM` that is the whole instruction. A build stage names itself
+            // — `FROM <repo>:24 AS builder` — and picks its tag for what that stage has
+            // to run: the smithy builder needs curl and unzip, which the slim tag this
+            // release vends for a runtime image does not carry. Rewriting it would
+            // break the build, and the two share a repository, so the instruction
+            // ending is what separates them.
+            pattern: `FROM ${escapeRegExp(repository)}:([^\\s]+)\\n`,
+            vended: tag,
+            kind: 'tag'
+        });
+    }
+    return pins;
+};
+/**
+ * The repository and tag of a pinned image reference. The tag is the part after
+ * the last `:`, which a registry port would otherwise be mistaken for — every
+ * reference here carries one.
+ */ const splitImageReference = (image)=>{
+    const at = image.lastIndexOf(':');
+    return [
+        image.slice(0, at),
+        image.slice(at + 1)
+    ];
+};
+/**
+ * Whether a file is a Dockerfile: exactly `Dockerfile`, or the `<name>.Dockerfile`
+ * form the smithy templates vend as `build.Dockerfile`.
+ *
+ * Deliberately exact rather than a prefix match, which would also claim a
+ * `Dockerfile.bak` or a `Dockerfile.md` the user keeps beside a real one.
+ */ export const isDockerfile = (filePath)=>{
+    const name = filePath.split('/').pop() ?? '';
+    return name === 'Dockerfile' || name.endsWith('.Dockerfile');
+};
+/**
+ * Sync the pins in every generated Dockerfile.
+ *
+ * Ownership is resolved per file, so a Dockerfile is only rewritten for the
+ * packages the project it belongs to owns — a sibling project owning `prisma`
+ * does not license rewriting a `prisma` pin here.
+ */ const syncDockerfiles = async (tree, owned)=>{
+    const dockerfiles = [];
+    visitNotIgnoredFiles(tree, '.', (path)=>{
+        if (isDockerfile(path)) {
+            dockerfiles.push(path);
+        }
+    });
+    const skipped = [];
+    for (const path of dockerfiles){
+        const result = await applyPins(tree, path, dockerfilePins(ownedForFile(owned, path)));
+        if (result.skipped) {
+            skipped.push(path);
+        }
+    }
+    return skipped;
+};
+/** The `uv run --with` pins to apply, for the Python packages owned where a file sits. */ const terraformScriptPins = (owned)=>[
+        ...owned.py
+    ].flatMap((name)=>{
+        const vended = vendedPyVersion(name);
+        return vended ? [
+            {
+                pattern: `--with ${escapeRegExp(name)}==([^${VERSION_TERMINATORS}]+)`,
+                vended
+            }
+        ] : [];
+    });
+/**
+ * Sync the Python pins a generated Terraform inline script runs through
+ * `uv run --with <package>==<version>`.
+ *
+ * These are the plugin's own pins, in a file the Terraform provider sync already
+ * visits but only reads `required_providers` from. Driven off the owned Python
+ * packages, so a pin added to a template later is covered without a change here.
+ *
+ * Scoped per file like the Dockerfiles. The modules carrying these live in the
+ * shared Terraform project, which no single generator owns — a file there belongs
+ * to no project, so it takes the workspace-wide union, which is the set of
+ * generators that legitimately write into it.
+ */ const syncTerraformScriptPins = async (tree, owned)=>{
+    const terraformFiles = [];
+    visitNotIgnoredFiles(tree, '.', (path)=>{
+        if (path.endsWith('.tf')) {
+            terraformFiles.push(path);
+        }
+    });
+    const skipped = [];
+    for (const path of terraformFiles){
+        const result = await applyPins(tree, path, terraformScriptPins(ownedForFile(owned, path)));
+        if (result.skipped) {
+            skipped.push(path);
+        }
+    }
+    return skipped;
+};
+/**
+ * The ways a `uvx` invocation pins a Python version: the tool it runs, and any
+ * package it adds to that tool's environment.
+ *
+ * A command string is JSON here, so a quote ends a version too.
+ */ const UVX_PIN_SHAPES = [
+    (name)=>`uvx --from ${name}==`,
+    (name)=>`--with ${name}==`
+];
+/**
+ * Sync the pinned tools a `project.json` target command runs: a container image,
+ * and the Python versions a `uvx` invocation pins.
+ *
+ * Both are built into the command string rather than declared as a dependency, so
+ * nothing else reaches them. The images are driven off `CONTAINER_REPOSITORIES`
+ * and the Python versions off `PY_VERSIONS`, so a tool pinned in a target command
+ * later is covered without a change here — the same property the Dockerfile and
+ * Terraform paths get from the owned set.
+ *
+ * Unscoped, unlike the file-body pins: a `uvx` invocation installs nothing into
+ * the project, so there is no dependency for a generator to own. A version is only
+ * rewritten where this release vends that exact package at a higher one.
+ */ const syncTargetToolPins = async (tree)=>{
+    const projectJsons = [];
+    visitNotIgnoredFiles(tree, '.', (path)=>{
+        if (path.endsWith('project.json')) {
+            projectJsons.push(path);
+        }
+    });
+    const pins = [
+        ...Object.entries(CONTAINER_REPOSITORIES).map(([tool, repository])=>({
+                // A command string is JSON here, so a quote ends the reference too.
+                pattern: `${escapeRegExp(repository)}:([^${VERSION_TERMINATORS}']+)`,
+                vended: CONTAINER_VERSIONS[tool]
+            })),
+        // The Smithy CLI a Smithy project's compile target runs, and the `mise` that
+        // resolves it. Neither is installed into the workspace — the target fetches
+        // mise with `npx` — so this command is the only place either version sits.
+        {
+            pattern: `exec smithy@([^${VERSION_TERMINATORS}']+)`,
+            vended: MISE_VERSIONS.smithy
+        },
+        {
+            pattern: `npx -y mise@([^${VERSION_TERMINATORS}']+)`,
+            vended: TS_VERSIONS.mise
+        },
+        ...Object.keys(PY_VERSIONS).flatMap((name)=>{
+            const vended = vendedPyVersion(name);
+            return vended ? UVX_PIN_SHAPES.map((shape)=>({
+                    pattern: `${shape(escapeRegExp(name))}([^${VERSION_TERMINATORS}']+)`,
+                    vended
+                })) : [];
+        })
+    ];
+    const skipped = [];
+    for (const path of projectJsons){
+        if ((await applyPins(tree, path, pins)).skipped) {
+            skipped.push(path);
+        }
+    }
+    return skipped;
+};
+/**
+ * Sync the Maven coordinates a generated `smithy-build.json` resolves.
+ *
+ * These are Java artifacts the Smithy CLI downloads, so they appear in no
+ * manifest the dependency sync reads — this file is the only place they sit. Each
+ * is matched by its `group:artifact` prefix so only the version is rewritten,
+ * leaving any coordinate the user added alone.
+ *
+ * Scoped to the projects `smithy#project` generated: a `smithy-build.json` a user
+ * wrote themselves keeps the versions they chose.
+ */ const syncSmithyMavenPins = async (tree)=>{
+    const isGeneratedSmithyProject = (project)=>project.metadata?.generator === SMITHY_PROJECT_GENERATOR_INFO.id;
+    const smithyBuilds = [];
+    for (const [, project] of getProjects(tree)){
+        if (!isGeneratedSmithyProject(project)) {
+            continue;
+        }
+        const path = joinPathFragments(project.root, 'smithy-build.json');
+        if (tree.exists(path)) {
+            smithyBuilds.push(path);
+        }
+    }
+    const pins = JAVA_ARTIFACTS.map((artifact)=>({
+            // A coordinate is a JSON string here, so a quote ends the version.
+            pattern: `${escapeRegExp(artifact)}:([^${VERSION_TERMINATORS}']+)`,
+            vended: JAVA_VERSIONS[artifact]
+        }));
+    const skipped = [];
+    for (const path of smithyBuilds){
+        if ((await applyPins(tree, path, pins)).skipped) {
+            skipped.push(path);
+        }
+    }
+    return skipped;
+};
+/**
+ * Sync the vended versions baked into generated file bodies: `Dockerfile` pins,
+ * the Python pins in Terraform inline scripts, the tooling `project.json` target
+ * commands run, and the Maven coordinates a `smithy-build.json` resolves.
+ *
+ * Reports only the files left for the user: a pin that takes effect the next time
+ * the thing holding it runs needs no follow-up, but one this skipped for holding
+ * more occurrences than it will rewrite at once does.
+ *
+ * @returns paths whose pins were left as they were
+ */ export const syncEmbeddedVersions = async (tree, owned)=>[
+        ...await syncDockerfiles(tree, owned),
+        ...await syncTerraformScriptPins(tree, owned),
+        ...await syncTargetToolPins(tree),
+        ...await syncSmithyMavenPins(tree)
+    ];
+
+//# sourceMappingURL=sync-embedded-versions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/nx-plugin/src/utils/version-upgrade-migration/sync-embedded-versions.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\nimport type { ProjectConfiguration, Tree } from '@nx/devkit';\nimport {\n  getProjects,\n  joinPathFragments,\n  visitNotIgnoredFiles,\n} from '@nx/devkit';\nimport { SMITHY_PROJECT_GENERATOR_INFO } from '../../smithy/project/generator';\nimport { applyGritQL } from '../ast';\nimport {\n  BASE_IMAGES,\n  CONTAINER_REPOSITORIES,\n  CONTAINER_VERSIONS,\n  JAVA_ARTIFACTS,\n  JAVA_VERSIONS,\n  MISE_VERSIONS,\n  PY_VERSIONS,\n  TS_VERSIONS,\n} from '../versions';\nimport { type OwnedDependencies, ownedForFile } from './owned-dependencies';\nimport { isVendedUpgrade } from './vended-upgrade';\n\n/**\n * Sync the vended versions generators bake into the body of a file rather than\n * into a manifest: the container image pins in a `Dockerfile`, the Python pins\n * in a Terraform inline script, and the tooling images a `project.json` target\n * command runs.\n *\n * Every version here is pinned to clear a known HIGH/CRITICAL vulnerability, or\n * to keep a generated image reproducible, so leaving them behind strands a\n * workspace on exactly the versions most in need of an upgrade.\n *\n * These sit inside shell commands, which GritQL has no grammar for — so instead\n * of pattern-matching the surrounding syntax, each pin is located by an anchored\n * regex whose single capture group is the version, and only that capture is\n * rewritten. The file's own text around it is never reconstructed, so a\n * reformatted or hand-edited file syncs the same way a freshly generated one\n * does.\n */\n\n/** A pin found in a file body, and the version this release vends for it. */\ninterface EmbeddedPin {\n  /** Regex matching the pin, with the version as its only capture group. */\n  readonly pattern: string;\n  readonly vended: string;\n  /**\n   * Whether the declared value is a version to move forward, or a tag to replace\n   * whenever it differs. A tag — `lts-slim`, say — has no ordering to compare, so\n   * one that isn't what this release vends is simply out of date.\n   */\n  readonly kind?: 'version' | 'tag';\n}\n\n/** Escape a package name or image reference for use inside a regex. */\nconst escapeRegExp = (value: string): string =>\n  value.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n\n/**\n * Characters that end a pinned version: whitespace, the backslash continuing a\n * shell line, and the quote closing the string the pin sits in.\n *\n * The quote is escaped because the pattern is itself a double-quoted GritQL\n * regex literal, which a bare quote would terminate.\n */\nconst VERSION_TERMINATORS = '\\\\s\\\\\\\\\\\\\"';\n\n/**\n * Rewrite the capture group of an anchored regex to the vended version.\n *\n * The leading and trailing `[\\s\\S]*` anchor the match to the whole file, which\n * is what lets a capture group be rewritten on its own: GritQL binds the group\n * to a node it can replace, leaving every other byte untouched. Without the\n * anchors nothing matches.\n */\nconst rewriteCapture = (pattern: string, vended: string): string =>\n  `r\"[\\\\s\\\\S]*${pattern}[\\\\s\\\\S]*\"($version) where { $version => \\`${vended}\\` }`;\n\n/**\n * Versions a pin's regex currently matches in the file.\n *\n * Read before rewriting so a version the user raised past what this release\n * vends is left alone, matching how every other surface behaves.\n */\nconst declaredVersions = (contents: string, pattern: string): string[] => {\n  const matches = contents.matchAll(new RegExp(pattern, 'g'));\n  return [...matches].flatMap((match) => (match[1] ? [match[1]] : []));\n};\n\n/**\n * Occurrences of one pin a single rewrite will handle.\n *\n * GritQL rewrites each match separately, so its cost grows with how many a\n * pattern matches — ~10ms an occurrence, which a hand-authored file with hundreds\n * of `RUN npm install` lines turns into minutes of an unattended `nx migrate`.\n * Past this the file is left alone and reported, since a wrong version the user\n * can see and fix beats an upgrade that appears to hang.\n */\nconst MAX_OCCURRENCES_PER_PIN = 100;\n\n/**\n * Apply the pins whose declared version this release moves forward.\n *\n * A single rewrite covers every occurrence of a pin in the file, so each pin is\n * applied once. Reports whether anything changed, and whether a pin was left\n * alone for exceeding {@link MAX_OCCURRENCES_PER_PIN}.\n */\nconst applyPins = async (\n  tree: Tree,\n  path: string,\n  pins: readonly EmbeddedPin[],\n): Promise<{ changed: boolean; skipped: boolean }> => {\n  // Read once and re-read only after a rewrite: a rewrite parses the whole file,\n  // and there is a pin per owned package, so re-reading per pin would scale the\n  // cost of a large file with the size of the owned set.\n  let contents = tree.read(path, 'utf-8') ?? '';\n  let changed = false;\n  let skipped = false;\n\n  for (const { pattern, vended, kind = 'version' } of pins) {\n    const declared = declaredVersions(contents, pattern);\n    if (declared.length === 0) {\n      continue;\n    }\n    if (declared.length > MAX_OCCURRENCES_PER_PIN) {\n      skipped = true;\n      continue;\n    }\n    const outOfDate =\n      kind === 'tag'\n        ? (tag: string) => tag !== vended\n        : (version: string) => isVendedUpgrade(vended, version);\n    // A rewrite replaces every occurrence at once, so this must hold for all of\n    // them — a pin already at or beyond the vended version is left as it is.\n    if (!declared.every(outOfDate)) {\n      continue;\n    }\n    if (await applyGritQL(tree, path, rewriteCapture(pattern, vended))) {\n      contents = tree.read(path, 'utf-8') ?? '';\n      changed = true;\n    }\n  }\n\n  return { changed, skipped };\n};\n\n/**\n * The version this release vends for a package, or undefined for one it doesn't\n * vend at all.\n *\n * Ownership is applied by the caller, which only ever passes a name drawn from\n * the owned set — so a package the user pinned themselves never reaches here and\n * keeps the version they chose.\n */\nconst vendedTsVersion = (name: string): string | undefined =>\n  TS_VERSIONS[name as keyof typeof TS_VERSIONS];\n\n/** `PY_VERSIONS` records the `==` operator; a pin holds the bare version. */\nconst vendedPyVersion = (name: string): string | undefined =>\n  PY_VERSIONS[name as keyof typeof PY_VERSIONS]?.replace(/^==/, '');\n\n/**\n * The ways a generated `Dockerfile` pins a TypeScript package's version, as\n * regex fragments taking the escaped package name.\n *\n * The name is required to run to its delimiter, so a package whose name merely\n * ends with another's — `some-npm` against `npm` — cannot match, and an\n * installed version must start with a digit so a `@latest` style tag is left\n * alone.\n */\nconst DOCKERFILE_PIN_SHAPES: readonly ((name: string) => string)[] = [\n  // Installed by the image build. `install` and its `i` alias are both used, as\n  // are `-g` and several packages in one command, so the name only has to follow\n  // an `npm` subcommand rather than sit right after it. The whitespace before it\n  // is matched rather than asserted, since GritQL's regex engine has no\n  // lookbehind — which also keeps `some-npm` from matching `npm`, and unlike a\n  // `\\b` boundary still reaches a `@scope/name`.\n  (name) =>\n    `npm (?:install|i|add)[^\\\\n]*?\\\\s${name}@([0-9][^${VERSION_TERMINATORS}]*)`,\n  // Held at a fixed version through an `npm pkg set` override, to clear a known\n  // vulnerability in a transitive dependency.\n  (name) => `overrides\\\\.${name}=([^${VERSION_TERMINATORS}]+)`,\n];\n\n/**\n * Every pin a generated `Dockerfile` may carry, for the packages owned where it\n * sits.\n *\n * Driven off the owned packages rather than a list of the ones that happen to be\n * pinned today: a pin added to a template in a later release is then covered\n * without this module changing, which is the whole point — the versions baked\n * into image builds are pinned precisely because they clear a known\n * vulnerability.\n *\n * A package the user pinned themselves is not owned, so it is never matched.\n */\nconst dockerfilePins = (owned: {\n  readonly ts: ReadonlySet<string>;\n}): EmbeddedPin[] => {\n  const pins: EmbeddedPin[] = [];\n\n  for (const name of owned.ts) {\n    const vended = vendedTsVersion(name);\n    if (!vended) {\n      continue;\n    }\n    for (const shape of DOCKERFILE_PIN_SHAPES) {\n      pins.push({ pattern: shape(escapeRegExp(name)), vended });\n    }\n  }\n\n  for (const image of Object.values(BASE_IMAGES)) {\n    const [repository, tag] = splitImageReference(image);\n    pins.push({\n      // Only a `FROM` that is the whole instruction. A build stage names itself\n      // — `FROM <repo>:24 AS builder` — and picks its tag for what that stage has\n      // to run: the smithy builder needs curl and unzip, which the slim tag this\n      // release vends for a runtime image does not carry. Rewriting it would\n      // break the build, and the two share a repository, so the instruction\n      // ending is what separates them.\n      pattern: `FROM ${escapeRegExp(repository)}:([^\\\\s]+)\\\\n`,\n      vended: tag,\n      kind: 'tag',\n    });\n  }\n\n  return pins;\n};\n\n/**\n * The repository and tag of a pinned image reference. The tag is the part after\n * the last `:`, which a registry port would otherwise be mistaken for — every\n * reference here carries one.\n */\nconst splitImageReference = (image: string): [string, string] => {\n  const at = image.lastIndexOf(':');\n  return [image.slice(0, at), image.slice(at + 1)];\n};\n\n/**\n * Whether a file is a Dockerfile: exactly `Dockerfile`, or the `<name>.Dockerfile`\n * form the smithy templates vend as `build.Dockerfile`.\n *\n * Deliberately exact rather than a prefix match, which would also claim a\n * `Dockerfile.bak` or a `Dockerfile.md` the user keeps beside a real one.\n */\nexport const isDockerfile = (filePath: string): boolean => {\n  const name = filePath.split('/').pop() ?? '';\n  return name === 'Dockerfile' || name.endsWith('.Dockerfile');\n};\n\n/**\n * Sync the pins in every generated Dockerfile.\n *\n * Ownership is resolved per file, so a Dockerfile is only rewritten for the\n * packages the project it belongs to owns — a sibling project owning `prisma`\n * does not license rewriting a `prisma` pin here.\n */\nconst syncDockerfiles = async (\n  tree: Tree,\n  owned: OwnedDependencies,\n): Promise<string[]> => {\n  const dockerfiles: string[] = [];\n\n  visitNotIgnoredFiles(tree, '.', (path) => {\n    if (isDockerfile(path)) {\n      dockerfiles.push(path);\n    }\n  });\n\n  const skipped: string[] = [];\n  for (const path of dockerfiles) {\n    const result = await applyPins(\n      tree,\n      path,\n      dockerfilePins(ownedForFile(owned, path)),\n    );\n    if (result.skipped) {\n      skipped.push(path);\n    }\n  }\n  return skipped;\n};\n\n/** The `uv run --with` pins to apply, for the Python packages owned where a file sits. */\nconst terraformScriptPins = (owned: {\n  readonly py: ReadonlySet<string>;\n}): EmbeddedPin[] =>\n  [...owned.py].flatMap((name) => {\n    const vended = vendedPyVersion(name);\n    return vended\n      ? [\n          {\n            pattern: `--with ${escapeRegExp(name)}==([^${VERSION_TERMINATORS}]+)`,\n            vended,\n          },\n        ]\n      : [];\n  });\n\n/**\n * Sync the Python pins a generated Terraform inline script runs through\n * `uv run --with <package>==<version>`.\n *\n * These are the plugin's own pins, in a file the Terraform provider sync already\n * visits but only reads `required_providers` from. Driven off the owned Python\n * packages, so a pin added to a template later is covered without a change here.\n *\n * Scoped per file like the Dockerfiles. The modules carrying these live in the\n * shared Terraform project, which no single generator owns — a file there belongs\n * to no project, so it takes the workspace-wide union, which is the set of\n * generators that legitimately write into it.\n */\nconst syncTerraformScriptPins = async (\n  tree: Tree,\n  owned: OwnedDependencies,\n): Promise<string[]> => {\n  const terraformFiles: string[] = [];\n\n  visitNotIgnoredFiles(tree, '.', (path) => {\n    if (path.endsWith('.tf')) {\n      terraformFiles.push(path);\n    }\n  });\n\n  const skipped: string[] = [];\n  for (const path of terraformFiles) {\n    const result = await applyPins(\n      tree,\n      path,\n      terraformScriptPins(ownedForFile(owned, path)),\n    );\n    if (result.skipped) {\n      skipped.push(path);\n    }\n  }\n  return skipped;\n};\n\n/**\n * The ways a `uvx` invocation pins a Python version: the tool it runs, and any\n * package it adds to that tool's environment.\n *\n * A command string is JSON here, so a quote ends a version too.\n */\nconst UVX_PIN_SHAPES: readonly ((name: string) => string)[] = [\n  (name) => `uvx --from ${name}==`,\n  (name) => `--with ${name}==`,\n];\n\n/**\n * Sync the pinned tools a `project.json` target command runs: a container image,\n * and the Python versions a `uvx` invocation pins.\n *\n * Both are built into the command string rather than declared as a dependency, so\n * nothing else reaches them. The images are driven off `CONTAINER_REPOSITORIES`\n * and the Python versions off `PY_VERSIONS`, so a tool pinned in a target command\n * later is covered without a change here — the same property the Dockerfile and\n * Terraform paths get from the owned set.\n *\n * Unscoped, unlike the file-body pins: a `uvx` invocation installs nothing into\n * the project, so there is no dependency for a generator to own. A version is only\n * rewritten where this release vends that exact package at a higher one.\n */\nconst syncTargetToolPins = async (tree: Tree): Promise<string[]> => {\n  const projectJsons: string[] = [];\n\n  visitNotIgnoredFiles(tree, '.', (path) => {\n    if (path.endsWith('project.json')) {\n      projectJsons.push(path);\n    }\n  });\n\n  const pins: EmbeddedPin[] = [\n    ...Object.entries(CONTAINER_REPOSITORIES).map(([tool, repository]) => ({\n      // A command string is JSON here, so a quote ends the reference too.\n      pattern: `${escapeRegExp(repository)}:([^${VERSION_TERMINATORS}']+)`,\n      vended: CONTAINER_VERSIONS[tool as keyof typeof CONTAINER_VERSIONS],\n    })),\n    // The Smithy CLI a Smithy project's compile target runs, and the `mise` that\n    // resolves it. Neither is installed into the workspace — the target fetches\n    // mise with `npx` — so this command is the only place either version sits.\n    {\n      pattern: `exec smithy@([^${VERSION_TERMINATORS}']+)`,\n      vended: MISE_VERSIONS.smithy,\n    },\n    {\n      pattern: `npx -y mise@([^${VERSION_TERMINATORS}']+)`,\n      vended: TS_VERSIONS.mise,\n    },\n    ...Object.keys(PY_VERSIONS).flatMap((name) => {\n      const vended = vendedPyVersion(name);\n      return vended\n        ? UVX_PIN_SHAPES.map((shape) => ({\n            pattern: `${shape(escapeRegExp(name))}([^${VERSION_TERMINATORS}']+)`,\n            vended,\n          }))\n        : [];\n    }),\n  ];\n\n  const skipped: string[] = [];\n  for (const path of projectJsons) {\n    if ((await applyPins(tree, path, pins)).skipped) {\n      skipped.push(path);\n    }\n  }\n  return skipped;\n};\n\n/**\n * Sync the Maven coordinates a generated `smithy-build.json` resolves.\n *\n * These are Java artifacts the Smithy CLI downloads, so they appear in no\n * manifest the dependency sync reads — this file is the only place they sit. Each\n * is matched by its `group:artifact` prefix so only the version is rewritten,\n * leaving any coordinate the user added alone.\n *\n * Scoped to the projects `smithy#project` generated: a `smithy-build.json` a user\n * wrote themselves keeps the versions they chose.\n */\nconst syncSmithyMavenPins = async (tree: Tree): Promise<string[]> => {\n  const isGeneratedSmithyProject = (project: ProjectConfiguration): boolean =>\n    (project.metadata as { generator?: string } | undefined)?.generator ===\n    SMITHY_PROJECT_GENERATOR_INFO.id;\n\n  const smithyBuilds: string[] = [];\n  for (const [, project] of getProjects(tree)) {\n    if (!isGeneratedSmithyProject(project)) {\n      continue;\n    }\n    const path = joinPathFragments(project.root, 'smithy-build.json');\n    if (tree.exists(path)) {\n      smithyBuilds.push(path);\n    }\n  }\n\n  const pins: EmbeddedPin[] = JAVA_ARTIFACTS.map((artifact) => ({\n    // A coordinate is a JSON string here, so a quote ends the version.\n    pattern: `${escapeRegExp(artifact)}:([^${VERSION_TERMINATORS}']+)`,\n    vended: JAVA_VERSIONS[artifact],\n  }));\n\n  const skipped: string[] = [];\n  for (const path of smithyBuilds) {\n    if ((await applyPins(tree, path, pins)).skipped) {\n      skipped.push(path);\n    }\n  }\n  return skipped;\n};\n\n/**\n * Sync the vended versions baked into generated file bodies: `Dockerfile` pins,\n * the Python pins in Terraform inline scripts, the tooling `project.json` target\n * commands run, and the Maven coordinates a `smithy-build.json` resolves.\n *\n * Reports only the files left for the user: a pin that takes effect the next time\n * the thing holding it runs needs no follow-up, but one this skipped for holding\n * more occurrences than it will rewrite at once does.\n *\n * @returns paths whose pins were left as they were\n */\nexport const syncEmbeddedVersions = async (\n  tree: Tree,\n  owned: OwnedDependencies,\n): Promise<string[]> => [\n  ...(await syncDockerfiles(tree, owned)),\n  ...(await syncTerraformScriptPins(tree, owned)),\n  ...(await syncTargetToolPins(tree)),\n  ...(await syncSmithyMavenPins(tree)),\n];\n"],"names":["getProjects","joinPathFragments","visitNotIgnoredFiles","SMITHY_PROJECT_GENERATOR_INFO","applyGritQL","BASE_IMAGES","CONTAINER_REPOSITORIES","CONTAINER_VERSIONS","JAVA_ARTIFACTS","JAVA_VERSIONS","MISE_VERSIONS","PY_VERSIONS","TS_VERSIONS","ownedForFile","isVendedUpgrade","escapeRegExp","value","replace","VERSION_TERMINATORS","rewriteCapture","pattern","vended","declaredVersions","contents","matches","matchAll","RegExp","flatMap","match","MAX_OCCURRENCES_PER_PIN","applyPins","tree","path","pins","read","changed","skipped","kind","declared","length","outOfDate","tag","version","every","vendedTsVersion","name","vendedPyVersion","DOCKERFILE_PIN_SHAPES","dockerfilePins","owned","ts","shape","push","image","Object","values","repository","splitImageReference","at","lastIndexOf","slice","isDockerfile","filePath","split","pop","endsWith","syncDockerfiles","dockerfiles","result","terraformScriptPins","py","syncTerraformScriptPins","terraformFiles","UVX_PIN_SHAPES","syncTargetToolPins","projectJsons","entries","map","tool","smithy","mise","keys","syncSmithyMavenPins","isGeneratedSmithyProject","project","metadata","generator","id","smithyBuilds","root","exists","artifact","syncEmbeddedVersions"],"mappings":"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"}

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>;