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

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

@@ -1,7 +1,14 @@
 import { ModelTransformer } from '@aws-amplify/graphql-model-transformer';
-import { ConflictHandlerType, GraphQLTransform, SyncConfig, validateModelSchema } from '@aws-amplify/graphql-transformer-core';
+import {
+  ConflictHandlerType,
+  DatasourceType,
+  GraphQLTransform,
+  SyncConfig,
+  validateModelSchema,
+} from '@aws-amplify/graphql-transformer-core';
 import { InputObjectTypeDefinitionNode, InputValueDefinitionNode, ListValueNode, NamedTypeNode, parse } from 'graphql';
 import { getBaseType } from 'graphql-transformer-common';
+import { Template } from 'aws-cdk-lib/assertions';
 import {
   doNotExpectFields,
   expectFields,
@@ -13,7 +20,6 @@ import {
   verifyInputCount,
   verifyMatchingTypes,
 } from './test-utils/helpers';
-import { Template } from 'aws-cdk-lib/assertions';
 
 describe('ModelTransformer: ', () => {
   it('should successfully transform simple valid schema', async () => {
@@ -70,17 +76,17 @@ describe('ModelTransformer: ', () => {
       resolverConfig: {
         project: {
           ConflictDetection: 'VERSION',
-          ConflictHandler: ConflictHandlerType.AUTOMERGE
-        }
+          ConflictHandler: ConflictHandlerType.AUTOMERGE,
+        },
       },
     });
     const out = transformer.transform(alsoValidSchema);
     expect(out).toBeDefined();
-    
+
     validateModelSchema(parse(out.schema));
     parse(out.schema);
     expect(out.schema).toMatchSnapshot();
-    expect(out.schema).toContain("input NonModelTypeInput")
+    expect(out.schema).toContain('input NonModelTypeInput');
   });
 
   it('should support custom query overrides', () => {
@@ -111,7 +117,7 @@ describe('ModelTransformer: ', () => {
 
     // 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');
+    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();
@@ -120,7 +126,7 @@ describe('ModelTransformer: ', () => {
     const subscriptionType = getObjectType(parsed, 'Subscription');
     expect(subscriptionType).toBeDefined();
     expectFields(subscriptionType!, ['onCreatePost', 'onUpdatePost', 'onDeletePost']);
-    const subField = subscriptionType!.fields!.find(f => f.name.value === 'onCreatePost');
+    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');
@@ -331,10 +337,10 @@ describe('ModelTransformer: ', () => {
     validateModelSchema(schema);
 
     const createPostInput: InputObjectTypeDefinitionNode = schema.definitions.find(
-      d => d.kind === 'InputObjectTypeDefinition' && d.name.value === 'CreatePostInput',
+      (d) => d.kind === 'InputObjectTypeDefinition' && d.name.value === 'CreatePostInput',
     )! as InputObjectTypeDefinitionNode;
     expect(createPostInput).toBeDefined();
-    const defaultIdField: InputValueDefinitionNode = createPostInput.fields!.find(f => f.name.value === 'id')!;
+    const defaultIdField: InputValueDefinitionNode = createPostInput.fields!.find((f) => f.name.value === 'id')!;
     expect(defaultIdField).toBeDefined();
     expect(getBaseType(defaultIdField.type)).toEqual('ID');
   });
@@ -433,10 +439,10 @@ describe('ModelTransformer: ', () => {
     validateModelSchema(schema);
 
     const createPostInput: InputObjectTypeDefinitionNode = schema.definitions.find(
-      d => d.kind === 'InputObjectTypeDefinition' && d.name.value === 'CreatePostInput',
+      (d) => d.kind === 'InputObjectTypeDefinition' && d.name.value === 'CreatePostInput',
     )! as InputObjectTypeDefinitionNode;
     expect(createPostInput).toBeDefined();
-    const defaultIdField: InputValueDefinitionNode = createPostInput.fields!.find(f => f.name.value === 'id')!;
+    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
@@ -723,8 +729,8 @@ describe('ModelTransformer: ', () => {
       resolverConfig: {
         project: {
           ConflictDetection: 'VERSION',
-          ConflictHandler: ConflictHandlerType.AUTOMERGE
-        }
+          ConflictHandler: ConflictHandlerType.AUTOMERGE,
+        },
       },
     });
     const result = transformer.transform(validSchema);
@@ -752,8 +758,8 @@ describe('ModelTransformer: ', () => {
       resolverConfig: {
         project: {
           ConflictDetection: 'VERSION',
-          ConflictHandler: ConflictHandlerType.AUTOMERGE
-        }
+          ConflictHandler: ConflictHandlerType.AUTOMERGE,
+        },
       },
     });
     const result = transformer.transform(validSchema);
@@ -781,8 +787,8 @@ describe('ModelTransformer: ', () => {
       resolverConfig: {
         project: {
           ConflictDetection: 'VERSION',
-          ConflictHandler: ConflictHandlerType.AUTOMERGE
-        }
+          ConflictHandler: ConflictHandlerType.AUTOMERGE,
+        },
       },
     });
 
@@ -809,8 +815,8 @@ describe('ModelTransformer: ', () => {
       resolverConfig: {
         project: {
           ConflictDetection: 'VERSION',
-          ConflictHandler: ConflictHandlerType.AUTOMERGE
-        }
+          ConflictHandler: ConflictHandlerType.AUTOMERGE,
+        },
       },
     });
     const result = transformer.transform(validSchema);
@@ -840,8 +846,8 @@ describe('ModelTransformer: ', () => {
       resolverConfig: {
         project: {
           ConflictDetection: 'VERSION',
-          ConflictHandler: ConflictHandlerType.AUTOMERGE
-        }
+          ConflictHandler: ConflictHandlerType.AUTOMERGE,
+        },
       },
     });
 
@@ -910,8 +916,8 @@ describe('ModelTransformer: ', () => {
       resolverConfig: {
         project: {
           ConflictDetection: 'VERSION',
-          ConflictHandler: ConflictHandlerType.AUTOMERGE
-        }
+          ConflictHandler: ConflictHandlerType.AUTOMERGE,
+        },
       },
     });
     const result = transformer.transform(validSchema);
@@ -1074,42 +1080,41 @@ describe('ModelTransformer: ', () => {
     const subscriptionType = getObjectType(parsed, 'Subscription');
     expect(subscriptionType).toBeDefined();
 
-    subscriptionType!.fields!.forEach(it => {
+    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: [
+    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-',
             {
-              Action: 'sts:AssumeRole',
-              Effect: 'Allow',
-              Principal: {
-                Service: 'appsync.amazonaws.com',
-              },
+              Ref: 'referencetotransformerrootstackGraphQLAPI20497F53ApiId',
+            },
+            '-',
+            {
+              Ref: 'referencetotransformerrootstackenv10C5A902Ref',
             },
           ],
-          Version: '2012-10-17',
-        },
-        RoleName: {
-          'Fn::Join': [
-            '',
-            [
-              'ThisIsAVeryLongNameM2d9fca-',
-              {
-                Ref: 'referencetotransformerrootstackGraphQLAPI20497F53ApiId',
-              },
-              '-',
-              {
-                Ref: 'referencetotransformerrootstackenv10C5A902Ref',
-              },
-            ],
-          ],
-        },
-      });
+        ],
+      },
+    });
 
     validateModelSchema(parsed);
   });
