serverless-spy 1.2.0 → 1.3.0

package/.jsii

@@ -3347,7 +3347,7 @@
   },
   "name": "serverless-spy",
   "readme": {
-    "markdown": "![ServerlessSpy](./logo/full_logo.svg)\n\nCDK-based library for writing elegant, fast-executing integration tests on AWS serverless architecture and an additional web console to monitor events in real time.\n\n# How it works\n\n**ServerlessSpy CDK construct creates infrastructure to intercept events in Lambda, SNS, SQS, EventBridge, DynamoDB, S3... and sends it to a testing library or your local web console via API Gateway WebSocket. The testing library subscribes to events so tests can be executed fast without checking/retrying if the process has finished. The testing library is integrated with Jest but can also be used with any other testing library. The web console can be used to see and inspect events in real time.**\n\n[![Concept](./doc/concept.svg)](https://serverlessspy.com/)\n\n**Your test for the example above would look something like this:**\n```typescript\n(\n  await serverlessSpyListener.waitForEventBridgeMyEventBus<TestData>({\n    condition: (d) => d.detail.id === id,\n  })\n).toMatchObject(...);\n\n(\n  await serverlessSpyListener.waitForSnsTopicMyTopic<TestData>({\n    condition: (d) => d.message.id === id,\n  })\n).toMatchObject(...);\n\n(\n  await serverlessSpyListener.waitForSqsMyQueue<TestData>({\n    condition: (d) => d.body.id === id,\n  })\n).toMatchObject(...);\n\n(\n  await (\n    await serverlessSpyListener.waitForFunctionMyLambdaRequest<TestData>({\n      condition: (d) => d.request.id === id,\n    })\n  ).followedByResponse();\n).toMatchObject(...);\n\n(\n  await serverlessSpyListener.waitForDynamoDBMyTable<TestData>({\n    condition: (d) => d.keys.pk === id,\n  })\n).toMatchObject({\n  eventName: 'INSERT',\n  newImage: ...,\n});\n```\n\n**You can see all the events in the local web console:**\n![Web console](./doc/web_console.gif)\n\n# Key benefits\n - **Easy** to write tests that are strongly typed thanks to TypeScript ❤️.\n - **Tests are executed much FASTER** 🏎️💨 No need to write tests in a way to periodically check if the process has finished because all events are pushed to the testing library.\n - **Tests can run in parallel** if you use conditions and filter events specific to your test. This drastically reduces the execution time of the CI/CD process.\n - **Web console** enables you to see all events in real time. Debugging 🕵 has never been easier. Search is supported (with regular expression).\n\n# What ServerlessSpy is not\n - ServerlessSpy can not be used if your infrastructure is not created with CDK.\n - The solution is meant only for the development and (automatic) testing environment. You should **EXCLUDE** ServerlessSpy CDK construct in any other environment, especially a production or a high-load environment. ServerlessSpy is not meant for those; it just induces costs and could contribute to hitting AWS quotas (Lambda concurrent executions, ...).\n - Only Node.js stack is supported. There are no plans to support Python or any other. Use of TypeScript is deeply encouraged.\n - Web console only runs on your local computer. No cloud hosting of any kind (for now).\n\n# Documentation\n - [Quick Start](doc/quick_start.md)\n - [CDK Construct](doc/CDK_construct.md)\n - [Writing Tests](doc/writing_tests.md)\n   - [Lambda](doc/Lambda.md)\n   - [SQS](doc/SQS.md)\n   - [SNS](doc/SNS.md)\n   - [EventBridge](doc/EventBridge.md)\n   - [DynamoDB](doc/DynamoDB.md)\n   - [S3](doc/S3.md)\n   - Kinesis (work in progress)\n   - Step Functions (work in progress)\n - [Web Console](doc/web_console.md)\n - [Frequently Asked Questions (FAQ)](doc/FAQ.md)\n - [Sample Application](https://github.com/ServerlessLife/serverless-spy-example){:target=\"_blank\"}\n - [Roadmap](doc/roadmap.md)\n - [Code of Conduct](doc/CODE_OF_CONDUCT.md)\n - [Contributing Guide](doc/CONTRIBUTING.md)\n - [Contributors](doc/Contributors.md)\n - [License](./LICENSE.md)"
+    "markdown": "![ServerlessSpy](./logo/full_logo.svg)\n\nCDK-based library for writing elegant, fast-executing integration tests on AWS serverless architecture and an additional web console to monitor events in real time.\n\n# How it works\n\n**ServerlessSpy CDK construct creates infrastructure to intercept events in Lambda, SNS, SQS, EventBridge, DynamoDB, S3... and sends it to a testing library or your local web console via API Gateway WebSocket. The testing library subscribes to events so tests can be executed fast without checking/retrying if the process has finished. The testing library is integrated with Jest but can also be used with any other testing library. The web console can be used to see and inspect events in real time.**\n\n[![Concept](./doc/concept.svg)](https://serverlessspy.com/)\n\n**Your test for the example above would look something like this:**\n```typescript\n(\n  await serverlessSpyListener.waitForEventBridgeMyEventBus<TestData>({\n    condition: (d) => d.detail.id === id,\n  })\n).toMatchObject(...);\n\n(\n  await serverlessSpyListener.waitForSnsTopicMyTopic<TestData>({\n    condition: (d) => d.message.id === id,\n  })\n).toMatchObject(...);\n\n(\n  await serverlessSpyListener.waitForSqsMyQueue<TestData>({\n    condition: (d) => d.body.id === id,\n  })\n).toMatchObject(...);\n\n(\n  await (\n    await serverlessSpyListener.waitForFunctionMyLambdaRequest<TestData>({\n      condition: (d) => d.request.id === id,\n    })\n  ).followedByResponse();\n).toMatchObject(...);\n\n(\n  await serverlessSpyListener.waitForDynamoDBMyTable<TestData>({\n    condition: (d) => d.keys.pk === id,\n  })\n).toMatchObject({\n  eventName: 'INSERT',\n  newImage: ...,\n});\n```\n\n**You can see all the events in the local web console:**\n![Web console](./doc/web_console.gif)\n\n# Key benefits\n - **Easy** to write tests that are strongly typed thanks to TypeScript ❤️.\n - **Tests are executed much FASTER** 🏎️💨 No need to write tests in a way to periodically check if the process has finished because all events are pushed to the testing library.\n - **Tests can run in parallel** if you use conditions and filter events specific to your test. This drastically reduces the execution time of the CI/CD process.\n - **Web console** enables you to see all events in real time. Debugging 🕵 has never been easier. Search is supported (with regular expression).\n\n# What ServerlessSpy is not\n - ServerlessSpy can not be used if your infrastructure is not created with CDK.\n - The solution is meant only for the development and (automatic) testing environment. You should **EXCLUDE** ServerlessSpy CDK construct in any other environment, especially a production or a high-load environment. ServerlessSpy is not meant for those; it just induces costs and could contribute to hitting AWS quotas (Lambda concurrent executions, ...).\n - Only Node.js stack is supported. There are no plans to support Python or any other. Use of TypeScript is deeply encouraged.\n - Web console only runs on your local computer. No cloud hosting of any kind (for now).\n\n# Documentation\n - [Quick Start](doc/quick_start.md)\n - [CDK Construct](doc/CDK_construct.md)\n - [Writing Tests](doc/writing_tests.md)\n   - [Lambda](doc/Lambda.md)\n   - [SQS](doc/SQS.md)\n   - [SNS](doc/SNS.md)\n   - [EventBridge](doc/EventBridge.md)\n   - [DynamoDB](doc/DynamoDB.md)\n   - [S3](doc/S3.md)\n   - Kinesis (work in progress)\n   - Step Functions (work in progress)\n - [Web Console](doc/web_console.md)\n - [Frequently Asked Questions (FAQ)](doc/FAQ.md)\n - [Sample Application](https://github.com/ServerlessLife/serverless-spy-example){:target=\"_blank\"}\n - [Roadmap](doc/roadmap.md)\n - [Code of Conduct](doc/CODE_OF_CONDUCT.md)\n - [Contributing Guide](doc/CONTRIBUTING.md)\n - [License](./LICENSE.md)\n\n# Contributors\n - [Hugo Lewenhaupt](https://github.com/Lewenhaupt)\n - ⭐⭐⭐ place for your name ⭐⭐⭐"
   },
   "repository": {
     "type": "git",
@@ -3724,6 +3724,6 @@
       "symbolId": "src/ServerlessSpy:SpyFilter"
     }
   },
