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

package/rds-lambda/package.json

@@ -10,7 +10,7 @@
     "babel-jest": "^29.1.2",
     "jest": "^29.1.2",
     "knex": "^2.3.0",
-    "mysql2": "^3.1.0",
+    "mysql2": "2.3.3",
     "pg": "^8.8.0",
     "ts-jest": "^29.0.3",
     "uuid": "^9.0.0"

package/rds-lambda/utils/rds_utils.ts

@@ -0,0 +1,107 @@
+/**
+ * Util method to convert any GraphQL input filter argument to an AWS RDS query expression 
+ */
+export const toRDSQueryExpression = (filter: any) => {
+    let rdsExpression = '';
+    let isAndAppended = false;
+    Object.entries(filter).forEach(([key, value]: any, index) => {
+        if(index != 0) {
+            rdsExpression += ` AND `;
+            isAndAppended = true;
+        }
+        switch(key) {
+            case 'and':
+            case 'or':
+                rdsExpression += value.map(toRDSQueryExpression).join(` ${key.toUpperCase()} `);
+                break;
+            case 'not':
+                rdsExpression += `NOT ${toRDSQueryExpression(value)}`;
+                break;
+            default:
+                Object.entries(value).forEach(([operator, operand]: any, secondIndex) => {
+                    if(secondIndex != 0) {
+                        rdsExpression += ` AND `;
+                    }
+                    switch(operator) {
+                        case 'attributeExists':
+                            rdsExpression += `${key} IS NOT NULL`;
+                            break;
+                        case 'beginsWith':
+                            rdsExpression += `${key} LIKE '${operand}%'`;
+                            break;
+                        case 'between':
+                            if (!Array.isArray(operand) || operand.length !== 2) {
+                                throw new Error(`between condition must have two values, but got: ${operand}.length`);
+                            }
+                            rdsExpression += `${key} BETWEEN '${operand[0]}' AND '${operand[1]}'`;
+                            break;
+                        case 'contains':
+                            rdsExpression += `${key} LIKE '%${operand}%'`;
+                            break;
+                        case 'eq':
+                            rdsExpression += `${key} = '${operand}'`;
+                            break;
+                        case 'ge':
+                            rdsExpression += `${key} >= '${operand}'`;
+                            break;
+                        case 'gt':
+                            rdsExpression += `${key} > '${operand}'`;
+                            break;
+                        case 'le':
+                            rdsExpression += `${key} <= '${operand}'`;
+                            break;
+                        case 'lt':
+                            rdsExpression += `${key} < '${operand}'`;
+                            break;
+                        case 'ne':
+                            rdsExpression += `${key} != '${operand}'`;
+                            break;
+                        case 'notContains':
+                            // key : name , operand : 'a' , operator : notContains
+                            rdsExpression += `${key} NOT LIKE '%${operand}%'`;
+                            break;
+                        case 'size':
+                            // size has nested operators:- between, eq, ge, gt, le, lt, ne
+                            Object.entries(operand).forEach(([sizeOperator, sizeOperand]: any) => {
+                                if(index != 0 && !isAndAppended) {
+                                    rdsExpression += ` AND `;
+                                    isAndAppended = true;
+                                }
+                                switch(sizeOperator) {
+                                    case 'between':
+                                        if (!Array.isArray(sizeOperand) || sizeOperand.length !== 2) {
+                                            throw new Error(`between condition must have two values, but got: ${sizeOperand}.length`);
+                                        }
+                                        rdsExpression += `LENGTH (${key}) BETWEEN '${sizeOperand[0]}' AND '${sizeOperand[1]}'`;
+                                        break;
+                                    case 'eq':
+                                        rdsExpression += `LENGTH (${key}) = '${sizeOperand}'`; 
+                                        break;
+                                    case 'ge':
+                                        rdsExpression += `LENGTH (${key}) >= '${sizeOperand}'`;
+                                        break;
+                                    case 'gt':
+                                        rdsExpression += `LENGTH (${key}) > '${sizeOperand}'`;
+                                        break;
+                                    case 'le':
+                                        rdsExpression += `LENGTH (${key}) <= '${sizeOperand}'`;
+                                        break;
+                                    case 'lt':
+                                        rdsExpression += `LENGTH (${key}) < '${sizeOperand}'`;
+                                        break;
+                                    case 'ne':
+                                        rdsExpression += `LENGTH (${key}) != '${sizeOperand}'`;
+                                        break;
+                                    default:
+                                        console.log(`Unsupported operator: ${sizeOperator}`);
+                                }
+                            });
+                            break;
+                        default:
+                            console.log(`Unsupported operator: ${operator}`);
+                    }
+                });
+            }
+    });
+    return `(${rdsExpression})`;
+};

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')),
+      }),
+    ]),
+  );
+};