serverless-offline 8.8.1 → 9.1.1

package/src/lambda/__tests__/fixtures/Lambda/LambdaFunctionThatReturnsNativeString.fixture.js

@@ -0,0 +1,46 @@
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import LambdaFunction from '../../../LambdaFunction.js'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+export default class LambdaFunctionThatReturnsNativeString {
+  #lambdaFunction
+
+  options = {}
+
+  serverless = {
+    config: {
+      serverlessPath: '',
+      servicePath: resolve(__dirname),
+    },
+    service: {
+      provider: {
+        runtime: 'nodejs12.x',
+      },
+    },
+  }
+
+  listFunctionNames() {
+    return ['foo']
+  }
+
+  getByFunctionName(functionName) {
+    const functionDefinition = {
+      handler: '../../fixtures/lambdaFunction.fixture.asyncFunctionHandler',
+    }
+
+    this.#lambdaFunction = new LambdaFunction(
+      functionName,
+      functionDefinition,
+      this.serverless,
+      this.options,
+    )
+
+    return this.#lambdaFunction
+  }
+
+  async cleanup() {
+    await this.#lambdaFunction.cleanup()
+  }
+}

package/src/lambda/__tests__/fixtures/Lambda/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/src/lambda/__tests__/fixtures/lambdaFunction.fixture.js

@@ -0,0 +1,145 @@
+'use strict'
+
+exports.contextDoneHandler = function contextDoneHandler(event, context) {
+  context.done(null, 'foo')
+}
+
+exports.contextDoneHandlerDeferred = function contextDoneHandlerDeferred(
+  event,
+  context,
+) {
+  setTimeout(() => context.done(null, 'foo'), 100)
+}
+
+exports.contextSucceedHandler = function contextSucceedHandler(event, context) {
+  context.succeed('foo')
+}
+
+exports.contextSucceedHandlerDeferred = function contextSucceedHandlerDeferred(
+  event,
+  context,
+) {
+  setTimeout(() => context.succeed('foo'), 100)
+}
+
+exports.callbackHandler = function callbackHandler(event, context, callback) {
+  callback(null, 'foo')
+}
+
+exports.callbackHandlerDeferred = function callbackHandlerDeferred(
+  event,
+  context,
+  callback,
+) {
+  setTimeout(() => callback(null, 'foo'), 100)
+}
+
+exports.promiseHandler = function promiseHandler() {
+  return Promise.resolve('foo')
+}
+
+exports.promiseHandlerDeferred = function promiseDeferred() {
+  return new Promise((resolve) => {
+    setTimeout(() => resolve('foo'), 100)
+  })
+}
+
+exports.asyncFunctionHandler = async function asyncFunctionHandler() {
+  return 'foo'
+}
+
+exports.asyncFunctionHandlerObject = async function asyncFunctionHandler() {
+  return {
+    foo: 'bar',
+  }
+}
+
+// we deliberately test the case where a 'callback' is defined
+// in the handler, but a promise is being returned to protect from a
+// potential naive implementation, e.g.
+//
+// const { promisify } = 'utils'
+// const promisifiedHandler = handler.length === 3 ? promisify(handler) : handler
+//
+// if someone would return a promise, but also defines callback, without using it
+// the handler would not be returning anything
+exports.promiseWithDefinedCallbackHandler =
+  function promiseWithDefinedCallbackHandler(
+    event, // eslint-disable-line no-unused-vars
+    context, // eslint-disable-line no-unused-vars
+    callback, // eslint-disable-line no-unused-vars
+  ) {
+    return Promise.resolve('Hello Promise!')
+  }
+
+exports.contextSucceedWithContextDoneHandler =
+  function contextSucceedWithContextDoneHandler(event, context) {
+    context.succeed('Hello Context.succeed!')
+
+    context.done(null, 'Hello Context.done!')
+  }
+
+exports.callbackWithContextDoneHandler =
+  function callbackWithContextDoneHandler(event, context, callback) {
+    callback(null, 'Hello Callback!')
+
+    context.done(null, 'Hello Context.done!')
+  }
+
+exports.callbackWithPromiseHandler = function callbackWithPromiseHandler(
+  event,
+  context,
+  callback,
+) {
+  callback(null, 'Hello Callback!')
+
+  return Promise.resolve('Hello Promise!')
+}
+
+exports.callbackInsidePromiseHandler = function callbackInsidePromiseHandler(
+  event,
+  context,
+  callback,
+) {
+  return new Promise((resolve) => {
+    callback(null, 'Hello Callback!')
+
+    resolve('Hello Promise!')
+  })
+}
+
+exports.requestIdHandler = async function requestIdHandler(event, context) {
+  return context.awsRequestId
+}
+
+exports.remainingExecutionTimeHandler =
+  async function remainingExecutionTimeHandler(event, context) {
+    const first = context.getRemainingTimeInMillis()
+
+    await new Promise((resolve) => {
+      setTimeout(resolve, 100)
+    })
+
+    const second = context.getRemainingTimeInMillis()
+
+    await new Promise((resolve) => {
+      setTimeout(resolve, 200)
+    })
+
+    const third = context.getRemainingTimeInMillis()
+
+    return [first, second, third]
+  }
+
+exports.defaultTimeoutHandler = async function defaultTimeoutHandler(
+  event,
+  context,
+) {
+  return context.getRemainingTimeInMillis()
+}
+
+exports.executionTimeInMillisHandler = function executionTimeInMillisHandler() {
+  return new Promise((resolve) => {
+    setTimeout(resolve, 100)
+  })
+}

package/src/lambda/__tests__/fixtures/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/src/lambda/__tests__/routes/invocations/InvocationsController.test.js