-  "version": "1.2.0",
-  "fingerprint": "vDOcVERbIQZ52jsl4PmUkXsW3onZ3JEZPcUjhtdYO6U="
+  "version": "1.3.0",
+  "fingerprint": "/tOVhx2e5Ip4D6CT7XIt1RHqG1j8UZLIPKMImPI2U/g="
 }

package/README.md

@@ -1,6 +1,6 @@
 ![ServerlessSpy](./logo/full_logo.svg)
 
-CDK-based library for writing elegant, fast-executing integration tests on AWS serverless architecture and an additional web console to monitor events in real time. 
+CDK-based library for writing elegant, fast-executing integration tests on AWS serverless architecture and an additional web console to monitor events in real time.
 
 # How it works
 
@@ -56,7 +56,7 @@ CDK-based library for writing elegant, fast-executing integration tests on AWS s
  - **Web console** enables you to see all events in real time. Debugging 🕵 has never been easier. Search is supported (with regular expression).
 
 # What ServerlessSpy is not
- - ServerlessSpy can not be used if your infrastructure is not created with CDK. 
+ - ServerlessSpy can not be used if your infrastructure is not created with CDK.
  - The solution is meant only for the development and (automatic) testing environment. You should **EXCLUDE** ServerlessSpy CDK construct in any other environment, especially a production or a high-load environment. ServerlessSpy is not meant for those; it just induces costs and could contribute to hitting AWS quotas (Lambda concurrent executions, ...).
  - Only Node.js stack is supported. There are no plans to support Python or any other. Use of TypeScript is deeply encouraged.
  - Web console only runs on your local computer. No cloud hosting of any kind (for now).
