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

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

@@ -0,0 +1,899 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackendSynthesizer = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+const client_cognito_identity_provider_1 = require("@aws-sdk/client-cognito-identity-provider");
+const assert_1 = __importDefault(require("assert"));
+const ts_factory_utils_1 = require("../ts_factory_utils");
+const factory = typescript_1.default.factory;
+class BackendSynthesizer {
+    constructor() {
+        this.importDurationFlag = false;
+        this.oAuthFlag = false;
+        this.readWriteAttributeFlag = false;
+        this.supportedIdentityProviderFlag = false;
+    }
+    createPropertyAccessExpression(objectIdentifier, propertyPath) {
+        const parts = propertyPath.split('.');
+        let expression = objectIdentifier;
+        for (let i = 0; i < parts.length; i++) {
+            expression = factory.createPropertyAccessExpression(expression, factory.createIdentifier(parts[i]));
+        }
+        return expression;
+    }
+    createVariableDeclaration(identifierName, propertyPath) {
+        const identifier = factory.createIdentifier(identifierName);
+        const propertyAccessExpression = this.createPropertyAccessExpression(factory.createIdentifier('backend'), propertyPath);
+        return factory.createVariableDeclaration(identifier, undefined, undefined, propertyAccessExpression);
+    }
+    createVariableStatement(variableDeclaration) {
+        return factory.createVariableStatement([], factory.createVariableDeclarationList([variableDeclaration], typescript_1.default.NodeFlags.Const));
+    }
+    createImportStatement(identifiers, backendPackageName) {
+        return factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports(identifiers.map((identifier) => factory.createImportSpecifier(false, undefined, identifier)))), factory.createStringLiteral(backendPackageName));
+    }
+    defineBackendCall(backendFunctionIdentifier, properties) {
+        const backendFunctionArgs = factory.createObjectLiteralExpression(properties, true);
+        return factory.createCallExpression(backendFunctionIdentifier, undefined, [backendFunctionArgs]);
+    }
+    setPropertyValue(objectIdentifier, propertyPath, value) {
+        const propertyAccessExpression = this.createPropertyAccessExpression(objectIdentifier, propertyPath);
+        const overrideValue = this.getOverrideValue(value);
+        return factory.createExpressionStatement(factory.createAssignment(propertyAccessExpression, overrideValue));
+    }
+    getOverrideValue(value) {
+        if (typeof value === 'number') {
+            return factory.createNumericLiteral(value);
+        }
+        else if (typeof value === 'string') {
+            return factory.createStringLiteral(value);
+        }
+        else if (Array.isArray(value) && value.every((item) => typeof item === 'string')) {
+            return factory.createArrayLiteralExpression(value.map((item) => factory.createStringLiteral(item)));
+        }
+        else if (typeof value === 'boolean') {
+            return value ? factory.createTrue() : factory.createFalse();
+        }
+        else if (typeof value === 'object' && value !== null) {
+            const properties = [];
+            for (const [key, val] of Object.entries(value)) {
+                const property = factory.createPropertyAssignment(factory.createIdentifier(key), this.getOverrideValue(val));
+                properties.push(property);
+            }
+            return factory.createObjectLiteralExpression(properties, true);
+        }
+        else if (value === undefined) {
+            return factory.createIdentifier('undefined');
+        }
+        throw new TypeError(`Unrecognized type: ${typeof value}`);
+    }
+    createBooleanPropertyAssignment(identifier, condition) {
+        return factory.createPropertyAssignment(factory.createIdentifier(identifier), condition ? factory.createTrue() : factory.createFalse());
+    }
+    createListPropertyAssignment(identifier, listAttribute) {
+        return factory.createPropertyAssignment(factory.createIdentifier(identifier), factory.createArrayLiteralExpression(listAttribute.map((attribute) => factory.createStringLiteral(attribute))));
+    }
+    createEnumListPropertyAssignment(identifier, enumIdentifier, listAttribute) {
+        return factory.createPropertyAssignment(factory.createIdentifier(identifier), factory.createArrayLiteralExpression(listAttribute.map((attribute) => factory.createPropertyAccessExpression(factory.createIdentifier(enumIdentifier), factory.createIdentifier(attribute))), true));
+    }
+    createNumericPropertyAssignment(identifier, numericLiteral) {
+        return factory.createPropertyAssignment(factory.createIdentifier(identifier), factory.createNumericLiteral(numericLiteral));
+    }
+    createDurationPropertyAssignment(identifier, numericLiteral, durationUnit) {
+        const duration = factory.createCallExpression(factory.createIdentifier(`Duration.${durationUnit}`), undefined, [
+            factory.createNumericLiteral(numericLiteral),
+        ]);
+        return factory.createPropertyAssignment(factory.createIdentifier(identifier), duration);
+    }
+    createStringPropertyAssignment(identifier, stringLiteral) {
+        return factory.createPropertyAssignment(factory.createIdentifier(identifier), factory.createStringLiteral(stringLiteral));
+    }
+    createUserPoolClientAssignment(userPoolClient, imports, createConstant) {
+        const userPoolClientAttributesMap = new Map();
+        userPoolClientAttributesMap.set('ClientSecret', 'generateSecret');
+        userPoolClientAttributesMap.set('ReadAttributes', 'readAttributes');
+        userPoolClientAttributesMap.set('WriteAttributes', 'writeAttributes');
+        userPoolClientAttributesMap.set('RefreshTokenValidity', 'refreshTokenValidity');
+        userPoolClientAttributesMap.set('AccessTokenValidity', 'accessTokenValidity');
+        userPoolClientAttributesMap.set('IdTokenValidity', 'idTokenValidity');
+        userPoolClientAttributesMap.set('RefreshToken', 'refreshToken');
+        userPoolClientAttributesMap.set('AccessToken', 'accessToken');
+        userPoolClientAttributesMap.set('IdToken', 'idToken');
+        userPoolClientAttributesMap.set('AllowedOAuthScopes', 'scopes');
+        userPoolClientAttributesMap.set('CallbackURLs', 'callbackUrls');
+        userPoolClientAttributesMap.set('LogoutURLs', 'logoutUrls');
+        userPoolClientAttributesMap.set('DefaultRedirectURI', 'defaultRedirectUri');
+        userPoolClientAttributesMap.set('AllowedOAuthFlowsUserPoolClient', 'disableOAuth');
+        userPoolClientAttributesMap.set('EnableTokenRevocation', 'enableTokenRevocation');
+        userPoolClientAttributesMap.set('EnablePropagateAdditionalUserContextData', 'enablePropagateAdditionalUserContextData');
+        userPoolClientAttributesMap.set('SupportedIdentityProviders', 'supportedIdentityProviders');
+        userPoolClientAttributesMap.set('AuthSessionValidity', 'authSessionValidity');
+        userPoolClientAttributesMap.set('ExplicitAuthFlows', 'authFlows');
+        userPoolClientAttributesMap.set('AllowedOAuthFlows', 'flows');
+        const addClientCall = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('userPool'), factory.createIdentifier('addClient')), undefined, [factory.createStringLiteral('NativeAppClient'), this.createNestedObjectExpression(userPoolClient, userPoolClientAttributesMap)]);
+        if (this.importDurationFlag) {
+            imports.push(this.createImportStatement([factory.createIdentifier('Duration')], 'aws-cdk-lib'));
+        }
+        if (this.readWriteAttributeFlag || this.oAuthFlag || this.supportedIdentityProviderFlag) {
+            const identifiers = [
+                ...(this.readWriteAttributeFlag ? [factory.createIdentifier('ClientAttributes')] : []),
+                ...(this.oAuthFlag ? [factory.createIdentifier('OAuthScope')] : []),
+                ...(this.supportedIdentityProviderFlag ? [factory.createIdentifier('UserPoolClientIdentityProvider')] : []),
+            ];
+            if (identifiers.length > 0) {
+                imports.push(this.createImportStatement(identifiers, 'aws-cdk-lib/aws-cognito'));
+            }
+        }
+        if (createConstant) {
+            return factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier('userPoolClient'), undefined, undefined, addClientCall)], typescript_1.default.NodeFlags.Const));
+        }
+        else {
+            return factory.createExpressionStatement(addClientCall);
+        }
+    }
+    createPropertyAccessChain(identifiers) {
+        return identifiers
+            .slice(1)
+            .reduce((acc, curr) => factory.createPropertyAccessExpression(acc, factory.createIdentifier(curr)), factory.createIdentifier(identifiers[0]));
+    }
+    getProviderSetupDeclaration() {
+        const providerSetupResult = 'providerSetupResult';
+        return factory.createVariableStatement(undefined, factory.createVariableDeclarationList([
+            factory.createVariableDeclaration(factory.createIdentifier(providerSetupResult), undefined, undefined, factory.createPropertyAccessExpression(factory.createParenthesizedExpression(factory.createAsExpression(factory.createCallExpression(factory.createPropertyAccessExpression(this.createPropertyAccessChain(['backend', 'auth', 'stack', 'node', 'children']), factory.createIdentifier('find')), undefined, [
+                factory.createArrowFunction(undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, factory.createIdentifier('child'))], undefined, factory.createToken(typescript_1.default.SyntaxKind.EqualsGreaterThanToken), factory.createBinaryExpression(this.createPropertyAccessChain(['child', 'node', 'id']), factory.createToken(typescript_1.default.SyntaxKind.EqualsEqualsEqualsToken), factory.createStringLiteral('amplifyAuth'))),
+            ]), factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.AnyKeyword))), factory.createIdentifier(providerSetupResult))),
+        ], typescript_1.default.NodeFlags.Const));
+    }
+    getProviderSetupForeachStatement() {
+        const providerSetupResult = 'providerSetupResult';
+        return factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('Object'), factory.createIdentifier('keys')), undefined, [factory.createIdentifier(providerSetupResult)]), factory.createIdentifier('forEach')), undefined, [
+            factory.createArrowFunction(undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, factory.createIdentifier('provider'))], undefined, factory.createToken(typescript_1.default.SyntaxKind.EqualsGreaterThanToken), factory.createBlock([
+                factory.createVariableStatement(undefined, factory.createVariableDeclarationList([
+                    factory.createVariableDeclaration(factory.createIdentifier('providerSetupPropertyValue'), undefined, undefined, factory.createElementAccessExpression(factory.createIdentifier(providerSetupResult), factory.createIdentifier('provider'))),
+                ], typescript_1.default.NodeFlags.Const)),
+                factory.createIfStatement(factory.createLogicalAnd(factory.createPropertyAccessExpression(factory.createIdentifier('providerSetupPropertyValue'), factory.createIdentifier('node')), factory.createCallExpression(factory.createPropertyAccessExpression(factory.createCallExpression(factory.createPropertyAccessExpression(this.createPropertyAccessChain(['providerSetupPropertyValue', 'node', 'id']), factory.createIdentifier('toLowerCase')), undefined, []), factory.createIdentifier('endsWith')), undefined, [factory.createStringLiteral('idp')])), factory.createBlock([
+                    factory.createExpressionStatement(factory.createCallExpression(this.createPropertyAccessChain(['userPoolClient', 'node', 'addDependency']), undefined, [factory.createIdentifier('providerSetupPropertyValue')])),
+                ], true)),
+            ], true)),
+        ]));
+    }
+    createProviderSetupCode() {
+        const providerSetupDeclaration = this.getProviderSetupDeclaration();
+        const forEachStatement = this.getProviderSetupForeachStatement();
+        return [providerSetupDeclaration, forEachStatement];
+    }
+    createNestedObjectExpression(object, gen2PropertyMap) {
+        const objectLiterals = [];
+        const clientSecretKey = 'ClientSecret';
+        for (const [key, value] of Object.entries(object)) {
+            const mappedProperty = gen2PropertyMap.get(key);
+            if (mappedProperty) {
+                if (typeof value == 'boolean') {
+                    if (key === 'AllowedOAuthFlowsUserPoolClient') {
+                        objectLiterals.push(this.createBooleanPropertyAssignment(mappedProperty, !value));
+                    }
+                    else {
+                        objectLiterals.push(this.createBooleanPropertyAssignment(mappedProperty, value));
+                    }
+                }
+                else if (typeof value == 'string') {
+                    if (!this.oAuthFlag && key == 'DefaultRedirectURI') {
+                        this.oAuthFlag = true;
+                        objectLiterals.push(this.createOAuthObjectExpression(object, gen2PropertyMap));
+                    }
+                    else if (key === clientSecretKey) {
+                        objectLiterals.push(this.createBooleanPropertyAssignment(mappedProperty, true));
+                    }
+                    else if (key != 'DefaultRedirectURI') {
+                        objectLiterals.push(this.createStringPropertyAssignment(mappedProperty, value));
+                    }
+                }
+                else if (typeof value == 'number') {
+                    if (['IdTokenValidity', 'RefreshTokenValidity', 'AccessTokenValidity', 'AuthSessionValidity'].includes(key)) {
+                        this.importDurationFlag = true;
+                        if (key == 'IdTokenValidity') {
+                            let durationUnit = 'hours';
+                            if (object['TokenValidityUnits'] && object['TokenValidityUnits'].IdToken) {
+                                durationUnit = object['TokenValidityUnits'].IdToken;
+                            }
+                            objectLiterals.push(this.createDurationPropertyAssignment(mappedProperty, value, durationUnit));
+                        }
+                        else if (key == 'RefreshTokenValidity') {
+                            let durationUnit = 'days';
+                            if (object['TokenValidityUnits'] && object['TokenValidityUnits'].RefreshToken) {
+                                durationUnit = object['TokenValidityUnits'].RefreshToken;
+                            }
+                            objectLiterals.push(this.createDurationPropertyAssignment(mappedProperty, value, durationUnit));
+                        }
+                        else if (key == 'AccessTokenValidity') {
+                            let durationUnit = 'hours';
+                            if (object['TokenValidityUnits'] && object['TokenValidityUnits'].AccessToken) {
+                                durationUnit = object['TokenValidityUnits'].AccessToken;
+                            }
+                            objectLiterals.push(this.createDurationPropertyAssignment(mappedProperty, value, durationUnit));
+                        }
+                        else if (key == 'AuthSessionValidity') {
+                            objectLiterals.push(this.createDurationPropertyAssignment(mappedProperty, value, 'minutes'));
+                        }
+                    }
+                    else {
+                        objectLiterals.push(this.createNumericPropertyAssignment(mappedProperty, value));
+                    }
+                }
+                else if (Array.isArray(value) && gen2PropertyMap.has(key)) {
+                    if (key == 'ReadAttributes' || key == 'WriteAttributes') {
+                        objectLiterals.push(this.createReadWriteAttributes(mappedProperty, value));
+                    }
+                    else if (key == 'SupportedIdentityProviders') {
+                        this.supportedIdentityProviderFlag = true;
+                        objectLiterals.push(this.createEnumListPropertyAssignment(mappedProperty, 'UserPoolClientIdentityProvider', value.map((provider) => {
+                            if (provider.toUpperCase() == 'LOGINWITHAMAZON') {
+                                return 'AMAZON';
+                            }
+                            else if (provider.toUpperCase() === 'SIGNINWITHAPPLE') {
+                                return 'APPLE';
+                            }
+                            return provider.toUpperCase();
+                        })));
+                    }
+                    else if (!this.oAuthFlag && key == 'AllowedOAuthFlows') {
+                        this.oAuthFlag = true;
+                        objectLiterals.push(this.createOAuthObjectExpression(object, gen2PropertyMap));
+                    }
+                    else if (key == 'ExplicitAuthFlows') {
+                        objectLiterals.push(factory.createPropertyAssignment(factory.createIdentifier(mappedProperty), this.createAuthFlowsObjectExpression(value)));
+                    }
+                    else if (!this.oAuthFlag && key == 'AllowedOAuthScopes') {
+                        this.oAuthFlag = true;
+                        objectLiterals.push(this.createOAuthObjectExpression(object, gen2PropertyMap));
+                    }
+                    else {
+                        if (!this.oAuthFlag && (key == 'CallbackURLs' || key == 'LogoutURLs')) {
+                            this.oAuthFlag = true;
+                            objectLiterals.push(this.createOAuthObjectExpression(object, gen2PropertyMap));
+                        }
+                        else if (key != 'CallbackURLs' && key != 'LogoutURLs' && key != 'AllowedOAuthScopes') {
+                            objectLiterals.push(this.createListPropertyAssignment(mappedProperty, value));
+                        }
+                    }
+                }
+                else if (typeof value == 'object' && value !== null) {
+                    objectLiterals.push(factory.createPropertyAssignment(factory.createIdentifier(key), this.createNestedObjectExpression(value, gen2PropertyMap)));
+                }
+            }
+        }
+        if (object[clientSecretKey] === undefined && gen2PropertyMap.has(clientSecretKey)) {
+            const mappedClientSecretKey = gen2PropertyMap.get(clientSecretKey);
+            (0, assert_1.default)(mappedClientSecretKey);
+            objectLiterals.push(this.createBooleanPropertyAssignment(mappedClientSecretKey, false));
+        }
+        return factory.createObjectLiteralExpression(objectLiterals, true);
+    }
+    createReadWriteAttributes(identifier, attributes) {
+        const standardAttrMap = new Map();
+        standardAttrMap.set('address', 'address');
+        standardAttrMap.set('birthdate', 'birthdate');
+        standardAttrMap.set('email', 'email');
+        standardAttrMap.set('family_name', 'familyName');
+        standardAttrMap.set('gender', 'gender');
+        standardAttrMap.set('given_name', 'givenName');
+        standardAttrMap.set('locale', 'locale');
+        standardAttrMap.set('middle_name', 'middleName');
+        standardAttrMap.set('name', 'fullname');
+        standardAttrMap.set('nickname', 'nickname');
+        standardAttrMap.set('phone_number', 'phoneNumber');
+        standardAttrMap.set('picture', 'profilePicture');
+        standardAttrMap.set('preferred_username', 'preferredUsername');
+        standardAttrMap.set('profile', 'profilePage');
+        standardAttrMap.set('updated_at', 'lastUpdateTime');
+        standardAttrMap.set('website', 'website');
+        standardAttrMap.set('zoneinfo', 'timezone');
+        standardAttrMap.set('email_verified', 'emailVerified');
+        standardAttrMap.set('phone_number_verified', 'phoneNumberVerified');
+        this.readWriteAttributeFlag = true;
+        const standardAttributes = attributes.filter((attribute) => !attribute.startsWith('custom:'));
+        const standardAttributesLiterals = [];
+        standardAttributes.forEach((attribute) => {
+            if (standardAttrMap.has(attribute)) {
+                const mappedAttribute = standardAttrMap.get(attribute);
+                if (mappedAttribute) {
+                    standardAttributesLiterals.push(factory.createPropertyAssignment(factory.createIdentifier(mappedAttribute), factory.createTrue()));
+                }
+            }
+        });
+        let clientAttributes = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('new ClientAttributes()'), factory.createIdentifier('withStandardAttributes')), undefined, [factory.createObjectLiteralExpression(standardAttributesLiterals, true)]);
+        const customAttributes = attributes.filter((attribute) => attribute.startsWith('custom:'));
+        if (customAttributes) {
+            clientAttributes = factory.createCallExpression(factory.createPropertyAccessExpression(clientAttributes, factory.createIdentifier('withCustomAttributes')), undefined, customAttributes.map((attr) => factory.createStringLiteral(attr)));
+        }
+        return factory.createPropertyAssignment(factory.createIdentifier(identifier), clientAttributes);
+    }
+    mapOAuthScopes(scopes) {
+        const scopeMap = new Map();
+        scopeMap.set('phone', 'PHONE');
+        scopeMap.set('email', 'EMAIL');
+        scopeMap.set('openid', 'OPENID');
+        scopeMap.set('profile', 'PROFILE');
+        scopeMap.set('aws.cognito.signin.user.admin', 'COGNITO_ADMIN');
+        const scopesList = [];
+        scopes.forEach((scope) => {
+            if (scopeMap.has(scope)) {
+                const scopeValue = scopeMap.get(scope);
+                if (scopeValue) {
+                    scopesList.push(scopeValue);
+                }
+            }
+        });
+        return scopesList;
+    }
+    createOAuthObjectExpression(object, map) {
+        const oAuthLiterals = [];
+        for (const [key, value] of Object.entries(object)) {
+            if (key == 'AllowedOAuthFlows') {
+                oAuthLiterals.push(factory.createPropertyAssignment(factory.createIdentifier('flows'), this.createOAuthFlowsObjectExpression(value)));
+            }
+            else if (key == 'AllowedOAuthScopes') {
+                oAuthLiterals.push(this.createEnumListPropertyAssignment('scopes', 'OAuthScope', this.mapOAuthScopes(value)));
+            }
+            else if (key == 'CallbackURLs' || key == 'LogoutURLs') {
+                const urlValue = map.get(key);
+                if (urlValue) {
+                    oAuthLiterals.push(this.createListPropertyAssignment(urlValue, value));
+                }
+            }
+            else if (key == 'DefaultRedirectURI') {
+                const redirectUriValue = map.get(key);
+                if (redirectUriValue) {
+                    oAuthLiterals.push(this.createStringPropertyAssignment(redirectUriValue, value));
+                }
+            }
+        }
+        return factory.createPropertyAssignment(factory.createIdentifier('oAuth'), factory.createObjectLiteralExpression(oAuthLiterals, true));
+    }
+    createOAuthFlowsObjectExpression(value) {
+        return factory.createObjectLiteralExpression([
+            this.createBooleanPropertyAssignment('authorizationCodeGrant', value.includes(client_cognito_identity_provider_1.OAuthFlowType.code)),
+            this.createBooleanPropertyAssignment('implicitCodeGrant', value.includes(client_cognito_identity_provider_1.OAuthFlowType.implicit)),
+            this.createBooleanPropertyAssignment('clientCredentials', value.includes(client_cognito_identity_provider_1.OAuthFlowType.client_credentials)),
+        ]);
+    }
+    createAuthFlowsObjectExpression(value) {
+        return factory.createObjectLiteralExpression([
+            this.createBooleanPropertyAssignment('adminUserPassword', value.includes(client_cognito_identity_provider_1.ExplicitAuthFlowsType.ALLOW_ADMIN_USER_PASSWORD_AUTH)),
+            this.createBooleanPropertyAssignment('custom', value.includes(client_cognito_identity_provider_1.ExplicitAuthFlowsType.ALLOW_CUSTOM_AUTH)),
+            this.createBooleanPropertyAssignment('userPassword', value.includes(client_cognito_identity_provider_1.ExplicitAuthFlowsType.ALLOW_USER_PASSWORD_AUTH)),
+            this.createBooleanPropertyAssignment('userSrp', value.includes(client_cognito_identity_provider_1.ExplicitAuthFlowsType.ALLOW_USER_SRP_AUTH)),
+        ]);
+    }
+    createAdditionalAuthProvidersArray(providers) {
+        const providerElements = providers.map((provider) => {
+            const properties = [];
+            properties.push(factory.createPropertyAssignment(factory.createIdentifier('authenticationType'), factory.createStringLiteral(provider.authenticationType)));
+            if (provider.userPoolConfig) {
+                const userPoolConfigProps = [];
+                if (provider.userPoolConfig.appIdClientRegex) {
+                    userPoolConfigProps.push(factory.createPropertyAssignment(factory.createIdentifier('appIdClientRegex'), factory.createStringLiteral(provider.userPoolConfig.appIdClientRegex)));
+                }
+                if (provider.userPoolConfig.awsRegion) {
+                    userPoolConfigProps.push(factory.createPropertyAssignment(factory.createIdentifier('awsRegion'), factory.createPropertyAccessExpression(factory.createIdentifier('backend'), 'auth.resources.userPool.stack.region')));
+                }
+                if (provider.userPoolConfig.userPoolId) {
+                    userPoolConfigProps.push(factory.createPropertyAssignment(factory.createIdentifier('userPoolId'), this.createPropertyAccessExpression(factory.createIdentifier('backend'), 'auth.resources.userPool.userPoolId')));
+                }
+                properties.push(factory.createPropertyAssignment(factory.createIdentifier('userPoolConfig'), factory.createObjectLiteralExpression(userPoolConfigProps, true)));
+            }
+            if (provider.lambdaAuthorizerConfig) {
+                properties.push(factory.createPropertyAssignment(factory.createIdentifier('lambdaAuthorizerConfig'), this.getOverrideValue(provider.lambdaAuthorizerConfig)));
+            }
+            if (provider.openIdConnectConfig) {
+                properties.push(factory.createPropertyAssignment(factory.createIdentifier('openIdConnectConfig'), this.getOverrideValue(provider.openIdConnectConfig)));
+            }
+            return factory.createObjectLiteralExpression(properties, true);
+        });
+        return factory.createArrayLiteralExpression(providerElements, true);
+    }
+    createTemplateLiteralExpression(id1, id2, templateHead, templateSpan, templateTail) {
+        return factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier(id1), factory.createIdentifier(id2)), factory.createTemplateExpression(factory.createTemplateHead(templateHead), [
+            factory.createTemplateSpan(factory.createIdentifier(templateSpan), factory.createTemplateTail(templateTail)),
+        ])));
+    }
+    createAmplifyEnvNameLogic() {
+        const variableDeclaration = factory.createVariableStatement(undefined, factory.createVariableDeclarationList([
+            factory.createVariableDeclaration(factory.createIdentifier('AMPLIFY_GEN_1_ENV_NAME'), undefined, undefined, factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(factory.createIdentifier('process'), factory.createIdentifier('env')), factory.createIdentifier('AMPLIFY_GEN_1_ENV_NAME'))),
+        ], typescript_1.default.NodeFlags.Let));
+        const ifStatement = factory.createIfStatement(factory.createLogicalAnd(factory.createPropertyAccessExpression(factory.createIdentifier('ci'), factory.createIdentifier('isCI')), factory.createLogicalNot(factory.createIdentifier('AMPLIFY_GEN_1_ENV_NAME'))), factory.createBlock([
+            factory.createThrowStatement(factory.createNewExpression(factory.createIdentifier('Error'), undefined, [
+                factory.createStringLiteral('AMPLIFY_GEN_1_ENV_NAME is required in CI environment'),
+            ])),
+        ], true), factory.createIfStatement(factory.createLogicalAnd(factory.createLogicalNot(factory.createPropertyAccessExpression(factory.createIdentifier('ci'), factory.createIdentifier('isCI'))), factory.createLogicalNot(factory.createIdentifier('AMPLIFY_GEN_1_ENV_NAME'))), factory.createBlock([
+            factory.createExpressionStatement(factory.createBinaryExpression(factory.createIdentifier('AMPLIFY_GEN_1_ENV_NAME'), factory.createToken(typescript_1.default.SyntaxKind.EqualsToken), factory.createStringLiteral('sandbox'))),
+        ], true)));
+        return [variableDeclaration, ifStatement];
+    }
+    sanitizeVariableName(name) {
+        return name.replace(/-/g, '_');
+    }
+    render(renderArgs) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9;
+        const authFunctionIdentifier = factory.createIdentifier('auth');
+        const storageFunctionIdentifier = factory.createIdentifier('storage');
+        const dataFunctionIdentifier = factory.createIdentifier('data');
+        const backendFunctionIdentifier = factory.createIdentifier('defineBackend');
+        const imports = [];
+        const errors = [];
+        const defineBackendProperties = [];
+        const nodes = [];
+        const mappedPolicyType = {
+            MinimumLength: 'minimumLength',
+            RequireUppercase: 'requireUppercase',
+            RequireLowercase: 'requireLowercase',
+            RequireNumbers: 'requireNumbers',
+            RequireSymbols: 'requireSymbols',
+            PasswordHistorySize: 'passwordHistorySize',
+            TemporaryPasswordValidityDays: 'temporaryPasswordValidityDays',
+        };
+        if (renderArgs.auth) {
+            imports.push(this.createImportStatement([authFunctionIdentifier], renderArgs.auth.importFrom));
+            const auth = factory.createShorthandPropertyAssignment(authFunctionIdentifier);
+            defineBackendProperties.push(auth);
+        }
+        if (renderArgs.data) {
+            imports.push(this.createImportStatement([dataFunctionIdentifier], renderArgs.data.importFrom));
+            const data = factory.createShorthandPropertyAssignment(dataFunctionIdentifier);
+            defineBackendProperties.push(data);
+        }
+        if (((_a = renderArgs.storage) === null || _a === void 0 ? void 0 : _a.hasS3Bucket) || ((_c = (_b = renderArgs.storage) === null || _b === void 0 ? void 0 : _b.dynamoTables) === null || _c === void 0 ? void 0 : _c.length)) {
+            if (renderArgs.storage.hasS3Bucket) {
+                imports.push(this.createImportStatement([storageFunctionIdentifier], renderArgs.storage.importFrom));
+                const storage = factory.createShorthandPropertyAssignment(storageFunctionIdentifier);
+                defineBackendProperties.push(storage);
+            }
+        }
+        if (renderArgs.function) {
+            const functionNameCategories = renderArgs.function.functionNamesAndCategories;
+            for (const [functionName, category] of functionNameCategories) {
+                const functionProperty = factory.createShorthandPropertyAssignment(factory.createIdentifier(functionName));
+                defineBackendProperties.push(functionProperty);
+                imports.push(this.createImportStatement([factory.createIdentifier(functionName)], `./${category}/${functionName}/resource`));
+            }
+        }
+        if ((_d = renderArgs.data) === null || _d === void 0 ? void 0 : _d.restApis) {
+            const allUniqueFunctions = new Set();
+            renderArgs.data.restApis.forEach((restApi) => {
+                if (restApi.uniqueFunctions) {
+                    restApi.uniqueFunctions.forEach((funcName) => allUniqueFunctions.add(funcName));
+                }
+            });
+            const existingFunctions = ((_e = renderArgs.function) === null || _e === void 0 ? void 0 : _e.functionNamesAndCategories) || new Map();
+            allUniqueFunctions.forEach((funcName) => {
+                if (!existingFunctions.has(funcName)) {
+                    const functionProperty = factory.createShorthandPropertyAssignment(factory.createIdentifier(funcName));
+                    defineBackendProperties.push(functionProperty);
+                    imports.push(this.createImportStatement([factory.createIdentifier(funcName)], `./function/${funcName}/resource`));
+                }
+            });
+        }
+        if ((_g = (_f = renderArgs.storage) === null || _f === void 0 ? void 0 : _f.dynamoTables) === null || _g === void 0 ? void 0 : _g.length) {
+            imports.push(this.createImportStatement([
+                factory.createIdentifier('Table'),
+                factory.createIdentifier('AttributeType'),
+                factory.createIdentifier('BillingMode'),
+                factory.createIdentifier('StreamViewType'),
+            ], 'aws-cdk-lib/aws-dynamodb'));
+            const stackDeclaration = factory.createVariableStatement([], factory.createVariableDeclarationList([
+                factory.createVariableDeclaration('storageStack', undefined, undefined, renderArgs.storage.hasS3Bucket
+                    ? factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(factory.createIdentifier('backend'), factory.createIdentifier('storage')), factory.createIdentifier('stack'))
+                    : factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('backend'), factory.createIdentifier('createStack')), undefined, [factory.createStringLiteral('storage')])),
+            ], typescript_1.default.NodeFlags.Const));
+            nodes.push(stackDeclaration);
+            renderArgs.storage.dynamoTables.forEach((table) => {
+                var _a;
+                const baseTableName = table.tableName.replace(/-[^-]+$/, '');
+                const sanitizedTableName = this.sanitizeVariableName(baseTableName);
+                const tableProps = [
+                    factory.createPropertyAssignment('partitionKey', factory.createObjectLiteralExpression([
+                        factory.createPropertyAssignment('name', factory.createStringLiteral(table.partitionKey.name)),
+                        factory.createPropertyAssignment('type', factory.createPropertyAccessExpression(factory.createIdentifier('AttributeType'), factory.createIdentifier(table.partitionKey.type))),
+                    ])),
+                    factory.createPropertyAssignment('billingMode', factory.createPropertyAccessExpression(factory.createIdentifier('BillingMode'), factory.createIdentifier(table.billingMode || 'PROVISIONED'))),
+                ];
+                if (table.billingMode !== 'PAY_PER_REQUEST') {
+                    tableProps.push(factory.createPropertyAssignment('readCapacity', factory.createNumericLiteral(String(table.readCapacity || 5))));
+                    tableProps.push(factory.createPropertyAssignment('writeCapacity', factory.createNumericLiteral(String(table.writeCapacity || 5))));
+                }
+                if (table.streamEnabled && table.streamViewType) {
+                    tableProps.push(factory.createPropertyAssignment('stream', factory.createPropertyAccessExpression(factory.createIdentifier('StreamViewType'), factory.createIdentifier(table.streamViewType))));
+                }
+                if (table.sortKey) {
+                    tableProps.push(factory.createPropertyAssignment('sortKey', factory.createObjectLiteralExpression([
+                        factory.createPropertyAssignment('name', factory.createStringLiteral(table.sortKey.name)),
+                        factory.createPropertyAssignment('type', factory.createPropertyAccessExpression(factory.createIdentifier('AttributeType'), factory.createIdentifier(table.sortKey.type))),
+                    ])));
+                }
+                if (table.gsis && table.gsis.length > 0) {
+                    const tableDeclaration = factory.createVariableStatement([], factory.createVariableDeclarationList([
+                        factory.createVariableDeclaration(sanitizedTableName, undefined, undefined, factory.createNewExpression(factory.createIdentifier('Table'), undefined, [
+                            factory.createIdentifier('storageStack'),
+                            factory.createStringLiteral(sanitizedTableName),
+                            factory.createObjectLiteralExpression(tableProps),
+                        ])),
+                    ], typescript_1.default.NodeFlags.Const));
+                    nodes.push(tableDeclaration);
+                }
+                else {
+                    const tableCreation = factory.createExpressionStatement(factory.createNewExpression(factory.createIdentifier('Table'), undefined, [
+                        factory.createIdentifier('storageStack'),
+                        factory.createStringLiteral(sanitizedTableName),
+                        factory.createObjectLiteralExpression(tableProps),
+                    ]));
+                    nodes.push(tableCreation);
+                }
+                (_a = table.gsis) === null || _a === void 0 ? void 0 : _a.forEach((gsi) => {
+                    const gsiProps = [
+                        factory.createPropertyAssignment('indexName', factory.createStringLiteral(gsi.indexName)),
+                        factory.createPropertyAssignment('partitionKey', factory.createObjectLiteralExpression([
+                            factory.createPropertyAssignment('name', factory.createStringLiteral(gsi.partitionKey.name)),
+                            factory.createPropertyAssignment('type', factory.createPropertyAccessExpression(factory.createIdentifier('AttributeType'), factory.createIdentifier(gsi.partitionKey.type))),
+                        ])),
+                    ];
+                    if (gsi.sortKey) {
+                        gsiProps.push(factory.createPropertyAssignment('sortKey', factory.createObjectLiteralExpression([
+                            factory.createPropertyAssignment('name', factory.createStringLiteral(gsi.sortKey.name)),
+                            factory.createPropertyAssignment('type', factory.createPropertyAccessExpression(factory.createIdentifier('AttributeType'), factory.createIdentifier(gsi.sortKey.type))),
+                        ])));
+                    }
+                    gsiProps.push(factory.createPropertyAssignment('readCapacity', factory.createNumericLiteral('5')));
+                    gsiProps.push(factory.createPropertyAssignment('writeCapacity', factory.createNumericLiteral('5')));
+                    const gsiCall = factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(sanitizedTableName), factory.createIdentifier('addGlobalSecondaryIndex')), undefined, [factory.createObjectLiteralExpression(gsiProps)]));
+                    nodes.push(gsiCall);
+                });
+            });
+        }
+        imports.push(this.createImportStatement([backendFunctionIdentifier], '@aws-amplify/backend'));
+        if (renderArgs.analytics) {
+            const analyticsFunctionIdentifier = factory.createIdentifier('analytics');
+            imports.push(this.createImportStatement([analyticsFunctionIdentifier], renderArgs.analytics.importFrom));
+        }
+        if (((_h = renderArgs.data) === null || _h === void 0 ? void 0 : _h.restApis) && renderArgs.function) {
+            const functionNameCategories = renderArgs.function.functionNamesAndCategories;
+            const hasRestApis = renderArgs.data.restApis.some((restApi) => functionNameCategories.has(restApi.functionName));
+            if (hasRestApis) {
+                imports.push(this.createImportStatement([factory.createIdentifier('HttpApi'), factory.createIdentifier('HttpMethod'), factory.createIdentifier('CorsHttpMethod')], 'aws-cdk-lib/aws-apigatewayv2'));
+                imports.push(this.createImportStatement([factory.createIdentifier('HttpLambdaIntegration')], 'aws-cdk-lib/aws-apigatewayv2-integrations'));
+                const hasPrivateAuth = renderArgs.data.restApis.some((restApi) => restApi.paths.some((path) => path.authType === 'private'));
+                const hasProtectedAuth = renderArgs.data.restApis.some((restApi) => restApi.paths.some((path) => path.authType === 'protected'));
+                const hasUserPoolGroups = renderArgs.data.restApis.some((restApi) => restApi.paths.some((path) => path.userPoolGroups && path.userPoolGroups.length > 0));
+                const authorizerImports = [];
+                if (hasPrivateAuth) {
+                    authorizerImports.push(factory.createIdentifier('HttpIamAuthorizer'));
+                }
+                if (hasProtectedAuth && renderArgs.auth) {
+                    authorizerImports.push(factory.createIdentifier('HttpUserPoolAuthorizer'));
+                }
+                if (hasUserPoolGroups && renderArgs.auth) {
+                    authorizerImports.push(factory.createIdentifier('HttpUserPoolAuthorizer'));
+                }
+                if (authorizerImports.length > 0) {
+                    imports.push(this.createImportStatement(authorizerImports, 'aws-cdk-lib/aws-apigatewayv2-authorizers'));
+                }
+                imports.push(this.createImportStatement([factory.createIdentifier('Policy'), factory.createIdentifier('PolicyStatement')], 'aws-cdk-lib/aws-iam'));
+                imports.push(this.createImportStatement([factory.createIdentifier('Stack')], 'aws-cdk-lib'));
+            }
+        }
+        if (renderArgs.unsupportedCategories) {
+            const categories = renderArgs.unsupportedCategories;
+            for (const [key, value] of categories) {
+                errors.push(factory.createCallExpression(factory.createIdentifier('throw new Error'), undefined, [
+                    factory.createStringLiteral(`Category ${key} is unsupported, please follow ${value}`),
+                ]));
+            }
+        }
+        const callBackendFn = this.defineBackendCall(backendFunctionIdentifier, defineBackendProperties);
+        const backendVariable = factory.createVariableDeclaration('backend', undefined, undefined, callBackendFn);
+        const backendStatement = factory.createVariableStatement([], factory.createVariableDeclarationList([backendVariable], typescript_1.default.NodeFlags.Const));
+        if (renderArgs.analytics) {
+            const analyticsCall = factory.createExpressionStatement(factory.createCallExpression(factory.createIdentifier('analytics'), undefined, [factory.createIdentifier('backend')]));
+            nodes.push(analyticsCall);
+        }
+        if (((_j = renderArgs.auth) === null || _j === void 0 ? void 0 : _j.userPoolOverrides) && !((_k = renderArgs === null || renderArgs === void 0 ? void 0 : renderArgs.auth) === null || _k === void 0 ? void 0 : _k.referenceAuth)) {
+            const cfnUserPoolVariableStatement = this.createVariableStatement(this.createVariableDeclaration('cfnUserPool', 'auth.resources.cfnResources.cfnUserPool'));
+            nodes.push(cfnUserPoolVariableStatement);
+            const policies = {
+                passwordPolicy: {},
+            };
+            for (const [overridePath, value] of Object.entries(renderArgs.auth.userPoolOverrides)) {
+                if (overridePath.includes('PasswordPolicy')) {
+                    const policyKey = overridePath.split('.')[2];
+                    if (value !== undefined && policyKey in mappedPolicyType) {
+                        policies.passwordPolicy[mappedPolicyType[policyKey]] = value;
+                    }
+                }
+                else {
+                    nodes.push(this.setPropertyValue(factory.createIdentifier('cfnUserPool'), overridePath, value));
+                }
+            }
+            nodes.push(this.setPropertyValue(factory.createIdentifier('cfnUserPool'), 'policies', policies));
+        }
+        if (((_l = renderArgs.auth) === null || _l === void 0 ? void 0 : _l.guestLogin) === false && !((_m = renderArgs === null || renderArgs === void 0 ? void 0 : renderArgs.auth) === null || _m === void 0 ? void 0 : _m.referenceAuth)) {
+            const cfnIdentityPoolVariableStatement = this.createVariableStatement(this.createVariableDeclaration('cfnIdentityPool', 'auth.resources.cfnResources.cfnIdentityPool'));
+            nodes.push(cfnIdentityPoolVariableStatement);
+            nodes.push(this.setPropertyValue(factory.createIdentifier('cfnIdentityPool'), 'allowUnauthenticatedIdentities', false));
+        }
+        if ((((_o = renderArgs.auth) === null || _o === void 0 ? void 0 : _o.oAuthFlows) || ((_p = renderArgs.auth) === null || _p === void 0 ? void 0 : _p.readAttributes) || ((_q = renderArgs.auth) === null || _q === void 0 ? void 0 : _q.writeAttributes)) &&
+            !((_r = renderArgs === null || renderArgs === void 0 ? void 0 : renderArgs.auth) === null || _r === void 0 ? void 0 : _r.referenceAuth)) {
+            const cfnUserPoolClientVariableStatement = this.createVariableStatement(this.createVariableDeclaration('cfnUserPoolClient', 'auth.resources.cfnResources.cfnUserPoolClient'));
+            nodes.push(cfnUserPoolClientVariableStatement);
+            if ((_s = renderArgs.auth) === null || _s === void 0 ? void 0 : _s.oAuthFlows) {
+                nodes.push(this.setPropertyValue(factory.createIdentifier('cfnUserPoolClient'), 'allowedOAuthFlows', (_t = renderArgs.auth) === null || _t === void 0 ? void 0 : _t.oAuthFlows));
+            }
+            if ((_u = renderArgs.auth) === null || _u === void 0 ? void 0 : _u.readAttributes) {
+                nodes.push(this.setPropertyValue(factory.createIdentifier('cfnUserPoolClient'), 'readAttributes', (_v = renderArgs.auth) === null || _v === void 0 ? void 0 : _v.readAttributes));
+            }
+        }
+        if (((_w = renderArgs.auth) === null || _w === void 0 ? void 0 : _w.writeAttributes) && !((_x = renderArgs === null || renderArgs === void 0 ? void 0 : renderArgs.auth) === null || _x === void 0 ? void 0 : _x.referenceAuth)) {
+            nodes.push(this.setPropertyValue(factory.createIdentifier('cfnUserPoolClient'), 'writeAttributes', (_y = renderArgs.auth) === null || _y === void 0 ? void 0 : _y.writeAttributes));
+        }
+        if ((_z = renderArgs.auth) === null || _z === void 0 ? void 0 : _z.userPoolClient) {
+            const userPoolVariableStatement = this.createVariableStatement(this.createVariableDeclaration('userPool', 'auth.resources.userPool'));
+            nodes.push(userPoolVariableStatement);
+            const needsUserPoolClientConstant = renderArgs.auth.userPoolClient.SupportedIdentityProviders && renderArgs.auth.userPoolClient.SupportedIdentityProviders.length > 0;
+            nodes.push(this.createUserPoolClientAssignment((_0 = renderArgs.auth) === null || _0 === void 0 ? void 0 : _0.userPoolClient, imports, needsUserPoolClientConstant));
+        }
+        if (renderArgs.storage && renderArgs.storage.hasS3Bucket) {
+            (0, assert_1.default)(renderArgs.storage.bucketName);
+            const cfnStorageVariableStatement = this.createVariableStatement(this.createVariableDeclaration('s3Bucket', 'storage.resources.cfnResources.cfnBucket'));
+            nodes.push(cfnStorageVariableStatement);
+            const bucketNameComment1 = factory.createNotEmittedStatement(factory.createStringLiteral(''));
+            typescript_1.default.addSyntheticLeadingComment(bucketNameComment1, typescript_1.default.SyntaxKind.SingleLineCommentTrivia, ` Use this bucket name post refactor`, true);
+            const bucketNameComment2 = factory.createNotEmittedStatement(factory.createStringLiteral(''));
+            typescript_1.default.addSyntheticLeadingComment(bucketNameComment2, typescript_1.default.SyntaxKind.SingleLineCommentTrivia, ` s3Bucket.bucketName = '${renderArgs.storage.bucketName}';`, true);
+            nodes.push(bucketNameComment1, bucketNameComment2);
+        }
+        if (((_1 = renderArgs.storage) === null || _1 === void 0 ? void 0 : _1.accelerateConfiguration) ||
+            ((_2 = renderArgs.storage) === null || _2 === void 0 ? void 0 : _2.versionConfiguration) ||
+            ((_3 = renderArgs.storage) === null || _3 === void 0 ? void 0 : _3.bucketEncryptionAlgorithm)) {
+            if ((_4 = renderArgs.storage) === null || _4 === void 0 ? void 0 : _4.accelerateConfiguration) {
+                const accelerateConfigAssignment = factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier('s3Bucket'), factory.createIdentifier('accelerateConfiguration')), factory.createObjectLiteralExpression([this.createStringPropertyAssignment('accelerationStatus', renderArgs.storage.accelerateConfiguration)], false)));
+                nodes.push(accelerateConfigAssignment);
+            }
+            if ((_5 = renderArgs.storage) === null || _5 === void 0 ? void 0 : _5.versionConfiguration) {
+                const versionConfigAssignment = factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier('s3Bucket'), factory.createIdentifier('versioningConfiguration')), factory.createObjectLiteralExpression([this.createStringPropertyAssignment('status', renderArgs.storage.versionConfiguration)], false)));
+                nodes.push(versionConfigAssignment);
+            }
+            if ((_6 = renderArgs.storage) === null || _6 === void 0 ? void 0 : _6.bucketEncryptionAlgorithm) {
+                const serverSideEncryptionByDefaultMap = new Map();
+                serverSideEncryptionByDefaultMap.set('SSEAlgorithm', 'sseAlgorithm');
+                serverSideEncryptionByDefaultMap.set('KMSMasterKeyID', 'kmsMasterKeyId');
+                serverSideEncryptionByDefaultMap.set('bucketKeyEnabled', 'bucketKeyEnabled');
+                serverSideEncryptionByDefaultMap.set('serverSideEncryptionByDefault', 'serverSideEncryptionByDefault');
+                const bucketEncryptionAssignment = factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier('s3Bucket'), factory.createIdentifier('bucketEncryption')), factory.createObjectLiteralExpression([
+                    factory.createPropertyAssignment(factory.createIdentifier('serverSideEncryptionConfiguration'), factory.createArrayLiteralExpression([this.createNestedObjectExpression(renderArgs.storage.bucketEncryptionAlgorithm, serverSideEncryptionByDefaultMap)], true)),
+                ], true)));
+                nodes.push(bucketEncryptionAssignment);
+            }
+        }
+        if (((_7 = renderArgs.auth) === null || _7 === void 0 ? void 0 : _7.userPoolClient) &&
+            renderArgs.auth.userPoolClient.SupportedIdentityProviders &&
+            renderArgs.auth.userPoolClient.SupportedIdentityProviders.length > 0) {
+            const idpStatements = this.createProviderSetupCode();
+            nodes.push(...idpStatements);
+            const userPoolDomainRemovalStatementCommented = factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(factory.createIdentifier('// backend.auth.resources.userPool'), factory.createIdentifier('node')), factory.createIdentifier('tryRemoveChild')), undefined, [factory.createStringLiteral('UserPoolDomain')]));
+            nodes.push(userPoolDomainRemovalStatementCommented);
+        }
+        if (((_8 = renderArgs.data) === null || _8 === void 0 ? void 0 : _8.additionalAuthProviders) && renderArgs.auth) {
+            const cfnGraphqlApiVariableStatement = this.createVariableStatement(this.createVariableDeclaration('cfnGraphqlApi', 'data.resources.cfnResources.cfnGraphqlApi'));
+            nodes.push(cfnGraphqlApiVariableStatement);
+            const additionalAuthProviders = this.createAdditionalAuthProvidersArray(renderArgs.data.additionalAuthProviders);
+            nodes.push(factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier('cfnGraphqlApi'), factory.createIdentifier('additionalAuthenticationProviders')), additionalAuthProviders)));
+        }
+        if (renderArgs.function) {
+            const branchNameStatement = factory.createVariableStatement([], factory.createVariableDeclarationList([
+                factory.createVariableDeclaration('branchName', undefined, undefined, factory.createIdentifier('process.env.AWS_BRANCH ?? "sandbox"')),
+            ], typescript_1.default.NodeFlags.Const));
+            nodes.push(branchNameStatement);
+            const functionNameCategories = renderArgs.function.functionNamesAndCategories;
+            for (const [functionName] of functionNameCategories) {
+                nodes.push(factory.createExpressionStatement(factory.createBinaryExpression(factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(factory.createIdentifier('backend'), factory.createIdentifier(functionName)), factory.createIdentifier('resources')), factory.createIdentifier('cfnResources')), factory.createIdentifier('cfnFunction')), factory.createIdentifier('functionName')), factory.createToken(typescript_1.default.SyntaxKind.EqualsToken), factory.createTemplateExpression(factory.createTemplateHead(`${functionName}-`), [
+                    factory.createTemplateSpan(factory.createIdentifier('branchName'), factory.createTemplateTail('')),
+                ]))));
+            }
+        }
+        if (((_9 = renderArgs.data) === null || _9 === void 0 ? void 0 : _9.restApis) && renderArgs.function) {
+            const functionNameCategories = renderArgs.function.functionNamesAndCategories;
+            const validRestApis = renderArgs.data.restApis.filter((restApi) => functionNameCategories.has(restApi.functionName));
+            if (validRestApis.length > 0) {
+                const apiStackStatement = factory.createVariableStatement([], factory.createVariableDeclarationList([
+                    factory.createVariableDeclaration('apiStack', undefined, undefined, factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('backend'), factory.createIdentifier('createStack')), undefined, [factory.createStringLiteral('api-stack')])),
+                ], typescript_1.default.NodeFlags.Const));
+                nodes.push(apiStackStatement);
+                const hasPrivateAuth = validRestApis.some((restApi) => restApi.paths.some((path) => path.authType === 'private'));
+                const hasProtectedAuth = validRestApis.some((restApi) => restApi.paths.some((path) => path.authType === 'protected'));
+                const hasUserPoolGroups = validRestApis.some((restApi) => restApi.paths.some((path) => path.userPoolGroups && path.userPoolGroups.length > 0));
+                if (hasPrivateAuth) {
+                    const iamAuthorizerStatement = factory.createVariableStatement([], factory.createVariableDeclarationList([
+                        factory.createVariableDeclaration('iamAuthorizer', undefined, undefined, factory.createNewExpression(factory.createIdentifier('HttpIamAuthorizer'), undefined, [])),
+                    ], typescript_1.default.NodeFlags.Const));
+                    nodes.push(iamAuthorizerStatement);
+                }
+                if (hasProtectedAuth && renderArgs.auth) {
+                    const userPoolAuthorizerStatement = factory.createVariableStatement([], factory.createVariableDeclarationList([
+                        factory.createVariableDeclaration('userPoolAuthorizer', undefined, undefined, factory.createNewExpression(factory.createIdentifier('HttpUserPoolAuthorizer'), undefined, [
+                            factory.createStringLiteral('userPoolAuth'),
+                            factory.createPropertyAccessExpression(factory.createIdentifier('backend.auth.resources'), factory.createIdentifier('userPool')),
+                            factory.createObjectLiteralExpression([
+                                factory.createPropertyAssignment(factory.createIdentifier('userPoolClients'), factory.createArrayLiteralExpression([
+                                    factory.createPropertyAccessExpression(factory.createIdentifier('backend.auth.resources'), factory.createIdentifier('userPoolClient')),
+                                ])),
+                            ]),
+                        ])),
+                    ], typescript_1.default.NodeFlags.Const));
+                    nodes.push(userPoolAuthorizerStatement);
+                }
+                if (hasUserPoolGroups && renderArgs.auth) {
+                    const allGroups = new Set();
+                    validRestApis.forEach((restApi) => {
+                        restApi.paths.forEach((path) => {
+                            if (path.userPoolGroups) {
+                                path.userPoolGroups.forEach((group) => allGroups.add(group));
+                            }
+                        });
+                    });
+                    allGroups.forEach((groupName) => {
+                        const groupAuthorizerStatement = factory.createVariableStatement([], factory.createVariableDeclarationList([
+                            factory.createVariableDeclaration(`${groupName}Authorizer`, undefined, undefined, factory.createNewExpression(factory.createIdentifier('HttpUserPoolAuthorizer'), undefined, [
+                                factory.createStringLiteral(`${groupName}Auth`),
+                                factory.createPropertyAccessExpression(factory.createIdentifier('backend.auth.resources'), factory.createIdentifier('userPool')),
+                                factory.createObjectLiteralExpression([
+                                    factory.createPropertyAssignment(factory.createIdentifier('userPoolClients'), factory.createArrayLiteralExpression([
+                                        factory.createPropertyAccessExpression(factory.createIdentifier('backend.auth.resources'), factory.createIdentifier('userPoolClient')),
+                                    ])),
+                                    factory.createPropertyAssignment(factory.createIdentifier('identitySource'), factory.createArrayLiteralExpression([factory.createStringLiteral('$request.header.Authorization')])),
+                                ]),
+                            ])),
+                        ], typescript_1.default.NodeFlags.Const));
+                        nodes.push(groupAuthorizerStatement);
+                    });
+                }
+                const httpApiVariables = [];
+                validRestApis.forEach((restApi, index) => {
+                    var _a, _b, _c;
+                    const httpApiVarName = `httpApi${index > 0 ? index + 1 : ''}`;
+                    httpApiVariables.push(httpApiVarName);
+                    const httpApiStatement = factory.createVariableStatement([], factory.createVariableDeclarationList([
+                        factory.createVariableDeclaration(httpApiVarName, undefined, undefined, factory.createNewExpression(factory.createIdentifier('HttpApi'), undefined, [
+                            factory.createIdentifier('apiStack'),
+                            factory.createStringLiteral(`HttpApi${index > 0 ? index + 1 : ''}`),
+                            factory.createObjectLiteralExpression([
+                                factory.createPropertyAssignment(factory.createIdentifier('apiName'), factory.createTemplateExpression(factory.createTemplateHead(`${restApi.apiName}-`), [
+                                    factory.createTemplateSpan(factory.createIdentifier('branchName'), factory.createTemplateTail('')),
+                                ])),
+                                factory.createPropertyAssignment(factory.createIdentifier('createDefaultStage'), factory.createTrue()),
+                                factory.createPropertyAssignment(factory.createIdentifier('corsPreflight'), factory.createObjectLiteralExpression([
+                                    factory.createPropertyAssignment(factory.createIdentifier('allowMethods'), factory.createArrayLiteralExpression((((_a = restApi.corsConfiguration) === null || _a === void 0 ? void 0 : _a.allowMethods) || ['GET', 'POST', 'PUT', 'DELETE']).map((method) => factory.createPropertyAccessExpression(factory.createIdentifier('CorsHttpMethod'), factory.createIdentifier(method.toUpperCase()))))),
+                                    factory.createPropertyAssignment(factory.createIdentifier('allowOrigins'), factory.createArrayLiteralExpression((((_b = restApi.corsConfiguration) === null || _b === void 0 ? void 0 : _b.allowOrigins) || ['*']).map((origin) => factory.createStringLiteral(origin)))),
+                                    factory.createPropertyAssignment(factory.createIdentifier('allowHeaders'), factory.createArrayLiteralExpression((((_c = restApi.corsConfiguration) === null || _c === void 0 ? void 0 : _c.allowHeaders) || ['content-type', 'authorization']).map((header) => factory.createStringLiteral(header)))),
+                                ])),
+                            ]),
+                        ])),
+                    ], typescript_1.default.NodeFlags.Const));
+                    nodes.push(httpApiStatement);
+                    restApi.paths.forEach((pathConfig) => {
+                        const pathFunctionName = pathConfig.lambdaFunction || restApi.functionName;
+                        if (!functionNameCategories.has(pathFunctionName)) {
+                            return;
+                        }
+                        const routeConfig = [
+                            factory.createPropertyAssignment(factory.createIdentifier('path'), factory.createStringLiteral(pathConfig.path)),
+                            factory.createPropertyAssignment(factory.createIdentifier('methods'), factory.createArrayLiteralExpression(pathConfig.methods.map((method) => factory.createPropertyAccessExpression(factory.createIdentifier('HttpMethod'), factory.createIdentifier(method.toUpperCase()))))),
+                            factory.createPropertyAssignment(factory.createIdentifier('integration'), factory.createNewExpression(factory.createIdentifier('HttpLambdaIntegration'), undefined, [
+                                factory.createStringLiteral(`${pathFunctionName}Integration`),
+                                factory.createPropertyAccessExpression(factory.createIdentifier(`backend.${pathFunctionName}.resources`), factory.createIdentifier('lambda')),
+                            ])),
+                        ];
+                        if (pathConfig.userPoolGroups && pathConfig.userPoolGroups.length > 0) {
+                            pathConfig.userPoolGroups.forEach((groupName) => {
+                                const groupRouteConfig = [...routeConfig];
+                                groupRouteConfig.push(factory.createPropertyAssignment(factory.createIdentifier('authorizer'), factory.createIdentifier(`${groupName}Authorizer`)));
+                                const addGroupRouteStatement = factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(httpApiVarName), factory.createIdentifier('addRoutes')), undefined, [factory.createObjectLiteralExpression(groupRouteConfig)]));
+                                nodes.push(addGroupRouteStatement);
+                            });
+                        }
+                        else if (pathConfig.authType === 'private') {
+                            routeConfig.push(factory.createPropertyAssignment(factory.createIdentifier('authorizer'), factory.createIdentifier('iamAuthorizer')));
+                            const addRoutesStatement = factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(httpApiVarName), factory.createIdentifier('addRoutes')), undefined, [factory.createObjectLiteralExpression(routeConfig)]));
+                            nodes.push(addRoutesStatement);
+                        }
+                        else if (pathConfig.authType === 'protected') {
+                            routeConfig.push(factory.createPropertyAssignment(factory.createIdentifier('authorizer'), factory.createIdentifier('userPoolAuthorizer')));
+                            const addRoutesStatement = factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(httpApiVarName), factory.createIdentifier('addRoutes')), undefined, [factory.createObjectLiteralExpression(routeConfig)]));
+                            nodes.push(addRoutesStatement);
+                        }
+                        else {
+                            const addRoutesStatement = factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(httpApiVarName), factory.createIdentifier('addRoutes')), undefined, [factory.createObjectLiteralExpression(routeConfig)]));
+                            nodes.push(addRoutesStatement);
+                        }
+                        const proxyRouteConfig = [
+                            factory.createPropertyAssignment(factory.createIdentifier('path'), factory.createStringLiteral(`${pathConfig.path}/{proxy+}`)),
+                            factory.createPropertyAssignment(factory.createIdentifier('methods'), factory.createArrayLiteralExpression([
+                                factory.createPropertyAccessExpression(factory.createIdentifier('HttpMethod'), factory.createIdentifier('ANY')),
+                            ])),
+                            factory.createPropertyAssignment(factory.createIdentifier('integration'), factory.createNewExpression(factory.createIdentifier('HttpLambdaIntegration'), undefined, [
+                                factory.createStringLiteral(`${pathFunctionName}ProxyIntegration`),
+                                factory.createPropertyAccessExpression(factory.createIdentifier(`backend.${pathFunctionName}.resources`), factory.createIdentifier('lambda')),
+                            ])),
+                        ];
+                        if (pathConfig.userPoolGroups && pathConfig.userPoolGroups.length > 0) {
+                            pathConfig.userPoolGroups.forEach((groupName) => {
+                                const groupProxyRouteConfig = [...proxyRouteConfig];
+                                groupProxyRouteConfig.push(factory.createPropertyAssignment(factory.createIdentifier('authorizer'), factory.createIdentifier(`${groupName}Authorizer`)));
+                                const addGroupProxyRouteStatement = factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(httpApiVarName), factory.createIdentifier('addRoutes')), undefined, [factory.createObjectLiteralExpression(groupProxyRouteConfig)]));
+                                nodes.push(addGroupProxyRouteStatement);
+                            });
+                        }
+                        else if (pathConfig.authType === 'private') {
+                            proxyRouteConfig.push(factory.createPropertyAssignment(factory.createIdentifier('authorizer'), factory.createIdentifier('iamAuthorizer')));
+                            const addProxyRoutesStatement = factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(httpApiVarName), factory.createIdentifier('addRoutes')), undefined, [factory.createObjectLiteralExpression(proxyRouteConfig)]));
+                            nodes.push(addProxyRoutesStatement);
+                        }
+                        else if (pathConfig.authType === 'protected') {
+                            proxyRouteConfig.push(factory.createPropertyAssignment(factory.createIdentifier('authorizer'), factory.createIdentifier('userPoolAuthorizer')));
+                            const addProxyRoutesStatement = factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(httpApiVarName), factory.createIdentifier('addRoutes')), undefined, [factory.createObjectLiteralExpression(proxyRouteConfig)]));
+                            nodes.push(addProxyRoutesStatement);
+                        }
+                        else {
+                            const addProxyRoutesStatement = factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(httpApiVarName), factory.createIdentifier('addRoutes')), undefined, [factory.createObjectLiteralExpression(proxyRouteConfig)]));
+                            nodes.push(addProxyRoutesStatement);
+                        }
+                    });
+                });
+                if (renderArgs.auth) {
+                    const policyResources = httpApiVariables.map((httpApiVar) => factory.createTemplateExpression(factory.createTemplateHead(''), [
+                        factory.createTemplateSpan(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(httpApiVar), factory.createIdentifier('arnForExecuteApi')), undefined, [factory.createStringLiteral('*'), factory.createStringLiteral('/*')]), factory.createTemplateTail('')),
+                    ]));
+                    const apiPolicyStatement = factory.createVariableStatement([], factory.createVariableDeclarationList([
+                        factory.createVariableDeclaration('apiPolicy', undefined, undefined, factory.createNewExpression(factory.createIdentifier('Policy'), undefined, [
+                            factory.createIdentifier('apiStack'),
+                            factory.createStringLiteral('ApiPolicy'),
+                            factory.createObjectLiteralExpression([
+                                factory.createPropertyAssignment(factory.createIdentifier('statements'), factory.createArrayLiteralExpression([
+                                    factory.createNewExpression(factory.createIdentifier('PolicyStatement'), undefined, [
+                                        factory.createObjectLiteralExpression([
+                                            factory.createPropertyAssignment(factory.createIdentifier('actions'), factory.createArrayLiteralExpression([factory.createStringLiteral('execute-api:Invoke')])),
+                                            factory.createPropertyAssignment(factory.createIdentifier('resources'), factory.createArrayLiteralExpression(policyResources)),
+                                        ]),
+                                    ]),
+                                ])),
+                            ]),
+                        ])),
+                    ], typescript_1.default.NodeFlags.Const));
+                    nodes.push(apiPolicyStatement);
+                    const attachAuthenticatedPolicyStatement = factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('backend.auth.resources.authenticatedUserIamRole'), factory.createIdentifier('attachInlinePolicy')), undefined, [factory.createIdentifier('apiPolicy')]));
+                    nodes.push(attachAuthenticatedPolicyStatement);
+                    const attachUnauthenticatedPolicyStatement = factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('backend.auth.resources.unauthenticatedUserIamRole'), factory.createIdentifier('attachInlinePolicy')), undefined, [factory.createIdentifier('apiPolicy')]));
+                    nodes.push(attachUnauthenticatedPolicyStatement);
+                }
+                const apiOutputs = httpApiVariables.map((httpApiVar, index) => {
+                    const restApi = validRestApis[index];
+                    return factory.createPropertyAssignment(factory.createComputedPropertyName(factory.createNonNullExpression(factory.createPropertyAccessExpression(factory.createIdentifier(httpApiVar), factory.createIdentifier('httpApiName')))), factory.createObjectLiteralExpression([
+                        factory.createPropertyAssignment(factory.createIdentifier('endpoint'), factory.createPropertyAccessExpression(factory.createIdentifier(httpApiVar), factory.createIdentifier('url'))),
+                        factory.createPropertyAssignment(factory.createIdentifier('region'), factory.createPropertyAccessExpression(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('Stack'), factory.createIdentifier('of')), undefined, [factory.createIdentifier(httpApiVar)]), factory.createIdentifier('region'))),
+                    ]));
+                });
+                const addOutputStatement = factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('backend'), factory.createIdentifier('addOutput')), undefined, [
+                    factory.createObjectLiteralExpression([
+                        factory.createPropertyAssignment(factory.createIdentifier('api'), factory.createObjectLiteralExpression([
+                            factory.createPropertyAssignment(factory.createIdentifier('REST'), factory.createObjectLiteralExpression(apiOutputs)),
+                        ])),
+                    ]),
+                ]));
+                nodes.push(addOutputStatement);
+            }
+        }
+        return factory.createNodeArray([...imports, ts_factory_utils_1.newLineIdentifier, ...errors, ts_factory_utils_1.newLineIdentifier, backendStatement, ...nodes], true);
+    }
+}
+exports.BackendSynthesizer = BackendSynthesizer;
+//# sourceMappingURL=synthesizer.js.map