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

package/rds-patching-lambda/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "rdslayerstresstest",
+  "version": "1.0.0",
+  "description": "",
+  "main": "lib/index.js",
+  "scripts": {
+    "test": "npm run build && node ./lib/index.js",
+    "build": "tsc",
+    "release": "rm -f test-lambda.zip && bestzip --force node ./test-lambda.zip ./*"
+  },
+  "dependencies": {
+    "@aws-sdk/client-lambda": "3.352.0",
+    "typescript": "5.1.3"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node": "^20.3.1",
+    "bestzip": "2.2.1"
+  }
+}

package/rds-patching-lambda/src/index.ts

@@ -0,0 +1,76 @@
+import { LambdaClient, UpdateFunctionConfigurationCommand, UpdateFunctionConfigurationCommandOutput } from "@aws-sdk/client-lambda";
+
+const SNS_EVENT_SOURCE = 'aws:sns';
+
+type LayerConfig = {
+  layerArn?: string;
+  region?: string;
+};
+
+const MIN_WAIT_TIME_IN_MS = 0; // No wait time
+const MAX_WAIT_TIME_IN_MS = 5 * 60 * 1000; // 5 minutes
+
+const delay = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));
+
+const waitRandomTime = (): Promise<void> => {
+  const waitTime = Math.floor(Math.random() * (MAX_WAIT_TIME_IN_MS - MIN_WAIT_TIME_IN_MS + 1) + MIN_WAIT_TIME_IN_MS);
+  console.log(`Waiting for ${waitTime} ms`);
+  return delay(waitTime);
+};
+
+const getLayerConfig = (event: any): LayerConfig => {
+  // Check layerArn in the event
+  const { Sns } = event.Records.find((record: any) => record.EventSource === SNS_EVENT_SOURCE);
+  if (!Sns) {
+    throw new Error('No SNS notification found in the event');
+  }
+
+  const layerArn = Sns?.MessageAttributes?.LayerArn?.Value;
+  const region = Sns?.MessageAttributes?.Region?.Value;
+
+  return {
+    layerArn,
+    region,
+  };
+};
+
+const updateFunction = async (layerArn: string): Promise<UpdateFunctionConfigurationCommandOutput> => {
+  const client = new LambdaClient({ region: process.env.AWS_REGION });
+  const lambdaFunctionArn = process.env.LAMBDA_FUNCTION_ARN;
+  const command = new UpdateFunctionConfigurationCommand({
+    FunctionName: lambdaFunctionArn,
+    Layers: [
+      layerArn,
+    ],
+  });
+  const response = await client.send(command);
+  return response;
+};
+
+export const handler = async (event: any): Promise<void> => {
+  // Record the received event in logs
+  console.log('Received event', JSON.stringify(event, null, 4));
+
+  const { layerArn, region } = getLayerConfig(event);
+  if (!layerArn || !region) {
+    throw new Error('Layer ARN or region is missing in the notification event');
+  }
+
+  if (region !== process.env.AWS_REGION) {
+    console.log(`Region ${region} in notification is not same as the current region ${process.env.AWS_REGION}. Skipping update.`);
+    return;
+  }
+
+  // Wait for a random time up to 5 minutes.
+  // This is to avoid all the functions updating at the same time which may result in throttling errors.
+  await waitRandomTime();
+
+  // Update the function configuration with the new layer version
+  try {
+    const response = await updateFunction(layerArn);
+    console.log(`Updated layer version to ${layerArn}`, response);
+  } catch (e) {
+    console.error('Error Updating layer', e);
+    throw e;
+  }
+};

