serverless-offline 8.8.1 → 9.0.0

package/README.md

@@ -89,7 +89,7 @@ plugins:
   - serverless-offline
 ```
 
-You can check wether you have successfully installed the plugin by running the serverless command line:
+You can check whether you have successfully installed the plugin by running the serverless command line:
 
 `serverless --verbose`
 
@@ -108,7 +108,6 @@ to list all the options for the plugin run:
 All CLI options are optional:
 
 ```
---allowCache                Allows the code of lambda functions to cache if supported.
 --apiKey                    Defines the API key value to be used for endpoints marked as private Defaults to a random hash.
 --corsAllowHeaders          Used as default Access-Control-Allow-Headers header value for responses. Delimit multiple values with commas. Default: 'accept,content-type,x-api-key'
 --corsAllowOrigin           Used as default Access-Control-Allow-Origin header value for responses. Delimit multiple values with commas. Default: '*'
@@ -134,10 +133,11 @@ All CLI options are optional:
 --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         Run handlers in a child process
 --useDocker                 Run handlers in a docker container.
---useWorkerThreads          Uses worker threads to run handlers.
+--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)
 --webSocketIdleTimeout      Set WebSocket idle timeout in seconds to reproduce AWS limits (https://docs.aws.amazon.com/apigateway/latest/developerguide/limits.html#apigateway-execution-service-websocket-limits-table). Default: 600 (10 minutes)
 --websocketPort             WebSocket port to listen on. Default: 3001

package/package.json

@@ -1,25 +1,26 @@
 {
   "dedicatedTo": "Blue, a great migrating bird.",
   "name": "serverless-offline",
-  "version": "8.8.1",
+  "version": "9.0.0",
   "description": "Emulate AWS λ and API Gateway locally when developing your Serverless project",
   "license": "MIT",
-  "main": "dist/main.js",
-  "type": "commonjs",
+  "main": "./src/index.js",
+  "exports": "./src/index.js",
+  "type": "module",
   "scripts": {
-    "build": "rimraf dist && babel src --ignore \"**/__tests__/**/*\" --out-dir dist && copyfiles -u 1 \"src/**/*.{vm,py,rb}\" dist",
     "format": "eslint . --fix",
     "lint": "eslint .",
     "lint:updated": "pipe-git-updated --ext=js -- eslint",
     "list-contributors": "echo 'clone https://github.com/mgechev/github-contributors-list.git first, then run npm install' && cd ../github-contributors-list && node bin/githubcontrib --owner dherault --repo serverless-offline --sortBy contributions --showlogin true --sortOrder desc > contributors.md",
-    "prepare": "npm run build",
+    "prepare": "husky install",
     "prepare-release": "standard-version && prettier --write CHANGELOG.md",
-    "prepublishOnly": "npm run lint && npm run build",
+    "prepublishOnly": "npm run lint",
     "prettier-check": "prettier -c --ignore-path .gitignore \"**/*.{css,html,js,json,md,yaml,yml}\"",
     "prettier-check:updated": "pipe-git-updated --ext=css --ext=html --ext=js --ext=json --ext=md --ext=yaml --ext=yml -- prettier -c",
     "prettify": "prettier --write --ignore-path .gitignore \"**/*.{css,html,js,json,md,yaml,yml}\"",
     "prettify:updated": "pipe-git-updated --ext=css --ext=html --ext=js --ext=json --ext=md --ext=yaml --ext=yml -- prettier --write",
-    "test": "npm run build && jest --verbose --silent --runInBand",
+    "test": "mocha --require ./tests/mochaHooks.cjs",
+    "test:jest": "npm run build && jest --verbose --silent --runInBand",
     "test:cov": "npm run build && jest --coverage --silent --runInBand --collectCoverageFrom=src/**/*.js",
     "test:log": "npm run build && jest --verbose",
     "test:noBuild": "jest --verbose --runInBand --bail",
@@ -49,7 +50,7 @@
     "websocket"
   ],
   "files": [
-    "dist/**",
+    "src/**",
     "package.json",
     "LICENSE",
     "README.md"
@@ -162,21 +163,8 @@
     "Fernando Alvarez (https://github.com/jefer590)",
     "Eric Carter (https://github.com/ericctsf)"
   ],
-  "husky": {
-    "hooks": {
-      "pre-commit": "lint-staged"
-    }
-  },
-  "lint-staged": {
-    "*.js": [
-      "eslint"
-    ],
-    "*.{css,html,js,json,md,yaml,yml}": [
-      "prettier -c"
-    ]
-  },
   "engines": {
-    "node": ">=12.0.0"
+    "node": ">=14.18.0"
   },
   "standard-version": {
     "skip": {
@@ -203,58 +191,46 @@
     ]
   },
   "dependencies": {
-    "@hapi/boom": "^9.1.4",
+    "@hapi/boom": "^10.0.0",
     "@hapi/h2o2": "^9.1.0",
     "@hapi/hapi": "^20.2.2",
-    "aws-sdk": "^2.1136.0",
-    "boxen": "^5.1.2",
-    "chalk": "^4.1.2",
-    "cuid": "^2.1.8",
-    "execa": "^5.1.1",
+    "aws-sdk": "^2.1176.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": "^5.1.0",
-    "jsonschema": "^1.4.0",
+    "jsonpath-plus": "^7.0.0",
+    "jsonschema": "^1.4.1",
     "jsonwebtoken": "^8.5.1",
-    "jszip": "^3.9.1",
-    "luxon": "^2.4.0",
-    "node-fetch": "^2.6.7",
+    "jszip": "^3.10.0",
+    "luxon": "^3.0.1",
+    "node-fetch": "^3.2.8",
     "node-schedule": "^2.1.0",
-    "p-memoize": "^4.0.4",
-    "p-queue": "^6.6.2",
-    "p-retry": "^4.6.2",
-    "semver": "^7.3.7",
+    "object.hasown": "^1.1.1",
+    "p-memoize": "^7.1.0",
+    "p-retry": "^5.1.1",
     "velocityjs": "^2.0.6",
-    "ws": "^7.5.7"
+    "ws": "^8.8.1"
   },
   "devDependencies": {
-    "@babel/cli": "^7.17.10",
-    "@babel/core": "^7.17.12",
-    "@babel/plugin-proposal-class-properties": "^7.17.12",
-    "@babel/plugin-proposal-dynamic-import": "^7.16.7",
-    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.17.12",
-    "@babel/plugin-proposal-optional-chaining": "^7.17.12",
-    "@babel/plugin-transform-modules-commonjs": "^7.17.12",
-    "@babel/register": "^7.17.7",
     "archiver": "^5.3.1",
-    "copyfiles": "^2.4.1",
-    "eslint": "^8.15.0",
+    "eslint": "^8.20.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-import": "^2.25.4",
-    "eslint-plugin-prettier": "^4.0.0",
+    "eslint-plugin-prettier": "^4.2.1",
     "git-list-updated": "^1.2.1",
-    "husky": "^4.3.8",
-    "jest": "^26.6.3",
-    "lint-staged": "^11.2.6",
-    "p-map": "^4.0.0",
-    "prettier": "^2.6.2",
-    "rimraf": "^3.0.2",
-    "serverless": "^2.72.3",
+    "husky": "^8.0.1",
+    "lint-staged": "^13.0.3",
+    "mocha": "^10.0.0",
+    "prettier": "^2.7.1",
+    "serverless": "^3.21.0",
     "standard-version": "^9.5.0"
   },
   "peerDependencies": {
-    "serverless": "^1.60.0 || 2 || 3"
+    "@serverless/utils": "^6.7.0",
+    "serverless": "^3.2.0"
   }
 }

package/src/ServerlessOffline.js

@@ -0,0 +1,412 @@
+import process, { env, exit } from 'node:process'
+import { log } from '@serverless/utils/log.js'
+import chalk from 'chalk'
+import {
+  commandOptions,
+  CUSTOM_OPTION,
+  defaultOptions,
+  SERVER_SHUTDOWN_TIMEOUT,
+} from './config/index.js'
+
+export default class ServerlessOffline {
+  #cliOptions = null
+
+  #http = null
+
+  #lambda = null
+
+  #options = null
+
+  #schedule = null
+
+  #serverless = null
+
+  #webSocket = null
+
+  constructor(serverless, cliOptions) {
+    this.#cliOptions = cliOptions
+    this.#serverless = serverless
+
+    this.commands = {
+      offline: {
+        // add start nested options
+        commands: {
+          functionsUpdated: {
+            lifecycleEvents: ['cleanup'],
+            type: 'entrypoint',
+          },
+          start: {
+            lifecycleEvents: ['init', 'ready', 'end'],
+            options: commandOptions,
+            usage:
+              'Simulates API Gateway to call your lambda functions offline using backward compatible initialization.',
+          },
+        },
+        lifecycleEvents: ['start'],
+        options: commandOptions,
+        usage: 'Simulates API Gateway to call your lambda functions offline.',
+      },
+    }
+
+    this.hooks = {
+      'offline:functionsUpdated:cleanup': this.#cleanupFunctions.bind(this),
+      'offline:start': this.#startWithExplicitEnd.bind(this),
+      'offline:start:end': this.end.bind(this),
+      'offline:start:init': this.start.bind(this),
+      'offline:start:ready': this.#ready.bind(this),
+    }
+  }
+
+  // Entry point for the plugin (sls offline) when running 'sls offline start'
+  async start() {
+    // Put here so available everywhere, not just in handlers
+    env.IS_OFFLINE = true
+
+    this.#mergeOptions()
+
+    const { httpEvents, lambdas, scheduleEvents, webSocketEvents } =
+      this.#getEvents()
+
+    // if (lambdas.length > 0) {
+    await this.#createLambda(lambdas)
+    // }
+
+    const eventModules = []
+
+    if (httpEvents.length > 0) {
+      eventModules.push(this.#createHttp(httpEvents))
+    }
+
+    if (!this.#options.disableScheduledEvents && scheduleEvents.length > 0) {
+      eventModules.push(this.#createSchedule(scheduleEvents))
+    }
+
+    if (webSocketEvents.length > 0) {
+      eventModules.push(this.#createWebSocket(webSocketEvents))
+    }
+
+    await Promise.all(eventModules)
+  }
+
+  async #ready() {
+    await this.#listenForTermination()
+  }
+
+  async end(skipExit) {
+    log.info('Halting offline server')
+
+    const eventModules = []
+
+    if (this.#lambda) {
+      eventModules.push(this.#lambda.cleanup())
+      eventModules.push(this.#lambda.stop(SERVER_SHUTDOWN_TIMEOUT))
+    }
+
+    if (this.#http) {
+      eventModules.push(this.#http.stop(SERVER_SHUTDOWN_TIMEOUT))
+    }
+
+    // if (this.#schedule) {
+    //   eventModules.push(this.#schedule.stop())
+    // }
+
+    if (this.#webSocket) {
+      eventModules.push(this.#webSocket.stop(SERVER_SHUTDOWN_TIMEOUT))
+    }
+
+    await Promise.all(eventModules)
+
+    if (!skipExit) {
+      exit(0)
+    }
+  }
+
+  async #cleanupFunctions() {
+    if (this.#lambda) {
+      log.debug('Forcing cleanup of Lambda functions')
+      await this.#lambda.cleanup()
+    }
+  }
+
+  /**
+   * Entry point for the plugin (serverless offline) when running 'serverless offline'
+   * The call to this.end() would terminate the process before 'offline:start:end' could be consumed
+   * by downstream plugins. When running serverless offline that can be expected, but docs say that
+   * 'serverless offline start' will provide the init and end hooks for other plugins to consume
+   * */
+  async #startWithExplicitEnd() {
+    await this.start()
+    await this.#ready()
+    this.end()
+  }
+
+  async #listenForTermination() {
+    const command = await new Promise((resolve) => {
+      process
+        // SIGINT will be usually sent when user presses ctrl+c
+        .on('SIGINT', () => resolve('SIGINT'))
+        // SIGTERM is a default termination signal in many cases,
+        // for example when "killing" a subprocess spawned in node
+        // with child_process methods
+        .on('SIGTERM', () => resolve('SIGTERM'))
+    })
+
+    log.info(`Got ${command} signal. Offline Halting...`)
+  }
+
+  async #createLambda(lambdas, skipStart) {
+    const { default: Lambda } = await import('./lambda/index.js')
+
+    this.#lambda = new Lambda(this.#serverless, this.#options)
+
+    this.#lambda.create(lambdas)
+
+    if (!skipStart) {
+      await this.#lambda.start()
+    }
+  }
+
+  async #createHttp(events, skipStart) {
+    const { default: Http } = await import('./events/http/index.js')
+
+    this.#http = new Http(this.#serverless, this.#options, this.#lambda)
+
+    await this.#http.registerPlugins()
+
+    this.#http.create(events)
+
+    // HTTP Proxy defined in Resource
+    this.#http.createResourceRoutes()
+
+    // Not found handling
+    // we have to create the 404 routes last, otherwise we could have
+    // collisions with catch all routes, e.g. any (proxy+}
+    this.#http.create404Route()
+
+    if (!skipStart) {
+      await this.#http.start()
+    }
+  }
+
+  async #createSchedule(events) {
+    const { default: Schedule } = await import('./events/schedule/index.js')
+
+    this.#schedule = new Schedule(
+      this.#lambda,
+      this.#serverless.service.provider.region,
+    )
+
+    this.#schedule.create(events)
+  }
+
+  async #createWebSocket(events) {
+    const { default: WebSocket } = await import('./events/websocket/index.js')
+
+    this.#webSocket = new WebSocket(
+      this.#serverless,
+      this.#options,
+      this.#lambda,
+    )
+
+    this.#webSocket.create(events)
+
+    return this.#webSocket.start()
+  }
+
+  #mergeOptions() {
+    const {
+      service: { custom = {}, provider },
+    } = this.#serverless
+
+    const customOptions = custom[CUSTOM_OPTION]
+
+    // merge options
+    // order of Precedence: command line options, custom options, defaults.
+    this.#options = {
+      ...defaultOptions,
+      ...customOptions,
+      ...this.#cliOptions,
+    }
+
+    // Parse CORS options
+    this.#options.corsAllowHeaders = this.#options.corsAllowHeaders
+      .replace(/\s/g, '')
+      .split(',')
+    this.#options.corsAllowOrigin = this.#options.corsAllowOrigin
+      .replace(/\s/g, '')
+      .split(',')
+    this.#options.corsExposedHeaders = this.#options.corsExposedHeaders
+      .replace(/\s/g, '')
+      .split(',')
+
+    if (this.#options.corsDisallowCredentials) {
+      this.#options.corsAllowCredentials = false
+    }
+
+    this.#options.corsConfig = {
+      credentials: this.#options.corsAllowCredentials,
+      exposedHeaders: this.#options.corsExposedHeaders,
+      headers: this.#options.corsAllowHeaders,
+      origin: this.#options.corsAllowOrigin,
+    }
+
+    log.notice()
+    log.notice(
+      `Starting Offline at stage ${provider.stage} ${chalk.gray(
+        `(${provider.region})`,
+      )}`,
+    )
+    log.notice()
+    log.debug('options:', this.#options)
+  }
+
+  #getEvents() {
+    const { service } = this.#serverless
+
+    const httpEvents = []
+    const lambdas = []
+    const scheduleEvents = []
+    const webSocketEvents = []
+
+    const functionKeys = service.getAllFunctions()
+
+    let hasPrivateHttpEvent = false
+
+    functionKeys.forEach((functionKey) => {
+      const functionDefinition = service.getFunction(functionKey)
+
+      lambdas.push({ functionDefinition, functionKey })
+
+      const events = service.getAllEventsInFunction(functionKey) || []
+
+      events.forEach((event) => {
+        const { http, httpApi, schedule, websocket } = event
+
+        if ((http || httpApi) && functionDefinition.handler) {
+          const httpEvent = {
+            functionKey,
+            handler: functionDefinition.handler,
+            http: http || httpApi,
+          }
+
+          if (httpApi) {
+            // Ensure definitions for 'httpApi' events are objects so that they can be marked
+            // with an 'isHttpApi' property (they are handled differently to 'http' events)
+            if (typeof httpEvent.http === 'string') {
+              httpEvent.http = {
+                routeKey: httpEvent.http === '*' ? '$default' : httpEvent.http,
+              }
+            } else if (typeof httpEvent.http === 'object') {
+              if (!httpEvent.http.method) {
+                log.warning(
+                  `Event definition is missing a method for function "${functionKey}"`,
+                )
+                httpEvent.http.method = ''
+              }
+              if (
+                httpEvent.http.method === '*' &&
+                httpEvent.http.path === '*'
+              ) {
+                httpEvent.http.routeKey = '$default'
+              } else {
+                const resolvedMethod =
+                  httpEvent.http.method === '*'
+                    ? 'ANY'
+                    : httpEvent.http.method.toUpperCase()
+                httpEvent.http.routeKey = `${resolvedMethod} ${httpEvent.http.path}`
+              }
+              // Clear these properties to avoid confusion (they will be derived from the routeKey
+              // when needed later)
+              delete httpEvent.http.method
+              delete httpEvent.http.path
+            } else {
+              log.warning(
+                `Event definition must be a string or object but received ${typeof httpEvent.http} for function "${functionKey}"`,
+              )
+              httpEvent.http.routeKey = ''
+            }
+
+            httpEvent.http.isHttpApi = true
+            if (
+              functionDefinition.httpApi &&
+              functionDefinition.httpApi.payload
+            ) {
+              httpEvent.http.payload = functionDefinition.httpApi.payload
+            } else {
+              httpEvent.http.payload =
+                service.provider.httpApi && service.provider.httpApi.payload
+                  ? service.provider.httpApi.payload
+                  : '2.0'
+            }
+          }
+
+          if (http && http.private) {
+            hasPrivateHttpEvent = true
+          }
+
+          httpEvents.push(httpEvent)
+        }
+
+        if (schedule) {
+          scheduleEvents.push({
+            functionKey,
+            schedule,
+          })
+        }
+
+        if (websocket) {
+          webSocketEvents.push({
+            functionKey,
+            websocket,
+          })
+        }
+      })
+    })
+
+    // for simple API Key authentication model
+    if (hasPrivateHttpEvent) {
+      log.notice(`Key with token: ${this.#options.apiKey}`)
+
+      if (this.#options.noAuth) {
+        log.notice(
+          'Authorizers are turned off. You do not need to use x-api-key header.',
+        )
+      } else {
+        log.notice('Remember to use x-api-key on the request headers')
+      }
+    }
+
+    return {
+      httpEvents,
+      lambdas,
+      scheduleEvents,
+      webSocketEvents,
+    }
+  }
+
+  // TODO FIXME
+  // TEMP quick fix to expose for testing, look for better solution
+  internals() {
+    return {
+      createHttp: (events, skipStart) => {
+        return this.#createHttp(events, skipStart)
+      },
+
+      createLambda: (lambdas, skipStart) => {
+        return this.#createLambda(lambdas, skipStart)
+      },
+
+      getApiGatewayServer: () => {
+        return this.#http.getServer()
+      },
+
+      getEvents: () => {
+        return this.#getEvents()
+      },
+
+      mergeOptions: () => {
+        this.#mergeOptions()
+      },
+    }
+  }
+}