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

package/src/connection/generator.js

@@ -1,192 +1,169 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.determineProjectType = exports.resolveConnection = exports.findComponentInMetadata = exports.connectionGenerator = exports.PROJECT_COMPONENT_SENTINEL = void 0;
-const tslib_1 = require("tslib");
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
- */
-const devkit_1 = require("@nx/devkit");
-const generator_1 = tslib_1.__importDefault(require("../py/agent/a2a-connection/generator"));
-const generator_2 = tslib_1.__importDefault(require("../py/agent/mcp-connection/generator"));
-const generator_3 = tslib_1.__importDefault(require("../py/agent/react-connection/generator"));
-const generator_4 = tslib_1.__importDefault(require("../py/fast-api/react/generator"));
-const generator_5 = require("../smithy/project/generator");
-const generator_6 = tslib_1.__importDefault(require("../smithy/react-connection/generator"));
-const generator_7 = require("../smithy/ts/api/generator");
-const generator_8 = tslib_1.__importDefault(require("../trpc/react/generator"));
-const generator_9 = tslib_1.__importDefault(require("../ts/agent/a2a-connection/generator"));
-const generator_10 = tslib_1.__importDefault(require("../ts/agent/mcp-connection/generator"));
-const generator_11 = tslib_1.__importDefault(require("../ts/agent/react-connection/generator"));
-const generator_12 = tslib_1.__importDefault(require("../ts/dynamodb/agent-connection/generator"));
-const generator_13 = require("../ts/dynamodb/generator");
-const generator_14 = tslib_1.__importDefault(require("../ts/dynamodb/mcp-server-connection/generator"));
-const generator_15 = tslib_1.__importDefault(require("../ts/dynamodb/smithy-connection/generator"));
-const generator_16 = tslib_1.__importDefault(require("../ts/dynamodb/trpc-connection/generator"));
-const generator_17 = tslib_1.__importDefault(require("../ts/rdb/agent-connection/generator"));
-const generator_18 = require("../ts/rdb/generator");
-const generator_19 = tslib_1.__importDefault(require("../ts/rdb/mcp-server-connection/generator"));
-const generator_20 = tslib_1.__importDefault(require("../ts/rdb/smithy-connection/generator"));
-const generator_21 = tslib_1.__importDefault(require("../ts/rdb/trpc-connection/generator"));
-const ast_1 = require("../utils/ast");
-const nx_1 = require("../utils/nx");
-const toml_1 = require("../utils/toml");
-/**
- * List of supported source and target project types for connections.
- * These can be project-level types (determined by introspection) or
- * component generator ids (from component metadata).
- */
-const SUPPORTED_PROJECT_TYPES = [
-    'ts#trpc-api',
-    'py#fast-api',
-    'react',
-    'smithy',
-    'ts#rdb',
-    'ts#dynamodb',
-];
+ */ import { joinPathFragments } from "@nx/devkit";
+import agentcoreGatewayAgentConnectionGenerator from "../agentcore-gateway/agent-connection/generator.js";
+import agentcoreGatewayGatewayConnectionGenerator from "../agentcore-gateway/gateway-connection/generator.js";
+import { AGENTCORE_GATEWAY_GENERATOR_INFO } from "../agentcore-gateway/generator.js";
+import agentcoreGatewayMcpConnectionGenerator from "../agentcore-gateway/mcp-connection/generator.js";
+import agentcoreGatewayReactConnectionGenerator from "../agentcore-gateway/react-connection/generator.js";
+import pyAgentA2aConnectionGenerator from "../py/agent/a2a-connection/generator.js";
+import pyAgentGatewayConnectionGenerator from "../py/agent/gateway-connection/generator.js";
+import pyAgentMcpConnectionGenerator from "../py/agent/mcp-connection/generator.js";
+import pyAgentReactConnectionGenerator from "../py/agent/react-connection/generator.js";
+import pyDynamoDBAgentConnectionGenerator from "../py/dynamodb/agent-connection/generator.js";
+import pyDynamoDBFastApiConnectionGenerator from "../py/dynamodb/fast-api-connection/generator.js";
+import { PY_DYNAMODB_GENERATOR_INFO } from "../py/dynamodb/generator.js";
+import pyDynamoDBMcpServerConnectionGenerator from "../py/dynamodb/mcp-server-connection/generator.js";
+import fastApiReactGenerator from "../py/fast-api/react/generator.js";
+import pyRdbAgentConnectionGenerator from "../py/rdb/agent-connection/generator.js";
+import pyRdbFastApiConnectionGenerator from "../py/rdb/fast-api-connection/generator.js";
+import { PY_RDB_GENERATOR_INFO } from "../py/rdb/generator.js";
+import pyRdbMcpServerConnectionGenerator from "../py/rdb/mcp-server-connection/generator.js";
+import { SMITHY_PROJECT_GENERATOR_INFO } from "../smithy/project/generator.js";
+import smithyReactConnectionGenerator from "../smithy/react-connection/generator.js";
+import { TS_SMITHY_API_GENERATOR_INFO } from "../smithy/ts/api/generator.js";
+import trpcReactGenerator from "../trpc/react/generator.js";
+import tsAgentA2aConnectionGenerator from "../ts/agent/a2a-connection/generator.js";
+import tsAgentGatewayConnectionGenerator from "../ts/agent/gateway-connection/generator.js";
+import tsAgentMcpConnectionGenerator from "../ts/agent/mcp-connection/generator.js";
+import tsAgentReactConnectionGenerator from "../ts/agent/react-connection/generator.js";
+import tsDynamoDBAgentConnectionGenerator from "../ts/dynamodb/agent-connection/generator.js";
+import { TS_DYNAMODB_GENERATOR_INFO } from "../ts/dynamodb/generator.js";
+import tsDynamoDBMcpServerConnectionGenerator from "../ts/dynamodb/mcp-server-connection/generator.js";
+import tsDynamoDBSmithyConnectionGenerator from "../ts/dynamodb/smithy-connection/generator.js";
+import tsDynamoDBTrpcConnectionGenerator from "../ts/dynamodb/trpc-connection/generator.js";
+import tsRdbAgentConnectionGenerator from "../ts/rdb/agent-connection/generator.js";
+import { TS_RDB_GENERATOR_INFO } from "../ts/rdb/generator.js";
+import tsRdbMcpServerConnectionGenerator from "../ts/rdb/mcp-server-connection/generator.js";
+import tsRdbSmithyConnectionGenerator from "../ts/rdb/smithy-connection/generator.js";
+import tsRdbTrpcConnectionGenerator from "../ts/rdb/trpc-connection/generator.js";
+import { hasExportDeclaration } from "../utils/ast.js";
+import { readProjectConfigurationUnqualified } from "../utils/nx.js";
+import { readToml } from "../utils/toml.js";
+import { SUPPORTED_CONNECTIONS } from "./supported-connections.js";
 /**
  * Sentinel value for sourceComponent/targetComponent that means
  * "use the project-level connection, not a component".
- */
-exports.PROJECT_COMPONENT_SENTINEL = '.';
-/**
- * Enumerates the supported project connections.
- * Source and target can be project-level types or component generator ids.
- */
-const SUPPORTED_CONNECTIONS = [
-    { source: 'ts#trpc-api', target: 'ts#rdb' },
-    { source: 'ts#trpc-api', target: 'ts#dynamodb' },
-    { source: 'ts#agent', target: 'ts#rdb' },
-    { source: 'smithy', target: 'ts#rdb' },
-    { source: 'smithy', target: 'ts#dynamodb' },
-    { source: 'ts#mcp-server', target: 'ts#rdb' },
-    { source: 'ts#mcp-server', target: 'ts#dynamodb' },
-    { source: 'react', target: 'ts#trpc-api' },
-    { source: 'react', target: 'py#fast-api' },
-    { source: 'react', target: 'smithy' },
-    { source: 'react', target: 'ts#agent' },
-    { source: 'react', target: 'py#agent' },
-    { source: 'ts#agent', target: 'ts#mcp-server' },
-    { source: 'ts#agent', target: 'py#mcp-server' },
-    { source: 'ts#agent', target: 'ts#dynamodb' },
-    { source: 'py#agent', target: 'ts#mcp-server' },
-    { source: 'py#agent', target: 'py#mcp-server' },
-    { source: 'ts#agent', target: 'ts#agent' },
-    { source: 'ts#agent', target: 'py#agent' },
-    { source: 'py#agent', target: 'ts#agent' },
-    { source: 'py#agent', target: 'py#agent' },
-];
+ */ export const PROJECT_COMPONENT_SENTINEL = '.';
 const CONNECTION_GENERATORS = {
-    'ts#trpc-api -> ts#rdb': (tree, options) => (0, generator_21.default)(tree, options),
-    'ts#agent -> ts#rdb': (tree, options) => (0, generator_17.default)(tree, options),
-    'smithy -> ts#rdb': (tree, options) => (0, generator_20.default)(tree, options),
-    'ts#mcp-server -> ts#rdb': (tree, options) => (0, generator_19.default)(tree, options),
-    'ts#trpc-api -> ts#dynamodb': (tree, options) => (0, generator_16.default)(tree, options),
-    'ts#agent -> ts#dynamodb': (tree, options) => (0, generator_12.default)(tree, options),
-    'smithy -> ts#dynamodb': (tree, options) => (0, generator_15.default)(tree, options),
-    'ts#mcp-server -> ts#dynamodb': (tree, options) => (0, generator_14.default)(tree, options),
-    'react -> ts#trpc-api': (tree, options) => (0, generator_8.default)(tree, {
-        frontendProjectName: options.sourceProject,
-        backendProjectName: options.targetProject,
-    }),
-    'react -> py#fast-api': (tree, options) => (0, generator_4.default)(tree, {
-        frontendProjectName: options.sourceProject,
-        fastApiProjectName: options.targetProject,
-    }),
-    'react -> smithy': (tree, options) => (0, generator_6.default)(tree, {
-        frontendProjectName: options.sourceProject,
-        smithyModelOrBackendProjectName: options.targetProject,
-    }),
-    'react -> ts#agent': (tree, options) => (0, generator_11.default)(tree, options),
-    'react -> py#agent': (tree, options) => (0, generator_3.default)(tree, options),
-    'ts#agent -> ts#mcp-server': (tree, options) => (0, generator_10.default)(tree, options),
-    'ts#agent -> py#mcp-server': (tree, options) => (0, generator_10.default)(tree, options),
-    'py#agent -> ts#mcp-server': (tree, options) => (0, generator_2.default)(tree, options),
-    'py#agent -> py#mcp-server': (tree, options) => (0, generator_2.default)(tree, options),
-    'ts#agent -> ts#agent': (tree, options) => (0, generator_9.default)(tree, options),
-    'ts#agent -> py#agent': (tree, options) => (0, generator_9.default)(tree, options),
-    'py#agent -> ts#agent': (tree, options) => (0, generator_1.default)(tree, options),
-    'py#agent -> py#agent': (tree, options) => (0, generator_1.default)(tree, options),
+    'ts#trpc-api -> ts#rdb': (tree, options)=>tsRdbTrpcConnectionGenerator(tree, options),
+    'ts#agent -> ts#rdb': (tree, options)=>tsRdbAgentConnectionGenerator(tree, options),
+    'ts#smithy-api -> ts#rdb': (tree, options)=>tsRdbSmithyConnectionGenerator(tree, options),
+    'ts#mcp-server -> ts#rdb': (tree, options)=>tsRdbMcpServerConnectionGenerator(tree, options),
+    'ts#trpc-api -> ts#dynamodb': (tree, options)=>tsDynamoDBTrpcConnectionGenerator(tree, options),
+    'ts#agent -> ts#dynamodb': (tree, options)=>tsDynamoDBAgentConnectionGenerator(tree, options),
+    'ts#smithy-api -> ts#dynamodb': (tree, options)=>tsDynamoDBSmithyConnectionGenerator(tree, options),
+    'ts#mcp-server -> ts#dynamodb': (tree, options)=>tsDynamoDBMcpServerConnectionGenerator(tree, options),
+    'ts#react-website -> ts#trpc-api': (tree, options)=>trpcReactGenerator(tree, {
+            frontendProjectName: options.sourceProject,
+            backendProjectName: options.targetProject,
+            preferInstallDependencies: options.preferInstallDependencies
+        }),
+    'ts#react-website -> py#fast-api': (tree, options)=>fastApiReactGenerator(tree, {
+            frontendProjectName: options.sourceProject,
+            fastApiProjectName: options.targetProject,
+            preferInstallDependencies: options.preferInstallDependencies
+        }),
+    'ts#react-website -> ts#smithy-api': (tree, options)=>smithyReactConnectionGenerator(tree, {
+            frontendProjectName: options.sourceProject,
+            smithyModelOrBackendProjectName: options.targetProject,
+            preferInstallDependencies: options.preferInstallDependencies
+        }),
+    'ts#react-website -> ts#agent': (tree, options)=>tsAgentReactConnectionGenerator(tree, options),
+    'ts#react-website -> py#agent': (tree, options)=>pyAgentReactConnectionGenerator(tree, options),
+    'ts#agent -> ts#mcp-server': (tree, options)=>tsAgentMcpConnectionGenerator(tree, options),
+    'ts#agent -> py#mcp-server': (tree, options)=>tsAgentMcpConnectionGenerator(tree, options),
+    'py#agent -> ts#mcp-server': (tree, options)=>pyAgentMcpConnectionGenerator(tree, options),
+    'py#agent -> py#mcp-server': (tree, options)=>pyAgentMcpConnectionGenerator(tree, options),
+    'ts#agent -> ts#agent': (tree, options)=>tsAgentA2aConnectionGenerator(tree, options),
+    'ts#agent -> py#agent': (tree, options)=>tsAgentA2aConnectionGenerator(tree, options),
+    'py#agent -> ts#agent': (tree, options)=>pyAgentA2aConnectionGenerator(tree, options),
+    'py#agent -> py#agent': (tree, options)=>pyAgentA2aConnectionGenerator(tree, options),
+    'ts#agent -> agentcore-gateway': (tree, options)=>tsAgentGatewayConnectionGenerator(tree, options),
+    'py#agent -> agentcore-gateway': (tree, options)=>pyAgentGatewayConnectionGenerator(tree, options),
+    'ts#react-website -> agentcore-gateway': (tree, options)=>agentcoreGatewayReactConnectionGenerator(tree, options),
+    'agentcore-gateway -> ts#agent': (tree, options)=>agentcoreGatewayAgentConnectionGenerator(tree, options),
+    'agentcore-gateway -> py#agent': (tree, options)=>agentcoreGatewayAgentConnectionGenerator(tree, options),
+    'agentcore-gateway -> ts#mcp-server': (tree, options)=>agentcoreGatewayMcpConnectionGenerator(tree, options),
+    'agentcore-gateway -> py#mcp-server': (tree, options)=>agentcoreGatewayMcpConnectionGenerator(tree, options),
+    'agentcore-gateway -> agentcore-gateway': (tree, options)=>agentcoreGatewayGatewayConnectionGenerator(tree, options),
+    'py#fast-api -> py#dynamodb': (tree, options)=>pyDynamoDBFastApiConnectionGenerator(tree, options),
+    'py#agent -> py#dynamodb': (tree, options)=>pyDynamoDBAgentConnectionGenerator(tree, options),
+    'py#mcp-server -> py#dynamodb': (tree, options)=>pyDynamoDBMcpServerConnectionGenerator(tree, options),
+    'py#fast-api -> py#rdb': (tree, options)=>pyRdbFastApiConnectionGenerator(tree, options),
+    'py#agent -> py#rdb': (tree, options)=>pyRdbAgentConnectionGenerator(tree, options),
+    'py#mcp-server -> py#rdb': (tree, options)=>pyRdbMcpServerConnectionGenerator(tree, options)
 };
 /**
  * Generator for a connection between two projects
- */
-const connectionGenerator = async (tree, options) => {
-    const resolved = await (0, exports.resolveConnection)(tree, options);
+ */ export const connectionGenerator = async (tree, options)=>{
+    const resolved = await resolveConnection(tree, options);
     const connectionKey = `${resolved.connection.source} -> ${resolved.connection.target}`;
     return await CONNECTION_GENERATORS[connectionKey](tree, {
         sourceProject: options.sourceProject,
         targetProject: options.targetProject,
         sourceComponent: resolved.sourceComponent,
         targetComponent: resolved.targetComponent,
+        preferInstallDependencies: options.preferInstallDependencies
     });
 };
-exports.connectionGenerator = connectionGenerator;
 /**
  * Find a component in project metadata matching the given reference.
  * Checks by name first, then by path, then by generator.
- */
-const findComponentInMetadata = (projectConfiguration, componentRef) => {
+ */ export const findComponentInMetadata = (projectConfiguration, componentRef)=>{
     const components = projectConfiguration.metadata?.components ?? [];
-    return (components.find((c) => c.name === componentRef) ??
-        components.find((c) => c.path === componentRef) ??
-        components.find((c) => c.generator === componentRef));
+    return components.find((c)=>c.name === componentRef) ?? components.find((c)=>c.path === componentRef) ?? components.find((c)=>c.generator === componentRef);
 };
-exports.findComponentInMetadata = findComponentInMetadata;
 /**
  * Gather all connection candidates for a project configuration. This includes:
  * - The project-level type (if it's a supported type)
  * - Each component's generator id as a candidate type
- */
-const gatherCandidates = async (tree, projectConfig) => {
+ */ const gatherCandidates = async (tree, projectConfig)=>{
     const type = await determineProjectTypeFromConfig(tree, projectConfig);
     const components = projectConfig.metadata?.components ?? [];
     return [
-        ...(type ? [{ type: type }] : []),
-        ...components.map((component) => ({
-            type: component.generator,
-            component,
-        })),
+        ...type ? [
+            {
+                type: type
+            }
+        ] : [],
+        ...components.map((component)=>({
+                type: component.generator,
+                component
+            }))
     ];
 };
 /**
  * Validate that a specified component exists in the project metadata.
  * Skips validation for undefined refs and the project sentinel '.'.
- */
-const validateComponent = (componentRef, projectConfig, side) => {
-    if (!componentRef || componentRef === exports.PROJECT_COMPONENT_SENTINEL)
-        return;
-    const found = (0, exports.findComponentInMetadata)(projectConfig, componentRef);
+ */ const validateComponent = (componentRef, projectConfig, side)=>{
+    if (!componentRef || componentRef === PROJECT_COMPONENT_SENTINEL) return;
+    const found = findComponentInMetadata(projectConfig, componentRef);
     if (!found) {
         const components = projectConfig.metadata?.components ?? [];
-        throw new Error(`Component '${componentRef}' not found in ${side} project ${projectConfig.name}. ` +
-            `Available components: ${components.length > 0 ? components.map((c) => c.name ?? c.generator).join(', ') : 'none'}`);
+        throw new Error(`Component '${componentRef}' not found in ${side} project ${projectConfig.name}. ` + `Available components: ${components.length > 0 ? components.map((c)=>c.name ?? c.generator).join(', ') : 'none'}`);
     }
 };
 /**
  * Narrow candidates based on the user's specified component reference.
- */
-const filterConnectionCandidatesForComponentReference = (componentRef, projectConfig, candidates, supportedConnections, side) => {
-    if (!componentRef)
-        return candidates;
-    if (componentRef === exports.PROJECT_COMPONENT_SENTINEL) {
-        return candidates.filter((c) => !c.component);
+ */ const filterConnectionCandidatesForComponentReference = (componentRef, projectConfig, candidates, supportedConnections, side)=>{
+    if (!componentRef) return candidates;
+    if (componentRef === PROJECT_COMPONENT_SENTINEL) {
+        return candidates.filter((c)=>!c.component);
     }
-    const component = (0, exports.findComponentInMetadata)(projectConfig, componentRef);
-    if (!component)
-        return candidates;
-    const isConnectionParticipant = supportedConnections.some((c) => c[side] === component.generator);
-    if (!isConnectionParticipant)
-        return candidates;
+    const component = findComponentInMetadata(projectConfig, componentRef);
+    if (!component) return candidates;
+    const isConnectionParticipant = supportedConnections.some((c)=>c[side] === component.generator);
+    if (!isConnectionParticipant) return candidates;
     // Filter to the specific matched component, not all components with the same generator
-    return candidates.filter((c) => c.component === component);
+    return candidates.filter((c)=>c.component === component);
 };
 /**
  * Resolve the connection to use, considering source/target projects and components.
- */
-const resolveConnection = async (tree, options, supportedConnections = SUPPORTED_CONNECTIONS) => {
-    const sourceConfig = (0, nx_1.readProjectConfigurationUnqualified)(tree, options.sourceProject);
-    const targetConfig = (0, nx_1.readProjectConfigurationUnqualified)(tree, options.targetProject);
+ */ export const resolveConnection = async (tree, options, supportedConnections = SUPPORTED_CONNECTIONS)=>{
+    const sourceConfig = readProjectConfigurationUnqualified(tree, options.sourceProject);
+    const targetConfig = readProjectConfigurationUnqualified(tree, options.targetProject);
     // Validate explicitly specified components exist
     validateComponent(options.sourceComponent, sourceConfig, 'source');
     validateComponent(options.targetComponent, targetConfig, 'target');
@@ -195,60 +172,52 @@ const resolveConnection = async (tree, options, supportedConnections = SUPPORTED
     const targetCandidates = filterConnectionCandidatesForComponentReference(options.targetComponent, targetConfig, await gatherCandidates(tree, targetConfig), supportedConnections, 'target');
     // Cross-product candidates and find supported connections
     const matches = [];
-    for (const source of sourceCandidates) {
-        for (const target of targetCandidates) {
-            const match = supportedConnections.find((c) => c.source === source.type && c.target === target.type);
+    for (const source of sourceCandidates){
+        for (const target of targetCandidates){
+            const match = supportedConnections.find((c)=>c.source === source.type && c.target === target.type);
             if (match) {
                 matches.push({
                     connection: match,
                     sourceComponent: source.component,
-                    targetComponent: target.component,
+                    targetComponent: target.component
                 });
             }
         }
     }
     if (matches.length === 0) {
-        const sourceTypes = [...new Set(sourceCandidates.map((c) => c.type))];
-        const targetTypes = [...new Set(targetCandidates.map((c) => c.type))];
+        const sourceTypes = [
+            ...new Set(sourceCandidates.map((c)=>c.type))
+        ];
+        const targetTypes = [
+            ...new Set(targetCandidates.map((c)=>c.type))
+        ];
         throw new Error(`This generator does not support a connection from ${options.sourceProject}${sourceTypes.length > 0 ? ` (${sourceTypes.join(', ')})` : ''} to ${options.targetProject}${targetTypes.length > 0 ? ` (${targetTypes.join(', ')})` : ''}`);
     }
     if (matches.length > 1) {
-        const connectionDescriptions = matches
-            .map((m) => {
+        const connectionDescriptions = matches.map((m)=>{
             const sourceName = m.sourceComponent?.name;
             const targetName = m.targetComponent?.name;
-            const sourceLabel = sourceName
-                ? `${sourceName} (${m.connection.source})`
-                : m.connection.source;
-            const targetLabel = targetName
-                ? `${targetName} (${m.connection.target})`
-                : m.connection.target;
+            const sourceLabel = sourceName ? `${sourceName} (${m.connection.source})` : m.connection.source;
+            const targetLabel = targetName ? `${targetName} (${m.connection.target})` : m.connection.target;
             return `${sourceLabel} -> ${targetLabel}`;
-        })
-            .join(', ');
-        throw new Error(`Ambiguous connection from ${options.sourceProject} to ${options.targetProject}. ` +
-            `Multiple supported connections found: ${connectionDescriptions}. ` +
-            `Please specify sourceComponent and/or targetComponent to disambiguate.`);
+        }).join(', ');
+        throw new Error(`Ambiguous connection from ${options.sourceProject} to ${options.targetProject}. ` + `Multiple supported connections found: ${connectionDescriptions}. ` + `Please specify sourceComponent and/or targetComponent to disambiguate.`);
     }
     return {
         connection: matches[0].connection,
         sourceComponent: matches[0].sourceComponent,
-        targetComponent: matches[0].targetComponent,
+        targetComponent: matches[0].targetComponent
     };
 };
-exports.resolveConnection = resolveConnection;
 /**
  * Determine whether the given project is of a known project type
- */
-const determineProjectType = async (tree, projectName) => {
-    const projectConfiguration = (0, nx_1.readProjectConfigurationUnqualified)(tree, projectName);
+ */ export const determineProjectType = async (tree, projectName)=>{
+    const projectConfiguration = readProjectConfigurationUnqualified(tree, projectName);
     return await determineProjectTypeFromConfig(tree, projectConfiguration);
 };
-exports.determineProjectType = determineProjectType;
 /**
  * Determine whether the given project configuration is of a known project type
- */
-const determineProjectTypeFromConfig = async (tree, projectConfiguration) => {
+ */ const determineProjectTypeFromConfig = async (tree, projectConfiguration)=>{
     // NB: if adding new checks, ensure these go from most to least specific
     // eg. react website is more specific than typescript project
     if (await isTrpcApi(tree, projectConfiguration)) {
@@ -258,74 +227,83 @@ const determineProjectTypeFromConfig = async (tree, projectConfiguration) => {
         return 'py#fast-api';
     }
     if (isSmithyApi(tree, projectConfiguration)) {
-        return 'smithy';
+        return 'ts#smithy-api';
     }
     if (isReact(tree, projectConfiguration)) {
-        return 'react';
+        return 'ts#react-website';
     }
     if (isRdb(projectConfiguration)) {
         return 'ts#rdb';
     }
-    if (isDynamoDB(projectConfiguration)) {
+    if (isTsDynamoDB(projectConfiguration)) {
         return 'ts#dynamodb';
     }
+    if (isPyDynamoDB(projectConfiguration)) {
+        return 'py#dynamodb';
+    }
+    if (isPyRdb(projectConfiguration)) {
+        return 'py#rdb';
+    }
+    if (isAgentCoreGateway(projectConfiguration)) {
+        return 'agentcore-gateway';
+    }
     return undefined;
 };
-const sourceRoot = (projectConfiguration) => projectConfiguration.sourceRoot ??
-    (0, devkit_1.joinPathFragments)(projectConfiguration.root, 'src');
-const isTrpcApi = async (tree, projectConfiguration) => {
+const sourceRoot = (projectConfiguration)=>projectConfiguration.sourceRoot ?? joinPathFragments(projectConfiguration.root, 'src');
+const isTrpcApi = async (tree, projectConfiguration)=>{
     // If the project.json says it's a trpc api, there's no need for introspection
     if (projectConfiguration.metadata?.apiType === 'trpc') {
         return true;
     }
     // Find the src/index.ts
-    const indexTs = tree.read((0, devkit_1.joinPathFragments)(sourceRoot(projectConfiguration), 'index.ts'), 'utf-8');
+    const indexTs = tree.read(joinPathFragments(sourceRoot(projectConfiguration), 'index.ts'), 'utf-8');
     if (indexTs === null) {
         return false;
     }
     // If the index file exports an AppRouter, it's a trpc api
-    if (await (0, ast_1.hasExportDeclaration)(tree, indexTs, 'AppRouter')) {
+    if (await hasExportDeclaration(tree, indexTs, 'AppRouter')) {
         return true;
     }
     // If there's a src/router.ts or src/lambdas/router.ts which exports an AppRouter, it's a trpc api
-    const trpcRouter = tree.read((0, devkit_1.joinPathFragments)(sourceRoot(projectConfiguration), 'router.ts'), 'utf-8') ??
-        tree.read((0, devkit_1.joinPathFragments)(sourceRoot(projectConfiguration), 'lambdas', 'router.ts'), 'utf-8');
+    const trpcRouter = tree.read(joinPathFragments(sourceRoot(projectConfiguration), 'router.ts'), 'utf-8') ?? tree.read(joinPathFragments(sourceRoot(projectConfiguration), 'lambdas', 'router.ts'), 'utf-8');
     if (trpcRouter === null) {
         return false;
     }
-    if (await (0, ast_1.hasExportDeclaration)(tree, trpcRouter, 'AppRouter')) {
+    if (await hasExportDeclaration(tree, trpcRouter, 'AppRouter')) {
         return true;
     }
     return false;
 };
-const isReact = (tree, projectConfiguration) => {
+const isReact = (tree, projectConfiguration)=>{
     // if there's a main.tsx, it's a react app
-    return tree.exists((0, devkit_1.joinPathFragments)(sourceRoot(projectConfiguration), 'main.tsx'));
+    return tree.exists(joinPathFragments(sourceRoot(projectConfiguration), 'main.tsx'));
 };
-const isFastApi = (tree, projectConfiguration) => {
+const isFastApi = (tree, projectConfiguration)=>{
     // If the project.json says it's a fast api, there's no need for introspection
     if (projectConfiguration.metadata?.apiType === 'fast-api') {
         return true;
     }
-    const pyProjectPath = (0, devkit_1.joinPathFragments)(projectConfiguration.root, 'pyproject.toml');
+    const pyProjectPath = joinPathFragments(projectConfiguration.root, 'pyproject.toml');
     if (tree.exists(pyProjectPath)) {
-        const pyProject = (0, toml_1.readToml)(tree, pyProjectPath);
+        const pyProject = readToml(tree, pyProjectPath);
         if ((pyProject?.project?.dependencies ?? []).includes('fastapi')) {
             return true;
         }
     }
     return false;
 };
-const isSmithyApi = (_tree, projectConfiguration) => {
+const isSmithyApi = (_tree, projectConfiguration)=>{
     // Support selecting either the smithy model or backend project
     return [
-        generator_5.SMITHY_PROJECT_GENERATOR_INFO.id,
-        generator_7.TS_SMITHY_API_GENERATOR_INFO.id,
+        SMITHY_PROJECT_GENERATOR_INFO.id,
+        TS_SMITHY_API_GENERATOR_INFO.id
     ].includes((projectConfiguration.metadata ?? {}).generator);
 };
-const isRdb = (projectConfiguration) => (projectConfiguration.metadata ?? {}).generator ===
-    generator_18.TS_RDB_GENERATOR_INFO.id;
-const isDynamoDB = (projectConfiguration) => (projectConfiguration.metadata ?? {}).generator ===
-    generator_13.TS_DYNAMODB_GENERATOR_INFO.id;
-exports.default = exports.connectionGenerator;
+const isRdb = (projectConfiguration)=>(projectConfiguration.metadata ?? {}).generator === TS_RDB_GENERATOR_INFO.id;
+const isTsDynamoDB = (projectConfiguration)=>(projectConfiguration.metadata ?? {}).generator === TS_DYNAMODB_GENERATOR_INFO.id;
+const isPyDynamoDB = (projectConfiguration)=>(projectConfiguration.metadata ?? {}).generator === PY_DYNAMODB_GENERATOR_INFO.id;
+const isPyRdb = (projectConfiguration)=>(projectConfiguration.metadata ?? {}).generator === PY_RDB_GENERATOR_INFO.id;
+const isAgentCoreGateway = (projectConfiguration)=>(projectConfiguration.metadata ?? {}).generator === AGENTCORE_GATEWAY_GENERATOR_INFO.id;
+export default connectionGenerator;
+
 //# sourceMappingURL=generator.js.map