package/rds-patching-lambda/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2015",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    "rootDir": "./src",                                  /* Specify the root folder within your source files. */
+    "moduleResolution": "node",                          /* Specify how TypeScript looks up a file from a given module specifier. */
+    "outDir": "./lib",                                   /* Specify an output folder for all emitted files. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  }
+}

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

@@ -1159,10 +1159,8 @@ describe('ModelTransformer: ', () => {
           ConflictHandler: ConflictHandlerType.AUTOMERGE,
         },
       },
+      sandboxModeEnabled: true,
       transformers: [new ModelTransformer()],
-      transformParameters: {
-        sandboxModeEnabled: true,
-      },
     });
     const out = transformer.transform(validSchema);
     expect(out).toBeDefined();
@@ -1252,10 +1250,8 @@ describe('ModelTransformer: ', () => {
           }
         }
       },
-      transformers: [new ModelTransformer()],
-      transformParameters: {
-        sandboxModeEnabled: true,
-      },
+      sandboxModeEnabled: true,
+      transformers: [new ModelTransformer()]
     });
     const out = transformer.transform(validSchema);
     expect(out).toBeDefined();
@@ -1341,10 +1337,8 @@ describe('ModelTransformer: ', () => {
       name: String
     }`;
     const transformer = new GraphQLTransform({
+      sandboxModeEnabled: true,
       transformers: [new ModelTransformer()],
-      transformParameters: {
-        sandboxModeEnabled: true,
-      },
     });
     const out = transformer.transform(validSchema);
 
@@ -1380,10 +1374,8 @@ describe('ModelTransformer: ', () => {
           },
         ],
       },
+      sandboxModeEnabled: true,
       transformers: [new ModelTransformer()],
-      transformParameters: {
-        sandboxModeEnabled: true,
-      }
     });
     const out = transformer.transform(validSchema);
     expect(out).toBeDefined();

package/src/definitions.ts

@@ -18,7 +18,5 @@ export const FLOAT_FUNCTIONS = new Set<string>(['attributeExists', 'attributeTyp
 export const BOOLEAN_FUNCTIONS = new Set<string>(['attributeExists', 'attributeType']);
 
 export const ATTRIBUTE_TYPES = ['binary', 'binarySet', 'bool', 'list', 'map', 'number', 'numberSet', 'string', 'stringSet', '_null'];
-
 export const OPERATION_KEY = '__operation';
-
 export const API_KEY_DIRECTIVE = 'aws_api_key';

package/src/graphql-model-transformer.ts

@@ -291,7 +291,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
         }
       }
       // global auth check
-      if (!hasAuth && ctx.transformParameters.sandboxModeEnabled && ctx.authConfig.defaultAuthentication.authenticationType !== 'API_KEY') {
+      if (!hasAuth && ctx.sandboxModeEnabled && ctx.authConfig.defaultAuthentication.authenticationType !== 'API_KEY') {
         const apiKeyDirArray = [makeDirective(API_KEY_DIRECTIVE, [])];
         extendTypeWithDirectives(ctx, def.name.value, apiKeyDirArray);
         propagateApiKeyToNestedTypes(ctx as TransformerContextProvider, def, new Set<string>());

package/src/resolvers/dynamodb/mutation.ts

@@ -220,7 +220,7 @@ export const generateCreateRequestTemplate = (modelName: string, modelIndexField
  * Generate mapping template that sets default values for create mutation
  * @param modelConfig directive configuration
  */
