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

package/src/smithy/ts/api/schema.json

@@ -2,6 +2,7 @@
   "$schema": "https://json-schema.org/schema",
   "$id": "ts#smithy-api",
   "title": "ts#smithy-api",
+  "x-label": "Smithy API",
   "description": "Create an API using Smithy and the Smithy TypeScript Server SDK",
   "type": "object",
   "properties": {
@@ -77,6 +78,11 @@
       "enum": ["rest-lambda", "none"],
       "x-prompt": "What infrastructure would you like to deploy your API with?",
       "x-priority": "internal"
+    },
+    "preferInstallDependencies": {
+      "type": "boolean",
+      "description": "Whether to prefer installing dependencies after the generator runs. Set to false to defer installing when batching multiple generators (an install still runs if needed so subsequent generators can compute the Nx project graph); install once at the end.",
+      "default": true
     }
   },
   "required": ["name"]

package/src/terraform/project/files/application/scripts/bootstrap.ts.template

@@ -4,7 +4,8 @@
  * Equivalent to `cdk bootstrap` — resolves account + region from the AWS
  * SDK credential chain, pulls any existing bootstrap tfstate from S3,
  * runs `terraform apply` in the `bootstrap` dir, then pushes the new
- * state back to S3.
+ * state back to S3. Adopts an already-existing state bucket when its
+ * state object is missing.
  */
 import { execFileSync } from 'node:child_process';
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
@@ -12,6 +13,7 @@ import { dirname, join, resolve } from 'node:path';
 import {
   S3Client,
   GetObjectCommand,
+  HeadBucketCommand,
   PutObjectCommand,
 } from '@aws-sdk/client-s3';
 import { fromNodeProviderChain } from '@aws-sdk/credential-providers';
@@ -34,6 +36,20 @@ const tfStatePath = join(
   'bootstrap.tfstate',
 );
 
