serverless-offline 13.3.1 → 13.3.3

package/src/lambda/LambdaFunction.js

@@ -1,21 +1,21 @@
-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 { setTimeout } from 'node:timers/promises'
-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 crypto from "node:crypto"
+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 { setTimeout } from "node:timers/promises"
+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 {
   DEFAULT_LAMBDA_MEMORY_SIZE,
   DEFAULT_LAMBDA_RUNTIME,
   DEFAULT_LAMBDA_TIMEOUT,
   supportedRuntimes,
-} from '../config/index.js'
-import { LambdaTimeoutError } from '../errors/index.js'
-import { createUniqueId } from '../utils/index.js'
+} from "../config/index.js"
+import { LambdaTimeoutError } from "../errors/index.js"
 
 const { ceil } = Math
 const { entries, fromEntries } = Object
@@ -57,7 +57,7 @@ export default class LambdaFunction {
 
   #runtime = null
 
-  #status = 'IDLE' // can be 'BUSY' or 'IDLE'
+  #status = "IDLE" // can be 'BUSY' or 'IDLE'
 
   #timeout = null
 
@@ -71,7 +71,7 @@ export default class LambdaFunction {
     // TEMP options.location, for compatibility with serverless-webpack:
     // https://github.com/dherault/serverless-offline/issues/787
     // TODO FIXME look into better way to work with serverless-webpack
-    const servicepath = resolve(servicePath, options.location ?? '')
+    const servicepath = resolve(servicePath, options.location ?? "")
 
     const { handler, name, package: functionPackage = {} } = functionDefinition
 
@@ -104,12 +104,12 @@ export default class LambdaFunction {
         ? process.env
         : // we always copy all AWS_xxxx environment variables over from local env
           fromEntries(
-            entries(process.env).filter(([key]) => key.startsWith('AWS_')),
+            entries(process.env).filter(([key]) => key.startsWith("AWS_")),
           )),
       ...this.#getAwsEnvVars(),
       ...provider.environment,
       ...functionDefinition.environment,
-      IS_OFFLINE: 'true',
+      IS_OFFLINE: "true",
     }
 
     this.#artifact = functionDefinition.package?.artifact
@@ -122,16 +122,16 @@ export default class LambdaFunction {
       // lambda directory contains code and layers
       this.#lambdaDir = join(
         servicepath,
-        '.serverless-offline',
-        'services',
+        ".serverless-offline",
+        "services",
         service.service,
         functionKey,
-        createUniqueId(),
+        crypto.randomUUID(),
       )
     }
 
     this.#codeDir = this.#lambdaDir
