@aws/nx-plugin 1.0.0-rc.9 → 1.0.0-rc.90

package/src/utils/ruff.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Rules whose fixes are applied to generated Python.
+ *
+ * `ruff_wasm`'s `check` serialises every fix without its applicability (the
+ * `Fix::applicability()` it drops is what `ruff check --fix` filters on) and
+ * ignores `unsafe-fixes`, so it cannot be asked for only the fixes the CLI would
+ * apply. Taking them all would rewrite `if x == True` to `if x`.
+ *
+ * Ruff's `fixable` setting filters inside the linter, which keeps the decision
+ * in ruff — but it selects by *rule*, and applicability is a property of each
+ * *diagnostic*: across ruff's own 1598 lint fixtures, 27 rules under the vended
+ * selection emit both safe and unsafe fixes depending on the code (one `UP008`
+ * is safe, another is unsafe when dropping the arguments would take a comment
+ * with them). So no rule list, allowing or denying, can reproduce `--fix`: for
+ * those 27 it can only take both or neither.
+ *
+ * Given that, the list stays as small as generation needs rather than reaching
+ * for an equivalence it cannot have. These four cover the import hygiene
+ * generation itself creates by merging imports into existing files, and ruff
+ * documents each of their fixes as safe — except F401 in an `__init__.py`, which
+ * is excluded below. Templates are authored free of other violations, so nothing
+ * else needs fixing here, and the user's own `lint --configuration=fix` remains
+ * the full-fidelity path. A test re-checks these against ruff's own docs.
+ */
+export declare const FIXABLE_RULES: string[];
+/**
+ * The ruff release these bindings are built from. `@astral-sh/ruff-wasm-nodejs`
+ * is published from the ruff repo on every release, so its versions track ruff's
+ * exactly — keep this in step with `PY_VERSIONS.ruff` (the ruff the vended
+ * `format` and `lint` targets run) so generated files stay `ruff format
+ * --check`-clean on disk. A test asserts the two agree.
+ */
+export declare const RUFF_WASM_VERSION: string;
+/** Ruff settings, as accepted by the WASM `Workspace` constructor. */
+export interface RuffOptions {
+    readonly 'line-length'?: number;
+    readonly 'target-version'?: string;
+    readonly lint?: {
+        readonly select?: readonly string[];
+        readonly 'extend-select'?: readonly string[];
+        readonly fixable?: readonly string[];
+        readonly unfixable?: readonly string[];
+        readonly isort?: {
+            readonly 'known-first-party'?: readonly string[];
+        };
+    };
+}
+/**
+ * Apply ruff's lint fixes and formatter to Python content, in process.
+ *
+ * Equivalent to piping the content through `ruff check --fix` then `ruff
+ * format` — the tools the vended `lint` and `format` targets run — without
+ * paying two process spawns per file.
+ */
+export declare const ruffFixAndFormat: (content: string, filePath: string, options: RuffOptions) => string;

package/src/utils/ruff.js

@@ -0,0 +1,140 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */ import { PositionEncoding, Workspace } from "@astral-sh/ruff-wasm-nodejs";
+import path from "path";
+/**
+ * Rules whose fixes are applied to generated Python.
+ *
+ * `ruff_wasm`'s `check` serialises every fix without its applicability (the
+ * `Fix::applicability()` it drops is what `ruff check --fix` filters on) and
+ * ignores `unsafe-fixes`, so it cannot be asked for only the fixes the CLI would
+ * apply. Taking them all would rewrite `if x == True` to `if x`.
+ *
+ * Ruff's `fixable` setting filters inside the linter, which keeps the decision
+ * in ruff — but it selects by *rule*, and applicability is a property of each
+ * *diagnostic*: across ruff's own 1598 lint fixtures, 27 rules under the vended
+ * selection emit both safe and unsafe fixes depending on the code (one `UP008`
+ * is safe, another is unsafe when dropping the arguments would take a comment
+ * with them). So no rule list, allowing or denying, can reproduce `--fix`: for
+ * those 27 it can only take both or neither.
+ *
+ * Given that, the list stays as small as generation needs rather than reaching
+ * for an equivalence it cannot have. These four cover the import hygiene
+ * generation itself creates by merging imports into existing files, and ruff
+ * documents each of their fixes as safe — except F401 in an `__init__.py`, which
+ * is excluded below. Templates are authored free of other violations, so nothing
+ * else needs fixing here, and the user's own `lint --configuration=fix` remains
+ * the full-fidelity path. A test re-checks these against ruff's own docs.
+ */ export const FIXABLE_RULES = [
+    'I001',
+    'F401',
+    'F811',
+    'E401'
+];
+/** Escape hatch matching ruff's own fix loop bound. */ const MAX_FIX_ITERATIONS = 100;
+/**
+ * The ruff release these bindings are built from. `@astral-sh/ruff-wasm-nodejs`
+ * is published from the ruff repo on every release, so its versions track ruff's
+ * exactly — keep this in step with `PY_VERSIONS.ruff` (the ruff the vended
+ * `format` and `lint` targets run) so generated files stay `ruff format
+ * --check`-clean on disk. A test asserts the two agree.
+ */ export const RUFF_WASM_VERSION = Workspace.version();
+/**
+ * Apply one diagnostic's fix, resolving ruff's (row, column) positions against
+ * the content. Positions are requested in UTF-16, which is how JavaScript
+ * already indexes strings, so they need no transcoding.
+ */ const applyFix = (content, edits)=>{
+    const lineStarts = [
+        0
+    ];
+    for(let i = 0; i < content.length; i++){
+        if (content[i] === '\n') {
+            lineStarts.push(i + 1);
+        }
+    }
+    // Ruff can report a position one past the last line (eg when deleting a
+    // trailing line), so clamp rather than indexing past the end.
+    const offsetOf = (location)=>(lineStarts[location.row - 1] ?? content.length) + (location.column - 1);
+    let result = '';
+    let end = 0;
+    for (const edit of [
+        ...edits
+    ].sort((a, b)=>offsetOf(a.location) - offsetOf(b.location))){
+        const start = offsetOf(edit.location);
+        if (start < end) {
+            continue;
+        }
+        result += content.slice(end, start) + (edit.content ?? '');
+        end = offsetOf(edit.end_location);
+    }
+    return result + content.slice(end);
+};
+/**
+ * Ruff treats an `__init__.py` as re-exporting its imports, so an unused import
+ * there gets a diagnostic with no fix — removing it would drop the package's
+ * public API. `ruff_wasm` lints under a fixed placeholder filename and so cannot
+ * apply this itself, making the file's real name the caller's to account for.
+ */ const isInitPy = (filePath)=>path.basename(filePath) === '__init__.py';
+/**
+ * A `Workspace` costs far more to construct than to run, and the same settings
+ * recur across every file of a project, so key them by the resolved options.
+ */ const _workspaces = new Map();
+const getWorkspace = (options)=>{
+    const key = JSON.stringify(options);
+    let workspace = _workspaces.get(key);
+    if (!workspace) {
+        workspace = new Workspace(options, PositionEncoding.Utf16);
+        _workspaces.set(key, workspace);
+    }
+    return workspace;
+};
+/**
+ * Apply ruff's lint fixes and formatter to Python content, in process.
+ *
+ * Equivalent to piping the content through `ruff check --fix` then `ruff
+ * format` — the tools the vended `lint` and `format` targets run — without
+ * paying two process spawns per file.
+ */ export const ruffFixAndFormat = (content, filePath, options)=>{
+    const workspace = getWorkspace({
+        ...options,
+        lint: {
+            ...options.lint,
+            fixable: FIXABLE_RULES,
+            // Never drop an `__init__.py` import: ruff keeps these as re-exports.
+            ...isInitPy(filePath) ? {
+                unfixable: [
+                    'F401'
+                ]
+            } : {}
+        }
+    });
+    // Apply a single fix per pass and re-lint, as ruff does until the content
+    // stabilises. Taking one fix at a time leaves ruff to decide what is
+    // applicable against the current content, rather than reproducing how it
+    // batches, orders and skips overlapping fixes within a pass.
+    for(let i = 0; i < MAX_FIX_ITERATIONS; i++){
+        let diagnostic;
+        try {
+            diagnostic = workspace.check(content).find((d)=>d.fix && d.fix.edits.length > 0);
+        } catch  {
+            break;
+        }
+        if (!diagnostic?.fix) {
+            break;
+        }
+        const fixed = applyFix(content, diagnostic.fix.edits);
+        if (fixed === content) {
+            break;
+        }
+        content = fixed;
+    }
+    try {
+        return workspace.format(content);
+    } catch  {
+        // Leave content the formatter rejects (eg a syntax error) as-is.
+        return content;
+    }
+};
+
+//# sourceMappingURL=ruff.js.map

