serverless-spy 0.0.0

package/lambda-extension/aws/UserFunction.ts

@@ -0,0 +1,169 @@
+/* eslint-disable @typescript-eslint/no-require-imports */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * This code was copied from:
+ * https://raw.githubusercontent.com/aws/aws-lambda-nodejs-runtime-interface-client/main/src/utils/UserFunction.ts
+ *
+ * This module defines the functions for loading the user's code as specified
+ * in a handler string.
+ */
+
+'use strict';
+
+import fs from 'fs';
+import path from 'path';
+import { HandlerFunction } from './Common';
+import {
+  HandlerNotFound,
+  MalformedHandlerName,
+  ImportModuleError,
+  UserCodeSyntaxError,
+} from './Errors';
+
+const FUNCTION_EXPR = /^([^.]*)\.(.*)$/;
+const RELATIVE_PATH_SUBSTRING = '..';
+
+/**
+ * Break the full handler string into two pieces, the module root and the actual
+ * handler string.
+ * Given './somepath/something/module.nestedobj.handler' this returns
+ * ['./somepath/something', 'module.nestedobj.handler']
+ */
+function _moduleRootAndHandler(fullHandlerString: string): [string, string] {
+  const handlerString = path.basename(fullHandlerString);
+  const moduleRoot = fullHandlerString.substring(
+    0,
+    fullHandlerString.indexOf(handlerString)
+  );
+  return [moduleRoot, handlerString];
+}
+
+/**
+ * Split the handler string into two pieces: the module name and the path to
+ * the handler function.
+ */
+function _splitHandlerString(handler: string): [string, string] {
+  const match = handler.match(FUNCTION_EXPR);
+  // eslint-disable-next-line eqeqeq
+  if (!match || match.length != 3) {
+    throw new MalformedHandlerName('Bad handler');
+  }
+  return [match[1], match[2]]; // [module, function-path]
+}
+
+/**
+ * Resolve the user's handler function from the module.
+ */
+function _resolveHandler(object: any, nestedProperty: string): any {
+  return nestedProperty.split('.').reduce((nested, key) => {
+    return nested && nested[key];
+  }, object);
+}
+
+/**
+ * Verify that the provided path can be loaded as a file per:
+ * https://nodejs.org/dist/latest-v10.x/docs/api/modules.html#modules_all_together
+ * @param string - the fully resolved file path to the module
+ * @return bool
+ */
+function _canLoadAsFile(modulePath: string): boolean {
+  return fs.existsSync(modulePath) || fs.existsSync(modulePath + '.js');
+}
+
+/**
+ * Attempt to load the user's module.
+ * Attempts to directly resolve the module relative to the application root,
+ * then falls back to the more general require().
+ */
+function _tryRequire(appRoot: string, moduleRoot: string, module: string): any {
+  const lambdaStylePath = path.resolve(appRoot, moduleRoot, module);
+  if (_canLoadAsFile(lambdaStylePath)) {
+    return require(lambdaStylePath);
+  } else {
+    // Why not just require(module)?
+    // Because require() is relative to __dirname, not process.cwd()
+    const nodeStylePath = require.resolve(module, {
+      paths: [appRoot, moduleRoot],
+    });
+    return require(nodeStylePath);
+  }
+}
+
+/**
+ * Load the user's application or throw a descriptive error.
+ * @throws Runtime errors in two cases
+ *   1 - UserCodeSyntaxError if there's a syntax error while loading the module
+ *   2 - ImportModuleError if the module cannot be found
+ */
+function _loadUserApp(
+  appRoot: string,
+  moduleRoot: string,
+  module: string
+): any {
+  try {
+    return _tryRequire(appRoot, moduleRoot, module);
+  } catch (e: any) {
+    if (e instanceof SyntaxError) {
+      throw new UserCodeSyntaxError(<any>e);
+    } else if (e.code !== undefined && e.code === 'MODULE_NOT_FOUND') {
+      throw new ImportModuleError(e);
+    } else {
+      throw e;
+    }
+  }
+}
+
+function _throwIfInvalidHandler(fullHandlerString: string): void {
+  if (fullHandlerString.includes(RELATIVE_PATH_SUBSTRING)) {
+    throw new MalformedHandlerName(
+      `'${fullHandlerString}' is not a valid handler name. Use absolute paths when specifying root directories in handler names.`
+    );
+  }
+}
+
+/**
+ * Load the user's function with the approot and the handler string.
+ * @param appRoot {string}
+ *   The path to the application root.
+ * @param handlerString {string}
+ *   The user-provided handler function in the form 'module.function'.
+ * @return userFuction {function}
+ *   The user's handler function. This function will be passed the event body,
+ *   the context object, and the callback function.
+ * @throws In five cases:-
+ *   1 - if the handler string is incorrectly formatted an error is thrown
+ *   2 - if the module referenced by the handler cannot be loaded
+ *   3 - if the function in the handler does not exist in the module
+ *   4 - if a property with the same name, but isn't a function, exists on the
+ *       module
+ *   5 - the handler includes illegal character sequences (like relative paths
+ *       for traversing up the filesystem '..')
+ *   Errors for scenarios known by the runtime, will be wrapped by Runtime.* errors.
+ */
+export const load = function (
+  appRoot: string,
+  fullHandlerString: string
+): HandlerFunction {
+  _throwIfInvalidHandler(fullHandlerString);
+
+  const [moduleRoot, moduleAndHandler] =
+    _moduleRootAndHandler(fullHandlerString);
+  const [module, handlerPath] = _splitHandlerString(moduleAndHandler);
+
+  const userApp = _loadUserApp(appRoot, moduleRoot, module);
+  const handlerFunc = _resolveHandler(userApp, handlerPath);
+
+  if (!handlerFunc) {
+    throw new HandlerNotFound(
+      `${fullHandlerString} is undefined or not exported`
+    );
+  }
+
+  if (typeof handlerFunc !== 'function') {
+    throw new HandlerNotFound(`${fullHandlerString} is not a function`);
+  }
+
+  return handlerFunc;
+};