-export const generateCreateInitSlotTemplate = (modelConfig: ModelDirectiveConfiguration): string => {
+export const generateCreateInitSlotTemplate = (modelConfig: ModelDirectiveConfiguration, initializeIdField: boolean): string => {
   const statements: Expression[] = [
     // initialize defaultValues
     qref(

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

@@ -28,8 +28,8 @@ export class DynamoDBModelVTLGenerator implements ModelVTLGenerator {
   generateCreateRequestTemplate(config: ModelCreateRequestConfig): string {
     return generateCreateRequestTemplate(config.modelName, config.modelIndexFields);
   }
-  generateCreateInitSlotTemplate(config: ModelCreateInitSlotConfig): string {
-    return generateCreateInitSlotTemplate(config.modelConfig);
+  generateCreateInitSlotTemplate(config: ModelCreateInitSlotConfig, initializeIdField: boolean): string {
+    return generateCreateInitSlotTemplate(config.modelConfig, initializeIdField);
   }
   generateDeleteRequestTemplate(config: ModelUpdateRequestConfig): string {
     return generateDeleteRequestTemplate(config.modelName, config.isSyncEnabled);

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

@@ -30,8 +30,8 @@ export class RDSModelVTLGenerator implements ModelVTLGenerator {
   generateCreateRequestTemplate(config: ModelCreateRequestConfig): string {
     return generateLambdaCreateRequestTemplate(config.modelName, config.operationName);
   }
-  generateCreateInitSlotTemplate(config: ModelCreateInitSlotConfig): string {
-    return generateCreateInitSlotTemplate(config.modelConfig);
+  generateCreateInitSlotTemplate(config: ModelCreateInitSlotConfig, initializeIdField: boolean): string {
+    return generateCreateInitSlotTemplate(config.modelConfig, initializeIdField);
   }
   generateDeleteRequestTemplate(config: ModelUpdateRequestConfig): string {
     return generateLambdaDeleteRequestTemplate(config.modelName, config.operationName, config.modelIndexFields ?? ['id']);

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

@@ -33,7 +33,7 @@ export type ModelDefaultResponseConfig = ModelRequestConfig & {
 export interface ModelVTLGenerator {
   generateUpdateRequestTemplate(config: ModelUpdateRequestConfig): string;
   generateCreateRequestTemplate(config: ModelCreateRequestConfig): string;
-  generateCreateInitSlotTemplate(config: ModelCreateInitSlotConfig): string;
+  generateCreateInitSlotTemplate(config: ModelCreateInitSlotConfig, initializeIdField: boolean): string;
   generateDeleteRequestTemplate(config: ModelDeleteRequestConfig): string;
   generateUpdateInitSlotTemplate(config: ModelUpdateInitSlotConfig): string;
   generateGetRequestTemplate(config: ModelRequestConfig): string;

package/src/resolvers/rds/mutation.ts

@@ -17,7 +17,7 @@ import { ModelDirectiveConfiguration } from '../../directive';
  * Generate mapping template that sets default values for create mutation
  * @param modelConfig directive configuration
  */
-export const generateCreateInitSlotTemplate = (modelConfig: ModelDirectiveConfiguration): string => {
+export const generateCreateInitSlotTemplate = (modelConfig: ModelDirectiveConfiguration, initializeIdField: boolean): string => {
   const statements: Expression[] = [
     // initialize defaultValues
     qref(
@@ -31,7 +31,9 @@ export const generateCreateInitSlotTemplate = (modelConfig: ModelDirectiveConfig
 
   if (modelConfig?.timestamps) {
     statements.push(set(ref('createdAt'), methodCall(ref('util.time.nowISO8601'))));
-    statements.push(qref(methodCall(ref('ctx.stash.defaultValues.put'), str('id'), methodCall(ref('util.autoId')))));
+    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'))));
     }
@@ -50,29 +52,27 @@ export const generateCreateInitSlotTemplate = (modelConfig: ModelDirectiveConfig
   return printBlock('Initialization default values')(compoundExpression(statements));
 };
 
-export const generateLambdaCreateRequestTemplate = (tableName: string, operationName: string): string => {
-  return 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')),
-      }),
-    ]),
-  );
-};
+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
@@ -109,49 +109,55 @@ export const generateUpdateInitSlotTemplate = (modelConfig: ModelDirectiveConfig
 /**
  * Generate VTL template that calls the lambda for an Update mutation
  */
-export const generateLambdaUpdateRequestTemplate = (tableName: string, operationName: string, modelIndexFields: string[]) => {
-  return 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({})))),
-      obj({
-        version: str('2018-05-29'),
-        operation: str('Invoke'),
-        payload: methodCall(ref('util.toJson'), ref('lambdaInput')),
-      }),
-    ]),
-  );
-};
+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[]) => {
-  return 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([])))),
-      obj({
-        version: str('2018-05-29'),
-        operation: str('Invoke'),
-        payload: methodCall(ref('util.toJson'), ref('lambdaInput')),
-      }),
-    ]),
-  );
-};
+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')),
+    }),
+  ]),
+);