+// S3 answers 404 only when the name is genuinely free; 403 means it exists
+// but is not readable with these credentials.
+const bucketExists = async (s3: S3Client, bucket: string) => {
+  try {
+    await s3.send(new HeadBucketCommand({ Bucket: bucket }));
+    return true;
+  } catch (err: any) {
+    const status = err?.$metadata?.httpStatusCode;
+    if (status === 404) return false;
+    if (status === 403) return true;
+    throw err;
+  }
+};
+
 const main = async () => {
   const { accountId, region } = await resolveAwsConfig();
   const bucket = `${accountId}-tf-state-${region}`;
@@ -46,12 +62,14 @@ const main = async () => {
   // Pull any existing bootstrap tfstate. First-time bootstrap has no
   // remote state yet — fall through and let terraform apply create the
   // bucket.
+  let haveState = false;
   try {
     const out = await s3.send(
       new GetObjectCommand({ Bucket: bucket, Key: key }),
     );
     if (out.Body) {
       writeFileSync(tfStatePath, await out.Body.transformToByteArray());
+      haveState = true;
     }
   } catch (err: any) {
     const name = err?.name ?? '';
@@ -65,6 +83,27 @@ const main = async () => {
   }
 
   execFileSync('terraform', ['init'], { cwd: bootstrapDir, stdio: 'inherit' });
+
+  // The bucket holds its own state, so losing the state object while the
+  // bucket survives would otherwise wedge bootstrap on a permanent
+  // `BucketAlreadyOwnedByYou`. Adopt the existing bucket instead.
+  if (!haveState && (await bucketExists(s3, bucket))) {
+    console.log(
+      `State bucket ${bucket} already exists but its bootstrap state is missing — importing it.`,
+    );
+    execFileSync(
+      'terraform',
+      [
+        'import',
+        `-state=${tfStatePath}`,
+        `-var=aws_region=${region}`,
+        'aws_s3_bucket.terraform_state',
+        bucket,
+      ],
+      { cwd: bootstrapDir, stdio: 'inherit' },
+    );
+  }
+
   execFileSync(
     'terraform',
     [

package/src/terraform/project/files/application/src/main.tf.template

@@ -14,6 +14,11 @@ resource "null_resource" "print_info" {
   # }
 
   provisioner "local-exec" {
-    command = "echo 'AWS Region: ${local.aws_region}, AWS Account: ${local.account_id}, Environment: ${var.environment}'"
+    command = "echo \"AWS Region: $AWS_REGION, AWS Account: $ACCOUNT_ID, Environment: $ENVIRONMENT\""
+    environment = {
+      AWS_REGION  = local.aws_region
+      ACCOUNT_ID  = local.account_id
+      ENVIRONMENT = var.environment
+    }
   }
 }

package/src/terraform/project/files/application/src/providers.tf.template

@@ -2,7 +2,7 @@ terraform {
   required_providers {
     aws = {
       source  = "hashicorp/aws"
-      version = "~> 6.0"
+      version = "<%- awsProviderVersion %>"
     }
   }
 

package/src/terraform/project/generator.d.ts

@@ -5,6 +5,56 @@
 import { type GeneratorCallback, type Tree } from '@nx/devkit';
 import { type NxGeneratorInfo } from '../../utils/nx';
 import type { TerraformProjectGeneratorSchema } from './schema';
+export declare const DEPENDENCIES: import("../../utils/declared-dependencies").DependencyDeclaration<readonly [{
+    readonly name: "@nx-extend/terraform";
+    readonly dev: true;
+    readonly root: true;
+}, {
+    readonly name: "make-dir-cli";
+    readonly dev: true;
+    readonly root: true;
+}, {
+    readonly name: "tsx";
+    readonly dev: true;
+    readonly root: true;
+}, {
+    readonly name: "@aws-sdk/client-s3";
+    readonly dev: true;
+    readonly root: true;
+}, {
+    readonly name: "@aws-sdk/client-sts";
+    readonly dev: true;
+    readonly root: true;
+}, {
+    readonly name: "@aws-sdk/credential-providers";
+    readonly dev: true;
+    readonly root: true;
+}, {
+    readonly name: "@smithy/config-resolver";
+    readonly dev: true;
+    readonly root: true;
+}, {
+    readonly name: "@smithy/node-config-provider";
+    readonly dev: true;
+    readonly root: true;
+}, {
+    readonly name: "@nx/devkit";
+    readonly versionOnly: true;
+}, {
+    readonly name: "constructs";
+    readonly when: (m: import("../../utils/shared-constructs-constants").IacMetadata) => boolean;
+} & {
+    versionOnly: true;
+}, {
+    readonly name: "aws-cdk-lib";
+    readonly when: (m: import("../../utils/shared-constructs-constants").IacMetadata) => boolean;
+} & {
+    versionOnly: true;
+}, {
+    readonly name: "@types/node";
+} & {
+    versionOnly: true;
+}], readonly import("../../utils/declared-dependencies").DeclaredPyDependency<"a2a-sdk" | "ag-ui-langgraph" | "ag-ui-protocol" | "ag-ui-strands" | "aws-lambda-powertools" | "aws-lambda-powertools[tracer]" | "aws-lambda-powertools[parser]" | "aws-opentelemetry-distro" | "bedrock-agentcore" | "boto3" | "checkov" | "fastapi" | "fastapi[standard]" | "httpx" | "langchain" | "langchain-aws" | "langchain-mcp-adapters" | "langgraph" | "mcp" | "pip-check-updates" | "pip-licenses" | "ruff" | "strands-agents" | "strands-agents[a2a]" | "strands-agents-tools" | "ty" | "pynamodb" | "uvicorn" | "sqlmodel" | "alembic" | "aiomysql" | "asyncpg" | "greenlet", Record<string, never>>[]>;
 export declare const TERRAFORM_PROJECT_GENERATOR_INFO: NxGeneratorInfo;
 export declare function terraformProjectGenerator(tree: Tree, schema: TerraformProjectGeneratorSchema): Promise<GeneratorCallback>;
 export default terraformProjectGenerator;

package/src/terraform/project/generator.js

@@ -1,114 +1,188 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TERRAFORM_PROJECT_GENERATOR_INFO = void 0;
-exports.terraformProjectGenerator = terraformProjectGenerator;
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
- */
-const devkit_1 = require("@nx/devkit");
-const path_1 = require("path");
-const generator_1 = require("../../ts/lib/generator");
-const git_1 = require("../../utils/git");
-const metrics_1 = require("../../utils/metrics");
-const names_1 = require("../../utils/names");
-const nx_1 = require("../../utils/nx");
-const object_1 = require("../../utils/object");
-const py_1 = require("../../utils/py");
-const shared_constructs_1 = require("../../utils/shared-constructs");
-const shared_constructs_constants_1 = require("../../utils/shared-constructs-constants");
-const versions_1 = require("../../utils/versions");
+ */ import { addProjectConfiguration, detectPackageManager, generateFiles, joinPathFragments, OverwriteStrategy, readNxJson, updateJson, updateNxJson } from "@nx/devkit";
+import { join, relative } from "path";
+import { getTsLibDetails } from "../../ts/lib/generator.js";
+import { addTsDependencies } from "../../utils/add-dependencies.js";
+import { declareDependencies, ownedElsewhere } from "../../utils/declared-dependencies.js";
+import { updateGitIgnore } from "../../utils/git.js";
+import { installDependencies } from "../../utils/install.js";
+import { addGeneratorMetricsIfApplicable } from "../../utils/metrics.js";
+import { kebabCase } from "../../utils/names.js";
+import { addGeneratorMetadata, getGeneratorInfo, projectExists } from "../../utils/nx.js";
+import { sortObjectKeys } from "../../utils/object.js";
+import { uvxCommand } from "../../utils/py.js";
+import { sharedConstructsGenerator } from "../../utils/shared-constructs.js";
+import { SHARED_CONSTRUCTS_DEPENDENCIES, SHARED_TERRAFORM_DIR, SHARED_TERRAFORM_NAME } from "../../utils/shared-constructs-constants.js";
+import { terraformProviderVersions, withVersions } from "../../utils/versions.js";
+// Terraform projects carry no package.json, so their build tooling and the AWS
+// SDK the vended deploy scripts import are declared at the workspace root. This
+// generator records no metadata, so nothing a predicate could read.
+export const DEPENDENCIES = declareDependencies()({
+    ts: [
+        {
+            name: '@nx-extend/terraform',
+            dev: true,
+            root: true
+        },
+        {
+            name: 'make-dir-cli',
+            dev: true,
+            root: true
+        },
+        {
+            name: 'tsx',
+            dev: true,
+            root: true
+        },
+        {
+            name: '@aws-sdk/client-s3',
+            dev: true,
+            root: true
+        },
+        {
+            name: '@aws-sdk/client-sts',
+            dev: true,
+            root: true
+        },
+        {
+            name: '@aws-sdk/credential-providers',
+            dev: true,
+            root: true
+        },
+        {
+            name: '@smithy/config-resolver',
+            dev: true,
+            root: true
+        },
+        {
+            name: '@smithy/node-config-provider',
+            dev: true,
+            root: true
+        },
+        // Declared for its pinned version, which goes into npm's `overrides` below.
+        {
+            name: '@nx/devkit',
+            versionOnly: true
+        },
+        ...ownedElsewhere(SHARED_CONSTRUCTS_DEPENDENCIES)
+    ]
+});
 const NX_EXTEND_PLUGIN = '@nx-extend/terraform';
-exports.TERRAFORM_PROJECT_GENERATOR_INFO = (0, nx_1.getGeneratorInfo)(__filename);
-async function terraformProjectGenerator(tree, schema) {
+export const TERRAFORM_PROJECT_GENERATOR_INFO = getGeneratorInfo(import.meta.filename);
+export async function terraformProjectGenerator(tree, schema) {
     // Just use getTsLibDetails as it isn't specific to TS
-    const lib = (0, generator_1.getTsLibDetails)(tree, schema);
-    const { fullyQualifiedName: sharedTfProjectName } = (0, generator_1.getTsLibDetails)(tree, {
-        name: shared_constructs_constants_1.SHARED_TERRAFORM_NAME,
+    const lib = getTsLibDetails(tree, schema);
+    const { fullyQualifiedName: sharedTfProjectName } = getTsLibDetails(tree, {
+        name: SHARED_TERRAFORM_NAME
     });
-    const outDirToRootRelativePath = (0, path_1.relative)((0, path_1.join)(tree.root, lib.dir, 'src'), tree.root).replace(/\\/g, '/');
-    const distDir = (0, devkit_1.joinPathFragments)(outDirToRootRelativePath, 'dist', '{projectRoot}');
-    const tfDistDir = (0, devkit_1.joinPathFragments)(distDir, 'terraform');
-    const checkovReportJsonPath = (0, devkit_1.joinPathFragments)(distDir, 'checkov', 'checkov_report.json');
+    const outDirToRootRelativePath = relative(join(tree.root, lib.dir, 'src'), tree.root).replace(/\\/g, '/');
+    const distDir = joinPathFragments(outDirToRootRelativePath, 'dist', '{projectRoot}');
+    const tfDistDir = joinPathFragments(distDir, 'terraform');
+    const checkovReportJsonPath = joinPathFragments(distDir, 'checkov', 'checkov_report.json');
     // Calculate relative path from current project to common/terraform/metrics
     // Use forward slashes for terraform module source paths (even on Windows)
-    const metricsModulePath = (0, path_1.relative)((0, path_1.join)(tree.root, lib.dir, 'src'), (0, path_1.join)(tree.root, 'packages', shared_constructs_constants_1.SHARED_TERRAFORM_DIR, 'src', 'metrics')).replace(/\\/g, '/');
-    (0, git_1.updateGitIgnore)(tree, '.', (patterns) => [...patterns, '.terraform']);
+    const metricsModulePath = relative(join(tree.root, lib.dir, 'src'), join(tree.root, 'packages', SHARED_TERRAFORM_DIR, 'src', 'metrics')).replace(/\\/g, '/');
+    updateGitIgnore(tree, '.', (patterns)=>[
+            ...patterns,
+            '.terraform'
+        ]);
     const applicationTargets = {
         apply: {
             executor: 'nx:run-commands',
             defaultConfiguration: 'dev',
             configurations: {
                 dev: {
-                    command: `terraform apply ${tfDistDir}/dev.tfplan`,
-                },
+                    command: `terraform apply ${tfDistDir}/dev.tfplan`
+                }
             },
             options: {
                 forwardAllArgs: true,
-                cwd: '{projectRoot}/src',
+                cwd: '{projectRoot}/src'
             },
-            dependsOn: ['plan'],
+            dependsOn: [
+                'plan'
+            ]
         },
         bootstrap: {
             executor: 'nx:run-commands',
             options: {
                 forwardAllArgs: true,
-                commands: ['tsx {projectRoot}/scripts/bootstrap.ts {projectRoot}'],
-                cwd: '{workspaceRoot}',
-            },
+                commands: [
+                    'tsx {projectRoot}/scripts/bootstrap.ts {projectRoot}'
+                ],
+                cwd: '{workspaceRoot}'
+            }
         },
         'bootstrap-destroy': {
             executor: 'nx:run-commands',
             options: {
                 forwardAllArgs: true,
                 command: `terraform destroy -state=${tfDistDir}/bootstrap.tfstate`,
-                cwd: '{projectRoot}/bootstrap',
-            },
+                cwd: '{projectRoot}/bootstrap'
+            }
         },
         build: {
-            dependsOn: ['fmt', 'test', `${sharedTfProjectName}:build`],
+            dependsOn: [
+                'fmt',
+                'test',
+                `${sharedTfProjectName}:build`
+            ]
         },
         deploy: {
-            dependsOn: ['apply'],
+            dependsOn: [
+                'apply'
+            ]
         },
         destroy: {
             executor: 'nx:run-commands',
             defaultConfiguration: 'dev',
             configurations: {
                 dev: {
-                    command: 'terraform destroy -var-file=env/dev.tfvars',
-                },
+                    command: 'terraform destroy -var-file=env/dev.tfvars'
+                }
             },
             options: {
                 forwardAllArgs: true,
-                cwd: '{projectRoot}/src',
+                cwd: '{projectRoot}/src'
             },
-            dependsOn: ['init'],
+            dependsOn: [
+                'init'
+            ]
         },
         init: {
             executor: 'nx:run-commands',
             defaultConfiguration: 'dev',
             configurations: {
                 dev: {
-                    env: { TF_ENV: 'dev' },
-                },
+                    env: {
+                        TF_ENV: 'dev'
+                    }
+                }
             },
             options: {
                 forwardAllArgs: true,
-                commands: ['tsx {projectRoot}/scripts/init.ts {projectRoot}'],
-                cwd: '{workspaceRoot}',
+                commands: [
+                    'tsx {projectRoot}/scripts/init.ts {projectRoot}'
+                ],
+                cwd: '{workspaceRoot}'
             },
-            dependsOn: ['^init'],
+            dependsOn: [
+                '^init'
+            ]
         },
         output: {
             executor: 'nx:run-commands',
             cache: true,
-            inputs: ['default'],
+            inputs: [
+                'default'
+            ],
             options: {
                 command: 'terraform output -json',
                 forwardAllArgs: true,
-                cwd: '{projectRoot}/src',
-            },
+                cwd: '{projectRoot}/src'
+            }
         },
         plan: {
             executor: 'nx:run-commands',
@@ -117,124 +191,151 @@ async function terraformProjectGenerator(tree, schema) {
                 dev: {
                     commands: [
                         `make-dir ${tfDistDir}`,
-                        `terraform plan -var-file=env/dev.tfvars -out=${tfDistDir}/dev.tfplan`,
-                    ],
-                },
+                        `terraform plan -var-file=env/dev.tfvars -out=${tfDistDir}/dev.tfplan`
+                    ]
+                }
             },
             options: {
                 forwardAllArgs: true,
                 cwd: '{projectRoot}/src',
-                parallel: false,
+                parallel: false
             },
-            dependsOn: ['init', 'validate', '^validate', 'build'],
-        },
+            dependsOn: [
+                'init',
+                'validate',
+                '^validate',
+                'build'
+            ]
+        }
     };
     const libTargets = {
         build: {
-            dependsOn: ['fmt', 'test'],
+            dependsOn: [
+                'fmt',
+                'test'
+            ]
         },
         fmt: {
             executor: 'nx:run-commands',
             cache: true,
-            inputs: ['default'],
+            inputs: [
+                'default'
+            ],
             options: {
                 command: 'terraform fmt',
                 forwardAllArgs: true,
-                cwd: '{projectRoot}/src',
-            },
+                cwd: '{projectRoot}/src'
+            }
         },
         init: {
             executor: 'nx:run-commands',
             defaultConfiguration: 'dev',
             configurations: {
                 dev: {
-                    command: 'terraform init',
-                },
+                    command: 'terraform init'
+                }
             },
             options: {
                 forwardAllArgs: true,
-                cwd: '{projectRoot}/src',
-            },
+                cwd: '{projectRoot}/src'
+            }
         },
         test: {
             executor: 'nx:run-commands',
             cache: true,
-            outputs: ['{workspaceRoot}/dist/{projectRoot}/checkov'],
+            outputs: [
+                '{workspaceRoot}/dist/{projectRoot}/checkov'
+            ],
             options: {
-                command: (0, py_1.uvxCommand)('checkov', `--directory . -o cli -o json --output-file-path console,${checkovReportJsonPath}`),
+                command: uvxCommand('checkov', `--directory . -o cli -o json --output-file-path console,${checkovReportJsonPath}`),
                 forwardAllArgs: true,
-                cwd: '{projectRoot}/src',
-            },
+                cwd: '{projectRoot}/src'
+            }
         },
         validate: {
             executor: 'nx:run-commands',
             cache: true,
-            inputs: ['default'],
+            inputs: [
+                'default'
+            ],
             options: {
                 command: 'terraform validate',
                 forwardAllArgs: true,
-                cwd: '{projectRoot}/src',
+                cwd: '{projectRoot}/src'
             },
-            dependsOn: ['init'],
-        },
+            dependsOn: [
+                'init'
+            ]
+        }
     };
