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

package/src/utils/api-constructs/files/terraform/core/api/http/http-api/http-api.tf.template

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

package/src/utils/api-constructs/files/terraform/core/api/rest/api-gateway-account/api-gateway-account.tf.template

@@ -0,0 +1,83 @@
+# Account-level CloudWatch Logs role used by API Gateway REST APIs for access
+# logging. The setting is a singleton per region per account, so it is managed
+# idempotently: the role is set only when none is already configured (the first
+# deployment wins, others defer) and is never reset on destroy. This keeps
+# logging working across multiple deployments sharing an account.
+
+terraform {
+  required_version = ">= 1.0"
+
+  required_providers {
+    aws = {
+      source  = "hashicorp/aws"
+      version = "<%- awsProviderVersion %>"
+    }
+  }
+}
+
+data "aws_region" "current" {}
+
+resource "aws_iam_role" "cloudwatch" {
+  name_prefix = "apigw-cloudwatch-"
+
+  assume_role_policy = jsonencode({
+    Version = "2012-10-17"
+    Statement = [{
+      Effect    = "Allow"
+      Principal = { Service = "apigateway.amazonaws.com" }
+      Action    = "sts:AssumeRole"
+    }]
+  })
+}
+
+resource "aws_iam_role_policy_attachment" "cloudwatch" {
+  role       = aws_iam_role.cloudwatch.name
+  policy_arn = "arn:aws:iam::aws:policy/service-role/AmazonAPIGatewayPushToCloudWatchLogs"
+}
+
+# Configures the account role on create/update only; destroying this resource is
+# a no-op, so teardown never disables logging for other REST APIs in the region.
+resource "terraform_data" "account" {
+  triggers_replace = [aws_iam_role.cloudwatch.arn]
+
+  provisioner "local-exec" {
+    command = "uv run --with boto3<%= boto3Version %> python -c \"$SCRIPT\""
+    environment = {
+      ROLE_ARN = aws_iam_role.cloudwatch.arn
+      REGION   = data.aws_region.current.region
+      SCRIPT   = <<-PY
+        import os, time, boto3
+        from botocore.exceptions import ClientError
+        apigw = boto3.client("apigateway", region_name=os.environ["REGION"])
+
+        def has_live_role():
+            arn = apigw.get_account().get("cloudwatchRoleArn")
+            if not arn:
+                return False
+            try:
+                boto3.client("iam").get_role(RoleName=arn.split("/")[-1])
+                return True
+            except ClientError as e:
+                if e.response["Error"]["Code"] == "NoSuchEntity":
+                    return False
+                raise
+
+        if not has_live_role():
+            op = {"op": "replace", "path": "/cloudwatchRoleArn", "value": os.environ["ROLE_ARN"]}
+            # Retry while the freshly created role propagates through IAM, and on throttling
+            retryable = ("BadRequestException", "TooManyRequestsException")
+            for attempt in range(12):
+                try:
+                    apigw.update_account(patchOperations=[op])
+                    break
+                except ClientError as e:
+                    if e.response["Error"]["Code"] in retryable and attempt < 11:
+                        time.sleep(5)
+                    else:
+                        raise
+      PY
+    }
+  }
+
+  depends_on = [aws_iam_role_policy_attachment.cloudwatch]
+}

package/src/utils/api-constructs/files/terraform/core/api/rest/rest-api/rest-api.tf.template

@@ -7,11 +7,11 @@ terraform {
   required_providers {
     aws = {
       source  = "hashicorp/aws"
-      version = "~> 6.33"
+      version = "<%- awsProviderVersion %>"
     }
     random = {
       source  = "hashicorp/random"
-      version = "~> 3.1"
+      version = "<%- randomProviderVersion %>"
     }
   }
 }
@@ -81,8 +81,6 @@ data "aws_caller_identity" "current" {}
 
 # Resources
 
