serverless-offline 9.3.1 → 10.0.0

package/README.md

@@ -121,7 +121,6 @@ All CLI options are optional:
 --dockerNetwork             The network that the Docker container will connect to
 --dockerReadOnly            Marks if the docker code layer should be read only. Default: true
 --enforceSecureCookies      Enforce secure cookies
---hideStackTraces           Hide the stack trace on lambda failure. Default: false
 --host                  -o  Host name to listen on. Default: localhost
 --httpPort                  Http port to listen on. Default: 3000
 --httpsProtocol         -H  To enable HTTPS, specify directory (relative to your cwd, typically your project dir) for both cert.pem and key.pem files
@@ -134,10 +133,9 @@ All CLI options are optional:
 --noStripTrailingSlashInUrl Don't strip trailing slash from http routes.
 --noTimeout             -t  Disables the timeout feature.
 --prefix                -p  Adds a prefix to every path, to send your requests to http://localhost:3000/[prefix]/[your_path] instead. Default: ''
---printOutput               Turns on logging of your lambda outputs in the terminal.
 --reloadHandler             Reloads handler with each request.
 --resourceRoutes            Turns on loading of your HTTP proxy settings from serverless.yml
---useChildProcesses         [This option is deprecated] Run handlers in a child process.
+--terminateIdleLambdaTime   Number of seconds until an idle function is eligible for termination.
 --useDocker                 Run handlers in a docker container.
 --useInProcess              Run handlers in the same process as 'serverless-offline'.
 --webSocketHardTimeout      Set WebSocket hard timeout in seconds to reproduce AWS limits (https://docs.aws.amazon.com/apigateway/latest/developerguide/limits.html#apigateway-execution-service-websocket-limits-table). Default: 7200 (2 hours)
@@ -188,15 +186,6 @@ Lambda handlers for the `node.js` runtime can run in different execution modes w
 - global state is being shared across lambda handlers as well as with `serverless` and `serverless-offline`
 - easy debugging
 
-#### child-processes (this option is deprecated, please use the default worker-threads instead)
-
-- handlers run in a separate node.js instance
-- memory is not being shared between handlers, memory consumption is therefore higher
-- memory is being released when handlers reload or after usage
-- environment (process.env) is not being shared across handlers
-- global state is not being shared across handlers
-- debugging more complicated
-
 #### docker
 
 - handlers run in a docker container

package/package.json

@@ -1,10 +1,13 @@
 {
   "dedicatedTo": "Blue, a great migrating bird.",
   "name": "serverless-offline",
-  "version": "9.3.1",
+  "version": "10.0.0",
   "description": "Emulate AWS λ and API Gateway locally when developing your Serverless project",
   "license": "MIT",
-  "exports": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./lambda": "./src/lambda/index.js"
+  },
   "type": "module",
   "scripts": {
     "format": "eslint . --fix",
@@ -188,14 +191,14 @@
     "@hapi/h2o2": "^9.1.0",
     "@hapi/hapi": "^20.2.2",
     "@serverless/utils": "^6.7.0",
-    "aws-sdk": "^2.1205.0",
+    "aws-sdk": "^2.1209.0",
     "boxen": "^7.0.0",
     "chalk": "^5.0.1",
     "execa": "^6.1.0",
     "fs-extra": "^10.1.0",
     "java-invoke-local": "0.0.6",
     "js-string-escape": "^1.0.1",
-    "jsonpath-plus": "^7.1.0",
+    "jsonpath-plus": "^7.2.0",
     "jsonschema": "^1.4.1",
     "jsonwebtoken": "^8.5.1",
     "jszip": "^3.10.1",

package/src/ServerlessOffline.js

@@ -6,7 +6,7 @@ import {
   defaultOptions,
   SERVER_SHUTDOWN_TIMEOUT,
 } from './config/index.js'
-import { gray, orange } from './config/colors.js'
+import { gray } from './config/colors.js'
 
 export default class ServerlessOffline {
   #cliOptions = null
@@ -83,15 +83,6 @@ export default class ServerlessOffline {
     }
 
     await Promise.all(eventModules)
-
-    if (this.#options.useChildProcesses) {
-      log.notice()
-      log.warning(
-        orange(`'--useChildProcesses' is deprecated and will be removed in the next major version. Worker threads, the current default, should provide the same if not an even better developer experience.
-If you are experiencing any issues please let us know: https://github.com/dherault/serverless-offline/issues`),
-      )
-      log.notice()
-    }
   }
 
   async #ready() {

package/src/config/commandOptions.js

@@ -54,14 +54,6 @@ export default {
     type: 'boolean',
     usage: 'Enforce secure cookies',
   },
-  functionCleanupIdleTimeSeconds: {
-    type: 'string',
-    usage: 'Number of seconds until an idle function is eligible for cleanup',
-  },
-  hideStackTraces: {
-    type: 'boolean',
-    usage: 'Hide the stack trace on lambda failure. Default: false',
-  },
   host: {
     shortcut: 'o',
     type: 'string',
@@ -118,10 +110,6 @@ export default {
     usage:
       'Adds a prefix to every path, to send your requests to http://localhost:3000/prefix/[your_path] instead.',
   },
-  printOutput: {
-    type: 'boolean',
-    usage: 'Outputs your lambda response to the terminal.',
-  },
   reloadHandler: {
     type: 'boolean',
     usage: 'Reloads handler with each request.',
@@ -130,10 +118,10 @@ export default {
     type: 'boolean',
     usage: 'Turns on loading of your HTTP proxy settings from serverless.yml.',
   },
-  useChildProcesses: {
-    type: 'boolean',
+  terminateIdleLambdaTime: {
+    type: 'string',
     usage:
-      '[This option is deprecated] Use separate node process to run handlers.',
+      'Number of seconds until an idle function is eligible for termination.',
   },
   useDocker: {
     type: 'boolean',

package/src/config/defaultOptions.js

@@ -13,8 +13,6 @@ export default {
   dockerNetwork: null,
   dockerReadOnly: true,
   enforceSecureCookies: false,
-  functionCleanupIdleTimeSeconds: 60,
-  hideStackTraces: false,
   host: 'localhost',
   httpPort: 3000,
   httpsProtocol: null,
@@ -26,10 +24,9 @@ export default {
   noStripTrailingSlashInUrl: false,
   noTimeout: false,
   prefix: '',
-  printOutput: false,
   reloadHandler: false,
   resourceRoutes: false,
-  useChildProcesses: false,
+  terminateIdleLambdaTime: 60,
   useDocker: false,
   useInProcess: false,
   webSocketHardTimeout: 7200,

package/src/config/supportedRuntimes.js

@@ -45,3 +45,9 @@ export const supportedRuntimes = new Set([
   ...supportedPython,
   ...supportedRuby,
 ])
+
+export const unsupportedDockerRuntimes = new Set([
+  'nodejs14.x',
+  'nodejs16.x',
+  'python3.9',
+])

package/src/events/http/HttpServer.js

@@ -580,21 +580,8 @@ export default class HttpServer {
 
       // Failure handling
       let errorStatusCode = '502'
-      if (err) {
-        // Since the --useChildProcesses option loads the handler in
-        // a separate process and serverless-offline communicates with it
-        // over IPC, we are unable to catch JavaScript unhandledException errors
-        // when the handler code contains bad JavaScript. Instead, we "catch"
-        // it here and reply in the same way that we would have above when
-        // we lazy-load the non-IPC handler function.
-        if (this.#options.useChildProcesses && err.ipcException) {
-          return this.#reply502(
-            response,
-            `Error while loading ${functionKey}`,
-            err,
-          )
-        }
 
+      if (err) {
         const errorMessage = (err.message || err).toString()
 
         const found = errorMessage.match(/\[(\d{3})]/)
@@ -614,10 +601,6 @@ export default class HttpServer {
 
         log.error(errorMessage)
 
-        if (!this.#options.hideStackTraces) {
-          log.error(err.stack)
-        }
-
         for (const [key, value] of entries(endpoint.responses)) {
           if (
             key !== 'default' &&
@@ -894,20 +877,6 @@ export default class HttpServer {
         }
       }
 
-      let whatToLog = result
-
-      try {
-        whatToLog = stringify(result)
-      } catch {
-        // nothing
-      } finally {
-        if (this.#options.printOutput) {
-          log.notice(
-            err ? `Replying ${statusCode}` : `[${statusCode}] ${whatToLog}`,
-          )
-        }
-      }
-
       return response
     }
   }

package/src/lambda/LambdaFunctionPool.js

@@ -21,7 +21,7 @@ export default class LambdaFunctionPool {
 
   #startCleanTimer() {
     const functionCleanupIdleTimeInMillis =
-      this.#options.functionCleanupIdleTimeSeconds * 1000
+      this.#options.terminateIdleLambdaTime * 1000
 
     // NOTE: don't use setInterval, as it would schedule always a new run,
     // regardless of function processing time and e.g. user action (debugging)

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

@@ -5,6 +5,7 @@ import {
   supportedNodejs,
   supportedPython,
   supportedRuby,
+  unsupportedDockerRuntimes,
 } from '../../config/index.js'
 
 export default class HandlerRunner {
@@ -23,25 +24,19 @@ export default class HandlerRunner {
   }
 
   async #loadRunner() {
-    const { useChildProcesses, useDocker, useInProcess } = this.#options
+    const { useDocker, useInProcess } = this.#options
     const { handler, runtime } = this.#funOptions
 
     log.debug(`Loading handler... (${handler})`)
 
     if (useDocker) {
-      // https://github.com/lambci/docker-lambda/issues/329
-      if (runtime === 'nodejs14.x') {
+      if (unsupportedDockerRuntimes.has(runtime)) {
         log.warning(
-          '"nodejs14.x" runtime is not supported with docker. See https://github.com/lambci/docker-lambda/issues/329',
+          `"${runtime}" runtime is not supported with docker. See https://github.com/lambci/docker-lambda`,
         )
         throw new Error('Unsupported runtime')
       }
 
-      if (runtime === 'python3.9') {
-        log.warning('"python3.9" runtime is not supported with docker.')
-        throw new Error('Unsupported runtime')
-      }
-
       const dockerOptions = {
         host: this.#options.dockerHost,
         hostServicePath: this.#options.dockerHostServicePath,
@@ -56,14 +51,6 @@ export default class HandlerRunner {
     }
 
     if (supportedNodejs.has(runtime)) {
-      if (useChildProcesses) {
-        const { default: ChildProcessRunner } = await import(
-          './child-process-runner/index.js'
-        )
-
-        return new ChildProcessRunner(this.#funOptions, this.#env)
-      }
-
       if (useInProcess) {
         const { default: InProcessRunner } = await import(
           './in-process-runner/index.js'

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

@@ -1,75 +0,0 @@
-import { dirname, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { log } from '@serverless/utils/log.js'
-import { execaNode } from 'execa'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-const childProcessHelperPath = resolve(__dirname, 'childProcessHelper.js')
-
-export default class ChildProcessRunner {
-  #codeDir = null
-
-  #env = null
-
-  #functionKey = null
-
-  #handler = null
-
-  #servicePath = null
-
-  #timeout = null
-
-  constructor(funOptions, env) {
-    const { codeDir, functionKey, handler, servicePath, timeout } = funOptions
-
-    this.#codeDir = codeDir
-    this.#env = env
-    this.#functionKey = functionKey
-    this.#handler = handler
-    this.#servicePath = servicePath
-    this.#timeout = timeout
-  }
-
-  // no-op
-  // () => void
-  cleanup() {}
-
-  async run(event, context) {
-    const childProcess = execaNode(
-      childProcessHelperPath,
-      [this.#functionKey, this.#handler, this.#servicePath, this.#codeDir],
-      {
-        env: this.#env,
-        stdio: 'inherit',
-      },
-    )
-
-    childProcess.send({
-      context,
-      event,
-      timeout: this.#timeout,
-    })
-
-    let result
-
-    try {
-      result = await new Promise((res, rej) => {
-        childProcess.on('message', (data) => {
-          if (data.error) {
-            rej(data.error)
-            return
-          }
-          res(data.result)
-        })
-      })
-    } catch (err) {
-      // TODO
-      log.error(err)
-      throw err
-    } finally {
-      childProcess.kill()
-    }
-
-    return result
-  }
-}

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

@@ -1,45 +0,0 @@
-import process, { argv } from 'node:process'
-import InProcessRunner from '../in-process-runner/index.js'
-
-// TODO handle this:
-process.on('uncaughtException', (err) => {
-  const {
-    constructor: { name },
-    message,
-    stack,
-  } = err
-
-  process.send({
-    // process.send() can't serialize an Error object, so we help it out a bit
-    error: {
-      constructor: {
-        name,
-      },
-      message,
-      stack,
-    },
-  })
-})
-
-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(
-    {
-      codeDir,
-      functionKey,
-      handler,
-      servicePath,
-      timeout,
-    },
-    process.env,
-  )
-
-  const result = await inProcessRunner.run(event, context)
-
-  // TODO check serializeability (contains function, symbol etc)
-  process.send({ result })
-})

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

@@ -1 +0,0 @@
-export { default } from './ChildProcessRunner.js'