serverless-offline 13.5.1 → 14.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "dedicatedTo": "Blue, a great migrating bird.",
   "name": "serverless-offline",
-  "version": "13.5.1",
+  "version": "14.0.0",
   "description": "Emulate AWS λ and API Gateway locally when developing your Serverless project",
   "license": "MIT",
   "exports": {
@@ -80,7 +80,7 @@
     "@aws-sdk/client-lambda": "^3.509.0",
     "@hapi/boom": "^10.0.1",
     "@hapi/h2o2": "^10.0.4",
-    "@hapi/hapi": "^21.3.3",
+    "@hapi/hapi": "^21.3.10",
     "array-unflat-js": "^0.1.3",
     "boxen": "^7.1.1",
     "chalk": "^5.3.0",
@@ -89,33 +89,35 @@
     "fs-extra": "^11.2.0",
     "is-wsl": "^3.1.0",
     "java-invoke-local": "0.0.6",
-    "jose": "^5.2.1",
+    "jose": "^5.6.3",
     "js-string-escape": "^1.0.1",
-    "jsonpath-plus": "^8.0.0",
+    "jsonpath-plus": "^9.0.0",
     "jsonschema": "^1.4.1",
     "jszip": "^3.10.1",
     "luxon": "^3.4.4",
     "node-schedule": "^2.1.1",
     "p-memoize": "^7.1.1",
+    "tree-kill": "^1.2.2",
+    "tsx": "^4.16.2",
     "velocityjs": "^2.0.6",
-    "ws": "^8.16.0"
+    "ws": "^8.18.0"
   },
   "devDependencies": {
     "@istanbuljs/esm-loader-hook": "^0.2.0",
-    "archiver": "^6.0.1",
-    "commit-and-tag-version": "^12.2.0",
-    "eslint": "^8.56.0",
+    "archiver": "^7.0.1",
+    "commit-and-tag-version": "^12.4.1",
+    "eslint": "^8.57.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-prettier": "^5.1.3",
-    "eslint-plugin-unicorn": "^51.0.1",
-    "mocha": "^10.3.0",
-    "nyc": "^15.1.0",
-    "prettier": "^3.2.5",
-    "serverless": "^3.38.0"
+    "eslint-plugin-unicorn": "^54.0.0",
+    "mocha": "^10.6.0",
+    "nyc": "^17.0.0",
+    "prettier": "^3.3.2",
+    "serverless": "^4.1.18"
   },
   "peerDependencies": {
-    "serverless": "^3.2.0"
+    "serverless": "^4.0.0"
   }
 }

package/src/config/supportedRuntimes.js

@@ -31,6 +31,7 @@ export const supportedRuntimesArchitecture = {
   provided: [X86_64],
   dotnet6: [ARM64, X86_64],
   "provided.al2": [ARM64, X86_64],
+  "provided.al2023": [ARM64, X86_64],
 }
 
 // GO
@@ -48,7 +49,11 @@ export const supportedNodejs = new Set([
 ])
 
 // PROVIDED