-# Note: CloudWatch logging removed due to account-level CloudWatch Logs role ARN requirement
-
 # REST API Gateway
 resource "aws_api_gateway_rest_api" "rest_api" {
   name        = var.api_name
@@ -99,10 +97,8 @@ resource "aws_api_gateway_rest_api" "rest_api" {
   tags = var.tags
 }
 
-# Note: Deployment and stage are created in the consuming module (e.g., foo-api.tf)
-# after all methods and integrations are defined
-
-# Note: CloudWatch Log Group removed due to account-level CloudWatch Logs role ARN requirement
+# Note: Deployment, stage and access logging are created in the consuming module
+# (e.g., foo-api.tf) after all methods and integrations are defined
 
 # Gateway Response for CORS (4XX errors)
 resource "aws_api_gateway_gateway_response" "cors_4xx" {
@@ -204,22 +200,75 @@ resource "aws_wafv2_web_acl" "api_waf" {
   }
 }
 
+resource "random_id" "waf_log_suffix" {
+  count       = var.enable_waf ? 1 : 0
+  byte_length = 4
+}
+
+locals {
+  waf_log_group_name = var.enable_waf ? "aws-waf-logs-${var.api_name}-${random_id.waf_log_suffix[0].hex}" : null
+}
+
+# KMS key for encrypting WAF request logs at rest
+resource "aws_kms_key" "waf_logs" {
+  count = var.enable_waf ? 1 : 0
+
+  description             = "${var.api_name} API WAF log encryption"
+  deletion_window_in_days = 7
+  enable_key_rotation     = true
+
+  policy = jsonencode({
+    Version = "2012-10-17"
+    Statement = [
+      {
+        Sid       = "Enable IAM User Permissions"
+        Effect    = "Allow"
+        Principal = { AWS = "arn:aws:iam::${data.aws_caller_identity.current.account_id}:root" }
+        Action    = "kms:*"
+        Resource  = "*"
+      },
+      {
+        Sid       = "Allow CloudWatch Logs"
+        Effect    = "Allow"
+        Principal = { Service = "logs.${data.aws_region.current.region}.amazonaws.com" }
+        Action = [
+          "kms:Encrypt",
+          "kms:Decrypt",
+          "kms:ReEncrypt*",
+          "kms:GenerateDataKey*",
+          "kms:DescribeKey"
+        ]
+        Resource = "*"
+        Condition = {
+          ArnEquals = {
+            "kms:EncryptionContext:aws:logs:arn" = "arn:aws:logs:${data.aws_region.current.region}:${data.aws_caller_identity.current.account_id}:log-group:${local.waf_log_group_name}"
+          }
+        }
+      }
+    ]
+  })
+
+  tags = var.tags
+}
+
+resource "aws_kms_alias" "waf_logs" {
+  count = var.enable_waf ? 1 : 0
+
+  name          = "alias/${var.api_name}-${random_id.waf_log_suffix[0].hex}-waf-logs"
+  target_key_id = aws_kms_key.waf_logs[0].key_id
+}
+
 # CloudWatch Log Group for WAF request logs. Name must start with `aws-waf-logs-`.
 resource "aws_cloudwatch_log_group" "api_waf_logs" {
-  #checkov:skip=CKV_AWS_158:Using default CloudWatch log encryption
   #checkov:skip=CKV_AWS_338:Log retention set to one month which is sufficient for WAF logs
   count = var.enable_waf ? 1 : 0
 
-  name              = "aws-waf-logs-${var.api_name}-${random_id.waf_log_suffix[0].hex}"
+  name              = local.waf_log_group_name
   retention_in_days = 30
+  kms_key_id        = aws_kms_key.waf_logs[0].arn
   tags              = var.tags
 }
 
-resource "random_id" "waf_log_suffix" {
-  count       = var.enable_waf ? 1 : 0
-  byte_length = 4
-}
-
 resource "aws_wafv2_web_acl_logging_configuration" "api_waf_logging" {
   count = var.enable_waf ? 1 : 0
 
@@ -260,6 +309,4 @@ output "waf_web_acl_arn" {
   value       = var.enable_waf ? aws_wafv2_web_acl.api_waf[0].arn : null
 }
 
-# Note: Stage and deployment outputs are provided by the consuming module
-
-# Note: CloudWatch log group outputs removed due to account-level CloudWatch Logs role ARN requirement
+# Note: Stage, deployment and access log outputs are provided by the consuming module

package/src/utils/api-constructs/open-api-metadata.d.ts

@@ -3,15 +3,32 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { type Tree } from '@nx/devkit';
-import type { Iac } from '../iac';
+import type { Iac } from '../iac.js';
 export interface AddOpenApiMetadataGenerateTargetOptions {
     iac: Iac;
     apiNameKebabCase: string;
     specPath: string;
     specBuildTargetName: string;
+    /**
+     * How integrations are mapped to operations. Terraform only needs the
+     * operations metadata for the `isolated` pattern, since the `shared` pattern
+     * routes every operation to one proxy Lambda.
+     */
+    integrationPattern?: 'isolated' | 'shared';
 }
 /**
- * Adds a generate:<api-name>-metadata target to shared constructs (CDK only)
- * This allows for API CDK constructs to have type-safety for integrations based on an OpenAPI Specification
+ * Adds a target which generates metadata about the API's operations from its
+ * OpenAPI specification, so that infrastructure can define an integration per
+ * operation.
+ *
+ * For CDK this generates TypeScript, giving the construct type-safe integrations.
+ * For Terraform this generates JSON, which the vended module reads to build one
+ * Lambda function and route per operation.
  */
-export declare const addSharedConstructsOpenApiMetadataGenerateTarget: (tree: Tree, { iac, apiNameKebabCase, specPath, specBuildTargetName, }: AddOpenApiMetadataGenerateTargetOptions) => void;
+export declare const addSharedConstructsOpenApiMetadataGenerateTarget: (tree: Tree, options: AddOpenApiMetadataGenerateTargetOptions) => void;
+/**
+ * Directory the operations metadata for an API is generated into, relative to
+ * the shared Terraform project's `src`. The vended module reads the file from
+ * here, so the module template and this target must agree on the location.
+ */
+export declare const terraformOperationsMetadataDir: (apiNameKebabCase: string) => string;

package/src/utils/api-constructs/open-api-metadata.js

@@ -1,27 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addSharedConstructsOpenApiMetadataGenerateTarget = void 0;
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
- */
-const devkit_1 = require("@nx/devkit");
-const git_1 = require("../git");
-const nx_1 = require("../nx");
-const shared_constructs_constants_1 = require("../shared-constructs-constants");
+ */ import { joinPathFragments, updateJson } from "@nx/devkit";
+import { updateGitIgnore } from "../git.js";
+import { addArtifactDependencyToTargets, addDependencyToTargetIfNotPresent } from "../nx.js";
+import { openApiCodegenTarget } from "../open-api-codegen-target.js";
+import { PACKAGES_DIR, SHARED_CONSTRUCTS_DIR, SHARED_TERRAFORM_DIR } from "../shared-constructs-constants.js";
 /**
- * Adds a generate:<api-name>-metadata target to shared constructs (CDK only)
- * This allows for API CDK constructs to have type-safety for integrations based on an OpenAPI Specification
- */
-const addSharedConstructsOpenApiMetadataGenerateTarget = (tree, { iac, apiNameKebabCase, specPath, specBuildTargetName, }) => {
-    if (iac !== 'cdk') {
-        // For Terraform, we do not support type-safe integration builders, rather only the single lambda
-        // router pattern, and therefore do not need to add depenencies on metadata generation.
-        return;
+ * Adds a target which generates metadata about the API's operations from its
+ * OpenAPI specification, so that infrastructure can define an integration per
+ * operation.
+ *
+ * For CDK this generates TypeScript, giving the construct type-safe integrations.
+ * For Terraform this generates JSON, which the vended module reads to build one
+ * Lambda function and route per operation.
+ */ export const addSharedConstructsOpenApiMetadataGenerateTarget = (tree, options)=>{
+    if (options.iac === 'cdk') {
+        addCdkOpenApiMetadataGenerateTarget(tree, options);
+    } else if (options.iac === 'terraform') {
+        addTerraformOpenApiOperationsGenerateTarget(tree, options);
     }
-    const generatedMetadataDir = (0, devkit_1.joinPathFragments)('generated', apiNameKebabCase);
-    const generatedMetadataDirFromRoot = (0, devkit_1.joinPathFragments)((0, devkit_1.joinPathFragments)(shared_constructs_constants_1.PACKAGES_DIR, shared_constructs_constants_1.SHARED_CONSTRUCTS_DIR), 'src', generatedMetadataDir);
-    (0, devkit_1.updateJson)(tree, (0, devkit_1.joinPathFragments)(shared_constructs_constants_1.PACKAGES_DIR, shared_constructs_constants_1.SHARED_CONSTRUCTS_DIR, 'project.json'), (config) => {
+};
+const addCdkOpenApiMetadataGenerateTarget = (tree, { apiNameKebabCase, specPath, specBuildTargetName })=>{
+    const generatedMetadataDir = joinPathFragments('generated', apiNameKebabCase);
+    const generatedMetadataDirFromRoot = joinPathFragments(joinPathFragments(PACKAGES_DIR, SHARED_CONSTRUCTS_DIR), 'src', generatedMetadataDir);
+    updateJson(tree, joinPathFragments(PACKAGES_DIR, SHARED_CONSTRUCTS_DIR, 'project.json'), (config)=>{
         if (!config.targets) {
             config.targets = {};
         }
@@ -32,31 +35,63 @@ const addSharedConstructsOpenApiMetadataGenerateTarget = (tree, { iac, apiNameKe
         // for providing a type-safe CDK construct
         const metadataTargetName = `generate:${apiNameKebabCase}-metadata`;
         if (!config.targets[metadataTargetName]) {
-            config.targets[metadataTargetName] = {
-                cache: true,
-                executor: 'nx:run-commands',
-                inputs: [
-                    {
-                        dependentTasksOutputFiles: '**/*.json',
-                    },
-                ],
+            config.targets[metadataTargetName] = openApiCodegenTarget({
+                generator: 'ts-metadata',
+                openApiSpecPath: specPath,
+                outputPath: generatedMetadataDirFromRoot,
+                specBuildTargetName,
+                outputs: [
+                    joinPathFragments('{workspaceRoot}', generatedMetadataDirFromRoot)
+                ]
+            });
+        }
+        addDependencyToTargetIfNotPresent(config, 'compile', metadataTargetName);
+        return config;
+    });
+    // Ignore the generated metadata by default
+    // Users can safely remove the entry from the .gitignore if they prefer to check it in
+    updateGitIgnore(tree, joinPathFragments(PACKAGES_DIR, SHARED_CONSTRUCTS_DIR), (patterns)=>[
+            ...patterns,
+            joinPathFragments('src', generatedMetadataDir)
+        ]);
+};
+/**
+ * Directory the operations metadata for an API is generated into, relative to
+ * the shared Terraform project's `src`. The vended module reads the file from
+ * here, so the module template and this target must agree on the location.
+ */ export const terraformOperationsMetadataDir = (apiNameKebabCase)=>joinPathFragments('generated', apiNameKebabCase);
+const addTerraformOpenApiOperationsGenerateTarget = (tree, { apiNameKebabCase, specPath, specBuildTargetName, integrationPattern })=>{
+    // The `shared` pattern routes every operation to a single proxy Lambda, so the
+    // module has no need for the operations metadata.
+    if (integrationPattern !== 'isolated') {
+        return;
+    }
+    const generatedDirFromRoot = joinPathFragments(PACKAGES_DIR, SHARED_TERRAFORM_DIR, 'src', terraformOperationsMetadataDir(apiNameKebabCase));
+    updateJson(tree, joinPathFragments(PACKAGES_DIR, SHARED_TERRAFORM_DIR, 'project.json'), (config)=>{
+        config.targets ??= {};
+        // Terraform reads the operations metadata with `file()`, so it must exist
+        // before plan; the target is wired into `build` below.
+        const operationsTargetName = `generate:${apiNameKebabCase}-operations`;
+        if (!config.targets[operationsTargetName]) {
+            config.targets[operationsTargetName] = openApiCodegenTarget({
+                generator: 'json-metadata',
+                openApiSpecPath: specPath,
+                outputPath: generatedDirFromRoot,
+                specBuildTargetName,
                 outputs: [
-                    (0, devkit_1.joinPathFragments)('{workspaceRoot}', generatedMetadataDirFromRoot),
-                ],
-                options: {
-                    commands: [
-                        `nx g @aws/nx-plugin:open-api#ts-metadata --openApiSpecPath="${specPath}" --outputPath="${generatedMetadataDirFromRoot}" --no-interactive`,
-                    ],
-                },
-                dependsOn: [specBuildTargetName],
-            };
+                    joinPathFragments('{workspaceRoot}', generatedDirFromRoot)
+                ]
+            });
         }
-        (0, nx_1.addDependencyToTargetIfNotPresent)(config, 'compile', metadataTargetName);
+        addArtifactDependencyToTargets(config, operationsTargetName);
         return config;
     });
     // Ignore the generated metadata by default
     // Users can safely remove the entry from the .gitignore if they prefer to check it in
-    (0, git_1.updateGitIgnore)(tree, (0, devkit_1.joinPathFragments)(shared_constructs_constants_1.PACKAGES_DIR, shared_constructs_constants_1.SHARED_CONSTRUCTS_DIR), (patterns) => [...patterns, (0, devkit_1.joinPathFragments)('src', generatedMetadataDir)]);
+    updateGitIgnore(tree, joinPathFragments(PACKAGES_DIR, SHARED_TERRAFORM_DIR), (patterns)=>[
+            ...patterns,
+            joinPathFragments('src', terraformOperationsMetadataDir(apiNameKebabCase))
+        ]);
 };
-exports.addSharedConstructsOpenApiMetadataGenerateTarget = addSharedConstructsOpenApiMetadataGenerateTarget;
+
 //# sourceMappingURL=open-api-metadata.js.map

package/src/utils/api-constructs/open-api-metadata.js.map

@@ -1 +1 @@
-{"version":3,"file":"open-api-metadata.js","sourceRoot":"","sources":["../../../../../../packages/nx-plugin/src/utils/api-constructs/open-api-metadata.ts"],"names":[],"mappings":";;;AAAA;;;GAGG;AACH,uCAKoB;AACpB,gCAAyC;AAEzC,8BAA0D;AAC1D,gFAGwC;AASxC;;;GAGG;AACI,MAAM,gDAAgD,GAAG,CAC9D,IAAU,EACV,EACE,GAAG,EACH,gBAAgB,EAChB,QAAQ,EACR,mBAAmB,GACqB,EAC1C,EAAE;IACF,IAAI,GAAG,KAAK,KAAK,EAAE,CAAC;QAClB,iGAAiG;QACjG,uFAAuF;QACvF,OAAO;IACT,CAAC;IAED,MAAM,oBAAoB,GAAG,IAAA,0BAAiB,EAAC,WAAW,EAAE,gBAAgB,CAAC,CAAC;IAC9E,MAAM,4BAA4B,GAAG,IAAA,0BAAiB,EACpD,IAAA,0BAAiB,EAAC,0CAAY,EAAE,mDAAqB,CAAC,EACtD,KAAK,EACL,oBAAoB,CACrB,CAAC;IAEF,IAAA,mBAAU,EACR,IAAI,EACJ,IAAA,0BAAiB,EAAC,0CAAY,EAAE,mDAAqB,EAAE,cAAc,CAAC,EACtE,CAAC,MAA4B,EAAE,EAAE;QAC/B,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACpB,MAAM,CAAC,OAAO,GAAG,EAAE,CAAC;QACtB,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;YAC1B,MAAM,CAAC,OAAO,CAAC,KAAK,GAAG,EAAE,CAAC;QAC5B,CAAC;QACD,wFAAwF;QACxF,0CAA0C;QAC1C,MAAM,kBAAkB,GAAG,YAAY,gBAAgB,WAAW,CAAC;QACnE,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,kBAAkB,CAAC,EAAE,CAAC;YACxC,MAAM,CAAC,OAAO,CAAC,kBAAkB,CAAC,GAAG;gBACnC,KAAK,EAAE,IAAI;gBACX,QAAQ,EAAE,iBAAiB;gBAC3B,MAAM,EAAE;oBACN;wBACE,yBAAyB,EAAE,WAAW;qBACvC;iBACF;gBACD,OAAO,EAAE;oBACP,IAAA,0BAAiB,EAAC,iBAAiB,EAAE,4BAA4B,CAAC;iBACnE;gBACD,OAAO,EAAE;oBACP,QAAQ,EAAE;wBACR,+DAA+D,QAAQ,mBAAmB,4BAA4B,oBAAoB;qBAC3I;iBACF;gBACD,SAAS,EAAE,CAAC,mBAAmB,CAAC;aACjC,CAAC;QACJ,CAAC;QACD,IAAA,sCAAiC,EAAC,MAAM,EAAE,SAAS,EAAE,kBAAkB,CAAC,CAAC;QACzE,OAAO,MAAM,CAAC;IAChB,CAAC,CACF,CAAC;IAEF,2CAA2C;IAC3C,sFAAsF;IACtF,IAAA,qBAAe,EACb,IAAI,EACJ,IAAA,0BAAiB,EAAC,0CAAY,EAAE,mDAAqB,CAAC,EACtD,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,GAAG,QAAQ,EAAE,IAAA,0BAAiB,EAAC,KAAK,EAAE,oBAAoB,CAAC,CAAC,CAC5E,CAAC;AACJ,CAAC,CAAC;AAnEW,QAAA,gDAAgD,oDAmE3D"}
+{"version":3,"sources":["../../../../../../packages/nx-plugin/src/utils/api-constructs/open-api-metadata.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\nimport {\n  joinPathFragments,\n  type ProjectConfiguration,\n  type Tree,\n  updateJson,\n} from '@nx/devkit';\nimport { updateGitIgnore } from '../git.js';\nimport type { Iac } from '../iac.js';\nimport {\n  addArtifactDependencyToTargets,\n  addDependencyToTargetIfNotPresent,\n} from '../nx.js';\nimport { openApiCodegenTarget } from '../open-api-codegen-target.js';\nimport {\n  PACKAGES_DIR,\n  SHARED_CONSTRUCTS_DIR,\n  SHARED_TERRAFORM_DIR,\n} from '../shared-constructs-constants.js';\n\nexport interface AddOpenApiMetadataGenerateTargetOptions {\n  iac: Iac;\n  apiNameKebabCase: string;\n  specPath: string;\n  specBuildTargetName: string;\n  /**\n   * How integrations are mapped to operations. Terraform only needs the\n   * operations metadata for the `isolated` pattern, since the `shared` pattern\n   * routes every operation to one proxy Lambda.\n   */\n  integrationPattern?: 'isolated' | 'shared';\n}\n\n/**\n * Adds a target which generates metadata about the API's operations from its\n * OpenAPI specification, so that infrastructure can define an integration per\n * operation.\n *\n * For CDK this generates TypeScript, giving the construct type-safe integrations.\n * For Terraform this generates JSON, which the vended module reads to build one\n * Lambda function and route per operation.\n */\nexport const addSharedConstructsOpenApiMetadataGenerateTarget = (\n  tree: Tree,\n  options: AddOpenApiMetadataGenerateTargetOptions,\n) => {\n  if (options.iac === 'cdk') {\n    addCdkOpenApiMetadataGenerateTarget(tree, options);\n  } else if (options.iac === 'terraform') {\n    addTerraformOpenApiOperationsGenerateTarget(tree, options);\n  }\n};\n\nconst addCdkOpenApiMetadataGenerateTarget = (\n  tree: Tree,\n  {\n    apiNameKebabCase,\n    specPath,\n    specBuildTargetName,\n  }: AddOpenApiMetadataGenerateTargetOptions,\n) => {\n  const generatedMetadataDir = joinPathFragments('generated', apiNameKebabCase);\n  const generatedMetadataDirFromRoot = joinPathFragments(\n    joinPathFragments(PACKAGES_DIR, SHARED_CONSTRUCTS_DIR),\n    'src',\n    generatedMetadataDir,\n  );\n\n  updateJson(\n    tree,\n    joinPathFragments(PACKAGES_DIR, SHARED_CONSTRUCTS_DIR, 'project.json'),\n    (config: ProjectConfiguration) => {\n      if (!config.targets) {\n        config.targets = {};\n      }\n      if (!config.targets.build) {\n        config.targets.build = {};\n      }\n      // If not already defined, add a target to generate metadata from the OpenAPI spec, used\n      // for providing a type-safe CDK construct\n      const metadataTargetName = `generate:${apiNameKebabCase}-metadata`;\n      if (!config.targets[metadataTargetName]) {\n        config.targets[metadataTargetName] = openApiCodegenTarget({\n          generator: 'ts-metadata',\n          openApiSpecPath: specPath,\n          outputPath: generatedMetadataDirFromRoot,\n          specBuildTargetName,\n          outputs: [\n            joinPathFragments('{workspaceRoot}', generatedMetadataDirFromRoot),\n          ],\n        });\n      }\n      addDependencyToTargetIfNotPresent(config, 'compile', metadataTargetName);\n      return config;\n    },\n  );\n\n  // Ignore the generated metadata by default\n  // Users can safely remove the entry from the .gitignore if they prefer to check it in\n  updateGitIgnore(\n    tree,\n    joinPathFragments(PACKAGES_DIR, SHARED_CONSTRUCTS_DIR),\n    (patterns) => [...patterns, joinPathFragments('src', generatedMetadataDir)],\n  );\n};\n\n/**\n * Directory the operations metadata for an API is generated into, relative to\n * the shared Terraform project's `src`. The vended module reads the file from\n * here, so the module template and this target must agree on the location.\n */\nexport const terraformOperationsMetadataDir = (apiNameKebabCase: string) =>\n  joinPathFragments('generated', apiNameKebabCase);\n\nconst addTerraformOpenApiOperationsGenerateTarget = (\n  tree: Tree,\n  {\n    apiNameKebabCase,\n    specPath,\n    specBuildTargetName,\n    integrationPattern,\n  }: AddOpenApiMetadataGenerateTargetOptions,\n) => {\n  // The `shared` pattern routes every operation to a single proxy Lambda, so the\n  // module has no need for the operations metadata.\n  if (integrationPattern !== 'isolated') {\n    return;\n  }\n\n  const generatedDirFromRoot = joinPathFragments(\n    PACKAGES_DIR,\n    SHARED_TERRAFORM_DIR,\n    'src',\n    terraformOperationsMetadataDir(apiNameKebabCase),\n  );\n\n  updateJson(\n    tree,\n    joinPathFragments(PACKAGES_DIR, SHARED_TERRAFORM_DIR, 'project.json'),\n    (config: ProjectConfiguration) => {\n      config.targets ??= {};\n      // Terraform reads the operations metadata with `file()`, so it must exist\n      // before plan; the target is wired into `build` below.\n      const operationsTargetName = `generate:${apiNameKebabCase}-operations`;\n      if (!config.targets[operationsTargetName]) {\n        config.targets[operationsTargetName] = openApiCodegenTarget({\n          generator: 'json-metadata',\n          openApiSpecPath: specPath,\n          outputPath: generatedDirFromRoot,\n          specBuildTargetName,\n          outputs: [joinPathFragments('{workspaceRoot}', generatedDirFromRoot)],\n        });\n      }\n      addArtifactDependencyToTargets(config, operationsTargetName);\n      return config;\n    },\n  );\n\n  // Ignore the generated metadata by default\n  // Users can safely remove the entry from the .gitignore if they prefer to check it in\n  updateGitIgnore(\n    tree,\n    joinPathFragments(PACKAGES_DIR, SHARED_TERRAFORM_DIR),\n    (patterns) => [\n      ...patterns,\n      joinPathFragments(\n        'src',\n        terraformOperationsMetadataDir(apiNameKebabCase),\n      ),\n    ],\n  );\n};\n"],"names":["joinPathFragments","updateJson","updateGitIgnore","addArtifactDependencyToTargets","addDependencyToTargetIfNotPresent","openApiCodegenTarget","PACKAGES_DIR","SHARED_CONSTRUCTS_DIR","SHARED_TERRAFORM_DIR","addSharedConstructsOpenApiMetadataGenerateTarget","tree","options","iac","addCdkOpenApiMetadataGenerateTarget","addTerraformOpenApiOperationsGenerateTarget","apiNameKebabCase","specPath","specBuildTargetName","generatedMetadataDir","generatedMetadataDirFromRoot","config","targets","build","metadataTargetName","generator","openApiSpecPath","outputPath","outputs","patterns","terraformOperationsMetadataDir","integrationPattern","generatedDirFromRoot","operationsTargetName"],"mappings":"AAAA;;;CAGC,GACD,SACEA,iBAAiB,EAGjBC,UAAU,QACL,aAAa;AACpB,SAASC,eAAe,QAAQ,YAAY;AAE5C,SACEC,8BAA8B,EAC9BC,iCAAiC,QAC5B,WAAW;AAClB,SAASC,oBAAoB,QAAQ,gCAAgC;AACrE,SACEC,YAAY,EACZC,qBAAqB,EACrBC,oBAAoB,QACf,oCAAoC;AAe3C;;;;;;;;CAQC,GACD,OAAO,MAAMC,mDAAmD,CAC9DC,MACAC;IAEA,IAAIA,QAAQC,GAAG,KAAK,OAAO;QACzBC,oCAAoCH,MAAMC;IAC5C,OAAO,IAAIA,QAAQC,GAAG,KAAK,aAAa;QACtCE,4CAA4CJ,MAAMC;IACpD;AACF,EAAE;AAEF,MAAME,sCAAsC,CAC1CH,MACA,EACEK,gBAAgB,EAChBC,QAAQ,EACRC,mBAAmB,EACqB;IAE1C,MAAMC,uBAAuBlB,kBAAkB,aAAae;IAC5D,MAAMI,+BAA+BnB,kBACnCA,kBAAkBM,cAAcC,wBAChC,OACAW;IAGFjB,WACES,MACAV,kBAAkBM,cAAcC,uBAAuB,iBACvD,CAACa;QACC,IAAI,CAACA,OAAOC,OAAO,EAAE;YACnBD,OAAOC,OAAO,GAAG,CAAC;QACpB;QACA,IAAI,CAACD,OAAOC,OAAO,CAACC,KAAK,EAAE;YACzBF,OAAOC,OAAO,CAACC,KAAK,GAAG,CAAC;QAC1B;QACA,wFAAwF;QACxF,0CAA0C;QAC1C,MAAMC,qBAAqB,CAAC,SAAS,EAAER,iBAAiB,SAAS,CAAC;QAClE,IAAI,CAACK,OAAOC,OAAO,CAACE,mBAAmB,EAAE;YACvCH,OAAOC,OAAO,CAACE,mBAAmB,GAAGlB,qBAAqB;gBACxDmB,WAAW;gBACXC,iBAAiBT;gBACjBU,YAAYP;gBACZF;gBACAU,SAAS;oBACP3B,kBAAkB,mBAAmBmB;iBACtC;YACH;QACF;QACAf,kCAAkCgB,QAAQ,WAAWG;QACrD,OAAOH;IACT;IAGF,2CAA2C;IAC3C,sFAAsF;IACtFlB,gBACEQ,MACAV,kBAAkBM,cAAcC,wBAChC,CAACqB,WAAa;eAAIA;YAAU5B,kBAAkB,OAAOkB;SAAsB;AAE/E;AAEA;;;;CAIC,GACD,OAAO,MAAMW,iCAAiC,CAACd,mBAC7Cf,kBAAkB,aAAae,kBAAkB;AAEnD,MAAMD,8CAA8C,CAClDJ,MACA,EACEK,gBAAgB,EAChBC,QAAQ,EACRC,mBAAmB,EACnBa,kBAAkB,EACsB;IAE1C,+EAA+E;IAC/E,kDAAkD;IAClD,IAAIA,uBAAuB,YAAY;QACrC;IACF;IAEA,MAAMC,uBAAuB/B,kBAC3BM,cACAE,sBACA,OACAqB,+BAA+Bd;IAGjCd,WACES,MACAV,kBAAkBM,cAAcE,sBAAsB,iBACtD,CAACY;QACCA,OAAOC,OAAO,KAAK,CAAC;QACpB,0EAA0E;QAC1E,uDAAuD;QACvD,MAAMW,uBAAuB,CAAC,SAAS,EAAEjB,iBAAiB,WAAW,CAAC;QACtE,IAAI,CAACK,OAAOC,OAAO,CAACW,qBAAqB,EAAE;YACzCZ,OAAOC,OAAO,CAACW,qBAAqB,GAAG3B,qBAAqB;gBAC1DmB,WAAW;gBACXC,iBAAiBT;gBACjBU,YAAYK;gBACZd;gBACAU,SAAS;oBAAC3B,kBAAkB,mBAAmB+B;iBAAsB;YACvE;QACF;QACA5B,+BAA+BiB,QAAQY;QACvC,OAAOZ;IACT;IAGF,2CAA2C;IAC3C,sFAAsF;IACtFlB,gBACEQ,MACAV,kBAAkBM,cAAcE,uBAChC,CAACoB,WAAa;eACTA;YACH5B,kBACE,OACA6B,+BAA+Bd;SAElC;AAEL"}

package/src/utils/api-constructs/trpc-operations-metadata.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type ProjectConfiguration, type Tree } from '@nx/devkit';
+export interface AddTrpcOperationsMetadataTargetOptions {
+    apiNameKebabCase: string;
+    /** The tRPC backend project the operations are derived from. */
+    project: ProjectConfiguration;
+    /** Template variables for the vended script (module format). */
+    templateOptions: Record<string, unknown>;
+}
+/**
+ * Adds operations metadata generation for a tRPC API deployed with Terraform.
+ *
+ * tRPC has no OpenAPI specification, so the operations are derived by walking
+ * the router: a vended script writes the same JSON shape the OpenAPI-based
+ * generator produces, which the Terraform module reads to define one Lambda
+ * function and route per procedure.
+ */
+export declare const addTrpcOperationsMetadataTarget: (tree: Tree, { apiNameKebabCase, project, templateOptions, }: AddTrpcOperationsMetadataTargetOptions) => void;

package/src/utils/api-constructs/trpc-operations-metadata.js

@@ -0,0 +1,61 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */ import { generateFiles, joinPathFragments, OverwriteStrategy, updateJson } from "@nx/devkit";
+import { OPERATIONS_METADATA_FILE_NAME } from "../../open-api/json-metadata/generator.js";
+import { updateGitIgnore } from "../git.js";
+import { addArtifactDependencyToTargets } from "../nx.js";
+import { PACKAGES_DIR, SHARED_TERRAFORM_DIR } from "../shared-constructs-constants.js";
+import { terraformOperationsMetadataDir } from "./open-api-metadata.js";
+/**
+ * Adds operations metadata generation for a tRPC API deployed with Terraform.
+ *
+ * tRPC has no OpenAPI specification, so the operations are derived by walking
+ * the router: a vended script writes the same JSON shape the OpenAPI-based
+ * generator produces, which the Terraform module reads to define one Lambda
+ * function and route per procedure.
+ */ export const addTrpcOperationsMetadataTarget = (tree, { apiNameKebabCase, project, templateOptions })=>{
+    generateFiles(tree, joinPathFragments(import.meta.dirname, '..', '..', 'trpc', 'backend', 'files-operations'), project.root, templateOptions, {
+        overwriteStrategy: OverwriteStrategy.Overwrite
+    });
+    const generatedDirFromRoot = joinPathFragments(PACKAGES_DIR, SHARED_TERRAFORM_DIR, 'src', terraformOperationsMetadataDir(apiNameKebabCase));
+    const operationsFile = joinPathFragments(generatedDirFromRoot, OPERATIONS_METADATA_FILE_NAME);
+    project.targets ??= {};
+    project.targets.operations ??= {
+        cache: true,
+        // The metadata is derived from this project's own router, so a dependency's
+        // project directory (which Nx's implicit inputs would read in full)
+        // contributes nothing beyond its build artifacts.
+        inputs: [
+            'default'
+        ],
+        executor: 'nx:run-commands',
+        outputs: [
+            joinPathFragments('{workspaceRoot}', generatedDirFromRoot)
+        ],
+        options: {
+            commands: [
+                `tsx {projectRoot}/scripts/generate-operations.ts ${operationsFile}`
+            ],
+            cwd: '{workspaceRoot}'
+        },
+        dependsOn: [
+            'compile'
+        ]
+    };
+    addArtifactDependencyToTargets(project, 'operations');
+    // The shared Terraform project reads the generated file with `file()`, so it
+    // must be written before that project is planned.
+    updateJson(tree, joinPathFragments(PACKAGES_DIR, SHARED_TERRAFORM_DIR, 'project.json'), (config)=>{
+        addArtifactDependencyToTargets(config, `${project.name}:operations`);
+        return config;
+    });
+    // Ignore the generated metadata by default
+    // Users can safely remove the entry from the .gitignore if they prefer to check it in
+    updateGitIgnore(tree, joinPathFragments(PACKAGES_DIR, SHARED_TERRAFORM_DIR), (patterns)=>[
+            ...patterns,
+            joinPathFragments('src', terraformOperationsMetadataDir(apiNameKebabCase))
+        ]);
+};
+
+//# sourceMappingURL=trpc-operations-metadata.js.map

package/src/utils/api-constructs/trpc-operations-metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/nx-plugin/src/utils/api-constructs/trpc-operations-metadata.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\nimport {\n  generateFiles,\n  joinPathFragments,\n  OverwriteStrategy,\n  type ProjectConfiguration,\n  type Tree,\n  updateJson,\n} from '@nx/devkit';\nimport { OPERATIONS_METADATA_FILE_NAME } from '../../open-api/json-metadata/generator.js';\nimport { updateGitIgnore } from '../git.js';\nimport { addArtifactDependencyToTargets } from '../nx.js';\nimport {\n  PACKAGES_DIR,\n  SHARED_TERRAFORM_DIR,\n} from '../shared-constructs-constants.js';\nimport { terraformOperationsMetadataDir } from './open-api-metadata.js';\n\nexport interface AddTrpcOperationsMetadataTargetOptions {\n  apiNameKebabCase: string;\n  /** The tRPC backend project the operations are derived from. */\n  project: ProjectConfiguration;\n  /** Template variables for the vended script (module format). */\n  templateOptions: Record<string, unknown>;\n}\n\n/**\n * Adds operations metadata generation for a tRPC API deployed with Terraform.\n *\n * tRPC has no OpenAPI specification, so the operations are derived by walking\n * the router: a vended script writes the same JSON shape the OpenAPI-based\n * generator produces, which the Terraform module reads to define one Lambda\n * function and route per procedure.\n */\nexport const addTrpcOperationsMetadataTarget = (\n  tree: Tree,\n  {\n    apiNameKebabCase,\n    project,\n    templateOptions,\n  }: AddTrpcOperationsMetadataTargetOptions,\n) => {\n  generateFiles(\n    tree,\n    joinPathFragments(\n      import.meta.dirname,\n      '..',\n      '..',\n      'trpc',\n      'backend',\n      'files-operations',\n    ),\n    project.root,\n    templateOptions,\n    {\n      overwriteStrategy: OverwriteStrategy.Overwrite,\n    },\n  );\n\n  const generatedDirFromRoot = joinPathFragments(\n    PACKAGES_DIR,\n    SHARED_TERRAFORM_DIR,\n    'src',\n    terraformOperationsMetadataDir(apiNameKebabCase),\n  );\n  const operationsFile = joinPathFragments(\n    generatedDirFromRoot,\n    OPERATIONS_METADATA_FILE_NAME,\n  );\n\n  project.targets ??= {};\n  project.targets.operations ??= {\n    cache: true,\n    // The metadata is derived from this project's own router, so a dependency's\n    // project directory (which Nx's implicit inputs would read in full)\n    // contributes nothing beyond its build artifacts.\n    inputs: ['default'],\n    executor: 'nx:run-commands',\n    outputs: [joinPathFragments('{workspaceRoot}', generatedDirFromRoot)],\n    options: {\n      commands: [\n        `tsx {projectRoot}/scripts/generate-operations.ts ${operationsFile}`,\n      ],\n      cwd: '{workspaceRoot}',\n    },\n    dependsOn: ['compile'],\n  };\n  addArtifactDependencyToTargets(project, 'operations');\n\n  // The shared Terraform project reads the generated file with `file()`, so it\n  // must be written before that project is planned.\n  updateJson(\n    tree,\n    joinPathFragments(PACKAGES_DIR, SHARED_TERRAFORM_DIR, 'project.json'),\n    (config: ProjectConfiguration) => {\n      addArtifactDependencyToTargets(config, `${project.name}:operations`);\n      return config;\n    },\n  );\n\n  // Ignore the generated metadata by default\n  // Users can safely remove the entry from the .gitignore if they prefer to check it in\n  updateGitIgnore(\n    tree,\n    joinPathFragments(PACKAGES_DIR, SHARED_TERRAFORM_DIR),\n    (patterns) => [\n      ...patterns,\n      joinPathFragments(\n        'src',\n        terraformOperationsMetadataDir(apiNameKebabCase),\n      ),\n    ],\n  );\n};\n"],"names":["generateFiles","joinPathFragments","OverwriteStrategy","updateJson","OPERATIONS_METADATA_FILE_NAME","updateGitIgnore","addArtifactDependencyToTargets","PACKAGES_DIR","SHARED_TERRAFORM_DIR","terraformOperationsMetadataDir","addTrpcOperationsMetadataTarget","tree","apiNameKebabCase","project","templateOptions","dirname","root","overwriteStrategy","Overwrite","generatedDirFromRoot","operationsFile","targets","operations","cache","inputs","executor","outputs","options","commands","cwd","dependsOn","config","name","patterns"],"mappings":"AAAA;;;CAGC,GACD,SACEA,aAAa,EACbC,iBAAiB,EACjBC,iBAAiB,EAGjBC,UAAU,QACL,aAAa;AACpB,SAASC,6BAA6B,QAAQ,4CAA4C;AAC1F,SAASC,eAAe,QAAQ,YAAY;AAC5C,SAASC,8BAA8B,QAAQ,WAAW;AAC1D,SACEC,YAAY,EACZC,oBAAoB,QACf,oCAAoC;AAC3C,SAASC,8BAA8B,QAAQ,yBAAyB;AAUxE;;;;;;;CAOC,GACD,OAAO,MAAMC,kCAAkC,CAC7CC,MACA,EACEC,gBAAgB,EAChBC,OAAO,EACPC,eAAe,EACwB;IAEzCd,cACEW,MACAV,kBACE,YAAYc,OAAO,EACnB,MACA,MACA,QACA,WACA,qBAEFF,QAAQG,IAAI,EACZF,iBACA;QACEG,mBAAmBf,kBAAkBgB,SAAS;IAChD;IAGF,MAAMC,uBAAuBlB,kBAC3BM,cACAC,sBACA,OACAC,+BAA+BG;IAEjC,MAAMQ,iBAAiBnB,kBACrBkB,sBACAf;IAGFS,QAAQQ,OAAO,KAAK,CAAC;IACrBR,QAAQQ,OAAO,CAACC,UAAU,KAAK;QAC7BC,OAAO;QACP,4EAA4E;QAC5E,oEAAoE;QACpE,kDAAkD;QAClDC,QAAQ;YAAC;SAAU;QACnBC,UAAU;QACVC,SAAS;YAACzB,kBAAkB,mBAAmBkB;SAAsB;QACrEQ,SAAS;YACPC,UAAU;gBACR,CAAC,iDAAiD,EAAER,gBAAgB;aACrE;YACDS,KAAK;QACP;QACAC,WAAW;YAAC;SAAU;IACxB;IACAxB,+BAA+BO,SAAS;IAExC,6EAA6E;IAC7E,kDAAkD;IAClDV,WACEQ,MACAV,kBAAkBM,cAAcC,sBAAsB,iBACtD,CAACuB;QACCzB,+BAA+ByB,QAAQ,GAAGlB,QAAQmB,IAAI,CAAC,WAAW,CAAC;QACnE,OAAOD;IACT;IAGF,2CAA2C;IAC3C,sFAAsF;IACtF1B,gBACEM,MACAV,kBAAkBM,cAAcC,uBAChC,CAACyB,WAAa;eACTA;YACHhC,kBACE,OACAQ,+BAA+BG;SAElC;AAEL,EAAE"}

package/src/utils/ast/website.js

@@ -1,27 +1,25 @@
-"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.addHookResultToRouterProviderContext = void 0;
-const ast_1 = require("../ast");
-const addHookResultToRouterProviderContext = async (tree, mainTsxPath, { hook, module, contextProp }) => {
+ */ import { addDestructuredImport, applyGritQL, matchGritQL } from "../ast.js";
+export const addHookResultToRouterProviderContext = async (tree, mainTsxPath, { hook, module, contextProp })=>{
     // All 4 patterns must exist for this transform to apply
     const checks = await Promise.all([
-        (0, ast_1.matchGritQL)(tree, mainTsxPath, '`RouterProviderContext`'),
-        (0, ast_1.matchGritQL)(tree, mainTsxPath, '`createRouter($_)`'),
-        (0, ast_1.matchGritQL)(tree, mainTsxPath, '`const App = $_`'),
-        (0, ast_1.matchGritQL)(tree, mainTsxPath, '`<RouterProvider $_ />`'),
+        matchGritQL(tree, mainTsxPath, '`RouterProviderContext`'),
+        matchGritQL(tree, mainTsxPath, '`createRouter($_)`'),
+        matchGritQL(tree, mainTsxPath, '`const App = $_`'),
+        matchGritQL(tree, mainTsxPath, '`<RouterProvider $_ />`')
     ]);
-    if (checks.some((c) => !c)) {
+    if (checks.some((c)=>!c)) {
         return;
     }
-    await (0, ast_1.addDestructuredImport)(tree, mainTsxPath, [hook], module);
+    await addDestructuredImport(tree, mainTsxPath, [
+        hook
+    ], module);
     // 1. Add property to RouterProviderContext type
     //    'some' checks direct members only (not nested), so a nested 'auth' won't block adding a top-level one.
     //    Type members use ; as terminators, so += with leading \n handles separation.
-    await (0, ast_1.applyGritQL)(tree, mainTsxPath, `or {
+    await applyGritQL(tree, mainTsxPath, `or {
       \`type RouterProviderContext = {}\` => \`type RouterProviderContext = {
   ${contextProp}?: ReturnType<typeof ${hook}>;
 }\`,
@@ -34,25 +32,25 @@ ${contextProp}?: ReturnType<typeof ${hook}>\`
     // 2. Add context property to createRouter config
     //    'some' checks direct properties of the createRouter argument object only.
     //    Use += for multi-prop objects, => rewrite for single-prop.
-    await (0, ast_1.applyGritQL)(tree, mainTsxPath, `\`createRouter({ $props })\` where {
+    await applyGritQL(tree, mainTsxPath, `\`createRouter({ $props })\` where {
       $props <: not some \`context: $_\`,
       $props += \`context: { ${contextProp}: undefined }\`
     }`);
     // If context already exists, add the new prop to it.
     // Handle empty context: {} via nested contains => rewrite, scoped to createRouter.
-    await (0, ast_1.applyGritQL)(tree, mainTsxPath, `\`createRouter({ $props })\` where {
+    await applyGritQL(tree, mainTsxPath, `\`createRouter({ $props })\` where {
       $props <: contains \`context: {}\` => \`context: { ${contextProp}: undefined }\`
     }`);
     // Handle non-empty context via rewrite (the context object may be single-prop
     // from the first hook call, where += concatenates without comma)
-    await (0, ast_1.applyGritQL)(tree, mainTsxPath, `\`context: { $cprops }\` => \`context: { $cprops, ${contextProp}: undefined }\` where {
+    await applyGritQL(tree, mainTsxPath, `\`context: { $cprops }\` => \`context: { $cprops, ${contextProp}: undefined }\` where {
       $cprops <: within \`createRouter($_)\`,
       $cprops <: not some \`${contextProp}: $_\`
     }`);
     // 3. Add hook call to App component body
     //    Block body: 'some' checks direct statements.
     //    Expression body: 'contains' to also prevent matching block bodies.
-    await (0, ast_1.applyGritQL)(tree, mainTsxPath, `or {
+    await applyGritQL(tree, mainTsxPath, `or {
       \`const App = () => { $body }\` => raw\`const App = () => {
   const ${contextProp} = ${hook}();
   $body
@@ -64,7 +62,7 @@ ${contextProp}?: ReturnType<typeof ${hook}>\`
     }`);
     // 4. Add context prop to RouterProvider JSX element
     //    'some' checks direct JSX attributes only.
-    await (0, ast_1.applyGritQL)(tree, mainTsxPath, `or {
+    await applyGritQL(tree, mainTsxPath, `or {
       \`<RouterProvider $attrs context={{}} />\` => \`<RouterProvider $attrs context={{ ${contextProp} }} />\`,
       \`<RouterProvider $attrs context={{ $cprops }} />\` => \`<RouterProvider $attrs context={{ $cprops, ${contextProp} }} />\` where {
         $cprops <: not some \`${contextProp}\`
@@ -74,5 +72,5 @@ ${contextProp}?: ReturnType<typeof ${hook}>\`
       }
     }`);
 };
-exports.addHookResultToRouterProviderContext = addHookResultToRouterProviderContext;
+
 //# sourceMappingURL=website.js.map