@aws-amplify/graphql-model-transformer 2.1.1 → 2.1.3-construct-uses-jsii.0

package/src/resolvers/rds/query.ts

@@ -1,25 +0,0 @@
-import { compoundExpression, list, methodCall, obj, printBlock, qref, ref, set, str } from 'graphql-mapping-template';
-
-export const generateLambdaListRequestTemplate = (tableName: string, operation: string, operationName: string): string => {
-  return printBlock('Invoke RDS Lambda data source')(
-    compoundExpression([
-      set(ref('lambdaInput'), obj({})),
-      set(ref('lambdaInput.args'), obj({})),
-      set(ref('lambdaInput.table'), str(tableName)),
-      set(ref('lambdaInput.operation'), str(operation)),
-      set(ref('lambdaInput.operationName'), str(operationName)),
-      set(ref('lambdaInput.args.metadata'), obj({})),
-      set(ref('lambdaInput.args.metadata.keys'), list([])),
-      qref(
-        methodCall(ref('lambdaInput.args.metadata.keys.addAll'), methodCall(ref('util.defaultIfNull'), ref('ctx.stash.keys'), list([]))),
-      ),
-      set(ref('lambdaInput.args.input'), methodCall(ref('util.defaultIfNull'), ref('ctx.stash.defaultValues'), obj({}))),
-      qref(methodCall(ref('lambdaInput.args.putAll'), methodCall(ref('util.defaultIfNull'), ref('context.arguments'), obj({})))),
-      obj({
-        version: str('2018-05-29'),
-        operation: str('Invoke'),
-        payload: methodCall(ref('util.toJson'), ref('lambdaInput')),
-      }),
-    ]),
-  );
-};

package/src/resolvers/rds/resolver.ts