@@ -1137,7 +1142,7 @@ describe('ModelTransformer: ', () => {
 
     expectFieldsOnInputType(createTodoInput!, ['id', 'name']);
 
-    const idField = createTodoInput!.fields!.find(f => f.name.value === 'id');
+    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');
 
@@ -1159,8 +1164,10 @@ describe('ModelTransformer: ', () => {
           ConflictHandler: ConflictHandlerType.AUTOMERGE,
         },
       },
-      sandboxModeEnabled: true,
       transformers: [new ModelTransformer()],
+      transformParameters: {
+        sandboxModeEnabled: true,
+      },
     });
     const out = transformer.transform(validSchema);
     expect(out).toBeDefined();
@@ -1173,54 +1180,53 @@ describe('ModelTransformer: ', () => {
     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',
+    Template.fromJSON(out.rootStack).hasResourceProperties('AWS::DynamoDB::Table', {
+      KeySchema: [
+        {
+          AttributeName: 'ds_pk',
+          KeyType: 'HASH',
         },
-        TableName: {
-          'Fn::Join': [
-            '',
-            [
-              'AmplifyDataStore-',
-              {
-                'Fn::GetAtt': ['GraphQLAPI', 'ApiId'],
-              },
-              '-',
-              {
-                Ref: 'env',
-              },
-            ],
-          ],
+        {
+          AttributeName: 'ds_sk',
+          KeyType: 'RANGE',
         },
-        TimeToLiveSpecification: {
-          AttributeName: '_ttl',
-          Enabled: true,
+      ],
+      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", () => {
+  it('the conflict detection of per model rule should be respected', () => {
     const validSchema = `
       type Todo @model {
         name: String
@@ -1233,74 +1239,69 @@ describe('ModelTransformer: ', () => {
     const transformer = new GraphQLTransform({
       resolverConfig: {
         project: {
-          ConflictDetection: "VERSION",
-          ConflictHandler: ConflictHandlerType.AUTOMERGE
+          ConflictDetection: 'VERSION',
+          ConflictHandler: ConflictHandlerType.AUTOMERGE,
         },
         models: {
           Todo: {
-            ConflictDetection: "VERSION",
+            ConflictDetection: 'VERSION',
             ConflictHandler: ConflictHandlerType.LAMBDA,
             LambdaConflictHandler: {
-              name: "myTodoConflictHandler"
-            }
+              name: 'myTodoConflictHandler',
+            },
           },
           Author: {
-            ConflictDetection: "VERSION",
-            ConflictHandler: ConflictHandlerType.AUTOMERGE
-          }
-        }
+            ConflictDetection: 'VERSION',
+            ConflictHandler: ConflictHandlerType.AUTOMERGE,
+          },
+        },
+      },
+      transformers: [new ModelTransformer()],
+      transformParameters: {
+        sandboxModeEnabled: true,
       },
-      sandboxModeEnabled: true,
-      transformers: [new ModelTransformer()]
     });
     const out = transformer.transform(validSchema);
     expect(out).toBeDefined();
     const schema = parse(out.schema);
     validateModelSchema(schema);
     // nested stacks for models
-    const todoStack = out.stacks["Todo"];
-    const authorStack = out.stacks["Author"];
+    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).hasResourceProperties('AWS::AppSync::FunctionConfiguration', {
+      SyncConfig: {
+        ConflictDetection: 'VERSION',
+        ConflictHandler: 'LAMBDA',
+      },
+    });
     Template.fromJSON(todoStack).resourcePropertiesCountIs(
-      "AWS::AppSync::FunctionConfiguration",
+      'AWS::AppSync::FunctionConfiguration',
       {
         SyncConfig: {
-          ConflictDetection: "VERSION",
-          ConflictHandler: "AUTOMERGE",
-        }
+          ConflictDetection: 'VERSION',
+          ConflictHandler: 'AUTOMERGE',
+        },
       },
-      0
+      0,
     );
     // Author stack should have automerge for conflict detect rather than lambda
     Template.fromJSON(authorStack).resourcePropertiesCountIs(
-      "AWS::AppSync::FunctionConfiguration",
+      'AWS::AppSync::FunctionConfiguration',
       {
         SyncConfig: {
-          ConflictDetection: "VERSION",
-          ConflictHandler: "LAMBDA",
-        }
+          ConflictDetection: 'VERSION',
+          ConflictHandler: 'LAMBDA',
+        },
       },
-      0
+      0,
     );
-    Template.fromJSON(authorStack).hasResourceProperties(
-      "AWS::AppSync::FunctionConfiguration",
-      {
-        SyncConfig: {
-          ConflictDetection: "VERSION",
-          ConflictHandler: "AUTOMERGE",
-        }
-      }
-    );
-
+    Template.fromJSON(authorStack).hasResourceProperties('AWS::AppSync::FunctionConfiguration', {
+      SyncConfig: {
+        ConflictDetection: 'VERSION',
+        ConflictHandler: 'AUTOMERGE',
+      },
+    });
   });
   it('should add the model parameters at the root sack', () => {
     const modelParams = {
@@ -1337,8 +1338,10 @@ describe('ModelTransformer: ', () => {
       name: String
     }`;
     const transformer = new GraphQLTransform({
-      sandboxModeEnabled: true,
       transformers: [new ModelTransformer()],
+      transformParameters: {
+        sandboxModeEnabled: true,
+      },
     });
     const out = transformer.transform(validSchema);
 
@@ -1374,8 +1377,10 @@ describe('ModelTransformer: ', () => {
           },
         ],
       },
-      sandboxModeEnabled: true,
       transformers: [new ModelTransformer()],
+      transformParameters: {
+        sandboxModeEnabled: true,
+      },
     });
     const out = transformer.transform(validSchema);
     expect(out).toBeDefined();
@@ -1386,12 +1391,12 @@ describe('ModelTransformer: ', () => {
     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);
+    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);
+    expect(tagType.directives!.some((dir) => dir.name.value === 'aws_api_key')).toEqual(true);
 
     // check operations
     const queryType = getObjectType(schema, 'Query')!;
@@ -1402,7 +1407,7 @@ describe('ModelTransformer: ', () => {
     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);
+      expect(field.directives!.some((dir) => dir.name.value === 'aws_api_key')).toEqual(true);
     }
   });
 
@@ -1505,4 +1510,29 @@ describe('ModelTransformer: ', () => {
     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 transformer = new GraphQLTransform({
+      transformers: [new ModelTransformer()],
+    });
+    const modelToDatasourceMap = new Map<string, DatasourceType>();
+    modelToDatasourceMap.set('Post', {
+      dbType: 'MySQL',
+      provisionDB: false,
+    });
+    const out = transformer.transform(validSchema, {
+      modelToDatasourceMap,
+    });
+    expect(out).toBeDefined();
+
+    validateModelSchema(parse(out.schema));
+    parse(out.schema);
+  });
 });

package/src/__tests__/test-utils/helpers.ts

@@ -43,7 +43,7 @@ export function doNotExpectFields(type: ObjectTypeDefinitionNode, fields: string
 }
 
 export function verifyInputCount(doc: DocumentNode, type: string, count: number): boolean {
-  return doc.definitions.filter(def => def.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION && def.name.value === type).length == count;
+  return doc.definitions.filter((def) => def.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION && def.name.value === type).length == count;
 }
 
 export function getFieldOnInputType(type: InputObjectTypeDefinitionNode, field: string): InputValueDefinitionNode {

package/src/definitions.ts

@@ -5,8 +5,34 @@ export const FLOAT_CONDITIONS = ['ne', 'eq', 'le', 'lt', 'ge', 'gt', 'between'];
 export const BOOLEAN_CONDITIONS = ['ne', 'eq'];
 export const SIZE_CONDITIONS = ['ne', 'eq', 'le', 'lt', 'ge', 'gt', 'between'];
 
-export const SUBSCRIPTION_STRING_CONDITIONS = ['ne', 'eq', 'le', 'lt', 'ge', 'gt', 'contains', 'notContains', 'between', 'beginsWith', 'in', 'notIn'];
-export const SUBSCRIPTION_ID_CONDITIONS = ['ne', 'eq', 'le', 'lt', 'ge', 'gt', 'contains', 'notContains', 'between', 'beginsWith', 'in', 'notIn'];
+export const SUBSCRIPTION_STRING_CONDITIONS = [
+  'ne',
+  'eq',
+  'le',
+  'lt',
+  'ge',
+  'gt',
+  'contains',
+  'notContains',
+  'between',
+  'beginsWith',
+  'in',
+  'notIn',
+];
+export const SUBSCRIPTION_ID_CONDITIONS = [
+  'ne',
+  'eq',
+  'le',
+  'lt',
+  'ge',
+  'gt',
+  'contains',
+  'notContains',
+  'between',
+  'beginsWith',
+  'in',
+  'notIn',
+];
 export const SUBSCRIPTION_INT_CONDITIONS = ['ne', 'eq', 'le', 'lt', 'ge', 'gt', 'between', 'in', 'notIn'];
 export const SUBSCRIPTION_FLOAT_CONDITIONS = ['ne', 'eq', 'le', 'lt', 'ge', 'gt', 'between', 'in', 'notIn'];
 export const SUBSCRIPTION_BOOLEAN_CONDITIONS = ['ne', 'eq'];