serverless-offline 9.0.0 → 9.1.2

package/README.md

@@ -7,8 +7,8 @@
   <a href="https://www.npmjs.com/package/serverless-offline">
     <img src="https://img.shields.io/npm/v/serverless-offline.svg?style=flat-square">
   </a>
-  <a href="https://github.com/dherault/serverless-offline/actions?query=workflow%3ACI">
-    <img src="https://img.shields.io/github/workflow/status/dherault/serverless-offline/CI?style=flat-square">
+  <a href="https://github.com/dherault/serverless-offline/actions/workflows/integrate.yml">
+    <img src="https://img.shields.io/github/workflow/status/dherault/serverless-offline/Integrate">
   </a>
   <img src="https://img.shields.io/node/v/serverless-offline.svg?style=flat-square">
   <a href="https://github.com/serverless/serverless">
@@ -29,9 +29,9 @@
 This [Serverless](https://github.com/serverless/serverless) plugin emulates [AWS λ](https://aws.amazon.com/lambda) and [API Gateway](https://aws.amazon.com/api-gateway) on your local machine to speed up your development cycles.
 To do so, it starts an HTTP server that handles the request's lifecycle like APIG does and invokes your handlers.
 
-**Features:**
+**Features**
 
-- [Node.js](https://nodejs.org), [Python](https://www.python.org), [Ruby](https://www.ruby-lang.org) and [Go](https://golang.org) λ runtimes.
+- [Node.js](https://nodejs.org), [Python](https://www.python.org), [Ruby](https://www.ruby-lang.org), [Go](https://golang.org), [Java](https://www.java.com) (incl. [Kotlin](https://kotlinlang.org), [Groovy](https://groovy-lang.org), [Scala](https://www.scala-lang.org)) λ runtimes.
 - Velocity templates support.
 - Lazy loading of your handler files.
 - And more: integrations, authorizers, proxies, timeouts, responseParameters, HTTPS, CORS, etc...
@@ -42,6 +42,7 @@ This plugin is updated by its users, I just do maintenance and ensure that PRs a
 
 - [Installation](#installation)
 - [Usage and command line options](#usage-and-command-line-options)
+- [Run modes](#run-modes)
 - [Usage with `invoke`](#usage-with-invoke)
 - [The `process.env.IS_OFFLINE` variable](#the-processenvis_offline-variable)
 - [Docker and Layers](#docker-and-layers)
@@ -84,7 +85,7 @@ Then inside your project's `serverless.yml` file add following entry to the plug
 
 It should look something like this:
 
-```YAML
+```yml
 plugins:
   - serverless-offline
 ```
@@ -127,6 +128,7 @@ All CLI options are optional:
 --ignoreJWTSignature        When using HttpApi with a JWT authorizer, don't check the signature of the JWT token. This should only be used for local development.
 --lambdaPort                Lambda http port to listen on. Default: 3002
 --layersDir                 The directory layers should be stored in. Default: ${codeDir}/.serverless-offline/layers'
+--localEnvironment          Copy local environment variables. Default: false
 --noAuth                    Turns off all authorizers
 --noPrependStageInUrl       Don't prepend http routes with the stage.
 --noStripTrailingSlashInUrl Don't strip trailing slash from http routes.
@@ -145,13 +147,12 @@ All CLI options are optional:
 
 Any of the CLI options can be added to your `serverless.yml`. For example:
 
-```
+```yml
 custom:
   serverless-offline:
-    httpsProtocol: "dev-certs"
+    httpsProtocol: 'dev-certs'
     httpPort: 4000
-    stageVariables:
-      foo: "bar"
+      foo: 'bar'
 ```
 
 Options passed on the command line override YAML options.
@@ -163,18 +164,64 @@ By default you can send your requests to `http://localhost:3000/`. Please note t
   But if you send an `application/x-www-form-urlencoded` or a `multipart/form-data` body with an `application/json` (or no) Content-Type, API Gateway won't parse your data (you'll get the ugly raw as input), whereas the plugin will answer 400 (malformed JSON).
   Please consider explicitly setting your requests' Content-Type and using separate templates.
 
+## Run modes
+
+### node.js
+
+Lambda handlers for the `node.js` runtime can run in different execution modes with `serverless-offline` and they have subtle differences with a variety of pros and cons. they are mutually exclusive and it is planned to combine the flags into one single flag in the future.
+
+#### worker-threads (default)
+
+- handlers run in their own context
+- 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
+- easy debugging
+
+#### in-process
+
+- handlers run in the same context (instance) as `serverless` and `serverless-offline`
+- memory is being shared across lambda handlers as well as with `serverless` and `serverless-offline`
+- no reloading capabilities as it is [currently] not possible to implement for commonjs handlers (without memory leaks) and for esm handlers
+- environment (process.env) is being shared across handlers as well as with `serverless` and `serverless-offline`
+- global state is being shared across lambda handlers as well as with `serverless` and `serverless-offline`
+- easy debugging
+
+#### child-processes
+
+- 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
+- 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
+
+### Python, Ruby, Go, Java (incl. Kotlin, Groovy, Scala)
+
+the Lambda handler process is running in a child process.
+
 ## Usage with `invoke`
 
-To use `Lambda.invoke` you need to set the lambda endpoint to the serverless-offline endpoint:
+To use `Lambda.invoke` you need to set the lambda endpoint to the `serverless-offline` endpoint:
 
 ```js
+const { env } = require('node:process')
 const { Lambda } = require('aws-sdk')
 
 const lambda = new Lambda({
   apiVersion: '2015-03-31',
-  // endpoint needs to be set only if it deviates from the default, e.g. in a dev environment
-  // process.env.SOME_VARIABLE could be set in e.g. serverless.yml for provider.environment or function.environment
-  endpoint: process.env.SOME_VARIABLE
+  // endpoint needs to be set only if it deviates from the default
+  endpoint: env.IS_OFFLINE
     ? 'http://localhost:3002'
     : 'https://lambda.us-east-1.amazonaws.com',
 })
@@ -183,15 +230,33 @@ const lambda = new Lambda({
 All your lambdas can then be invoked in a handler using
 
 ```js
+const { Buffer } = require('node:buffer')
+const { Lambda } = require('aws-sdk')
+
+const { stringify } = JSON
+
+const lambda = new Lambda({
+  apiVersion: '2015-03-31',
+  endpoint: 'http://localhost:3002',
+})
+
 exports.handler = async function () {
+  const clientContextData = stringify({ foo: 'foo' })
+
   const params = {
+    ClientContext: Buffer.from(clientContextData).toString('base64'),
     // FunctionName is composed of: service name - stage - function name, e.g.
     FunctionName: 'myServiceName-dev-invokedHandler',
     InvocationType: 'RequestResponse',
-    Payload: JSON.stringify({ data: 'foo' }),
+    Payload: stringify({ data: 'foo' }),
   }
 
   const response = await lambda.invoke(params).promise()
+
+  return {
+    body: stringify(response),
+    statusCode: 200,
+  }
 }
 ```
 
@@ -243,7 +308,7 @@ to calling it via `aws-sdk`.
 
 ## The `process.env.IS_OFFLINE` variable
 
-Will be `"true"` in your handlers and throughout the plugin.
+Will be `"true"` in your handlers when using `serverless-offline`.
 
 ## Docker and Layers
 
@@ -266,14 +331,14 @@ If you're using least-privilege principals for your AWS roles, this policy shoul
 
 ```json
 {
-  "Version": "2012-10-17",
   "Statement": [
     {
-      "Effect": "Allow",
       "Action": "lambda:GetLayerVersion",
+      "Effect": "Allow",
       "Resource": "arn:aws:lambda:*:*:layer:*:*"
     }
-  ]
+  ],
+  "Version": "2012-10-17"
 }
 ```
 
@@ -325,11 +390,11 @@ Only [custom authorizers](https://aws.amazon.com/blogs/compute/introducing-custo
 
 The Custom authorizer is passed an `event` object as below:
 
-```javascript
+```js
 {
-  "type": "TOKEN",
   "authorizationToken": "<Incoming bearer token>",
-  "methodArn": "arn:aws:execute-api:<Region id>:<Account id>:<API id>/<Stage>/<Method>/<Resource path>"
+  "methodArn": "arn:aws:execute-api:<Region id>:<Account id>:<API id>/<Stage>/<Method>/<Resource path>",
+  "type": "TOKEN"
 }
 ```
 
@@ -337,11 +402,11 @@ The `methodArn` does not include the Account id or API id.
 
 The plugin only supports retrieving Tokens from headers. You can configure the header as below:
 
-```javascript
+```js
 "authorizer": {
-  "type": "TOKEN",
+  "authorizerResultTtlInSeconds": "0",
   "identitySource": "method.request.header.Authorization", // or method.request.header.SomeOtherHeader
-  "authorizerResultTtlInSeconds": "0"
+  "type": "TOKEN"
 }
 ```
 
@@ -369,14 +434,14 @@ If your authentication needs are custom and not satisfied by the existing capabi
 ```js
 module.exports = function (endpoint, functionKey, method, path) {
   return {
-    name: 'your strategy name',
-    scheme: 'your scheme name',
-
     getAuthenticateFunction: () => ({
       async authenticate(request, h) {
         // your implementation
       },
     }),
+
+    name: 'your strategy name',
+    scheme: 'your scheme name',
   }
 }
 ```
@@ -440,7 +505,7 @@ Now let's make a request with this body: `{ "id": 1 }`
 
 AWS parses the event as such:
 
-```javascript
+```js
 {
   "payload": {
     "id": 1
@@ -452,7 +517,7 @@ AWS parses the event as such:
 
 Whereas Offline parses:
 
-```javascript
+```js
 {
   "payload": {
     "id": 1
@@ -504,7 +569,7 @@ Works out of the box. See examples in the manual_test directory.
 
 Example of enabling proxy:
 
-```
+```yml
 custom:
   serverless-offline:
     resourceRoutes: true
@@ -512,18 +577,18 @@ custom:
 
 or
 
-```
+```yml
     YourCloudFormationMethodId:
-      Type: AWS::ApiGateway::Method
       Properties:
         ......
         Integration:
           Type: HTTP_PROXY
           Uri: 'https://s3-${self:custom.region}.amazonaws.com/${self:custom.yourBucketName}/{proxy}'
           ......
+      Type: AWS::ApiGateway::Method
 ```
 
-```
+```yml
 custom:
   serverless-offline:
     resourceRoutes:
@@ -541,7 +606,7 @@ May not work properly. Please PR. (Difficulty: hard?)
 
 Example response velocity template:
 
-```javascript
+```js
 "responseParameters": {
   "method.response.header.X-Powered-By": "Serverless", // a string
   "method.response.header.Warning": "integration.response.body", // the whole response
@@ -558,7 +623,9 @@ Usage in order to send messages back to clients:
 Or,
 
 ```js
-const apiGatewayManagementApi = new AWS.ApiGatewayManagementApi({
+const { ApiGatewayManagementApi } = require('aws-sdk')
+
+const apiGatewayManagementApi = new ApiGatewayManagementApi({
   apiVersion: '2018-11-29',
   endpoint: 'http://localhost:3001',
 });
@@ -603,13 +670,13 @@ Add a new [launch configuration](https://code.visualstudio.com/docs/editor/debug
 
 ```json
 {
-  "type": "node",
-  "request": "launch",
-  "name": "Debug Serverless Offline",
   "cwd": "${workspaceFolder}",
-  "runtimeExecutable": "npm",
+  "name": "Debug Serverless Offline",
+  "request": "launch",
   "runtimeArgs": ["run", "debug"],
-  "sourceMaps": true
+  "runtimeExecutable": "npm",
+  "sourceMaps": true,
+  "type": "node"
 }
 ```
 
@@ -647,7 +714,7 @@ You can change this profile directly in the code or by setting proper environmen
 ## Simulation quality
 
 This plugin simulates API Gateway for many practical purposes, good enough for development - but is not a perfect simulator.
-Specifically, Lambda currently runs on Node.js v10.x, v12.x and v14.x ([AWS Docs](https://docs.aws.amazon.com/lambda/latest/dg/current-supported-versions.html)), whereas _Offline_ runs on your own runtime where no memory limits are enforced.
+Specifically, Lambda currently runs on Node.js v12.x, v14.x and v16.x ([AWS Docs](https://docs.aws.amazon.com/lambda/latest/dg/current-supported-versions.html)), whereas _Offline_ runs on your own runtime where no memory limits are enforced.
 
 ## Usage with other plugins
 
@@ -660,7 +727,7 @@ Plugins are executed in order, so plugins that process your code or add resource
 
 For example:
 
-```yaml
+```yml
 plugins:
   - serverless-middleware # modifies some of your handler based on configuration
   - serverless-webpack # package your javascript handlers using webpack

package/package.json

@@ -1,7 +1,7 @@
 {
   "dedicatedTo": "Blue, a great migrating bird.",
   "name": "serverless-offline",
-  "version": "9.0.0",
+  "version": "9.1.2",
   "description": "Emulate AWS λ and API Gateway locally when developing your Serverless project",
   "license": "MIT",
   "main": "./src/index.js",
@@ -194,7 +194,7 @@
     "@hapi/boom": "^10.0.0",
     "@hapi/h2o2": "^9.1.0",
     "@hapi/hapi": "^20.2.2",
-    "aws-sdk": "^2.1176.0",
+    "aws-sdk": "^2.1185.0",
     "boxen": "^7.0.0",
     "chalk": "^5.0.1",
     "execa": "^6.1.0",
@@ -206,7 +206,7 @@
     "jsonwebtoken": "^8.5.1",
     "jszip": "^3.10.0",
     "luxon": "^3.0.1",
-    "node-fetch": "^3.2.8",
+    "node-fetch": "^3.2.10",
     "node-schedule": "^2.1.0",
     "object.hasown": "^1.1.1",
     "p-memoize": "^7.1.0",

package/src/ServerlessOffline.js

@@ -1,4 +1,4 @@
-import process, { env, exit } from 'node:process'
+import process, { exit } from 'node:process'
 import { log } from '@serverless/utils/log.js'
 import chalk from 'chalk'
 import {
@@ -59,9 +59,6 @@ export default class ServerlessOffline {
 
   // 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 } =

package/src/config/commandOptions.js

@@ -91,6 +91,10 @@ export default {
     usage:
       'The directory layers should be stored in. Default: {codeDir}/.serverless-offline/layers',
   },
+  localEnvironment: {
+    type: 'boolean',
+    usage: 'Copy local environment variables. Default: false',
+  },
   noAuth: {
     type: 'boolean',
     usage: 'Turns off all authorizers',

package/src/config/constants.js

@@ -4,12 +4,12 @@ export const BASE_URL_PLACEHOLDER = 'http://example'
 
 export const CUSTOM_OPTION = 'serverless-offline'
 
-export const DEFAULT_LAMBDA_RUNTIME = 'nodejs12.x'
+export const DEFAULT_LAMBDA_RUNTIME = 'nodejs14.x'
 
 // https://docs.aws.amazon.com/lambda/latest/dg/limits.html
 export const DEFAULT_LAMBDA_MEMORY_SIZE = 1024
 // default function timeout in seconds
-export const DEFAULT_LAMBDA_TIMEOUT = 900 // 15 min
+export const DEFAULT_LAMBDA_TIMEOUT = 6 // 6 seconds
 
 // timeout for all connections to be closed
 export const SERVER_SHUTDOWN_TIMEOUT = 5000

package/src/config/defaultOptions.js

@@ -20,6 +20,7 @@ export default {
   httpsProtocol: '',
   lambdaPort: 3002,
   layersDir: null,
+  localEnvironment: false,
   noAuth: false,
   noPrependStageInUrl: false,
   noStripTrailingSlashInUrl: false,

package/src/events/http/HttpServer.js

@@ -2,7 +2,7 @@ import { Buffer } from 'node:buffer'
 import { readFileSync } from 'node:fs'
 import { createRequire } from 'node:module'
 import { join, resolve } from 'node:path'
-import process, { exit } from 'node:process'
+import { exit } from 'node:process'
 import h2o2 from '@hapi/h2o2'
 import { Server } from '@hapi/hapi'
 import { log } from '@serverless/utils/log.js'
@@ -35,8 +35,6 @@ const { assign, entries, keys } = Object
 export default class HttpServer {
   #lambda = null
 
-  #lastRequestOptions = null
-
   #options = null
 
   #serverless = null
@@ -198,17 +196,6 @@ export default class HttpServer {
     const server = `${httpsProtocol ? 'https' : 'http'}://${host}:${httpPort}`
 
     log.notice(`Server ready: ${server} 🚀`)
-    log.notice()
-    log.notice('Enter "rp" to replay the last request')
-
-    process.openStdin().addListener('data', (data) => {
-      // note: data is an object, and when converted to a string it will
-      // end with a linefeed.  so we (rather crudely) account for that
-      // with toString() and then trim()
-      if (data.toString().trim() === 'rp') {
-        this.#injectLastRequest()
-      }
-    })
   }
 
   // stops the server
@@ -513,24 +500,11 @@ export default class HttpServer {
     hapiOptions.tags = ['api']
 
     const hapiHandler = async (request, h) => {
-      // Here we go
-      // Store current request as the last one
-      this.#lastRequestOptions = {
-        headers: request.headers,
-        method: request.method,
-        payload: request.payload,
-        url: request.url.href,
-      }
-
       const requestPath =
         endpoint.isHttpApi || this.#options.noPrependStageInUrl
           ? request.path
           : request.path.substr(`/${stage}`.length)
 
-      if (request.auth.credentials && request.auth.strategy) {
-        this.#lastRequestOptions.auth = request.auth
-      }
-
       // Payload processing
       const encoding = detectEncoding(request)
 
@@ -667,24 +641,18 @@ export default class HttpServer {
           event = request.payload || {}
         }
       } else if (integration === 'AWS_PROXY') {
-        const stageVariables = this.#serverless.service.custom
-          ? this.#serverless.service.custom.stageVariables
-          : null
-
         const lambdaProxyIntegrationEvent =
           endpoint.isHttpApi && endpoint.payload === '2.0'
             ? new LambdaProxyIntegrationEventV2(
                 request,
                 stage,
                 endpoint.routeKey,
-                stageVariables,
                 additionalRequestContext,
               )
             : new LambdaProxyIntegrationEvent(
                 request,
                 stage,
                 requestPath,
-                stageVariables,
                 endpoint.isHttpApi ? endpoint.routeKey : null,
                 additionalRequestContext,
               )
@@ -1257,15 +1225,6 @@ export default class HttpServer {
       .map((line) => line.trim())
   }
 
-  #injectLastRequest() {
-    if (this.#lastRequestOptions) {
-      log.notice('Replaying HTTP last request')
-      this.#server.inject(this.#lastRequestOptions)
-    } else {
-      log.notice('No last HTTP request to replay!')
-    }
-  }
-
   writeRoutesTerminal() {
     logRoutes(this.#terminalInfo)
   }

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

@@ -30,22 +30,12 @@ export default class LambdaProxyIntegrationEvent {
 
   #stage = null
 
-  #stageVariables = null
-
-  constructor(
-    request,
-    stage,
-    path,
-    stageVariables,
-    routeKey,
-    additionalRequestContext,
-  ) {
+  constructor(request, stage, path, routeKey, additionalRequestContext) {
     this.#additionalRequestContext = additionalRequestContext || {}
     this.#path = path
     this.#routeKey = routeKey
     this.#request = request
     this.#stage = stage
-    this.#stageVariables = stageVariables
   }
 
   create() {
@@ -227,7 +217,7 @@ export default class LambdaProxyIntegrationEvent {
         stage: this.#stage,
       },
       resource,
-      stageVariables: this.#stageVariables,
+      stageVariables: null,
     }
   }
 }

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

@@ -24,20 +24,11 @@ export default class LambdaProxyIntegrationEventV2 {
 
   #stage = null
 
-  #stageVariables = null
-
-  constructor(
-    request,
-    stage,
-    routeKey,
-    stageVariables,
-    additionalRequestContext,
-  ) {
+  constructor(request, stage, routeKey, additionalRequestContext) {
     this.#additionalRequestContext = additionalRequestContext || {}
     this.#routeKey = routeKey
     this.#request = request
     this.#stage = stage
-    this.#stageVariables = stageVariables
   }
 
   create() {
@@ -183,7 +174,7 @@ export default class LambdaProxyIntegrationEventV2 {
         timeEpoch: requestTimeEpoch,
       },
       routeKey: this.#routeKey,
-      stageVariables: this.#stageVariables,
+      stageVariables: null,
       version: '2.0',
     }
   }

package/src/events/schedule/Schedule.js

@@ -39,9 +39,9 @@ export default class Schedule {
       const cron = this.#convertExpressionToCron(entry)
 
       log.notice(
-        `Scheduling [${functionKey}] cron: [${cron}] input: ${stringify(
-          input,
-        )}`,
+        `Scheduling [${functionKey}] cron: [${cron}]${
+          input ? ` input: ${stringify(input)}` : ''
+        }`,
       )
 
       nodeSchedule.scheduleJob(cron, async () => {

package/src/lambda/LambdaFunction.js

@@ -1,12 +1,12 @@
 import { readFile, writeFile } from 'node:fs/promises'
 import { dirname, join, resolve } from 'node:path'
+import process from 'node:process'
 import { performance } from 'node:perf_hooks'
 import { log } from '@serverless/utils/log.js'
 import { emptyDir, ensureDir, remove } from 'fs-extra'
 import jszip from 'jszip'
 import HandlerRunner from './handler-runner/index.js'
 import LambdaContext from './LambdaContext.js'
-import resolveJoins from '../utils/resolveJoins.js'
 import {
   DEFAULT_LAMBDA_MEMORY_SIZE,
   DEFAULT_LAMBDA_RUNTIME,
@@ -15,8 +15,8 @@ import {
 } from '../config/index.js'
 import { createUniqueId, splitHandlerPathAndName } from '../utils/index.js'
 
-const { entries } = Object
 const { ceil } = Math
+const { entries, fromEntries } = Object
 
 export default class LambdaFunction {
   #artifact = null
@@ -35,6 +35,8 @@ export default class LambdaFunction {
 
   #functionName = null
 
+  #handler = null
+
   #handlerRunner = null
 
   #idleTimeStarted = null
@@ -86,6 +88,7 @@ export default class LambdaFunction {
     // this._executionTimeout = null
     this.#functionKey = functionKey
     this.#functionName = name
+    this.#handler = handler
     this.#memorySize = memorySize
     this.#region = provider.region
     this.#runtime = runtime
@@ -93,11 +96,18 @@ export default class LambdaFunction {
 
     this.#verifySupportedRuntime()
 
-    const env = this.#getEnv(
-      resolveJoins(provider.environment),
-      functionDefinition.environment,
-      handler,
-    )
+    const env = {
+      ...(options.localEnvironment
+        ? process.env
+        : // we always copy all AWS_xxxx environment variables over from local env
+          fromEntries(
+            entries(process.env).filter(([key]) => key.startsWith('AWS_')),
+          )),
+      ...this.#getAwsEnvVars(),
+      ...provider.environment,
+      ...functionDefinition.environment,
+      IS_OFFLINE: 'true',
+    }
 
     this.#artifact = functionDefinition.package?.artifact
 
@@ -176,6 +186,7 @@ export default class LambdaFunction {
   // https://github.com/serverless/serverless/blob/v1.50.0/lib/plugins/aws/invokeLocal/index.js#L108
   #getAwsEnvVars() {
     return {
+      _HANDLER: this.#handler,
       AWS_DEFAULT_REGION: this.#region,
       AWS_LAMBDA_FUNCTION_MEMORY_SIZE: this.#memorySize,
       AWS_LAMBDA_FUNCTION_NAME: this.#functionName,
@@ -194,16 +205,6 @@ export default class LambdaFunction {
     }
   }
 
-  #getEnv(providerEnv, functionDefinitionEnv, handler) {
-    return {
-      ...this.#getAwsEnvVars(),
-      ...providerEnv,
-      ...functionDefinitionEnv,
-      _HANDLER: handler, // TODO is this available in AWS?
-      IS_OFFLINE: true,
-    }
-  }
-
   setClientContext(clientContext) {
     this.#clientContext = clientContext
   }

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

@@ -41,14 +41,18 @@ export default class ChildProcessRunner {
       },
     )
 
-    const message = new Promise((res, rej) => {
-      childProcess.on('message', (data) => {
-        if (data.error) rej(data.error)
-        else res(data)
+    let message
+
+    try {
+      message = new Promise((res, rej) => {
+        childProcess.on('message', (data) => {
+          if (data.error) rej(data.error)
+          else res(data)
+        })
       })
-    }).finally(() => {
+    } finally {
       childProcess.kill()
-    })
+    }
 
     childProcess.send({
       context,

package/src/lambda/handler-runner/docker-runner/DockerContainer.js

@@ -12,6 +12,8 @@ import pRetry from 'p-retry'
 import DockerImage from './DockerImage.js'
 
 const { stringify } = JSON
+const { floor, log: mathLog } = Math
+const { parseFloat } = Number
 const { entries, hasOwn } = Object
 
 export default class DockerContainer {
@@ -402,7 +404,7 @@ export default class DockerContainer {
     const dm = decimals < 0 ? 0 : decimals
     const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
 
-    const i = Math.floor(Math.log(bytes) / Math.log(k))
+    const i = floor(mathLog(bytes) / mathLog(k))
 
     return `${parseFloat((bytes / k ** i).toFixed(dm))} ${sizes[i]}`
   }

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

@@ -1,15 +1,15 @@
-import { mkdir, readFile, rmdir, writeFile } from 'node:fs/promises'
+import { mkdir, readFile, rm, rmdir, writeFile } from 'node:fs/promises'
 import { EOL } from 'node:os'
-import { sep, resolve, parse as pathParse } from 'node:path'
 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, execaSync } from 'execa'
+import { execa } from 'execa'
 
 const { parse, stringify } = JSON
 
-const PAYLOAD_IDENTIFIER = 'offline_payload'
-
 export default class GoRunner {
+  static #payloadIdentifier = 'offline_payload'
+
   #codeDir = null
 
   #env = null
@@ -18,10 +18,10 @@ export default class GoRunner {
 
   #handlerPath = null
 
-  #tmpPath = null
-
   #tmpFile = null
 
+  #tmpPath = null
+
   constructor(funOptions, env) {
     const { handlerPath, codeDir } = funOptions
 
@@ -32,7 +32,12 @@ export default class GoRunner {
 
   async cleanup() {
     try {
-      await rmdir(this.#tmpPath, { recursive: true })
+      // refresh go.mod
+      await rm(this.#tmpFile)
+      await execa('go', ['mod', 'tidy'])
+      await rmdir(this.#tmpPath, {
+        recursive: true,
+      })
     } catch {
       // @ignore
     }
@@ -46,12 +51,10 @@ export default class GoRunner {
     let payload
 
     for (const item of value.split(EOL)) {
-      if (item.indexOf(PAYLOAD_IDENTIFIER) === -1) {
-        logs.push(item)
-      } else if (item.indexOf(PAYLOAD_IDENTIFIER) !== -1) {
+      if (item.includes(GoRunner.#payloadIdentifier)) {
         try {
           const {
-            offline_payload: { success, error },
+            [GoRunner.#payloadIdentifier]: { error, success },
           } = parse(item)
 
           if (success) {
@@ -62,6 +65,8 @@ export default class GoRunner {
         } catch {
           // @ignore
         }
+      } else {
+        logs.push(item)
       }
     }
 
@@ -119,8 +124,11 @@ export default class GoRunner {
       chdir(cwdPath.substring(0, cwdPath.indexOf('main.go')))
 
       // Make sure we have the mock-lambda runner
-      execaSync('go', ['get', 'github.com/icarus-sullivan/mock-lambda@e065469'])
-      execaSync('go', ['build'])
+      await execa('go', [
+        'get',
+        'github.com/icarus-sullivan/mock-lambda@e065469',
+      ])
+      await execa('go', ['build'])
     } catch {
       // @ignore
     }
@@ -154,8 +162,6 @@ export default class GoRunner {
     }
 
     try {
-      // refresh go.mod
-      execaSync('go', ['mod', 'tidy'])
       chdir(this.#codeDir)
     } catch {
       // @ignore

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

@@ -3,6 +3,7 @@ import { performance } from 'node:perf_hooks'
 import process from 'node:process'
 import { log } from '@serverless/utils/log.js'
 
+const { floor } = Math
 const { assign } = Object
 
 const require = createRequire(import.meta.url)
@@ -88,11 +89,11 @@ export default class InProcessRunner {
       ...context,
       done: (err, data) => callback(err, data),
       fail: (err) => callback(err),
-      getRemainingTimeInMillis: () => {
+      getRemainingTimeInMillis() {
         const timeLeft = executionTimeout - performance.now()
 
         // just return 0 for now if we are beyond alotted time (timeout)
-        return timeLeft > 0 ? timeLeft : 0
+        return timeLeft > 0 ? floor(timeLeft) : 0
       },
       succeed: (res) => callback(null, res),
     }

package/src/lambda/handler-runner/java-runner/JavaRunner.js

@@ -4,9 +4,11 @@ import { log } from '@serverless/utils/log.js'
 import { invokeJavaLocal } from 'java-invoke-local'
 
 const { parse, stringify } = JSON
-const { has } = Reflect
+const { hasOwn } = Object
 
 export default class JavaRunner {
+  static #payloadIdentifier = '__offline_payload__'
+
   #deployPackage = null
 
   #env = null
@@ -45,9 +47,9 @@ export default class JavaRunner {
       if (
         json &&
         typeof json === 'object' &&
-        has(json, '__offline_payload__')
+        hasOwn(json, JavaRunner.#payloadIdentifier)
       ) {
-        return json.__offline_payload__
+        return json[JavaRunner.#payloadIdentifier]
       }
     }
 

package/src/lambda/handler-runner/python-runner/PythonRunner.js

@@ -7,12 +7,13 @@ import { fileURLToPath } from 'node:url'
 import { log } from '@serverless/utils/log.js'
 
 const { parse, stringify } = JSON
-const { assign } = Object
-const { has } = Reflect
+const { assign, hasOwn } = Object
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 
 export default class PythonRunner {
+  static #payloadIdentifier = '__offline_payload__'
+
   #env = null
 
   #handlerName = null
@@ -83,9 +84,9 @@ export default class PythonRunner {
       if (
         json &&
         typeof json === 'object' &&
-        has(json, '__offline_payload__')
+        hasOwn(json, PythonRunner.#payloadIdentifier)
       ) {
-        payload = json.__offline_payload__
+        payload = json[PythonRunner.#payloadIdentifier]
         // everything else is print(), logging, ...
       } else {
         log.notice(item)

package/src/lambda/handler-runner/ruby-runner/RubyRunner.js

@@ -6,11 +6,13 @@ import { log } from '@serverless/utils/log.js'
 import { execa } from 'execa'
 
 const { parse, stringify } = JSON
-const { has } = Reflect
+const { hasOwn } = Object
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 
 export default class RubyRunner {
+  static #payloadIdentifier = '__offline_payload__'
+
   #env = null
 
   #handlerName = null
@@ -47,9 +49,9 @@ export default class RubyRunner {
       if (
         json &&
         typeof json === 'object' &&
-        has(json, '__offline_payload__')
+        hasOwn(json, RubyRunner.#payloadIdentifier)
       ) {
-        payload = json.__offline_payload__
+        payload = json[RubyRunner.#payloadIdentifier]
       } else {
         log.notice(item)
       }

package/src/lambda/handler-runner/worker-thread-runner/workerThreadHelper.js

@@ -2,10 +2,10 @@ import { env } from 'node:process'
 import { parentPort, workerData } from 'node:worker_threads'
 import InProcessRunner from '../in-process-runner/index.js'
 
-const { functionKey, handlerName, handlerPath } = workerData
+const { functionKey, handlerName, handlerPath, timeout } = workerData
 
 parentPort.on('message', async (messageData) => {
-  const { context, event, port, timeout } = messageData
+  const { context, event, port } = messageData
 
   // TODO we could probably cache this in the module scope?
   const inProcessRunner = new InProcessRunner(

package/src/utils/resolveJoins.js

@@ -1,29 +0,0 @@
-const { entries } = Object
-
-// Used to resolve Fn::Join in environment variables
-export default function resolveJoins(environment) {
-  if (!environment) {
-    return undefined
-  }
-
-  const newEnv = {}
-
-  entries(environment).forEach(([key, value]) => {
-    if (!value) {
-      return
-    }
-
-    const joinArray = value['Fn::Join']
-    const isJoin = Boolean(joinArray)
-
-    if (isJoin) {
-      const separator = joinArray[0]
-      const joined = joinArray[1].join(separator)
-      newEnv[key] = joined
-    } else {
-      newEnv[key] = value
-    }
-  })
-
-  return newEnv
-}