-      ? resolve(this.#lambdaDir, 'code')
+      ? resolve(this.#lambdaDir, "code")
       : servicepath
 
     // TEMP
@@ -189,18 +189,18 @@ export default class LambdaFunction {
       AWS_DEFAULT_REGION: this.#region,
       AWS_LAMBDA_FUNCTION_MEMORY_SIZE: this.#memorySize,
       AWS_LAMBDA_FUNCTION_NAME: this.#functionName,
-      AWS_LAMBDA_FUNCTION_VERSION: '$LATEST',
+      AWS_LAMBDA_FUNCTION_VERSION: "$LATEST",
       // https://github.com/serverless/serverless/blob/v1.50.0/lib/plugins/aws/lib/naming.js#L123
       AWS_LAMBDA_LOG_GROUP_NAME: `/aws/lambda/${this.#functionName}`,
       AWS_LAMBDA_LOG_STREAM_NAME:
-        '2016/12/02/[$LATEST]f77ff5e4026c45bda9a9ebcec6bc9cad',
+        "2016/12/02/[$LATEST]f77ff5e4026c45bda9a9ebcec6bc9cad",
       AWS_REGION: this.#region,
-      LAMBDA_RUNTIME_DIR: '/var/runtime',
-      LAMBDA_TASK_ROOT: '/var/task',
-      LANG: 'en_US.UTF-8',
+      LAMBDA_RUNTIME_DIR: "/var/runtime",
+      LAMBDA_TASK_ROOT: "/var/task",
+      LANG: "en_US.UTF-8",
       LD_LIBRARY_PATH:
-        '/usr/local/lib64/node-v4.3.x/lib:/lib64:/usr/lib64:/var/runtime:/var/runtime/lib:/var/task:/var/task/lib:/opt/lib',
-      NODE_PATH: '/var/runtime:/var/task:/var/runtime/node_modules',
+        "/usr/local/lib64/node-v4.3.x/lib:/lib64:/usr/lib64:/var/runtime:/var/runtime/lib:/var/task:/var/task/lib:/opt/lib",
+      NODE_PATH: "/var/runtime:/var/task:/var/runtime/node_modules",
     }
   }
 
@@ -244,8 +244,8 @@ export default class LambdaFunction {
 
     await Promise.all(
       entries(zip.files).map(async ([filename, jsZipObj]) => {
-        const fileData = await jsZipObj.async('nodebuffer')
-        if (filename.endsWith('/')) {
+        const fileData = await jsZipObj.async("nodebuffer")
+        if (filename.endsWith("/")) {
           return undefined
         }
         await ensureDir(join(this.#codeDir, dirname(filename)))
@@ -276,17 +276,17 @@ export default class LambdaFunction {
   async #timeoutAndTerminate() {
     await setTimeout(this.#timeout)
 
-    throw new LambdaTimeoutError('[504] - Lambda timeout.')
+    throw new LambdaTimeoutError("[504] - Lambda timeout.")
   }
 
   async runHandler() {
-    this.#status = 'BUSY'
+    this.#status = "BUSY"
 
     if (!this.#initialized) {
       await this.#initialize()
     }
 
-    const requestId = createUniqueId()
+    const requestId = crypto.randomUUID()
 
     this.#lambdaContext.setRequestId(requestId)
     this.#lambdaContext.setClientContext(this.#clientContext)
@@ -322,7 +322,7 @@ export default class LambdaFunction {
 
       throw err
     } finally {
-      this.#status = 'IDLE'
+      this.#status = "IDLE"
 
       this.#startIdleTimer()
     }

package/src/lambda/LambdaFunctionPool.js

@@ -1,4 +1,4 @@
-import LambdaFunction from './LambdaFunction.js'
+import LambdaFunction from "./LambdaFunction.js"
 
 export default class LambdaFunctionPool {
   #options = null
@@ -34,7 +34,7 @@ export default class LambdaFunctionPool {
           const { idleTimeInMillis, status } = lambdaFunction
 
           if (
-            status === 'IDLE' &&
+            status === "IDLE" &&
             idleTimeInMillis >= functionCleanupIdleTimeInMillis
           ) {
             cleanupWait.push(lambdaFunction.cleanup())
@@ -96,7 +96,7 @@ export default class LambdaFunctionPool {
     if (!this.#options.reloadHandler) {
       // find any IDLE
       lambdaFunction = Array.from(lambdaFunctions).find(
-        ({ status }) => status === 'IDLE',
+        ({ status }) => status === "IDLE",
       )
 
       if (lambdaFunction != null) {

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

@@ -1,4 +1,4 @@
-import { log } from '@serverless/utils/log.js'
+import { log } from "@serverless/utils/log.js"
 import {
   supportedGo,
   supportedJava,
@@ -6,7 +6,7 @@ import {
   supportedPython,
   supportedRuby,
   unsupportedDockerRuntimes,
-} from '../../config/index.js'
+} from "../../config/index.js"
 
 export default class HandlerRunner {
   #env = null
@@ -34,7 +34,7 @@ export default class HandlerRunner {
         log.warning(
           `"${runtime}" runtime is not supported with docker. See https://github.com/lambci/docker-lambda`,
         )
-        throw new Error('Unsupported runtime')
+        throw new Error("Unsupported runtime")
       }
 
       const dockerOptions = {
@@ -45,7 +45,7 @@ export default class HandlerRunner {
         readOnly: this.#options.dockerReadOnly,
       }
 
-      const { default: DockerRunner } = await import('./docker-runner/index.js')
+      const { default: DockerRunner } = await import("./docker-runner/index.js")
 
       return new DockerRunner(this.#funOptions, this.#env, dockerOptions)
     }
@@ -53,50 +53,50 @@ export default class HandlerRunner {
     if (supportedNodejs.has(runtime)) {
       if (useInProcess) {
         const { default: InProcessRunner } = await import(
-          './in-process-runner/index.js'
+          "./in-process-runner/index.js"
         )
 
         return new InProcessRunner(this.#funOptions, this.#env)
       }
 
       const { default: WorkerThreadRunner } = await import(
-        './worker-thread-runner/index.js'
+        "./worker-thread-runner/index.js"
       )
 
       return new WorkerThreadRunner(this.#funOptions, this.#env)
     }
 
     if (supportedGo.has(runtime)) {
-      const { default: GoRunner } = await import('./go-runner/index.js')
+      const { default: GoRunner } = await import("./go-runner/index.js")
 
       return new GoRunner(this.#funOptions, this.#env)
     }
 
     if (supportedPython.has(runtime)) {
-      const { default: PythonRunner } = await import('./python-runner/index.js')
+      const { default: PythonRunner } = await import("./python-runner/index.js")
 
       return new PythonRunner(this.#funOptions, this.#env)
     }
 
     if (supportedRuby.has(runtime)) {
-      const { default: RubyRunner } = await import('./ruby-runner/index.js')
+      const { default: RubyRunner } = await import("./ruby-runner/index.js")
 
       return new RubyRunner(this.#funOptions, this.#env)
     }
 
     if (supportedJava.has(runtime)) {
-      const { default: JavaRunner } = await import('./java-runner/index.js')
+      const { default: JavaRunner } = await import("./java-runner/index.js")
 
       return new JavaRunner(this.#funOptions, this.#env)
     }
 
     // TODO FIXME
-    throw new Error('Unsupported runtime')
+    throw new Error("Unsupported runtime")
   }
 
   // TEMP TODO FIXME
   isDockerRunner() {
-    return this.#runner && this.#runner.constructor.name === 'DockerRunner'
+    return this.#runner && this.#runner.constructor.name === "DockerRunner"
   }
 
   // () => Promise<void>

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

@@ -1,16 +1,16 @@
-import { createHash } from 'node:crypto'
-import { createWriteStream } from 'node:fs'
-import { readFile, unlink, writeFile } from 'node:fs/promises'
-import { platform } from 'node:os'
-import { dirname, join, sep } from 'node:path'
-import { LambdaClient, GetLayerVersionCommand } from '@aws-sdk/client-lambda'
-import { log, progress } from '@serverless/utils/log.js'
-import { execa } from 'execa'
-import { ensureDir, pathExists } from 'fs-extra'
-import isWsl from 'is-wsl'
-import jszip from 'jszip'
-import pRetry from 'p-retry'
-import DockerImage from './DockerImage.js'
+import { createHash } from "node:crypto"
+import { createWriteStream } from "node:fs"
+import { readFile, unlink, writeFile } from "node:fs/promises"
+import { platform } from "node:os"
+import { dirname, join, sep } from "node:path"
+import { LambdaClient, GetLayerVersionCommand } from "@aws-sdk/client-lambda"
+import { log, progress } from "@serverless/utils/log.js"
+import { execa } from "execa"
+import { ensureDir, pathExists } from "fs-extra"
+import isWsl from "is-wsl"
+import jszip from "jszip"
+import pRetry from "p-retry"
+import DockerImage from "./DockerImage.js"
 
 const { stringify } = JSON
 const { floor, log: mathLog } = Math
@@ -73,33 +73,33 @@ export default class DockerContainer {
   async start(codeDir) {
     await this.#image.pull()
 
-    log.debug('Run Docker container...')
+    log.debug("Run Docker container...")
 
-    let permissions = 'ro'
+    let permissions = "ro"
 
     if (!this.#dockerOptions.readOnly) {
-      permissions = 'rw'
+      permissions = "rw"
     }
     // https://github.com/serverless/serverless/blob/v1.57.0/lib/plugins/aws/invokeLocal/index.js#L291-L293
     const dockerArgs = [
-      '-v',
+      "-v",
       `${codeDir}:/var/task:${permissions},delegated`,
-      '-p',
+      "-p",
       9001,
-      '-e',
-      'DOCKER_LAMBDA_STAY_OPEN=1', // API mode
-      '-e',
-      'DOCKER_LAMBDA_WATCH=1', // Watch mode
+      "-e",
+      "DOCKER_LAMBDA_STAY_OPEN=1", // API mode
+      "-e",
+      "DOCKER_LAMBDA_WATCH=1", // Watch mode
     ]
 
     if (this.#layers.length > 0) {
       log.verbose(`Found layers, checking provider type`)
 
-      if (this.#provider.name.toLowerCase() === 'aws') {
+      if (this.#provider.name.toLowerCase() === "aws") {
         let layerDir = this.#dockerOptions.layersDir
 
         if (!layerDir) {
-          layerDir = join(this.#servicePath, '.serverless-offline', 'layers')
+          layerDir = join(this.#servicePath, ".serverless-offline", "layers")
         }
 
         layerDir = join(layerDir, this.#getLayersSha256())
@@ -113,7 +113,7 @@ export default class DockerContainer {
 
           // Only initialise if we have layers, we're using AWS, and they don't already exist
           this.#lambdaClient = new LambdaClient({
-            apiVersion: '2015-03-31',
+            apiVersion: "2015-03-31",
             region: this.#provider.region,
           })
 
@@ -135,7 +135,7 @@ export default class DockerContainer {
             this.#dockerOptions.hostServicePath,
           )
         }
-        dockerArgs.push('-v', `${layerDir}:/opt:ro,delegated`)
+        dockerArgs.push("-v", `${layerDir}:/opt:ro,delegated`)
       } else {
         log.warning(
           `Provider ${this.#provider.name} is Unsupported. Layers are only supported on aws.`,
@@ -144,52 +144,52 @@ export default class DockerContainer {
     }
 
     entries(this.#env).forEach(([key, value]) => {
-      dockerArgs.push('-e', `${key}=${value}`)
+      dockerArgs.push("-e", `${key}=${value}`)
     })
 
-    if (platform() === 'linux' && !isWsl) {
+    if (platform() === "linux" && !isWsl) {
       // Add `host.docker.internal` DNS name to access host from inside the container
       // https://github.com/docker/for-linux/issues/264
       const gatewayIp = await this.#getBridgeGatewayIp()
       if (gatewayIp) {
-        dockerArgs.push('--add-host', `host.docker.internal:${gatewayIp}`)
+        dockerArgs.push("--add-host", `host.docker.internal:${gatewayIp}`)
       }
     }
 
     if (this.#dockerOptions.network) {
-      dockerArgs.push('--network', this.#dockerOptions.network)
+      dockerArgs.push("--network", this.#dockerOptions.network)
     }
 
-    const { stdout: containerId } = await execa('docker', [
-      'create',
+    const { stdout: containerId } = await execa("docker", [
+      "create",
       ...dockerArgs,
       this.#imageNameTag,
       this.#handler,
     ])
 
-    const dockerStart = execa('docker', ['start', '-a', containerId], {
+    const dockerStart = execa("docker", ["start", "-a", containerId], {
       all: true,
     })
 
     await new Promise((resolve, reject) => {
-      dockerStart.all.on('data', (data) => {
+      dockerStart.all.on("data", (data) => {
         const str = String(data)
         log.error(str)
 
-        if (str.includes('Lambda API listening on port')) {
+        if (str.includes("Lambda API listening on port")) {
           resolve()
         }
       })
 
-      dockerStart.on('error', (err) => {
+      dockerStart.on("error", (err) => {
         reject(err)
       })
     })
 
     // parse `docker port` output and get the container port
     let containerPort
-    const { stdout: dockerPortOutput } = await execa('docker', [
-      'port',
+    const { stdout: dockerPortOutput } = await execa("docker", [
+      "port",
       containerId,
     ])
     // NOTE: `docker port` may output multiple lines.
@@ -199,7 +199,7 @@ export default class DockerContainer {
     // 9001/tcp -> :::49153
     //
     // Parse each line until it finds the mapped port.
-    for (const line of dockerPortOutput.split('\n')) {
+    for (const line of dockerPortOutput.split("\n")) {
       const result = line.match(/^9001\/tcp -> (.*):(\d+)$/)
       if (result && result.length > 2) {
         ;[, , containerPort] = result
@@ -207,7 +207,7 @@ export default class DockerContainer {
       }
     }
     if (!containerPort) {
-      throw new Error('Failed to get container port')
+      throw new Error("Failed to get container port")
     }
 
     this.#containerId = containerId
@@ -224,7 +224,7 @@ export default class DockerContainer {
   }
 
   async #downloadLayer(layerArn, layerDir) {
-    const [, layerName] = layerArn.split(':layer:')
+    const [, layerName] = layerArn.split(":layer:")
     const layerZipFile = `${layerDir}/${layerName}.zip`
     const layerProgress = progress.get(`layer-${layerName}`)
 
@@ -249,7 +249,7 @@ export default class DockerContainer {
       }
 
       if (
-        hasOwn(layer, 'CompatibleRuntimes') &&
+        hasOwn(layer, "CompatibleRuntimes") &&
         !layer.CompatibleRuntimes.includes(this.#runtime)
       ) {
         log.warning(
@@ -289,10 +289,10 @@ export default class DockerContainer {
 
       await new Promise((resolve, reject) => {
         res.body.pipe(fileStream)
-        res.body.on('error', (err) => {
+        res.body.on("error", (err) => {
           reject(err)
         })
-        fileStream.on('finish', () => {
+        fileStream.on("finish", () => {
           resolve()
         })
       })
@@ -307,7 +307,7 @@ export default class DockerContainer {
 
       await Promise.all(
         entries(zip.files).map(async ([filename, jsZipObj]) => {
-          const fileData = await jsZipObj.async('nodebuffer')
+          const fileData = await jsZipObj.async("nodebuffer")
           if (filename.endsWith(sep)) {
             return undefined
           }
@@ -329,19 +329,19 @@ export default class DockerContainer {
   async #getBridgeGatewayIp() {
     let gateway
     try {
-      ;({ stdout: gateway } = await execa('docker', [
-        'network',
-        'inspect',
-        'bridge',
-        '--format',
-        '{{(index .IPAM.Config 0).Gateway}}',
+      ;({ stdout: gateway } = await execa("docker", [
+        "network",
+        "inspect",
+        "bridge",
+        "--format",
+        "{{(index .IPAM.Config 0).Gateway}}",
       ]))
     } catch (err) {
       log.error(err.stderr)
 
       throw err
     }
-    return gateway.split('/')[0]
+    return gateway.split("/")[0]
   }
 
   async #ping() {
@@ -360,8 +360,8 @@ export default class DockerContainer {
 
     const res = await fetch(url, {
       body: stringify(event),
-      headers: { 'Content-Type': 'application/json' },
-      method: 'post',
+      headers: { "Content-Type": "application/json" },
+      method: "post",
     })
 
     if (!res.ok) {
@@ -374,8 +374,8 @@ export default class DockerContainer {
   async stop() {
     if (this.#containerId) {
       try {
-        await execa('docker', ['stop', this.#containerId])
-        await execa('docker', ['rm', this.#containerId])
+        await execa("docker", ["stop", this.#containerId])
+        await execa("docker", ["rm", this.#containerId])
       } catch (err) {
         log.error(err.stderr)
 
@@ -385,11 +385,11 @@ export default class DockerContainer {
   }
 
   #formatBytes(bytes, decimals = 2) {
-    if (bytes === 0) return '0 Bytes'
+    if (bytes === 0) return "0 Bytes"
 
     const k = 1024
     const dm = decimals < 0 ? 0 : decimals
-    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
+    const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"]
 
     const i = floor(mathLog(bytes) / mathLog(k))
 
@@ -397,7 +397,7 @@ export default class DockerContainer {
   }
 
   #getLayersSha256() {
-    return createHash('sha256').update(stringify(this.#layers)).digest('hex')
+    return createHash("sha256").update(stringify(this.#layers)).digest("hex")
   }
 
   get isRunning() {

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

@@ -1,8 +1,8 @@
-import { log } from '@serverless/utils/log.js'
-import { execa } from 'execa'
+import { log } from "@serverless/utils/log.js"
+import { execa } from "execa"
 // TODO FIXME eslint plugin import bug, or not supporting package.json "expprts" field?
 // eslint-disable-next-line import/no-unresolved
-import promiseMemoize from 'p-memoize'
+import promiseMemoize from "p-memoize"
 
 export default class DockerImage {
   #imageNameTag = null
@@ -17,9 +17,9 @@ export default class DockerImage {
     log.debug(`Downloading base Docker image... (${imageNameTag})`)
 
     try {
-      await execa('docker', [
-        'pull',
-        '--disable-content-trust=false',
+      await execa("docker", [
+        "pull",
+        "--disable-content-trust=false",
         imageNameTag,
       ])
     } catch (err) {

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

@@ -1,5 +1,5 @@
-import DockerContainer from './DockerContainer.js'
-import { checkDockerDaemon } from '../../../utils/index.js'
+import DockerContainer from "./DockerContainer.js"
+import { checkDockerDaemon } from "../../../utils/index.js"
 
 export default class DockerRunner {
   #codeDir = null

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

@@ -1 +1 @@
-export { default } from './DockerRunner.js'
+export { default } from "./DockerRunner.js"