-    (0, devkit_1.addProjectConfiguration)(tree, lib.fullyQualifiedName, {
+    const projectConfiguration = {
         root: lib.dir,
         projectType: schema.type,
-        sourceRoot: (0, devkit_1.joinPathFragments)(lib.dir, 'src'),
-        targets: (0, object_1.sortObjectKeys)({
+        sourceRoot: joinPathFragments(lib.dir, 'src'),
+        targets: sortObjectKeys({
             ...libTargets,
-            ...(schema.type === 'application' ? applicationTargets : {}),
-        }),
+            ...schema.type === 'application' ? applicationTargets : {}
+        })
+    };
+    // Only create the project configuration on first run; skip it on re-run so
+    // existing project.json customisations are preserved.
+    if (!projectExists(tree, lib.fullyQualifiedName)) {
+        addProjectConfiguration(tree, lib.fullyQualifiedName, projectConfiguration);
+    }
+    // This generator IS the Terraform project, so the provider is fixed.
+    addGeneratorMetadata(tree, lib.fullyQualifiedName, TERRAFORM_PROJECT_GENERATOR_INFO, {
+        iac: 'terraform'
     });
-    (0, nx_1.addGeneratorMetadata)(tree, lib.fullyQualifiedName, exports.TERRAFORM_PROJECT_GENERATOR_INFO);
-    (0, devkit_1.generateFiles)(tree, // the virtual file system
-    (0, devkit_1.joinPathFragments)(__dirname, `./files/${schema.type}`), // path to the file templates
-    lib.dir, // destination path of the files
-    {
+    generateFiles(tree, joinPathFragments(import.meta.dirname, `./files/${schema.type}`), lib.dir, {
         metricsModulePath,
-        stateKeyPrefix: (0, names_1.kebabCase)(lib.fullyQualifiedName),
+        stateKeyPrefix: kebabCase(lib.fullyQualifiedName),
+        ...terraformProviderVersions()
     }, {
-        overwriteStrategy: devkit_1.OverwriteStrategy.Overwrite,
+        overwriteStrategy: OverwriteStrategy.Overwrite
     });
-    const nxJson = (0, devkit_1.readNxJson)(tree);
-    if (!nxJson.plugins?.find((p) => typeof p === 'string'
-        ? p === NX_EXTEND_PLUGIN
-        : p.plugin === NX_EXTEND_PLUGIN)) {
-        nxJson.plugins = [...(nxJson.plugins ?? []), NX_EXTEND_PLUGIN];
-        (0, devkit_1.updateNxJson)(tree, nxJson);
+    const nxJson = readNxJson(tree);
+    if (!nxJson.plugins?.find((p)=>typeof p === 'string' ? p === NX_EXTEND_PLUGIN : p.plugin === NX_EXTEND_PLUGIN)) {
+        nxJson.plugins = [
+            ...nxJson.plugins ?? [],
+            NX_EXTEND_PLUGIN
+        ];
+        updateNxJson(tree, nxJson);
     }
     // Ensure shared constructs for Terraform are created
-    await (0, shared_constructs_1.sharedConstructsGenerator)(tree, { iac: 'terraform' });
+    await sharedConstructsGenerator(tree, {
+        iac: 'terraform'
+    }, DEPENDENCIES);
     // Add Terraform metrics
-    await (0, metrics_1.addGeneratorMetricsIfApplicable)(tree, [
-        exports.TERRAFORM_PROJECT_GENERATOR_INFO,
+    await addGeneratorMetricsIfApplicable(tree, [
+        TERRAFORM_PROJECT_GENERATOR_INFO
     ]);
-    (0, devkit_1.addDependenciesToPackageJson)(tree, {}, (0, versions_1.withVersions)([
-        '@nx-extend/terraform',
-        'make-dir-cli',
-        'tsx',
-        '@aws-sdk/client-s3',
-        '@aws-sdk/client-sts',
-        '@aws-sdk/credential-providers',
-        '@smithy/config-resolver',
-        '@smithy/node-config-provider',
-    ]));
+    addTsDependencies(tree, DEPENDENCIES);
     // @nx-extend/terraform has a peer dependency on @nx/devkit ^21.0.0 which causes
     // npm install to fail, so for NPM we add a resolution
     // Can remove when https://github.com/TriPSs/nx-extend/issues/407 is addressed
-    if ((0, devkit_1.detectPackageManager)() === 'npm') {
-        (0, devkit_1.updateJson)(tree, 'package.json', (packageJson) => {
+    if (detectPackageManager() === 'npm') {
+        updateJson(tree, 'package.json', (packageJson)=>{
             packageJson.overrides = {
                 ...packageJson.overrides,
-                ...(0, versions_1.withVersions)(['@nx/devkit']),
+                ...withVersions(DEPENDENCIES, [
+                    '@nx/devkit'
+                ])
             };
             return packageJson;
         });
     }
-    return () => {
-        (0, devkit_1.installPackagesTask)(tree);
-    };
+    // `@nx-extend/terraform` is registered as an Nx plugin in nx.json, so Nx
+    // loads it when computing the project graph — it must resolve even if the
+    // caller would otherwise prefer to defer installing.
+    return ()=>installDependencies(tree, schema.preferInstallDependencies, {
+            languages: [
+                'typescript'
+            ],
+            ensureResolvable: [
+                NX_EXTEND_PLUGIN
+            ]
+        });
 }
-exports.default = terraformProjectGenerator;
+export default terraformProjectGenerator;
+
 //# sourceMappingURL=generator.js.map