@aws-amplify/graphql-model-transformer 0.7.0-graphql-vnext-dev-preview.2 → 0.7.0-graphql-vnext-dev-preview.8

package/src/graphql-model-transformer.ts

@@ -1,4 +1,12 @@
-import { InvalidDirectiveError, MappingTemplate, SyncConfig, SyncUtils, TransformerModelBase } from '@aws-amplify/graphql-transformer-core';
+import {
+  DirectiveWrapper,
+  InvalidDirectiveError,
+  MappingTemplate,
+  SyncConfig,
+  SyncUtils,
+  TransformerModelBase,
+  TransformerNestedStack,
+} from '@aws-amplify/graphql-transformer-core';
 import {
   AppSyncDataSourceType,
   DataSourceInstance,
@@ -13,6 +21,7 @@ import {
   TransformerSchemaVisitStepContextProvider,
   TransformerTransformSchemaStepContextProvider,
   TransformerValidationStepContextProvider,
+  TransformerBeforeStepContextProvider,
 } from '@aws-amplify/graphql-transformer-interfaces';
 import { AttributeType, CfnTable, ITable, StreamViewType, Table, TableEncryption } from '@aws-cdk/aws-dynamodb';
 import * as iam from '@aws-cdk/aws-iam';
@@ -37,6 +46,7 @@ import {
   makeValueNode,
   ModelResourceIDs,
   plurality,
+  ResolverResourceIDs,
   ResourceConstants,
   SyncResourceIDs,
   toCamelCase,
@@ -71,12 +81,7 @@ 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';
 
@@ -164,6 +169,37 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     this.options = this.getOptions(options);
   }
 
+  before = (ctx: TransformerBeforeStepContextProvider) => {
+    // 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'],
+    });
+  };
+
   object = (definition: ObjectTypeDefinitionNode, directive: DirectiveNode, ctx: TransformerSchemaVisitStepContextProvider): void => {
     const isTypeNameReserved =
       definition.name.value === ctx.output.getQueryTypeName() ||
@@ -241,8 +277,6 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       this.addAutoGeneratableFields(ctx, type);
 
       if (ctx.isProjectUsingDataStore()) {
-        SyncUtils.validateResolverConfigForType(ctx, def!.name.value);
-        this.options.SyncConfig = SyncUtils.getSyncConfig(ctx, def!.name.value);
         this.addModelSyncFields(ctx, type);
       }
     }
@@ -262,13 +296,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');
@@ -289,13 +323,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');
@@ -319,13 +353,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');
@@ -349,6 +401,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];
@@ -357,6 +410,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`),
@@ -370,6 +424,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];
@@ -378,6 +433,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(
@@ -394,6 +450,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];
@@ -402,6 +459,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       const resolver = ctx.resolvers.generateMutationResolver(
         typeName,
         fieldName,
+        resolverLogicalId,
         dataSource,
         MappingTemplate.s3MappingTemplateFromString(
           generateUpdateRequestTemplate(typeName, isSyncEnabled),
@@ -429,6 +487,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];
@@ -437,6 +496,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(
@@ -453,12 +513,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`),
       );
@@ -470,12 +532,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`),
       );
@@ -487,12 +551,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`),
       );
@@ -504,6 +570,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];
@@ -512,6 +579,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(
@@ -526,15 +594,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),
       });
     }
 
@@ -543,6 +612,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
         typeName: 'Query',
         fieldName: modelDirectiveConfig.queries.list || toCamelCase(['list', typeName]),
         type: QueryFieldType.LIST,
+        resolverLogicalId: ResolverResourceIDs.DynamoDBListResolverResourceID(typeName),
       });
     }
 
@@ -551,6 +621,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
         typeName: 'Query',
         fieldName: modelDirectiveConfig.queries.sync || toCamelCase(['sync', typeName]),
         type: QueryFieldType.SYNC,
+        resolverLogicalId: ResolverResourceIDs.SyncResolverResourceID(typeName),
       });
     }
 
@@ -560,7 +631,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);
@@ -577,13 +648,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),
         });
       }
     }
@@ -597,6 +682,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       fieldName: string;
       typeName: string;
       type: MutationFieldType;
+      resolverLogicalId: string;
     }>,
   ): string => {
     const mutationToSubscriptionTypeMap = {
@@ -682,11 +768,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);
@@ -697,6 +785,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
             typeName: 'Subscription',
             fieldName: fieldName,
             type: SubscriptionFieldType.ON_CREATE,
+            resolverLogicalId: ResolverResourceIDs.ResolverResourceID('Subscription', fieldName),
           });
         }
       }
