@aws/nx-plugin 1.0.0-rc.6 → 1.0.0-rc.60

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

@@ -1,27 +1,22 @@
-"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 { addDependencyToTargetIfNotPresent } from "../nx.js";
+import { PACKAGES_DIR, SHARED_CONSTRUCTS_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, }) => {
+ */ export 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;
     }
-    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 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 = {};
         }
@@ -37,26 +32,31 @@ const addSharedConstructsOpenApiMetadataGenerateTarget = (tree, { iac, apiNameKe
                 executor: 'nx:run-commands',
                 inputs: [
                     {
-                        dependentTasksOutputFiles: '**/*.json',
-                    },
+                        dependentTasksOutputFiles: '**/*.json'
+                    }
                 ],
                 outputs: [
-                    (0, devkit_1.joinPathFragments)('{workspaceRoot}', generatedMetadataDirFromRoot),
+                    joinPathFragments('{workspaceRoot}', generatedMetadataDirFromRoot)
                 ],
                 options: {
                     commands: [
-                        `nx g @aws/nx-plugin:open-api#ts-metadata --openApiSpecPath="${specPath}" --outputPath="${generatedMetadataDirFromRoot}" --no-interactive`,
-                    ],
+                        `nx g @aws/nx-plugin:open-api#ts-metadata --openApiSpecPath="${specPath}" --outputPath="${generatedMetadataDirFromRoot}" --no-interactive`
+                    ]
                 },
-                dependsOn: [specBuildTargetName],
+                dependsOn: [
+                    specBuildTargetName
+                ]
             };
         }
-        (0, nx_1.addDependencyToTargetIfNotPresent)(config, 'compile', metadataTargetName);
+        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
-    (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_CONSTRUCTS_DIR), (patterns)=>[
+            ...patterns,
+            joinPathFragments('src', generatedMetadataDir)
+        ]);
 };
