serverless-offline 9.1.7 → 9.2.2

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

@@ -2,9 +2,10 @@ import { spawn } from 'node:child_process'
 import { EOL, platform } from 'node:os'
 import { delimiter, dirname, join, relative, resolve } from 'node:path'
 import process, { cwd } from 'node:process'
-import readline from 'node:readline'
+import { createInterface } from 'node:readline'
 import { fileURLToPath } from 'node:url'
 import { log } from '@serverless/utils/log.js'
+import { splitHandlerPathAndName } from '../../../utils/index.js'
 
 const { parse, stringify } = JSON
 const { assign, hasOwn } = Object
@@ -16,18 +17,15 @@ export default class PythonRunner {
 
   #env = null
 
-  #handlerName = null
-
-  #handlerPath = null
+  #handlerProcess = null
 
   #runtime = null
 
   constructor(funOptions, env) {
-    const { handlerName, handlerPath, runtime } = funOptions
+    const { handler, runtime } = funOptions
+    const [handlerPath, handlerName] = splitHandlerPathAndName(handler)
 
     this.#env = env
-    this.#handlerName = handlerName
-    this.#handlerPath = handlerPath
     this.#runtime = platform() === 'win32' ? 'python.exe' : runtime
 
     if (process.env.VIRTUAL_ENV) {
@@ -42,13 +40,13 @@ export default class PythonRunner {
 
     const [pythonExecutable] = this.#runtime.split('.')
 
-    this.handlerProcess = spawn(
+    this.#handlerProcess = spawn(
       pythonExecutable,
       [
         '-u',
         resolve(__dirname, 'invoke.py'),
-        relative(cwd(), this.#handlerPath),
-        this.#handlerName,
+        relative(cwd(), handlerPath),
+        handlerName,
       ],
       {
         env: assign(process.env, this.#env),
@@ -56,14 +54,14 @@ export default class PythonRunner {
       },
     )
 
-    this.handlerProcess.stdout.readline = readline.createInterface({
-      input: this.handlerProcess.stdout,
+    this.#handlerProcess.stdout.readline = createInterface({
+      input: this.#handlerProcess.stdout,
     })
   }
 
   // () => void
   cleanup() {
-    this.handlerProcess.kill()
+    this.#handlerProcess.kill()
   }
 
   #parsePayload(value) {
@@ -117,8 +115,8 @@ export default class PythonRunner {
         try {
           const parsed = this.#parsePayload(line.toString())
           if (parsed) {
-            this.handlerProcess.stdout.readline.removeListener('line', onLine)
-            this.handlerProcess.stderr.removeListener('data', onErr)
+            this.#handlerProcess.stdout.readline.removeListener('line', onLine)
+            this.#handlerProcess.stderr.removeListener('data', onErr)
             return accept(parsed)
           }
           return null
@@ -127,12 +125,12 @@ export default class PythonRunner {
         }
       }
 
-      this.handlerProcess.stdout.readline.on('line', onLine)
-      this.handlerProcess.stderr.on('data', onErr)
+      this.#handlerProcess.stdout.readline.on('line', onLine)
+      this.#handlerProcess.stderr.on('data', onErr)
 
       process.nextTick(() => {
-        this.handlerProcess.stdin.write(input)
-        this.handlerProcess.stdin.write('\n')
+        this.#handlerProcess.stdin.write(input)
+        this.#handlerProcess.stdin.write('\n')
       })
     })
   }

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

@@ -4,6 +4,7 @@ import { cwd } from 'node:process'
 import { fileURLToPath } from 'node:url'
 import { log } from '@serverless/utils/log.js'
 import { execa } from 'execa'
+import { splitHandlerPathAndName } from '../../../utils/index.js'
 
 const { parse, stringify } = JSON
 const { hasOwn } = Object
@@ -20,7 +21,9 @@ export default class RubyRunner {
   #handlerPath = null
 
   constructor(funOptions, env) {
-    const { handlerName, handlerPath } = funOptions
+    const [handlerPath, handlerName] = splitHandlerPathAndName(
+      funOptions.handler,
+    )
 
     this.#env = env
     this.#handlerName = handlerName

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

@@ -8,18 +8,17 @@ const workerThreadHelperPath = resolve(__dirname, './workerThreadHelper.js')
 export default class WorkerThreadRunner {
   #workerThread = null
 
-  constructor(funOptions /* options */, env) {
-    // this._options = options
-
-    const { functionKey, handlerName, handlerPath, timeout } = funOptions
+  constructor(funOptions, env) {
+    const { codeDir, functionKey, handler, servicePath, timeout } = funOptions
 
     this.#workerThread = new Worker(workerThreadHelperPath, {
       // don't pass process.env from the main process!
       env,
       workerData: {
+        codeDir,
         functionKey,
-        handlerName,
-        handlerPath,
+        handler,
+        servicePath,
         timeout,
       },
     })

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

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

package/src/lambda/__tests__/LambdaContext.test.js

@@ -1,30 +0,0 @@
-import assert from 'node:assert'
-import LambdaContext from '../LambdaContext.js'
-
-describe('LambdaContext', () => {
-  it('should create LambdaContext with correct values', () => {
-    const functionName = 'foo'
-    const memorySize = 512
-    const requestId = 'abc123'
-
-    const lambdaContext = new LambdaContext(functionName, memorySize)
-    lambdaContext.setRequestId(requestId)
-    const context = lambdaContext.create()
-
-    const expected = {
-      awsRequestId: 'abc123',
-      callbackWaitsForEmptyEventLoop: true,
-      clientContext: undefined,
-      functionName: 'foo',
-      functionVersion: '$LATEST',
-      identity: undefined,
-      invokedFunctionArn: 'offline_invokedFunctionArn_for_foo',
-      logGroupName: 'offline_logGroupName_for_foo',
-      logStreamName: 'offline_logStreamName_for_foo',
-      memoryLimitInMB: '512',
-    }
-
-    // expect(context).toEqual(expected)
-    assert.deepEqual(context, expected)
-  })
-})

package/src/lambda/__tests__/LambdaFunction.test.js

@@ -1,196 +0,0 @@
-import assert from 'node:assert'
-import { dirname, resolve } from 'node:path'
-// import { performance } from 'node:perf_hooks'
-import { fileURLToPath } from 'node:url'
-import LambdaFunction from '../LambdaFunction.js'
-import { DEFAULT_LAMBDA_TIMEOUT } from '../../config/index.js'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-
-describe('LambdaFunction', () => {
-  const functionName = 'foo'
-
-  const serverless = {
-    config: {
-      serverlessPath: '',
-      servicePath: resolve(__dirname),
-    },
-    service: {
-      provider: {
-        runtime: 'nodejs12.x',
-      },
-    },
-  }
-
-  describe('Handler tests', () => {
-    ;[
-      {
-        description: 'should return result when handler is context.done',
-        expected: 'foo',
-        handler: 'fixtures/lambdaFunction.fixture.contextDoneHandler',
-      },
-      {
-        description:
-          'should return result when handler is context.done which is deferred',
-        expected: 'foo',
-        handler: 'fixtures/lambdaFunction.fixture.contextDoneHandlerDeferred',
-      },
-      {
-        description: 'should return result when handler is context.succeed',
-        expected: 'foo',
-        handler: 'fixtures/lambdaFunction.fixture.contextSucceedHandler',
-      },
-      {
-        description:
-          'should return result when handler is context.succeed which is deferred',
-        expected: 'foo',
-        handler:
-          'fixtures/lambdaFunction.fixture.contextSucceedHandlerDeferred',
-      },
-      {
-        description: 'should return result when handler is a callback',
-        expected: 'foo',
-        handler: 'fixtures/lambdaFunction.fixture.callbackHandler',
-      },
-      {
-        description:
-          'should return result when handler is a callback which is deferred',
-        expected: 'foo',
-        handler: 'fixtures/lambdaFunction.fixture.callbackHandlerDeferred',
-      },
-      {
-        description: 'should return result when handler returns a promise',
-        expected: 'foo',
-        handler: 'fixtures/lambdaFunction.fixture.promiseHandler',
-      },
-      {
-        description:
-          'should return result when handler returns a promise which is deferred',
-        expected: 'foo',
-        handler: 'fixtures/lambdaFunction.fixture.promiseHandlerDeferred',
-      },
-      {
-        description: 'should return result when handler is an async function',
-        expected: 'foo',
-        handler: 'fixtures/lambdaFunction.fixture.asyncFunctionHandler',
-      },
-      // NOTE: mix and matching of callbacks and promises is not recommended,
-      // nonetheless, we test some of the behaviour to match AWS execution precedence
-      {
-        description:
-          'should return result when handler returns a callback but defines a callback parameter',
-        expected: 'Hello Promise!',
-        handler:
-          'fixtures/lambdaFunction.fixture.promiseWithDefinedCallbackHandler',
-      },
-      {
-        description:
-          'should return result when handler calls context.succeed and context.done',
-        expected: 'Hello Context.succeed!',
-        handler:
-          'fixtures/lambdaFunction.fixture.contextSucceedWithContextDoneHandler',
-      },
-      {
-        description:
-          'should return result when handler calls callback and context.done',
-        expected: 'Hello Callback!',
-        handler:
-          'fixtures/lambdaFunction.fixture.callbackWithContextDoneHandler',
-      },
-      {
-        description:
-          'should return result when handler calls callback and returns Promise',
-        expected: 'Hello Callback!',
-        handler: 'fixtures/lambdaFunction.fixture.callbackWithPromiseHandler',
-      },
-      {
-        description:
-          'should return result when handler calls callback inside returned Promise',
-        expected: 'Hello Callback!',
-        handler: 'fixtures/lambdaFunction.fixture.callbackInsidePromiseHandler',
-      },
-    ].forEach(({ description, expected, handler }) => {
-      it(description, async () => {
-        const functionDefinition = {
-          handler,
-        }
-        const options = {}
-        const lambdaFunction = new LambdaFunction(
-          functionName,
-          functionDefinition,
-          serverless,
-          options,
-        )
-        const result = await lambdaFunction.runHandler()
-
-        await lambdaFunction.cleanup()
-
-        assert.equal(result, expected)
-      })
-    })
-  })
-
-  it('should pass remaining time to LambdaContext', async () => {
-    const functionDefinition = {
-      handler: 'fixtures/lambdaFunction.fixture.remainingExecutionTimeHandler',
-    }
-    const options = {}
-    const lambdaFunction = new LambdaFunction(
-      functionName,
-      functionDefinition,
-      serverless,
-      options,
-    )
-    const [first, second, third] = await lambdaFunction.runHandler()
-
-    await lambdaFunction.cleanup()
-
-    // handler "pauses" for 100 ms
-    assert.ok(first > second - 100)
-    assert.ok(second > third - 200)
-  })
-
-  it.skip('should use default lambda timeout when timeout is not provided', async () => {
-    const functionDefinition = {
-      handler: 'fixtures/lambdaFunction.fixture.defaultTimeoutHandler',
-    }
-    const options = {}
-    const lambdaFunction = new LambdaFunction(
-      functionName,
-      functionDefinition,
-      serverless,
-      options,
-    )
-    const remainingTime = await lambdaFunction.runHandler()
-
-    await lambdaFunction.cleanup()
-
-    assert.ok(remainingTime < DEFAULT_LAMBDA_TIMEOUT * 1000)
-
-    // result might be flaky/unreliable:
-    // (assmuning handler runs no longer than 1 s)
-    assert.ok(remainingTime + 1000 > DEFAULT_LAMBDA_TIMEOUT * 1000)
-  })
-
-  // // might run flaky (unreliable)
-  // test('executionTimeInMillis should return execution time', async () => {
-  //   const functionDefinition = {
-  //     handler: 'fixtures/lambdaFunction.fixture.executionTimeInMillisHandler',
-  //   }
-  //   const options = {}
-  //   const lambdaFunction = new LambdaFunction(
-  //     functionName,
-  //     functionDefinition,
-  //     provider,
-  //     config,
-  //     options,
-  //   )
-  //   const timerStart = performance.now()
-  //   await lambdaFunction.runHandler()
-  //   const timerEnd = performance.now()
-  //
-  //   expect(lambdaFunction.executionTimeInMillis).toBeLessThanOrEqual(
-  //     timerEnd - timerStart + 10,
-  //   )
-  // })
-})

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

@@ -1,47 +0,0 @@
-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 LambdaFunctionThatReturnsJSONObject {
-  #lambdaFunction
-
-  options = {}
-
-  serverless = {
-    config: {
-      serverlessPath: '',
-      servicePath: resolve(__dirname),
-    },
-    service: {
-      provider: {
-        runtime: 'nodejs12.x',
-      },
-    },
-  }
-
-  listFunctionNames() {
-    return ['foo']
-  }
-
-  getByFunctionName(functionName) {
-    const functionDefinition = {
-      handler:
-        '../../fixtures/lambdaFunction.fixture.asyncFunctionHandlerObject',
-    }
-
-    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/LambdaFunctionThatReturnsNativeString.fixture.js

@@ -1,46 +0,0 @@
-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

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

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

@@ -1,145 +0,0 @@
-'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__/routes/invocations/InvocationsController.test.js

@@ -1,42 +0,0 @@
-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)
-    })
-  })
-})