@aws-amplify/graphql-model-transformer 1.2.1-ownerfield-pk-fix.0 → 1.3.0-sync-fix.0

package/src/graphql-model-transformer.ts

@@ -1,16 +1,16 @@
 import {
+  DDB_DB_TYPE,
+  MYSQL_DB_TYPE,
   DirectiveWrapper,
   FieldWrapper,
   generateGetArgumentsInput,
   getFieldNameFor,
   InputObjectDefinitionWrapper,
   InvalidDirectiveError,
-  MappingTemplate,
   ObjectDefinitionWrapper,
-  SyncConfig,
   SyncUtils,
   TransformerModelBase,
-  TransformerNestedStack,
+  DatasourceType,
 } from '@aws-amplify/graphql-transformer-core';
 import {
   AppSyncDataSourceType,
@@ -29,17 +29,13 @@ import {
   TransformerValidationStepContextProvider,
 } from '@aws-amplify/graphql-transformer-interfaces';
 import {
-  AttributeType,
-  CfnTable,
   ITable,
   StreamViewType,
   Table,
   TableEncryption,
 } from 'aws-cdk-lib/aws-dynamodb';
 import * as iam from 'aws-cdk-lib/aws-iam';
-import { CfnRole } from 'aws-cdk-lib/aws-iam';
 import * as cdk from 'aws-cdk-lib';
-import { CfnDataSource } from 'aws-cdk-lib/aws-appsync';
 import {
   DirectiveNode,
   FieldDefinitionNode,
@@ -57,11 +53,6 @@ import {
   makeNamedType,
   makeNonNullType,
   makeValueNode,
-  ModelResourceIDs,
-  ResolverResourceIDs,
-  ResourceConstants,
-  SyncResourceIDs,
-  toCamelCase,
   toPascalCase,
   toUpper,
 } from 'graphql-transformer-common';
@@ -80,26 +71,12 @@ import {
   makeUpdateInputField,
   propagateApiKeyToNestedTypes,
 } from './graphql-types';
-import {
-  generateAuthExpressionForSandboxMode,
-  generateCreateInitSlotTemplate,
-  generateCreateRequestTemplate,
-  generateDefaultResponseMappingTemplate,
-  generateDeleteRequestTemplate,
-  generateResolverKey,
-  generateSubscriptionRequestTemplate,
-  generateSubscriptionResponseTemplate,
-  generateUpdateInitSlotTemplate,
-  generateUpdateRequestTemplate,
-} from './resolvers';
-import {
-  generateGetRequestTemplate,
-  generateGetResponseTemplate,
-  generateListRequestTemplate,
-  generateSyncRequestTemplate,
-} from './resolvers/query';
 import { API_KEY_DIRECTIVE } from './definitions';
 import { ModelDirectiveConfiguration, SubscriptionLevel } from './directive';
+import { ModelResourceGenerator } from './resources/model-resource-generator';
+import { DynamoModelResourceGenerator } from './resources/dynamo-model-resource-generator';
+import { RdsModelResourceGenerator } from './resources/rds-model-resource-generator';
+import { ModelTransformerOptions } from './types';
 
 /**
  * Nullable
@@ -139,10 +116,7 @@ export const directiveDefinition = /* GraphQl */ `
   }
 `;
 
-type ModelTransformerOptions = {
-  EnableDeletionProtection?: boolean;
-  SyncConfig?: SyncConfig;
-};
+const DDB_DATASOURCE_TYPE = { dbType: DDB_DB_TYPE, provisioned: true };
 
 /**
  * ModelTransformer
@@ -153,6 +127,8 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
   private ddbTableMap: Record<string, ITable> = {};
   private resolverMap: Record<string, TransformerResolverProvider> = {};
   private typesWithModelDirective: Set<string> = new Set();
+  private resourceGeneratorMap: Map<string, ModelResourceGenerator> = new Map<string, ModelResourceGenerator>();
+  private modelToDatasourceMap: Map<string, DatasourceType> = new Map<string, DatasourceType>()
   /**
    * A Map to hold the directive configuration
    */
@@ -160,37 +136,29 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
   constructor(options: ModelTransformerOptions = {}) {
     super('amplify-model-transformer', directiveDefinition);
     this.options = this.getOptions(options);
+    const rdsGenerator = new RdsModelResourceGenerator();
+    this.resourceGeneratorMap.set(DDB_DB_TYPE, new DynamoModelResourceGenerator());
+    this.resourceGeneratorMap.set(MYSQL_DB_TYPE, rdsGenerator);
   }
 
   before = (ctx: TransformerBeforeStepContextProvider): void => {
-    // add model related-parameters to the root stack
-    ctx.stackManager.addParameter(ResourceConstants.PARAMETERS.DynamoDBModelTableReadIOPS, {
-      description: 'The number of read IOPS the table should support.',
-      type: 'Number',
-      default: 5,
-    });
-    ctx.stackManager.addParameter(ResourceConstants.PARAMETERS.DynamoDBModelTableWriteIOPS, {
-      description: 'The number of write IOPS the table should support.',
-      type: 'Number',
-      default: 5,
-    });
-    ctx.stackManager.addParameter(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'],
-    });
-    ctx.stackManager.addParameter(ResourceConstants.PARAMETERS.DynamoDBEnablePointInTimeRecovery, {
-      description: 'Whether to enable Point in Time Recovery on the table.',
-      type: 'String',
-      default: 'false',
-      allowedValues: ['true', 'false'],
-    });
-    ctx.stackManager.addParameter(ResourceConstants.PARAMETERS.DynamoDBEnableServerSideEncryption, {
-      description: 'Enable server side encryption powered by KMS.',
-      type: 'String',
-      default: 'true',
-      allowedValues: ['true', 'false'],
-    });
+    const datasourceMapValues: Array<DatasourceType> = Array.from(ctx.modelToDatasourceMap.values());
+    if (datasourceMapValues.some((value) => value.dbType === DDB_DB_TYPE && value.provisionDB)) {
+      this.resourceGeneratorMap.get(DDB_DB_TYPE)?.enableGenerator();
+      this.resourceGeneratorMap.get(DDB_DB_TYPE)?.enableProvisioned();
+    }
+    if (datasourceMapValues.some((value) => value.dbType === MYSQL_DB_TYPE && !value.provisionDB)) {
+      this.resourceGeneratorMap.get(MYSQL_DB_TYPE)?.enableGenerator();
+      this.resourceGeneratorMap.get(MYSQL_DB_TYPE)?.enableUnprovisioned();
+    }
+    if (datasourceMapValues.length === 0) {
+      // Just enable DynamoDB provisioned, legacy use
+      this.resourceGeneratorMap.get(DDB_DB_TYPE)?.enableGenerator();
+      this.resourceGeneratorMap.get(DDB_DB_TYPE)?.enableProvisioned();
+    }
+    // We only store this in the model because some of the required override methods need to pass through to the
+    // Resource generators, but do not have access to the context
+    this.modelToDatasourceMap = ctx.modelToDatasourceMap;
   };
 
   object = (definition: ObjectTypeDefinitionNode, directive: DirectiveNode, ctx: TransformerSchemaVisitStepContextProvider): void => {
@@ -198,6 +166,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       || definition.name.value === ctx.output.getMutationTypeName()
       || definition.name.value === ctx.output.getSubscriptionTypeName();
 
+    const isDynamoDB = (ctx.modelToDatasourceMap.get(definition.name.value) ?? DDB_DATASOURCE_TYPE).dbType === DDB_DB_TYPE;
     if (isTypeNameReserved) {
       throw new InvalidDirectiveError(
         `'${definition.name.value}' is a reserved type name and currently in use within the default schema element.`,
@@ -228,9 +197,12 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
         onDelete: [getFieldNameFor('onDelete', typeName)],
         onUpdate: [getFieldNameFor('onUpdate', typeName)],
       },
-      timestamps: {
+      timestamps: isDynamoDB ? {
         createdAt: 'createdAt',
         updatedAt: 'updatedAt',
+      } : {
+        createdAt: undefined,
+        updatedAt: undefined,
       },
     }, generateGetArgumentsInput(ctx.featureFlags));
 
@@ -272,6 +244,14 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
 
     this.modelDirectiveConfig.set(typeName, options);
     this.typesWithModelDirective.add(typeName);
+
+    const dataType = ctx.modelToDatasourceMap.get(typeName) ?? DDB_DATASOURCE_TYPE;
+    const resourceGenerator = this.resourceGeneratorMap.get(dataType.dbType);
+    if (resourceGenerator) {
+      resourceGenerator.addModelDefinition(definition, options);
+    } else {
+      throw Error(`DB Type or Resource Generator not defined for ${typeName}`);
+    }
   };
 
   prepare = (context: TransformerPrepareStepContextProvider): void => {
@@ -302,11 +282,13 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       const subscriptionsFields = this.createSubscriptionFields(ctx, def!);
       ctx.output.addSubscriptionFields(subscriptionsFields);
 
-      // Update the field with auto generatable Fields
-      this.addAutoGeneratableFields(ctx, type);
+      if ((ctx.modelToDatasourceMap.get(def.name.value) ?? DDB_DATASOURCE_TYPE).dbType === DDB_DB_TYPE) {
+        // Update the field with auto generatable Fields
+        this.addAutoGeneratableFields(ctx, type);
 
-      if (ctx.isProjectUsingDataStore()) {
-        this.addModelSyncFields(ctx, type);
+        if (ctx.isProjectUsingDataStore()) {
+          this.addModelSyncFields(ctx, type);
+        }
       }
       // global auth check
       if (!hasAuth && ctx.sandboxModeEnabled && ctx.authConfig.defaultAuthentication.authenticationType !== 'API_KEY') {
@@ -330,118 +312,8 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
   };
 
   generateResolvers = (context: TransformerContextProvider): void => {
-    this.typesWithModelDirective.forEach(type => {
-      const def = context.output.getObject(type)!;
-      // This name is used by the mock functionality. Changing this can break mock.
-      const tableBaseName = context.resourceHelper.getModelNameMapping(def!.name.value);
-      const tableLogicalName = ModelResourceIDs.ModelTableResourceID(tableBaseName);
-      const stack = context.stackManager.getStackFor(tableLogicalName, tableBaseName);
-
-      this.createModelTable(stack, def!, context);
-
-      const queryFields = this.getQueryFieldNames(def!);
-      queryFields.forEach(query => {
-        let resolver;
-        switch (query.type) {
-          case QueryFieldType.GET:
-            resolver = this.generateGetResolver(context, def!, query.typeName, query.fieldName, query.resolverLogicalId);
-            break;
-          case QueryFieldType.LIST:
-            resolver = this.generateListResolver(context, def!, query.typeName, query.fieldName, query.resolverLogicalId);
-            break;
-          case QueryFieldType.SYNC:
-            resolver = this.generateSyncResolver(context, def!, query.typeName, query.fieldName, query.resolverLogicalId);
-            break;
-          default:
-            throw new Error('Unknown query field type');
-        }
-        // TODO: add mechanism to add an auth like rule to all non auth @models
-        // this way we can just depend on auth to add the check
-        resolver.addToSlot(
-          'postAuth',
-          MappingTemplate.s3MappingTemplateFromString(
-            generateAuthExpressionForSandboxMode(context.sandboxModeEnabled),
-            `${query.typeName}.${query.fieldName}.{slotName}.{slotIndex}.req.vtl`,
-          ),
-        );
-        resolver.mapToStack(context.stackManager.getStackFor(query.resolverLogicalId, def!.name.value));
-        context.resolvers.addResolver(query.typeName, query.fieldName, resolver);
-      });
-
-      const mutationFields = this.getMutationFieldNames(def!);
-      mutationFields.forEach(mutation => {
-        let resolver;
-        switch (mutation.type) {
-          case MutationFieldType.CREATE:
-            resolver = this.generateCreateResolver(context, def!, mutation.typeName, mutation.fieldName, mutation.resolverLogicalId);
-            break;
-          case MutationFieldType.DELETE:
-            resolver = this.generateDeleteResolver(context, def!, mutation.typeName, mutation.fieldName, mutation.resolverLogicalId);
-            break;
-          case MutationFieldType.UPDATE:
-            resolver = this.generateUpdateResolver(context, def!, mutation.typeName, mutation.fieldName, mutation.resolverLogicalId);
-            break;
-          default:
-            throw new Error('Unknown mutation field type');
-        }
-        resolver.addToSlot(
-          'postAuth',
-          MappingTemplate.s3MappingTemplateFromString(
-            generateAuthExpressionForSandboxMode(context.sandboxModeEnabled),
-            `${mutation.typeName}.${mutation.fieldName}.{slotName}.{slotIndex}.req.vtl`,
-          ),
-        );
-        resolver.mapToStack(context.stackManager.getStackFor(mutation.resolverLogicalId, def!.name.value));
-        context.resolvers.addResolver(mutation.typeName, mutation.fieldName, resolver);
-      });
-
-      const subscriptionLevel = this.modelDirectiveConfig.get(def.name.value)?.subscriptions?.level;
-      // in order to create subscription resolvers the level needs to be on
-      if (subscriptionLevel !== SubscriptionLevel.off) {
-        const subscriptionFields = this.getSubscriptionFieldNames(def!);
-        subscriptionFields.forEach(subscription => {
-          let resolver;
-          switch (subscription.type) {
-            case SubscriptionFieldType.ON_CREATE:
-              resolver = this.generateOnCreateResolver(
-                context,
-                subscription.typeName,
-                subscription.fieldName,
-                subscription.resolverLogicalId,
-              );
-              break;
-            case SubscriptionFieldType.ON_UPDATE:
-              resolver = this.generateOnUpdateResolver(
-                context,
-                subscription.typeName,
-                subscription.fieldName,
-                subscription.resolverLogicalId,
-              );
-              break;
-            case SubscriptionFieldType.ON_DELETE:
-              resolver = this.generateOnDeleteResolver(
-                context,
-                subscription.typeName,
-                subscription.fieldName,
-                subscription.resolverLogicalId,
-              );
-              break;
-            default:
-              throw new Error('Unknown subscription field type');
-          }
-          if (subscriptionLevel === SubscriptionLevel.on) {
-            resolver.addToSlot(
-              'postAuth',
-              MappingTemplate.s3MappingTemplateFromString(
-                generateAuthExpressionForSandboxMode(context.sandboxModeEnabled),
-                `${subscription.typeName}.${subscription.fieldName}.{slotName}.{slotIndex}.req.vtl`,
-              ),
-            );
-          }
-          resolver.mapToStack(context.stackManager.getStackFor(subscription.resolverLogicalId, def!.name.value));
-          context.resolvers.addResolver(subscription.typeName, subscription.fieldName, resolver);
-        });
-      }
+    this.resourceGeneratorMap.forEach((generator) => {
+      generator.generateResources(context);
     });
   };
 
@@ -452,20 +324,12 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     fieldName: string,
     resolverLogicalId: string,
   ): TransformerResolverProvider => {
-    const isSyncEnabled = ctx.isProjectUsingDataStore();
-    const dataSource = this.datasourceMap[type.name.value];
-    const resolverKey = `Get${generateResolverKey(typeName, fieldName)}`;
-    if (!this.resolverMap[resolverKey]) {
-      this.resolverMap[resolverKey] = ctx.resolvers.generateQueryResolver(
-        typeName,
-        fieldName,
-        resolverLogicalId,
-        dataSource,
-        MappingTemplate.s3MappingTemplateFromString(generateGetRequestTemplate(), `${typeName}.${fieldName}.req.vtl`),
-        MappingTemplate.s3MappingTemplateFromString(generateGetResponseTemplate(isSyncEnabled), `${typeName}.${fieldName}.res.vtl`),
-      );
+    const dbInfo = ctx.modelToDatasourceMap.get(type.name.value) ?? DDB_DATASOURCE_TYPE;
+    if (dbInfo?.dbType && this.resourceGeneratorMap.has(dbInfo.dbType)) {
+      // Coercing this into being defined as we're running a check on it first
+      return this.resourceGeneratorMap.get(dbInfo.dbType)!.generateGetResolver(ctx, type, typeName, fieldName, resolverLogicalId);
     }
-    return this.resolverMap[resolverKey];
+    throw new Error(`DB Type undefined or resource generator not provided for ${type.name.value}`);
   };
 
   generateListResolver = (
@@ -475,23 +339,27 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     fieldName: string,
     resolverLogicalId: string,
   ): TransformerResolverProvider => {
-    const isSyncEnabled = ctx.isProjectUsingDataStore();
-    const dataSource = this.datasourceMap[type.name.value];
-    const resolverKey = `List${generateResolverKey(typeName, fieldName)}`;
-    if (!this.resolverMap[resolverKey]) {
-      this.resolverMap[resolverKey] = ctx.resolvers.generateQueryResolver(
-        typeName,
-        fieldName,
-        resolverLogicalId,
-        dataSource,
-        MappingTemplate.s3MappingTemplateFromString(generateListRequestTemplate(), `${typeName}.${fieldName}.req.vtl`),
-        MappingTemplate.s3MappingTemplateFromString(
-          generateDefaultResponseMappingTemplate(isSyncEnabled),
-          `${typeName}.${fieldName}.res.vtl`,
-        ),
-      );
+    const dbInfo = ctx.modelToDatasourceMap.get(type.name.value) ?? DDB_DATASOURCE_TYPE;
+    if (dbInfo?.dbType && this.resourceGeneratorMap.has(dbInfo.dbType)) {
+      // Coercing this into being defined as we're running a check on it first
+      return this.resourceGeneratorMap.get(dbInfo.dbType)!.generateListResolver(ctx, type, typeName, fieldName, resolverLogicalId);
     }
-    return this.resolverMap[resolverKey];
+    throw new Error(`DB Type undefined or resource generator not provided for ${type.name.value}`);
+  };
+
+  generateCreateResolver = (
+    ctx: TransformerContextProvider,
+    type: ObjectTypeDefinitionNode,
+    typeName: string,
+    fieldName: string,
+    resolverLogicalId: string,
+  ): TransformerResolverProvider => {
+    const dbInfo = ctx.modelToDatasourceMap.get(type.name.value) ?? DDB_DATASOURCE_TYPE;
+    if (dbInfo?.dbType && this.resourceGeneratorMap.has(dbInfo.dbType)) {
+      // Coercing this into being defined as we're running a check on it first
+      return this.resourceGeneratorMap.get(dbInfo.dbType)!.generateCreateResolver(ctx, type, typeName, fieldName, resolverLogicalId);
+    }
+    throw new Error(`DB Type undefined or resource generator not provided for ${type.name.value}`);
   };
 
   generateUpdateResolver = (
@@ -501,35 +369,20 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     fieldName: string,
     resolverLogicalId: string,
   ): TransformerResolverProvider => {
-    const isSyncEnabled = ctx.isProjectUsingDataStore();
-    const dataSource = this.datasourceMap[type.name.value];
-    const resolverKey = `Update${generateResolverKey(typeName, fieldName)}`;
-    if (!this.resolverMap[resolverKey]) {
-      const resolver = ctx.resolvers.generateMutationResolver(
+    const modelDirectiveConfig = this.modelDirectiveConfig.get(type.name.value)!;
+    const dbInfo = ctx.modelToDatasourceMap.get(type.name.value) ?? DDB_DATASOURCE_TYPE;
+    if (dbInfo?.dbType && this.resourceGeneratorMap.has(dbInfo.dbType)) {
+      // Coercing this into being defined as we're running a check on it first
+      return this.resourceGeneratorMap.get(dbInfo.dbType)!.generateUpdateResolver(
+        ctx,
+        type,
+        modelDirectiveConfig,
         typeName,
         fieldName,
         resolverLogicalId,
-        dataSource,
-        MappingTemplate.s3MappingTemplateFromString(
-          generateUpdateRequestTemplate(typeName, isSyncEnabled),
-          `${typeName}.${fieldName}.req.vtl`,
-        ),
-        MappingTemplate.s3MappingTemplateFromString(
-          generateDefaultResponseMappingTemplate(isSyncEnabled, true),
-          `${typeName}.${fieldName}.res.vtl`,
-        ),
-      );
-      // Todo: get the slot index from the resolver to keep the name unique and show the order of functions
-      resolver.addToSlot(
-        'init',
-        MappingTemplate.s3MappingTemplateFromString(
-          generateUpdateInitSlotTemplate(this.modelDirectiveConfig.get(type.name.value)!),
-          `${typeName}.${fieldName}.{slotName}.{slotIndex}.req.vtl`,
-        ),
       );
-      this.resolverMap[resolverKey] = resolver;
     }
-    return this.resolverMap[resolverKey];
+    throw new Error(`DB Type undefined or resource generator not provided for ${type.name.value}`);
   };
 
   generateDeleteResolver = (
@@ -539,23 +392,12 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     fieldName: string,
     resolverLogicalId: string,
   ): TransformerResolverProvider => {
-    const isSyncEnabled = ctx.isProjectUsingDataStore();
-    const dataSource = this.datasourceMap[type.name.value];
-    const resolverKey = `delete${generateResolverKey(typeName, fieldName)}`;
-    if (!this.resolverMap[resolverKey]) {
-      this.resolverMap[resolverKey] = ctx.resolvers.generateMutationResolver(
-        typeName,
-        fieldName,
-        resolverLogicalId,
-        dataSource,
-        MappingTemplate.s3MappingTemplateFromString(generateDeleteRequestTemplate(isSyncEnabled), `${typeName}.${fieldName}.req.vtl`),
-        MappingTemplate.s3MappingTemplateFromString(
-          generateDefaultResponseMappingTemplate(isSyncEnabled, true),
-          `${typeName}.${fieldName}.res.vtl`,
-        ),
-      );
+    const dbInfo = ctx.modelToDatasourceMap.get(type.name.value) ?? DDB_DATASOURCE_TYPE;
+    if (dbInfo?.dbType && this.resourceGeneratorMap.has(dbInfo.dbType)) {
+      // Coercing this into being defined as we're running a check on it first
+      return this.resourceGeneratorMap.get(dbInfo.dbType)!.generateDeleteResolver(ctx, type, typeName, fieldName, resolverLogicalId);
     }
-    return this.resolverMap[resolverKey];
+    throw new Error(`DB Type undefined or resource generator not provided for ${type.name.value}`);
   };
 
   generateOnCreateResolver = (
@@ -564,17 +406,11 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     fieldName: string,
     resolverLogicalId: string,
   ): TransformerResolverProvider => {
-    const resolverKey = `OnCreate${generateResolverKey(typeName, fieldName)}`;
-    if (!this.resolverMap[resolverKey]) {
-      this.resolverMap[resolverKey] = ctx.resolvers.generateSubscriptionResolver(
-        typeName,
-        fieldName,
-        resolverLogicalId,
-        MappingTemplate.s3MappingTemplateFromString(generateSubscriptionRequestTemplate(), `${typeName}.${fieldName}.req.vtl`),
-        MappingTemplate.s3MappingTemplateFromString(generateSubscriptionResponseTemplate(), `${typeName}.${fieldName}.res.vtl`),
-      );
+    if (this.resourceGeneratorMap.has(DDB_DB_TYPE)) {
+      // Coercing this into being defined as we're running a check on it first
+      return this.resourceGeneratorMap.get(DDB_DB_TYPE)!.generateOnCreateResolver(ctx, typeName, fieldName, resolverLogicalId);
     }
-    return this.resolverMap[resolverKey];
+    throw new Error('Resource generator not provided for DDB');
   };
 
   generateOnUpdateResolver = (
@@ -583,17 +419,11 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     fieldName: string,
     resolverLogicalId: string,
   ): TransformerResolverProvider => {
-    const resolverKey = `OnUpdate${generateResolverKey(typeName, fieldName)}`;
-    if (!this.resolverMap[resolverKey]) {
-      this.resolverMap[resolverKey] = ctx.resolvers.generateSubscriptionResolver(
-        typeName,
-        fieldName,
-        resolverLogicalId,
-        MappingTemplate.s3MappingTemplateFromString(generateSubscriptionRequestTemplate(), `${typeName}.${fieldName}.req.vtl`),
-        MappingTemplate.s3MappingTemplateFromString(generateSubscriptionResponseTemplate(), `${typeName}.${fieldName}.res.vtl`),
-      );
+    if (this.resourceGeneratorMap.has(DDB_DB_TYPE)) {
+      // Coercing this into being defined as we're running a check on it first
+      return this.resourceGeneratorMap.get(DDB_DB_TYPE)!.generateOnUpdateResolver(ctx, typeName, fieldName, resolverLogicalId);
     }
-    return this.resolverMap[resolverKey];
+    throw new Error('Resource generator not provided for DDB');
   };
 
   generateOnDeleteResolver = (
@@ -602,17 +432,11 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     fieldName: string,
     resolverLogicalId: string,
   ): TransformerResolverProvider => {
-    const resolverKey = `OnDelete${generateResolverKey(typeName, fieldName)}`;
-    if (!this.resolverMap[resolverKey]) {
-      this.resolverMap[resolverKey] = ctx.resolvers.generateSubscriptionResolver(
-        typeName,
-        fieldName,
-        resolverLogicalId,
-        MappingTemplate.s3MappingTemplateFromString(generateSubscriptionRequestTemplate(), `${typeName}.${fieldName}.req.vtl`),
-        MappingTemplate.s3MappingTemplateFromString(generateSubscriptionResponseTemplate(), `${typeName}.${fieldName}.res.vtl`),
-      );
+    if (this.resourceGeneratorMap.has(DDB_DB_TYPE)) {
+      // Coercing this into being defined as we're running a check on it first
+      return this.resourceGeneratorMap.get(DDB_DB_TYPE)!.generateOnDeleteResolver(ctx, typeName, fieldName, resolverLogicalId);
     }
-    return this.resolverMap[resolverKey];
+    throw new Error('Resource generator not provided for DDB');
   };
 
   generateSyncResolver = (
@@ -622,106 +446,12 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     fieldName: string,
     resolverLogicalId: string,
   ): TransformerResolverProvider => {
-    const isSyncEnabled = ctx.isProjectUsingDataStore();
-    const dataSource = this.datasourceMap[type.name.value];
-    const resolverKey = `Sync${generateResolverKey(typeName, fieldName)}`;
-    if (!this.resolverMap[resolverKey]) {
-      this.resolverMap[resolverKey] = ctx.resolvers.generateQueryResolver(
-        typeName,
-        fieldName,
-        resolverLogicalId,
-        dataSource,
-        MappingTemplate.s3MappingTemplateFromString(generateSyncRequestTemplate(), `${typeName}.${fieldName}.req.vtl`),
-        MappingTemplate.s3MappingTemplateFromString(
-          generateDefaultResponseMappingTemplate(isSyncEnabled),
-          `${typeName}.${fieldName}.res.vtl`,
-        ),
-      );
+    const dbInfo = ctx.modelToDatasourceMap.get(type.name.value) ?? DDB_DATASOURCE_TYPE;
+    if (dbInfo?.dbType && this.resourceGeneratorMap.has(dbInfo.dbType)) {
+      // Coercing this into being defined as we're running a check on it first
+      return this.resourceGeneratorMap.get(dbInfo.dbType)!.generateSyncResolver(ctx, type, typeName, fieldName, resolverLogicalId);
     }
-    return this.resolverMap[resolverKey];
-  };
-
-  getQueryFieldNames = (
-    type: ObjectTypeDefinitionNode,
-  ): Set<{ fieldName: string; typeName: string; type: QueryFieldType; resolverLogicalId: string }> => {
-    const typeName = type.name.value;
-    const fields: Set<{ fieldName: string; typeName: string; type: QueryFieldType; resolverLogicalId: string }> = new Set();
-    const modelDirectiveConfig = this.modelDirectiveConfig.get(type.name.value);
-    if (modelDirectiveConfig?.queries?.get) {
-      fields.add({
-        typeName: 'Query',
-        fieldName: modelDirectiveConfig.queries.get || toCamelCase(['get', typeName]),
-        type: QueryFieldType.GET,
-        resolverLogicalId: ResolverResourceIDs.DynamoDBGetResolverResourceID(typeName),
-      });
-    }
-
-    if (modelDirectiveConfig?.queries?.list) {
-      fields.add({
-        typeName: 'Query',
-        fieldName: modelDirectiveConfig.queries.list || toCamelCase(['list', typeName]),
-        type: QueryFieldType.LIST,
-        resolverLogicalId: ResolverResourceIDs.DynamoDBListResolverResourceID(typeName),
-      });
-    }
-
-    if (modelDirectiveConfig?.queries?.sync) {
-      fields.add({
-        typeName: 'Query',
-        fieldName: modelDirectiveConfig.queries.sync || toCamelCase(['sync', typeName]),
-        type: QueryFieldType.SYNC,
-        resolverLogicalId: ResolverResourceIDs.SyncResolverResourceID(typeName),
-      });
-    }
-
-    return fields;
-  };
-
-  getMutationFieldNames = (
-    type: ObjectTypeDefinitionNode,
-  ): Set<{ fieldName: string; typeName: string; type: MutationFieldType; resolverLogicalId: string }> => {
-    // Todo: get fields names from the directives
-    const typeName = type.name.value;
-    const modelDirectiveConfig = this.modelDirectiveConfig.get(typeName);
-    const getMutationType = (mutationType: string): MutationFieldType => {
-      switch (mutationType) {
-        case 'create':
-          return MutationFieldType.CREATE;
-        case 'update':
-          return MutationFieldType.UPDATE;
-        case 'delete':
-          return MutationFieldType.DELETE;
-        default:
-          throw new Error('Unknown mutation type');
-      }
-    };
-
-    const getMutationResolverLogicalId = (mutationType: string): string => {
-      switch (mutationType) {
-        case 'create':
-          return ResolverResourceIDs.DynamoDBCreateResolverResourceID(typeName);
-        case 'update':
-          return ResolverResourceIDs.DynamoDBUpdateResolverResourceID(typeName);
-        case 'delete':
-          return ResolverResourceIDs.DynamoDBDeleteResolverResourceID(typeName);
-        default:
-          throw new Error('Unknown mutation type');
-      }
-    };
-
-    const fieldNames: Set<{ fieldName: string; typeName: string; type: MutationFieldType; resolverLogicalId: string }> = new Set();
-    Object.entries(modelDirectiveConfig?.mutations || {}).forEach(([mutationType, mutationName]) => {
-      if (mutationName) {
-        fieldNames.add({
-          typeName: 'Mutation',
-          fieldName: mutationName,
-          type: getMutationType(mutationType),
-          resolverLogicalId: getMutationResolverLogicalId(mutationType),
-        });
-      }
-    });
-
-    return fieldNames;
+    throw new Error(`DB Type undefined or resource generator not provided for ${type.name.value}`);
   };
 
   getMutationName = (
@@ -809,6 +539,28 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     return subscriptionFields;
   };
 
+  getQueryFieldNames = (
+    type: ObjectTypeDefinitionNode,
+  ): Set<{ fieldName: string; typeName: string; type: QueryFieldType; resolverLogicalId: string }> => {
+    const dbType = (this.modelToDatasourceMap.get(type.name.value) ?? DDB_DATASOURCE_TYPE)?.dbType;
+    const resourceGenerator = dbType ? this.resourceGeneratorMap.get(dbType) : null;
+    if (resourceGenerator) {
+      return resourceGenerator.getQueryFieldNames(type);
+    }
+    throw new Error(`Resource Generator or DB Type not defined for ${type.name.value}`);
+  };
+
+  getMutationFieldNames = (
+    type: ObjectTypeDefinitionNode,
+  ): Set<{ fieldName: string; typeName: string; type: MutationFieldType; resolverLogicalId: string }> => {
+    const dbType = (this.modelToDatasourceMap.get(type.name.value) ?? DDB_DATASOURCE_TYPE)?.dbType;
+    const resourceGenerator = dbType ? this.resourceGeneratorMap.get(dbType) : null;
+    if (resourceGenerator) {
+      return resourceGenerator.getMutationFieldNames(type);
+    }
+    throw new Error(`Resource Generator or DB Type not defined for ${type.name.value}`);
+  };
+
   getSubscriptionFieldNames = (
     type: ObjectTypeDefinitionNode,
   ): Set<{
@@ -817,50 +569,12 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     type: SubscriptionFieldType;
     resolverLogicalId: string;
   }> => {
-    const fields: Set<{
-      fieldName: string;
-      typeName: string;
-      type: SubscriptionFieldType;
-      resolverLogicalId: string;
-    }> = new Set();
-
-    const modelDirectiveConfig = this.modelDirectiveConfig.get(type.name.value);
-    if (modelDirectiveConfig?.subscriptions?.level !== SubscriptionLevel.off) {
-      if (modelDirectiveConfig?.subscriptions?.onCreate && modelDirectiveConfig.mutations?.create) {
-        modelDirectiveConfig.subscriptions.onCreate.forEach((fieldName: string) => {
-          fields.add({
-            typeName: 'Subscription',
-            fieldName,
-            type: SubscriptionFieldType.ON_CREATE,
-            resolverLogicalId: ResolverResourceIDs.ResolverResourceID('Subscription', fieldName),
-          });
-        });
-      }
-
-      if (modelDirectiveConfig?.subscriptions?.onUpdate && modelDirectiveConfig.mutations?.update) {
-        modelDirectiveConfig.subscriptions.onUpdate.forEach((fieldName: string) => {
-          fields.add({
-            typeName: 'Subscription',
-            fieldName,
-            type: SubscriptionFieldType.ON_UPDATE,
-            resolverLogicalId: ResolverResourceIDs.ResolverResourceID('Subscription', fieldName),
-          });
-        });
-      }
-
-      if (modelDirectiveConfig?.subscriptions?.onDelete && modelDirectiveConfig.mutations?.delete) {
-        modelDirectiveConfig.subscriptions.onDelete.forEach((fieldName: string) => {
-          fields.add({
-            typeName: 'Subscription',
-            fieldName,
-            type: SubscriptionFieldType.ON_DELETE,
-            resolverLogicalId: ResolverResourceIDs.ResolverResourceID('Subscription', fieldName),
-          });
-        });
-      }
+    const dbType = (this.modelToDatasourceMap.get(type.name.value) ?? DDB_DATASOURCE_TYPE)?.dbType;
+    const resourceGenerator = dbType ? this.resourceGeneratorMap.get(dbType) : null;
+    if (resourceGenerator) {
+      return resourceGenerator.getSubscriptionFieldNames(type);
     }
-
-    return fields;
+    throw new Error(`Resource Generator or DB Type not defined for ${type.name.value}`);
   };
 
   // Todo: add sanity check to ensure the type has an table
@@ -868,41 +582,6 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
 
   getDataSourceType = (): AppSyncDataSourceType => AppSyncDataSourceType.AMAZON_DYNAMODB;
 
-  generateCreateResolver = (
-    ctx: TransformerContextProvider,
-    type: ObjectTypeDefinitionNode,
-    typeName: string,
-    fieldName: string,
-    resolverLogicalId: string,
-  ): TransformerResolverProvider => {
-    const isSyncEnabled = ctx.isProjectUsingDataStore();
-    const dataSource = this.datasourceMap[type.name.value];
-    const resolverKey = `Create${generateResolverKey(typeName, fieldName)}`;
-    const modelIndexFields = type.fields!.filter(field => field.directives?.some(it => it.name.value === 'index')).map(it => it.name.value);
-    if (!this.resolverMap[resolverKey]) {
-      const resolver = ctx.resolvers.generateMutationResolver(
-        typeName,
-        fieldName,
-        resolverLogicalId,
-        dataSource,
-        MappingTemplate.s3MappingTemplateFromString(generateCreateRequestTemplate(type.name.value, modelIndexFields), `${typeName}.${fieldName}.req.vtl`),
-        MappingTemplate.s3MappingTemplateFromString(
-          generateDefaultResponseMappingTemplate(isSyncEnabled, true),
-          `${typeName}.${fieldName}.res.vtl`,
-        ),
-      );
-      this.resolverMap[resolverKey] = resolver;
-      resolver.addToSlot(
-        'init',
-        MappingTemplate.s3MappingTemplateFromString(
-          generateCreateInitSlotTemplate(this.modelDirectiveConfig.get(type.name.value)!),
-          `${typeName}.${fieldName}.{slotName}.{slotIndex}.req.vtl`,
-        ),
-      );
-    }
-    return this.resolverMap[resolverKey];
-  };
-
   getInputs = (
     ctx: TransformerTransformSchemaStepContextProvider,
     type: ObjectTypeDefinitionNode,
@@ -1067,6 +746,14 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     return outputType;
   };
 
+  /**
+   * createIAMRole
+   */
+  createIAMRole = (context: TransformerContextProvider, def: ObjectTypeDefinitionNode, stack: cdk.Stack, tableName: string): iam.Role => {
+    const ddbGenerator = this.resourceGeneratorMap.get(DDB_DB_TYPE) as DynamoModelResourceGenerator;
+    return ddbGenerator.createIAMRole(context, def, stack, tableName);
+  }
+
   private createNonModelInputs = (ctx: TransformerTransformSchemaStepContextProvider, obj: ObjectTypeDefinitionNode): void => {
     (obj.fields ?? []).forEach(field => {
       if (!isScalar(field.type)) {
@@ -1161,229 +848,6 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     return subscriptionToMutationsMap;
   };
 
-  private createModelTable(stack: cdk.Stack, def: ObjectTypeDefinitionNode, context: TransformerContextProvider): void {
-    const tableLogicalName = ModelResourceIDs.ModelTableResourceID(def!.name.value);
-    const tableName = context.resourceHelper.generateTableName(def!.name.value);
-
-    // Add parameters.
-    const env = context.stackManager.getParameter(ResourceConstants.PARAMETERS.Env) as cdk.CfnParameter;
-    const readIops = new cdk.CfnParameter(stack, ResourceConstants.PARAMETERS.DynamoDBModelTableReadIOPS, {
-      description: 'The number of read IOPS the table should support.',
-      type: 'Number',
-      default: 5,
-    });
-    const writeIops = new cdk.CfnParameter(stack, ResourceConstants.PARAMETERS.DynamoDBModelTableWriteIOPS, {
-      description: 'The number of write IOPS the table should support.',
-      type: 'Number',
-      default: 5,
-    });
-    const billingMode = new cdk.CfnParameter(stack, 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(stack, 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(stack, 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
-    (stack as TransformerNestedStack).setParameter(readIops.node.id, cdk.Fn.ref(ResourceConstants.PARAMETERS.DynamoDBModelTableReadIOPS));
-    (stack as TransformerNestedStack).setParameter(writeIops.node.id, cdk.Fn.ref(ResourceConstants.PARAMETERS.DynamoDBModelTableWriteIOPS));
-    (stack as TransformerNestedStack).setParameter(billingMode.node.id, cdk.Fn.ref(ResourceConstants.PARAMETERS.DynamoDBBillingMode));
-    (stack as TransformerNestedStack).setParameter(
-      pointInTimeRecovery.node.id,
-      cdk.Fn.ref(ResourceConstants.PARAMETERS.DynamoDBEnablePointInTimeRecovery),
-    );
-    (stack as TransformerNestedStack).setParameter(
-      enableSSE.node.id,
-      cdk.Fn.ref(ResourceConstants.PARAMETERS.DynamoDBEnableServerSideEncryption),
-    );
-
-    // Add conditions.
-    // eslint-disable-next-line no-new
-    new cdk.CfnCondition(stack, ResourceConstants.CONDITIONS.HasEnvironmentParameter, {
-      expression: cdk.Fn.conditionNot(cdk.Fn.conditionEquals(env, ResourceConstants.NONE)),
-    });
-    const useSSE = new cdk.CfnCondition(stack, ResourceConstants.CONDITIONS.ShouldUseServerSideEncryption, {
-      expression: cdk.Fn.conditionEquals(enableSSE, 'true'),
-    });
-    const usePayPerRequestBilling = new cdk.CfnCondition(stack, ResourceConstants.CONDITIONS.ShouldUsePayPerRequestBilling, {
-      expression: cdk.Fn.conditionEquals(billingMode, 'PAY_PER_REQUEST'),
-    });
-    const usePointInTimeRecovery = new cdk.CfnCondition(stack, 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(stack, 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;
-
-    // CDK started to append hash to logical id of dynamodb table.
-    // This line overrides that behavior to avoid deletion and re-creation of existing tables.
-    cfnTable.overrideLogicalId(tableLogicalName);
-
-    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)}`;
-    // eslint-disable-next-line no-new
-    new cdk.CfnOutput(stack, streamArnOutputId, {
-      value: cdk.Fn.getAtt(tableLogicalName, 'StreamArn').toString(),
-      description: 'Your DynamoDB table StreamArn.',
-      exportName: cdk.Fn.join(':', [context.api.apiId, 'GetAtt', tableLogicalName, 'StreamArn']),
-    });
-
-    const tableNameOutputId = `GetAtt${tableLogicalName}Name`;
-    // eslint-disable-next-line no-new
-    new cdk.CfnOutput(stack, tableNameOutputId, {
-      value: cdk.Fn.ref(tableLogicalName),
-      description: 'Your DynamoDB table name.',
-      exportName: cdk.Fn.join(':', [context.api.apiId, 'GetAtt', tableLogicalName, 'Name']),
-    });
-
-    const role = this.createIAMRole(context, def, stack, tableName);
-    const tableDataSourceLogicalName = `${def!.name.value}Table`;
-    this.createModelTableDataSource(def, context, table, stack, role, tableDataSourceLogicalName);
-  }
-
-  private createModelTableDataSource(
-    def: ObjectTypeDefinitionNode,
-    context: TransformerContextProvider,
-    table: Table,
-    stack: cdk.Stack,
-    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 },
-      stack,
-    );
-
-    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`;
-    // eslint-disable-next-line no-new
-    new cdk.CfnOutput(stack, 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, stack: cdk.Stack, tableName: string): iam.Role => {
-    const roleName = context.resourceHelper.generateIAMRoleName(ModelResourceIDs.ModelTableIAMRoleID(def!.name.value));
-    const role = new iam.Role(stack, ModelResourceIDs.ModelTableIAMRoleID(def!.name.value), {
-      roleName,
-      assumedBy: new iam.ServicePrincipal('appsync.amazonaws.com'),
-    });
-
-    const amplifyDataStoreTableName = context.resourceHelper.generateTableName(SyncResourceIDs.syncTableName);
-    role.attachInlinePolicy(
-      new iam.Policy(stack, '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, stack, syncConfig.LambdaConflictHandler.name, syncConfig.LambdaConflictHandler.region),
-      );
-    }
-
-    return role;
-  }
-
   ensureModelSortDirectionEnum = (ctx: TransformerValidationStepContextProvider): void => {
     if (!ctx.output.hasType('ModelSortDirection')) {
       const modelSortDirection = makeModelSortDirectionEnumObject();