package/lambda-extension/interceptor.ts

@@ -0,0 +1,146 @@
+import { LambdaClient, InvokeCommand } from '@aws-sdk/client-lambda';
+import { Callback, Context, Handler } from 'aws-lambda';
+import { FunctionContext } from '../common/spyEvents/FunctionContext';
+import { FunctionErrorSpyEvent } from '../common/spyEvents/FunctionErrorSpyEvent';
+import { FunctionRequestSpyEvent } from '../common/spyEvents/FunctionRequestSpyEvent';
+import { FunctionResponseSpyEvent } from '../common/spyEvents/FunctionResponseSpyEvent';
+import { load } from './aws/UserFunction';
+
+const ORIGINAL_HANDLER_KEY = 'ORIGINAL_HANDLER';
+const fluentTestSendFunctionName = process.env.FLUENT_TEST_SEND_FUNCTION_NAME;
+const subscribedToSQS = process.env.FLUENT_TEST_SUBSCRIBED_TO_SQS === 'true';
+
+const lambdaClient = new LambdaClient({});
+
+// Wrap original handler.
+// Handler can be async or non-async:
+// https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-handler.html
+export const handler = (
+  event: any,
+  context: Context,
+  callback: Callback
+): Promise<any> | undefined => {
+  const promises: Promise<any>[] = [];
+
+  if (subscribedToSQS) {
+    // send raw message
+    console.log('EXTENSION: Send raw message for SQS');
+    const p = sendRawSpyEvent(event);
+    promises.push(p);
+  }
+
+  const contextSpy: FunctionContext = {
+    functionName: context.functionName,
+    awsRequestId: context.awsRequestId,
+    identity: context.identity,
+    clientContext: context.clientContext,
+  };
+
+  console.log('EXTENSION REQUEST:', JSON.stringify(event));
+  const key = `Function#${process.env.FUNCTION_NAME}#Request`;
+  const p = sendLambdaSpyEvent(key, <FunctionRequestSpyEvent>{
+    request: event,
+    context: contextSpy,
+  });
+  promises.push(p);
+
+  const originalHandler = getOriginalHandler();
+
+  const fail = (error: any) => {
+    const key = `Function#${process.env.FUNCTION_NAME}#Error`;
+    const p = sendLambdaSpyEvent(key, <FunctionErrorSpyEvent>{
+      request: event,
+      error,
+      context: contextSpy,
+    });
+    promises.push(p);
+    return Promise.all(promises);
+  };
+
+  const succeed = (response: any) => {
+    console.log('EXTENSION RESPONSE:', JSON.stringify(response));
+    const key = `Function#${process.env.FUNCTION_NAME}#Response`;
+    const p = sendLambdaSpyEvent(key, <FunctionResponseSpyEvent>{
+      request: event,
+      response,
+      context: contextSpy,
+    });
+    promises.push(p);
+    return Promise.all(promises);
+  };
+
+  const newCallback = (err: any, data: any) => {
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    (err ? fail(data) : succeed(data)).then(() => {
+      callback(err, data);
+    });
+  };
+
+  try {
+    const result = originalHandler(event, context, newCallback);
+
+    // Async handler returns Promise
+    if (isPromise(result)) {
+      return new Promise((resolve, reject) => {
+        (result as Promise<any>)
+          .then((response: any) =>
+            // The response is received via Promise
+            succeed(response).then(() => {
+              resolve(response);
+            })
+          )
+          .catch((error: any) =>
+            fail(error).then(() => {
+              reject(error);
+            })
+          );
+      });
+    }
+  } catch (error) {
+    // Even if the original handler is not async, we return the promise as an async handler so we can send an error message
+    return new Promise((_, reject) =>
+      fail(error).then(() => {
+        reject(error);
+      })
+    );
+  }
+};
+
+function isPromise(obj: any): boolean {
+  return typeof obj?.then === 'function';
+}
+
+async function sendLambdaSpyEvent(
+  serviceKey: string,
+  data: {
+    request: any;
+    response?: any;
+    error?: any;
+  }
+) {
+  await sendRawSpyEvent({
+    data,
+    serviceKey,
+  });
+}
+
+async function sendRawSpyEvent(data: any) {
+  const command = new InvokeCommand({
+    FunctionName: fluentTestSendFunctionName,
+    InvocationType: 'RequestResponse',
+    LogType: 'Tail',
+    Payload: JSON.stringify(data) as any,
+  });
+  await lambdaClient.send(command);
+}
+
+function getOriginalHandler(): Handler {
+  console.log('ORIGINAL_HANDLER_KEY', process.env[ORIGINAL_HANDLER_KEY]);
+
+  if (process.env[ORIGINAL_HANDLER_KEY] === undefined)
+    throw Error('Missing original handler');
+  return load(
+    process.env.LAMBDA_TASK_ROOT!,
+    process.env[ORIGINAL_HANDLER_KEY]
+  ) as Handler;
+}