@@ -707,6 +796,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
             typeName: 'Subscription',
             fieldName: fieldName,
             type: SubscriptionFieldType.ON_UPDATE,
+            resolverLogicalId: ResolverResourceIDs.ResolverResourceID('Subscription', fieldName),
           });
         }
       }
@@ -717,6 +807,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
             typeName: 'Subscription',
             fieldName: fieldName,
             type: SubscriptionFieldType.ON_DELETE,
+            resolverLogicalId: ResolverResourceIDs.ResolverResourceID('Subscription', fieldName),
           });
         }
       }
@@ -739,6 +830,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];
@@ -747,6 +839,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(
@@ -1025,30 +1118,42 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       description: 'The number of read IOPS the table should support.',
       type: 'Number',
       default: 5,
-    }).valueAsString;
+    });
     const writeIops = new cdk.CfnParameter(stack, ResourceConstants.PARAMETERS.DynamoDBModelTableWriteIOPS, {
       description: 'The number of write IOPS the table should support.',
       type: 'Number',
       default: 5,
-    }).valueAsString;
+    });
     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'],
-    }).valueAsString;
+    });
     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'],
-    }).valueAsString;
+    });
     const enableSSE = new cdk.CfnParameter(stack, ResourceConstants.PARAMETERS.DynamoDBEnableServerSideEncryption, {
       description: 'Enable server side encryption powered by KMS.',
       type: 'String',
       default: 'true',
       allowedValues: ['true', 'false'],
-    }).valueAsString;
+    });
+    // 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
@@ -1207,13 +1312,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;

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/wrappers/object-definition-wrapper.ts

@@ -1,5 +1,5 @@
+import { DirectiveWrapper } from '@aws-amplify/graphql-transformer-core';
 import {
-  ArgumentNode,
   DirectiveNode,
   DocumentNode,
   EnumTypeDefinitionNode,
@@ -11,13 +11,10 @@ import {
   ListTypeNode,
   Location,
   NamedTypeNode,
-  NameNode,
   NonNullTypeNode,
   ObjectTypeDefinitionNode,
   StringValueNode,
   TypeNode,
-  valueFromASTUntyped,
-  ValueNode,
 } from 'graphql';
 import {
   DEFAULT_SCALARS,
@@ -29,53 +26,6 @@ import {
   withNamedNodeNamed,
 } from 'graphql-transformer-common';
 
-// Todo: to be moved to core later. context.output.getObject would return wrapper type so its easier to manipulate
-// objects
-
-export class ArgumentWrapper {
-  public readonly name: NameNode;
-  public readonly value: ValueNode;
-  constructor(argument: ArgumentNode) {
-    this.name = argument.name;
-    this.value = argument.value;
-  }
-  serialize = (): ArgumentNode => {
-    return {
-      kind: 'Argument',
-      name: this.name,
-      value: this.value,
-    };
-  };
-}
-
-export class DirectiveWrapper {
-  private arguments: ArgumentWrapper[] = [];
-  private name: NameNode;
-  private location?: Location;
-  constructor(node: DirectiveNode) {
-    this.name = node.name;
-    this.arguments = (node.arguments || []).map(arg => new ArgumentWrapper(arg));
-    this.location = this.location;
-  }
-  public serialize = (): DirectiveNode => {
-    return {
-      kind: 'Directive',
-      name: this.name,
-      arguments: this.arguments.map(arg => arg.serialize()),
-    };
-  };
-  public getArguments = <T>(defaultValue: Required<T>): Required<T> => {
-    const argValues = this.arguments.reduce(
-      (acc: Record<string, any>, arg: ArgumentWrapper) => ({
-        ...acc,
-        [arg.name.value]: valueFromASTUntyped(arg.value),
-      }),
-      {},
-    );
-    return Object.assign(defaultValue, argValues);
-  };
-}
-
 export class GenericFieldWrapper {
   protected type: TypeNode;
   public readonly directives: DirectiveWrapper[];
@@ -295,7 +245,7 @@ export class FieldWrapper extends GenericFieldWrapper {
       field.makeNonNullable();
     }
     if (isList) {
-      field.wrapListType();
+      field.wrapListType().makeNonNullable();
     }
     return field;
   };