@aws-amplify/graphql-model-transformer 0.7.0-auth-dir-v-next.3 → 0.7.0-ext12.0

package/src/__tests__/model-transformer.test.ts

@@ -13,6 +13,7 @@ import {
   verifyInputCount,
   verifyMatchingTypes,
 } from './test-utils/helpers';
+import { expect as cdkExpect, haveResource } from '@aws-cdk/assert';
 
 const featureFlags = {
   getBoolean: jest.fn(),
@@ -912,7 +913,7 @@ describe('ModelTransformer: ', () => {
     validateModelSchema(parse(definition));
   });
 
-  it('should generate sync resolver with ConflictHandlerType.Lambda', () => {
+  it('should generate sync resolver with ConflictHandlerType.LAMBDA', () => {
     const validSchema = `
       type Post @model {
           id: ID!
@@ -983,24 +984,109 @@ describe('ModelTransformer: ', () => {
     validateModelSchema(parse(definition));
   });
 
-  it('should support sandbox mode of api', async () => {
+  it('should generate iam role names under 64 chars and subscriptions under 50', () => {
     const validSchema = `
-      type AMPLIFY_GLOBAL @allow_public_data_access_with_api_key(in: "staging")
-
-      type Post @model {
+      type ThisIsAVeryLongNameModelThatShouldNotGenerateIAMRoleNamesOver64Characters @model {
           id: ID!
           title: String!
       }
     `;
 
+    const config: SyncConfig = {
+      ConflictDetection: 'VERSION',
+      ConflictHandler: ConflictHandlerType.AUTOMERGE,
+    };
+
     const transformer = new GraphQLTransform({
       transformers: [new ModelTransformer()],
       featureFlags,
+      transformConfig: {
+        ResolverConfig: {
+          project: config,
+        },
+      },
+    });
+    const out = transformer.transform(validSchema);
+    expect(out).toBeDefined();
+
+    const definition = out.schema;
+    expect(definition).toBeDefined();
+
+    const parsed = parse(definition);
+    const subscriptionType = getObjectType(parsed, 'Subscription');
+    expect(subscriptionType).toBeDefined();
+
+    subscriptionType!.fields!.forEach(it => {
+      expect(it.name.value.length <= 50).toBeTruthy();
+    });
+
+    const iamStackResource = out.stacks.ThisIsAVeryLongNameModelThatShouldNotGenerateIAMRoleNamesOver64Characters;
+    expect(iamStackResource).toBeDefined();
+    cdkExpect(iamStackResource).to(
+      haveResource('AWS::IAM::Role', {
+        AssumeRolePolicyDocument: {
+          Statement: [
+            {
+              Action: 'sts:AssumeRole',
+              Effect: 'Allow',
+              Principal: {
+                Service: 'appsync.amazonaws.com',
+              },
+            },
+          ],
+          Version: '2012-10-17',
+        },
+        RoleName: {
+          'Fn::Join': [
+            '',
+            [
+              'ThisIsAVeryLongNameM2d9fca-',
+              {
+                Ref: 'referencetotransformerrootstackGraphQLAPI20497F53ApiId',
+              },
+              '-',
+              {
+                Ref: 'referencetotransformerrootstackenv10C5A902Ref',
+              },
+            ],
+          ],
+        },
+      }),
+    );
+
+    validateModelSchema(parsed);
+  });
+
+  it('should generate the ID field when not specified', () => {
+    const validSchema = `type Todo @model {
+      name: String
+    }`;
+
+    const transformer = new GraphQLTransform({
+      transformers: [new ModelTransformer()],
     });
 
     const out = transformer.transform(validSchema);
     expect(out).toBeDefined();
 
-    parse(out.schema);
+    const definition = out.schema;
+    expect(definition).toBeDefined();
+
+    const parsed = parse(definition);
+    validateModelSchema(parsed);
+
+    const createTodoInput = getInputType(parsed, 'CreateTodoInput');
+    expect(createTodoInput).toBeDefined();
+
+    expectFieldsOnInputType(createTodoInput!, ['id', 'name']);
+
+    const idField = createTodoInput!.fields!.find(f => f.name.value === 'id');
+    expect((idField!.type as NamedTypeNode).name!.value).toEqual('ID');
+    expect((idField!.type as NamedTypeNode).kind).toEqual('NamedType');
+
+    const updateTodoInput = getInputType(parsed, 'UpdateTodoInput');
+    expect(updateTodoInput).toBeDefined();
+
+    expectFieldsOnInputType(updateTodoInput!, ['name']);
   });
 });

package/src/graphql-model-transformer.ts

@@ -1,4 +1,11 @@
-import { InvalidDirectiveError, MappingTemplate, SyncConfig, SyncUtils, TransformerModelBase } from '@aws-amplify/graphql-transformer-core';
+import {
+  DirectiveWrapper,
+  InvalidDirectiveError,
+  MappingTemplate,
+  SyncConfig,
+  SyncUtils,
+  TransformerModelBase,
+} from '@aws-amplify/graphql-transformer-core';
 import {
   AppSyncDataSourceType,
   DataSourceInstance,
@@ -37,6 +44,7 @@ import {
   makeValueNode,
   ModelResourceIDs,
   plurality,
+  ResolverResourceIDs,
   ResourceConstants,
   SyncResourceIDs,
   toCamelCase,
@@ -71,13 +79,9 @@ import {
   generateListRequestTemplate,
   generateSyncRequestTemplate,
 } from './resolvers/query';
-import {
-  DirectiveWrapper,
-  FieldWrapper,
-  InputObjectDefinitionWrapper,
-  ObjectDefinitionWrapper,
-} from './wrappers/object-definition-wrapper';
+import { FieldWrapper, InputObjectDefinitionWrapper, ObjectDefinitionWrapper } from './wrappers/object-definition-wrapper';
 import { CfnRole } from '@aws-cdk/aws-iam';
+import md5 from 'md5';
 
 export type Nullable<T> = T | null;
 export type OptionalAndNullable<T> = Partial<T>;
@@ -176,14 +180,17 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     }
     // todo: get model configuration with default values and store it in the map
     const typeName = definition.name.value;
+
+    if (ctx.isProjectUsingDataStore()) {
+      SyncUtils.validateResolverConfigForType(ctx, typeName);
+    }
+
     const directiveWrapped: DirectiveWrapper = new DirectiveWrapper(directive);
     const options = directiveWrapped.getArguments({
       queries: {
         get: toCamelCase(['get', typeName]),
         list: toCamelCase(['list', plurality(typeName, true)]),
-        ...((ctx as TransformerContextProvider).isProjectUsingDataStore()
-          ? { sync: toCamelCase(['sync', plurality(typeName, true)]) }
-          : undefined),
+        ...(ctx.isProjectUsingDataStore() ? { sync: toCamelCase(['sync', plurality(typeName, true)]) } : undefined),
       },
       mutations: {
         create: toCamelCase(['create', typeName]),
@@ -192,9 +199,9 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       },
       subscriptions: {
         level: SubscriptionLevel.on,
-        onCreate: [toCamelCase(['onCreate', typeName])],
-        onDelete: [toCamelCase(['onDelete', typeName])],
-        onUpdate: [toCamelCase(['onUpdate', typeName])],
+        onCreate: [this.ensureValidSubscriptionName(toCamelCase(['onCreate', typeName]))],
+        onDelete: [this.ensureValidSubscriptionName(toCamelCase(['onDelete', typeName]))],
+        onUpdate: [this.ensureValidSubscriptionName(toCamelCase(['onUpdate', typeName]))],
       },
       timestamps: {
         createdAt: 'createdAt',
@@ -237,7 +244,6 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       this.addAutoGeneratableFields(ctx, type);
 
       if (ctx.isProjectUsingDataStore()) {
-        this.options.SyncConfig = SyncUtils.getSyncConfig(ctx as TransformerContextProvider, def!.name.value);
         this.addModelSyncFields(ctx, type);
       }
     }
@@ -257,13 +263,13 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
         let resolver;
         switch (query.type) {
           case QueryFieldType.GET:
-            resolver = this.generateGetResolver(context, def!, query.typeName, query.fieldName);
+            resolver = this.generateGetResolver(context, def!, query.typeName, query.fieldName, query.resolverLogicalId);
             break;
           case QueryFieldType.LIST:
-            resolver = this.generateListResolver(context, def!, query.typeName, query.fieldName);
+            resolver = this.generateListResolver(context, def!, query.typeName, query.fieldName, query.resolverLogicalId);
             break;
           case QueryFieldType.SYNC:
-            resolver = this.generateSyncResolver(context, def!, query.typeName, query.fieldName);
+            resolver = this.generateSyncResolver(context, def!, query.typeName, query.fieldName, query.resolverLogicalId);
             break;
           default:
             throw new Error('Unknown query field type');
@@ -284,13 +290,13 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
         let resolver;
         switch (mutation.type) {
           case MutationFieldType.CREATE:
-            resolver = this.generateCreateResolver(context, def!, mutation.typeName, mutation.fieldName);
+            resolver = this.generateCreateResolver(context, def!, mutation.typeName, mutation.fieldName, mutation.resolverLogicalId);
             break;
           case MutationFieldType.DELETE:
-            resolver = this.generateDeleteResolver(context, def!, mutation.typeName, mutation.fieldName);
+            resolver = this.generateDeleteResolver(context, def!, mutation.typeName, mutation.fieldName, mutation.resolverLogicalId);
             break;
           case MutationFieldType.UPDATE:
-            resolver = this.generateUpdateResolver(context, def!, mutation.typeName, mutation.fieldName);
+            resolver = this.generateUpdateResolver(context, def!, mutation.typeName, mutation.fieldName, mutation.resolverLogicalId);
             break;
           default:
             throw new Error('Unknown mutation field type');
@@ -314,13 +320,31 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
           let resolver;
           switch (subscription.type) {
             case SubscriptionFieldType.ON_CREATE:
-              resolver = this.generateOnCreateResolver(context, def, subscription.typeName, subscription.fieldName);
+              resolver = this.generateOnCreateResolver(
+                context,
+                def,
+                subscription.typeName,
+                subscription.fieldName,
+                subscription.resolverLogicalId,
+              );
               break;
             case SubscriptionFieldType.ON_UPDATE:
-              resolver = this.generateOnUpdateResolver(context, def, subscription.typeName, subscription.fieldName);
+              resolver = this.generateOnUpdateResolver(
+                context,
+                def,
+                subscription.typeName,
+                subscription.fieldName,
+                subscription.resolverLogicalId,
+              );
               break;
             case SubscriptionFieldType.ON_DELETE:
-              resolver = this.generateOnDeleteResolver(context, def, subscription.typeName, subscription.fieldName);
+              resolver = this.generateOnDeleteResolver(
+                context,
+                def,
+                subscription.typeName,
+                subscription.fieldName,
+                subscription.resolverLogicalId,
+              );
               break;
             default:
               throw new Error('Unknown subscription field type');
@@ -344,6 +368,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     type: ObjectTypeDefinitionNode,
     typeName: string,
     fieldName: string,
+    resolverLogicalId: string,
   ): TransformerResolverProvider => {
     const isSyncEnabled = ctx.isProjectUsingDataStore();
     const dataSource = this.datasourceMap[type.name.value];
@@ -352,6 +377,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       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`),
@@ -365,6 +391,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     type: ObjectTypeDefinitionNode,
     typeName: string,
     fieldName: string,
+    resolverLogicalId: string,
   ): TransformerResolverProvider => {
     const isSyncEnabled = ctx.isProjectUsingDataStore();
     const dataSource = this.datasourceMap[type.name.value];
@@ -373,6 +400,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       this.resolverMap[resolverKey] = ctx.resolvers.generateQueryResolver(
         typeName,
         fieldName,
+        resolverLogicalId,
         dataSource,
         MappingTemplate.s3MappingTemplateFromString(generateListRequestTemplate(), `${typeName}.${fieldName}.req.vtl`),
         MappingTemplate.s3MappingTemplateFromString(
@@ -389,6 +417,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     type: ObjectTypeDefinitionNode,
     typeName: string,
     fieldName: string,
+    resolverLogicalId: string,
   ): TransformerResolverProvider => {
     const isSyncEnabled = ctx.isProjectUsingDataStore();
     const dataSource = this.datasourceMap[type.name.value];
@@ -397,6 +426,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       const resolver = ctx.resolvers.generateMutationResolver(
         typeName,
         fieldName,
+        resolverLogicalId,
         dataSource,
         MappingTemplate.s3MappingTemplateFromString(
           generateUpdateRequestTemplate(typeName, isSyncEnabled),
@@ -424,6 +454,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     type: ObjectTypeDefinitionNode,
     typeName: string,
     fieldName: string,
+    resolverLogicalId: string,
   ): TransformerResolverProvider => {
     const isSyncEnabled = ctx.isProjectUsingDataStore();
     const dataSource = this.datasourceMap[type.name.value];
@@ -432,6 +463,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       this.resolverMap[resolverKey] = ctx.resolvers.generateMutationResolver(
         typeName,
         fieldName,
+        resolverLogicalId,
         dataSource,
         MappingTemplate.s3MappingTemplateFromString(generateDeleteRequestTemplate(isSyncEnabled), `${typeName}.${fieldName}.req.vtl`),
         MappingTemplate.s3MappingTemplateFromString(
@@ -448,12 +480,14 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     type: ObjectTypeDefinitionNode,
     typeName: string,
     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`),
       );
@@ -465,12 +499,14 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     type: ObjectTypeDefinitionNode,
     typeName: string,
     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`),
       );
@@ -482,12 +518,14 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     type: ObjectTypeDefinitionNode,
     typeName: string,
     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`),
       );
@@ -499,6 +537,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     type: ObjectTypeDefinitionNode,
     typeName: string,
     fieldName: string,
+    resolverLogicalId: string,
   ): TransformerResolverProvider => {
     const isSyncEnabled = ctx.isProjectUsingDataStore();
     const dataSource = this.datasourceMap[type.name.value];
@@ -507,6 +546,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       this.resolverMap[resolverKey] = ctx.resolvers.generateQueryResolver(
         typeName,
         fieldName,
+        resolverLogicalId,
         dataSource,
         MappingTemplate.s3MappingTemplateFromString(generateSyncRequestTemplate(), `${typeName}.${fieldName}.req.vtl`),
         MappingTemplate.s3MappingTemplateFromString(
@@ -521,15 +561,16 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
   getQueryFieldNames = (
     ctx: TransformerTransformSchemaStepContextProvider,
     type: ObjectTypeDefinitionNode,
-  ): Set<{ fieldName: string; typeName: string; type: QueryFieldType }> => {
+  ): Set<{ fieldName: string; typeName: string; type: QueryFieldType; resolverLogicalId: string }> => {
     const typeName = type.name.value;
-    const fields: Set<{ fieldName: string; typeName: string; type: QueryFieldType }> = new Set();
+    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),
       });
     }
 
@@ -538,6 +579,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
         typeName: 'Query',
         fieldName: modelDirectiveConfig.queries.list || toCamelCase(['list', typeName]),
         type: QueryFieldType.LIST,
+        resolverLogicalId: ResolverResourceIDs.DynamoDBListResolverResourceID(typeName),
       });
     }
 
@@ -546,6 +588,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
         typeName: 'Query',
         fieldName: modelDirectiveConfig.queries.sync || toCamelCase(['sync', typeName]),
         type: QueryFieldType.SYNC,
+        resolverLogicalId: ResolverResourceIDs.SyncResolverResourceID(typeName),
       });
     }
 
@@ -555,7 +598,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
   getMutationFieldNames = (
     ctx: TransformerTransformSchemaStepContextProvider,
     type: ObjectTypeDefinitionNode,
-  ): Set<{ fieldName: string; typeName: string; type: MutationFieldType }> => {
+  ): 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);
@@ -572,13 +615,27 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       }
     };
 
-    const fieldNames: Set<{ fieldName: string; typeName: string; type: MutationFieldType }> = new Set();
+    const getMutationResolverLogicalId = (type: string): string => {
+      switch (type) {
+        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();
     for (let [mutationType, mutationName] of Object.entries(modelDirectiveConfig?.mutations || {})) {
       if (mutationName) {
         fieldNames.add({
           typeName: 'Mutation',
           fieldName: mutationName,
           type: getMutationType(mutationType),
+          resolverLogicalId: getMutationResolverLogicalId(mutationType),
         });
       }
     }
@@ -592,6 +649,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       fieldName: string;
       typeName: string;
       type: MutationFieldType;
+      resolverLogicalId: string;
     }>,
   ): string => {
     const mutationToSubscriptionTypeMap = {
@@ -677,11 +735,13 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     fieldName: string;
     typeName: string;
     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);
@@ -692,6 +752,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
             typeName: 'Subscription',
             fieldName: fieldName,
             type: SubscriptionFieldType.ON_CREATE,
+            resolverLogicalId: ModelResourceIDs.ModelOnCreateSubscriptionName(type.name.value),
           });
         }
       }
@@ -702,6 +763,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
             typeName: 'Subscription',
             fieldName: fieldName,
             type: SubscriptionFieldType.ON_UPDATE,
+            resolverLogicalId: ModelResourceIDs.ModelOnUpdateSubscriptionName(type.name.value),
           });
         }
       }
@@ -712,6 +774,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
             typeName: 'Subscription',
             fieldName: fieldName,
             type: SubscriptionFieldType.ON_DELETE,
+            resolverLogicalId: ModelResourceIDs.ModelOnDeleteSubscriptionName(type.name.value),
           });
         }
       }
@@ -734,6 +797,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     type: ObjectTypeDefinitionNode,
     typeName: string,
     fieldName: string,
+    resolverLogicalId: string,
   ): TransformerResolverProvider => {
     const isSyncEnabled = ctx.isProjectUsingDataStore();
     const dataSource = this.datasourceMap[type.name.value];
@@ -742,6 +806,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       const resolver = ctx.resolvers.generateMutationResolver(
         typeName,
         fieldName,
+        resolverLogicalId,
         dataSource,
         MappingTemplate.s3MappingTemplateFromString(generateCreateRequestTemplate(type.name.value), `${typeName}.${fieldName}.req.vtl`),
         MappingTemplate.s3MappingTemplateFromString(
@@ -1072,7 +1137,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       stream: StreamViewType.NEW_AND_OLD_IMAGES,
       encryption: TableEncryption.DEFAULT,
       removalPolicy: removalPolicy,
-      ...(this.options.SyncConfig ? { timeToLiveAttribute: '_ttl' } : undefined),
+      ...(context.isProjectUsingDataStore() ? { timeToLiveAttribute: '_ttl' } : undefined),
     });
     const cfnTable = table.node.defaultChild as CfnTable;
 
@@ -1128,8 +1193,9 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
 
     const cfnDataSource = dataSource.node.defaultChild as CfnDataSource;
     cfnDataSource.addDependsOn(role.node.defaultChild as CfnRole);
+    cfnDataSource.overrideLogicalId(datasourceRoleLogicalID);
 
-    if (this.options.SyncConfig) {
+    if (context.isProjectUsingDataStore()) {
       const datasourceDynamoDb = cfnDataSource.dynamoDbConfig as any;
       datasourceDynamoDb.deltaSyncConfig = {
         deltaSyncTableName: context.resourceHelper.generateResourceName(SyncResourceIDs.syncTableName),
@@ -1153,7 +1219,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
   }
 
   private createIAMRole(context: TransformerContextProvider, def: ObjectTypeDefinitionNode, stack: cdk.Stack, tableName: string) {
-    const roleName = context.resourceHelper.generateResourceName(ModelResourceIDs.ModelTableIAMRoleID(def!.name.value));
+    const roleName = context.resourceHelper.generateIAMRoleName(ModelResourceIDs.ModelTableIAMRoleID(def!.name.value));
     const role = new iam.Role(stack, ModelResourceIDs.ModelTableIAMRoleID(def!.name.value), {
       roleName: roleName,
       assumedBy: new iam.ServicePrincipal('appsync.amazonaws.com'),
@@ -1184,7 +1250,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
               cdk.Fn.sub('arn:aws:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tablename}/*', {
                 tablename: tableName,
               }),
-              ...(this.options.SyncConfig
+              ...(context.isProjectUsingDataStore()
                 ? [
                     // eslint-disable-next-line no-template-curly-in-string
                     cdk.Fn.sub('arn:aws:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tablename}', {
@@ -1202,13 +1268,10 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       }),
     );
 
-    if (this.options.SyncConfig && SyncUtils.isLambdaSyncConfig(this.options.SyncConfig)) {
+    const syncConfig = SyncUtils.getSyncConfig(context, def!.name.value);
+    if (syncConfig && SyncUtils.isLambdaSyncConfig(syncConfig)) {
       role.attachInlinePolicy(
-        SyncUtils.createSyncLambdaIAMPolicy(
-          stack,
-          this.options.SyncConfig.LambdaConflictHandler.name,
-          this.options.SyncConfig.LambdaConflictHandler.region,
-        ),
+        SyncUtils.createSyncLambdaIAMPolicy(stack, syncConfig.LambdaConflictHandler.name, syncConfig.LambdaConflictHandler.region),
       );
     }
     return role;
@@ -1228,4 +1291,10 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       ...options,
     };
   };
+
+  private ensureValidSubscriptionName = (name: string): string => {
+    if (name.length <= 50) return name;
+
+    return name.slice(0, 45) + md5(name).slice(0, 5);
+  };
 }

package/src/graphql-types/mutation.ts

@@ -45,9 +45,7 @@ export const makeUpdateInputField = (
   input.fields.forEach(f => f.makeNullable());
 
   // Add id field and make it optional
-  if (!hasIdField) {
-    input.addField(InputFieldWrapper.create('id', 'ID', false));
-  } else {
+  if (hasIdField) {
     const idField = input.fields.find(f => f.name === 'id');
     if (idField) {
       idField.makeNonNullable();
@@ -127,7 +125,7 @@ export const makeCreateInputField = (
 
   // Add id field and make it optional
   if (!hasIdField) {
-    input.addField(InputFieldWrapper.create('id', 'ID'));
+    input.addField(InputFieldWrapper.create('id', 'ID', true));
   } else {
     const idField = input.fields.find(f => f.name === 'id');
     if (idField) {

package/src/graphql-types/query.ts

@@ -13,7 +13,7 @@ export const makeListQueryFilterInput = (
 export const makeListQueryModel = (type: ObjectTypeDefinitionNode, modelName: string, isSyncEnabled: boolean): ObjectTypeDefinitionNode => {
   const outputType = ObjectDefinitionWrapper.create(modelName);
 
-  outputType.addField(FieldWrapper.create('items', type.name.value, true, true));
+  outputType.addField(FieldWrapper.create('items', type.name.value, false, true));
   outputType.addField(FieldWrapper.create('nextToken', 'String', true, false));
 
   if (isSyncEnabled) {

package/src/resolvers/common.ts

@@ -99,13 +99,13 @@ export const generateResolverKey = (typeName: string, fieldName: string): string
  * @param ctx context to get sandbox mode
  */
 export const generateAuthExpressionForSandboxMode = (ctx: any): string => {
-  let enabled = ctx.resourceHelper.api.globalSandboxModeEnabled;
+  const enabled = ctx.resourceHelper.api.sandboxModeEnabled;
   let exp;
 
   if (enabled) exp = iff(notEquals(methodCall(ref('util.authType')), str(API_KEY)), methodCall(ref('util.unauthorized')));
   else exp = methodCall(ref('util.unauthorized'));
 
   return printBlock(`Sandbox Mode ${enabled ? 'Enabled' : 'Disabled'}`)(
-    compoundExpression([iff(not(ref('ctx.stash.get("hasAuth")')), exp)]),
+    compoundExpression([iff(not(ref('ctx.stash.get("hasAuth")')), exp), toJson(obj({}))]),
   );
 };

package/src/resolvers/mutation.ts

@@ -152,8 +152,6 @@ export const generateUpdateRequestTemplate = (modelName: string, isSyncEnabled:
  */
 export const generateCreateRequestTemplate = (modelName: string): string => {
   const statements: Expression[] = [
-    // set key the condition
-    ...generateKeyConditionTemplate(false),
     // Generate conditions
     comment('Set the default values to put request'),
     set(ref('mergedValues'), methodCall(ref('util.defaultIfNull'), ref('ctx.stash.defaultValues'), obj({}))),
@@ -174,7 +172,6 @@ export const generateCreateRequestTemplate = (modelName: string): string => {
     ),
 
     // add conditions
-
     iff(ref('context.args.condition'), qref(methodCall(ref('ctx.stash.conditions.add'), ref('context.args.condition')))),
     // key conditions
     ...generateKeyConditionTemplate(false),