package/lambda-extension/spy-wrapper

@@ -0,0 +1,4 @@
+#!/bin/bash
+export ORIGINAL_HANDLER=$_HANDLER
+export _HANDLER="interceptor.handler"
+exec "$@"

package/lambda-extension/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "display": "Node 16",
+  "compilerOptions": {
+    "lib": ["es2021"],
+    "module": "esnext",
+    "target": "es2017",
+    "strict": true,
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true
+  }
+}

package/lib/ServerlessSpy.d.ts

@@ -0,0 +1,27 @@
+import { Construct, IConstruct } from 'constructs';
+export declare class ServerlessSpy extends Construct {
+    private extensionLayer;
+    private table;
+    private webSocketApi;
+    private ownContructs;
+    private functionSubscriptionPool;
+    private functionSubscriptionMain;
+    private webSocketStage;
+    wsUrl: string;
+    constructor(scope: Construct, id: string);
+    private iterateAllElements;
+    private interceptSqs;
+    private createFunctionForSubscription;
+    private interceptS3;
+    private interceptDynamodb;
+    private interceptEventBusRule;
+    private interceptEventBus;
+    private interceptSnsTopic;
+    private interceptSnsSubscription;
+    private provideFunctionForSubscription;
+    private interceptFunction;
+    getConstructName(construct: IConstruct): string;
+    private getTopic;
+    private getEventBridge;
+    private findElement;
+}