@aws-amplify/graphql-model-transformer 0.17.0-rds-support-preview1.0.0 → 0.17.0-rdsv2preview.0

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

@@ -13,7 +13,7 @@ import {
   verifyInputCount,
   verifyMatchingTypes,
 } from './test-utils/helpers';
-import { expect as cdkExpect, haveResource } from '@aws-cdk/assert';
+import { expect as cdkExpect, haveResource, haveResourceLike } from '@aws-cdk/assert';
 
 const featureFlags = {
   getBoolean: jest.fn(),
@@ -1170,7 +1170,95 @@ describe('ModelTransformer: ', () => {
       }),
     );
   });
+  it("the conflict detection of per model rule should be respected", () => {
+    const validSchema = `
+      type Todo @model {
+        name: String
+      }
+      type Author @model {
+        name: String
+      }
+    `;
+
+    const transformer = new GraphQLTransform({
+      transformConfig: {},
+      resolverConfig: {
+        project: {
+          ConflictDetection: "VERSION",
+          ConflictHandler: ConflictHandlerType.AUTOMERGE
+        },
+        models: {
+          Todo: {
+            ConflictDetection: "VERSION",
+            ConflictHandler: ConflictHandlerType.LAMBDA,
+            LambdaConflictHandler: {
+              name: "myTodoConflictHandler"
+            }
+          },
+          Author: {
+            ConflictDetection: "VERSION",
+            ConflictHandler: ConflictHandlerType.AUTOMERGE
+          }
+        }
+      },
+      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"];
+    // Todo stack should have lambda for conflict detect rather than auto merge
+    cdkExpect(todoStack).to(
+      haveResourceLike(
+        "AWS::AppSync::FunctionConfiguration",
+        {
+          SyncConfig: {
+            ConflictDetection: "VERSION",
+            ConflictHandler: "LAMBDA",
+          }
+        }
+      )
+    );
+    cdkExpect(todoStack).notTo(
+      haveResourceLike(
+        "AWS::AppSync::FunctionConfiguration",
+        {
+          SyncConfig: {
+            ConflictDetection: "VERSION",
+            ConflictHandler: "AUTOMERGE",
+          }
+        }
+      )
+    );
+    // Author stack should have automerge for conflict detect rather than lambda
+    cdkExpect(authorStack).notTo(
+      haveResourceLike(
+        "AWS::AppSync::FunctionConfiguration",
+        {
+          SyncConfig: {
+            ConflictDetection: "VERSION",
+            ConflictHandler: "LAMBDA",
+          }
+        }
+      )
+    );
+    cdkExpect(authorStack).to(
+      haveResourceLike(
+        "AWS::AppSync::FunctionConfiguration",
+        {
+          SyncConfig: {
+            ConflictDetection: "VERSION",
+            ConflictHandler: "AUTOMERGE",
+          }
+        }
+      )
+    );
 
+  });
   it('should add the model parameters at the root sack', () => {
     const modelParams = {
       DynamoDBModelTableReadIOPS: expect.objectContaining({

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

@@ -0,0 +1,299 @@
+import { toRDSQueryExpression } from './../../../rds-lambda/utils/rds_utils';
+
+describe('filterToRdsExpression', () => {
+    // QueryGroup - and, or 
+    it('should convert and: QueryGroup ', () => {
+    const filter = {
+        and : [
+            { id : { eq : '123' } },
+            { name : { eq : 'Amplify' } },
+        ],
+    };
+    expect(toRDSQueryExpression(filter)).toEqual("((id = '123') AND (name = 'Amplify'))");
+    }); 
+    it('should convert or: QueryGroup ', () => {
+    const filter = {
+        or : [
+            { id : { eq : '123' } },
+            { name : { eq : 'Amplify' } },
+        ],
+    };
+    expect(toRDSQueryExpression(filter)).toEqual("((id = '123') OR (name = 'Amplify'))");
+    });
+    // Operator - eq, ne, gt, ge, lt, le, contains, notContains, between, beginsWith
+    it('should convert eq: Operator ', () => {
+    const filter = {
+        id : { eq : '123' },
+        name: { eq : 'Amplify' },
+        org: { eq : 'AWS' },
+    };
+    expect(toRDSQueryExpression(filter)).toEqual("(id = '123' AND name = 'Amplify' AND org = 'AWS')");
+    });
+
+    it('should convert ne: , eq: Operator ', () => {
+    const filter = {
+        id : { ne : '123' },
+        name: { eq : 'Amplify' },
+    };
+    expect(toRDSQueryExpression(filter)).toEqual("(id != '123' AND name = 'Amplify')");
+    });
+
+    it('should convert gt: , eq: Operator ', () => {
+    const filter = {
+        id : { gt : '123' },
+        name: { eq : 'Amplify' },
+    };
+    expect(toRDSQueryExpression(filter)).toEqual("(id > '123' AND name = 'Amplify')");
+    });
+
+    it('should convert ge: , eq: , ne:  Operator ', () => {
+    const filter = {
+        id : { ge : '123' },
+        name: { eq : 'Amplify' },
+        org: { ne : 'AWS' },
+    };
+    expect(toRDSQueryExpression(filter)).toEqual("(id >= '123' AND name = 'Amplify' AND org != 'AWS')");
+    });
+
+    it('should convert lt: , eq: , ne:  Operator ', () => {
+    const filter = {
+        id : { lt : '123' },
+        name: { eq : 'Amplify' },
+        org: { ne : 'AWS' },
+    };
+    expect(toRDSQueryExpression(filter)).toEqual("(id < '123' AND name = 'Amplify' AND org != 'AWS')");
+    });
+
+    it('should convert le: , eq: , ne:  Operator ', () => {
+    const filter = {
+        id : { le : '123' },
+        name: { ne : 'Amplify' },
+        org: { eq : 'AWS' },
+    };
+    expect(toRDSQueryExpression(filter)).toEqual("(id <= '123' AND name != 'Amplify' AND org = 'AWS')");
+    });
+
+    it('should convert contains: , eq: , ne:  Operator ', () => {
+    const filter = {
+        id : {  ne : '123' },
+        name: { contains : 'Amplify' },
+        org: { eq : 'AWS' },
+    };
+    expect(toRDSQueryExpression(filter)).toEqual("(id != '123' AND name LIKE '%Amplify%' AND org = 'AWS')");
+    });
+
+    it('should convert  eq: , notContains: , ne:  Operator ', () => {
+    const filter = {
+        id : {  eq : '123' },
+        name: { notContains : 'Amplify' },
+        org: { ne : 'AWS' },
+    };
+    expect(toRDSQueryExpression(filter)).toEqual("(id = '123' AND name NOT LIKE '%Amplify%' AND org != 'AWS')");
+    });
+
+    it('should convert beginsWith: , eq: , ne:  Operator ', () => {
+    const filter = {
+        id : {  eq : '123' },
+        name: { beginsWith : 'Amplify' },
+        org: { ne : 'AWS' },
+    };
+    expect(toRDSQueryExpression(filter)).toEqual("(id = '123' AND name LIKE 'Amplify%' AND org != 'AWS')");
+    });
+
+    it('should convert between: , eq: , ne:  Operator ', () => {
+    const filter = {
+        id : {  eq : '123' },
+        age: { between : ['18', '60'] },
+        org: { ne : 'AWS' },
+    };
+    expect(toRDSQueryExpression(filter)).toEqual("(id = '123' AND age BETWEEN '18' AND '60' AND org != 'AWS')");
+    });
+
+    test('filterToRdsExpression > should throw error if between: doesn\'t have 2 values', () => {
+        const filter = {
+          id : { eq : '123' },
+          age: { between : ['18'] },
+          org: { ne : 'AWS' },
+        };
+        expect(() => {toRDSQueryExpression(filter);}).toThrowError(/between condition must have two values/);
+      });
+
+    // nested QueryGroup & Operators
+    it('should convert nested and: or: with Operators ', () => {
+    const filter = {
+        and : [
+            { id : { eq : '123' } },
+            { or : [
+                { name : { eq : 'Amplify' } },
+                { org : { eq : 'AWS' } },
+            ]},
+        ],
+    }; 
+    expect(toRDSQueryExpression(filter)).toEqual("((id = '123') AND ((name = 'Amplify') OR (org = 'AWS')))");
+    });
+
+    it('should convert nested or: and: with Operators ', () => {
+    const filter = {
+        or : [
+            { id : { eq : '123' } },
+            { and : [
+                { name : { eq : 'Amplify' } },
+                { org : { eq : 'AWS' } },
+            ]},
+        ],
+    };
+    expect(toRDSQueryExpression(filter)).toEqual("((id = '123') OR ((name = 'Amplify') AND (org = 'AWS')))");
+    });
+
+    it('should convert nested and: and: with Operators ', () => {
+    const filter = {
+        and : [
+            { id : { eq : '123' } },
+            { and : [
+                { name : { eq : 'Amplify' } },
+                { org : { eq : 'AWS' } },
+            ]},
+        ],
+    };
+    expect(toRDSQueryExpression(filter)).toEqual("((id = '123') AND ((name = 'Amplify') AND (org = 'AWS')))");
+    });
+
+    it('should convert deep nested query and: or: and: ', () => {
+    const filter = {
+        and : [
+            { id : { eq : '123' } },
+            { or : [
+                { name : { eq : 'Amplify' } },
+                { and : [
+                    { org : { eq : 'AWS' } },
+                    { age : { between : [`18`, `60`] } },
+                ]},
+            ]},
+        ],
+    };
+    expect(toRDSQueryExpression(filter)).toEqual("((id = '123') AND ((name = 'Amplify') OR ((org = 'AWS') AND (age BETWEEN '18' AND '60'))))");
+    });
+
+    it(`should convert deep nested query and: or: and: with multiple operators`, () => {
+    const filter = {
+        id: { eq: '123' },
+        and : [
+            { or : [
+                { name : { eq : 'Amplify' } },
+                { and : [
+                    { org : { eq : 'AWS' } },
+                    { age : { between : [`18`, `60`] } },
+                    { name : { beginsWith : 'Amplify' } },
+                ]},
+            ]},
+        ],
+    };
+    expect(toRDSQueryExpression(filter)).toEqual("(id = '123' AND ((name = 'Amplify') OR ((org = 'AWS') AND (age BETWEEN '18' AND '60') AND (name LIKE 'Amplify%'))))");
+    });
+
+    it(`should convert deep nested query and: or: and: with multiple operators`, () => {
+    const filter = {
+        id: { ne: '123' },
+        and : [
+            { or : [
+                { name : { eq : 'Amplify' } },
+                { and : [
+                    { org : { ne : 'AWS' } },
+                    { age : { between : [`18`, `60`] } },
+                    { name : { beginsWith : 'Amplify' } },
+                ]},
+            ]},
+        ],
+        or : [
+            { name : { eq : 'Amplify' } },  
+            { org : { eq : 'AWS' } },
+        ],
+    };
+    expect(toRDSQueryExpression(filter)).toEqual("(id != '123' AND ((name = 'Amplify') OR ((org != 'AWS') AND (age BETWEEN '18' AND '60') AND (name LIKE 'Amplify%'))) AND (name = 'Amplify') OR (org = 'AWS'))");
+    });
+
+    it(`should convert deep nested query and: or: and: with multiple operators`, () => {
+        const filter = {
+            name : { beginsWith : 'A' },
+            or : [
+                { name : { eq : 'Amplify' } },
+                { and : [
+                    { org : { eq : 'AWS' } },
+                    { age : { between : [`18`, `60`] } },
+                    { name : { eq : 'Amplify' } },
+                ]},
+            ],
+            and : [
+                { name : { eq : 'Amplify' } },  
+                { org : { eq : 'AWS' } },
+            ],
+        };
+    expect(toRDSQueryExpression(filter)).toEqual("(name LIKE 'A%' AND (name = 'Amplify') OR ((org = 'AWS') AND (age BETWEEN '18' AND '60') AND (name = 'Amplify')) AND (name = 'Amplify') AND (org = 'AWS'))");
+     });
+
+     // size operator tests
+    it(`should work on size: gt: operator`, () => {
+    const filter = {
+        id : { eq : '123', size : { gt : 1 } },
+    }
+    expect(toRDSQueryExpression(filter)).toEqual("(id = '123' AND LENGTH (id) > '1')");
+    });
+
+    it(`should work on size: ge: operator`, () => {
+        const filter = {
+            id : { eq : '123', size : { ge : 1 } },
+        }
+    expect(toRDSQueryExpression(filter)).toEqual("(id = '123' AND LENGTH (id) >= '1')");
+    });
+
+    it(`should work on size: lt: operator`, () => {
+        const filter = {
+            id : { eq : '123', size : { lt : 1 } },
+        }
+    expect(toRDSQueryExpression(filter)).toEqual("(id = '123' AND LENGTH (id) < '1')");
+    });
+
+    it(`should work on size: le: operator`, () => {
+        const filter = {
+            id : { eq : '123', size : { le : 1 } },
+        }
+    expect(toRDSQueryExpression(filter)).toEqual("(id = '123' AND LENGTH (id) <= '1')");
+    });
+
+    it(`should work on size: eq: operator along with and: QueryGroup`, () => {
+        const filter = {
+            and : [
+                { id : { eq : '123', size : { eq : 1 } } },
+            ],
+        }
+        expect(toRDSQueryExpression(filter)).toEqual("((id = '123' AND LENGTH (id) = '1'))");
+    });
+
+    it(`should work on size: eq: operator along with or: QueryGroup`, () => {
+        const filter = {
+            or : [
+                { id : { eq : '123', size : { eq : 2 } } },
+            ],
+            and : [
+                { age : { eq : '30', size : { eq : 3 } } },
+            ],
+        }
+        expect(toRDSQueryExpression(filter)).toEqual("((id = '123' AND LENGTH (id) = '2') AND (age = '30' AND LENGTH (age) = '3'))");
+    });
+
+    it(`should work on size: eq: operator along with or: and: QueryGroup`, () => {
+        const filter = {
+            or : [
+                { id : { eq : '123', size : { eq : 2 } } },
+                { and : [
+                    { age : { eq : '30', size : { eq : 3 } } },
+                ]},
+            ],
+            and : [
+                { age : { eq : '20', size : { eq : 3 } } },
+                { org: { eq : 'AWS', size : { eq : 3 } } },
+            ],
+        }
+        expect(toRDSQueryExpression(filter)).toEqual("((id = '123' AND LENGTH (id) = '2') OR ((age = '30' AND LENGTH (age) = '3')) AND (age = '20' AND LENGTH (age) = '3') AND (org = 'AWS' AND LENGTH (org) = '3'))");
+    });
+});

package/src/graphql-model-transformer.ts

@@ -162,6 +162,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       || definition.name.value === ctx.output.getMutationTypeName()
       || definition.name.value === ctx.output.getSubscriptionTypeName();
 
+    const isDynamoDB = (ctx.modelToDatasourceMap.get(definition.name.value) ?? DDB_DATASOURCE_TYPE).dbType === DDB_DB_TYPE;
     if (isTypeNameReserved) {
       throw new InvalidDirectiveError(
         `'${definition.name.value}' is a reserved type name and currently in use within the default schema element.`,
@@ -192,9 +193,12 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
         onDelete: [getFieldNameFor('onDelete', typeName)],
         onUpdate: [getFieldNameFor('onUpdate', typeName)],
       },
-      timestamps: {
+      timestamps: isDynamoDB ? {
         createdAt: 'createdAt',
         updatedAt: 'updatedAt',
+      } : {
+        createdAt: undefined,
+        updatedAt: undefined,
       },
     }, generateGetArgumentsInput(ctx.featureFlags));
 

package/src/resolvers/generators/rds-vtl-generator.ts

@@ -7,6 +7,7 @@ import {
   generateUpdateInitSlotTemplate,
   generateLambdaUpdateRequestTemplate,
   generateLambdaDeleteRequestTemplate,
+  generateLambdaListRequestTemplate,
 } from '../rds';
 import {
   generateSubscriptionRequestTemplate,
@@ -45,7 +46,7 @@ export class RDSModelVTLGenerator implements ModelVTLGenerator {
     return generateGetLambdaResponseTemplate(false);
   }
   generateListRequestTemplate(config: ModelRequestConfig): string {
-    return generateLambdaRequestTemplate(config.modelName, config.operation, config.operationName);
+    return generateLambdaListRequestTemplate(config.modelName, config.operation, config.operationName);
   }
   generateSyncRequestTemplate(config: ModelRequestConfig): string {
     return generateDefaultLambdaResponseMappingTemplate(false);

package/src/resolvers/rds/index.ts

@@ -1,2 +1,3 @@
 export * from './resolver';
 export * from './mutation';
+export * from './query';

package/src/resolvers/rds/mutation.ts

@@ -58,6 +58,9 @@ export const generateLambdaCreateRequestTemplate = (tableName: string, operation
       set(ref('lambdaInput.args'), obj({})),
       set(ref('lambdaInput.operation'), str('CREATE')),
       set(ref('lambdaInput.operationName'), str(operationName)),
+      set(ref('lambdaInput.args.metadata'), obj({})),
+      set(ref('lambdaInput.args.metadata.keys'), list([])),
+      qref(methodCall(ref('lambdaInput.args.metadata.keys.addAll'), methodCall(ref('util.defaultIfNull'), ref('ctx.stash.keys'), list([])))),
       comment('Set the default values to put request'),
       set(ref('lambdaInput.args.input'), methodCall(ref('util.defaultIfNull'), ref('ctx.stash.defaultValues'), obj({}))),
       comment('copy the values from input'),
@@ -115,7 +118,8 @@ export const generateLambdaUpdateRequestTemplate = (tableName: string, operation
       set(ref('lambdaInput.operation'), str('UPDATE')),
       set(ref('lambdaInput.operationName'), str(operationName)),
       set(ref('lambdaInput.args.metadata'), obj({})),
-      set(ref('lambdaInput.args.metadata.keys'), list(modelIndexFields.map((field) => str(field)))),
+      set(ref('lambdaInput.args.metadata.keys'), list([])),
+      qref(methodCall(ref('lambdaInput.args.metadata.keys.addAll'), methodCall(ref('util.defaultIfNull'), ref('ctx.stash.keys'), list([])))),
       comment('Set the default values to put request'),
       set(ref('lambdaInput.args.input'), methodCall(ref('util.defaultIfNull'), ref('ctx.stash.defaultValues'), obj({}))),
       comment('copy the values from input'),
@@ -141,7 +145,8 @@ export const generateLambdaDeleteRequestTemplate = (tableName: string, operation
       set(ref('lambdaInput.operation'), str('DELETE')),
       set(ref('lambdaInput.operationName'), str(operationName)),
       set(ref('lambdaInput.args.metadata'), obj({})),
-      set(ref('lambdaInput.args.metadata.keys'), list(modelIndexFields.map((field) => str(field)))),
+      set(ref('lambdaInput.args.metadata.keys'), list([])),
+      qref(methodCall(ref('lambdaInput.args.metadata.keys.addAll'), methodCall(ref('util.defaultIfNull'), ref('ctx.stash.keys'), list([])))),
       obj({
         version: str('2018-05-29'),
         operation: str('Invoke'),

package/src/resolvers/rds/query.ts

@@ -0,0 +1,33 @@
+import {
+  compoundExpression,
+  list,
+  methodCall,
+  obj,
+  printBlock,
+  qref,
+  ref,
+  set,
+  str,
+} from 'graphql-mapping-template';
+
+export const generateLambdaListRequestTemplate = (tableName: string, operation: string, operationName: string): string => {
+  return printBlock('Invoke RDS Lambda data source')(
+    compoundExpression([
+      set(ref('lambdaInput'), obj({})),
+      set(ref('lambdaInput.args'), obj({})),
+      set(ref('lambdaInput.table'), str(tableName)),
+      set(ref('lambdaInput.operation'), str(operation)),
+      set(ref('lambdaInput.operationName'), str(operationName)),
+      set(ref('lambdaInput.args.metadata'), obj({})),
+      set(ref('lambdaInput.args.metadata.keys'), list([])),
+      qref(methodCall(ref('lambdaInput.args.metadata.keys.addAll'), methodCall(ref('util.defaultIfNull'), ref('ctx.stash.keys'), list([])))),
+      set(ref('lambdaInput.args.input'), methodCall(ref('util.defaultIfNull'), ref('ctx.stash.defaultValues'), obj({}))),
+      qref(methodCall(ref('lambdaInput.args.putAll'), methodCall(ref('util.defaultIfNull'), ref('context.arguments'), obj({})))),
+      obj({
+        version: str('2018-05-29'),
+        operation: str('Invoke'),
+        payload: methodCall(ref('util.toJson'), ref('lambdaInput')),
+      }),
+    ]),
+  );
+};

package/src/resolvers/rds/resolver.ts

@@ -11,7 +11,14 @@ import {
   compoundExpression,
   iff,
   toJson,
-  printBlock, and, not, equals, int, nul, set, comment,
+  printBlock,
+  and,
+  not,
+  equals,
+  int,
+  nul,
+  set,
+  list,
 } from 'graphql-mapping-template';
 import { ResourceConstants } from 'graphql-transformer-common';
 import { Construct, Stack } from '@aws-cdk/core';
@@ -86,10 +93,15 @@ export const generateLambdaRequestTemplate = (tableName: string, operation: stri
   return printBlock('Invoke RDS Lambda data source')(
     compoundExpression([
       set(ref('lambdaInput'), obj({})),
-      set(ref('lambdaInput.args'), ref('context.arguments')),
+      set(ref('lambdaInput.args'), obj({})),
       set(ref('lambdaInput.table'), str(tableName)),
       set(ref('lambdaInput.operation'), str(operation)),
       set(ref('lambdaInput.operationName'), str(operationName)),
+      set(ref('lambdaInput.args.metadata'), obj({})),
+      set(ref('lambdaInput.args.metadata.keys'), list([])),
+      qref(methodCall(ref('lambdaInput.args.metadata.keys.addAll'), methodCall(ref('util.defaultIfNull'), ref('ctx.stash.keys'), list([])))),
+      set(ref('lambdaInput.args.input'), methodCall(ref('util.defaultIfNull'), ref('ctx.stash.defaultValues'), obj({}))),
+      qref(methodCall(ref('lambdaInput.args.input.putAll'), methodCall(ref('util.defaultIfNull'), ref('context.arguments'), obj({})))),
       obj({
         version: str('2018-05-29'),
         operation: str('Invoke'),
@@ -100,25 +112,22 @@ export const generateLambdaRequestTemplate = (tableName: string, operation: stri
 };
 
 export const generateGetLambdaResponseTemplate = (isSyncEnabled: boolean): string => {
-  const statements = new Array<Expression>();
+  const statements: Expression[] = [];
   if (isSyncEnabled) {
     statements.push(
-      iff(ref('ctx.error'), methodCall(ref('util.error'), ref('ctx.error.message'), ref('ctx.error.type'), ref('ctx.result'))),
+      ifElse(
+        ref('ctx.error'),
+        methodCall(ref('util.error'), ref('ctx.error.message'), ref('ctx.error.type'), ref('ctx.result')),
+        toJson(ref('ctx.result')),
+      ),
     );
   } else {
-    statements.push(iff(ref('ctx.error'), methodCall(ref('util.error'), ref('ctx.error.message'), ref('ctx.error.type'))));
+    statements.push(
+      ifElse(ref('ctx.error'), methodCall(ref('util.error'), ref('ctx.error.message'), ref('ctx.error.type')), toJson(ref('ctx.result'))),
+    );
   }
-  statements.push(
-    ifElse(
-      and([not(ref('ctx.result.items.isEmpty()')), equals(ref('ctx.result.scannedCount'), int(1))]),
-      toJson(ref('ctx.result.items[0]')),
-      compoundExpression([
-        iff(and([ref('ctx.result.items.isEmpty()'), equals(ref('ctx.result.scannedCount'), int(1))]), ref('util.unauthorized()')),
-        toJson(nul()),
-      ]),
-    ),
-  );
-  return printBlock('Get Response template')(compoundExpression(statements));
+
+  return printBlock('ResponseTemplate')(compoundExpression(statements));
 };
 
 /**