@@ -1,368 +0,0 @@
-import { CfnMapping, Duration, Fn } from 'aws-cdk-lib';
-import {
-  Expression,
-  compoundExpression,
-  ifElse,
-  list,
-  methodCall,
-  obj,
-  printBlock,
-  qref,
-  ref,
-  set,
-  str,
-  toJson,
-} from 'graphql-mapping-template';
-import { ResourceConstants } from 'graphql-transformer-common';
-import { RDSConnectionSecrets, setResourceName } from '@aws-amplify/graphql-transformer-core';
-import { GraphQLAPIProvider, RDSLayerMapping } from '@aws-amplify/graphql-transformer-interfaces';
-import { Effect, IRole, Policy, PolicyStatement, Role, ServicePrincipal } from 'aws-cdk-lib/aws-iam';
-import { IFunction, LayerVersion, Runtime } from 'aws-cdk-lib/aws-lambda';
-import { Construct } from 'constructs';
-import path from 'path';
-import { VpcConfig } from '@aws-amplify/graphql-transformer-interfaces/src';
-
-/**
- * Define RDS Lambda operations
- */
-export type OPERATIONS = 'CREATE' | 'UPDATE' | 'DELETE' | 'GET' | 'LIST' | 'SYNC';
-
-const OPERATION_KEY = '__operation';
-
-const RDSLayerMappingID = 'RDSLayerResourceMapping';
-// TODO: This is temporary state, we need to modify this to a production layer
-/**
- * Define RDS Lambda Layer region mappings
- * @param scope Construct
- */
-export const setRDSLayerMappings = (scope: Construct, mapping?: RDSLayerMapping): CfnMapping =>
-  new CfnMapping(scope, RDSLayerMappingID, {
-    mapping: getLatestLayers(mapping),
-  });
-
-const getLatestLayers = (latestLayers?: RDSLayerMapping): RDSLayerMapping => {
-  if (latestLayers && Object.keys(latestLayers).length > 0) {
-    return latestLayers;
-  }
-  const defaultLayerMapping = getDefaultLayerMapping();
-  return defaultLayerMapping;
-};
-
-// For beta use account '956468067974', layer name 'AmplifyRDSLayerBeta' and layer version '12' as of 2023-06-20
-// For prod use account '582037449441', layer name 'AmplifyRDSLayer' and layer version '3' as of 2023-06-20
-const getDefaultLayerMapping = (): RDSLayerMapping => ({
-  'ap-northeast-1': {
-    layerRegion: 'arn:aws:lambda:ap-northeast-1:582037449441:layer:AmplifyRDSLayer:5',
-  },
-  'us-east-1': {
-    layerRegion: 'arn:aws:lambda:us-east-1:582037449441:layer:AmplifyRDSLayer:5',
-  },
-  'ap-southeast-1': {
-    layerRegion: 'arn:aws:lambda:ap-southeast-1:582037449441:layer:AmplifyRDSLayer:5',
-  },
-  'eu-west-1': {
-    layerRegion: 'arn:aws:lambda:eu-west-1:582037449441:layer:AmplifyRDSLayer:5',
-  },
-  'us-west-1': {
-    layerRegion: 'arn:aws:lambda:us-west-1:582037449441:layer:AmplifyRDSLayer:5',
-  },
-  'ap-east-1': {
-    layerRegion: 'arn:aws:lambda:ap-east-1:582037449441:layer:AmplifyRDSLayer:5',
-  },
-  'ap-northeast-2': {
-    layerRegion: 'arn:aws:lambda:ap-northeast-2:582037449441:layer:AmplifyRDSLayer:5',
-  },
-  'ap-northeast-3': {
-    layerRegion: 'arn:aws:lambda:ap-northeast-3:582037449441:layer:AmplifyRDSLayer:5',
-  },
-  'ap-south-1': {
-    layerRegion: 'arn:aws:lambda:ap-south-1:582037449441:layer:AmplifyRDSLayer:5',
-  },
-  'ap-southeast-2': {
-    layerRegion: 'arn:aws:lambda:ap-southeast-2:582037449441:layer:AmplifyRDSLayer:5',
-  },
-  'ca-central-1': {
-    layerRegion: 'arn:aws:lambda:ca-central-1:582037449441:layer:AmplifyRDSLayer:5',
-  },
-  'eu-central-1': {
-    layerRegion: 'arn:aws:lambda:eu-central-1:582037449441:layer:AmplifyRDSLayer:5',
-  },
-  'eu-north-1': {
-    layerRegion: 'arn:aws:lambda:eu-north-1:582037449441:layer:AmplifyRDSLayer:5',
-  },
-  'eu-west-2': {
-    layerRegion: 'arn:aws:lambda:eu-west-2:582037449441:layer:AmplifyRDSLayer:5',
-  },
-  'eu-west-3': {
-    layerRegion: 'arn:aws:lambda:eu-west-3:582037449441:layer:AmplifyRDSLayer:5',
-  },
-  'sa-east-1': {
-    layerRegion: 'arn:aws:lambda:sa-east-1:582037449441:layer:AmplifyRDSLayer:5',
-  },
-  'us-east-2': {
-    layerRegion: 'arn:aws:lambda:us-east-2:582037449441:layer:AmplifyRDSLayer:5',
-  },
-  'us-west-2': {
-    layerRegion: 'arn:aws:lambda:us-west-2:582037449441:layer:AmplifyRDSLayer:5',
-  },
-  'cn-north-1': {
-    layerRegion: 'arn:aws:lambda:cn-north-1:582037449441:layer:AmplifyRDSLayer:5',
-  },
-  'cn-northwest-1': {
-    layerRegion: 'arn:aws:lambda:cn-northwest-1:582037449441:layer:AmplifyRDSLayer:5',
-  },
-  'us-gov-west-1': {
-    layerRegion: 'arn:aws:lambda:us-gov-west-1:582037449441:layer:AmplifyRDSLayer:5',
-  },
-  'us-gov-east-1': {
-    layerRegion: 'arn:aws:lambda:us-gov-east-1:582037449441:layer:AmplifyRDSLayer:5',
-  },
-  'me-south-1': {
-    layerRegion: 'arn:aws:lambda:me-south-1:582037449441:layer:AmplifyRDSLayer:5',
-  },
-});
-
-/**
- * Create RDS Lambda function
- * @param scope Construct
- * @param apiGraphql GraphQLAPIProvider
- * @param lambdaRole IRole
- */
-export const createRdsLambda = (
-  scope: Construct,
-  apiGraphql: GraphQLAPIProvider,
-  lambdaRole: IRole,
-  environment?: { [key: string]: string },
-  sqlLambdaVpcConfig?: VpcConfig,
-): IFunction => {
-  const { RDSLambdaLogicalID } = ResourceConstants.RESOURCES;
-  return apiGraphql.host.addLambdaFunction(
-    RDSLambdaLogicalID,
-    `functions/${RDSLambdaLogicalID}.zip`,
-    'handler.run',
-    path.resolve(__dirname, '..', '..', '..', 'lib', 'rds-lambda.zip'),
-    Runtime.NODEJS_18_X,
-    [
-      LayerVersion.fromLayerVersionArn(
-        scope,
-        'SQLLambdaLayerVersion',
-        Fn.findInMap(RDSLayerMappingID, Fn.ref('AWS::Region'), 'layerRegion'),
-      ),
-    ],
-    lambdaRole,
-    environment,
-    Duration.seconds(30),
-    scope,
-    sqlLambdaVpcConfig,
-  );
-};
-
-/**
- * Create RDS Patching Lambda function
- * @param scope Construct
- * @param apiGraphql GraphQLAPIProvider
- * @param lambdaRole IRole
- */
-export const createRdsPatchingLambda = (
-  scope: Construct,
-  apiGraphql: GraphQLAPIProvider,
-  lambdaRole: IRole,
-  environment?: { [key: string]: string },
-  sqlLambdaVpcConfig?: VpcConfig,
-): IFunction => {
-  const { RDSPatchingLambdaLogicalID } = ResourceConstants.RESOURCES;
-  return apiGraphql.host.addLambdaFunction(
-    RDSPatchingLambdaLogicalID,
-    `functions/${RDSPatchingLambdaLogicalID}.zip`,
-    'index.handler',
-    path.resolve(__dirname, '..', '..', '..', 'lib', 'rds-patching-lambda.zip'),
-    Runtime.NODEJS_18_X,
-    [],
-    lambdaRole,
-    environment,
-    Duration.minutes(6), // We have an arbituary wait time of up to 5 minutes in the lambda function to avoid throttling errors
-    scope,
-    sqlLambdaVpcConfig,
-  );
-};
-
-/**
- * Create RDS Lambda IAM role
- * @param roleName string
- * @param scope Construct
- * @param secretEntry RDSConnectionSecrets
- */
-export const createRdsLambdaRole = (roleName: string, scope: Construct, secretEntry: RDSConnectionSecrets): IRole => {
-  const { RDSLambdaIAMRoleLogicalID, RDSLambdaLogAccessPolicy } = ResourceConstants.RESOURCES;
-  const role = new Role(scope, RDSLambdaIAMRoleLogicalID, {
-    assumedBy: new ServicePrincipal('lambda.amazonaws.com'),
-    roleName,
-  });
-  setResourceName(role, { name: RDSLambdaIAMRoleLogicalID, setOnDefaultChild: true });
-  const policyStatements = [
-    new PolicyStatement({
-      actions: ['logs:CreateLogGroup', 'logs:CreateLogStream', 'logs:PutLogEvents'],
-      effect: Effect.ALLOW,
-      resources: ['arn:aws:logs:*:*:*'],
-    }),
-  ];
-  if (secretEntry) {
-    policyStatements.push(
-      new PolicyStatement({
-        actions: ['ssm:GetParameter', 'ssm:GetParameters'],
-        effect: Effect.ALLOW,
-        resources: [
-          `arn:aws:ssm:*:*:parameter${secretEntry.username}`,
-          `arn:aws:ssm:*:*:parameter${secretEntry.password}`,
-          `arn:aws:ssm:*:*:parameter${secretEntry.host}`,
-          `arn:aws:ssm:*:*:parameter${secretEntry.database}`,
-          `arn:aws:ssm:*:*:parameter${secretEntry.port}`,
-        ],
-      }),
-    );
-  }
-
-  role.attachInlinePolicy(
-    new Policy(scope, RDSLambdaLogAccessPolicy, {
-      statements: policyStatements,
-      policyName: `${roleName}Policy`,
-    }),
-  );
-
-  role.addToPolicy(
-    new PolicyStatement({
-      effect: Effect.ALLOW,
-      resources: ['*'],
-      actions: ['ec2:CreateNetworkInterface', 'ec2:DescribeNetworkInterfaces', 'ec2:DeleteNetworkInterface'],
-    }),
-  );
-
-  return role;
-};
-
-/**
- * Create RDS Patching Lambda IAM role
- * @param roleName string
- * @param scope Construct
- * @param functionArn FunctionArn
- */
-export const createRdsPatchingLambdaRole = (roleName: string, scope: Construct, functionArn: string): IRole => {
-  const { RDSPatchingLambdaIAMRoleLogicalID, RDSPatchingLambdaLogAccessPolicy } = ResourceConstants.RESOURCES;
-  const role = new Role(scope, RDSPatchingLambdaIAMRoleLogicalID, {
-    assumedBy: new ServicePrincipal('lambda.amazonaws.com'),
-    roleName,
-  });
-  setResourceName(role, { name: RDSPatchingLambdaIAMRoleLogicalID, setOnDefaultChild: true });
-  const policyStatements = [
-    new PolicyStatement({
-      actions: ['logs:CreateLogGroup', 'logs:CreateLogStream', 'logs:PutLogEvents'],
-      effect: Effect.ALLOW,
-      resources: ['arn:aws:logs:*:*:*'],
-    }),
-    new PolicyStatement({
-      actions: ['lambda:UpdateFunctionConfiguration'],
-      effect: Effect.ALLOW,
-      resources: [functionArn],
-    }),
-    new PolicyStatement({
-      actions: ['lambda:GetLayerVersion', 'lambda:GetLayerVersionPolicy'],
-      effect: Effect.ALLOW,
-      resources: ['*'],
-    }),
-  ];
-
-  role.attachInlinePolicy(
-    new Policy(scope, RDSPatchingLambdaLogAccessPolicy, {
-      statements: policyStatements,
-      policyName: `${roleName}Policy`,
-    }),
-  );
-
-  role.addToPolicy(
-    new PolicyStatement({
-      effect: Effect.ALLOW,
-      resources: ['*'],
-      actions: ['ec2:CreateNetworkInterface', 'ec2:DescribeNetworkInterfaces', 'ec2:DeleteNetworkInterface'],
-    }),
-  );
-
-  return role;
-};
-
-/**
- * Generate RDS Lambda request template
- * @param tableName string
- * @param operation string
- * @param operationName string
- */
-export const generateLambdaRequestTemplate = (tableName: string, operation: string, operationName: string): string =>
-  printBlock('Invoke RDS Lambda data source')(
-    compoundExpression([
-      set(ref('lambdaInput'), obj({})),
-      set(ref('lambdaInput.args'), obj({})),
-      set(ref('lambdaInput.table'), str(tableName)),
-      set(ref('lambdaInput.operation'), str(operation)),
-      set(ref('lambdaInput.operationName'), str(operationName)),
-      set(ref('lambdaInput.args.metadata'), obj({})),
-      set(ref('lambdaInput.args.metadata.keys'), list([])),
-      qref(
-        methodCall(ref('lambdaInput.args.metadata.keys.addAll'), methodCall(ref('util.defaultIfNull'), ref('ctx.stash.keys'), list([]))),
-      ),
-      set(ref('lambdaInput.args.input'), methodCall(ref('util.defaultIfNull'), ref('ctx.stash.defaultValues'), obj({}))),
-      qref(methodCall(ref('lambdaInput.args.input.putAll'), methodCall(ref('util.defaultIfNull'), ref('context.arguments'), obj({})))),
-      obj({
-        version: str('2018-05-29'),
-        operation: str('Invoke'),
-        payload: methodCall(ref('util.toJson'), ref('lambdaInput')),
-      }),
-    ]),
-  );
-
-/**
- * Generate RDS Lambda response template
- * @param isSyncEnabled boolean
- */
-export const generateGetLambdaResponseTemplate = (isSyncEnabled: boolean): string => {
-  const statements: Expression[] = [];
-  if (isSyncEnabled) {
-    statements.push(
-      ifElse(
-        ref('ctx.error'),
-        methodCall(ref('util.error'), ref('ctx.error.message'), ref('ctx.error.type'), ref('ctx.result')),
-        toJson(ref('ctx.result')),
-      ),
-    );
-  } else {
-    statements.push(
-      ifElse(ref('ctx.error'), methodCall(ref('util.error'), ref('ctx.error.message'), ref('ctx.error.type')), toJson(ref('ctx.result'))),
-    );
-  }
-
-  return printBlock('ResponseTemplate')(compoundExpression(statements));
-};
-
-/**
- * Generate common response template used by most of the resolvers.
- * Append operation if response is coming from a mutation, this is to protect field resolver for subscriptions
- * @param isSyncEnabled boolean
- * @param mutation boolean
- */
-export const generateDefaultLambdaResponseMappingTemplate = (isSyncEnabled: boolean, mutation = false): string => {
-  const statements: Expression[] = [];
-  if (mutation) statements.push(qref(methodCall(ref('ctx.result.put'), str(OPERATION_KEY), str('Mutation'))));
-  if (isSyncEnabled) {
-    statements.push(
-      ifElse(
-        ref('ctx.error'),
-        methodCall(ref('util.error'), ref('ctx.error.message'), ref('ctx.error.type'), ref('ctx.result')),
-        toJson(ref('ctx.result')),
-      ),
-    );
-  } else {
-    statements.push(
-      ifElse(ref('ctx.error'), methodCall(ref('util.error'), ref('ctx.error.message'), ref('ctx.error.type')), toJson(ref('ctx.result'))),
-    );
-  }
-
-  return printBlock('ResponseTemplate')(compoundExpression(statements));
-};