package/src/utils/ruff.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../packages/nx-plugin/src/utils/ruff.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { PositionEncoding, Workspace } from '@astral-sh/ruff-wasm-nodejs';\nimport path from 'path';\n\n/**\n * Rules whose fixes are applied to generated Python.\n *\n * `ruff_wasm`'s `check` serialises every fix without its applicability (the\n * `Fix::applicability()` it drops is what `ruff check --fix` filters on) and\n * ignores `unsafe-fixes`, so it cannot be asked for only the fixes the CLI would\n * apply. Taking them all would rewrite `if x == True` to `if x`.\n *\n * Ruff's `fixable` setting filters inside the linter, which keeps the decision\n * in ruff — but it selects by *rule*, and applicability is a property of each\n * *diagnostic*: across ruff's own 1598 lint fixtures, 27 rules under the vended\n * selection emit both safe and unsafe fixes depending on the code (one `UP008`\n * is safe, another is unsafe when dropping the arguments would take a comment\n * with them). So no rule list, allowing or denying, can reproduce `--fix`: for\n * those 27 it can only take both or neither.\n *\n * Given that, the list stays as small as generation needs rather than reaching\n * for an equivalence it cannot have. These four cover the import hygiene\n * generation itself creates by merging imports into existing files, and ruff\n * documents each of their fixes as safe — except F401 in an `__init__.py`, which\n * is excluded below. Templates are authored free of other violations, so nothing\n * else needs fixing here, and the user's own `lint --configuration=fix` remains\n * the full-fidelity path. A test re-checks these against ruff's own docs.\n */\nexport const FIXABLE_RULES = ['I001', 'F401', 'F811', 'E401'];\n\n/** Escape hatch matching ruff's own fix loop bound. */\nconst MAX_FIX_ITERATIONS = 100;\n\n/**\n * The ruff release these bindings are built from. `@astral-sh/ruff-wasm-nodejs`\n * is published from the ruff repo on every release, so its versions track ruff's\n * exactly — keep this in step with `PY_VERSIONS.ruff` (the ruff the vended\n * `format` and `lint` targets run) so generated files stay `ruff format\n * --check`-clean on disk. A test asserts the two agree.\n */\nexport const RUFF_WASM_VERSION = Workspace.version();\n\ninterface Location {\n  readonly row: number;\n  readonly column: number;\n}\n\ninterface Edit {\n  readonly content: string | null;\n  readonly location: Location;\n  readonly end_location: Location;\n}\n\ninterface Diagnostic {\n  readonly fix: { readonly edits: readonly Edit[] } | null;\n}\n\n/** Ruff settings, as accepted by the WASM `Workspace` constructor. */\nexport interface RuffOptions {\n  readonly 'line-length'?: number;\n  readonly 'target-version'?: string;\n  readonly lint?: {\n    readonly select?: readonly string[];\n    readonly 'extend-select'?: readonly string[];\n    readonly fixable?: readonly string[];\n    readonly unfixable?: readonly string[];\n    readonly isort?: { readonly 'known-first-party'?: readonly string[] };\n  };\n}\n\n/**\n * Apply one diagnostic's fix, resolving ruff's (row, column) positions against\n * the content. Positions are requested in UTF-16, which is how JavaScript\n * already indexes strings, so they need no transcoding.\n */\nconst applyFix = (content: string, edits: readonly Edit[]): string => {\n  const lineStarts = [0];\n  for (let i = 0; i < content.length; i++) {\n    if (content[i] === '\\n') {\n      lineStarts.push(i + 1);\n    }\n  }\n  // Ruff can report a position one past the last line (eg when deleting a\n  // trailing line), so clamp rather than indexing past the end.\n  const offsetOf = (location: Location): number =>\n    (lineStarts[location.row - 1] ?? content.length) + (location.column - 1);\n\n  let result = '';\n  let end = 0;\n  for (const edit of [...edits].sort(\n    (a, b) => offsetOf(a.location) - offsetOf(b.location),\n  )) {\n    const start = offsetOf(edit.location);\n    if (start < end) {\n      continue;\n    }\n    result += content.slice(end, start) + (edit.content ?? '');\n    end = offsetOf(edit.end_location);\n  }\n  return result + content.slice(end);\n};\n\n/**\n * Ruff treats an `__init__.py` as re-exporting its imports, so an unused import\n * there gets a diagnostic with no fix — removing it would drop the package's\n * public API. `ruff_wasm` lints under a fixed placeholder filename and so cannot\n * apply this itself, making the file's real name the caller's to account for.\n */\nconst isInitPy = (filePath: string): boolean =>\n  path.basename(filePath) === '__init__.py';\n\n/**\n * A `Workspace` costs far more to construct than to run, and the same settings\n * recur across every file of a project, so key them by the resolved options.\n */\nconst _workspaces = new Map<string, Workspace>();\nconst getWorkspace = (options: RuffOptions): Workspace => {\n  const key = JSON.stringify(options);\n  let workspace = _workspaces.get(key);\n  if (!workspace) {\n    workspace = new Workspace(options, PositionEncoding.Utf16);\n    _workspaces.set(key, workspace);\n  }\n  return workspace;\n};\n\n/**\n * Apply ruff's lint fixes and formatter to Python content, in process.\n *\n * Equivalent to piping the content through `ruff check --fix` then `ruff\n * format` — the tools the vended `lint` and `format` targets run — without\n * paying two process spawns per file.\n */\nexport const ruffFixAndFormat = (\n  content: string,\n  filePath: string,\n  options: RuffOptions,\n): string => {\n  const workspace = getWorkspace({\n    ...options,\n    lint: {\n      ...options.lint,\n      fixable: FIXABLE_RULES,\n      // Never drop an `__init__.py` import: ruff keeps these as re-exports.\n      ...(isInitPy(filePath) ? { unfixable: ['F401'] } : {}),\n    },\n  });\n\n  // Apply a single fix per pass and re-lint, as ruff does until the content\n  // stabilises. Taking one fix at a time leaves ruff to decide what is\n  // applicable against the current content, rather than reproducing how it\n  // batches, orders and skips overlapping fixes within a pass.\n  for (let i = 0; i < MAX_FIX_ITERATIONS; i++) {\n    let diagnostic: Diagnostic | undefined;\n    try {\n      diagnostic = (workspace.check(content) as Diagnostic[]).find(\n        (d) => d.fix && d.fix.edits.length > 0,\n      );\n    } catch {\n      // Content that does not parse has nothing to fix; still try to format it.\n      break;\n    }\n    if (!diagnostic?.fix) {\n      break;\n    }\n    const fixed = applyFix(content, diagnostic.fix.edits);\n    if (fixed === content) {\n      break;\n    }\n    content = fixed;\n  }\n\n  try {\n    return workspace.format(content);\n  } catch {\n    // Leave content the formatter rejects (eg a syntax error) as-is.\n    return content;\n  }\n};\n"],"names":["PositionEncoding","Workspace","path","FIXABLE_RULES","MAX_FIX_ITERATIONS","RUFF_WASM_VERSION","version","applyFix","content","edits","lineStarts","i","length","push","offsetOf","location","row","column","result","end","edit","sort","a","b","start","slice","end_location","isInitPy","filePath","basename","_workspaces","Map","getWorkspace","options","key","JSON","stringify","workspace","get","Utf16","set","ruffFixAndFormat","lint","fixable","unfixable","diagnostic","check","find","d","fix","fixed","format"],"mappings":"AAAA;;;CAGC,GAED,SAASA,gBAAgB,EAAEC,SAAS,QAAQ,8BAA8B;AAC1E,OAAOC,UAAU,OAAO;AAExB;;;;;;;;;;;;;;;;;;;;;;;CAuBC,GACD,OAAO,MAAMC,gBAAgB;IAAC;IAAQ;IAAQ;IAAQ;CAAO,CAAC;AAE9D,qDAAqD,GACrD,MAAMC,qBAAqB;AAE3B;;;;;;CAMC,GACD,OAAO,MAAMC,oBAAoBJ,UAAUK,OAAO,GAAG;AA8BrD;;;;CAIC,GACD,MAAMC,WAAW,CAACC,SAAiBC;IACjC,MAAMC,aAAa;QAAC;KAAE;IACtB,IAAK,IAAIC,IAAI,GAAGA,IAAIH,QAAQI,MAAM,EAAED,IAAK;QACvC,IAAIH,OAAO,CAACG,EAAE,KAAK,MAAM;YACvBD,WAAWG,IAAI,CAACF,IAAI;QACtB;IACF;IACA,wEAAwE;IACxE,8DAA8D;IAC9D,MAAMG,WAAW,CAACC,WAChB,AAACL,CAAAA,UAAU,CAACK,SAASC,GAAG,GAAG,EAAE,IAAIR,QAAQI,MAAM,AAAD,IAAMG,CAAAA,SAASE,MAAM,GAAG,CAAA;IAExE,IAAIC,SAAS;IACb,IAAIC,MAAM;IACV,KAAK,MAAMC,QAAQ;WAAIX;KAAM,CAACY,IAAI,CAChC,CAACC,GAAGC,IAAMT,SAASQ,EAAEP,QAAQ,IAAID,SAASS,EAAER,QAAQ,GACnD;QACD,MAAMS,QAAQV,SAASM,KAAKL,QAAQ;QACpC,IAAIS,QAAQL,KAAK;YACf;QACF;QACAD,UAAUV,QAAQiB,KAAK,CAACN,KAAKK,SAAUJ,CAAAA,KAAKZ,OAAO,IAAI,EAAC;QACxDW,MAAML,SAASM,KAAKM,YAAY;IAClC;IACA,OAAOR,SAASV,QAAQiB,KAAK,CAACN;AAChC;AAEA;;;;;CAKC,GACD,MAAMQ,WAAW,CAACC,WAChB1B,KAAK2B,QAAQ,CAACD,cAAc;AAE9B;;;CAGC,GACD,MAAME,cAAc,IAAIC;AACxB,MAAMC,eAAe,CAACC;IACpB,MAAMC,MAAMC,KAAKC,SAAS,CAACH;IAC3B,IAAII,YAAYP,YAAYQ,GAAG,CAACJ;IAChC,IAAI,CAACG,WAAW;QACdA,YAAY,IAAIpC,UAAUgC,SAASjC,iBAAiBuC,KAAK;QACzDT,YAAYU,GAAG,CAACN,KAAKG;IACvB;IACA,OAAOA;AACT;AAEA;;;;;;CAMC,GACD,OAAO,MAAMI,mBAAmB,CAC9BjC,SACAoB,UACAK;IAEA,MAAMI,YAAYL,aAAa;QAC7B,GAAGC,OAAO;QACVS,MAAM;YACJ,GAAGT,QAAQS,IAAI;YACfC,SAASxC;YACT,sEAAsE;YACtE,GAAIwB,SAASC,YAAY;gBAAEgB,WAAW;oBAAC;iBAAO;YAAC,IAAI,CAAC,CAAC;QACvD;IACF;IAEA,0EAA0E;IAC1E,qEAAqE;IACrE,yEAAyE;IACzE,6DAA6D;IAC7D,IAAK,IAAIjC,IAAI,GAAGA,IAAIP,oBAAoBO,IAAK;QAC3C,IAAIkC;QACJ,IAAI;YACFA,aAAa,AAACR,UAAUS,KAAK,CAACtC,SAA0BuC,IAAI,CAC1D,CAACC,IAAMA,EAAEC,GAAG,IAAID,EAAEC,GAAG,CAACxC,KAAK,CAACG,MAAM,GAAG;QAEzC,EAAE,OAAM;YAEN;QACF;QACA,IAAI,CAACiC,YAAYI,KAAK;YACpB;QACF;QACA,MAAMC,QAAQ3C,SAASC,SAASqC,WAAWI,GAAG,CAACxC,KAAK;QACpD,IAAIyC,UAAU1C,SAAS;YACrB;QACF;QACAA,UAAU0C;IACZ;IAEA,IAAI;QACF,OAAOb,UAAUc,MAAM,CAAC3C;IAC1B,EAAE,OAAM;QACN,iEAAiE;QACjE,OAAOA;IACT;AACF,EAAE"}

package/src/utils/shared-constructs-constants.d.ts

@@ -1,7 +1,3 @@
-/**
- * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
 export declare const PACKAGES_DIR = "packages";
 export declare const SHARED_CONSTRUCTS_NAME = "common-constructs";
 export declare const SHARED_CONSTRUCTS_DIR = "common/constructs";
@@ -13,3 +9,71 @@ export declare const SHARED_INFRA_CONFIG_NAME = "common-infra-config";
 export declare const SHARED_INFRA_CONFIG_DIR = "common/infra-config";
 export declare const SHARED_SCRIPTS_NAME = "common-scripts";
 export declare const SHARED_SCRIPTS_DIR = "common/scripts";
+export declare const DYNAMODB_GENERATOR_IDS: string[];
+/**
+ * Directory the vended Terraform runtime-config modules aggregate into at apply
+ * time, relative to the workspace root. The `entry` module writes leaf files
+ * under `entries/<namespace>/`, and the `read` / `appconfig-deployment` modules
+ * merge those into one `<namespace>.json` here.
+ */
+export declare const TERRAFORM_RUNTIME_CONFIG_DIR = "dist/packages/common/terraform/runtime-config";
+/**
+ * Runtime-config namespace the static website publishes to and reads back, as
+ * passed to the `read` module by the vended static-website Terraform module.
+ */
+export declare const WEBSITE_RUNTIME_CONFIG_NAMESPACE = "connection";
+/**
+ * File the Terraform aggregation writes the website's runtime config to,
+ * relative to the workspace root.
+ */
+export declare const TERRAFORM_WEBSITE_RUNTIME_CONFIG_FILE = "dist/packages/common/terraform/runtime-config/connection.json";
+/**
+ * What a generator records about the infrastructure it generated.
+ *
+ * Every generator that creates infrastructure records the `iac` it used, so a
+ * predicate can tell a CDK project from a Terraform one at upgrade time. Absent
+ * when the generator was run with no infrastructure, so its presence doubles as
+ * "infrastructure was generated" — which is what gates the packages an infra
+ * helper adds.
+ */
+export interface IacMetadata {
+    readonly iac?: string;
+}
+/**
+ * Whether infrastructure was generated at all, so the packages an infra helper
+ * adds are only claimed where that helper ran.
+ *
+ * Reads `iac` rather than the generator's own `infra` option: every generator
+ * resolves `iac` only on the infra branch, so one recorded field answers both
+ * questions and no generator needs a second one.
+ */
+export declare const generatedInfrastructure: (m: IacMetadata) => boolean;
+/**
+ * Whether Terraform infrastructure was generated, for the versions only a `.tf`
+ * module pins — a Terraform inline script's `uv run --with` pins, which the CDK
+ * branch never writes.
+ */
+export declare const generatedTerraform: (m: IacMetadata) => boolean;
+/**
+ * Whether CDK infrastructure was generated, for the packages only a construct
+ * imports.
+ */
+export declare const generatedCdk: (m: IacMetadata) => boolean;
+/**
+ * Dependencies a caller must declare to use the shared constructs project.
+ * Lives here so generators can spread it without importing the generator.
+ *
+ * `constructs` and `aws-cdk-lib` are gated on CDK because
+ * `sharedConstructsGenerator` creates the TypeScript constructs project on that
+ * branch alone — a Terraform workspace gets the shared Terraform project and
+ * never receives them.
+ */
+export declare const SHARED_CONSTRUCTS_DEPENDENCIES: readonly [{
+    readonly name: "constructs";
+    readonly when: (m: IacMetadata) => boolean;
+}, {
+    readonly name: "aws-cdk-lib";
+    readonly when: (m: IacMetadata) => boolean;
+}, {
+    readonly name: "@types/node";
+}];

package/src/utils/shared-constructs-constants.js

@@ -1,19 +1,72 @@
-"use strict";
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SHARED_SCRIPTS_DIR = exports.SHARED_SCRIPTS_NAME = exports.SHARED_INFRA_CONFIG_DIR = exports.SHARED_INFRA_CONFIG_NAME = exports.SHARED_SHADCN_DIR = exports.SHARED_SHADCN_NAME = exports.SHARED_TERRAFORM_DIR = exports.SHARED_TERRAFORM_NAME = exports.SHARED_CONSTRUCTS_DIR = exports.SHARED_CONSTRUCTS_NAME = exports.PACKAGES_DIR = void 0;
-exports.PACKAGES_DIR = 'packages';
-exports.SHARED_CONSTRUCTS_NAME = 'common-constructs';
-exports.SHARED_CONSTRUCTS_DIR = 'common/constructs';
-exports.SHARED_TERRAFORM_NAME = 'terraform';
-exports.SHARED_TERRAFORM_DIR = 'common/terraform';
-exports.SHARED_SHADCN_NAME = 'common-shadcn';
-exports.SHARED_SHADCN_DIR = 'common/shadcn';
-exports.SHARED_INFRA_CONFIG_NAME = 'common-infra-config';
-exports.SHARED_INFRA_CONFIG_DIR = 'common/infra-config';
-exports.SHARED_SCRIPTS_NAME = 'common-scripts';
-exports.SHARED_SCRIPTS_DIR = 'common/scripts';
+ */ export const PACKAGES_DIR = 'packages';
+export const SHARED_CONSTRUCTS_NAME = 'common-constructs';
+export const SHARED_CONSTRUCTS_DIR = 'common/constructs';
+export const SHARED_TERRAFORM_NAME = 'terraform';
+export const SHARED_TERRAFORM_DIR = 'common/terraform';
+export const SHARED_SHADCN_NAME = 'common-shadcn';
+export const SHARED_SHADCN_DIR = 'common/shadcn';
+export const SHARED_INFRA_CONFIG_NAME = 'common-infra-config';
+export const SHARED_INFRA_CONFIG_DIR = 'common/infra-config';
+export const SHARED_SCRIPTS_NAME = 'common-scripts';
+export const SHARED_SCRIPTS_DIR = 'common/scripts';
+export const DYNAMODB_GENERATOR_IDS = [
+    'ts#dynamodb',
+    'py#dynamodb'
+];
+/**
+ * Directory the vended Terraform runtime-config modules aggregate into at apply
+ * time, relative to the workspace root. The `entry` module writes leaf files
+ * under `entries/<namespace>/`, and the `read` / `appconfig-deployment` modules
+ * merge those into one `<namespace>.json` here.
+ */ export const TERRAFORM_RUNTIME_CONFIG_DIR = `dist/${PACKAGES_DIR}/${SHARED_TERRAFORM_DIR}/runtime-config`;
+/**
+ * Runtime-config namespace the static website publishes to and reads back, as
+ * passed to the `read` module by the vended static-website Terraform module.
+ */ export const WEBSITE_RUNTIME_CONFIG_NAMESPACE = 'connection';
+/**
+ * File the Terraform aggregation writes the website's runtime config to,
+ * relative to the workspace root.
+ */ export const TERRAFORM_WEBSITE_RUNTIME_CONFIG_FILE = `${TERRAFORM_RUNTIME_CONFIG_DIR}/${WEBSITE_RUNTIME_CONFIG_NAMESPACE}.json`;
+/**
+ * Whether infrastructure was generated at all, so the packages an infra helper
+ * adds are only claimed where that helper ran.
+ *
+ * Reads `iac` rather than the generator's own `infra` option: every generator
+ * resolves `iac` only on the infra branch, so one recorded field answers both
+ * questions and no generator needs a second one.
+ */ export const generatedInfrastructure = (m)=>m.iac !== undefined;
+/**
+ * Whether Terraform infrastructure was generated, for the versions only a `.tf`
+ * module pins — a Terraform inline script's `uv run --with` pins, which the CDK
+ * branch never writes.
+ */ export const generatedTerraform = (m)=>m.iac === 'terraform';
+/**
+ * Whether CDK infrastructure was generated, for the packages only a construct
+ * imports.
+ */ export const generatedCdk = (m)=>m.iac === 'cdk';
+/**
+ * Dependencies a caller must declare to use the shared constructs project.
+ * Lives here so generators can spread it without importing the generator.
+ *
+ * `constructs` and `aws-cdk-lib` are gated on CDK because
+ * `sharedConstructsGenerator` creates the TypeScript constructs project on that
+ * branch alone — a Terraform workspace gets the shared Terraform project and
+ * never receives them.
+ */ export const SHARED_CONSTRUCTS_DEPENDENCIES = [
+    {
+        name: 'constructs',
+        when: (m)=>m.iac === 'cdk'
+    },
+    {
+        name: 'aws-cdk-lib',
+        when: (m)=>m.iac === 'cdk'
+    },
+    {
+        name: '@types/node'
+    }
+];
+
 //# sourceMappingURL=shared-constructs-constants.js.map

package/src/utils/shared-constructs-constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"shared-constructs-constants.js","sourceRoot":"","sources":["../../../../../packages/nx-plugin/src/utils/shared-constructs-constants.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEU,QAAA,YAAY,GAAG,UAAU,CAAC;AAC1B,QAAA,sBAAsB,GAAG,mBAAmB,CAAC;AAC7C,QAAA,qBAAqB,GAAG,mBAAmB,CAAC;AAC5C,QAAA,qBAAqB,GAAG,WAAW,CAAC;AACpC,QAAA,oBAAoB,GAAG,kBAAkB,CAAC;AAC1C,QAAA,kBAAkB,GAAG,eAAe,CAAC;AACrC,QAAA,iBAAiB,GAAG,eAAe,CAAC;AACpC,QAAA,wBAAwB,GAAG,qBAAqB,CAAC;AACjD,QAAA,uBAAuB,GAAG,qBAAqB,CAAC;AAChD,QAAA,mBAAmB,GAAG,gBAAgB,CAAC;AACvC,QAAA,kBAAkB,GAAG,gBAAgB,CAAC"}
+{"version":3,"sources":["../../../../../packages/nx-plugin/src/utils/shared-constructs-constants.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\nimport type { DeclaredTsDependency } from './declared-dependencies.js';\nimport type { ITsDepVersion } from './versions.js';\n\nexport const PACKAGES_DIR = 'packages';\nexport const SHARED_CONSTRUCTS_NAME = 'common-constructs';\nexport const SHARED_CONSTRUCTS_DIR = 'common/constructs';\nexport const SHARED_TERRAFORM_NAME = 'terraform';\nexport const SHARED_TERRAFORM_DIR = 'common/terraform';\nexport const SHARED_SHADCN_NAME = 'common-shadcn';\nexport const SHARED_SHADCN_DIR = 'common/shadcn';\nexport const SHARED_INFRA_CONFIG_NAME = 'common-infra-config';\nexport const SHARED_INFRA_CONFIG_DIR = 'common/infra-config';\nexport const SHARED_SCRIPTS_NAME = 'common-scripts';\nexport const SHARED_SCRIPTS_DIR = 'common/scripts';\n\nexport const DYNAMODB_GENERATOR_IDS = ['ts#dynamodb', 'py#dynamodb'];\n\n/**\n * Directory the vended Terraform runtime-config modules aggregate into at apply\n * time, relative to the workspace root. The `entry` module writes leaf files\n * under `entries/<namespace>/`, and the `read` / `appconfig-deployment` modules\n * merge those into one `<namespace>.json` here.\n */\nexport const TERRAFORM_RUNTIME_CONFIG_DIR = `dist/${PACKAGES_DIR}/${SHARED_TERRAFORM_DIR}/runtime-config`;\n\n/**\n * Runtime-config namespace the static website publishes to and reads back, as\n * passed to the `read` module by the vended static-website Terraform module.\n */\nexport const WEBSITE_RUNTIME_CONFIG_NAMESPACE = 'connection';\n\n/**\n * File the Terraform aggregation writes the website's runtime config to,\n * relative to the workspace root.\n */\nexport const TERRAFORM_WEBSITE_RUNTIME_CONFIG_FILE = `${TERRAFORM_RUNTIME_CONFIG_DIR}/${WEBSITE_RUNTIME_CONFIG_NAMESPACE}.json`;\n\n/**\n * What a generator records about the infrastructure it generated.\n *\n * Every generator that creates infrastructure records the `iac` it used, so a\n * predicate can tell a CDK project from a Terraform one at upgrade time. Absent\n * when the generator was run with no infrastructure, so its presence doubles as\n * \"infrastructure was generated\" — which is what gates the packages an infra\n * helper adds.\n */\nexport interface IacMetadata {\n  readonly iac?: string;\n}\n\n/**\n * Whether infrastructure was generated at all, so the packages an infra helper\n * adds are only claimed where that helper ran.\n *\n * Reads `iac` rather than the generator's own `infra` option: every generator\n * resolves `iac` only on the infra branch, so one recorded field answers both\n * questions and no generator needs a second one.\n */\nexport const generatedInfrastructure = (m: IacMetadata): boolean =>\n  m.iac !== undefined;\n\n/**\n * Whether Terraform infrastructure was generated, for the versions only a `.tf`\n * module pins — a Terraform inline script's `uv run --with` pins, which the CDK\n * branch never writes.\n */\nexport const generatedTerraform = (m: IacMetadata): boolean =>\n  m.iac === 'terraform';\n\n/**\n * Whether CDK infrastructure was generated, for the packages only a construct\n * imports.\n */\nexport const generatedCdk = (m: IacMetadata): boolean => m.iac === 'cdk';\n\n/**\n * Dependencies a caller must declare to use the shared constructs project.\n * Lives here so generators can spread it without importing the generator.\n *\n * `constructs` and `aws-cdk-lib` are gated on CDK because\n * `sharedConstructsGenerator` creates the TypeScript constructs project on that\n * branch alone — a Terraform workspace gets the shared Terraform project and\n * never receives them.\n */\nexport const SHARED_CONSTRUCTS_DEPENDENCIES = [\n  { name: 'constructs', when: (m: IacMetadata) => m.iac === 'cdk' },\n  { name: 'aws-cdk-lib', when: (m: IacMetadata) => m.iac === 'cdk' },\n  { name: '@types/node' },\n] as const satisfies readonly DeclaredTsDependency<\n  ITsDepVersion,\n  IacMetadata\n>[];\n"],"names":["PACKAGES_DIR","SHARED_CONSTRUCTS_NAME","SHARED_CONSTRUCTS_DIR","SHARED_TERRAFORM_NAME","SHARED_TERRAFORM_DIR","SHARED_SHADCN_NAME","SHARED_SHADCN_DIR","SHARED_INFRA_CONFIG_NAME","SHARED_INFRA_CONFIG_DIR","SHARED_SCRIPTS_NAME","SHARED_SCRIPTS_DIR","DYNAMODB_GENERATOR_IDS","TERRAFORM_RUNTIME_CONFIG_DIR","WEBSITE_RUNTIME_CONFIG_NAMESPACE","TERRAFORM_WEBSITE_RUNTIME_CONFIG_FILE","generatedInfrastructure","m","iac","undefined","generatedTerraform","generatedCdk","SHARED_CONSTRUCTS_DEPENDENCIES","name","when"],"mappings":"AAAA;;;CAGC,GAID,OAAO,MAAMA,eAAe,WAAW;AACvC,OAAO,MAAMC,yBAAyB,oBAAoB;AAC1D,OAAO,MAAMC,wBAAwB,oBAAoB;AACzD,OAAO,MAAMC,wBAAwB,YAAY;AACjD,OAAO,MAAMC,uBAAuB,mBAAmB;AACvD,OAAO,MAAMC,qBAAqB,gBAAgB;AAClD,OAAO,MAAMC,oBAAoB,gBAAgB;AACjD,OAAO,MAAMC,2BAA2B,sBAAsB;AAC9D,OAAO,MAAMC,0BAA0B,sBAAsB;AAC7D,OAAO,MAAMC,sBAAsB,iBAAiB;AACpD,OAAO,MAAMC,qBAAqB,iBAAiB;AAEnD,OAAO,MAAMC,yBAAyB;IAAC;IAAe;CAAc,CAAC;AAErE;;;;;CAKC,GACD,OAAO,MAAMC,+BAA+B,CAAC,KAAK,EAAEZ,aAAa,CAAC,EAAEI,qBAAqB,eAAe,CAAC,CAAC;AAE1G;;;CAGC,GACD,OAAO,MAAMS,mCAAmC,aAAa;AAE7D;;;CAGC,GACD,OAAO,MAAMC,wCAAwC,GAAGF,6BAA6B,CAAC,EAAEC,iCAAiC,KAAK,CAAC,CAAC;AAehI;;;;;;;CAOC,GACD,OAAO,MAAME,0BAA0B,CAACC,IACtCA,EAAEC,GAAG,KAAKC,UAAU;AAEtB;;;;CAIC,GACD,OAAO,MAAMC,qBAAqB,CAACH,IACjCA,EAAEC,GAAG,KAAK,YAAY;AAExB;;;CAGC,GACD,OAAO,MAAMG,eAAe,CAACJ,IAA4BA,EAAEC,GAAG,KAAK,MAAM;AAEzE;;;;;;;;CAQC,GACD,OAAO,MAAMI,iCAAiC;IAC5C;QAAEC,MAAM;QAAcC,MAAM,CAACP,IAAmBA,EAAEC,GAAG,KAAK;IAAM;IAChE;QAAEK,MAAM;QAAeC,MAAM,CAACP,IAAmBA,EAAEC,GAAG,KAAK;IAAM;IACjE;QAAEK,MAAM;IAAc;CACvB,CAGG"}

package/src/utils/shared-constructs.d.ts

@@ -3,8 +3,11 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { type Tree } from '@nx/devkit';
-import type { Iac } from './iac';
+import type { DependencyDeclaration, MustDeclare } from './declared-dependencies.js';
+import type { Iac } from './iac.js';
+import { SHARED_CONSTRUCTS_DEPENDENCIES } from './shared-constructs-constants.js';
+export { SHARED_CONSTRUCTS_DEPENDENCIES };
 export interface SharedConstructsGeneratorOptions {
     iac: Iac;
 }
-export declare function sharedConstructsGenerator(tree: Tree, options: SharedConstructsGeneratorOptions): Promise<void>;
+export declare function sharedConstructsGenerator<const D extends DependencyDeclaration>(tree: Tree, options: SharedConstructsGeneratorOptions, declaration: D & MustDeclare<typeof SHARED_CONSTRUCTS_DEPENDENCIES, D>): Promise<void>;

package/src/utils/shared-constructs.js

@@ -1,96 +1,90 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sharedConstructsGenerator = sharedConstructsGenerator;
-const tslib_1 = require("tslib");
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
- */
-const devkit_1 = require("@nx/devkit");
-const generator_1 = tslib_1.__importDefault(require("../terraform/project/generator"));
-const generator_2 = tslib_1.__importDefault(require("../ts/lib/generator"));
-const utils_1 = require("./config/utils");
-const format_1 = require("./format");
-const npm_scope_1 = require("./npm-scope");
-const pkg_manager_1 = require("./pkg-manager");
-const shared_constructs_constants_1 = require("./shared-constructs-constants");
-const versions_1 = require("./versions");
-async function sharedConstructsGenerator(tree, options) {
+ */ import { generateFiles, joinPathFragments, OverwriteStrategy, updateJson } from "@nx/devkit";
+import terraformProjectGenerator from "../terraform/project/generator.js";
+import tsProjectGenerator from "../ts/lib/generator.js";
+import { readAwsNxPluginConfig } from "./config/utils.js";
+import { addDependenciesToPackageJson } from "./dependencies.js";
+import { formatFilesInSubtree } from "./format.js";
+import { esmVars } from "./module-format.js";
+import { getNpmScopePrefix } from "./npm-scope.js";
+import { getPackageManagerDisplayCommands } from "./pkg-manager.js";
+import { PACKAGES_DIR, SHARED_CONSTRUCTS_DEPENDENCIES, SHARED_CONSTRUCTS_DIR, SHARED_CONSTRUCTS_NAME, SHARED_TERRAFORM_DIR, SHARED_TERRAFORM_NAME } from "./shared-constructs-constants.js";
+export { SHARED_CONSTRUCTS_DEPENDENCIES };
+import { terraformProviderVersions, withVersions } from "./versions.js";
+export async function sharedConstructsGenerator(tree, options, declaration) {
     const { iac } = options;
-    const npmScopePrefix = (0, npm_scope_1.getNpmScopePrefix)(tree);
+    const npmScopePrefix = getNpmScopePrefix(tree);
     updateGitignore(tree);
     if (iac === 'cdk') {
-        if (!tree.exists((0, devkit_1.joinPathFragments)(shared_constructs_constants_1.PACKAGES_DIR, shared_constructs_constants_1.SHARED_CONSTRUCTS_DIR, 'project.json'))) {
-            await (0, generator_2.default)(tree, {
-                name: shared_constructs_constants_1.SHARED_CONSTRUCTS_NAME,
-                directory: shared_constructs_constants_1.PACKAGES_DIR,
-                subDirectory: shared_constructs_constants_1.SHARED_CONSTRUCTS_DIR,
+        if (!tree.exists(joinPathFragments(PACKAGES_DIR, SHARED_CONSTRUCTS_DIR, 'project.json'))) {
+            await tsProjectGenerator(tree, {
+                name: SHARED_CONSTRUCTS_NAME,
+                directory: PACKAGES_DIR,
+                subDirectory: SHARED_CONSTRUCTS_DIR
             });
-            tree.delete((0, devkit_1.joinPathFragments)(shared_constructs_constants_1.PACKAGES_DIR, shared_constructs_constants_1.SHARED_CONSTRUCTS_DIR, 'src'));
-            (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, 'files', shared_constructs_constants_1.SHARED_CONSTRUCTS_DIR, 'src'), (0, devkit_1.joinPathFragments)(shared_constructs_constants_1.PACKAGES_DIR, shared_constructs_constants_1.SHARED_CONSTRUCTS_DIR, 'src'), {
+            tree.delete(joinPathFragments(PACKAGES_DIR, SHARED_CONSTRUCTS_DIR, 'src'));
+            generateFiles(tree, joinPathFragments(import.meta.dirname, 'files', SHARED_CONSTRUCTS_DIR, 'src'), joinPathFragments(PACKAGES_DIR, SHARED_CONSTRUCTS_DIR, 'src'), {
                 npmScopePrefix,
-                scopeAlias: (0, npm_scope_1.toScopeAlias)(npmScopePrefix),
-                tags: (await (0, utils_1.readAwsNxPluginConfig)(tree))?.tags ?? [],
+                scopeAlias: npmScopePrefix,
+                tags: readAwsNxPluginConfig(tree)?.tags ?? [],
+                ...esmVars(tree)
             }, {
-                overwriteStrategy: devkit_1.OverwriteStrategy.KeepExisting,
+                overwriteStrategy: OverwriteStrategy.KeepExisting
             });
-            (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, 'files', 'common', 'readme'), (0, devkit_1.joinPathFragments)(shared_constructs_constants_1.PACKAGES_DIR, shared_constructs_constants_1.SHARED_CONSTRUCTS_DIR), {
-                fullyQualifiedName: `${npmScopePrefix}${shared_constructs_constants_1.SHARED_CONSTRUCTS_NAME}`,
-                name: shared_constructs_constants_1.SHARED_CONSTRUCTS_NAME,
-                pkgMgrCmd: (0, pkg_manager_1.getPackageManagerDisplayCommands)().exec,
+            generateFiles(tree, joinPathFragments(import.meta.dirname, 'files', 'common', 'readme'), joinPathFragments(PACKAGES_DIR, SHARED_CONSTRUCTS_DIR), {
+                fullyQualifiedName: `${npmScopePrefix}${SHARED_CONSTRUCTS_NAME}`,
+                name: SHARED_CONSTRUCTS_NAME,
+                pkgMgrCmd: getPackageManagerDisplayCommands().exec
             }, {
-                overwriteStrategy: devkit_1.OverwriteStrategy.Overwrite,
+                overwriteStrategy: OverwriteStrategy.Overwrite
             });
-            (0, devkit_1.addDependenciesToPackageJson)(tree, (0, versions_1.withVersions)(['constructs', 'aws-cdk-lib']), (0, versions_1.withVersions)(['@types/node']));
-            await (0, format_1.formatFilesInSubtree)(tree);
+            addDependenciesToPackageJson(tree, withVersions(declaration, [
+                'constructs',
+                'aws-cdk-lib'
+            ]), withVersions(declaration, [
+                '@types/node'
+            ]), joinPathFragments(joinPathFragments(PACKAGES_DIR, SHARED_CONSTRUCTS_DIR), 'package.json'));
+            await formatFilesInSubtree(tree);
         }
     }
     // Handle Terraform provider
     if (iac === 'terraform') {
-        const terraformLibPath = (0, devkit_1.joinPathFragments)(shared_constructs_constants_1.PACKAGES_DIR, shared_constructs_constants_1.SHARED_TERRAFORM_DIR);
-        if (!tree.exists((0, devkit_1.joinPathFragments)(terraformLibPath, 'project.json'))) {
-            await (0, generator_1.default)(tree, {
-                name: shared_constructs_constants_1.SHARED_TERRAFORM_NAME,
-                directory: (0, devkit_1.joinPathFragments)(shared_constructs_constants_1.PACKAGES_DIR, 'common'),
-                type: 'library',
+        const terraformLibPath = joinPathFragments(PACKAGES_DIR, SHARED_TERRAFORM_DIR);
+        if (!tree.exists(joinPathFragments(terraformLibPath, 'project.json'))) {
+            await terraformProjectGenerator(tree, {
+                name: SHARED_TERRAFORM_NAME,
+                directory: joinPathFragments(PACKAGES_DIR, 'common'),
+                type: 'library'
             });
-            // Add target to reset runtime config as part of the build, ensuring any plan/apply target
-            // which depends on shared terraform will build runtime-config.json from scratch, meaning no old
-            // values will remain when resources are removed.
-            // NB: runtime-config.json starts as an empty object to keep the reader terraform module simple
-            (0, devkit_1.updateJson)(tree, (0, devkit_1.joinPathFragments)(shared_constructs_constants_1.PACKAGES_DIR, shared_constructs_constants_1.SHARED_TERRAFORM_DIR, 'project.json'), (projectConfig) => {
+            // `build` is a no-op orchestration target that produces no files of its
+            // own. Terraform writes runtime-config entries into
+            // `dist/{projectRoot}/runtime-config` at apply time, and other terraform
+            // projects contribute their own entries to the same directory. Without
+            // explicit outputs, Nx infers `dist/{projectRoot}` as this target's
+            // cached output and, on a cache hit, restores the cached copy over the
+            // freshly-applied config — wiping the very values consumers read. Declare
+            // no outputs so Nx never treats runtime config as a cacheable artifact.
+            updateJson(tree, joinPathFragments(PACKAGES_DIR, SHARED_TERRAFORM_DIR, 'project.json'), (projectConfig)=>{
                 projectConfig.targets ??= {};
-                projectConfig.targets['reset-runtime-config'] = {
-                    executor: 'nx:run-commands',
-                    options: {
-                        command: 'tsx scripts/reset-runtime-config.ts',
-                        cwd: '{projectRoot}',
-                        env: {
-                            DIST_DIR: '{workspaceRoot}/dist/{projectRoot}',
-                        },
-                    },
-                };
                 projectConfig.targets.build ??= {};
-                projectConfig.targets.build.dependsOn = [
-                    ...(projectConfig.targets.build.dependsOn ?? []).filter((t) => t !== 'reset-runtime-config'),
-                    'reset-runtime-config',
-                ];
+                projectConfig.targets.build.outputs = [];
                 return projectConfig;
             });
-            tree.delete((0, devkit_1.joinPathFragments)(terraformLibPath, 'src', 'main.tf'));
+            tree.delete(joinPathFragments(terraformLibPath, 'src', 'main.tf'));
             // Create the metrics.tf file with empty initial values
-            (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, 'files', 'terraform'), terraformLibPath, {}, {
-                overwriteStrategy: devkit_1.OverwriteStrategy.KeepExisting,
+            generateFiles(tree, joinPathFragments(import.meta.dirname, 'files', 'terraform'), terraformLibPath, {
+                ...terraformProviderVersions()
+            }, {
+                overwriteStrategy: OverwriteStrategy.KeepExisting
             });
-            (0, devkit_1.addDependenciesToPackageJson)(tree, {}, (0, versions_1.withVersions)(['tsx']));
-            await (0, format_1.formatFilesInSubtree)(tree);
+            await formatFilesInSubtree(tree);
         }
     }
 }
-const updateGitignore = (tree) => {
-    const gitignore = tree.exists('.gitignore')
-        ? tree.read('.gitignore', 'utf-8')
-        : '';
+const updateGitignore = (tree)=>{
+    const gitignore = tree.exists('.gitignore') ? tree.read('.gitignore', 'utf-8') : '';
     const regex = /runtime-config.json/gm;
     const hasRuntimeConfig = regex.test(gitignore ?? '');
     if (hasRuntimeConfig) {
@@ -98,4 +92,5 @@ const updateGitignore = (tree) => {
     }
     tree.write('.gitignore', `${gitignore}\n\nruntime-config.json`);
 };
+
 //# sourceMappingURL=shared-constructs.js.map