@aws-amplify/cli-internal-gen2-migration-experimental-alpha 0.1.0 → 0.2.0

package/lib/commands/gen2-migration/generate/backend/synthesizer.test.js

@@ -0,0 +1,700 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const synthesizer_1 = require("./synthesizer");
+const ts_node_printer_1 = require("../test_utils/ts_node_printer");
+const typescript_1 = __importDefault(require("typescript"));
+(0, globals_1.describe)('BackendSynthesizer', () => {
+    let synthesizer;
+    beforeEach(() => {
+        synthesizer = new synthesizer_1.BackendSynthesizer();
+    });
+    (0, globals_1.describe)('AppSync API Generation', () => {
+        (0, globals_1.it)('should set awsRegion to a dynamic value from backend', () => {
+            const renderArgs = {
+                data: {
+                    importFrom: './data/resource',
+                    additionalAuthProviders: [
+                        {
+                            authenticationType: 'AMAZON_COGNITO_USER_POOLS',
+                            userPoolConfig: {
+                                awsRegion: 'us-east-1',
+                                userPoolId: 'userpool_1234',
+                            },
+                        },
+                    ],
+                },
+                auth: {
+                    importFrom: './auth/resource',
+                },
+            };
+            const result = synthesizer.render(renderArgs);
+            const source = (0, ts_node_printer_1.printNodeArray)(result);
+            (0, globals_1.expect)(source).toMatchInlineSnapshot(`
+        "import { auth } from "./auth/resource";
+        import { data } from "./data/resource";
+        import { defineBackend } from "@aws-amplify/backend";
+
+
+        const backend = defineBackend({
+            auth,
+            data
+        });
+        const cfnGraphqlApi = backend.data.resources.cfnResources.cfnGraphqlApi;
+        cfnGraphqlApi.additionalAuthenticationProviders = [
+            {
+                authenticationType: "AMAZON_COGNITO_USER_POOLS",
+                userPoolConfig: {
+                    awsRegion: backend.auth.resources.userPool.stack.region,
+                    userPoolId: backend.auth.resources.userPool.userPoolId
+                }
+            }
+        ];
+        "
+      `);
+        });
+    });
+    (0, globals_1.describe)('REST API Generation', () => {
+        (0, globals_1.it)('should generate HttpApi with CORS configuration', () => {
+            const renderArgs = {
+                data: {
+                    importFrom: './data/resource',
+                    restApis: [
+                        {
+                            apiName: 'testapi',
+                            functionName: 'testFunction',
+                            paths: [
+                                {
+                                    path: '/items',
+                                    methods: ['GET', 'POST'],
+                                    authType: 'private',
+                                    lambdaFunction: 'testFunction',
+                                },
+                            ],
+                        },
+                    ],
+                },
+                function: {
+                    importFrom: './function/resource',
+                    functionNamesAndCategories: new Map([['testFunction', 'function']]),
+                },
+            };
+            const result = synthesizer.render(renderArgs);
+            const sourceFile = typescript_1.default.createSourceFile('test.ts', '', typescript_1.default.ScriptTarget.Latest);
+            const printer = typescript_1.default.createPrinter();
+            const output = printer.printList(typescript_1.default.ListFormat.SourceFileStatements, result, sourceFile);
+            (0, globals_1.expect)(output).toContain('CorsHttpMethod');
+            (0, globals_1.expect)(output).toContain('aws-cdk-lib/aws-apigatewayv2');
+            (0, globals_1.expect)(output).toContain('corsPreflight');
+            (0, globals_1.expect)(output).toContain('allowMethods');
+            (0, globals_1.expect)(output).toContain('allowOrigins');
+            (0, globals_1.expect)(output).toContain('allowHeaders');
+            (0, globals_1.expect)(output).toContain('CorsHttpMethod.GET');
+            (0, globals_1.expect)(output).toContain('CorsHttpMethod.POST');
+            (0, globals_1.expect)(output).toContain('CorsHttpMethod.PUT');
+            (0, globals_1.expect)(output).toContain('CorsHttpMethod.DELETE');
+        });
+        (0, globals_1.it)('should map auth types to correct authorizers', () => {
+            const renderArgs = {
+                data: {
+                    importFrom: './data/resource',
+                    restApis: [
+                        {
+                            apiName: 'testapi',
+                            functionName: 'testFunction',
+                            paths: [
+                                {
+                                    path: '/private',
+                                    methods: ['GET'],
+                                    authType: 'private',
+                                    lambdaFunction: 'testFunction',
+                                },
+                                {
+                                    path: '/protected',
+                                    methods: ['POST'],
+                                    authType: 'protected',
+                                    lambdaFunction: 'testFunction',
+                                },
+                                {
+                                    path: '/open',
+                                    methods: ['GET'],
+                                    authType: 'open',
+                                    lambdaFunction: 'testFunction',
+                                },
+                            ],
+                        },
+                    ],
+                },
+                function: {
+                    importFrom: './function/resource',
+                    functionNamesAndCategories: new Map([['testFunction', 'function']]),
+                },
+                auth: {
+                    importFrom: './auth/resource',
+                },
+            };
+            const result = synthesizer.render(renderArgs);
+            const sourceFile = typescript_1.default.createSourceFile('test.ts', '', typescript_1.default.ScriptTarget.Latest);
+            const printer = typescript_1.default.createPrinter();
+            const output = printer.printList(typescript_1.default.ListFormat.SourceFileStatements, result, sourceFile);
+            (0, globals_1.expect)(output).toContain('HttpIamAuthorizer');
+            (0, globals_1.expect)(output).toContain('HttpUserPoolAuthorizer');
+            (0, globals_1.expect)(output).toContain('authorizer: iamAuthorizer');
+            (0, globals_1.expect)(output).toContain('authorizer: userPoolAuthorizer');
+        });
+        (0, globals_1.it)('should generate unique integration names per function', () => {
+            const renderArgs = {
+                data: {
+                    importFrom: './data/resource',
+                    restApis: [
+                        {
+                            apiName: 'testapi',
+                            functionName: 'function1',
+                            paths: [
+                                {
+                                    path: '/items',
+                                    methods: ['GET'],
+                                    authType: 'open',
+                                    lambdaFunction: 'function1',
+                                },
+                                {
+                                    path: '/books',
+                                    methods: ['POST'],
+                                    authType: 'open',
+                                    lambdaFunction: 'function2',
+                                },
+                            ],
+                        },
+                    ],
+                },
+                function: {
+                    importFrom: './function/resource',
+                    functionNamesAndCategories: new Map([
+                        ['function1', 'function'],
+                        ['function2', 'function'],
+                    ]),
+                },
+            };
+            const result = synthesizer.render(renderArgs);
+            const sourceFile = typescript_1.default.createSourceFile('test.ts', '', typescript_1.default.ScriptTarget.Latest);
+            const printer = typescript_1.default.createPrinter();
+            const output = printer.printList(typescript_1.default.ListFormat.SourceFileStatements, result, sourceFile);
+            (0, globals_1.expect)(output).toContain('function1Integration');
+            (0, globals_1.expect)(output).toContain('function2Integration');
+            (0, globals_1.expect)(output).toContain('backend.function1.resources');
+            (0, globals_1.expect)(output).toContain('backend.function2.resources');
+        });
+        (0, globals_1.it)('should respect HTTP methods from path configuration', () => {
+            const renderArgs = {
+                data: {
+                    importFrom: './data/resource',
+                    restApis: [
+                        {
+                            apiName: 'testapi',
+                            functionName: 'testFunction',
+                            paths: [
+                                {
+                                    path: '/items',
+                                    methods: ['GET', 'POST'],
+                                    authType: 'open',
+                                    lambdaFunction: 'testFunction',
+                                },
+                                {
+                                    path: '/books',
+                                    methods: ['PUT', 'DELETE'],
+                                    authType: 'open',
+                                    lambdaFunction: 'testFunction',
+                                },
+                            ],
+                        },
+                    ],
+                },
+                function: {
+                    importFrom: './function/resource',
+                    functionNamesAndCategories: new Map([['testFunction', 'function']]),
+                },
+            };
+            const result = synthesizer.render(renderArgs);
+            const sourceFile = typescript_1.default.createSourceFile('test.ts', '', typescript_1.default.ScriptTarget.Latest);
+            const printer = typescript_1.default.createPrinter();
+            const output = printer.printList(typescript_1.default.ListFormat.SourceFileStatements, result, sourceFile);
+            (0, globals_1.expect)(output).toContain('HttpMethod.GET');
+            (0, globals_1.expect)(output).toContain('HttpMethod.POST');
+            (0, globals_1.expect)(output).toContain('HttpMethod.PUT');
+            (0, globals_1.expect)(output).toContain('HttpMethod.DELETE');
+            (0, globals_1.expect)(output).not.toContain('HttpMethod.PATCH');
+            (0, globals_1.expect)(output).not.toContain('HttpMethod.OPTIONS');
+        });
+        (0, globals_1.it)('should generate IAM policy for all HttpApis', () => {
+            const renderArgs = {
+                data: {
+                    importFrom: './data/resource',
+                    restApis: [
+                        {
+                            apiName: 'testapi',
+                            functionName: 'testFunction',
+                            paths: [
+                                {
+                                    path: '/items',
+                                    methods: ['GET'],
+                                    authType: 'open',
+                                    lambdaFunction: 'testFunction',
+                                },
+                            ],
+                        },
+                    ],
+                },
+                function: {
+                    importFrom: './function/resource',
+                    functionNamesAndCategories: new Map([['testFunction', 'function']]),
+                },
+                auth: {
+                    importFrom: './auth/resource',
+                },
+            };
+            const result = synthesizer.render(renderArgs);
+            const sourceFile = typescript_1.default.createSourceFile('test.ts', '', typescript_1.default.ScriptTarget.Latest);
+            const printer = typescript_1.default.createPrinter();
+            const output = printer.printList(typescript_1.default.ListFormat.SourceFileStatements, result, sourceFile);
+            (0, globals_1.expect)(output).toContain('Policy');
+            (0, globals_1.expect)(output).toContain('PolicyStatement');
+            (0, globals_1.expect)(output).toContain('execute-api:Invoke');
+            (0, globals_1.expect)(output).toContain('arnForExecuteApi');
+            (0, globals_1.expect)(output).toContain('authenticatedUserIamRole');
+            (0, globals_1.expect)(output).toContain('unauthenticatedUserIamRole');
+            (0, globals_1.expect)(output).toContain('attachInlinePolicy');
+        });
+        (0, globals_1.it)('should generate backend output for client configuration', () => {
+            const renderArgs = {
+                data: {
+                    importFrom: './data/resource',
+                    restApis: [
+                        {
+                            apiName: 'testapi',
+                            functionName: 'testFunction',
+                            paths: [
+                                {
+                                    path: '/items',
+                                    methods: ['GET'],
+                                    authType: 'open',
+                                    lambdaFunction: 'testFunction',
+                                },
+                            ],
+                        },
+                    ],
+                },
+                function: {
+                    importFrom: './function/resource',
+                    functionNamesAndCategories: new Map([['testFunction', 'function']]),
+                },
+            };
+            const result = synthesizer.render(renderArgs);
+            const sourceFile = typescript_1.default.createSourceFile('test.ts', '', typescript_1.default.ScriptTarget.Latest);
+            const printer = typescript_1.default.createPrinter();
+            const output = printer.printList(typescript_1.default.ListFormat.SourceFileStatements, result, sourceFile);
+            (0, globals_1.expect)(output).toContain('backend.addOutput');
+            (0, globals_1.expect)(output).toContain('api');
+            (0, globals_1.expect)(output).toContain('REST');
+            (0, globals_1.expect)(output).toContain('endpoint');
+            (0, globals_1.expect)(output).toContain('region');
+        });
+        (0, globals_1.it)('should skip routes for non-existent functions', () => {
+            const renderArgs = {
+                data: {
+                    importFrom: './data/resource',
+                    restApis: [
+                        {
+                            apiName: 'testapi',
+                            functionName: 'existingFunction',
+                            paths: [
+                                {
+                                    path: '/items',
+                                    methods: ['GET'],
+                                    authType: 'open',
+                                    lambdaFunction: 'existingFunction',
+                                },
+                                {
+                                    path: '/missing',
+                                    methods: ['GET'],
+                                    authType: 'open',
+                                    lambdaFunction: 'nonExistentFunction',
+                                },
+                            ],
+                        },
+                    ],
+                },
+                function: {
+                    importFrom: './function/resource',
+                    functionNamesAndCategories: new Map([['existingFunction', 'function']]),
+                },
+            };
+            const result = synthesizer.render(renderArgs);
+            const sourceFile = typescript_1.default.createSourceFile('test.ts', '', typescript_1.default.ScriptTarget.Latest);
+            const printer = typescript_1.default.createPrinter();
+            const output = printer.printList(typescript_1.default.ListFormat.SourceFileStatements, result, sourceFile);
+            (0, globals_1.expect)(output).toContain('/items');
+            (0, globals_1.expect)(output).toContain('existingFunction');
+            (0, globals_1.expect)(output).not.toContain('/missing');
+            (0, globals_1.expect)(output).not.toContain('nonExistentFunction');
+        });
+        (0, globals_1.it)('should respect CORS configuration from Gen1 project', () => {
+            const renderArgs = {
+                data: {
+                    importFrom: './data/resource',
+                    restApis: [
+                        {
+                            apiName: 'testapi',
+                            functionName: 'testFunction',
+                            paths: [
+                                {
+                                    path: '/items',
+                                    methods: ['GET'],
+                                    authType: 'open',
+                                    lambdaFunction: 'testFunction',
+                                },
+                            ],
+                            corsConfiguration: {
+                                allowOrigins: ['https://example.com'],
+                                allowMethods: ['GET', 'POST'],
+                                allowHeaders: ['content-type', 'authorization'],
+                            },
+                        },
+                    ],
+                },
+                function: {
+                    importFrom: './function/resource',
+                    functionNamesAndCategories: new Map([['testFunction', 'function']]),
+                },
+            };
+            const result = synthesizer.render(renderArgs);
+            const sourceFile = typescript_1.default.createSourceFile('test.ts', '', typescript_1.default.ScriptTarget.Latest);
+            const printer = typescript_1.default.createPrinter();
+            const output = printer.printList(typescript_1.default.ListFormat.SourceFileStatements, result, sourceFile);
+            (0, globals_1.expect)(output).toContain('https://example.com');
+            (0, globals_1.expect)(output).toContain('CorsHttpMethod.GET');
+            (0, globals_1.expect)(output).toContain('CorsHttpMethod.POST');
+            (0, globals_1.expect)(output).toContain('content-type');
+            (0, globals_1.expect)(output).toContain('authorization');
+            (0, globals_1.expect)(output).not.toContain('CorsHttpMethod.ANY');
+        });
+        (0, globals_1.it)('should use default CORS configuration when not specified in Gen1', () => {
+            const renderArgs = {
+                data: {
+                    importFrom: './data/resource',
+                    restApis: [
+                        {
+                            apiName: 'testapi',
+                            functionName: 'testFunction',
+                            paths: [
+                                {
+                                    path: '/items',
+                                    methods: ['GET'],
+                                    authType: 'open',
+                                    lambdaFunction: 'testFunction',
+                                },
+                            ],
+                        },
+                    ],
+                },
+                function: {
+                    importFrom: './function/resource',
+                    functionNamesAndCategories: new Map([['testFunction', 'function']]),
+                },
+            };
+            const result = synthesizer.render(renderArgs);
+            const sourceFile = typescript_1.default.createSourceFile('test.ts', '', typescript_1.default.ScriptTarget.Latest);
+            const printer = typescript_1.default.createPrinter();
+            const output = printer.printList(typescript_1.default.ListFormat.SourceFileStatements, result, sourceFile);
+            (0, globals_1.expect)(output).toContain('corsPreflight');
+            (0, globals_1.expect)(output).toContain('CorsHttpMethod.GET');
+            (0, globals_1.expect)(output).toContain('CorsHttpMethod.POST');
+            (0, globals_1.expect)(output).toContain('CorsHttpMethod.PUT');
+            (0, globals_1.expect)(output).toContain('CorsHttpMethod.DELETE');
+            (0, globals_1.expect)(output).toContain('content-type');
+            (0, globals_1.expect)(output).toContain('authorization');
+        });
+    });
+    (0, globals_1.describe)('DynamoDB table generation', () => {
+        (0, globals_1.it)('should generate table with underscores in name', () => {
+            const tableDefinition = {
+                tableName: 'countsTable-dev',
+                partitionKey: { name: 'postId', type: 'STRING' },
+                sortKey: { name: 'metricType', type: 'STRING' },
+                billingMode: 'PROVISIONED',
+                readCapacity: 5,
+                writeCapacity: 5,
+            };
+            const result = synthesizer.render({
+                storage: {
+                    importFrom: './storage/resource',
+                    dynamoTables: [tableDefinition],
+                },
+            });
+            const source = (0, ts_node_printer_1.printNodeArray)(result);
+            (0, globals_1.expect)(source).toMatchInlineSnapshot(`
+        "import { Table, AttributeType, BillingMode, StreamViewType } from "aws-cdk-lib/aws-dynamodb";
+        import { defineBackend } from "@aws-amplify/backend";
+
+
+        const backend = defineBackend({});
+        const storageStack = backend.createStack("storage");
+        new Table(storageStack, "countsTable", { partitionKey: { name: "postId", type: AttributeType.STRING }, billingMode: BillingMode.PROVISIONED, readCapacity: 5, writeCapacity: 5, sortKey: { name: "metricType", type: AttributeType.STRING } });
+        "
+      `);
+        });
+        (0, globals_1.it)('should generate table with partition key and sort key', () => {
+            const tableDefinition = {
+                tableName: 'testTable',
+                partitionKey: { name: 'id', type: 'STRING' },
+                sortKey: { name: 'timestamp', type: 'NUMBER' },
+                billingMode: 'PAY_PER_REQUEST',
+            };
+            const result = synthesizer.render({
+                storage: {
+                    importFrom: './storage/resource',
+                    dynamoTables: [tableDefinition],
+                },
+            });
+            const source = (0, ts_node_printer_1.printNodeArray)(result);
+            (0, globals_1.expect)(source).toMatchInlineSnapshot(`
+        "import { Table, AttributeType, BillingMode, StreamViewType } from "aws-cdk-lib/aws-dynamodb";
+        import { defineBackend } from "@aws-amplify/backend";
+
+
+        const backend = defineBackend({});
+        const storageStack = backend.createStack("storage");
+        new Table(storageStack, "testTable", { partitionKey: { name: "id", type: AttributeType.STRING }, billingMode: BillingMode.PAY_PER_REQUEST, sortKey: { name: "timestamp", type: AttributeType.NUMBER } });
+        "
+      `);
+        });
+        (0, globals_1.it)('should generate table with GSI', () => {
+            const tableDefinition = {
+                tableName: 'testTable',
+                partitionKey: { name: 'id', type: 'STRING' },
+                billingMode: 'PROVISIONED',
+                readCapacity: 5,
+                writeCapacity: 5,
+                gsis: [
+                    {
+                        indexName: 'testIndex',
+                        partitionKey: { name: 'gsiPK', type: 'STRING' },
+                        sortKey: { name: 'gsiSK', type: 'NUMBER' },
+                    },
+                ],
+            };
+            const result = synthesizer.render({
+                storage: {
+                    importFrom: './storage/resource',
+                    dynamoTables: [tableDefinition],
+                },
+            });
+            const source = (0, ts_node_printer_1.printNodeArray)(result);
+            (0, globals_1.expect)(source).toMatchInlineSnapshot(`
+        "import { Table, AttributeType, BillingMode, StreamViewType } from "aws-cdk-lib/aws-dynamodb";
+        import { defineBackend } from "@aws-amplify/backend";
+
+
+        const backend = defineBackend({});
+        const storageStack = backend.createStack("storage");
+        const testTable = new Table(storageStack, "testTable", { partitionKey: { name: "id", type: AttributeType.STRING }, billingMode: BillingMode.PROVISIONED, readCapacity: 5, writeCapacity: 5 });
+        testTable.addGlobalSecondaryIndex({ indexName: "testIndex", partitionKey: { name: "gsiPK", type: AttributeType.STRING }, sortKey: { name: "gsiSK", type: AttributeType.NUMBER }, readCapacity: 5, writeCapacity: 5 });
+        "
+      `);
+        });
+        (0, globals_1.it)('should generate table with stream configuration', () => {
+            const tableDefinition = {
+                tableName: 'streamTable',
+                partitionKey: { name: 'id', type: 'STRING' },
+                billingMode: 'PAY_PER_REQUEST',
+                streamEnabled: true,
+                streamViewType: 'NEW_AND_OLD_IMAGES',
+            };
+            const result = synthesizer.render({
+                storage: {
+                    importFrom: './storage/resource',
+                    dynamoTables: [tableDefinition],
+                },
+            });
+            const source = (0, ts_node_printer_1.printNodeArray)(result);
+            (0, globals_1.expect)(source).toMatchInlineSnapshot(`
+        "import { Table, AttributeType, BillingMode, StreamViewType } from "aws-cdk-lib/aws-dynamodb";
+        import { defineBackend } from "@aws-amplify/backend";
+
+
+        const backend = defineBackend({});
+        const storageStack = backend.createStack("storage");
+        new Table(storageStack, "streamTable", { partitionKey: { name: "id", type: AttributeType.STRING }, billingMode: BillingMode.PAY_PER_REQUEST, stream: StreamViewType.NEW_AND_OLD_IMAGES });
+        "
+      `);
+        });
+        (0, globals_1.it)('should handle multiple tables with different configurations', () => {
+            const tables = [
+                {
+                    tableName: 'table-one',
+                    partitionKey: { name: 'pk1', type: 'STRING' },
+                    billingMode: 'PAY_PER_REQUEST',
+                },
+                {
+                    tableName: 'table-two',
+                    partitionKey: { name: 'pk2', type: 'NUMBER' },
+                    sortKey: { name: 'sk2', type: 'STRING' },
+                    billingMode: 'PROVISIONED',
+                    readCapacity: 10,
+                    writeCapacity: 10,
+                },
+            ];
+            const result = synthesizer.render({
+                storage: {
+                    importFrom: './storage/resource',
+                    dynamoTables: tables,
+                },
+            });
+            const source = (0, ts_node_printer_1.printNodeArray)(result);
+            (0, globals_1.expect)(source).toMatchInlineSnapshot(`
+        "import { Table, AttributeType, BillingMode, StreamViewType } from "aws-cdk-lib/aws-dynamodb";
+        import { defineBackend } from "@aws-amplify/backend";
+
+
+        const backend = defineBackend({});
+        const storageStack = backend.createStack("storage");
+        new Table(storageStack, "table", { partitionKey: { name: "pk1", type: AttributeType.STRING }, billingMode: BillingMode.PAY_PER_REQUEST });
+        new Table(storageStack, "table", { partitionKey: { name: "pk2", type: AttributeType.NUMBER }, billingMode: BillingMode.PROVISIONED, readCapacity: 10, writeCapacity: 10, sortKey: { name: "sk2", type: AttributeType.STRING } });
+        "
+      `);
+        });
+        (0, globals_1.it)('should include required CDK imports for DynamoDB', () => {
+            const tableDefinition = {
+                tableName: 'importTest',
+                partitionKey: { name: 'id', type: 'STRING' },
+                billingMode: 'PAY_PER_REQUEST',
+            };
+            const result = synthesizer.render({
+                storage: {
+                    importFrom: './storage/resource',
+                    dynamoTables: [tableDefinition],
+                },
+            });
+            const source = (0, ts_node_printer_1.printNodeArray)(result);
+            (0, globals_1.expect)(source).toMatchInlineSnapshot(`
+        "import { Table, AttributeType, BillingMode, StreamViewType } from "aws-cdk-lib/aws-dynamodb";
+        import { defineBackend } from "@aws-amplify/backend";
+
+
+        const backend = defineBackend({});
+        const storageStack = backend.createStack("storage");
+        new Table(storageStack, "importTest", { partitionKey: { name: "id", type: AttributeType.STRING }, billingMode: BillingMode.PAY_PER_REQUEST });
+        "
+      `);
+        });
+        (0, globals_1.it)('should create storage stack when no S3 bucket exists', () => {
+            const tableDefinition = {
+                tableName: 'stackTest',
+                partitionKey: { name: 'id', type: 'STRING' },
+                billingMode: 'PAY_PER_REQUEST',
+            };
+            const result = synthesizer.render({
+                storage: {
+                    importFrom: './storage/resource',
+                    dynamoTables: [tableDefinition],
+                },
+            });
+            const source = (0, ts_node_printer_1.printNodeArray)(result);
+            (0, globals_1.expect)(source).toMatchInlineSnapshot(`
+        "import { Table, AttributeType, BillingMode, StreamViewType } from "aws-cdk-lib/aws-dynamodb";
+        import { defineBackend } from "@aws-amplify/backend";
+
+
+        const backend = defineBackend({});
+        const storageStack = backend.createStack("storage");
+        new Table(storageStack, "stackTest", { partitionKey: { name: "id", type: AttributeType.STRING }, billingMode: BillingMode.PAY_PER_REQUEST });
+        "
+      `);
+        });
+        (0, globals_1.it)('should use existing storage stack when S3 bucket exists', () => {
+            const tableDefinition = {
+                tableName: 'stackTest',
+                partitionKey: { name: 'id', type: 'STRING' },
+                billingMode: 'PAY_PER_REQUEST',
+            };
+            const result = synthesizer.render({
+                storage: {
+                    importFrom: './storage/resource',
+                    dynamoTables: [tableDefinition],
+                    hasS3Bucket: 'testBucket',
+                    bucketName: 'testBucket',
+                },
+            });
+            const source = (0, ts_node_printer_1.printNodeArray)(result);
+            (0, globals_1.expect)(source).toMatchInlineSnapshot(`
+        "import { storage } from "./storage/resource";
+        import { Table, AttributeType, BillingMode, StreamViewType } from "aws-cdk-lib/aws-dynamodb";
+        import { defineBackend } from "@aws-amplify/backend";
+
+
+        const backend = defineBackend({
+            storage
+        });
+        const storageStack = backend.storage.stack;
+        new Table(storageStack, "stackTest", { partitionKey: { name: "id", type: AttributeType.STRING }, billingMode: BillingMode.PAY_PER_REQUEST });
+        const s3Bucket = backend.storage.resources.cfnResources.cfnBucket;
+        // Use this bucket name post refactor
+        // s3Bucket.bucketName = 'testBucket';
+        "
+      `);
+        });
+    });
+    (0, globals_1.describe)('Table name transformation', () => {
+        (0, globals_1.it)('should replace multiple hyphens with underscores', () => {
+            const tableDefinition = {
+                tableName: 'my-complex-table-name-dev',
+                partitionKey: { name: 'id', type: 'STRING' },
+                billingMode: 'PAY_PER_REQUEST',
+            };
+            const result = synthesizer.render({
+                storage: {
+                    importFrom: './storage/resource',
+                    dynamoTables: [tableDefinition],
+                },
+            });
+            const source = (0, ts_node_printer_1.printNodeArray)(result);
+            (0, globals_1.expect)(source).toMatchInlineSnapshot(`
+        "import { Table, AttributeType, BillingMode, StreamViewType } from "aws-cdk-lib/aws-dynamodb";
+        import { defineBackend } from "@aws-amplify/backend";
+
+
+        const backend = defineBackend({});
+        const storageStack = backend.createStack("storage");
+        new Table(storageStack, "my_complex_table_name", { partitionKey: { name: "id", type: AttributeType.STRING }, billingMode: BillingMode.PAY_PER_REQUEST });
+        "
+      `);
+        });
+        (0, globals_1.it)('should handle table names without hyphens', () => {
+            const tableDefinition = {
+                tableName: 'simpleTableName',
+                partitionKey: { name: 'id', type: 'STRING' },
+                billingMode: 'PAY_PER_REQUEST',
+            };
+            const result = synthesizer.render({
+                storage: {
+                    importFrom: './storage/resource',
+                    dynamoTables: [tableDefinition],
+                },
+            });
+            const source = (0, ts_node_printer_1.printNodeArray)(result);
+            (0, globals_1.expect)(source).toMatchInlineSnapshot(`
+        "import { Table, AttributeType, BillingMode, StreamViewType } from "aws-cdk-lib/aws-dynamodb";
+        import { defineBackend } from "@aws-amplify/backend";
+
+
+        const backend = defineBackend({});
+        const storageStack = backend.createStack("storage");
+        new Table(storageStack, "simpleTableName", { partitionKey: { name: "id", type: AttributeType.STRING }, billingMode: BillingMode.PAY_PER_REQUEST });
+        "
+      `);
+        });
+    });
+});
+//# sourceMappingURL=synthesizer.test.js.map