@aws-amplify/graphql-model-transformer 2.1.1 → 2.1.3-jsii-build.0

package/src/resolvers/dynamodb/query.ts

@@ -1,275 +0,0 @@
-import {
-  Expression,
-  set,
-  ref,
-  obj,
-  str,
-  ifElse,
-  compoundExpression,
-  methodCall,
-  qref,
-  toJson,
-  printBlock,
-  iff,
-  int,
-  not,
-  equals,
-  bool,
-  and,
-  isNullOrEmpty,
-  list,
-  forEach,
-  nul,
-  raw,
-} from 'graphql-mapping-template';
-import { ResourceConstants, setArgs } from 'graphql-transformer-common';
-
-const authFilter = ref('ctx.stash.authFilter');
-
-/**
- * Generate get query resolver template
- */
-export const generateGetRequestTemplate = (): string => {
-  const statements: Expression[] = [
-    set(ref('GetRequest'), obj({ version: str('2018-05-29'), operation: str('Query') })),
-    ifElse(
-      ref('ctx.stash.metadata.modelObjectKey'),
-      compoundExpression([
-        set(ref('expression'), str('')),
-        set(ref('expressionNames'), obj({})),
-        set(ref('expressionValues'), obj({})),
-        forEach(ref('item'), ref('ctx.stash.metadata.modelObjectKey.entrySet()'), [
-          set(ref('expression'), str('$expression#keyCount$velocityCount = :valueCount$velocityCount AND ')),
-          qref(methodCall(ref('expressionNames.put'), str('#keyCount$velocityCount'), ref('item.key'))),
-          qref(methodCall(ref('expressionValues.put'), str(':valueCount$velocityCount'), ref('item.value'))),
-        ]),
-        set(ref('expression'), methodCall(ref('expression.replaceAll'), str('AND $'), str(''))),
-        set(
-          ref('query'),
-          obj({ expression: ref('expression'), expressionNames: ref('expressionNames'), expressionValues: ref('expressionValues') }),
-        ),
-      ]),
-      set(
-        ref('query'),
-        obj({
-          expression: str('id = :id'),
-          expressionValues: obj({
-            ':id': methodCall(ref('util.parseJson'), methodCall(ref('util.dynamodb.toDynamoDBJson'), ref('ctx.args.id'))),
-          }),
-        }),
-      ),
-    ),
-    qref(methodCall(ref('GetRequest.put'), str('query'), ref('query'))),
-    iff(
-      not(isNullOrEmpty(authFilter)),
-      qref(
-        methodCall(
-          ref('GetRequest.put'),
-          str('filter'),
-          methodCall(ref('util.parseJson'), methodCall(ref('util.transform.toDynamoDBFilterExpression'), authFilter)),
-        ),
-      ),
-    ),
-    toJson(ref('GetRequest')),
-  ];
-
-  return printBlock('Get Request template')(compoundExpression(statements));
-};
-
-export const generateGetResponseTemplate = (isSyncEnabled: boolean): string => {
-  const statements = new Array<Expression>();
-  if (isSyncEnabled) {
-    statements.push(
-      iff(ref('ctx.error'), methodCall(ref('util.error'), ref('ctx.error.message'), ref('ctx.error.type'), 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(
-      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));
-};
-
-export const generateListRequestTemplate = (): string => {
-  const requestVariable = 'ListRequest';
-  const modelQueryObj = 'ctx.stash.modelQueryExpression';
-  const indexNameVariable = 'ctx.stash.metadata.index';
-  const expression = compoundExpression([
-    setArgs,
-    set(ref('limit'), methodCall(ref(`util.defaultIfNull`), ref('args.limit'), int(100))),
-    set(
-      ref(requestVariable),
-      obj({
-        version: str('2018-05-29'),
-        limit: ref('limit'),
-      }),
-    ),
-    iff(ref('args.nextToken'), set(ref(`${requestVariable}.nextToken`), ref('args.nextToken'))),
-    ifElse(
-      not(isNullOrEmpty(authFilter)),
-      compoundExpression([
-        set(ref('filter'), authFilter),
-        iff(not(isNullOrEmpty(ref('args.filter'))), set(ref('filter'), obj({ and: list([ref('filter'), ref('args.filter')]) }))),
-      ]),
-      iff(not(isNullOrEmpty(ref('args.filter'))), set(ref('filter'), ref('args.filter'))),
-    ),
-    iff(
-      not(isNullOrEmpty(ref('filter'))),
-      compoundExpression([
-        set(
-          ref(`filterExpression`),
-          methodCall(ref('util.parseJson'), methodCall(ref('util.transform.toDynamoDBFilterExpression'), ref('filter'))),
-        ),
-        iff(
-          isNullOrEmpty(ref('filterExpression')),
-          methodCall(ref('util.error'), str('Unable to process the filter expression'), str('Unrecognized Filter')),
-        ),
-        iff(
-          not(methodCall(ref('util.isNullOrBlank'), ref('filterExpression.expression'))),
-          compoundExpression([
-            iff(
-              equals(methodCall(ref('filterExpression.expressionValues.size')), int(0)),
-              qref(methodCall(ref('filterExpression.remove'), str('expressionValues'))),
-            ),
-            set(ref(`${requestVariable}.filter`), ref(`filterExpression`)),
-          ]),
-        ),
-      ]),
-    ),
-    ifElse(
-      and([
-        not(methodCall(ref('util.isNull'), ref(modelQueryObj))),
-        not(methodCall(ref('util.isNullOrEmpty'), ref(`${modelQueryObj}.expression`))),
-      ]),
-      compoundExpression([
-        qref(methodCall(ref(`${requestVariable}.put`), str('operation'), str('Query'))),
-        qref(methodCall(ref(`${requestVariable}.put`), str('query'), ref(modelQueryObj))),
-        ifElse(
-          and([not(methodCall(ref('util.isNull'), ref('args.sortDirection'))), equals(ref('args.sortDirection'), str('DESC'))]),
-          set(ref(`${requestVariable}.scanIndexForward`), bool(false)),
-          set(ref(`${requestVariable}.scanIndexForward`), bool(true)),
-        ),
-      ]),
-      qref(methodCall(ref(`${requestVariable}.put`), str('operation'), str('Scan'))),
-    ),
-    iff(not(methodCall(ref('util.isNull'), ref(indexNameVariable))), set(ref(`${requestVariable}.IndexName`), ref(indexNameVariable))),
-    toJson(ref(requestVariable)),
-  ]);
-  return printBlock('List Request')(expression);
-};
-
-export const generateSyncRequestTemplate = (): string => {
-  const requestVariable = 'ctx.stash.QueryRequest';
-  return printBlock('Sync Request template')(
-    compoundExpression([
-      setArgs,
-      set(ref('queryFilterContainsAuthField'), bool(false)),
-      set(ref('authFilterContainsSortKey'), bool(false)),
-      set(ref('useScan'), bool(true)),
-      iff(and([isNullOrEmpty(authFilter), ref('ctx.stash.QueryRequest')]), set(ref('useScan'), bool(false))),
-      ifElse(
-        not(isNullOrEmpty(authFilter)),
-        compoundExpression([
-          set(ref('filter'), authFilter),
-          iff(
-            ref('ctx.stash.QueryRequestVariables.partitionKey'),
-            compoundExpression([
-              // Check if the auth filter contains the QueryRequest's partition key.
-              // If yes, then the filter on auth field must match one of the Auth filter to perform a query.
-              forEach(ref('filterItem'), ref('ctx.stash.authFilter.or'), [
-                iff(
-                  raw('$filterItem.get($ctx.stash.QueryRequestVariables.partitionKey)'),
-                  set(ref('queryFilterContainsAuthField'), bool(true)),
-                ),
-              ]),
-              ifElse(
-                not(ref('queryFilterContainsAuthField')),
-                // If the auth filter is not on an auth field, check if the QueryRequest's sort keys contain an auth field.
-                // If yes, perform a scan. Otherwise, query the GSI/table.
-                compoundExpression([
-                  forEach(ref('filterItem'), ref('ctx.stash.authFilter.or'), [
-                    forEach(ref('sortKey'), ref('ctx.stash.QueryRequestVariables.sortKeys'), [
-                      iff(raw('$filterItem.get($sortKey)'), set(ref('authFilterContainsSortKey'), bool(true))),
-                    ]),
-                  ]),
-                  iff(
-                    not(ref('authFilterContainsSortKey')),
-                    compoundExpression([
-                      ifElse(
-                        not(isNullOrEmpty(ref(`${requestVariable}.filter`))),
-                        set(ref(`${requestVariable}.filter`), obj({ and: list([ref(`${requestVariable}.filter`), authFilter]) })),
-                        set(ref(`${requestVariable}.filter`), authFilter),
-                      ),
-                      set(ref('useScan'), bool(false)),
-                    ]),
-                  ),
-                ]),
-                compoundExpression([
-                  forEach(ref('filterItem'), ref('ctx.stash.authFilter.or'), [
-                    iff(
-                      raw('$util.toJson($filterItem) == $util.toJson($ctx.stash.QueryRequestVariables.partitionKeyFilter)'),
-                      set(ref('useScan'), bool(false)),
-                    ),
-                  ]),
-                ]),
-              ),
-            ]),
-          ),
-          iff(not(isNullOrEmpty(ref('args.filter'))), set(ref('filter'), obj({ and: list([ref('filter'), ref('args.filter')]) }))),
-        ]),
-        iff(not(isNullOrEmpty(ref('args.filter'))), set(ref('filter'), ref('args.filter'))),
-      ),
-      iff(
-        not(isNullOrEmpty(ref('filter'))),
-        compoundExpression([
-          set(
-            ref(`filterExpression`),
-            methodCall(ref('util.parseJson'), methodCall(ref('util.transform.toDynamoDBFilterExpression'), ref('filter'))),
-          ),
-          iff(
-            not(methodCall(ref('util.isNullOrBlank'), ref('filterExpression.expression'))),
-            compoundExpression([
-              iff(
-                equals(methodCall(ref('filterExpression.expressionValues.size')), int(0)),
-                qref(methodCall(ref('filterExpression.remove'), str('expressionValues'))),
-              ),
-              set(ref('filter'), ref('filterExpression')),
-            ]),
-          ),
-        ]),
-      ),
-      ifElse(
-        not(ref('useScan')),
-        compoundExpression([
-          iff(
-            ref(`${requestVariable}.filter`),
-            set(
-              ref(`${requestVariable}.filter`),
-              methodCall(
-                ref('util.parseJson'),
-                methodCall(ref('util.transform.toDynamoDBFilterExpression'), ref(`${requestVariable}.filter`)),
-              ),
-            ),
-          ),
-          raw(`$util.toJson($${requestVariable})`),
-        ]),
-        obj({
-          version: str('2018-05-29'),
-          operation: str('Sync'),
-          filter: ifElse(ref('filter'), ref('util.toJson($filter)'), nul()),
-          limit: ref(`util.defaultIfNull($args.limit, ${ResourceConstants.DEFAULT_SYNC_QUERY_PAGE_LIMIT})`),
-          lastSync: ref('util.toJson($util.defaultIfNull($args.lastSync, null))'),
-          nextToken: ref('util.toJson($util.defaultIfNull($args.nextToken, null))'),
-        }),
-      ),
-    ]),
-  );
-};

package/src/resolvers/dynamodb/subscriptions.ts

@@ -1,22 +0,0 @@
-import { compoundExpression, Expression, obj, printBlock, str, toJson, nul, iff, not, isNullOrEmpty, ref } from 'graphql-mapping-template';
-/**
- * Generates subscription request template
- */
-export const generateSubscriptionRequestTemplate = (): string => {
-  const statements: Expression[] = [toJson(obj({ version: str('2018-05-29'), payload: obj({}) }))];
-  return printBlock('Subscription Request template')(compoundExpression(statements));
-};
-
-/**
- * Generates subscription response template
- */
-export const generateSubscriptionResponseTemplate = (): string => {
-  const statements: Expression[] = [
-    iff(
-      not(isNullOrEmpty(ref('ctx.args.filter'))),
-      ref('extensions.setSubscriptionFilter($util.transform.toSubscriptionFilter($ctx.args.filter))'),
-    ),
-    toJson(nul()),
-  ];
-  return printBlock('Subscription Response template')(compoundExpression(statements));
-};

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

@@ -1,71 +0,0 @@
-import {
-  generateUpdateRequestTemplate,
-  generateCreateRequestTemplate,
-  generateCreateInitSlotTemplate,
-  generateDeleteRequestTemplate,
-  generateUpdateInitSlotTemplate,
-  generateGetRequestTemplate,
-  generateGetResponseTemplate,
-  generateListRequestTemplate,
-  generateSyncRequestTemplate,
-  generateSubscriptionRequestTemplate,
-  generateSubscriptionResponseTemplate,
-  generateDefaultResponseMappingTemplate,
-} from '../dynamodb';
-import {
-  ModelCreateInitSlotConfig,
-  ModelCreateRequestConfig,
-  ModelDefaultResponseConfig,
-  ModelRequestConfig,
-  ModelUpdateRequestConfig,
-  ModelVTLGenerator,
-} from './vtl-generator';
-
-export class DynamoDBModelVTLGenerator implements ModelVTLGenerator {
-  generateUpdateRequestTemplate(config: ModelUpdateRequestConfig): string {
-    return generateUpdateRequestTemplate(config.modelName, config.isSyncEnabled);
-  }
-
-  generateCreateRequestTemplate(config: ModelCreateRequestConfig): string {
-    return generateCreateRequestTemplate(config.modelName, config.modelIndexFields);
-  }
-  generateCreateInitSlotTemplate(config: ModelCreateInitSlotConfig, initializeIdField: boolean): string {
-    return generateCreateInitSlotTemplate(config.modelConfig, initializeIdField);
-  }
-
-  generateDeleteRequestTemplate(config: ModelUpdateRequestConfig): string {
-    return generateDeleteRequestTemplate(config.modelName, config.isSyncEnabled);
-  }
-
-  generateUpdateInitSlotTemplate(config: ModelCreateInitSlotConfig): string {
-    return generateUpdateInitSlotTemplate(config.modelConfig);
-  }
-
-  generateGetRequestTemplate(config: ModelRequestConfig): string {
-    return generateGetRequestTemplate();
-  }
-
-  generateGetResponseTemplate(config: ModelUpdateRequestConfig): string {
-    return generateGetResponseTemplate(config.isSyncEnabled);
-  }
-
-  generateListRequestTemplate(config: ModelRequestConfig): string {
-    return generateListRequestTemplate();
-  }
-
-  generateSyncRequestTemplate(config: ModelRequestConfig): string {
-    return generateSyncRequestTemplate();
-  }
-
-  generateSubscriptionRequestTemplate(): string {
-    return generateSubscriptionRequestTemplate();
-  }
-
-  generateSubscriptionResponseTemplate(): string {
-    return generateSubscriptionResponseTemplate();
-  }
-
-  generateDefaultResponseMappingTemplate(config: ModelDefaultResponseConfig): string {
-    return generateDefaultResponseMappingTemplate(config.isSyncEnabled, config.mutation);
-  }
-}

package/src/resolvers/generators/index.ts

@@ -1,3 +0,0 @@
-export * from './vtl-generator';
-export * from './dynamodb-vtl-generator';
-export * from './rds-vtl-generator';

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

@@ -1,70 +0,0 @@
-import {
-  generateDefaultLambdaResponseMappingTemplate,
-  generateGetLambdaResponseTemplate,
-  generateLambdaRequestTemplate,
-  generateCreateInitSlotTemplate,
-  generateLambdaCreateRequestTemplate,
-  generateUpdateInitSlotTemplate,
-  generateLambdaUpdateRequestTemplate,
-  generateLambdaDeleteRequestTemplate,
-  generateLambdaListRequestTemplate,
-} from '../rds';
-import { generateSubscriptionRequestTemplate, generateSubscriptionResponseTemplate } from '../dynamodb';
-import {
-  ModelCreateInitSlotConfig,
-  ModelCreateRequestConfig,
-  ModelDefaultResponseConfig,
-  ModelRequestConfig,
-  ModelUpdateRequestConfig,
-  ModelVTLGenerator,
-} from './vtl-generator';
-
-// TODO: This class is created only to show the class structure. This needs a revisit to generate correct resolvers for RDS.
-export class RDSModelVTLGenerator implements ModelVTLGenerator {
-  generateUpdateRequestTemplate(config: ModelUpdateRequestConfig): string {
-    return generateLambdaUpdateRequestTemplate(config.modelName, config.operationName, config.modelIndexFields ?? ['id']);
-  }
-
-  generateCreateRequestTemplate(config: ModelCreateRequestConfig): string {
-    return generateLambdaCreateRequestTemplate(config.modelName, config.operationName);
-  }
-  generateCreateInitSlotTemplate(config: ModelCreateInitSlotConfig, initializeIdField: boolean): string {
-    return generateCreateInitSlotTemplate(config.modelConfig, initializeIdField);
-  }
-
-  generateDeleteRequestTemplate(config: ModelUpdateRequestConfig): string {
-    return generateLambdaDeleteRequestTemplate(config.modelName, config.operationName, config.modelIndexFields ?? ['id']);
-  }
-
-  generateUpdateInitSlotTemplate(config: ModelCreateInitSlotConfig): string {
-    return generateUpdateInitSlotTemplate(config.modelConfig);
-  }
-
-  generateGetRequestTemplate(config: ModelRequestConfig): string {
-    return generateLambdaRequestTemplate(config.modelName, config.operation, config.operationName);
-  }
-
-  generateGetResponseTemplate(config: ModelUpdateRequestConfig): string {
-    return generateGetLambdaResponseTemplate(false);
-  }
-
-  generateListRequestTemplate(config: ModelRequestConfig): string {
-    return generateLambdaListRequestTemplate(config.modelName, config.operation, config.operationName);
-  }
-
-  generateSyncRequestTemplate(config: ModelRequestConfig): string {
-    return generateDefaultLambdaResponseMappingTemplate(false);
-  }
-
-  generateSubscriptionRequestTemplate(): string {
-    return generateSubscriptionRequestTemplate();
-  }
-
-  generateSubscriptionResponseTemplate(): string {
-    return generateSubscriptionResponseTemplate();
-  }
-
-  generateDefaultResponseMappingTemplate(config: ModelDefaultResponseConfig): string {
-    return generateDefaultLambdaResponseMappingTemplate(false);
-  }
-}

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

@@ -1,46 +0,0 @@
-import { ModelDirectiveConfiguration } from '../../directive';
-
-export type ModelRequestConfig = {
-  modelName: string;
-  operation: string;
-  operationName: string;
-};
-
-export type ModelUpdateRequestConfig = ModelRequestConfig & {
-  modelIndexFields: string[];
-  isSyncEnabled: boolean;
-};
-
-export type ModelDeleteRequestConfig = ModelUpdateRequestConfig;
-
-export type ModelCreateRequestConfig = ModelRequestConfig & {
-  modelIndexFields: string[];
-};
-
-export type ModelCreateInitSlotConfig = {
-  modelConfig: ModelDirectiveConfiguration;
-};
-
-export type ModelUpdateInitSlotConfig = ModelCreateInitSlotConfig;
-
-export type ModelGetResponseConfig = ModelUpdateRequestConfig;
-
-export type ModelDefaultResponseConfig = ModelRequestConfig & {
-  isSyncEnabled: boolean;
-  mutation: boolean;
-};
-
-export interface ModelVTLGenerator {
-  generateUpdateRequestTemplate(config: ModelUpdateRequestConfig): string;
-  generateCreateRequestTemplate(config: ModelCreateRequestConfig): string;
-  generateCreateInitSlotTemplate(config: ModelCreateInitSlotConfig, initializeIdField: boolean): string;
-  generateDeleteRequestTemplate(config: ModelDeleteRequestConfig): string;
-  generateUpdateInitSlotTemplate(config: ModelUpdateInitSlotConfig): string;
-  generateGetRequestTemplate(config: ModelRequestConfig): string;
-  generateGetResponseTemplate(config: ModelGetResponseConfig): string;
-  generateListRequestTemplate(config: ModelRequestConfig): string;
-  generateSyncRequestTemplate(config: ModelRequestConfig): string;
-  generateSubscriptionRequestTemplate(): string;
-  generateSubscriptionResponseTemplate(): string;
-  generateDefaultResponseMappingTemplate(config: ModelDefaultResponseConfig): string;
-}

package/src/resolvers/index.ts

@@ -1,3 +0,0 @@
-export * from './generators';
-export * from './common';
-export { generateApplyDefaultsToInputTemplate } from './dynamodb';

package/src/resolvers/rds/index.ts

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

package/src/resolvers/rds/mutation.ts

@@ -1,169 +0,0 @@
-import {
-  comment,
-  compoundExpression,
-  Expression,
-  list,
-  methodCall,
-  obj,
-  printBlock,
-  qref,
-  ref,
-  set,
-  str,
-  toJson,
-} from 'graphql-mapping-template';
-import { ModelDirectiveConfiguration } from '../../directive';
-
-/**
- * Generate mapping template that sets default values for create mutation
- * @param modelConfig directive configuration
- */
-export const generateCreateInitSlotTemplate = (modelConfig: ModelDirectiveConfiguration, initializeIdField: boolean): string => {
-  const statements: Expression[] = [
-    // initialize defaultValues
-    qref(
-      methodCall(
-        ref('ctx.stash.put'),
-        str('defaultValues'),
-        methodCall(ref('util.defaultIfNull'), ref('ctx.stash.defaultValues'), obj({})),
-      ),
-    ),
-  ];
-
-  if (modelConfig?.timestamps) {
-    statements.push(set(ref('createdAt'), methodCall(ref('util.time.nowISO8601'))));
-    if (initializeIdField) {
-      statements.push(qref(methodCall(ref('ctx.stash.defaultValues.put'), str('id'), methodCall(ref('util.autoId')))));
-    }
-    if (modelConfig.timestamps.createdAt) {
-      statements.push(qref(methodCall(ref('ctx.stash.defaultValues.put'), str(modelConfig.timestamps.createdAt), ref('createdAt'))));
-    }
-    if (modelConfig.timestamps.updatedAt) {
-      statements.push(qref(methodCall(ref('ctx.stash.defaultValues.put'), str(modelConfig.timestamps.updatedAt), ref('createdAt'))));
-    }
-  }
-  statements.push(
-    toJson(
-      obj({
-        version: str('2018-05-29'),
-        payload: obj({}),
-      }),
-    ),
-  );
-  return printBlock('Initialization default values')(compoundExpression(statements));
-};
-
-export const generateLambdaCreateRequestTemplate = (tableName: string, operationName: string): string =>
-  printBlock('Invoke RDS Lambda data source')(
-    compoundExpression([
-      set(ref('lambdaInput'), obj({})),
-      set(ref('lambdaInput.table'), str(tableName)),
-      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'),
-      qref(
-        methodCall(ref('lambdaInput.args.input.putAll'), methodCall(ref('util.defaultIfNull'), ref('context.arguments.input'), obj({}))),
-      ),
-      obj({
-        version: str('2018-05-29'),
-        operation: str('Invoke'),
-        payload: methodCall(ref('util.toJson'), ref('lambdaInput')),
-      }),
-    ]),
-  );
-
-/**
- * Generate VTL template that sets the default values for Update mutation
- * @param modelConfig model directive configuration
- */
-export const generateUpdateInitSlotTemplate = (modelConfig: ModelDirectiveConfiguration): string => {
-  const statements: Expression[] = [
-    // initialize defaultValues
-    qref(
-      methodCall(
-        ref('ctx.stash.put'),
-        str('defaultValues'),
-        methodCall(ref('util.defaultIfNull'), ref('ctx.stash.defaultValues'), obj({})),
-      ),
-    ),
-  ];
-  if (modelConfig?.timestamps) {
-    if (modelConfig.timestamps.updatedAt) {
-      statements.push(set(ref('updatedAt'), methodCall(ref('util.time.nowISO8601'))));
-      statements.push(qref(methodCall(ref('ctx.stash.defaultValues.put'), str(modelConfig.timestamps.updatedAt), ref('updatedAt'))));
-    }
-  }
-  statements.push(
-    toJson(
-      obj({
-        version: str('2018-05-29'),
-        payload: obj({}),
-      }),
-    ),
-  );
-  return printBlock('Initialization default values')(compoundExpression(statements));
-};
-
-/**
- * Generate VTL template that calls the lambda for an Update mutation
- */
-export const generateLambdaUpdateRequestTemplate = (tableName: string, operationName: string, modelIndexFields: string[]): string =>
-  printBlock('Invoke RDS Lambda data source')(
-    compoundExpression([
-      set(ref('lambdaInput'), obj({})),
-      set(ref('lambdaInput.table'), str(tableName)),
-      set(ref('lambdaInput.args'), obj({})),
-      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([])),
-      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'),
-      qref(
-        methodCall(ref('lambdaInput.args.input.putAll'), methodCall(ref('util.defaultIfNull'), ref('context.arguments.input'), obj({}))),
-      ),
-      set(ref('lambdaInput.args.condition'), methodCall(ref('util.defaultIfNull'), ref('context.arguments.condition'), obj({}))),
-      obj({
-        version: str('2018-05-29'),
-        operation: str('Invoke'),
-        payload: methodCall(ref('util.toJson'), ref('lambdaInput')),
-      }),
-    ]),
-  );
-
-/**
- * Generate VTL template that calls the lambda for a Delete mutation
- */
-export const generateLambdaDeleteRequestTemplate = (tableName: string, operationName: string, modelIndexFields: string[]): string =>
-  printBlock('Invoke RDS Lambda data source')(
-    compoundExpression([
-      set(ref('lambdaInput'), obj({})),
-      set(ref('lambdaInput.table'), str(tableName)),
-      set(ref('lambdaInput.args'), ref('context.arguments')),
-      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([])),
-      qref(
-        methodCall(ref('lambdaInput.args.metadata.keys.addAll'), methodCall(ref('util.defaultIfNull'), ref('ctx.stash.keys'), list([]))),
-      ),
-      set(ref('lambdaInput.args.condition'), methodCall(ref('util.defaultIfNull'), ref('context.arguments.condition'), obj({}))),
-      obj({
-        version: str('2018-05-29'),
-        operation: str('Invoke'),
-        payload: methodCall(ref('util.toJson'), ref('lambdaInput')),
-      }),
-    ]),
-  );