serverless-spy 1.2.0 → 1.3.1

package/extension/aws/Errors.ts

@@ -1,140 +0,0 @@
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-/* 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/Errors/index.ts
- *
- * Defines custom error types throwable by the runtime.
- */
-
-'use strict';
-
-import util from 'util';
-
-export function isError(obj: any): obj is Error {
-  return (
-    obj &&
-    obj.name &&
-    obj.message &&
-    obj.stack &&
-    typeof obj.name === 'string' &&
-    typeof obj.message === 'string' &&
-    typeof obj.stack === 'string'
-  );
-}
-
-interface RuntimeErrorResponse {
-  errorType: string;
-  errorMessage: string;
-  trace: string[];
-}
-
-/**
- * Attempt to convert an object into a response object.
- * This method accounts for failures when serializing the error object.
- */
-export function toRuntimeResponse(error: unknown): RuntimeErrorResponse {
-  try {
-    if (util.types.isNativeError(error) || isError(error)) {
-      if (!error.stack) {
-        throw new Error('Error stack is missing.');
-      }
-      return {
-        errorType: error.name,
-        errorMessage: error.message,
-        trace: error.stack.split('\n') || [],
-      };
-    } else {
-      return {
-        errorType: typeof error,
-        errorMessage: (error as any).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',
-      trace: [],
-    };
-  }
-}
-
-/**
- * Format an error with the expected properties.
- * For compatability, the error string always starts with a tab.
- */
-export const toFormatted = (error: unknown): string => {
-  try {
-    return (
-      '\t' + JSON.stringify(error, (_k, v) => _withEnumerableProperties(v))
-    );
-  } catch (err) {
-    return '\t' + JSON.stringify(toRuntimeResponse(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: any) {
-  if (error instanceof Error) {
-    const extendedError: ExtendedError = <ExtendedError>(<any>error);
-    const ret: any = Object.assign(
-      {
-        errorType: extendedError.name,
-        errorMessage: extendedError.message,
-        code: extendedError.code,
-      },
-      extendedError
-    );
-    if (typeof extendedError.stack === 'string') {
-      ret.stack = extendedError.stack.split('\n');
-    }
-    return ret;
-  } else {
-    return error;
-  }
-}
-
-export class ExtendedError extends Error {
-  code?: number;
-  custom?: string;
-  reason?: string;
-  promise?: Promise<any>;
-
-  constructor(reason?: string) {
-    super(reason); // 'Error' breaks prototype chain here
-    Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain
-  }
-}
-
-export class ImportModuleError extends ExtendedError {}
-export class HandlerNotFound extends ExtendedError {}
-export class MalformedHandlerName extends ExtendedError {}
-export class UserCodeSyntaxError extends ExtendedError {}
-export class UnhandledPromiseRejection extends ExtendedError {
-  constructor(reason?: string, promise?: Promise<any>) {
-    super(reason);
-    this.reason = reason;
-    this.promise = promise;
-  }
-}
-
-const errorClasses = [
-  ImportModuleError,
-  HandlerNotFound,
-  MalformedHandlerName,
-  UserCodeSyntaxError,
-  UnhandledPromiseRejection,
-];
-
-errorClasses.forEach((e) => {
-  e.prototype.name = `Runtime.${e.name}`;
-});

package/extension/aws/UserFunction.ts

@@ -1,169 +0,0 @@
-/* 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;
-};