fix(graphql-model-transformer): fixed @model scalar types model filter input generation

packages/amplify-e2e-tests/src/__tests__/container-hosting.test.ts

@@ -21,7 +21,7 @@ describe('amplify add hosting - container', () => {
     await initJSProjectWithProfile(projRoot, {});
     await amplifyConfigureProject({
       cwd: projRoot,
-      enableContainers: true
+      enableContainers: true,
     });
     // TODO: This needs attention. Need to force circle ci to run this test in us-east-1
     // await addDevContainerHosting(projRoot);

packages/amplify-graphql-index-transformer/src/schema.ts

@@ -380,7 +380,6 @@ function generateFilterInputs(config: IndexDirectiveConfiguration, ctx: Transfor
 function makeModelXFilterInputObject(config: IndexDirectiveConfiguration, ctx: TransformerContextProvider): InputObjectTypeDefinitionNode {
   const { object } = config;
   const name = ModelResourceIDs.ModelFilterInputTypeName(object.name.value);
-  const supportsConditions = true;
   const fields = object
     .fields!.filter((field: FieldDefinitionNode) => {
       const fieldType = ctx.output.getType(getBaseType(field.type));
@@ -389,13 +388,14 @@ function makeModelXFilterInputObject(config: IndexDirectiveConfiguration, ctx: T
     })
     .map((field: FieldDefinitionNode) => {
       const baseType = getBaseType(field.type);
-      const fieldType = ctx.output.getType(baseType);
       const isList = isListType(field.type);
-      const isEnumType = fieldType && fieldType.kind === Kind.ENUM_TYPE_DEFINITION;
-      const filterTypeName =
-        isEnumType && isList
-          ? ModelResourceIDs.ModelFilterListInputTypeName(baseType, !supportsConditions)
-          : ModelResourceIDs.ModelScalarFilterInputTypeName(baseType, !supportsConditions);
+      let filterTypeName = baseType;
+
+      if (isScalar(field.type) || isList) {
+        filterTypeName = isList
+          ? ModelResourceIDs.ModelFilterListInputTypeName(baseType, true)
+          : ModelResourceIDs.ModelScalarFilterInputTypeName(baseType, true);
+      }
 
       return {
         kind: Kind.INPUT_VALUE_DEFINITION,

packages/amplify-graphql-model-transformer/src/__tests__/model-transformer.test.ts

@@ -10,6 +10,7 @@ import {
   getFieldOnObjectType,
   getInputType,
   getObjectType,
+  verifyInputCount,
   verifyMatchingTypes,
 } from './test-utils/helpers';
 
@@ -412,6 +413,63 @@ describe('ModelTransformer: ', () => {
     expect(result.pipelineFunctions['Mutation.createPost.req.vtl']).toMatchSnapshot();
   });
 
+  it('support schema with multiple model directives', () => {
+    const validSchema = `
+      type Post @model {
+          id: ID!
+          title: String!
+          createdAt: String
+          updatedAt: String
+      }
+
+      type User @model {
+          id: ID!
+          name: String!
+
+      }
+    `;
+    const transformer = new GraphQLTransform({
+      transformers: [new ModelTransformer()],
+      featureFlags,
+    });
+
+    const out = transformer.transform(validSchema);
+    expect(out).toBeDefined();
+
+    const definition = out.schema;
+    expect(definition).toBeDefined();
+    const parsed = parse(definition);
+    validateModelSchema(parsed);
+
+    const queryType = getObjectType(parsed, 'Query');
+    expect(queryType).toBeDefined();
+    expectFields(queryType!, ['listPosts']);
+    expectFields(queryType!, ['listUsers']);
+
+    const stringInputType = getInputType(parsed, 'ModelStringFilterInput');
+    expect(stringInputType).toBeDefined();
+    const booleanInputType = getInputType(parsed, 'ModelBooleanFilterInput');
+    expect(booleanInputType).toBeDefined();
+    const intInputType = getInputType(parsed, 'ModelIntFilterInput');
+    expect(intInputType).toBeDefined();
+    const floatInputType = getInputType(parsed, 'ModelFloatFilterInput');
+    expect(floatInputType).toBeDefined();
+    const idInputType = getInputType(parsed, 'ModelIDFilterInput');
+    expect(idInputType).toBeDefined();
+    const postInputType = getInputType(parsed, 'ModelPostFilterInput');
+    expect(postInputType).toBeDefined();
+    const userInputType = getInputType(parsed, 'ModelUserFilterInput');
+    expect(userInputType).toBeDefined();
+
+    expect(verifyInputCount(parsed, 'ModelStringFilterInput', 1)).toBeTruthy();
+    expect(verifyInputCount(parsed, 'ModelBooleanFilterInput', 1)).toBeTruthy();
+    expect(verifyInputCount(parsed, 'ModelIntFilterInput', 1)).toBeTruthy();
+    expect(verifyInputCount(parsed, 'ModelFloatFilterInput', 1)).toBeTruthy();
+    expect(verifyInputCount(parsed, 'ModelIDFilterInput', 1)).toBeTruthy();
+    expect(verifyInputCount(parsed, 'ModelPostFilterInput', 1)).toBeTruthy();
+    expect(verifyInputCount(parsed, 'ModelUserFilterInput', 1)).toBeTruthy();
+  });
+
   it('should support enum as a field', () => {
     const validSchema = `
       enum Status { DELIVERED IN_TRANSIT PENDING UNKNOWN }
@@ -438,4 +496,60 @@ describe('ModelTransformer: ', () => {
     const updateTestInput = getInputType(parsed, 'CreateTestInput');
     expectFieldsOnInputType(updateTestInput!, ['status', 'lastStatus']);
   });
+
+  it('should support non-model types and enums', () => {
+    const validSchema = `
+      type Post @model {
+          id: ID!
+          title: String!
+          createdAt: String
+          updatedAt: String
+          metadata: [PostMetadata!]!
+          appearsIn: [Episode]!
+      }
+      type PostMetadata {
+          tags: Tag
+      }
+      type Tag {
+          published: Boolean
+          metadata: PostMetadata
+      }
+      enum Episode {
+          NEWHOPE
+          EMPIRE
+          JEDI
+      }
+    `;
+    const transformer = new GraphQLTransform({
+      transformers: [new ModelTransformer()],
+      featureFlags,
+    });
+    const out = transformer.transform(validSchema);
+    expect(out).toBeDefined();
+
+    const definition = out.schema;
+    expect(definition).toBeDefined();
+    const parsed = parse(definition);
+    validateModelSchema(parsed);
+
+    const postMetaDataInputType = getInputType(parsed, 'PostMetadataInput');
+    expect(postMetaDataInputType).toBeDefined();
+    const tagInputType = getInputType(parsed, 'TagInput');
+    expect(tagInputType).toBeDefined();
+    expectFieldsOnInputType(tagInputType!, ['metadata']);
+    const createPostInputType = getInputType(parsed, 'CreatePostInput');
+    expectFieldsOnInputType(createPostInputType!, ['metadata', 'appearsIn']);
+    const updatePostInputType = getInputType(parsed, 'UpdatePostInput');
+    expectFieldsOnInputType(updatePostInputType!, ['metadata', 'appearsIn']);
+
+    const postModelObject = getObjectType(parsed, 'Post');
+    const postMetaDataInputField = getFieldOnInputType(createPostInputType!, 'metadata');
+    const postMetaDataField = getFieldOnObjectType(postModelObject!, 'metadata');
+    // this checks that the non-model type was properly "unwrapped", renamed, and "rewrapped"
+    // in the generated CreatePostInput type - its types should be the same as in the Post @model type
+    verifyMatchingTypes(postMetaDataInputField.type, postMetaDataField.type);
+
+    expect(verifyInputCount(parsed, 'PostMetadataInput', 1)).toBeTruthy();
+    expect(verifyInputCount(parsed, 'TagInput', 1)).toBeTruthy();
+  });
 });

packages/amplify-graphql-model-transformer/src/graphql-model-transformer.ts

@@ -864,6 +864,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
           if (!ctx.output.getType(name)) {
             const inputObj = InputObjectDefinitionWrapper.fromObject(name, def, ctx.inputDocument);
             ctx.output.addInput(inputObj.serialize());
+            this.createNonModelInputs(ctx, def);
           }
         }
       }

packages/amplify-graphql-model-transformer/src/graphql-types/common.ts

@@ -13,6 +13,7 @@ import {
   makeField,
   makeNamedType,
   makeValueNode,
+  ModelResourceIDs,
   toPascalCase,
 } from 'graphql-transformer-common';
 import {
@@ -52,11 +53,14 @@ export const makeConditionFilterInput = (
   for (let field of wrappedObject.fields) {
     const fieldType = ctx.output.getType(field.getTypeName());
     const isEnumType = fieldType && fieldType.kind === 'EnumTypeDefinition';
-    if (field.isScalar() || isEnumType) {
-      const fieldTypeName = field.getTypeName();
-      const nameOverride = DEFAULT_SCALARS[fieldTypeName] || fieldTypeName;
-      const conditionTypeName = isEnumType && field.isList() ? `Model${nameOverride}ListInput` : `Model${nameOverride}Input`;
-      const inputField = InputFieldWrapper.create(field.name, conditionTypeName, true);
+    if (field.isScalar() || field.isList()) {
+      const conditionTypeName = field.isList()
+        ? ModelResourceIDs.ModelFilterListInputTypeName(field.getTypeName(), true)
+        : ModelResourceIDs.ModelFilterScalarInputTypeName(field.getTypeName(), true);
+      const inputField = InputFieldWrapper.create(field.name, conditionTypeName, true, field.isList());
+      input.addField(inputField);
+    } else if (isEnumType) {
+      const inputField = InputFieldWrapper.create(field.name, field.getTypeName(), true, field.isList());
       input.addField(inputField);
     }
   }
@@ -76,7 +80,7 @@ export const makeConditionFilterInput = (
 
 export const addModelConditionInputs = (ctx: TransformerTransformSchemaStepContextProvider): void => {
   const conditionsInput: TypeDefinitionNode[] = ['String', 'Int', 'Float', 'Boolean', 'ID'].map(scalarName =>
-    makeModelScalarFilterInputObject(scalarName, true),
+    makeModelScalarFilterInputObject(scalarName, false),
   );
   conditionsInput.push(makeAttributeTypeEnum());
   conditionsInput.push(makeSizeInputType());
@@ -90,7 +94,7 @@ export const addModelConditionInputs = (ctx: TransformerTransformSchemaStepConte
 
 /**
  *
- * @param typeName Name of the scarlar type
+ * @param typeName Name of the scalar type
  * @param includeFilter add filter suffix to input
  */
 export function generateModelScalarFilterInputName(typeName: string, includeFilter: boolean): string {
@@ -100,6 +104,7 @@ export function generateModelScalarFilterInputName(typeName: string, includeFilt
   }
   return `Model${typeName}${includeFilter ? 'Filter' : ''}Input`;
 }
+
 export const createEnumModelFilters = (
   ctx: TransformerTransformSchemaStepContextProvider,
   type: ObjectTypeDefinitionNode,