serverless-offline 9.1.7 → 9.2.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "dedicatedTo": "Blue, a great migrating bird.",
   "name": "serverless-offline",
-  "version": "9.1.7",
+  "version": "9.2.2",
   "description": "Emulate AWS λ and API Gateway locally when developing your Serverless project",
   "license": "MIT",
   "main": "./src/index.js",
@@ -49,12 +49,6 @@
     "schedule",
     "websocket"
   ],
-  "files": [
-    "src/**",
-    "package.json",
-    "LICENSE",
-    "README.md"
-  ],
   "author": "David Hérault <dherault@gmail.com> (https://github.com/dherault)",
   "maintainers": [
     "Bilal Soylu (https://github.com/Bilal-S)",
@@ -195,7 +189,7 @@
     "@hapi/h2o2": "^9.1.0",
     "@hapi/hapi": "^20.2.2",
     "@serverless/utils": "^6.7.0",
-    "aws-sdk": "^2.1187.0",
+    "aws-sdk": "^2.1195.0",
     "boxen": "^7.0.0",
     "chalk": "^5.0.1",
     "execa": "^6.1.0",
@@ -217,7 +211,7 @@
   },
   "devDependencies": {
     "archiver": "^5.3.1",
-    "eslint": "^8.21.0",
+    "eslint": "^8.22.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-import": "^2.25.4",
@@ -227,7 +221,7 @@
     "lint-staged": "^13.0.3",
     "mocha": "^10.0.0",
     "prettier": "^2.7.1",
-    "serverless": "^3.21.0",
+    "serverless": "^3.22.0",
     "standard-version": "^9.5.0"
   },
   "peerDependencies": {

package/src/ServerlessOffline.js

@@ -245,9 +245,9 @@ export default class ServerlessOffline {
 
     log.notice()
     log.notice(
-      `Starting Offline at stage ${provider.stage} ${chalk.gray(
-        `(${provider.region})`,
-      )}`,
+      `Starting Offline at stage ${
+        this.#options.stage || provider.stage
+      } ${chalk.gray(`(${this.#options.region || provider.region})`)}`,
     )
     log.notice()
     log.debug('options:', this.#options)

package/src/lambda/LambdaFunction.js

@@ -13,7 +13,7 @@ import {
   DEFAULT_LAMBDA_TIMEOUT,
   supportedRuntimes,
 } from '../config/index.js'
-import { createUniqueId, splitHandlerPathAndName } from '../utils/index.js'
+import { createUniqueId } from '../utils/index.js'
 
 const { ceil } = Math
 const { entries, fromEntries } = Object
@@ -70,7 +70,6 @@ export default class LambdaFunction {
     const servicepath = resolve(servicePath, options.location || '')
 
     const { handler, name, package: functionPackage = {} } = functionDefinition
-    const [handlerPath, handlerName] = splitHandlerPathAndName(handler)
 
     const memorySize =
       functionDefinition.memorySize ||
@@ -140,8 +139,6 @@ export default class LambdaFunction {
         ? resolve(servicepath, functionPackage.artifact)
         : undefined,
       handler,
-      handlerName,
-      handlerPath: resolve(this.#codeDir, handlerPath),
       layers: functionDefinition.layers || [],
       provider,
       runtime,

package/src/lambda/handler-runner/HandlerRunner.js

@@ -24,11 +24,9 @@ export default class HandlerRunner {
 
   async #loadRunner() {
     const { useChildProcesses, useDocker, useInProcess } = this.#options
+    const { handler, runtime } = this.#funOptions
 
-    const { functionKey, handlerName, handlerPath, runtime, timeout } =
-      this.#funOptions
-
-    log.debug(`Loading handler... (${handlerPath})`)
+    log.debug(`Loading handler... (${handler})`)
 
     if (useDocker) {
       // https://github.com/lambci/docker-lambda/issues/329
@@ -71,13 +69,7 @@ export default class HandlerRunner {
           './in-process-runner/index.js'
         )
 
-        return new InProcessRunner(
-          functionKey,
-          handlerPath,
-          handlerName,
-          this.#env,
-          timeout,
-        )
+        return new InProcessRunner(this.#funOptions, this.#env)
       }
 
       const { default: WorkerThreadRunner } = await import(

package/src/lambda/handler-runner/child-process-runner/ChildProcessRunner.js

@@ -7,23 +7,26 @@ const __dirname = dirname(fileURLToPath(import.meta.url))
 const childProcessHelperPath = resolve(__dirname, 'childProcessHelper.js')
 
 export default class ChildProcessRunner {
+  #codeDir = null
+
   #env = null
 
   #functionKey = null
 
-  #handlerName = null
+  #handler = null
 
-  #handlerPath = null
+  #servicePath = null
 
   #timeout = null
 
   constructor(funOptions, env) {
-    const { functionKey, handlerName, handlerPath, timeout } = funOptions
+    const { codeDir, functionKey, handler, servicePath, timeout } = funOptions
 
+    this.#codeDir = codeDir
     this.#env = env
     this.#functionKey = functionKey
-    this.#handlerName = handlerName
-    this.#handlerPath = handlerPath
+    this.#handler = handler
+    this.#servicePath = servicePath
     this.#timeout = timeout
   }
 
@@ -34,7 +37,7 @@ export default class ChildProcessRunner {
   async run(event, context) {
     const childProcess = execaNode(
       childProcessHelperPath,
-      [this.#functionKey, this.#handlerName, this.#handlerPath],
+      [this.#functionKey, this.#handler, this.#servicePath, this.#codeDir],
       {
         env: this.#env,
         stdio: 'inherit',

package/src/lambda/handler-runner/child-process-runner/childProcessHelper.js

@@ -21,18 +21,21 @@ process.on('uncaughtException', (err) => {
   })
 })
 
-const [, , functionKey, handlerName, handlerPath] = argv
+const [, , functionKey, handler, servicePath, codeDir] = argv
 
 process.on('message', async (messageData) => {
   const { context, event, timeout } = messageData
 
   // TODO we could probably cache this in the module scope?
   const inProcessRunner = new InProcessRunner(
-    functionKey,
-    handlerPath,
-    handlerName,
+    {
+      codeDir,
+      functionKey,
+      handler,
+      servicePath,
+      timeout,
+    },
     process.env,
-    timeout,
   )
 
   const result = await inProcessRunner.run(event, context)

package/src/lambda/handler-runner/go-runner/GoRunner.js

@@ -4,6 +4,7 @@ import process, { chdir, cwd } from 'node:process'
 import { parse as pathParse, resolve, sep } from 'node:path'
 import { log } from '@serverless/utils/log.js'
 import { execa } from 'execa'
+import { splitHandlerPathAndName } from '../../../utils/index.js'
 
 const { parse, stringify } = JSON
 
@@ -23,7 +24,8 @@ export default class GoRunner {
   #tmpPath = null
 
   constructor(funOptions, env) {
-    const { handlerPath, codeDir } = funOptions
+    const { handler, codeDir } = funOptions
+    const [handlerPath] = splitHandlerPathAndName(handler)
 
     this.#codeDir = codeDir
     this.#env = env

package/src/lambda/handler-runner/in-process-runner/InProcessRunner.js

@@ -1,29 +1,32 @@
-import { createRequire } from 'node:module'
+import { join } from 'node:path'
 import { performance } from 'node:perf_hooks'
 import process from 'node:process'
-import { log } from '@serverless/utils/log.js'
+import { load } from './aws-lambda-ric/UserFunction.js'
 
 const { floor } = Math
 const { assign } = Object
 
-const require = createRequire(import.meta.url)
-
 export default class InProcessRunner {
+  #codeDir = null
+
   #env = null
 
   #functionKey = null
 
-  #handlerName = null
+  #handler = null
 
-  #handlerPath = null
+  #servicePath = null
 
   #timeout = null
 
-  constructor(functionKey, handlerPath, handlerName, env, timeout) {
+  constructor(funOptions, env) {
+    const { codeDir, functionKey, handler, servicePath, timeout } = funOptions
+
+    this.#codeDir = codeDir
     this.#env = env
     this.#functionKey = functionKey
-    this.#handlerName = handlerName
-    this.#handlerPath = handlerPath
+    this.#handler = handler
+    this.#servicePath = servicePath
     this.#timeout = timeout
   }
 
@@ -32,37 +35,16 @@ export default class InProcessRunner {
   cleanup() {}
 
   async run(event, context) {
-    // check if the handler module path exists
-    if (!require.resolve(this.#handlerPath)) {
-      throw new Error(
-        `Could not find handler module '${this.#handlerPath}' for function '${
-          this.#functionKey
-        }'.`,
-      )
-    }
-
     // process.env should be available in the handler module scope as well as in the handler function scope
     // NOTE: Don't use Object spread (...) here!
     // otherwise the values of the attached props are not coerced to a string
     // e.g. process.env.foo = 1 should be coerced to '1' (string)
     assign(process.env, this.#env)
 
-    let handler
-
-    try {
-      // eslint-disable-next-line import/no-dynamic-require
-      ;({ [this.#handlerName]: handler } = require(this.#handlerPath))
-    } catch (err) {
-      log.error(err)
-    }
-
-    if (typeof handler !== 'function') {
-      throw new Error(
-        `offline: handler '${this.#handlerName}' in ${
-          this.#handlerPath
-        } is not a function`,
-      )
-    }
+    const handler = await load(
+      this.#servicePath,
+      join(this.#codeDir, this.#handler),
+    )
 
     let callback
 

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

@@ -0,0 +1,359 @@
+'use strict'
+
+const { pathToFileURL } = require('node:url')
+
+// 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)
+  }
+  function _tryRequireFile(file, extension) {
+    const path2 = file + (extension || '')
+    verbose('Try loading as commonjs:', path2)
+    return fs.existsSync(path2) ? require(path2) : void 0
+  }
+  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
+  }
+  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
+        }
+      } catch (e) {
+        console.warn(
+          `${pj} cannot be read, it will be ignored for ES module detection purposes.`,
+          e,
+        )
+        return false
+      }
+    }
+    if (folder === '/') {
+      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
+  }
+  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')
+    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
+      }
+    }
+  }
+  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
+    }
+    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
+  }
+  module.exports.getHandlerMetadata = function (handlerFunc) {
+    return {
+      streaming: _isHandlerStreaming(handlerFunc),
+    }
+  }
+  module.exports.STREAM_RESPONSE = STREAM_RESPONSE
+})()