@@ -64,20 +64,23 @@ CDK-based library for writing elegant, fast-executing integration tests on AWS s
 # Documentation
  - [Quick Start](doc/quick_start.md)
  - [CDK Construct](doc/CDK_construct.md)
- - [Writing Tests](doc/writing_tests.md) 
-   - [Lambda](doc/Lambda.md) 
+ - [Writing Tests](doc/writing_tests.md)
+   - [Lambda](doc/Lambda.md)
    - [SQS](doc/SQS.md)
    - [SNS](doc/SNS.md)
    - [EventBridge](doc/EventBridge.md)
    - [DynamoDB](doc/DynamoDB.md)
-   - [S3](doc/S3.md)   
+   - [S3](doc/S3.md)
    - Kinesis (work in progress)
    - Step Functions (work in progress)
- - [Web Console](doc/web_console.md)  
- - [Frequently Asked Questions (FAQ)](doc/FAQ.md)  
+ - [Web Console](doc/web_console.md)
+ - [Frequently Asked Questions (FAQ)](doc/FAQ.md)
  - [Sample Application](https://github.com/ServerlessLife/serverless-spy-example){:target="_blank"}
- - [Roadmap](doc/roadmap.md)   
- - [Code of Conduct](doc/CODE_OF_CONDUCT.md) 
- - [Contributing Guide](doc/CONTRIBUTING.md) 
- - [Contributors](doc/Contributors.md)  
- - [License](./LICENSE.md)   
+ - [Roadmap](doc/roadmap.md)
+ - [Code of Conduct](doc/CODE_OF_CONDUCT.md)
+ - [Contributing Guide](doc/CONTRIBUTING.md)
+ - [License](./LICENSE.md)
+
+# Contributors
+ - [Hugo Lewenhaupt](https://github.com/Lewenhaupt)
+ - ⭐⭐⭐ place for your name ⭐⭐⭐

package/cli/cli.ts

@@ -46,7 +46,7 @@ async function run() {
   progam.parse(process.argv);
 
   if (!options.ws && !options.cdkoutput) {
-    throw new Error('--ws or --cdkstack parameter not specified');
+    throw new Error('--ws or --cdkoutput parameter not specified');
   }
 
   if (options.cdkoutput) {
@@ -195,6 +195,13 @@ function getNpmModuleInstalledPath(npm: string) {
     return folderAsPackage;
   }
 
+  // When boostrap ends up in importing projects root node_modules and not in serverless-spys node_modules
+  folderAsPackage = path.join(__dirname, '../../../../', 'node_modules', npm);
+
+  if (fs.existsSync(folderAsPackage)) {
+    return folderAsPackage;
+  }
+
   throw new Error(
     `Can not find package in folder ${folder} and ${folderAsPackage}`
   );

package/dist/releasetag.txt

@@ -1 +1 @@
-v1.2.0
+v1.3.0

package/extension/aws/Errors.js

@@ -0,0 +1,124 @@
+/**
+ * Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * This code was copied from:
+ * https://github.com/aws/aws-lambda-nodejs-runtime-interface-client
+ *
+ * Defines custom error types throwable by the runtime.
+ */
+
+'use strict';
+
+const util = require('util');
+
+function _isError(obj) {
+  return (
+    obj &&
+    obj.name &&
+    obj.message &&
+    obj.stack &&
+    typeof obj.name === 'string' &&
+    typeof obj.message === 'string' &&
+    typeof obj.stack === 'string'
+  );
+}
+
+function intoError(err) {
+  if (err instanceof Error) {
+    return err;
+  } else {
+    return new Error(err);
+  }
+}
+
+module.exports.intoError = intoError;
+
+/**
+ * Attempt to convert an object into a response object.
+ * This method accounts for failures when serializing the error object.
+ */
+function toRapidResponse(error) {
+  try {
+    if (util.types.isNativeError(error) || _isError(error)) {
+      return {
+        errorType: error.name,
+        errorMessage: error.message,
+        trace: error.stack.split('\n'),
+      };
+    } else {
+      return {
+        errorType: typeof error,
+        errorMessage: error.toString(),
+        trace: [],
+      };
+    }
+  } catch (_err) {
+    return {
+      errorType: 'handled',
+      errorMessage:
+        'callback called with Error argument, but there was a problem while retrieving one or more of its message, name, and stack',
+    };
+  }
+}
+
+module.exports.toRapidResponse = toRapidResponse;
+
+/**
+ * Format an error with the expected properties.
+ * For compatability, the error string always starts with a tab.
+ */
+module.exports.toFormatted = (error) => {
+  try {
+    return (
+      '\t' + JSON.stringify(error, (_k, v) => _withEnumerableProperties(v))
+    );
+  } catch (err) {
+    return '\t' + JSON.stringify(toRapidResponse(error));
+  }
+};
+
+/**
+ * Error name, message, code, and stack are all members of the superclass, which
+ * means they aren't enumerable and don't normally show up in JSON.stringify.
+ * This method ensures those interesting properties are available along with any
+ * user-provided enumerable properties.
+ */
+function _withEnumerableProperties(error) {
+  if (error instanceof Error) {
+    let ret = Object.assign(
+      {
+        errorType: error.name,
+        errorMessage: error.message,
+        code: error.code,
+      },
+      error
+    );
+    if (typeof error.stack == 'string') {
+      ret.stack = error.stack.split('\n');
+    }
+    return ret;
+  } else {
+    return error;
+  }
+}
+
+const errorClasses = [
+  class ImportModuleError extends Error {},
+  class HandlerNotFound extends Error {},
+  class MalformedHandlerName extends Error {},
+  class UserCodeSyntaxError extends Error {},
+  class MalformedStreamingHandler extends Error {},
+  class InvalidStreamingOperation extends Error {},
+  class UnhandledPromiseRejection extends Error {
+    constructor(reason, promise) {
+      super(reason);
+      this.reason = reason;
+      this.promise = promise;
+    }
+  },
+];
+
+errorClasses.forEach((e) => {
+  module.exports[e.name] = e;
+  e.prototype.name = `Runtime.${e.name}`;
+});

package/extension/aws/HttpResponseStream.js

@@ -0,0 +1,36 @@
+/**
+ * Copyright 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * This code was copied from:
+ * https://github.com/aws/aws-lambda-nodejs-runtime-interface-client
+ *
+ * HttpResponseStream is NOT used by the runtime.
+ * It is only exposed in the `awslambda` variable for customers to use.
+ */
+
+'use strict';
+
+const METADATA_PRELUDE_CONTENT_TYPE =
+  'application/vnd.awslambda.http-integration-response';
+const DELIMITER_LEN = 8;
+
+// Implements the application/vnd.awslambda.http-integration-response content type.
+class HttpResponseStream {
+  static from(underlyingStream, prelude) {
+    underlyingStream.setContentType(METADATA_PRELUDE_CONTENT_TYPE);
+
+    // JSON.stringify is required. NULL byte is not allowed in metadataPrelude.
+    const metadataPrelude = JSON.stringify(prelude);
+
+    underlyingStream._onBeforeFirstWrite = (write) => {
+      write(metadataPrelude);
+
+      // Write 8 null bytes after the JSON prelude.
+      write(new Uint8Array(DELIMITER_LEN));
+    };
+
+    return underlyingStream;
+  }
+}
+
+module.exports.HttpResponseStream = HttpResponseStream;

package/extension/aws/UserFunction.js

@@ -0,0 +1,324 @@
+/**
+ * Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * This code was copied from:
+ * https://github.com/aws/aws-lambda-nodejs-runtime-interface-client
+ *
+ * This module defines the functions for loading the user's code as specified
+ * in a handler string.
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const {
+  HandlerNotFound,
+  MalformedHandlerName,
+  ImportModuleError,
+  UserCodeSyntaxError,
+} = require('./Errors.js');
+const { verbose } = require('./VerboseLog.js').logger('LOADER');
+const { HttpResponseStream } = require('./HttpResponseStream');
+
+const FUNCTION_EXPR = /^([^.]*)\.(.*)$/;
+const RELATIVE_PATH_SUBSTRING = '..';
+const HANDLER_STREAMING = Symbol.for('aws.lambda.runtime.handler.streaming');
+const HANDLER_HIGHWATERMARK = Symbol.for(
+  'aws.lambda.runtime.handler.streaming.highWaterMark'
+);
+const STREAM_RESPONSE = 'response';
+
+// `awslambda.streamifyResponse` function is provided by default.
+const NoGlobalAwsLambda =
+  process.env['AWS_LAMBDA_NODEJS_NO_GLOBAL_AWSLAMBDA'] === '1' ||
+  process.env['AWS_LAMBDA_NODEJS_NO_GLOBAL_AWSLAMBDA'] === 'true';
+
+/**
+ * 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) {
+  let handlerString = path.basename(fullHandlerString);
+  let 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) {
+  let match = handler.match(FUNCTION_EXPR);
+  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, nestedProperty) {
+  return nestedProperty.split('.').reduce((nested, key) => {
+    return nested && nested[key];
+  }, object);
+}
+
+function _tryRequireFile(file, extension) {
+  const path = file + (extension || '');
+  verbose('Try loading as commonjs:', path);
+  return fs.existsSync(path) ? require(path) : undefined;
+}
+
+async function _tryAwaitImport(file, extension) {
+  const path = file + (extension || '');
+  verbose('Try loading as esmodule:', path);
+
+  if (fs.existsSync(path)) {
+    return await import(path);
+  }
+
+  return undefined;
+}
+
+function _hasFolderPackageJsonTypeModule(folder) {
+  // Check if package.json exists, return true if type === "module" in package json.
+  // If there is no package.json, and there is a node_modules, return false.
+  // Check parent folder otherwise, if there is one.
+  if (folder.endsWith('/node_modules')) {
+    return false;
+  }
+
+  const pj = path.join(folder, '/package.json');
+  if (fs.existsSync(pj)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pj));
+      if (pkg) {
+        if (pkg.type === 'module') {
+          verbose('type: module detected in', pj);
+          return true;
+        } else {
+          verbose('type: module not detected in', pj);
+          return false;
+        }
+      }
+    } catch (e) {
+      console.warn(
+        `${pj} cannot be read, it will be ignored for ES module detection purposes.`,
+        e
+      );
+      return false;
+    }
+  }
+
+  if (folder === '/') {
+    // We have reached root without finding either a package.json or a node_modules.
+    return false;
+  }
+
+  return _hasFolderPackageJsonTypeModule(path.resolve(folder, '..'));
+}
+
+function _hasPackageJsonTypeModule(file) {
+  // File must have a .js extension
+  const jsPath = file + '.js';
+  return fs.existsSync(jsPath)
+    ? _hasFolderPackageJsonTypeModule(path.resolve(path.dirname(jsPath)))
+    : false;
+}
+
+/**
+ * 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().
+ */
+async function _tryRequire(appRoot, moduleRoot, module) {
+  verbose(
+    'Try loading as commonjs: ',
+    module,
+    ' with paths: ,',
+    appRoot,
+    moduleRoot
+  );
+
+  const lambdaStylePath = path.resolve(appRoot, moduleRoot, module);
+
+  // Extensionless files are loaded via require.
+  const extensionless = _tryRequireFile(lambdaStylePath);
+  if (extensionless) {
+    return extensionless;
+  }
+
+  // If package.json type != module, .js files are loaded via require.
+  const pjHasModule = _hasPackageJsonTypeModule(lambdaStylePath);
+  if (!pjHasModule) {
+    const loaded = _tryRequireFile(lambdaStylePath, '.js');
+    if (loaded) {
+      return loaded;
+    }
+  }
+
+  // If still not loaded, try .js, .mjs, and .cjs in that order.
+  // Files ending with .js are loaded as ES modules when the nearest parent package.json
+  // file contains a top-level field "type" with a value of "module".
+  // https://nodejs.org/api/packages.html#packages_type
+  const loaded =
+    (pjHasModule && (await _tryAwaitImport(lambdaStylePath, '.js'))) ||
+    (await _tryAwaitImport(lambdaStylePath, '.mjs')) ||
+    _tryRequireFile(lambdaStylePath, '.cjs');
+  if (loaded) {
+    return loaded;
+  }
+
+  verbose(
+    'Try loading as commonjs: ',
+    module,
+    ' with path(s): ',
+    appRoot,
+    moduleRoot
+  );
+
+  // Why not just require(module)?
+  // Because require() is relative to __dirname, not process.cwd(). And the
+  // runtime implementation is not located in /var/task
+  // This won't work (yet) for esModules as import.meta.resolve is still experimental
+  // See: https://nodejs.org/api/esm.html#esm_import_meta_resolve_specifier_parent
+  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
+ */
+async function _loadUserApp(appRoot, moduleRoot, module) {
+  if (!NoGlobalAwsLambda) {
+    globalThis.awslambda = {
+      streamifyResponse: (handler, options) => {
+        handler[HANDLER_STREAMING] = STREAM_RESPONSE;
+        if (typeof options?.highWaterMark === 'number') {
+          handler[HANDLER_HIGHWATERMARK] = parseInt(options.highWaterMark);
+        }
+        return handler;
+      },
+      HttpResponseStream: HttpResponseStream,
+    };
+  }
+
+  try {
+    return await _tryRequire(appRoot, moduleRoot, module);
+  } catch (e) {
+    if (e instanceof SyntaxError) {
+      throw new UserCodeSyntaxError(e);
+    } else if (e.code !== undefined && e.code === 'MODULE_NOT_FOUND') {
+      verbose('globalPaths', JSON.stringify(require('module').globalPaths));
+      throw new ImportModuleError(e);
+    } else {
+      throw e;
+    }
+  }
+}
+
+function _throwIfInvalidHandler(fullHandlerString) {
+  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.`
+    );
+  }
+}
+
+function _isHandlerStreaming(handler) {
+  if (
+    typeof handler[HANDLER_STREAMING] === 'undefined' ||
+    handler[HANDLER_STREAMING] === null ||
+    handler[HANDLER_STREAMING] === false
+  ) {
+    return false;
+  }
+
+  if (handler[HANDLER_STREAMING] === STREAM_RESPONSE) {
+    return STREAM_RESPONSE;
+  } else {
+    throw new MalformedStreamingHandler(
+      'Only response streaming is supported.'
+    );
+  }
+}
+
+function _highWaterMark(handler) {
+  if (
+    typeof handler[HANDLER_HIGHWATERMARK] === 'undefined' ||
+    handler[HANDLER_HIGHWATERMARK] === null ||
+    handler[HANDLER_HIGHWATERMARK] === false
+  ) {
+    return undefined;
+  }
+
+  const hwm = parseInt(handler[HANDLER_HIGHWATERMARK]);
+  return isNaN(hwm) ? undefined : hwm;
+}
+
+/**
+ * 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.
+ */
+module.exports.load = async function (appRoot, fullHandlerString) {
+  _throwIfInvalidHandler(fullHandlerString);
+
+  let [moduleRoot, moduleAndHandler] = _moduleRootAndHandler(fullHandlerString);
+  let [module, handlerPath] = _splitHandlerString(moduleAndHandler);
+
+  let userApp = await _loadUserApp(appRoot, moduleRoot, module);
+  let 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;
+};
+
+module.exports.isHandlerFunction = function (value) {
+  return typeof value === 'function';
+};
+
+module.exports.getHandlerMetadata = function (handlerFunc) {
+  return {
+    streaming: _isHandlerStreaming(handlerFunc),
+    highWaterMark: _highWaterMark(handlerFunc),
+  };
+};
+
+module.exports.STREAM_RESPONSE = STREAM_RESPONSE;

package/extension/aws/VerboseLog.js

@@ -0,0 +1,53 @@
+/**
+ * Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * This code was copied from:
+ * https://github.com/aws/aws-lambda-nodejs-runtime-interface-client
+ *
+ */
+
+'use strict';
+
+const EnvVarName = 'AWS_LAMBDA_RUNTIME_VERBOSE';
+const Tag = 'RUNTIME';
+const Verbosity = (() => {
+  if (!process.env[EnvVarName]) {
+    return 0;
+  }
+
+  try {
+    const verbosity = parseInt(process.env[EnvVarName]);
+    return verbosity < 0 ? 0 : verbosity > 3 ? 3 : verbosity;
+  } catch (_) {
+    return 0;
+  }
+})();
+
+exports.logger = function (category) {
+  return {
+    verbose: function () {
+      if (Verbosity >= 1) {
+        const args = [...arguments].map((arg) =>
+          typeof arg === 'function' ? arg() : arg
+        );
+        console.log.apply(null, [Tag, category, ...args]);
+      }
+    },
+    vverbose: function () {
+      if (Verbosity >= 2) {
+        const args = [...arguments].map((arg) =>
+          typeof arg === 'function' ? arg() : arg
+        );
+        console.log.apply(null, [Tag, category, ...args]);
+      }
+    },
+    vvverbose: function () {
+      if (Verbosity >= 3) {
+        const args = [...arguments].map((arg) =>
+          typeof arg === 'function' ? arg() : arg
+        );
+        console.log.apply(null, [Tag, category, ...args]);
+      }
+    },
+  };
+};