@aws-amplify/graphql-model-transformer 2.1.3-jsii-build.1 → 2.2.0-rds-2.0

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

@@ -0,0 +1,1630 @@
+import { ModelTransformer } from '@aws-amplify/graphql-model-transformer';
+import { ConflictHandlerType, DatasourceType, GraphQLTransform, validateModelSchema } from '@aws-amplify/graphql-transformer-core';
+import { InputObjectTypeDefinitionNode, InputValueDefinitionNode, NamedTypeNode, parse } from 'graphql';
+import { getBaseType } from 'graphql-transformer-common';
+import { Template } from 'aws-cdk-lib/assertions';
+import { testTransform } from '@aws-amplify/graphql-transformer-test-utils';
+import {
+  doNotExpectFields,
+  expectFields,
+  expectFieldsOnInputType,
+  getFieldOnInputType,
+  getFieldOnObjectType,
+  getInputType,
+  getObjectType,
+  verifyInputCount,
+  verifyMatchingTypes,
+} from './test-utils/helpers';
+import { VpcSubnetConfig } from '@aws-amplify/graphql-transformer-interfaces';
+
+describe('ModelTransformer:', () => {
+  it('should successfully transform simple valid schema', async () => {
+    const validSchema = `
+      type Post @model {
+          id: ID!
+          title: String!
+      }
+    `;
+
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    expect(out).toBeDefined();
+
+    validateModelSchema(parse(out.schema));
+    parse(out.schema);
+  });
+
+  // should successfully transform simple Embeddable type (non-model) schema
+  it('should successfully transform simple Embeddable type (non-model) schema', async () => {
+    const validSchema = `
+      type NonModelType {
+          id: ID!
+          title: String!
+      }
+      `;
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    expect(out).toBeDefined();
+
+    validateModelSchema(parse(out.schema));
+    parse(out.schema);
+    expect(out.schema).toMatchSnapshot();
+  });
+  // should successfully transform simple non-capitalized Embeddable type (non-model) name schema
+  it('should successfully transform simple non-capitalized Model/Embeddable type (non-model) name schema', async () => {
+    const alsoValidSchema = `
+      type modelType @model {
+          id: ID!
+          title: String!
+          nonModelTypeValue: nonModelType
+      }
+      type nonModelType {
+          id: ID!
+          title: String!
+      }
+      `;
+    const out = testTransform({
+      schema: alsoValidSchema,
+      transformers: [new ModelTransformer()],
+      resolverConfig: {
+        project: {
+          ConflictDetection: 'VERSION',
+          ConflictHandler: ConflictHandlerType.AUTOMERGE,
+        },
+      },
+    });
+    expect(out).toBeDefined();
+
+    validateModelSchema(parse(out.schema));
+    parse(out.schema);
+    expect(out.schema).toMatchSnapshot();
+    expect(out.schema).toContain('input NonModelTypeInput');
+  });
+
+  it('id with non string type should require the field on create mutation', async () => {
+    const validSchema = `
+      type Task @model {
+          id: Int!
+          title: String!
+      }
+      `;
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    expect(out).toBeDefined();
+
+    validateModelSchema(parse(out.schema));
+    const schema = parse(out.schema);
+    expect(out.schema).toMatchSnapshot();
+    const createTaskInput = getInputType(schema, 'CreateTaskInput');
+    expectFieldsOnInputType(createTaskInput!, ['id', 'title']);
+    const idField = createTaskInput!.fields!.find((f) => f.name.value === 'id');
+    expect(idField).toBeDefined();
+    expect(idField?.type.kind).toEqual('NonNullType');
+  });
+
+  it('should support custom query overrides', () => {
+    const validSchema = `type Post @model(queries: { get: "customGetPost", list: "customListPost" }) {
+          id: ID!
+          title: String!
+          createdAt: String
+          updatedAt: String
+      }
+    `;
+
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    expect(out).toBeDefined();
+
+    const definition = out.schema;
+    expect(definition).toBeDefined();
+
+    const parsed = parse(definition);
+    validateModelSchema(parsed);
+    const createPostInput = getInputType(parsed, 'CreatePostInput');
+    expect(createPostInput).toBeDefined();
+
+    expectFieldsOnInputType(createPostInput!, ['id', 'title', 'createdAt', 'updatedAt']);
+
+    // This id should always be optional.
+    // aka a named type node aka name.value would not be set if it were a non null node
+    const idField = createPostInput!.fields!.find((f) => f.name.value === 'id');
+    expect((idField!.type as NamedTypeNode).name!.value).toEqual('ID');
+    const queryType = getObjectType(parsed, 'Query');
+    expect(queryType).toBeDefined();
+    expectFields(queryType!, ['customGetPost']);
+    expectFields(queryType!, ['customListPost']);
+    const subscriptionType = getObjectType(parsed, 'Subscription');
+    expect(subscriptionType).toBeDefined();
+    expectFields(subscriptionType!, ['onCreatePost', 'onUpdatePost', 'onDeletePost']);
+    const subField = subscriptionType!.fields!.find((f) => f.name.value === 'onCreatePost');
+    expect(subField).toBeDefined();
+    expect(subField!.directives!.length).toEqual(1);
+    expect(subField!.directives![0].name!.value).toEqual('aws_subscribe');
+  });
+
+  it('should support custom mutations overrides', () => {
+    const validSchema = `type Post @model(mutations: { create: "customCreatePost", update: "customUpdatePost", delete: "customDeletePost" }) {
+        id: ID!
+        title: String!
+        createdAt: String
+        updatedAt: String
+      }
+    `;
+
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    expect(out).toBeDefined();
+    const definition = out.schema;
+    expect(definition).toBeDefined();
+    const parsedDefinition = parse(definition);
+    validateModelSchema(parsedDefinition);
+    const mutationType = getObjectType(parsedDefinition, 'Mutation');
+    expect(mutationType).toBeDefined();
+    expectFields(mutationType!, ['customCreatePost', 'customUpdatePost', 'customDeletePost']);
+  });
+
+  it('should not generate mutations when mutations are set to null', () => {
+    const validSchema = `type Post @model(mutations: null) {
+            id: ID!
+            title: String!
+            createdAt: String
+            updatedAt: String
+        }
+        `;
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    expect(out).toBeDefined();
+    const definition = out.schema;
+    expect(definition).toBeDefined();
+    const parsed = parse(definition);
+    validateModelSchema(parsed);
+    const mutationType = getObjectType(parsed, 'Mutation');
+    expect(mutationType).not.toBeDefined();
+  });
+
+  it('should not generate queries when queries are set to null', () => {
+    const validSchema = `type Post @model(queries: null) {
+        id: ID!
+        title: String!
+        createdAt: String
+        updatedAt: String
+      }
+    `;
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    expect(out).toBeDefined();
+    const definition = out.schema;
+    expect(definition).toBeDefined();
+    const parsed = parse(definition);
+    validateModelSchema(parsed);
+    const mutationType = getObjectType(parsed, 'Mutation');
+    expect(mutationType).toBeDefined();
+    const queryType = getObjectType(parsed, 'Query');
+    expect(queryType).not.toBeDefined();
+  });
+
+  it('should not generate subscriptions with subscriptions are set to null', () => {
+    const validSchema = `type Post @model(subscriptions: null) {
+        id: ID!
+        title: String!
+        createdAt: String
+        updatedAt: String
+      }
+    `;
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    expect(out).toBeDefined();
+    const definition = out.schema;
+    expect(definition).toBeDefined();
+    const parsed = parse(definition);
+    validateModelSchema(parsed);
+    const mutationType = getObjectType(parsed, 'Mutation');
+    expect(mutationType).toBeDefined();
+    const queryType = getObjectType(parsed, 'Query');
+    expect(queryType).toBeDefined();
+    const subscriptionType = getObjectType(parsed, 'Subscription');
+    expect(subscriptionType).not.toBeDefined();
+  });
+
+  it('should not generate subscriptions, mutations or queries when subscriptions, queries and mutations set to null', () => {
+    const validSchema = `type Post @model(queries: null, mutations: null, subscriptions: null) {
+            id: ID!
+            title: String!
+            createdAt: String
+            updatedAt: String
+        }
+        `;
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    expect(out).toBeDefined();
+    const definition = out.schema;
+    expect(definition).toBeDefined();
+    const parsed = parse(definition);
+    validateModelSchema(parsed);
+    const mutationType = getObjectType(parsed, 'Mutation');
+    expect(mutationType).not.toBeDefined();
+    const queryType = getObjectType(parsed, 'Query');
+    expect(queryType).not.toBeDefined();
+    const subscriptionType = getObjectType(parsed, 'Subscription');
+    expect(subscriptionType).not.toBeDefined();
+  });
+
+  it('should support mutation input overrides when mutations are disabled', () => {
+    const validSchema = `type Post @model(mutations: null) {
+          id: ID!
+          title: String!
+          createdAt: String
+          updatedAt: String
+      }
+      input CreatePostInput {
+          different: String
+      }
+      input UpdatePostInput {
+          different2: String
+      }
+      input DeletePostInput {
+          different3: String
+      }
+    `;
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    expect(out).toBeDefined();
+    const definition = out.schema;
+    expect(definition).toBeDefined();
+    const parsed = parse(definition);
+    validateModelSchema(parsed);
+    const createPostInput = getInputType(parsed, 'CreatePostInput');
+    expectFieldsOnInputType(createPostInput!, ['different']);
+    const updatePostInput = getInputType(parsed, 'UpdatePostInput');
+    expectFieldsOnInputType(updatePostInput!, ['different2']);
+    const deletePostInput = getInputType(parsed, 'DeletePostInput');
+    expectFieldsOnInputType(deletePostInput!, ['different3']);
+  });
+
+  it('should support mutation input overrides when mutations are enabled', () => {
+    const validSchema = `type Post @model {
+        id: ID!
+        title: String!
+        createdAt: String
+        updatedAt: String
+    }
+    # User defined types always take precedence.
+    input CreatePostInput {
+        different: String
+    }
+    input UpdatePostInput {
+        different2: String
+    }
+    input DeletePostInput {
+        different3: String
+    }
+  `;
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    expect(out).toBeDefined();
+    const definition = out.schema;
+    expect(definition).toBeDefined();
+    const parsed = parse(definition);
+    validateModelSchema(parsed);
+
+    const createPostInput = getInputType(parsed, 'CreatePostInput');
+    expectFieldsOnInputType(createPostInput!, ['different']);
+    const updatePostInput = getInputType(parsed, 'UpdatePostInput');
+    expectFieldsOnInputType(updatePostInput!, ['different2']);
+    const deletePostInput = getInputType(parsed, 'DeletePostInput');
+    expectFieldsOnInputType(deletePostInput!, ['different3']);
+  });
+
+  it('should add default primary key when not defined', () => {
+    const validSchema = `
+      type Post @model{
+        str: String
+      }
+    `;
+    const result = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    expect(result).toBeDefined();
+    expect(result.schema).toBeDefined();
+    const schema = parse(result.schema);
+    validateModelSchema(schema);
+
+    const createPostInput: InputObjectTypeDefinitionNode = schema.definitions.find(
+      (d) => d.kind === 'InputObjectTypeDefinition' && d.name.value === 'CreatePostInput',
+    )! as InputObjectTypeDefinitionNode;
+    expect(createPostInput).toBeDefined();
+    const defaultIdField: InputValueDefinitionNode = createPostInput.fields!.find((f) => f.name.value === 'id')!;
+    expect(defaultIdField).toBeDefined();
+    expect(getBaseType(defaultIdField.type)).toEqual('ID');
+  });
+
+  it('should compile schema successfully when subscription is missing from schema', () => {
+    const validSchema = `
+    type Post @model {
+      id: Int
+      str: String
+    }
+
+    type Query {
+      Custom: String
+    }
+
+    schema {
+      query: Query
+    }
+    `;
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    expect(out).toBeDefined();
+    const parsed = parse(out.schema);
+    validateModelSchema(parsed);
+
+    const subscriptionType = getObjectType(parsed, 'Subscription');
+    expect(subscriptionType).toBeDefined();
+    expectFields(subscriptionType!, ['onCreatePost', 'onUpdatePost', 'onDeletePost']);
+    const mutationType = getObjectType(parsed, 'Mutation');
+    expect(mutationType).toBeDefined();
+    expectFields(mutationType!, ['createPost', 'updatePost', 'deletePost']);
+  });
+
+  it('should support non model objects contain id as a type for fields', () => {
+    const validSchema = `
+      type Post @model {
+        id: ID!
+        comments: [Comment]
+      }
+      type Comment {
+        id: String!
+        text: String!
+      }
+    `;
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    expect(out).toBeDefined();
+    const definition = out.schema;
+    expect(definition).toBeDefined();
+    const parsed = parse(definition);
+    validateModelSchema(parsed);
+    const commentInput = getInputType(parsed, 'CommentInput');
+    expectFieldsOnInputType(commentInput!, ['id', 'text']);
+    const commentObject = getObjectType(parsed, 'Comment');
+    const commentInputObject = getInputType(parsed, 'CommentInput');
+    const commentObjectIDField = getFieldOnObjectType(commentObject!, 'id');
+    const commentInputIDField = getFieldOnInputType(commentInputObject!, 'id');
+    verifyMatchingTypes(commentObjectIDField.type, commentInputIDField.type);
+    const subscriptionType = getObjectType(parsed, 'Subscription');
+    expect(subscriptionType).toBeDefined();
+  });
+
+  it('should throw for reserved type name usage', () => {
+    const invalidSchema = `
+      type Subscription @model{
+        id: Int
+        str: String
+      }
+    `;
+    expect(() =>
+      testTransform({
+        schema: invalidSchema,
+        transformers: [new ModelTransformer()],
+      }),
+    ).toThrowError("'Subscription' is a reserved type name and currently in use within the default schema element.");
+  });
+
+  it('should not add default primary key when ID is defined', () => {
+    const validSchema = `
+      type Post @model{
+        id: Int
+        str: String
+      }
+    `;
+    const result = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    expect(result).toBeDefined();
+    expect(result.schema).toBeDefined();
+    const schema = parse(result.schema);
+    validateModelSchema(schema);
+
+    const createPostInput: InputObjectTypeDefinitionNode = schema.definitions.find(
+      (d) => d.kind === 'InputObjectTypeDefinition' && d.name.value === 'CreatePostInput',
+    )! as InputObjectTypeDefinitionNode;
+    expect(createPostInput).toBeDefined();
+    const defaultIdField: InputValueDefinitionNode = createPostInput.fields!.find((f) => f.name.value === 'id')!;
+    expect(defaultIdField).toBeDefined();
+    expect(getBaseType(defaultIdField.type)).toEqual('Int');
+    // It should not add default value for ctx.arg.id as id is of type Int
+    expect(result.resolvers['Mutation.createPost.req.vtl']).toMatchSnapshot();
+  });
+
+  it('should generate only create mutation', () => {
+    const validSchema = `type Post @model(mutations: { create: "customCreatePost" }) {
+        id: ID!
+        title: String!
+        createdAt: String
+        updatedAt: String
+      }
+    `;
+
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+      transformParameters: {
+        shouldDeepMergeDirectiveConfigDefaults: false,
+      },
+    });
+    expect(out).toBeDefined();
+    const definition = out.schema;
+    expect(definition).toBeDefined();
+    const parsed = parse(definition);
+    validateModelSchema(parsed);
+
+    const mutationType = getObjectType(parsed, 'Mutation');
+    expect(mutationType).toBeDefined();
+    expectFields(mutationType!, ['customCreatePost']);
+    doNotExpectFields(mutationType!, ['updatePost']);
+  });
+
+  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 out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    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, 'ModelStringInput');
+    expect(stringInputType).toBeDefined();
+    const booleanInputType = getInputType(parsed, 'ModelBooleanInput');
+    expect(booleanInputType).toBeDefined();
+    const intInputType = getInputType(parsed, 'ModelIntInput');
+    expect(intInputType).toBeDefined();
+    const floatInputType = getInputType(parsed, 'ModelFloatInput');
+    expect(floatInputType).toBeDefined();
+    const idInputType = getInputType(parsed, 'ModelIDInput');
+    expect(idInputType).toBeDefined();
+    const postInputType = getInputType(parsed, 'ModelPostFilterInput');
+    expect(postInputType).toBeDefined();
+    const userInputType = getInputType(parsed, 'ModelUserFilterInput');
+    expect(userInputType).toBeDefined();
+
+    expect(verifyInputCount(parsed, 'ModelStringInput', 1)).toBeTruthy();
+    expect(verifyInputCount(parsed, 'ModelBooleanInput', 1)).toBeTruthy();
+    expect(verifyInputCount(parsed, 'ModelIntInput', 1)).toBeTruthy();
+    expect(verifyInputCount(parsed, 'ModelFloatInput', 1)).toBeTruthy();
+    expect(verifyInputCount(parsed, 'ModelIDInput', 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 }
+      type Test @model {
+        status: Status!
+        lastStatus: Status!
+      }
+    `;
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    expect(out).toBeDefined();
+    const definition = out.schema;
+    expect(definition).toBeDefined();
+    const parsed = parse(definition);
+    validateModelSchema(parsed);
+
+    const createTestInput = getInputType(parsed, 'CreateTestInput');
+    expectFieldsOnInputType(createTestInput!, ['status', 'lastStatus']);
+
+    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 out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    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();
+  });
+
+  it('should generate filter inputs', () => {
+    const validSchema = `
+      type Post @model {
+          id: ID!
+          title: String!
+          createdAt: String
+          updatedAt: String
+      }`;
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    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']);
+
+    const connectionType = getObjectType(parsed, 'ModelPostConnection');
+    expect(connectionType).toBeDefined();
+
+    expect(verifyInputCount(parsed, 'ModelStringInput', 1)).toBeTruthy();
+    expect(verifyInputCount(parsed, 'ModelBooleanInput', 1)).toBeTruthy();
+    expect(verifyInputCount(parsed, 'ModelIntInput', 1)).toBeTruthy();
+    expect(verifyInputCount(parsed, 'ModelFloatInput', 1)).toBeTruthy();
+    expect(verifyInputCount(parsed, 'ModelIDInput', 1)).toBeTruthy();
+    expect(verifyInputCount(parsed, 'ModelPostFilterInput', 1)).toBeTruthy();
+  });
+
+  it('Should support public level subscriptions without defining custom names', () => {
+    const validSchema = `
+    type Post @model(subscriptions: { level: public }) {
+      id: ID!
+      title: String!
+    }
+    `;
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    expect(out).toBeDefined();
+    const definition = out.schema;
+    expect(definition).toBeDefined();
+    const parsed = parse(definition);
+    validateModelSchema(parsed);
+
+    const subscriptionType = getObjectType(parsed, 'Subscription');
+    expect(subscriptionType).toBeDefined();
+    expectFields(subscriptionType!, ['onUpdatePost', 'onCreatePost', 'onDeletePost']);
+  });
+
+  it('should support advanced subscriptions', () => {
+    const validSchema = `type Post @model(subscriptions: {
+          onCreate: ["onCreatePoster", "onCreatePost"],
+          onUpdate: ["onUpdatePoster"],
+          onDelete: ["onDeletePoster"]
+      }) {
+        id: ID!
+        title: String!
+        createdAt: String
+        updatedAt: String
+    }
+    `;
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    expect(out).toBeDefined();
+    const definition = out.schema;
+    expect(definition).toBeDefined();
+    const parsed = parse(definition);
+    validateModelSchema(parsed);
+
+    const subscriptionType = getObjectType(parsed, 'Subscription');
+    expect(subscriptionType).toBeDefined();
+    expectFields(subscriptionType!, ['onUpdatePoster', 'onCreatePoster', 'onDeletePoster', 'onCreatePost']);
+  });
+
+  it('should not generate superfluous input and filter types', () => {
+    const validSchema = `
+    type Entity @model(mutations: null, subscriptions: null, queries: {get: "getEntity"}) {
+      id: ID!
+      str: String
+    }
+    `;
+    const result = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+      transformParameters: {
+        shouldDeepMergeDirectiveConfigDefaults: false,
+      },
+    });
+    expect(result).toBeDefined();
+    expect(result.schema).toBeDefined();
+    expect(result.schema).toMatchSnapshot();
+    const schema = parse(result.schema);
+    validateModelSchema(schema);
+  });
+
+  it('should support timestamp parameters when generating resolvers and output schema', () => {
+    const validSchema = `
+    type Post @model(timestamps: { createdAt: "createdOn", updatedAt: "updatedOn"}) {
+      id: ID!
+      str: String
+    }
+    `;
+    const result = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+      resolverConfig: {
+        project: {
+          ConflictDetection: 'VERSION',
+          ConflictHandler: ConflictHandlerType.AUTOMERGE,
+        },
+      },
+    });
+    expect(result).toBeDefined();
+    expect(result.schema).toBeDefined();
+    expect(result.schema).toMatchSnapshot();
+    const schema = parse(result.schema);
+    validateModelSchema(schema);
+
+    expect(result.resolvers['Mutation.createPost.req.vtl']).toMatchSnapshot();
+    expect(result.resolvers['Mutation.updatePost.req.vtl']).toMatchSnapshot();
+  });
+
+  it('should not to auto generate createdAt and updatedAt when the type in schema is not AWSDateTime', () => {
+    const validSchema = `
+  type Post @model {
+    id: ID!
+    str: String
+    createdAt: AWSTimestamp
+    updatedAt: AWSTimestamp
+  }
+  `;
+    const result = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+      resolverConfig: {
+        project: {
+          ConflictDetection: 'VERSION',
+          ConflictHandler: ConflictHandlerType.AUTOMERGE,
+        },
+      },
+    });
+    expect(result).toBeDefined();
+    expect(result.schema).toBeDefined();
+    expect(result.schema).toMatchSnapshot();
+    const schema = parse(result.schema);
+    validateModelSchema(schema);
+
+    expect(result.resolvers['Mutation.createPost.req.vtl']).toMatchSnapshot();
+    expect(result.resolvers['Mutation.updatePost.req.vtl']).toMatchSnapshot();
+  });
+
+  it('should have timestamps as nullable fields when the type makes it non-nullable', () => {
+    const validSchema = `
+      type Post @model {
+        id: ID!
+        str: String
+        createdAt: AWSDateTime!
+        updatedAt: AWSDateTime!
+      }
+    `;
+    const result = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+      resolverConfig: {
+        project: {
+          ConflictDetection: 'VERSION',
+          ConflictHandler: ConflictHandlerType.AUTOMERGE,
+        },
+      },
+    });
+    expect(result).toBeDefined();
+    expect(result.schema).toBeDefined();
+    expect(result.schema).toMatchSnapshot();
+    const schema = parse(result.schema);
+    validateModelSchema(schema);
+
+    expect(result.resolvers['Mutation.createPost.req.vtl']).toMatchSnapshot();
+    expect(result.resolvers['Mutation.updatePost.req.vtl']).toMatchSnapshot();
+  });
+
+  it('should not to include createdAt and updatedAt field when timestamps is set to null', () => {
+    const validSchema = `
+    type Post @model(timestamps: null) {
+      id: ID!
+      str: String
+    }
+    `;
+    const result = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+      resolverConfig: {
+        project: {
+          ConflictDetection: 'VERSION',
+          ConflictHandler: ConflictHandlerType.AUTOMERGE,
+        },
+      },
+    });
+    expect(result).toBeDefined();
+    expect(result.schema).toBeDefined();
+    expect(result.schema).toMatchSnapshot();
+    const schema = parse(result.schema);
+    validateModelSchema(schema);
+
+    expect(result.resolvers['Mutation.createPost.req.vtl']).toMatchSnapshot();
+    expect(result.resolvers['Mutation.updatePost.req.vtl']).toMatchSnapshot();
+  });
+
+  it('should filter known input types from create and update input fields', () => {
+    const validSchema = `
+      type Test @model {
+        id: ID!
+        email: Email
+      }
+
+      type Email @model {
+        id: ID!
+      }
+    `;
+    const result = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+      resolverConfig: {
+        project: {
+          ConflictDetection: 'VERSION',
+          ConflictHandler: ConflictHandlerType.AUTOMERGE,
+        },
+      },
+    });
+    expect(result).toBeDefined();
+    expect(result.schema).toBeDefined();
+    expect(result.schema).toMatchSnapshot();
+    const schema = parse(result.schema);
+    validateModelSchema(schema);
+
+    const createTestInput = getInputType(schema, 'CreateTestInput');
+    expect(getFieldOnInputType(createTestInput!, 'email')).toBeUndefined();
+
+    const updateTestInput = getInputType(schema, 'UpdateTestInput');
+    expect(getFieldOnInputType(updateTestInput!, 'email')).toBeUndefined();
+  });
+
+  it('should generate enum input objects', () => {
+    const validSchema = /* GraphQL */ `
+      type Post @model {
+        id: ID!
+        title: String!
+        createdAt: AWSDateTime
+        updatedAt: AWSDateTime
+        metadata: PostMetadata
+        entityMetadata: EntityMetadata
+        appearsIn: [Episode!]
+        episode: Episode
+      }
+      type Author @model {
+        id: ID!
+        name: String!
+        postMetadata: PostMetadata
+        entityMetadata: EntityMetadata
+      }
+      type EntityMetadata {
+        isActive: Boolean
+      }
+      type PostMetadata {
+        tags: Tag
+      }
+      type Tag {
+        published: Boolean
+        metadata: PostMetadata
+      }
+      enum Episode {
+        NEWHOPE
+        EMPIRE
+        JEDI
+      }
+      type Require @model {
+        id: ID!
+        requiredField: String!
+        notRequiredField: String
+      }
+      type Comment @model(timestamps: { createdAt: "createdOn", updatedAt: "updatedOn" }) {
+        id: ID!
+        title: String!
+        content: String
+        updatedOn: Int # No automatic generation of timestamp if its not AWSDateTime
+      }
+    `;
+
+    const result = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+      resolverConfig: {
+        project: {
+          ConflictDetection: 'VERSION',
+          ConflictHandler: ConflictHandlerType.AUTOMERGE,
+        },
+      },
+    });
+    expect(result).toBeDefined();
+    expect(result.schema).toBeDefined();
+    const schema = parse(result.schema);
+    validateModelSchema(schema);
+    expect(result.schema).toMatchSnapshot();
+    expect(verifyInputCount(schema, 'ModelEpisodeInput', 1)).toBeTruthy();
+  });
+
+  it('should support support scalar list', () => {
+    const validSchema = /* GraphQL */ `
+      type Post @model {
+        id: ID!
+        author: String!
+        title: String
+        content: String
+        url: String
+        ups: Int
+        downs: Int
+        version: Int
+        postedAt: String
+        createdAt: AWSDateTime
+        comments: [String!]
+        ratings: [Int!]
+        percentageUp: Float
+        isPublished: Boolean
+        jsonField: AWSJSON
+      }
+    `;
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    expect(out).toBeDefined();
+    validateModelSchema(parse(out.schema));
+  });
+
+  it('should generate sync resolver with ConflictHandlerType.Automerge', () => {
+    const validSchema = `
+      type Post @model {
+          id: ID!
+          title: String!
+      }
+    `;
+
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+      resolverConfig: {
+        project: {
+          ConflictDetection: 'VERSION',
+          ConflictHandler: ConflictHandlerType.AUTOMERGE,
+        },
+      },
+    });
+    expect(out).toBeDefined();
+
+    const definition = out.schema;
+    expect(definition).toBeDefined();
+    expect(out.resolvers).toMatchSnapshot();
+
+    validateModelSchema(parse(definition));
+  });
+
+  it('should generate sync resolver with ConflictHandlerType.LAMBDA', () => {
+    const validSchema = `
+      type Post @model {
+          id: ID!
+          title: String!
+          createdAt: String
+          updatedAt: String
+      }
+    `;
+
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+      resolverConfig: {
+        project: {
+          ConflictDetection: 'VERSION',
+          ConflictHandler: ConflictHandlerType.LAMBDA,
+          LambdaConflictHandler: {
+            name: 'myLambdaConflictHandler',
+          },
+        },
+      },
+    });
+    expect(out).toBeDefined();
+
+    const definition = out.schema;
+    expect(definition).toBeDefined();
+    expect(out.resolvers).toMatchSnapshot();
+
+    validateModelSchema(parse(definition));
+  });
+
+  it('should generate sync resolver with ConflictHandlerType.Optimistic', () => {
+    const validSchema = `
+      type Post @model {
+          id: ID!
+          title: String!
+          createdAt: String
+          updatedAt: String
+      }
+    `;
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+      resolverConfig: {
+        project: {
+          ConflictDetection: 'VERSION',
+          ConflictHandler: ConflictHandlerType.OPTIMISTIC,
+        },
+      },
+    });
+    expect(out).toBeDefined();
+
+    const definition = out.schema;
+    expect(definition).toBeDefined();
+    expect(out.resolvers).toMatchSnapshot();
+
+    validateModelSchema(parse(definition));
+  });
+
+  it('should generate iam role names under 64 chars and subscriptions under 50', () => {
+    const validSchema = `
+      type ThisIsAVeryLongNameModelThatShouldNotGenerateIAMRoleNamesOver64Characters @model {
+          id: ID!
+          title: String!
+      }
+    `;
+
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+      resolverConfig: {
+        project: {
+          ConflictDetection: 'VERSION',
+          ConflictHandler: ConflictHandlerType.AUTOMERGE,
+        },
+      },
+    });
+    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();
+    Template.fromJSON(iamStackResource).hasResourceProperties('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 out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    expect(out).toBeDefined();
+
+    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']);
+  });
+  it('the datastore table should be configured', () => {
+    const validSchema = `
+    type Todo @model {
+      name: String
+    }`;
+
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+      transformParameters: {
+        sandboxModeEnabled: true,
+      },
+      resolverConfig: {
+        project: {
+          ConflictDetection: 'VERSION',
+          ConflictHandler: ConflictHandlerType.AUTOMERGE,
+        },
+      },
+    });
+    expect(out).toBeDefined();
+    const schema = parse(out.schema);
+    validateModelSchema(schema);
+    // sync operation
+    const queryObject = getObjectType(schema, 'Query');
+    expectFields(queryObject!, ['syncTodos']);
+    // sync resolvers
+    expect(out.resolvers['Query.syncTodos.req.vtl']).toMatchSnapshot();
+    expect(out.resolvers['Query.syncTodos.res.vtl']).toMatchSnapshot();
+    // ds table
+    Template.fromJSON(out.rootStack).hasResourceProperties('AWS::DynamoDB::Table', {
+      KeySchema: [
+        {
+          AttributeName: 'ds_pk',
+          KeyType: 'HASH',
+        },
+        {
+          AttributeName: 'ds_sk',
+          KeyType: 'RANGE',
+        },
+      ],
+      AttributeDefinitions: [
+        {
+          AttributeName: 'ds_pk',
+          AttributeType: 'S',
+        },
+        {
+          AttributeName: 'ds_sk',
+          AttributeType: 'S',
+        },
+      ],
+      BillingMode: 'PAY_PER_REQUEST',
+      StreamSpecification: {
+        StreamViewType: 'NEW_AND_OLD_IMAGES',
+      },
+      TableName: {
+        'Fn::Join': [
+          '',
+          [
+            'AmplifyDataStore-',
+            {
+              'Fn::GetAtt': ['GraphQLAPI', 'ApiId'],
+            },
+            '-',
+            {
+              Ref: 'env',
+            },
+          ],
+        ],
+      },
+      TimeToLiveSpecification: {
+        AttributeName: '_ttl',
+        Enabled: true,
+      },
+    });
+  });
+  it('the conflict detection of per model rule should be respected', () => {
+    const validSchema = `
+      type Todo @model {
+        name: String
+      }
+      type Author @model {
+        name: String
+      }
+    `;
+
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+      transformParameters: {
+        sandboxModeEnabled: true,
+      },
+      resolverConfig: {
+        project: {
+          ConflictDetection: 'VERSION',
+          ConflictHandler: ConflictHandlerType.AUTOMERGE,
+        },
+        models: {
+          Todo: {
+            ConflictDetection: 'VERSION',
+            ConflictHandler: ConflictHandlerType.LAMBDA,
+            LambdaConflictHandler: {
+              name: 'myTodoConflictHandler',
+            },
+          },
+          Author: {
+            ConflictDetection: 'VERSION',
+            ConflictHandler: ConflictHandlerType.AUTOMERGE,
+          },
+        },
+      },
+    });
+    expect(out).toBeDefined();
+    const schema = parse(out.schema);
+    validateModelSchema(schema);
+    // nested stacks for models
+    const todoStack = out.stacks['Todo'];
+    const authorStack = out.stacks['Author'];
+    // Todo stack should have lambda for conflict detect rather than auto merge
+    Template.fromJSON(todoStack).hasResourceProperties('AWS::AppSync::FunctionConfiguration', {
+      SyncConfig: {
+        ConflictDetection: 'VERSION',
+        ConflictHandler: 'LAMBDA',
+      },
+    });
+    Template.fromJSON(todoStack).resourcePropertiesCountIs(
+      'AWS::AppSync::FunctionConfiguration',
+      {
+        SyncConfig: {
+          ConflictDetection: 'VERSION',
+          ConflictHandler: 'AUTOMERGE',
+        },
+      },
+      0,
+    );
+    // Author stack should have automerge for conflict detect rather than lambda
+    Template.fromJSON(authorStack).resourcePropertiesCountIs(
+      'AWS::AppSync::FunctionConfiguration',
+      {
+        SyncConfig: {
+          ConflictDetection: 'VERSION',
+          ConflictHandler: 'LAMBDA',
+        },
+      },
+      0,
+    );
+    Template.fromJSON(authorStack).hasResourceProperties('AWS::AppSync::FunctionConfiguration', {
+      SyncConfig: {
+        ConflictDetection: 'VERSION',
+        ConflictHandler: 'AUTOMERGE',
+      },
+    });
+  });
+  it('should add the model parameters at the root sack', () => {
+    const modelParams = {
+      DynamoDBModelTableReadIOPS: expect.objectContaining({
+        Type: 'Number',
+        Default: 5,
+        Description: 'The number of read IOPS the table should support.',
+      }),
+      DynamoDBModelTableWriteIOPS: expect.objectContaining({
+        Type: 'Number',
+        Default: 5,
+        Description: 'The number of write IOPS the table should support.',
+      }),
+      DynamoDBBillingMode: expect.objectContaining({
+        Type: 'String',
+        Default: 'PAY_PER_REQUEST',
+        AllowedValues: ['PAY_PER_REQUEST', 'PROVISIONED'],
+        Description: 'Configure @model types to create DynamoDB tables with PAY_PER_REQUEST or PROVISIONED billing modes.',
+      }),
+      DynamoDBEnablePointInTimeRecovery: expect.objectContaining({
+        Type: 'String',
+        Default: 'false',
+        AllowedValues: ['true', 'false'],
+        Description: 'Whether to enable Point in Time Recovery on the table.',
+      }),
+      DynamoDBEnableServerSideEncryption: expect.objectContaining({
+        Type: 'String',
+        Default: 'true',
+        AllowedValues: ['true', 'false'],
+        Description: 'Enable server side encryption powered by KMS.',
+      }),
+    };
+    const validSchema = `type Todo @model {
+      name: String
+    }`;
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+      transformParameters: {
+        sandboxModeEnabled: true,
+      },
+    });
+
+    const rootStack = out.rootStack;
+    expect(rootStack).toBeDefined();
+    expect(rootStack.Parameters).toMatchObject(modelParams);
+
+    const todoStack = out.stacks['Todo'];
+    expect(todoStack).toBeDefined();
+    expect(todoStack.Parameters).toMatchObject(modelParams);
+  });
+
+  it('global auth enabled should add apiKey if not default mode of auth', () => {
+    const validSchema = `
+    type Post @model {
+      id: ID!
+      title: String!
+      tags: [Tag]
+    }
+
+    type Tag {
+      id: ID
+      tags: [Tag]
+    }`;
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+      transformParameters: {
+        sandboxModeEnabled: true,
+      },
+      authConfig: {
+        defaultAuthentication: {
+          authenticationType: 'AMAZON_COGNITO_USER_POOLS',
+        },
+        additionalAuthenticationProviders: [
+          {
+            authenticationType: 'API_KEY',
+          },
+        ],
+      },
+    });
+    expect(out).toBeDefined();
+
+    const schema = parse(out.schema);
+    validateModelSchema(schema);
+
+    const postType = getObjectType(schema, 'Post')!;
+    expect(postType).toBeDefined();
+    expect(postType.directives).toBeDefined();
+    expect(postType.directives!.some((dir) => dir.name.value === 'aws_api_key')).toEqual(true);
+
+    const tagType = getObjectType(schema, 'Tag')!;
+    expect(tagType).toBeDefined();
+    expect(tagType.directives).toBeDefined();
+    expect(tagType.directives!.some((dir) => dir.name.value === 'aws_api_key')).toEqual(true);
+
+    // check operations
+    const queryType = getObjectType(schema, 'Query')!;
+    expect(queryType).toBeDefined();
+    const mutationType = getObjectType(schema, 'Mutation')!;
+    expect(mutationType).toBeDefined();
+    const subscriptionType = getObjectType(schema, 'Subscription')!;
+    expect(subscriptionType).toBeDefined();
+
+    for (const field of [...queryType.fields!, ...mutationType.fields!, ...subscriptionType.fields!]) {
+      expect(field.directives!.some((dir) => dir.name.value === 'aws_api_key')).toEqual(true);
+    }
+  });
+
+  it('maps model resolvers to specified stack', () => {
+    const inputSchema = /* GraphQL */ `
+      type Blog @model {
+        id: ID!
+        name: String!
+      }
+    `;
+    const result = testTransform({
+      schema: inputSchema,
+      transformers: [new ModelTransformer()],
+      stackMapping: {
+        CreateBlogResolver: 'myCustomStack1',
+        UpdateBlogResolver: 'myCustomStack2',
+      },
+    });
+    expect(Object.keys(result.stacks.myCustomStack1.Resources!).includes('CreateBlogResolver')).toBe(true);
+    expect(Object.keys(result.stacks.myCustomStack2.Resources!).includes('UpdateBlogResolver')).toBe(true);
+
+    expect(Object.keys(result.stacks.Blog.Resources!).includes('CreateBlogResolver')).toBe(false);
+    expect(Object.keys(result.stacks.Blog.Resources!).includes('UpdateBlogResolver')).toBe(false);
+  });
+
+  it('allow aws_lambda to pass through', () => {
+    const validSchema = `
+    type Todo @aws_lambda {
+      id: ID!
+      name: String!
+      description: String
+    }
+
+    schema {
+      query: Query
+    }
+
+    type Query {
+      todo: Todo @aws_lambda
+    }`;
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    expect(out).toBeDefined();
+
+    const schema = parse(out.schema);
+    validateModelSchema(schema);
+  });
+
+  it('handles custom subscriptions passed as strings', () => {
+    const validSchema = `type Post @model(subscriptions: {
+          onCreate: "onFeedCreated",
+          onUpdate: "onFeedUpdated",
+          onDelete: "onFeedDeleted"
+      }) {
+        id: ID!
+    }
+    `;
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    expect(out).toBeDefined();
+    const definition = out.schema;
+    expect(definition).toBeDefined();
+    const parsed = parse(definition);
+    validateModelSchema(parsed);
+
+    const subscriptionType = getObjectType(parsed, 'Subscription');
+    expect(subscriptionType).toBeDefined();
+    expect(subscriptionType!.fields!.length).toEqual(3);
+    expectFields(subscriptionType!, ['onFeedCreated', 'onFeedUpdated', 'onFeedDeleted']);
+  });
+
+  it('should generate id for the update input object', async () => {
+    const validSchema = `
+      type Todo @model {
+        uid: String!
+        username: String
+      }
+    `;
+
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+    });
+    expect(out).toBeDefined();
+    const definition = out.schema;
+    expect(definition).toBeDefined();
+
+    const parsed = parse(definition);
+    validateModelSchema(parsed);
+
+    const updateTodoInput = getInputType(parsed, 'UpdateTodoInput');
+    expect(updateTodoInput).toBeDefined();
+
+    expectFieldsOnInputType(updateTodoInput!, ['id']);
+    const updateTodoIdField = getFieldOnInputType(updateTodoInput!, 'id');
+    expect(updateTodoIdField.type.kind).toBe('NonNullType');
+  });
+
+  it('should successfully transform simple rds valid schema', async () => {
+    const validSchema = `
+      type Post @model {
+          id: ID!
+          title: String!
+      }
+    `;
+
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+      modelToDatasourceMap: new Map(
+        Object.entries({
+          Post: {
+            dbType: 'MySQL',
+            provisionDB: false,
+          },
+        }),
+      ),
+    });
+    expect(out).toBeDefined();
+
+    validateModelSchema(parse(out.schema));
+    parse(out.schema);
+  });
+
+  it('should successfully transform rds schema with array and object fields', async () => {
+    const validSchema = `
+      type Note @model {
+          id: ID!
+          content: String!
+          tags: [String!]
+          attachments: Attachment
+      }
+
+      type Attachment {
+        report: String!
+        image: String!
+      }
+    `;
+
+    const modelToDatasourceMap = new Map<string, DatasourceType>();
+    modelToDatasourceMap.set('Note', {
+      dbType: 'MySQL',
+      provisionDB: false,
+    });
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+      modelToDatasourceMap,
+    });
+    expect(out).toBeDefined();
+
+    validateModelSchema(parse(out.schema));
+    parse(out.schema);
+    expect(out.schema).toMatchSnapshot();
+    expect(out.resolvers).toMatchSnapshot();
+  });
+
+  it('sql lambda with vpc config should generate correct stack', async () => {
+    const validSchema = `
+      type Note @model {
+          id: ID!
+          content: String!
+      }
+    `;
+
+    const modelToDatasourceMap = new Map<string, DatasourceType>();
+    modelToDatasourceMap.set('Note', {
+      dbType: 'MySQL',
+      provisionDB: false,
+    });
+    const sqlLambdaVpcConfig: VpcSubnetConfig = {
+      vpcConfig: {
+        vpcId: 'vpc-123',
+        subnetIds: ['sub-123', 'sub-456'],
+        securityGroupIds: ['sg-123'],
+      },
+      subnetAvailabilityZoneConfig: [
+        {
+          SubnetId: 'sub-123',
+          AvailabilityZone: 'az-123'
+        },
+        {
+          SubnetId: 'sub-456',
+          AvailabilityZone: 'az-456'
+        },
+      ],
+    }
+    const out = testTransform({
+      schema: validSchema,
+      transformers: [new ModelTransformer()],
+      modelToDatasourceMap,
+      sqlLambdaVpcConfig,
+    });
+    expect(out).toBeDefined();
+
+    validateModelSchema(parse(out.schema));
+    expect(out.stacks).toBeDefined();
+    expect(out.stacks.RdsApiStack).toBeDefined();
+    expect(out.stacks.RdsApiStack.Resources).toBeDefined();
+    const resourcesIds = Object.keys(out.stacks.RdsApiStack.Resources!) as string[];
+    const sqlLambda = out.stacks.RdsApiStack.Resources![resourcesIds.find((resource) => resource.startsWith('RDSLambdaLogicalID'))!];
+    expect(sqlLambda).toBeDefined();
+    expect(sqlLambda.Properties).toBeDefined();
+    expect(sqlLambda.Properties?.VpcConfig).toBeDefined();
+    expect(sqlLambda.Properties?.VpcConfig?.SubnetIds).toBeDefined();
+    expect(sqlLambda.Properties?.VpcConfig?.SubnetIds).toEqual(
+      expect.arrayContaining(['sub-123', 'sub-456']),
+    );
+    expect(sqlLambda.Properties?.VpcConfig?.SecurityGroupIds).toBeDefined();
+    expect(sqlLambda.Properties?.VpcConfig?.SecurityGroupIds).toEqual(
+      expect.arrayContaining(['sg-123']),
+    );    
+  });
+});