-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';\nimport type { Iac } from '../iac';\nimport { addDependencyToTargetIfNotPresent } from '../nx';\nimport {\n  PACKAGES_DIR,\n  SHARED_CONSTRUCTS_DIR,\n} from '../shared-constructs-constants';\n\nexport interface AddOpenApiMetadataGenerateTargetOptions {\n  iac: Iac;\n  apiNameKebabCase: string;\n  specPath: string;\n  specBuildTargetName: string;\n}\n\n/**\n * Adds a generate:<api-name>-metadata target to shared constructs (CDK only)\n * This allows for API CDK constructs to have type-safety for integrations based on an OpenAPI Specification\n */\nexport const addSharedConstructsOpenApiMetadataGenerateTarget = (\n  tree: Tree,\n  {\n    iac,\n    apiNameKebabCase,\n    specPath,\n    specBuildTargetName,\n  }: AddOpenApiMetadataGenerateTargetOptions,\n) => {\n  if (iac !== 'cdk') {\n    // For Terraform, we do not support type-safe integration builders, rather only the single lambda\n    // router pattern, and therefore do not need to add depenencies on metadata generation.\n    return;\n  }\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] = {\n          cache: true,\n          executor: 'nx:run-commands',\n          inputs: [\n            {\n              dependentTasksOutputFiles: '**/*.json',\n            },\n          ],\n          outputs: [\n            joinPathFragments('{workspaceRoot}', generatedMetadataDirFromRoot),\n          ],\n          options: {\n            commands: [\n              `nx g @aws/nx-plugin:open-api#ts-metadata --openApiSpecPath=\"${specPath}\" --outputPath=\"${generatedMetadataDirFromRoot}\" --no-interactive`,\n            ],\n          },\n          dependsOn: [specBuildTargetName],\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"],"names":["joinPathFragments","updateJson","updateGitIgnore","addDependencyToTargetIfNotPresent","PACKAGES_DIR","SHARED_CONSTRUCTS_DIR","addSharedConstructsOpenApiMetadataGenerateTarget","tree","iac","apiNameKebabCase","specPath","specBuildTargetName","generatedMetadataDir","generatedMetadataDirFromRoot","config","targets","build","metadataTargetName","cache","executor","inputs","dependentTasksOutputFiles","outputs","options","commands","dependsOn","patterns"],"mappings":"AAAA;;;CAGC,GACD,SACEA,iBAAiB,EAGjBC,UAAU,QACL,aAAa;AACpB,SAASC,eAAe,QAAQ,YAAS;AAEzC,SAASC,iCAAiC,QAAQ,WAAQ;AAC1D,SACEC,YAAY,EACZC,qBAAqB,QAChB,oCAAiC;AASxC;;;CAGC,GACD,OAAO,MAAMC,mDAAmD,CAC9DC,MACA,EACEC,GAAG,EACHC,gBAAgB,EAChBC,QAAQ,EACRC,mBAAmB,EACqB;IAE1C,IAAIH,QAAQ,OAAO;QACjB,iGAAiG;QACjG,uFAAuF;QACvF;IACF;IAEA,MAAMI,uBAAuBZ,kBAAkB,aAAaS;IAC5D,MAAMI,+BAA+Bb,kBACnCA,kBAAkBI,cAAcC,wBAChC,OACAO;IAGFX,WACEM,MACAP,kBAAkBI,cAAcC,uBAAuB,iBACvD,CAACS;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,GAAG;gBACnCC,OAAO;gBACPC,UAAU;gBACVC,QAAQ;oBACN;wBACEC,2BAA2B;oBAC7B;iBACD;gBACDC,SAAS;oBACPtB,kBAAkB,mBAAmBa;iBACtC;gBACDU,SAAS;oBACPC,UAAU;wBACR,CAAC,4DAA4D,EAAEd,SAAS,gBAAgB,EAAEG,6BAA6B,kBAAkB,CAAC;qBAC3I;gBACH;gBACAY,WAAW;oBAACd;iBAAoB;YAClC;QACF;QACAR,kCAAkCW,QAAQ,WAAWG;QACrD,OAAOH;IACT;IAGF,2CAA2C;IAC3C,sFAAsF;IACtFZ,gBACEK,MACAP,kBAAkBI,cAAcC,wBAChC,CAACqB,WAAa;eAAIA;YAAU1B,kBAAkB,OAAOY;SAAsB;AAE/E,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,15 +62,15 @@ ${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}\`
       },
       \`<RouterProvider $attrs />\` => \`<RouterProvider $attrs context={{ ${contextProp} }} />\` where {
-        $attrs <: not some \`context\`
+        $attrs <: not some \`context={$_}\`
       }
     }`);
 };
-exports.addHookResultToRouterProviderContext = addHookResultToRouterProviderContext;
+
 //# sourceMappingURL=website.js.map

package/src/utils/ast/website.js.map

@@ -1 +1 @@
-{"version":3,"file":"website.js","sourceRoot":"","sources":["../../../../../../packages/nx-plugin/src/utils/ast/website.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAGH,gCAAyE;AAQlE,MAAM,oCAAoC,GAAG,KAAK,EACvD,IAAU,EACV,WAAmB,EACnB,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAA6C,EACxE,EAAE;IACF,wDAAwD;IACxD,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;QAC/B,IAAA,iBAAW,EAAC,IAAI,EAAE,WAAW,EAAE,yBAAyB,CAAC;QACzD,IAAA,iBAAW,EAAC,IAAI,EAAE,WAAW,EAAE,oBAAoB,CAAC;QACpD,IAAA,iBAAW,EAAC,IAAI,EAAE,WAAW,EAAE,kBAAkB,CAAC;QAClD,IAAA,iBAAW,EAAC,IAAI,EAAE,WAAW,EAAE,yBAAyB,CAAC;KAC1D,CAAC,CAAC;IAEH,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAC3B,OAAO;IACT,CAAC;IAED,MAAM,IAAA,2BAAqB,EAAC,IAAI,EAAE,WAAW,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,CAAC;IAE/D,gDAAgD;IAChD,4GAA4G;IAC5G,kFAAkF;IAClF,MAAM,IAAA,iBAAW,EACf,IAAI,EACJ,WAAW,EACX;;IAEA,WAAW,wBAAwB,IAAI;;;iCAGV,WAAW;;EAE1C,WAAW,wBAAwB,IAAI;;MAEnC,CACH,CAAC;IAEF,iDAAiD;IACjD,+EAA+E;IAC/E,gEAAgE;IAChE,MAAM,IAAA,iBAAW,EACf,IAAI,EACJ,WAAW,EACX;;+BAE2B,WAAW;MACpC,CACH,CAAC;IAEF,qDAAqD;IACrD,mFAAmF;IACnF,MAAM,IAAA,iBAAW,EACf,IAAI,EACJ,WAAW,EACX;2DACuD,WAAW;MAChE,CACH,CAAC;IACF,8EAA8E;IAC9E,iEAAiE;IACjE,MAAM,IAAA,iBAAW,EACf,IAAI,EACJ,WAAW,EACX,qDAAqD,WAAW;;8BAEtC,WAAW;MACnC,CACH,CAAC;IAEF,yCAAyC;IACzC,kDAAkD;IAClD,wEAAwE;IACxE,MAAM,IAAA,iBAAW,EACf,IAAI,EACJ,WAAW,EACX;;UAEM,WAAW,MAAM,IAAI;;wCAES,WAAW,MAAM,IAAI;;UAEnD,WAAW,MAAM,IAAI;;sCAEO,IAAI;MACpC,CACH,CAAC;IAEF,oDAAoD;IACpD,+CAA+C;IAC/C,MAAM,IAAA,iBAAW,EACf,IAAI,EACJ,WAAW,EACX;0FACsF,WAAW;4GACO,WAAW;gCACvF,WAAW;;6EAEkC,WAAW;;;MAGlF,CACH,CAAC;AACJ,CAAC,CAAC;AAtGW,QAAA,oCAAoC,wCAsG/C"}
+{"version":3,"sources":["../../../../../../packages/nx-plugin/src/utils/ast/website.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { Tree } from '@nx/devkit';\nimport { addDestructuredImport, applyGritQL, matchGritQL } from '../ast';\n\nexport interface AddHookResultToRouterProviderContextProps {\n  hook: string; // eg useAuth\n  module: string; // eg. react-oidc-context\n  contextProp: string; // eg. auth\n}\n\nexport const addHookResultToRouterProviderContext = async (\n  tree: Tree,\n  mainTsxPath: string,\n  { hook, module, contextProp }: AddHookResultToRouterProviderContextProps,\n) => {\n  // All 4 patterns must exist for this transform to apply\n  const checks = await Promise.all([\n    matchGritQL(tree, mainTsxPath, '`RouterProviderContext`'),\n    matchGritQL(tree, mainTsxPath, '`createRouter($_)`'),\n    matchGritQL(tree, mainTsxPath, '`const App = $_`'),\n    matchGritQL(tree, mainTsxPath, '`<RouterProvider $_ />`'),\n  ]);\n\n  if (checks.some((c) => !c)) {\n    return;\n  }\n\n  await addDestructuredImport(tree, mainTsxPath, [hook], module);\n\n  // 1. Add property to RouterProviderContext type\n  //    'some' checks direct members only (not nested), so a nested 'auth' won't block adding a top-level one.\n  //    Type members use ; as terminators, so += with leading \\n handles separation.\n  await applyGritQL(\n    tree,\n    mainTsxPath,\n    `or {\n      \\`type RouterProviderContext = {}\\` => \\`type RouterProviderContext = {\n  ${contextProp}?: ReturnType<typeof ${hook}>;\n}\\`,\n      \\`type RouterProviderContext = { $members }\\` where {\n        $members <: not some \\`${contextProp}?: $_\\`,\n        $members += \\`\n${contextProp}?: ReturnType<typeof ${hook}>\\`\n      }\n    }`,\n  );\n\n  // 2. Add context property to createRouter config\n  //    'some' checks direct properties of the createRouter argument object only.\n  //    Use += for multi-prop objects, => rewrite for single-prop.\n  await applyGritQL(\n    tree,\n    mainTsxPath,\n    `\\`createRouter({ $props })\\` where {\n      $props <: not some \\`context: $_\\`,\n      $props += \\`context: { ${contextProp}: undefined }\\`\n    }`,\n  );\n\n  // If context already exists, add the new prop to it.\n  // Handle empty context: {} via nested contains => rewrite, scoped to createRouter.\n  await applyGritQL(\n    tree,\n    mainTsxPath,\n    `\\`createRouter({ $props })\\` where {\n      $props <: contains \\`context: {}\\` => \\`context: { ${contextProp}: undefined }\\`\n    }`,\n  );\n  // Handle non-empty context via rewrite (the context object may be single-prop\n  // from the first hook call, where += concatenates without comma)\n  await applyGritQL(\n    tree,\n    mainTsxPath,\n    `\\`context: { $cprops }\\` => \\`context: { $cprops, ${contextProp}: undefined }\\` where {\n      $cprops <: within \\`createRouter($_)\\`,\n      $cprops <: not some \\`${contextProp}: $_\\`\n    }`,\n  );\n\n  // 3. Add hook call to App component body\n  //    Block body: 'some' checks direct statements.\n  //    Expression body: 'contains' to also prevent matching block bodies.\n  await applyGritQL(\n    tree,\n    mainTsxPath,\n    `or {\n      \\`const App = () => { $body }\\` => raw\\`const App = () => {\n  const ${contextProp} = ${hook}();\n  $body\n}\\` where { $body <: not some \\`const ${contextProp} = ${hook}()\\` },\n      \\`const App = () => $expr\\` => raw\\`const App = () => {\n  const ${contextProp} = ${hook}();\n  return $expr;\n}\\` where { $expr <: not contains \\`${hook}()\\` }\n    }`,\n  );\n\n  // 4. Add context prop to RouterProvider JSX element\n  //    'some' checks direct JSX attributes only.\n  await applyGritQL(\n    tree,\n    mainTsxPath,\n    `or {\n      \\`<RouterProvider $attrs context={{}} />\\` => \\`<RouterProvider $attrs context={{ ${contextProp} }} />\\`,\n      \\`<RouterProvider $attrs context={{ $cprops }} />\\` => \\`<RouterProvider $attrs context={{ $cprops, ${contextProp} }} />\\` where {\n        $cprops <: not some \\`${contextProp}\\`\n      },\n      \\`<RouterProvider $attrs />\\` => \\`<RouterProvider $attrs context={{ ${contextProp} }} />\\` where {\n        $attrs <: not some \\`context={$_}\\`\n      }\n    }`,\n  );\n};\n"],"names":["addDestructuredImport","applyGritQL","matchGritQL","addHookResultToRouterProviderContext","tree","mainTsxPath","hook","module","contextProp","checks","Promise","all","some","c"],"mappings":"AAAA;;;CAGC,GAGD,SAASA,qBAAqB,EAAEC,WAAW,EAAEC,WAAW,QAAQ,YAAS;AAQzE,OAAO,MAAMC,uCAAuC,OAClDC,MACAC,aACA,EAAEC,IAAI,EAAEC,MAAM,EAAEC,WAAW,EAA6C;IAExE,wDAAwD;IACxD,MAAMC,SAAS,MAAMC,QAAQC,GAAG,CAAC;QAC/BT,YAAYE,MAAMC,aAAa;QAC/BH,YAAYE,MAAMC,aAAa;QAC/BH,YAAYE,MAAMC,aAAa;QAC/BH,YAAYE,MAAMC,aAAa;KAChC;IAED,IAAII,OAAOG,IAAI,CAAC,CAACC,IAAM,CAACA,IAAI;QAC1B;IACF;IAEA,MAAMb,sBAAsBI,MAAMC,aAAa;QAACC;KAAK,EAAEC;IAEvD,gDAAgD;IAChD,4GAA4G;IAC5G,kFAAkF;IAClF,MAAMN,YACJG,MACAC,aACA,CAAC;;EAEH,EAAEG,YAAY,qBAAqB,EAAEF,KAAK;;;+BAGb,EAAEE,YAAY;;AAE7C,EAAEA,YAAY,qBAAqB,EAAEF,KAAK;;KAErC,CAAC;IAGJ,iDAAiD;IACjD,+EAA+E;IAC/E,gEAAgE;IAChE,MAAML,YACJG,MACAC,aACA,CAAC;;6BAEwB,EAAEG,YAAY;KACtC,CAAC;IAGJ,qDAAqD;IACrD,mFAAmF;IACnF,MAAMP,YACJG,MACAC,aACA,CAAC;yDACoD,EAAEG,YAAY;KAClE,CAAC;IAEJ,8EAA8E;IAC9E,iEAAiE;IACjE,MAAMP,YACJG,MACAC,aACA,CAAC,kDAAkD,EAAEG,YAAY;;4BAEzC,EAAEA,YAAY;KACrC,CAAC;IAGJ,yCAAyC;IACzC,kDAAkD;IAClD,wEAAwE;IACxE,MAAMP,YACJG,MACAC,aACA,CAAC;;QAEG,EAAEG,YAAY,GAAG,EAAEF,KAAK;;sCAEM,EAAEE,YAAY,GAAG,EAAEF,KAAK;;QAEtD,EAAEE,YAAY,GAAG,EAAEF,KAAK;;oCAEI,EAAEA,KAAK;KACtC,CAAC;IAGJ,oDAAoD;IACpD,+CAA+C;IAC/C,MAAML,YACJG,MACAC,aACA,CAAC;wFACmF,EAAEG,YAAY;0GACI,EAAEA,YAAY;8BAC1F,EAAEA,YAAY;;2EAE+B,EAAEA,YAAY;;;KAGpF,CAAC;AAEN,EAAE"}

package/src/utils/ast.d.ts

@@ -54,6 +54,15 @@ export declare const matchGritQL: (tree: Tree, filePath: string, pattern: string
  * matches. The file is not modified.
  */
 export declare const captureGritQL: (tree: Tree, filePath: string, pattern: string) => Promise<string | undefined>;
