@aws-amplify/graphql-model-transformer 1.4.0-rds.0 → 1.4.0

package/src/graphql-model-transformer.ts

@@ -28,12 +28,7 @@ import {
   TransformerTransformSchemaStepContextProvider,
   TransformerValidationStepContextProvider,
 } from '@aws-amplify/graphql-transformer-interfaces';
-import {
-  ITable,
-  StreamViewType,
-  Table,
-  TableEncryption,
-} from 'aws-cdk-lib/aws-dynamodb';
+import { ITable, StreamViewType, Table, TableEncryption } from 'aws-cdk-lib/aws-dynamodb';
 import * as iam from 'aws-cdk-lib/aws-iam';
 import * as cdk from 'aws-cdk-lib';
 import {
@@ -123,16 +118,24 @@ const DDB_DATASOURCE_TYPE = { dbType: DDB_DB_TYPE, provisioned: true };
  */
 export class ModelTransformer extends TransformerModelBase implements TransformerModelProvider {
   private options: ModelTransformerOptions;
+
   private datasourceMap: Record<string, DataSourceProvider> = {};
+
   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>()
+
+  private modelToDatasourceMap: Map<string, DatasourceType> = new Map<string, DatasourceType>();
+
   /**
    * A Map to hold the directive configuration
    */
   private modelDirectiveConfig: Map<string, ModelDirectiveConfiguration> = new Map();
+
   constructor(options: ModelTransformerOptions = {}) {
     super('amplify-model-transformer', directiveDefinition);
     this.options = this.getOptions(options);
@@ -162,9 +165,10 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
   };
 
   object = (definition: ObjectTypeDefinitionNode, directive: DirectiveNode, ctx: TransformerSchemaVisitStepContextProvider): void => {
-    const isTypeNameReserved = definition.name.value === ctx.output.getQueryTypeName()
-      || definition.name.value === ctx.output.getMutationTypeName()
-      || definition.name.value === ctx.output.getSubscriptionTypeName();
+    const isTypeNameReserved =
+      definition.name.value === ctx.output.getQueryTypeName() ||
+      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) {
@@ -180,31 +184,36 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     }
 
     const directiveWrapped: DirectiveWrapper = new DirectiveWrapper(directive);
-    const options = directiveWrapped.getArguments({
-      queries: {
-        get: getFieldNameFor('get', typeName),
-        list: getFieldNameFor('list', typeName),
-        ...(ctx.isProjectUsingDataStore() ? { sync: getFieldNameFor('sync', typeName) } : undefined),
-      },
-      mutations: {
-        create: getFieldNameFor('create', typeName),
-        update: getFieldNameFor('update', typeName),
-        delete: getFieldNameFor('delete', typeName),
-      },
-      subscriptions: {
-        level: SubscriptionLevel.on,
-        onCreate: [getFieldNameFor('onCreate', typeName)],
-        onDelete: [getFieldNameFor('onDelete', typeName)],
-        onUpdate: [getFieldNameFor('onUpdate', typeName)],
-      },
-      timestamps: isDynamoDB ? {
-        createdAt: 'createdAt',
-        updatedAt: 'updatedAt',
-      } : {
-        createdAt: undefined,
-        updatedAt: undefined,
+    const options = directiveWrapped.getArguments(
+      {
+        queries: {
+          get: getFieldNameFor('get', typeName),
+          list: getFieldNameFor('list', typeName),
+          ...(ctx.isProjectUsingDataStore() ? { sync: getFieldNameFor('sync', typeName) } : undefined),
+        },
+        mutations: {
+          create: getFieldNameFor('create', typeName),
+          update: getFieldNameFor('update', typeName),
+          delete: getFieldNameFor('delete', typeName),
+        },
+        subscriptions: {
+          level: SubscriptionLevel.on,
+          onCreate: [getFieldNameFor('onCreate', typeName)],
+          onDelete: [getFieldNameFor('onDelete', typeName)],
+          onUpdate: [getFieldNameFor('onUpdate', typeName)],
+        },
+        timestamps: isDynamoDB
+          ? {
+              createdAt: 'createdAt',
+              updatedAt: 'updatedAt',
+            }
+          : {
+              createdAt: undefined,
+              updatedAt: undefined,
+            },
       },
-    }, generateGetArgumentsInput(ctx.transformParameters));
+      generateGetArgumentsInput(ctx.transformParameters),
+    );
 
     // This property override is specifically to address parity between V1 and V2 when the FF is disabled
     // If one subscription is defined, just let the others go to null without FF. But if public and none defined, default all subs
@@ -224,8 +233,10 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
         },
         generateGetArgumentsInput(ctx.transformParameters),
       );
-      if (baseArgs?.subscriptions?.level === SubscriptionLevel.public
-        && !(baseArgs?.subscriptions?.onCreate || baseArgs?.subscriptions?.onDelete || baseArgs?.subscriptions?.onUpdate)) {
+      if (
+        baseArgs?.subscriptions?.level === SubscriptionLevel.public &&
+        !(baseArgs?.subscriptions?.onCreate || baseArgs?.subscriptions?.onDelete || baseArgs?.subscriptions?.onUpdate)
+      ) {
         options.subscriptions = { level: SubscriptionLevel.public, ...publicSubscriptionDefaults };
       }
     }
@@ -255,7 +266,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
   };
 
   prepare = (context: TransformerPrepareStepContextProvider): void => {
-    this.typesWithModelDirective.forEach(modelTypeName => {
+    this.typesWithModelDirective.forEach((modelTypeName) => {
       const type = context.output.getObject(modelTypeName);
       context.providerRegistry.registerDataSourceProvider(type!, this);
     });
@@ -266,9 +277,9 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     addModelConditionInputs(ctx);
 
     this.ensureModelSortDirectionEnum(ctx);
-    this.typesWithModelDirective.forEach(type => {
+    this.typesWithModelDirective.forEach((type) => {
       const def = ctx.output.getObject(type)!;
-      const hasAuth = def.directives!.some(dir => dir.name.value === 'auth');
+      const hasAuth = def.directives!.some((dir) => dir.name.value === 'auth');
 
       // add Non Model type inputs
       this.createNonModelInputs(ctx, def);
@@ -291,19 +302,19 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
         }
       }
       // global auth check
-      if (!hasAuth && ctx.sandboxModeEnabled && ctx.authConfig.defaultAuthentication.authenticationType !== 'API_KEY') {
+      if (!hasAuth && ctx.transformParameters.sandboxModeEnabled && ctx.authConfig.defaultAuthentication.authenticationType !== 'API_KEY') {
         const apiKeyDirArray = [makeDirective(API_KEY_DIRECTIVE, [])];
         extendTypeWithDirectives(ctx, def.name.value, apiKeyDirArray);
         propagateApiKeyToNestedTypes(ctx as TransformerContextProvider, def, new Set<string>());
-        queryFields.forEach(operationField => {
+        queryFields.forEach((operationField) => {
           const operationName = operationField.name.value;
           addDirectivesToOperation(ctx, ctx.output.getQueryTypeName()!, operationName, apiKeyDirArray);
         });
-        mutationFields.forEach(operationField => {
+        mutationFields.forEach((operationField) => {
           const operationName = operationField.name.value;
           addDirectivesToOperation(ctx, ctx.output.getMutationTypeName()!, operationName, apiKeyDirArray);
         });
-        subscriptionsFields.forEach(operationField => {
+        subscriptionsFields.forEach((operationField) => {
           const operationName = operationField.name.value;
           addDirectivesToOperation(ctx, ctx.output.getSubscriptionTypeName()!, operationName, apiKeyDirArray);
         });
@@ -373,14 +384,9 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     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,
-      );
+      return this.resourceGeneratorMap
+        .get(dbInfo.dbType)!
+        .generateUpdateResolver(ctx, type, modelDirectiveConfig, typeName, fieldName, resolverLogicalId);
     }
     throw new Error(`DB Type undefined or resource generator not provided for ${type.name.value}`);
   };
@@ -468,7 +474,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       [SubscriptionFieldType.ON_UPDATE]: MutationFieldType.UPDATE,
       [SubscriptionFieldType.ON_DELETE]: MutationFieldType.DELETE,
     };
-    const mutation = Array.from(mutationMap).find(m => m.type === mutationToSubscriptionTypeMap[subscriptionType]);
+    const mutation = Array.from(mutationMap).find((m) => m.type === mutationToSubscriptionTypeMap[subscriptionType]);
     if (mutation) {
       return mutation.fieldName;
     }
@@ -478,7 +484,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
   private createQueryFields = (ctx: TransformerValidationStepContextProvider, def: ObjectTypeDefinitionNode): FieldDefinitionNode[] => {
     const queryFields: FieldDefinitionNode[] = [];
     const queryFieldNames = this.getQueryFieldNames(def!);
-    queryFieldNames.forEach(queryField => {
+    queryFieldNames.forEach((queryField) => {
       const outputType = this.getOutputType(ctx, def, queryField);
       const args = this.getInputs(ctx, def!, {
         fieldName: queryField.fieldName,
@@ -494,7 +500,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
   private createMutationFields = (ctx: TransformerValidationStepContextProvider, def: ObjectTypeDefinitionNode): FieldDefinitionNode[] => {
     const mutationFields: FieldDefinitionNode[] = [];
     const mutationFieldNames = this.getMutationFieldNames(def!);
-    mutationFieldNames.forEach(mutationField => {
+    mutationFieldNames.forEach((mutationField) => {
       const args = this.getInputs(ctx, def!, {
         fieldName: mutationField.fieldName,
         typeName: mutationField.typeName,
@@ -516,19 +522,21 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
 
     const subscriptionFields: FieldDefinitionNode[] = [];
 
-    Object.keys(subscriptionToMutationsMap).forEach(subscriptionFieldName => {
+    Object.keys(subscriptionToMutationsMap).forEach((subscriptionFieldName) => {
       const maps = subscriptionToMutationsMap[subscriptionFieldName];
 
       const args: InputValueDefinitionNode[] = [];
-      maps.map(it => args.push(
-        ...this.getInputs(ctx, def!, {
-          fieldName: it.fieldName,
-          typeName: it.typeName,
-          type: it.type,
-        }),
-      ));
+      maps.map((it) =>
+        args.push(
+          ...this.getInputs(ctx, def!, {
+            fieldName: it.fieldName,
+            typeName: it.typeName,
+            type: it.type,
+          }),
+        ),
+      );
 
-      const mutationNames = maps.map(it => this.getMutationName(it.type, mutationFields));
+      const mutationNames = maps.map((it) => this.getMutationName(it.type, mutationFields));
 
       // Todo use directive wrapper to build the directive node
       const directive = makeDirective('aws_subscribe', [makeArgument('mutations', makeValueNode(mutationNames))]);
@@ -601,7 +609,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       const filterInputs = createEnumModelFilters(ctx, type);
       conditionInput = makeMutationConditionInput(ctx, conditionTypeName, type);
       filterInputs.push(conditionInput);
-      filterInputs.forEach(input => {
+      filterInputs.forEach((input) => {
         const conditionInputName = input.name.value;
         if (!ctx.output.getType(conditionInputName)) {
           ctx.output.addInput(input);
@@ -616,7 +624,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
         const filterInputName = toPascalCase(['Model', type.name.value, 'FilterInput']);
         const filterInputs = createEnumModelFilters(ctx, type);
         filterInputs.push(makeListQueryFilterInput(ctx, filterInputName, type));
-        filterInputs.forEach(input => {
+        filterInputs.forEach((input) => {
           const conditionInputName = input.name.value;
           if (!ctx.output.getType(conditionInputName)) {
             ctx.output.addInput(input);
@@ -694,16 +702,14 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
         const filterInputName = toPascalCase(['ModelSubscription', type.name.value, 'FilterInput']);
         const filterInputs = createEnumModelFilters(ctx, type);
         filterInputs.push(makeSubscriptionQueryFilterInput(ctx, filterInputName, type));
-        filterInputs.forEach(input => {
+        filterInputs.forEach((input) => {
           const conditionInputName = input.name.value;
           if (!ctx.output.getType(conditionInputName)) {
             ctx.output.addInput(input);
           }
         });
 
-        return [
-          makeInputValueDefinition('filter', makeNamedType(filterInputName)),
-        ];
+        return [makeInputValueDefinition('filter', makeNamedType(filterInputName))];
 
       default:
         throw new Error('Unknown operation type');
@@ -752,10 +758,10 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
   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 => {
+    (obj.fields ?? []).forEach((field) => {
       if (!isScalar(field.type)) {
         const def = ctx.output.getType(getBaseType(field.type));
         if (def && def.kind === 'ObjectTypeDefinition' && !this.isModelField(def.name.value)) {
@@ -770,7 +776,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     });
   };
 
-  private isModelField = (name: string): boolean => (!!this.typesWithModelDirective.has(name));
+  private isModelField = (name: string): boolean => !!this.typesWithModelDirective.has(name);
 
   private getNonModelInputObjectName = (name: string): string => `${toUpper(name)}Input`;
 
@@ -803,7 +809,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       }
     }
 
-    timestamps.forEach(fieldName => {
+    timestamps.forEach((fieldName) => {
       if (typeWrapper.hasField(fieldName)) {
         const field = typeWrapper.getField(fieldName);
         if (!['String', 'AWSDateTime'].includes(field.getTypeName())) {
@@ -838,7 +844,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
     const subscriptionToMutationsMap: { [subField: string]: { fieldName: string; typeName: string; type: SubscriptionFieldType }[] } = {};
     const subscriptionFieldNames = this.getSubscriptionFieldNames(def);
 
-    subscriptionFieldNames.forEach(subscriptionFieldName => {
+    subscriptionFieldNames.forEach((subscriptionFieldName) => {
       if (!subscriptionToMutationsMap[subscriptionFieldName.fieldName]) {
         subscriptionToMutationsMap[subscriptionFieldName.fieldName] = [];
       }
@@ -854,7 +860,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
 
       ctx.output.addEnum(modelSortDirection);
     }
-  }
+  };
 
   private getOptions = (options: ModelTransformerOptions): ModelTransformerOptions => ({
     EnableDeletionProtection: false,

package/src/graphql-types/common.ts

@@ -64,11 +64,11 @@ export const makeConditionFilterInput = (
   object: ObjectTypeDefinitionNode,
 ): InputObjectDefinitionWrapper => {
   const input = InputObjectDefinitionWrapper.create(name);
-  
-  addSimpleFieldsConditionsForListing(input, object, ctx)
+
+  addSimpleFieldsConditionsForListing(input, object, ctx);
   addListTypeConditions(input, name);
-  addNonListTypeConditions(input, name)
-  addDatastoreConditions(input, ctx)
+  addNonListTypeConditions(input, name);
+  addDatastoreConditions(input, ctx);
 
   return input;
 };
@@ -91,7 +91,7 @@ export const makeSubscriptionFilterInput = (
       const conditionTypeName = ModelResourceIDs.ModelFilterScalarInputTypeName(
         isEnumType ? 'String' : field.getTypeName(),
         !supportsConditions,
-        true
+        true,
       );
       const inputField = InputFieldWrapper.create(field.name, conditionTypeName, true);
       input.addField(inputField);
@@ -99,7 +99,7 @@ export const makeSubscriptionFilterInput = (
   }
 
   addListTypeConditions(input, name);
-  addDatastoreConditions(input, ctx)
+  addDatastoreConditions(input, ctx);
 
   return input;
 };
@@ -113,7 +113,7 @@ export const makeSubscriptionFilterInput = (
 const addSimpleFieldsConditionsForListing = (
   input: InputObjectDefinitionWrapper,
   object: ObjectTypeDefinitionNode,
-  ctx: TransformerTransformSchemaStepContextProvider
+  ctx: TransformerTransformSchemaStepContextProvider,
 ) => {
   const supportsConditions = true;
   const wrappedObject = new ObjectDefinitionWrapper(object);
@@ -121,16 +121,17 @@ const addSimpleFieldsConditionsForListing = (
   for (const field of wrappedObject.fields) {
     const fieldType = ctx.output.getType(field.getTypeName());
     const isEnumType = fieldType && fieldType.kind === Kind.ENUM_TYPE_DEFINITION;
-    
+
     if (field.isScalar() || isEnumType) {
-      const conditionTypeName = isEnumType && field.isList()
-        ? ModelResourceIDs.ModelFilterListInputTypeName(field.getTypeName(), !supportsConditions)
-        : ModelResourceIDs.ModelFilterScalarInputTypeName(field.getTypeName(), !supportsConditions);
+      const conditionTypeName =
+        isEnumType && field.isList()
+          ? ModelResourceIDs.ModelFilterListInputTypeName(field.getTypeName(), !supportsConditions)
+          : ModelResourceIDs.ModelFilterScalarInputTypeName(field.getTypeName(), !supportsConditions);
       const inputField = InputFieldWrapper.create(field.name, conditionTypeName, true);
       input.addField(inputField);
     }
   }
-}
+};
 
 /**
  * Make additional conditions of non-list type
@@ -139,10 +140,10 @@ const addSimpleFieldsConditionsForListing = (
  */
 const addNonListTypeConditions = (input: InputObjectDefinitionWrapper, name: string) => {
   for (const additionalField of ['not']) {
-    const inputField = InputFieldWrapper.create(additionalField, name, true, false);	
-    input.addField(inputField);	
+    const inputField = InputFieldWrapper.create(additionalField, name, true, false);
+    input.addField(inputField);
   }
-}
+};
 
 /**
  * Make additional conditions of list type
@@ -154,29 +155,24 @@ const addListTypeConditions = (input: InputObjectDefinitionWrapper, name: string
     const inputField = InputFieldWrapper.create(additionalField, name, true, true);
     input.addField(inputField);
   }
-}
+};
 
 /**
  * Make additional conditions for datastore-enabled apps
  * @param input output object
  * @param ctx TransformerContext
  */
-const addDatastoreConditions = (
-  input: InputObjectDefinitionWrapper,
-  ctx: TransformerTransformSchemaStepContextProvider
-) => {
+const addDatastoreConditions = (input: InputObjectDefinitionWrapper, ctx: TransformerTransformSchemaStepContextProvider) => {
   if (ctx.isProjectUsingDataStore()) {
-    const datastoreFields = [
-      {fieldName: '_deleted', typeName: STANDARD_SCALARS.Boolean}
-    ]
+    const datastoreFields = [{ fieldName: '_deleted', typeName: STANDARD_SCALARS.Boolean }];
 
-    for (const {fieldName, typeName} of datastoreFields) {
-      const type = ModelResourceIDs.ModelScalarFilterInputTypeName(typeName, false)
+    for (const { fieldName, typeName } of datastoreFields) {
+      const type = ModelResourceIDs.ModelScalarFilterInputTypeName(typeName, false);
       const inputField = InputFieldWrapper.create(fieldName, type, true, false);
       input.addField(inputField);
     }
   }
-}
+};
 
 /**
  * Generates the Subscription filter input type name
@@ -198,7 +194,7 @@ export const removeSubscriptionFilterInputAttribute = (
   }
   const newFilterType: InputObjectTypeDefinitionNode = {
     ...filterType,
-    fields: filterType.fields?.filter(field => field.name.value !== fieldName),
+    fields: filterType.fields?.filter((field) => field.name.value !== fieldName),
   };
   ctx.output.putType(newFilterType);
 };
@@ -207,11 +203,15 @@ export const removeSubscriptionFilterInputAttribute = (
  * Generates model condition input type
  */
 export const addModelConditionInputs = (ctx: TransformerTransformSchemaStepContextProvider): void => {
-  const conditionsInput: TypeDefinitionNode[] = ['String', 'Int', 'Float', 'Boolean', 'ID'].map(scalarName => makeModelScalarFilterInputObject(scalarName, true));
-  ['String', 'Int', 'Float', 'Boolean', 'ID'].map(scalarName => conditionsInput.push(makeModelScalarFilterInputObject(scalarName, true, true)));
+  const conditionsInput: TypeDefinitionNode[] = ['String', 'Int', 'Float', 'Boolean', 'ID'].map((scalarName) =>
+    makeModelScalarFilterInputObject(scalarName, true),
+  );
+  ['String', 'Int', 'Float', 'Boolean', 'ID'].map((scalarName) =>
+    conditionsInput.push(makeModelScalarFilterInputObject(scalarName, true, true)),
+  );
   conditionsInput.push(makeAttributeTypeEnum());
   conditionsInput.push(makeSizeInputType());
-  conditionsInput.forEach(input => {
+  conditionsInput.forEach((input) => {
     const inputName = input.name.value;
     if (!ctx.output.getType(inputName)) {
       ctx.output.addType(input);
@@ -241,13 +241,13 @@ export const createEnumModelFilters = (
 ): InputObjectTypeDefinitionNode[] => {
   // add enum type if present
   const typeWrapper = new ObjectDefinitionWrapper(type);
-  const enumFields = typeWrapper.fields.filter(field => {
+  const enumFields = typeWrapper.fields.filter((field) => {
     const typeName = field.getTypeName();
     const typeObj = ctx.output.getType(typeName);
     return typeObj && typeObj.kind === 'EnumTypeDefinition';
   });
 
-  return enumFields.map(field => makeEnumFilterInput(field));
+  return enumFields.map((field) => makeEnumFilterInput(field));
 };
 
 /**
@@ -281,7 +281,7 @@ export function makeModelScalarFilterInputObject(
   }
 
   if (!isSubscriptionFilter) {
-    makeFunctionInputFields(type).map(f => scalarConditionInput.addField(f));
+    makeFunctionInputFields(type).map((f) => scalarConditionInput.addField(f));
   }
 
   return scalarConditionInput.serialize();
@@ -398,13 +398,13 @@ export function makeEnumFilterInput(fieldWrapper: FieldWrapper): InputObjectType
     : ModelResourceIDs.ModelFilterScalarInputTypeName(fieldWrapper.getTypeName(), !supportsConditions);
 
   const input = InputObjectDefinitionWrapper.create(conditionTypeName);
-  ['eq', 'ne'].forEach(fieldName => {
+  ['eq', 'ne'].forEach((fieldName) => {
     const field = InputFieldWrapper.create(fieldName, fieldWrapper.getTypeName(), true, fieldWrapper.isList());
     input.addField(field);
   });
 
   if (fieldWrapper.isList()) {
-    ['contains', 'notContains'].forEach(fieldName => {
+    ['contains', 'notContains'].forEach((fieldName) => {
       const field = InputFieldWrapper.create(fieldName, fieldWrapper.getTypeName(), true);
       input.addField(field);
     });
@@ -423,9 +423,9 @@ export const addDirectivesToField = (
 ): void => {
   const type = ctx.output.getType(typeName) as ObjectTypeDefinitionNode;
   if (type) {
-    const field = type.fields?.find(f => f.name.value === fieldName);
+    const field = type.fields?.find((f) => f.name.value === fieldName);
     if (field) {
-      const newFields = [...type.fields!.filter(f => f.name.value !== field.name.value), extendFieldWithDirectives(field, directives)];
+      const newFields = [...type.fields!.filter((f) => f.name.value !== field.name.value), extendFieldWithDirectives(field, directives)];
 
       const newType = {
         ...type,
@@ -452,7 +452,7 @@ export const addDirectivesToOperation = (
   // add the directives to the result type of the operation
   const type = ctx.output.getType(typeName) as ObjectTypeDefinitionNode;
   if (type) {
-    const field = type.fields!.find(f => f.name.value === operationName);
+    const field = type.fields!.find((f) => f.name.value === operationName);
 
     if (field) {
       const returnFieldType = field.type as NamedTypeNode;
@@ -501,18 +501,18 @@ export const propagateApiKeyToNestedTypes = (
       if (fieldType.kind !== 'ObjectTypeDefinition') {
         return undefined;
       }
-      const typeModel = fieldType.directives!.find(dir => dir.name.value === 'model');
+      const typeModel = fieldType.directives!.find((dir) => dir.name.value === 'model');
       return typeModel !== undefined ? undefined : fieldType;
     }
     return fieldType;
   };
   const nonModelFieldTypes = def
-    .fields!.map(f => ctx.output.getType(getBaseType(f.type)) as TypeDefinitionNode)
+    .fields!.map((f) => ctx.output.getType(getBaseType(f.type)) as TypeDefinitionNode)
     .filter(nonModelTypePredicate);
   for (const nonModelFieldType of nonModelFieldTypes) {
     const nonModelName = nonModelFieldType.name.value;
     const hasSeenType = seenNonModelTypes.has(nonModelName);
-    const hasApiKey = nonModelFieldType.directives?.some(dir => dir.name.value === API_KEY_DIRECTIVE) ?? false;
+    const hasApiKey = nonModelFieldType.directives?.some((dir) => dir.name.value === API_KEY_DIRECTIVE) ?? false;
     if (!hasSeenType && !hasApiKey) {
       seenNonModelTypes.add(nonModelName);
       extendTypeWithDirectives(ctx, nonModelName, [makeDirective(API_KEY_DIRECTIVE, [])]);

package/src/graphql-types/mutation.ts

@@ -2,8 +2,8 @@ import { TransformerTransformSchemaStepContextProvider } from '@aws-amplify/grap
 import { DocumentNode, InputObjectTypeDefinitionNode, ObjectTypeDefinitionNode } from 'graphql';
 import { ModelResourceIDs, toPascalCase } from 'graphql-transformer-common';
 import { InputFieldWrapper, InputObjectDefinitionWrapper, ObjectDefinitionWrapper } from '@aws-amplify/graphql-transformer-core';
-import { makeConditionFilterInput } from './common';
 import { ModelDirectiveConfiguration } from '../directive';
+import { makeConditionFilterInput } from './common';
 
 /**
  * Generate input used for update mutation
@@ -24,36 +24,36 @@ export const makeUpdateInputField = (
   const name = toPascalCase(['Update', typeName, 'Input']);
   const hasIdField = objectWrapped.hasField('id');
   const fieldsToRemove = objectWrapped
-    .fields!.filter(field => {
+    .fields!.filter((field) => {
       if (knownModelTypes.has(field.getTypeName())) {
         return true;
       }
       return false;
     })
-    .map(field => field.name);
+    .map((field) => field.name);
 
   const objectTypeDefinition: ObjectTypeDefinitionNode = {
     ...obj,
-    fields: obj.fields?.filter(f => !fieldsToRemove.includes(f.name.value)),
+    fields: obj.fields?.filter((f) => !fieldsToRemove.includes(f.name.value)),
   };
 
   const input = InputObjectDefinitionWrapper.fromObject(name, objectTypeDefinition, document);
 
   // make all the fields optional
-  input.fields.forEach(f => f.makeNullable());
+  input.fields.forEach((f) => f.makeNullable());
 
   if (!hasIdField) {
     // Add id field and make it optional
     input.addField(InputFieldWrapper.create('id', 'ID', false));
   } else {
-    const idField = input.fields.find(f => f.name === 'id');
+    const idField = input.fields.find((f) => f.name === 'id');
     if (idField) {
       idField.makeNonNullable();
     }
   }
 
   // Make createdAt and updatedAt field Optionals if present
-  Object.values(modelDirectiveConfig?.timestamps || {}).forEach(timeStampFieldName => {
+  Object.values(modelDirectiveConfig?.timestamps || {}).forEach((timeStampFieldName) => {
     if (input.hasField(timeStampFieldName!)) {
       const timestampField = input.getField(timeStampFieldName!);
       if (['String', 'AWSDateTime'].includes(timestampField.getTypeName())) {
@@ -106,17 +106,17 @@ export const makeCreateInputField = (
 
   const hasIdField = objectWrapped.hasField('id');
   const fieldsToRemove = objectWrapped
-    .fields!.filter(field => {
+    .fields!.filter((field) => {
       if (knownModelTypes.has(field.getTypeName())) {
         return true;
       }
       return false;
     })
-    .map(field => field.name);
+    .map((field) => field.name);
 
   const objectTypeDefinition: ObjectTypeDefinitionNode = {
     ...obj,
-    fields: obj.fields?.filter(f => !fieldsToRemove.includes(f.name.value)),
+    fields: obj.fields?.filter((f) => !fieldsToRemove.includes(f.name.value)),
   };
 
   const input = InputObjectDefinitionWrapper.fromObject(name, objectTypeDefinition, document);
@@ -125,13 +125,13 @@ export const makeCreateInputField = (
   if (!hasIdField) {
     input.addField(InputFieldWrapper.create('id', 'ID', true));
   } else {
-    const idField = input.fields.find(f => f.name === 'id');
+    const idField = input.fields.find((f) => f.name === 'id');
     if (idField) {
       idField.makeNullable();
     }
   }
   // Make createdAt and updatedAt field Optionals if present
-  Object.values(modelDirectiveConfig?.timestamps || {}).forEach(timeStampFieldName => {
+  Object.values(modelDirectiveConfig?.timestamps || {}).forEach((timeStampFieldName) => {
     if (input.hasField(timeStampFieldName!)) {
       const timestampField = input.getField(timeStampFieldName!);
       if (['String', 'AWSDateTime'].includes(timestampField.getTypeName())) {
@@ -156,7 +156,7 @@ export const makeMutationConditionInput = (
   object: ObjectTypeDefinitionNode,
 ): InputObjectTypeDefinitionNode => {
   const input = makeConditionFilterInput(ctx, name, object);
-  const idField = input.fields.find(f => f.name === 'id' && f.getTypeName() === 'ModelIDInput');
+  const idField = input.fields.find((f) => f.name === 'id' && f.getTypeName() === 'ModelIDInput');
   if (idField) {
     input.removeField(idField);
   }

package/src/graphql-types/query.ts

@@ -2,6 +2,7 @@ import { TransformerTransformSchemaStepContextProvider } from '@aws-amplify/grap
 import { InputObjectTypeDefinitionNode, ObjectTypeDefinitionNode } from 'graphql';
 import { FieldWrapper, ObjectDefinitionWrapper } from '@aws-amplify/graphql-transformer-core';
 import { makeConditionFilterInput, makeSubscriptionFilterInput } from './common';
+
 export const makeListQueryFilterInput = (
   ctx: TransformerTransformSchemaStepContextProvider,
   name: string,

package/src/index.ts

@@ -3,3 +3,4 @@ export { ModelTransformer } from './graphql-model-transformer';
 export { OPERATION_KEY } from './definitions';
 export * from './graphql-types';
 export * from './resolvers';
+// No-op change to trigger publish