@@ -0,0 +1,42 @@
+import assert from 'node:assert'
+import InvocationsController from '../../../routes/invocations/InvocationsController.js'
+import LambdaFunctionThatReturnsJSONObject from '../../fixtures/Lambda/LambdaFunctionThatReturnsJSONObject.fixture.js'
+import LambdaFunctionThatReturnsNativeString from '../../fixtures/Lambda/LambdaFunctionThatReturnsNativeString.fixture.js'
+
+describe('InvocationController', () => {
+  const functionName = 'foo'
+
+  describe('when event type is "RequestResponse"', () => {
+    const eventType = 'RequestResponse'
+
+    it('should return json object if lambda response is json', async () => {
+      const expected = {
+        Payload: {
+          foo: 'bar',
+        },
+        StatusCode: 200,
+      }
+
+      const lambdaFunction = new LambdaFunctionThatReturnsJSONObject()
+      const invocationController = new InvocationsController(lambdaFunction)
+      const result = await invocationController.invoke(functionName, eventType)
+      await lambdaFunction.cleanup()
+
+      assert.deepEqual(result, expected)
+    })
+
+    it('should wrap native string responses with ""', async () => {
+      const expected = {
+        Payload: '"foo"',
+        StatusCode: 200,
+      }
+
+      const lambdaFunction = new LambdaFunctionThatReturnsNativeString()
+      const invocationController = new InvocationsController(lambdaFunction)
+      const result = await invocationController.invoke(functionName, eventType)
+      await lambdaFunction.cleanup()
+
+      assert.deepEqual(result, expected)
+    })
+  })
+})

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

@@ -0,0 +1,136 @@
+import { log } from '@serverless/utils/log.js'
+import {
+  supportedGo,
+  supportedJava,
+  supportedNodejs,
+  supportedPython,
+  supportedRuby,
+} from '../../config/index.js'
+
+export default class HandlerRunner {
+  #env = null
+
+  #funOptions = null
+
+  #options = null
+
+  #runner = null
+
+  constructor(funOptions, options, env) {
+    this.#env = env
+    this.#funOptions = funOptions
+    this.#options = options
+  }
+
+  async #loadRunner() {
+    const { useChildProcesses, useDocker, useInProcess } = this.#options
+
+    const { functionKey, handlerName, handlerPath, runtime, timeout } =
+      this.#funOptions
+
+    log.debug(`Loading handler... (${handlerPath})`)
+
+    if (useDocker) {
+      // https://github.com/lambci/docker-lambda/issues/329
+      if (runtime === 'nodejs14.x') {
+        log.warning(
+          '"nodejs14.x" runtime is not supported with docker. See https://github.com/lambci/docker-lambda/issues/329',
+        )
+        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,
+        layersDir: this.#options.layersDir,
+        network: this.#options.dockerNetwork,
+        readOnly: this.#options.dockerReadOnly,
+      }
+
+      const { default: DockerRunner } = await import('./docker-runner/index.js')
+
+      return new DockerRunner(this.#funOptions, this.#env, dockerOptions)
+    }
+
+    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'
+        )
+
+        return new InProcessRunner(
+          functionKey,
+          handlerPath,
+          handlerName,
+          this.#env,
+          timeout,
+        )
+      }
+
+      const { default: WorkerThreadRunner } = await import(
+        './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')
+
+      return new GoRunner(this.#funOptions, this.#env)
+    }
+
+    if (supportedPython.has(runtime)) {
+      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')
+
+      return new RubyRunner(this.#funOptions, this.#env)
+    }
+
+    if (supportedJava.has(runtime)) {
+      const { default: JavaRunner } = await import('./java-runner/index.js')
+
+      return new JavaRunner(this.#funOptions, this.#env)
+    }
+
+    // TODO FIXME
+    throw new Error('Unsupported runtime')
+  }
+
+  // TEMP TODO FIXME
+  isDockerRunner() {
+    return this.#runner && this.#runner.constructor.name === 'DockerRunner'
+  }
+
+  // () => Promise<void>
+  cleanup() {
+    // TODO console.log('handler runner cleanup')
+    return this.#runner.cleanup()
+  }
+
+  async run(event, context) {
+    if (this.#runner == null) {
+      this.#runner = await this.#loadRunner()
+    }
+
+    return this.#runner.run(event, context)
+  }
+}

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

@@ -0,0 +1,76 @@
+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 {
+  #env = null
+
+  #functionKey = null
+
+  #handlerName = null
+
+  #handlerPath = null
+
+  #timeout = null
+
+  constructor(funOptions, env) {
+    const { functionKey, handlerName, handlerPath, timeout } = funOptions
+
+    this.#env = env
+    this.#functionKey = functionKey
+    this.#handlerName = handlerName
+    this.#handlerPath = handlerPath
+    this.#timeout = timeout
+  }
+
+  // no-op
+  // () => void
+  cleanup() {}
+
+  async run(event, context) {
+    const childProcess = execaNode(
+      childProcessHelperPath,
+      [this.#functionKey, this.#handlerName, this.#handlerPath],
+      {
+        env: this.#env,
+        stdio: 'inherit',
+      },
+    )
+
+    let message
+
+    try {
+      message = new Promise((res, rej) => {
+        childProcess.on('message', (data) => {
+          if (data.error) rej(data.error)
+          else res(data)
+        })
+      })
+    } finally {
+      childProcess.kill()
+    }
+
+    childProcess.send({
+      context,
+      event,
+      timeout: this.#timeout,
+    })
+
+    let result
+
+    try {
+      result = await message
+    } catch (err) {
+      // TODO
+      log.error(err)
+
+      throw err
+    }
+
+    return result
+  }
+}

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

@@ -0,0 +1,42 @@
+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, handlerName, handlerPath] = 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,
+    process.env,
+    timeout,
+  )
+
+  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

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