+/**
+ * Like `captureGritQL`, but returns one metavariable's binding (e.g. `mod`
+ * for `$mod`) instead of the whole matched node.
+ */
+export declare const captureGritQLVariable: (tree: Tree, filePath: string, pattern: string, variableName: string) => Promise<string | undefined>;
+/**
+ * Return the text of every node matching the GritQL pattern, in document order.
+ */
+export declare const captureAllGritQL: (tree: Tree, filePath: string, pattern: string) => Promise<string[]>;
 /**
  * A unique token that is a valid identifier, so it can stand in for an array
  * element or object property inside a GritQL rewrite.

package/src/utils/ast.js

@@ -1,40 +1,49 @@
-"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.insertViaGritQL = exports.GRIT_INSERT_PLACEHOLDER = exports.captureGritQL = exports.matchGritQL = exports.applyGritQL = exports.hasExportDeclaration = exports.addStarExport = exports.addSingleImport = exports.addPythonDestructuredImport = exports.addDestructuredImport = void 0;
-const tslib_1 = require("tslib");
-const gritql_1 = require("@getgrit/gritql");
-const path = tslib_1.__importStar(require("path"));
-const git_1 = require("./git");
+ */ import { QueryBuilder } from "@getgrit/gritql";
+import * as path from "path";
+import { updateGitIgnore } from "./git.js";
+import { isEsmWorkspace } from "./module-format.js";
 const GRIT_DIR = '.grit';