package/src/resources/dynamo-model-resource-generator.ts

@@ -1,290 +0,0 @@
-import * as cdk from 'aws-cdk-lib';
-import { TransformerContextProvider } from '@aws-amplify/graphql-transformer-interfaces';
-import { ModelResourceIDs, ResourceConstants, SyncResourceIDs } from 'graphql-transformer-common';
-import { ObjectTypeDefinitionNode } from 'graphql';
-import { SyncUtils, setResourceName } from '@aws-amplify/graphql-transformer-core';
-import { AttributeType, CfnTable, StreamViewType, Table, TableEncryption } from 'aws-cdk-lib/aws-dynamodb';
-import { CfnDataSource } from 'aws-cdk-lib/aws-appsync';
-import * as iam from 'aws-cdk-lib/aws-iam';
-import { CfnRole } from 'aws-cdk-lib/aws-iam';
-import { Construct } from 'constructs';
-import { DynamoDBModelVTLGenerator, ModelVTLGenerator } from '../resolvers';
-import { ModelResourceGenerator } from './model-resource-generator';
-
-/**
- * DynamoModelResourceGenerator is an implementation of ModelResourceGenerator,
- * providing necessary utilities to generate the DynamoDB resources for models
- */
-export class DynamoModelResourceGenerator extends ModelResourceGenerator {
-  protected readonly generatorType = 'DynamoModelResourceGenerator';
-
-  generateResources(ctx: TransformerContextProvider): void {
-    if (!this.isEnabled()) {
-      return;
-    }
-
-    if (this.isProvisioned()) {
-      // add model related-parameters to the root stack
-      const rootStack = cdk.Stack.of(ctx.stackManager.scope);
-      new cdk.CfnParameter(rootStack, ResourceConstants.PARAMETERS.DynamoDBModelTableReadIOPS, {
-        description: 'The number of read IOPS the table should support.',
-        type: 'Number',
-        default: 5,
-      });
-      new cdk.CfnParameter(rootStack, ResourceConstants.PARAMETERS.DynamoDBModelTableWriteIOPS, {
-        description: 'The number of write IOPS the table should support.',
-        type: 'Number',
-        default: 5,
-      });
-      new cdk.CfnParameter(rootStack, ResourceConstants.PARAMETERS.DynamoDBBillingMode, {
-        description: 'Configure @model types to create DynamoDB tables with PAY_PER_REQUEST or PROVISIONED billing modes.',
-        default: 'PAY_PER_REQUEST',
-        allowedValues: ['PAY_PER_REQUEST', 'PROVISIONED'],
-      });
-      new cdk.CfnParameter(rootStack, ResourceConstants.PARAMETERS.DynamoDBEnablePointInTimeRecovery, {
-        description: 'Whether to enable Point in Time Recovery on the table.',
-        type: 'String',
-        default: 'false',
-        allowedValues: ['true', 'false'],
-      });
-      new cdk.CfnParameter(rootStack, ResourceConstants.PARAMETERS.DynamoDBEnableServerSideEncryption, {
-        description: 'Enable server side encryption powered by KMS.',
-        type: 'String',
-        default: 'true',
-        allowedValues: ['true', 'false'],
-      });
-    }
-
-    this.models.forEach((model) => {
-      // This name is used by the mock functionality. Changing this can break mock.
-      const tableBaseName = ctx.resourceHelper.getModelNameMapping(model!.name.value);
-      const tableLogicalName = ModelResourceIDs.ModelTableResourceID(tableBaseName);
-      const scope = ctx.stackManager.getScopeFor(tableLogicalName, tableBaseName);
-
-      this.createModelTable(scope, model, ctx);
-    });
-
-    this.generateResolvers(ctx);
-  }
-
-  // eslint-disable-next-line class-methods-use-this
-  getVTLGenerator(): ModelVTLGenerator {
-    return new DynamoDBModelVTLGenerator();
-  }
-
-  private createModelTable(scope: Construct, def: ObjectTypeDefinitionNode, context: TransformerContextProvider): void {
-    const modelName = def!.name.value;
-    const tableLogicalName = ModelResourceIDs.ModelTableResourceID(modelName);
-    const tableName = context.resourceHelper.generateTableName(modelName);
-
-    // Add parameters.
-    const readIops = new cdk.CfnParameter(scope, ResourceConstants.PARAMETERS.DynamoDBModelTableReadIOPS, {
-      description: 'The number of read IOPS the table should support.',
-      type: 'Number',
-      default: 5,
-    });
-    const writeIops = new cdk.CfnParameter(scope, ResourceConstants.PARAMETERS.DynamoDBModelTableWriteIOPS, {
-      description: 'The number of write IOPS the table should support.',
-      type: 'Number',
-      default: 5,
-    });
-    const billingMode = new cdk.CfnParameter(scope, ResourceConstants.PARAMETERS.DynamoDBBillingMode, {
-      description: 'Configure @model types to create DynamoDB tables with PAY_PER_REQUEST or PROVISIONED billing modes.',
-      type: 'String',
-      default: 'PAY_PER_REQUEST',
-      allowedValues: ['PAY_PER_REQUEST', 'PROVISIONED'],
-    });
-    const pointInTimeRecovery = new cdk.CfnParameter(scope, ResourceConstants.PARAMETERS.DynamoDBEnablePointInTimeRecovery, {
-      description: 'Whether to enable Point in Time Recovery on the table.',
-      type: 'String',
-      default: 'false',
-      allowedValues: ['true', 'false'],
-    });
-    const enableSSE = new cdk.CfnParameter(scope, ResourceConstants.PARAMETERS.DynamoDBEnableServerSideEncryption, {
-      description: 'Enable server side encryption powered by KMS.',
-      type: 'String',
-      default: 'true',
-      allowedValues: ['true', 'false'],
-    });
-    // add the connection between the root and nested stack so the values can be passed down
-    (scope as cdk.NestedStack).setParameter(readIops.node.id, cdk.Fn.ref(ResourceConstants.PARAMETERS.DynamoDBModelTableReadIOPS));
-    (scope as cdk.NestedStack).setParameter(writeIops.node.id, cdk.Fn.ref(ResourceConstants.PARAMETERS.DynamoDBModelTableWriteIOPS));
-    (scope as cdk.NestedStack).setParameter(billingMode.node.id, cdk.Fn.ref(ResourceConstants.PARAMETERS.DynamoDBBillingMode));
-    (scope as cdk.NestedStack).setParameter(
-      pointInTimeRecovery.node.id,
-      cdk.Fn.ref(ResourceConstants.PARAMETERS.DynamoDBEnablePointInTimeRecovery),
-    );
-    (scope as cdk.NestedStack).setParameter(enableSSE.node.id, cdk.Fn.ref(ResourceConstants.PARAMETERS.DynamoDBEnableServerSideEncryption));
-
-    // Add conditions.
-    new cdk.CfnCondition(scope, ResourceConstants.CONDITIONS.HasEnvironmentParameter, {
-      expression: cdk.Fn.conditionNot(cdk.Fn.conditionEquals(context.synthParameters.amplifyEnvironmentName, ResourceConstants.NONE)),
-    });
-    const useSSE = new cdk.CfnCondition(scope, ResourceConstants.CONDITIONS.ShouldUseServerSideEncryption, {
-      expression: cdk.Fn.conditionEquals(enableSSE, 'true'),
-    });
-    const usePayPerRequestBilling = new cdk.CfnCondition(scope, ResourceConstants.CONDITIONS.ShouldUsePayPerRequestBilling, {
-      expression: cdk.Fn.conditionEquals(billingMode, 'PAY_PER_REQUEST'),
-    });
-    const usePointInTimeRecovery = new cdk.CfnCondition(scope, ResourceConstants.CONDITIONS.ShouldUsePointInTimeRecovery, {
-      expression: cdk.Fn.conditionEquals(pointInTimeRecovery, 'true'),
-    });
-
-    const removalPolicy = this.options.EnableDeletionProtection ? cdk.RemovalPolicy.RETAIN : cdk.RemovalPolicy.DESTROY;
-
-    // Expose a way in context to allow proper resource naming
-    const table = new Table(scope, tableLogicalName, {
-      tableName,
-      partitionKey: {
-        name: 'id',
-        type: AttributeType.STRING,
-      },
-      stream: StreamViewType.NEW_AND_OLD_IMAGES,
-      encryption: TableEncryption.DEFAULT,
-      removalPolicy,
-      ...(context.isProjectUsingDataStore() ? { timeToLiveAttribute: '_ttl' } : undefined),
-    });
-    const cfnTable = table.node.defaultChild as CfnTable;
-    setResourceName(table, { name: modelName, setOnDefaultChild: true });
-
-    cfnTable.provisionedThroughput = cdk.Fn.conditionIf(usePayPerRequestBilling.logicalId, cdk.Fn.ref('AWS::NoValue'), {
-      ReadCapacityUnits: readIops,
-      WriteCapacityUnits: writeIops,
-    });
-    cfnTable.pointInTimeRecoverySpecification = cdk.Fn.conditionIf(
-      usePointInTimeRecovery.logicalId,
-      { PointInTimeRecoveryEnabled: true },
-      cdk.Fn.ref('AWS::NoValue'),
-    );
-    cfnTable.billingMode = cdk.Fn.conditionIf(usePayPerRequestBilling.logicalId, 'PAY_PER_REQUEST', cdk.Fn.ref('AWS::NoValue')).toString();
-    cfnTable.sseSpecification = {
-      sseEnabled: cdk.Fn.conditionIf(useSSE.logicalId, true, false),
-    };
-
-    const streamArnOutputId = `GetAtt${ModelResourceIDs.ModelTableStreamArn(def!.name.value)}`;
-    if (table.tableStreamArn) {
-      new cdk.CfnOutput(cdk.Stack.of(scope), streamArnOutputId, {
-        value: table.tableStreamArn,
-        description: 'Your DynamoDB table StreamArn.',
-        exportName: cdk.Fn.join(':', [context.api.apiId, 'GetAtt', tableLogicalName, 'StreamArn']),
-      });
-    }
-
-    const tableNameOutputId = `GetAtt${tableLogicalName}Name`;
-    new cdk.CfnOutput(cdk.Stack.of(scope), tableNameOutputId, {
-      value: table.tableName,
-      description: 'Your DynamoDB table name.',
-      exportName: cdk.Fn.join(':', [context.api.apiId, 'GetAtt', tableLogicalName, 'Name']),
-    });
-
-    const role = this.createIAMRole(context, def, scope, tableName);
-    const tableDataSourceLogicalName = `${def!.name.value}Table`;
-    this.createModelTableDataSource(def, context, table, scope, role, tableDataSourceLogicalName);
-  }
-
-  private createModelTableDataSource(
-    def: ObjectTypeDefinitionNode,
-    context: TransformerContextProvider,
-    table: Table,
-    scope: Construct,
-    role: iam.Role,
-    dataSourceLogicalName: string,
-  ): void {
-    const datasourceRoleLogicalID = ModelResourceIDs.ModelTableDataSourceID(def!.name.value);
-    const dataSource = context.api.host.addDynamoDbDataSource(
-      datasourceRoleLogicalID,
-      table,
-      { name: dataSourceLogicalName, serviceRole: role },
-      scope,
-    );
-
-    const cfnDataSource = dataSource.node.defaultChild as CfnDataSource;
-    cfnDataSource.addDependency(role.node.defaultChild as CfnRole);
-
-    if (context.isProjectUsingDataStore()) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const datasourceDynamoDb = cfnDataSource.dynamoDbConfig as any;
-      datasourceDynamoDb.deltaSyncConfig = {
-        deltaSyncTableName: context.resourceHelper.generateTableName(SyncResourceIDs.syncTableName),
-        deltaSyncTableTtl: '30',
-        baseTableTtl: '43200',
-      };
-      datasourceDynamoDb.versioned = true;
-    }
-
-    const datasourceOutputId = `GetAtt${datasourceRoleLogicalID}Name`;
-    new cdk.CfnOutput(cdk.Stack.of(scope), datasourceOutputId, {
-      value: dataSource.ds.attrName,
-      description: 'Your model DataSource name.',
-      exportName: cdk.Fn.join(':', [context.api.apiId, 'GetAtt', datasourceRoleLogicalID, 'Name']),
-    });
-
-    // add the data source
-    context.dataSources.add(def!, dataSource);
-    this.datasourceMap[def!.name.value] = dataSource;
-  }
-
-  /**
-   * createIAMRole
-   */
-  createIAMRole = (context: TransformerContextProvider, def: ObjectTypeDefinitionNode, scope: Construct, tableName: string): iam.Role => {
-    const roleName = context.resourceHelper.generateIAMRoleName(ModelResourceIDs.ModelTableIAMRoleID(def!.name.value));
-    const role = new iam.Role(scope, ModelResourceIDs.ModelTableIAMRoleID(def!.name.value), {
-      roleName,
-      assumedBy: new iam.ServicePrincipal('appsync.amazonaws.com'),
-    });
-    setResourceName(role, { name: ModelResourceIDs.ModelTableIAMRoleID(def!.name.value), setOnDefaultChild: true });
-
-    const amplifyDataStoreTableName = context.resourceHelper.generateTableName(SyncResourceIDs.syncTableName);
-    role.attachInlinePolicy(
-      new iam.Policy(scope, 'DynamoDBAccess', {
-        statements: [
-          new iam.PolicyStatement({
-            effect: iam.Effect.ALLOW,
-            actions: [
-              'dynamodb:BatchGetItem',
-              'dynamodb:BatchWriteItem',
-              'dynamodb:PutItem',
-              'dynamodb:DeleteItem',
-              'dynamodb:GetItem',
-              'dynamodb:Scan',
-              'dynamodb:Query',
-              'dynamodb:UpdateItem',
-            ],
-            resources: [
-              // eslint-disable-next-line no-template-curly-in-string
-              cdk.Fn.sub('arn:aws:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tablename}', {
-                tablename: tableName,
-              }),
-              // eslint-disable-next-line no-template-curly-in-string
-              cdk.Fn.sub('arn:aws:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tablename}/*', {
-                tablename: tableName,
-              }),
-              ...(context.isProjectUsingDataStore()
-                ? [
-                    // eslint-disable-next-line no-template-curly-in-string
-                    cdk.Fn.sub('arn:aws:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tablename}', {
-                      tablename: amplifyDataStoreTableName,
-                    }),
-                    // eslint-disable-next-line no-template-curly-in-string
-                    cdk.Fn.sub('arn:aws:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tablename}/*', {
-                      tablename: amplifyDataStoreTableName,
-                    }),
-                  ]
-                : []),
-            ],
-          }),
-        ],
-      }),
-    );
-
-    const syncConfig = SyncUtils.getSyncConfig(context, def!.name.value);
-    if (syncConfig && SyncUtils.isLambdaSyncConfig(syncConfig)) {
-      role.attachInlinePolicy(
-        SyncUtils.createSyncLambdaIAMPolicy(context, scope, syncConfig.LambdaConflictHandler.name, syncConfig.LambdaConflictHandler.region),
-      );
-    }
-
-    return role;
-  };
-}