@aws-amplify/graphql-model-transformer 2.2.0-rds-2.0 → 2.2.1

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

@@ -1,1630 +0,0 @@
-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']),
-    );    
-  });
-});