+/**
+ * Normalize a relative module specifier for the workspace's module format.
+ * ESM (`nodenext`) requires an explicit `.js` extension on relative imports;
+ * CommonJS (`node16`) resolves them extensionless. Callers always pass the ESM
+ * form (with `.js`); this strips the extension for CommonJS workspaces.
+ */ const normalizeModuleSpecifier = (tree, from)=>{
+    if (isEsmWorkspace(tree)) {
+        return from;
+    }
+    const isRelative = from.startsWith('./') || from.startsWith('../');
+    return isRelative && from.endsWith('.js') ? from.slice(0, -'.js'.length) : from;
+};
 // Pin the gritql native library's "global" stdlib directory to <workspace>/.grit so it doesn't try to write to /usr/local/.grit (or wherever node's grandparent resolves to).
-const ensureGritDir = (tree) => {
+const ensureGritDir = (tree)=>{
     process.env.GRIT_GLOBAL_DIR ??= path.join(tree.root, GRIT_DIR);
-    (0, git_1.updateGitIgnore)(tree, '.', (patterns) => [...patterns, GRIT_DIR]);
+    updateGitIgnore(tree, '.', (patterns)=>[
+            ...patterns,
+            GRIT_DIR
+        ]);
 };
-const assertFilePath = (tree, filePath) => {
+const assertFilePath = (tree, filePath)=>{
     if (!tree.exists(filePath)) {
         throw new Error(`No file located at ${filePath}`);
     }
 };
-const addDestructuredImport = async (tree, filePath, variableNames, from) => {
+export const addDestructuredImport = async (tree, filePath, variableNames, from)=>{
     assertFilePath(tree, filePath);
+    from = normalizeModuleSpecifier(tree, from);
     // Check if there's an existing import from this module
-    const hasExistingImport = await (0, exports.matchGritQL)(tree, filePath, `\`import { $_ } from '${from}'\``);
+    const hasExistingImport = await matchGritQL(tree, filePath, `\`import { $_ } from '${from}'\``);
     if (hasExistingImport) {
         // For each new variable, use GritQL rewrite to add it if not already present
-        for (const variableName of variableNames) {
-            const localName = variableName.includes(' as ')
-                ? variableName.split(' as ')[1]
-                : variableName;
+        for (const variableName of variableNames){
+            const localName = variableName.includes(' as ') ? variableName.split(' as ')[1] : variableName;
             // Use rewrite (=>) which correctly handles comma-separated import specifier lists
-            await (0, exports.applyGritQL)(tree, filePath, `\`import { $imports } from '${from}'\` => \`import { $imports, ${variableName} } from '${from}'\` where { $imports <: not contains \`${localName}\` }`);
+            await applyGritQL(tree, filePath, `\`import { $imports } from '${from}'\` => \`import { $imports, ${variableName} } from '${from}'\` where { $imports <: not contains \`${localName}\` }`);
         }
-    }
-    else {
+    } else {
         // No existing import — prepend a new one (after shebang if present)
         const specifiers = variableNames.join(', ');
         const contents = tree.read(filePath).toString();
@@ -42,13 +51,11 @@ const addDestructuredImport = async (tree, filePath, variableNames, from) => {
         if (contents.startsWith('#!')) {
             const newlineIndex = contents.indexOf('\n');
             tree.write(filePath, `${contents.substring(0, newlineIndex + 1)}${newImport}${contents.substring(newlineIndex + 1)}`);
-        }
-        else {
+        } else {
             tree.write(filePath, `${newImport}${contents}`);
         }
     }
 };
-exports.addDestructuredImport = addDestructuredImport;
 /**
  * Ensure a Python `from <module> import <name1>, <name2>, ...` statement
  * exists in the given file. If the module already has a `from <module> import`
@@ -61,17 +68,16 @@ exports.addDestructuredImport = addDestructuredImport;
  * was rewritten after trying every requested name, we fall back to checking
  * whether the module is imported at all; if not, we prepend a fresh
  * `from <module> import ...` line.
- */
-const addPythonDestructuredImport = async (tree, filePath, variableNames, from) => {
+ */ export const addPythonDestructuredImport = async (tree, filePath, variableNames, from)=>{
     assertFilePath(tree, filePath);
     // Determine whether there's any `from <module> import ...` line in the file.
     // We detect this by attempting a no-op transformation — the file is unchanged,
     // but a successful match tells us the line exists.
     const beforeContents = tree.read(filePath).toString();
     let moduleAlreadyImported = false;
-    for (const variableName of variableNames) {
+    for (const variableName of variableNames){
         // Appends the name if the import-from exists and the name isn't already there.
-        const appended = await (0, exports.applyGritQL)(tree, filePath, `language python\n\`from ${from} import $names\` where { $names <: not contains \`${variableName}\`, $names += \`, ${variableName}\` }`);
+        const appended = await applyGritQL(tree, filePath, `language python\n\`from ${from} import $names\` where { $names <: not contains \`${variableName}\`, $names += \`, ${variableName}\` }`);
         if (appended) {
             moduleAlreadyImported = true;
         }
@@ -83,9 +89,7 @@ const addPythonDestructuredImport = async (tree, filePath, variableNames, from)
     if (moduleAlreadyImported) {
         return;
     }
-    const allAlreadyPresent = await (0, exports.matchGritQL)(tree, filePath, `language python\n\`from ${from} import $names\` where { ${variableNames
-        .map((n) => `$names <: contains \`${n}\``)
-        .join(', ')} }`);
+    const allAlreadyPresent = await matchGritQL(tree, filePath, `language python\n\`from ${from} import $names\` where { ${variableNames.map((n)=>`$names <: contains \`${n}\``).join(', ')} }`);
     if (allAlreadyPresent) {
         return;
     }
@@ -94,15 +98,14 @@ const addPythonDestructuredImport = async (tree, filePath, variableNames, from)
     const specifiers = variableNames.join(', ');
     tree.write(filePath, `from ${from} import ${specifiers}\n${beforeContents}`);
 };
-exports.addPythonDestructuredImport = addPythonDestructuredImport;
 /**
  * Adds an `import <variableName> from '<from>'; statement to the beginning of the file,
  * if it doesn't already exist
- */
-const addSingleImport = async (tree, filePath, variableName, from) => {
+ */ export const addSingleImport = async (tree, filePath, variableName, from)=>{
     assertFilePath(tree, filePath);
+    from = normalizeModuleSpecifier(tree, from);
     // Check if default import already exists using GritQL
-    const alreadyImported = await (0, exports.matchGritQL)(tree, filePath, `\`import ${variableName} from '${from}'\``);
+    const alreadyImported = await matchGritQL(tree, filePath, `\`import ${variableName} from '${from}'\``);
     if (alreadyImported) {
         return;
     }
@@ -110,12 +113,11 @@ const addSingleImport = async (tree, filePath, variableName, from) => {
     const contents = tree.read(filePath).toString();
     tree.write(filePath, `import ${variableName} from '${from}';\n${contents}`);
 };
-exports.addSingleImport = addSingleImport;
 /**
  * Adds an `export * from '<from>'; statement to the given TypeScript file.
  * Note that this will create the file if it does not exist in the tree.
- */
-const addStarExport = async (tree, filePath, from) => {
+ */ export const addStarExport = async (tree, filePath, from)=>{
+    from = normalizeModuleSpecifier(tree, from);
     const contents = tree.read(filePath)?.toString() ?? '';
     // For empty/non-existent files, just write the export
     if (!contents.trim()) {
@@ -123,59 +125,54 @@ const addStarExport = async (tree, filePath, from) => {
         return;
     }
     // Check if already exported using GritQL
-    const alreadyExported = await (0, exports.matchGritQL)(tree, filePath, `\`export * from '${from}'\``);
+    const alreadyExported = await matchGritQL(tree, filePath, `\`export * from '${from}'\``);
     if (alreadyExported) {
         return;
     }
     // Prepend new export to file
     tree.write(filePath, `export * from '${from}';\n${contents}`);
 };
-exports.addStarExport = addStarExport;
 /**
  * Return whether or not the given identifier is exported in the source file.
  * Checks for both `export { Identifier }` and `export type Identifier = ...`.
- */
-const hasExportDeclaration = async (tree, source, identifierName) => {
+ */ export const hasExportDeclaration = async (tree, source, identifierName)=>{
     ensureGritDir(tree);
     const patterns = [
         `\`export type ${identifierName} = $_\``,
         `\`export { ${identifierName} }\``,
-        `\`export type { ${identifierName} } from $_\``,
+        `\`export type { ${identifierName} } from $_\``
     ];
-    for (const pattern of patterns) {
+    for (const pattern of patterns){
         try {
-            const q = new gritql_1.QueryBuilder(`$p => $p where { $p <: ${pattern} }`);
+            const q = new QueryBuilder(`$p => $p where { $p <: ${pattern} }`);
             const result = await q.applyToFile({
                 path: 'check.ts',
-                content: source,
+                content: source
             });
-            if (result !== null)
-                return true;
-        }
-        catch {
-            // Pattern didn't match, try next
+            if (result !== null) return true;
+        } catch  {
+        // Pattern didn't match, try next
         }
     }
     return false;
 };
-exports.hasExportDeclaration = hasExportDeclaration;
 /**
  * Apply a GritQL pattern to a file in the Nx tree.
- */
-const applyGritQL = async (tree, filePath, pattern) => {
-    if (!tree.exists(filePath))
-        throw new Error(`No file at ${filePath}`);
+ */ export const applyGritQL = async (tree, filePath, pattern)=>{
+    if (!tree.exists(filePath)) throw new Error(`No file at ${filePath}`);
     ensureGritDir(tree);
     const source = tree.read(filePath).toString();
-    const query = new gritql_1.QueryBuilder(pattern);
-    const result = await query.applyToFile({ path: filePath, content: source });
+    const query = new QueryBuilder(pattern);
+    const result = await query.applyToFile({
+        path: filePath,
+        content: source
+    });
     if (result && result.content !== source) {
         tree.write(filePath, result.content);
         return true;
     }
     return false;
 };
-exports.applyGritQL = applyGritQL;
 /**
  * Check whether a GritQL pattern matches anywhere in a file.
  * Returns true if the pattern matches at least once.
@@ -183,59 +180,103 @@ exports.applyGritQL = applyGritQL;
  * Accepts raw GritQL, including patterns that start with a `language <name>`
  * header (e.g. `language python\n\`print($_)\``) — the pattern is passed
  * straight through to QueryBuilder without any wrapping rewrite.
- */
-const matchGritQL = async (tree, filePath, pattern) => {
-    if (!tree.exists(filePath))
-        return false;
+ */ export const matchGritQL = async (tree, filePath, pattern)=>{
+    if (!tree.exists(filePath)) return false;
     ensureGritDir(tree);
     const source = tree.read(filePath).toString();
     let matched = false;
     try {
-        const query = new gritql_1.QueryBuilder(pattern);
-        query.filter(() => {
+        const query = new QueryBuilder(pattern);
+        query.filter(()=>{
             matched = true;
             return true;
         });
-        await query.applyToFile({ path: filePath, content: source });
-    }
-    catch {
+        await query.applyToFile({
+            path: filePath,
+            content: source
+        });
+    } catch  {
         return false;
     }
     return matched;
 };
-exports.matchGritQL = matchGritQL;
 /**
  * Capture the source text of the first match of a GritQL pattern.
  *
  * For example `` `dependencyCheck: $_` `` returns the whole
  * `dependencyCheck: { ... }` property text. Returns undefined if nothing
  * matches. The file is not modified.
- */
-const captureGritQL = async (tree, filePath, pattern) => {
-    if (!tree.exists(filePath))
-        return undefined;
+ */ export const captureGritQL = async (tree, filePath, pattern)=>{
+    if (!tree.exists(filePath)) return undefined;
     ensureGritDir(tree);
     const source = tree.read(filePath).toString();
     let captured;
     try {
-        const query = new gritql_1.QueryBuilder(pattern);
-        query.filter((node) => {
+        const query = new QueryBuilder(pattern);
+        query.filter((node)=>{
             captured ??= node.text();
             return true;
         });
-        await query.applyToFile({ path: filePath, content: source });
+        await query.applyToFile({
+            path: filePath,
+            content: source
+        });
+    } catch  {
+        return undefined;
     }
-    catch {
+    return captured;
+};
+/**
+ * Like `captureGritQL`, but returns one metavariable's binding (e.g. `mod`
+ * for `$mod`) instead of the whole matched node.
+ */ export const captureGritQLVariable = async (tree, filePath, pattern, variableName)=>{
+    if (!tree.exists(filePath)) return undefined;
+    ensureGritDir(tree);
+    const source = tree.read(filePath).toString();
+    // The underlying binding lookup requires the `$` sigil.
+    const name = variableName.startsWith('$') ? variableName : `$${variableName}`;
+    let captured;
+    try {
+        const query = new QueryBuilder(pattern);
+        query.filter((node)=>{
+            captured ??= node.var(name) ?? undefined;
+            return true;
+        });
+        await query.applyToFile({
+            path: filePath,
+            content: source
+        });
+    } catch  {
         return undefined;
     }
     return captured;
 };
-exports.captureGritQL = captureGritQL;
+/**
+ * Return the text of every node matching the GritQL pattern, in document order.
+ */ export const captureAllGritQL = async (tree, filePath, pattern)=>{
+    if (!tree.exists(filePath)) return [];
+    ensureGritDir(tree);
+    const source = tree.read(filePath).toString();
+    const captured = [];
+    try {
+        const query = new QueryBuilder(pattern);
+        query.filter((node)=>{
+            captured.push(node.text());
+            return true;
+        });
+        await query.applyToFile({
+            path: filePath,
+            content: source
+        });
+    } catch  {
+        return [];
+    }
+    return captured;
+};
 /**
  * A unique token that is a valid identifier, so it can stand in for an array
  * element or object property inside a GritQL rewrite.
- */
-exports.GRIT_INSERT_PLACEHOLDER = '__GRIT_INSERT_PLACEHOLDER__';
+ */ export const GRIT_INSERT_PLACEHOLDER = '__GRIT_INSERT_PLACEHOLDER__';
 /**
  * Apply a GritQL rewrite that inserts {@link GRIT_INSERT_PLACEHOLDER}, then
  * replace the placeholder with `text`. Routing user-provided text through a
@@ -249,17 +290,15 @@ exports.GRIT_INSERT_PLACEHOLDER = '__GRIT_INSERT_PLACEHOLDER__';
  *
  * The caller formats afterwards. Returns true if the pattern matched and the
  * file changed.
- */
-const insertViaGritQL = async (tree, filePath, pattern, text) => {
-    if (!(await (0, exports.applyGritQL)(tree, filePath, pattern)))
-        return false;
+ */ export const insertViaGritQL = async (tree, filePath, pattern, text)=>{
+    if (!await applyGritQL(tree, filePath, pattern)) return false;
     const content = tree.read(filePath).toString();
-    const at = content.indexOf(exports.GRIT_INSERT_PLACEHOLDER);
+    const at = content.indexOf(GRIT_INSERT_PLACEHOLDER);
     const lineSoFar = content.slice(content.lastIndexOf('\n', at) + 1, at);
     const replacement = lineSoFar.includes('//') ? `\n${text}` : text;
     // Function replacer so `$` in `text` isn't treated as a replacement pattern.
-    tree.write(filePath, content.replace(exports.GRIT_INSERT_PLACEHOLDER, () => replacement));
+    tree.write(filePath, content.replace(GRIT_INSERT_PLACEHOLDER, ()=>replacement));
     return true;
 };
-exports.insertViaGritQL = insertViaGritQL;
+
 //# sourceMappingURL=ast.js.map