-export const supportedProvided = new Set(["provided", "provided.al2"])
+export const supportedProvided = new Set([
+  "provided",
+  "provided.al2",
+  "provided.al2023",
+])
 
 // PYTHON
 export const supportedPython = new Set([
@@ -57,6 +62,7 @@ export const supportedPython = new Set([
   "python3.9",
   "python3.10",
   "python3.11",
+  "python3.12",
 ])
 
 // RUBY

package/src/events/alb/HttpServer.js

@@ -267,6 +267,8 @@ export default class HttpServer {
         override: false,
       })
 
+      response.headers = headers
+
       if (typeof result === "string") {
         response.source = stringify(result)
       } else if (result && result.body !== undefined) {

package/src/events/authMatchPolicyResource.js

@@ -1,7 +1,8 @@
 function parseResource(resource) {
-  const [, region, accountId, restApiId, path] = resource.match(
-    /arn:aws:execute-api:(.*?):(.*?):(.*?)\/(.*)/,
-  )
+  const [, region = "*", accountId = "*", restApiId = "*", path = "*"] =
+    resource.match(
+      /arn:aws:execute-api:([^\s:]+)(?::([^\s:]+))?(?::([^\s/:]+))?(?:\/(.*))?/,
+    )
 
   return {
     accountId,
@@ -26,10 +27,6 @@ export default function authMatchPolicyResource(policyResource, resource) {
     return true
   }
 
-  if (policyResource === "arn:aws:execute-api:*:*:*") {
-    return true
-  }
-
   if (policyResource.includes("*") || policyResource.includes("?")) {
     // Policy contains a wildcard resource
 
@@ -61,7 +58,7 @@ export default function authMatchPolicyResource(policyResource, resource) {
     // for the requested resource and the resource defined in the policy
     // Need to create a regex replacing ? with one character and * with any number of characters
     const regExp = new RegExp(
-      parsedPolicyResource.path.replaceAll("*", ".*").replaceAll("?", "."),
+      `${parsedPolicyResource.path.replaceAll("*", ".*").replaceAll("?", ".")}$`,
     )
 
     return regExp.test(parsedResource.path)

package/src/events/http/HttpServer.js

@@ -295,7 +295,7 @@ export default class HttpServer {
       return null
     }
 
-    const authFunctionName = this.#extractAuthFunctionName(endpoint)
+    let authFunctionName = this.#extractAuthFunctionName(endpoint)
 
     if (!authFunctionName) {
       return null
@@ -303,16 +303,32 @@ export default class HttpServer {
 
     log.notice(`Configuring Authorization: ${path} ${authFunctionName}`)
 
+    const standardFunctionExists =
+      this.#serverless.service.functions &&
+      this.#serverless.service.functions[authFunctionName]
+    const serverlessAuthorizerOptions =
+      this.#serverless.service.provider.httpApi &&
+      this.#serverless.service.provider.httpApi.authorizers &&
+      this.#serverless.service.provider.httpApi.authorizers[authFunctionName]
+
+    if (
+      !standardFunctionExists &&
+      endpoint.isHttpApi &&
+      serverlessAuthorizerOptions &&
+      serverlessAuthorizerOptions.functionName
+    ) {
+      log.notice(
+        `Redirecting authorizer function: ${authFunctionName} to ${serverlessAuthorizerOptions.functionName}`,
+      )
+      authFunctionName = serverlessAuthorizerOptions.functionName
+    }
+
     const authFunction = this.#serverless.service.getFunction(authFunctionName)
 
     if (!authFunction) {
       log.error(`Authorization function ${authFunctionName} does not exist`)
       return null
     }
-    const serverlessAuthorizerOptions =
-      this.#serverless.service.provider.httpApi &&
-      this.#serverless.service.provider.httpApi.authorizers &&
-      this.#serverless.service.provider.httpApi.authorizers[authFunctionName]
 
     const authorizerOptions = {
       enableSimpleResponses:
@@ -326,7 +342,8 @@ export default class HttpServer {
         ? serverlessAuthorizerOptions?.payloadVersion || "2.0"
         : "1.0",
       resultTtlInSeconds:
-        serverlessAuthorizerOptions?.resultTtlInSeconds || "300",
+        serverlessAuthorizerOptions?.resultTtlInSeconds ?? "300",
+      type: endpoint.isHttpApi ? serverlessAuthorizerOptions?.type : undefined,
     }
 
     if (
@@ -339,11 +356,10 @@ export default class HttpServer {
       return null
     }
 
-    if (typeof endpoint.authorizer === "string") {
-      authorizerOptions.name = authFunctionName
-    } else {
+    if (typeof endpoint.authorizer !== "string") {
       assign(authorizerOptions, endpoint.authorizer)
     }
+    authorizerOptions.name = authFunctionName
 
     if (
       !authorizerOptions.identitySource &&
@@ -443,7 +459,7 @@ export default class HttpServer {
       request.payload = request.payload && request.payload.toString(encoding)
       request.rawPayload = request.payload
 
-      // incomming request message
+      // incoming request message
       log.notice()
 
       log.notice()

package/src/events/http/createJWTAuthScheme.js

@@ -5,7 +5,7 @@ import { log } from "../../utils/log.js"
 const { isArray } = Array
 const { now } = Date
 
-export default function createAuthScheme(jwtOptions) {
+export default function createJWTAuthScheme(jwtOptions) {
   const authorizerName = jwtOptions.name
 
   const identitySourceMatch = /^\$request.header.((?:\w+-?)+\w+)$/.exec(
@@ -43,7 +43,7 @@ export default function createAuthScheme(jwtOptions) {
           return Boom.unauthorized("JWT Token expired")
         }
 
-        const { aud, iss, scope, client_id: clientId } = claims
+        const { aud, iss, scope, scp, client_id: clientId } = claims
         if (iss !== jwtOptions.issuerUrl) {
           log.notice(`JWT Token not from correct issuer url`)
 
@@ -68,13 +68,13 @@ export default function createAuthScheme(jwtOptions) {
 
         let scopes = null
         if (jwtOptions.scopes && jwtOptions.scopes.length > 0) {
-          if (!scope) {
+          if (!scope && !scp) {
             log.notice(`JWT Token missing valid scope`)
 
             return Boom.forbidden("JWT Token missing valid scope")
           }
 
-          scopes = scope.split(" ")
+          scopes = scp || scope.split(" ")
           if (scopes.every((s) => !jwtOptions.scopes.includes(s))) {
             log.notice(`JWT Token missing valid scope`)
 
@@ -85,7 +85,6 @@ export default function createAuthScheme(jwtOptions) {
         log.notice(`JWT Token validated`)
 
         // Set the credentials for the rest of the pipeline
-        // return resolve(
         return h.authenticated({
           credentials: {
             claims,

package/src/events/http/lambda-events/LambdaProxyIntegrationEvent.js

@@ -134,8 +134,8 @@ export default class LambdaProxyIntegrationEvent {
     if (token) {
       try {
         claims = decodeJwt(token)
-        if (claims.scope) {
-          scopes = claims.scope.split(" ")
+        if (claims.scp || claims.scope) {
+          scopes = claims.scp || claims.scope.split(" ")
           // In AWS HTTP Api the scope property is removed from the decoded JWT
           // I'm leaving this property because I'm not sure how all of the authorizers
           // for AWS REST Api handle JWT.

package/src/events/http/lambda-events/LambdaProxyIntegrationEventV2.js

@@ -120,8 +120,8 @@ export default class LambdaProxyIntegrationEventV2 {
     if (token) {
       try {
         claims = decodeJwt(token)
-        if (claims.scope) {
-          scopes = claims.scope.split(" ")
+        if (claims.scp || claims.scope) {
+          scopes = claims.scp || claims.scope.split(" ")
           // In AWS HTTP Api the scope property is removed from the decoded JWT
           // I'm leaving this property because I'm not sure how all of the authorizers
           // for AWS REST Api handle JWT.

package/src/events/http/lambda-events/VelocityContext.js

@@ -10,7 +10,7 @@ const { assign, entries, fromEntries } = Object
 
 function escapeJavaScript(x) {
   if (typeof x === "string") {
-    return jsEscapeString(x).replaceAll("\\n", "\n") // See #26,
+    return jsEscapeString(x).replaceAll(String.raw`\n`, "\n") // See #26,
   }
 
   if (isPlainObject(x)) {

package/src/lambda/handler-runner/in-process-runner/aws-lambda-ric/Errors.js

@@ -0,0 +1,32 @@
+/* eslint-disable max-classes-per-file */
+/**
+ * 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/blob/main/src/Errors.js
+ *
+ * Defines custom error types throwable by the runtime.
+ */
+
+"use strict"
+
+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/src/lambda/handler-runner/in-process-runner/aws-lambda-ric/HttpResponseStream.js

@@ -0,0 +1,38 @@
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable no-param-reassign */
+/**
+ * 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/blob/main/src/HttpResponseStream.js
+ *
+ * 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/src/lambda/handler-runner/in-process-runner/aws-lambda-ric/UserFunction.js

@@ -1,359 +1,337 @@
+/* eslint-disable import/no-dynamic-require */
+/* eslint-disable global-require */
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable func-names */
+/**
+ * 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/blob/main/src/UserFunction.js
+ *
+ * This module defines the functions for loading the user's code as specified
+ * in a handler string.
+ */
+
 "use strict"
 
+const path = require("node:path")
 const { pathToFileURL } = require("node:url")
+const fs = require("node:fs")
+const process = require("node:process")
 
-// node_modules/lambda-runtime/dist/node16/UserFunction.js
-;(function () {
-  const __getOwnPropNames = Object.getOwnPropertyNames
-  const __commonJS = (cb, mod) =>
-    function __require() {
-      return (
-        mod ||
-          (0, cb[__getOwnPropNames(cb)[0]])(
-            (mod = { exports: {} }).exports,
-            mod,
-          ),
-        mod.exports
-      )
-    }
-  const require_Errors = __commonJS({
-    "Errors.js": function (exports2, module2) {
-      "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
-        }
-        return new Error(err)
-      }
-      module2.exports.intoError = intoError
-      function toRapidResponse(error) {
-        try {
-          if (util.types.isNativeError(error) || _isError(error)) {
-            return {
-              errorType: error.name,
-              errorMessage: error.message,
-              trace: error.stack.split("\n"),
-            }
-          }
-          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",
-          }
-        }
-      }
-      module2.exports.toRapidResponse = toRapidResponse
-      module2.exports.toFormatted = (error) => {
-        try {
-          return `      ${JSON.stringify(error, (_k, v) =>
-            _withEnumerableProperties(v),
-          )}`
-        } catch (err) {
-          return `      ${JSON.stringify(toRapidResponse(error))}`
-        }
-      }
-      function _withEnumerableProperties(error) {
-        if (error instanceof Error) {
-          const ret = {
-            errorType: error.name,
-            errorMessage: error.message,
-            code: error.code,
-            ...error,
-          }
-          if (typeof error.stack === "string") {
-            ret.stack = error.stack.split("\n")
-          }
-          return ret
-        }
-        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) => {
-        module2.exports[e.name] = e
-        e.prototype.name = `Runtime.${e.name}`
-      })
-    },
-  })
-  const require_VerboseLog = __commonJS({
-    "VerboseLog.js": function (exports2) {
-      "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
-        }
-      })()
-      exports2.logger = function (category) {
-        return {
-          verbose() {
-            if (Verbosity >= 1) {
-              console.log.apply(null, [Tag, category, ...arguments])
-            }
-          },
-          vverbose() {
-            if (Verbosity >= 2) {
-              console.log.apply(null, [Tag, category, ...arguments])
-            }
-          },
-          vvverbose() {
-            if (Verbosity >= 3) {
-              console.log.apply(null, [Tag, category, ...arguments])
-            }
-          },
-        }
-      }
-    },
-  })
-  const require_HttpResponseStream = __commonJS({
-    "HttpResponseStream.js": function (exports2, module2) {
-      "use strict"
-
-      const METADATA_PRELUDE_CONTENT_TYPE =
-        "application/vnd.awslambda.http-integration-response"
-      const DELIMITER_LEN = 8
-      const HttpResponseStream2 = class {
-        static from(underlyingStream, prelude) {
-          underlyingStream.setContentType(METADATA_PRELUDE_CONTENT_TYPE)
-          const metadataPrelude = JSON.stringify(prelude)
-          underlyingStream._onBeforeFirstWrite = (write) => {
-            write(metadataPrelude)
-            write(new Uint8Array(DELIMITER_LEN))
-          }
-          return underlyingStream
-        }
-      }
-      module2.exports.HttpResponseStream = HttpResponseStream2
-    },
-  })
-  const path = require("path")
-  const fs = require("fs")
-  const {
-    HandlerNotFound,
-    MalformedHandlerName,
-    ImportModuleError,
-    UserCodeSyntaxError,
-  } = require_Errors()
-  const { verbose } = require_VerboseLog().logger("LOADER")
-  const { HttpResponseStream } = require_HttpResponseStream()
-  const FUNCTION_EXPR = /^([^.]*)\.(.*)$/
-  const RELATIVE_PATH_SUBSTRING = ".."
-  const HANDLER_STREAMING = Symbol.for("aws.lambda.runtime.handler.streaming")
-  const STREAM_RESPONSE = "response"
-  const NoGlobalAwsLambda =
-    process.env.AWS_LAMBDA_NODEJS_NO_GLOBAL_AWSLAMBDA === "1" ||
-    process.env.AWS_LAMBDA_NODEJS_NO_GLOBAL_AWSLAMBDA === "true"
-  function _moduleRootAndHandler(fullHandlerString) {
-    const handlerString = path.basename(fullHandlerString)
-    const moduleRoot = fullHandlerString.substring(
-      0,
-      fullHandlerString.indexOf(handlerString),
-    )
-    return [moduleRoot, handlerString]
-  }
-  function _splitHandlerString(handler) {
-    const match = handler.match(FUNCTION_EXPR)
-    if (!match || match.length != 3) {
-      throw new MalformedHandlerName("Bad handler")
-    }
-    return [match[1], match[2]]
-  }
-  function _resolveHandler(object, nestedProperty) {
-    return nestedProperty.split(".").reduce((nested, key) => {
-      return nested && nested[key]
-    }, object)
+const { require: tsxRequire } = require(`tsx/cjs/api`)
+const {
+  HandlerNotFound,
+  MalformedHandlerName,
+  ImportModuleError,
+  UserCodeSyntaxError,
+  MalformedStreamingHandler,
+} = require("./Errors.js")
+const { verbose } = require("./VerboseLog.js").logger("LOADER")
+const { HttpResponseStream } = require("./HttpResponseStream.js")
+
+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) {
+  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) {
+  const match = handler.match(FUNCTION_EXPR)
+  if (!match || match.length !== 3) {
+    throw new MalformedHandlerName("Bad handler")
   }
-  function _tryRequireFile(file, extension) {
-    const path2 = file + (extension || "")
-    verbose("Try loading as commonjs:", path2)
-    return fs.existsSync(path2) ? require(path2) : void 0
+  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 pathRequireFile = file + (extension || "")
+  verbose("Try loading as commonjs:", pathRequireFile)
+  return fs.existsSync(pathRequireFile) ? require(pathRequireFile) : undefined
+}
+
+async function _tryAwaitImport(file, extension) {
+  const pathAwaitImport = file + (extension || "")
+  verbose("Try loading as esmodule:", pathAwaitImport)
+
+  if (fs.existsSync(pathAwaitImport)) {
+    // eslint-disable-next-line no-return-await
+    return await import(pathToFileURL(pathAwaitImport).href)
   }
-  async function _tryAwaitImport(file, extension) {
-    const path2 = file + (extension || "")
-    verbose("Try loading as esmodule:", path2)
-    if (fs.existsSync(path2)) {
-      return await import(pathToFileURL(path2).href)
-    }
-    return void 0
+
+  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
   }
-  function _hasFolderPackageJsonTypeModule(folder) {
-    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
-          }
-          verbose(`'type: module' not detected in ${pj}`)
-          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
         }
-      } catch (e) {
-        console.warn(
-          `${pj} cannot be read, it will be ignored for ES module detection purposes.`,
-          e,
-        )
+        verbose("type: module not detected in", pj)
         return false
       }
-    }
-    if (folder === "/") {
+    } catch (e) {
+      console.warn(
+        `${pj} cannot be read, it will be ignored for ES module detection purposes.`,
+        e,
+      )
       return false
     }
-    return _hasFolderPackageJsonTypeModule(path.resolve(folder, ".."))
   }
-  function _hasPackageJsonTypeModule(file) {
-    const jsPath = `${file}.js`
-    return fs.existsSync(jsPath)
-      ? _hasFolderPackageJsonTypeModule(path.resolve(path.dirname(jsPath)))
-      : false
+
+  if (folder === "/") {
+    // We have reached root without finding either a package.json or a node_modules.
+    return false
   }
-  async function _tryRequire(appRoot, moduleRoot, module2) {
-    verbose(
-      "Try loading as commonjs: ",
-      module2,
-      " with paths: ,",
-      appRoot,
-      moduleRoot,
-    )
-    const lambdaStylePath = path.resolve(appRoot, moduleRoot, module2)
-    const extensionless = _tryRequireFile(lambdaStylePath)
-    if (extensionless) {
-      return extensionless
-    }
-    const pjHasModule = _hasPackageJsonTypeModule(lambdaStylePath)
-    if (!pjHasModule) {
-      const loaded2 = _tryRequireFile(lambdaStylePath, ".js")
-      if (loaded2) {
-        return loaded2
-      }
-    }
-    const loaded =
-      (pjHasModule && (await _tryAwaitImport(lambdaStylePath, ".js"))) ||
-      (await _tryAwaitImport(lambdaStylePath, ".mjs")) ||
-      _tryRequireFile(lambdaStylePath, ".cjs")
+
+  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
     }
-    verbose(
-      "Try loading as commonjs: ",
-      module2,
-      " with path(s): ",
-      appRoot,
-      moduleRoot,
-    )
-    const nodeStylePath = require.resolve(module2, {
-      paths: [appRoot, moduleRoot],
-    })
-    return require(nodeStylePath)
   }
-  async function _loadUserApp(appRoot, moduleRoot, module2) {
-    if (!NoGlobalAwsLambda) {
-      globalThis.awslambda = {
-        streamifyResponse: (handler) => {
-          handler[HANDLER_STREAMING] = STREAM_RESPONSE
-          return handler
-        },
-        HttpResponseStream,
-      }
-    }
-    try {
-      return await _tryRequire(appRoot, moduleRoot, module2)
-    } catch (e) {
-      if (e instanceof SyntaxError) {
-        throw new UserCodeSyntaxError(e)
-      } else if (e.code !== void 0 && e.code === "MODULE_NOT_FOUND") {
-        verbose("globalPaths", JSON.stringify(require("module").globalPaths))
-        throw new ImportModuleError(e)
-      } else {
-        throw e
-      }
-    }
+
+  // If still not loaded, try .js, .mjs, .cjs and .ts 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") ||
+    tsxRequire(`${lambdaStylePath}.ts`, `${lambdaStylePath}.ts`)
+  if (loaded) {
+    return loaded
   }
-  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.`,
-      )
+
+  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 = {
+      HttpResponseStream,
+      streamifyResponse: (handler, options) => {
+        // eslint-disable-next-line no-param-reassign
+        handler[HANDLER_STREAMING] = STREAM_RESPONSE
+        if (typeof options?.highWaterMark === "number") {
+          // eslint-disable-next-line no-param-reassign
+          handler[HANDLER_HIGHWATERMARK] = Number.parseInt(
+            options.highWaterMark,
+            10,
+          )
+        }
+        return handler
+      },
     }
   }
-  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
+
+  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("node:module").globalPaths))
+      throw new ImportModuleError(e)
+    } else {
+      throw e
     }
-    throw new MalformedStreamingHandler("Only response streaming is supported.")
   }
-  module.exports.load = async function (appRoot, fullHandlerString) {
-    _throwIfInvalidHandler(fullHandlerString)
-    const [moduleRoot, moduleAndHandler] =
-      _moduleRootAndHandler(fullHandlerString)
-    const [module2, handlerPath] = _splitHandlerString(moduleAndHandler)
-    const userApp = await _loadUserApp(appRoot, moduleRoot, module2)
-    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
+}
+
+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.`,
+    )
   }
-  module.exports.getHandlerMetadata = function (handlerFunc) {
-    return {
-      streaming: _isHandlerStreaming(handlerFunc),
-    }
+}
+
+function _isHandlerStreaming(handler) {
+  if (
+    handler[HANDLER_STREAMING] === undefined ||
+    handler[HANDLER_STREAMING] === null ||
+    handler[HANDLER_STREAMING] === false
+  ) {
+    return false
+  }
+
+  if (handler[HANDLER_STREAMING] === STREAM_RESPONSE) {
+    return STREAM_RESPONSE
+  }
+  throw new MalformedStreamingHandler("Only response streaming is supported.")
+}
+
+function _highWaterMark(handler) {
+  if (
+    handler[HANDLER_HIGHWATERMARK] === undefined ||
+    handler[HANDLER_HIGHWATERMARK] === null ||
+    handler[HANDLER_HIGHWATERMARK] === false
+  ) {
+    return undefined
+  }
+
+  const hwm = Number.parseInt(handler[HANDLER_HIGHWATERMARK], 10)
+  return Number.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)
+
+  const [moduleRoot, moduleAndHandler] =
+    _moduleRootAndHandler(fullHandlerString)
+  const [module, handlerPath] = _splitHandlerString(moduleAndHandler)
+
+  const userApp = await _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
+}
+
+module.exports.isHandlerFunction = function (value) {
+  return typeof value === "function"
+}
+
+module.exports.getHandlerMetadata = function (handlerFunc) {
+  return {
+    highWaterMark: _highWaterMark(handlerFunc),
+    streaming: _isHandlerStreaming(handlerFunc),
   }
-  module.exports.STREAM_RESPONSE = STREAM_RESPONSE
-})()
+}
+
+module.exports.STREAM_RESPONSE = STREAM_RESPONSE

package/src/lambda/handler-runner/in-process-runner/aws-lambda-ric/VerboseLog.js

@@ -0,0 +1,54 @@
+/* eslint-disable prefer-rest-params */
+/* eslint-disable func-names */
+/**
+ * Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ */
+
+"use strict"
+
+const process = require("node:process")
+
+const EnvVarName = "AWS_LAMBDA_RUNTIME_VERBOSE"
+const Tag = "RUNTIME"
+const Verbosity = (() => {
+  if (!process.env[EnvVarName]) {
+    return 0
+  }
+
+  try {
+    const verbosity = Number.parseInt(process.env[EnvVarName], 10)
+    // eslint-disable-next-line unicorn/no-nested-ternary
+    return verbosity < 0 ? 0 : verbosity > 3 ? 3 : verbosity
+  } catch {
+    return 0
+  }
+})()
+
+exports.logger = function (category) {
+  return {
+    verbose() {
+      if (Verbosity >= 1) {
+        const args = [...arguments].map((arg) =>
+          typeof arg === "function" ? arg() : arg,
+        )
+        Reflect.apply(console.log, null, [Tag, category, ...args])
+      }
+    },
+    vverbose() {
+      if (Verbosity >= 2) {
+        const args = [...arguments].map((arg) =>
+          typeof arg === "function" ? arg() : arg,
+        )
+        Reflect.apply(console.log, null, [Tag, category, ...args])
+      }
+    },
+    vvverbose() {
+      if (Verbosity >= 3) {
+        const args = [...arguments].map((arg) =>
+          typeof arg === "function" ? arg() : arg,
+        )
+        Reflect.apply(console.log, null, [Tag, category, ...args])
+      }
+    },
+  }
+}

package/src/utils/index.js

@@ -21,13 +21,20 @@ export { generateAlbHapiPath } from "./generateHapiPath.js"
 const { isArray } = Array
 const { keys } = Object
 
+const possibleBinaryContentTypes = [
+  "application/octet-stream",
+  "multipart/form-data",
+]
+
 // Detect the toString encoding from the request headers content-type
 // enhance if further content types need to be non utf8 encoded.
 export function detectEncoding(request) {
   const contentType = request.headers["content-type"]
 
   return typeof contentType === "string" &&
-    contentType.includes("multipart/form-data")
+    possibleBinaryContentTypes.some((possibleBinaryContentType) =>
+      contentType.includes(possibleBinaryContentType),
+    )
     ? "binary"
     : "utf8"
 }