serverless-offline 9.1.6 → 9.2.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "dedicatedTo": "Blue, a great migrating bird.",
   "name": "serverless-offline",
-  "version": "9.1.6",
+  "version": "9.2.1",
   "description": "Emulate AWS λ and API Gateway locally when developing your Serverless project",
   "license": "MIT",
   "main": "./src/index.js",
@@ -195,7 +195,7 @@
     "@hapi/h2o2": "^9.1.0",
     "@hapi/hapi": "^20.2.2",
     "@serverless/utils": "^6.7.0",
-    "aws-sdk": "^2.1187.0",
+    "aws-sdk": "^2.1194.0",
     "boxen": "^7.0.0",
     "chalk": "^5.0.1",
     "execa": "^6.1.0",
@@ -217,7 +217,7 @@
   },
   "devDependencies": {
     "archiver": "^5.3.1",
-    "eslint": "^8.21.0",
+    "eslint": "^8.22.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-import": "^2.25.4",

package/src/ServerlessOffline.js

@@ -23,38 +23,38 @@ export default class ServerlessOffline {
 
   #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.',
-          },
+  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.',
       },
-    }
+      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),
-    }
+  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),
+  }
+
+  constructor(serverless, cliOptions) {
+    this.#cliOptions = cliOptions
+    this.#serverless = serverless
   }
 
   // Entry point for the plugin (sls offline) when running 'sls offline start'
@@ -245,9 +245,9 @@ export default class ServerlessOffline {
 
     log.notice()
     log.notice(
-      `Starting Offline at stage ${provider.stage} ${chalk.gray(
-        `(${provider.region})`,
-      )}`,
+      `Starting Offline at stage ${
+        this.#options.stage || provider.stage
+      } ${chalk.gray(`(${this.#options.region || provider.region})`)}`,
     )
     log.notice()
     log.debug('options:', this.#options)

package/src/config/defaultOptions.js

@@ -17,7 +17,7 @@ export default {
   hideStackTraces: false,
   host: 'localhost',
   httpPort: 3000,
-  httpsProtocol: '',
+  httpsProtocol: null,
   lambdaPort: 3002,
   layersDir: null,
   localEnvironment: false,

package/src/events/http/HttpServer.js

@@ -49,6 +49,18 @@ export default class HttpServer {
     this.#serverless = serverless
   }
 
+  async #loadCerts(httpsProtocol) {
+    const [cert, key] = await Promise.all([
+      readFile(resolve(httpsProtocol, 'cert.pem'), 'utf-8'),
+      readFile(resolve(httpsProtocol, 'key.pem'), 'utf-8'),
+    ])
+
+    return {
+      cert,
+      key,
+    }
+  }
+
   async createServer() {
     const {
       enforceSecureCookies,
@@ -77,19 +89,10 @@ export default class HttpServer {
             isSameSite: false,
             isSecure: false,
           },
-    }
-
-    // https support
-    if (typeof httpsProtocol === 'string' && httpsProtocol.length > 0) {
-      const [cert, key] = await Promise.all([
-        readFile(resolve(httpsProtocol, 'cert.pem'), 'utf-8'),
-        readFile(resolve(httpsProtocol, 'key.pem'), 'utf-8'),
-      ])
-
-      serverOptions.tls = {
-        cert,
-        key,
-      }
+      // https support
+      ...(httpsProtocol != null && {
+        tls: await this.#loadCerts(httpsProtocol),
+      }),
     }
 
     // Hapijs server creation
@@ -1017,7 +1020,9 @@ export default class HttpServer {
       auth: authStrategyName,
       cors,
       state,
-      timeout: { socket: false },
+      timeout: {
+        socket: false,
+      },
     }
 
     // skip HEAD routes as hapi will fail with 'Method name not allowed: HEAD ...'

package/src/events/schedule/ScheduleEvent.js

@@ -1,18 +1,26 @@
 import { createUniqueId } from '../../utils/index.js'
 
 export default class ScheduleEvent {
-  constructor(region) {
-    // format of aws displaying the time, e.g.: 2020-02-09T14:13:57Z
-    const time = new Date().toISOString().replace(/\.(.*)(?=Z)/g, '')
+  account = createUniqueId()
+
+  detail = {};
+
+  ['detail-type'] = 'Scheduled Event'
+
+  id = createUniqueId()
+
+  region = null
 
-    this.account = createUniqueId()
-    this.detail = {}
-    this['detail-type'] = 'Scheduled Event'
-    this.id = createUniqueId()
+  resources = []
+
+  source = 'aws.events'
+
+  // format of aws displaying the time, e.g.: 2020-02-09T14:13:57Z
+  time = new Date().toISOString().replace(/\.(.*)(?=Z)/g, '')
+
+  version = '0'
+
+  constructor(region) {
     this.region = region
-    this.resources = []
-    this.source = 'aws.events'
-    this.time = time
-    this.version = '0'
   }
 }

package/src/events/websocket/HttpServer.js

@@ -50,8 +50,8 @@ export default class HttpServer {
     }
 
     log.notice(
-      `Offline [http for websocket] listening on http${
-        httpsProtocol ? 's' : ''
+      `Offline [http for websocket] listening on ${
+        httpsProtocol ? 'https' : 'http'
       }://${host}:${websocketPort}`,
     )
   }

package/src/events/websocket/WebSocketServer.js

@@ -58,8 +58,8 @@ export default class WebSocketServer {
     const { host, httpsProtocol, websocketPort } = this.#options
 
     log.notice(
-      `Offline [websocket] listening on ws${
-        httpsProtocol ? 's' : ''
+      `Offline [websocket] listening on ${
+        httpsProtocol ? 'wss' : 'ws'
       }://${host}:${websocketPort}`,
     )
   }

package/src/events/websocket/lambda-events/WebSocketConnectEvent.js

@@ -37,7 +37,7 @@ export default class WebSocketConnectEvent {
     //   'X-Amzn-Trace-Id': `Root=${createUniqueId()}`,
     //   'X-Forwarded-For': '127.0.0.1',
     //   'X-Forwarded-Port': String(this.#websocketPort),
-    //   'X-Forwarded-Proto': `http${this.#httpsProtocol ? 's' : ''}`,
+    //   'X-Forwarded-Proto': ${httpsProtocol ? 'https' : 'http'},
     // }
 
     const headers = parseHeaders(this.#rawHeaders)

package/src/lambda/HttpServer.js

@@ -44,13 +44,15 @@ export default class HttpServer {
     }
 
     log.notice(
-      `Offline [http for lambda] listening on http${
-        httpsProtocol ? 's' : ''
+      `Offline [http for lambda] listening on ${
+        httpsProtocol ? 'https' : 'http'
       }://${host}:${lambdaPort}`,
     )
 
     // Print all the invocation routes to debug
-    const basePath = `http${httpsProtocol ? 's' : ''}://${host}:${lambdaPort}`
+    const basePath = `${
+      httpsProtocol ? 'https' : 'http'
+    }://${host}:${lambdaPort}`
     const funcNamePairs = this.#lambda.listFunctionNamePairs()
 
     log.notice(

package/src/lambda/LambdaFunction.js

@@ -13,7 +13,7 @@ import {
   DEFAULT_LAMBDA_TIMEOUT,
   supportedRuntimes,
 } from '../config/index.js'
-import { createUniqueId, splitHandlerPathAndName } from '../utils/index.js'
+import { createUniqueId } from '../utils/index.js'
 
 const { ceil } = Math
 const { entries, fromEntries } = Object
@@ -70,7 +70,6 @@ export default class LambdaFunction {
     const servicepath = resolve(servicePath, options.location || '')
 
     const { handler, name, package: functionPackage = {} } = functionDefinition
-    const [handlerPath, handlerName] = splitHandlerPathAndName(handler)
 
     const memorySize =
       functionDefinition.memorySize ||
@@ -140,8 +139,6 @@ export default class LambdaFunction {
         ? resolve(servicepath, functionPackage.artifact)
         : undefined,
       handler,
-      handlerName,
-      handlerPath: resolve(this.#codeDir, handlerPath),
       layers: functionDefinition.layers || [],
       provider,
       runtime,

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

@@ -27,52 +27,52 @@ describe('LambdaFunction', () => {
       {
         description: 'should return result when handler is context.done',
         expected: 'foo',
-        handler: 'fixtures/lambdaFunction.fixture.contextDoneHandler',
+        handler: 'fixtures/lambdaFunction-fixture.contextDoneHandler',
       },
       {
         description:
           'should return result when handler is context.done which is deferred',
         expected: 'foo',
-        handler: 'fixtures/lambdaFunction.fixture.contextDoneHandlerDeferred',
+        handler: 'fixtures/lambdaFunction-fixture.contextDoneHandlerDeferred',
       },
       {
         description: 'should return result when handler is context.succeed',
         expected: 'foo',
-        handler: 'fixtures/lambdaFunction.fixture.contextSucceedHandler',
+        handler: 'fixtures/lambdaFunction-fixture.contextSucceedHandler',
       },
       {
         description:
           'should return result when handler is context.succeed which is deferred',
         expected: 'foo',
         handler:
-          'fixtures/lambdaFunction.fixture.contextSucceedHandlerDeferred',
+          'fixtures/lambdaFunction-fixture.contextSucceedHandlerDeferred',
       },
       {
         description: 'should return result when handler is a callback',
         expected: 'foo',
-        handler: 'fixtures/lambdaFunction.fixture.callbackHandler',
+        handler: 'fixtures/lambdaFunction-fixture.callbackHandler',
       },
       {
         description:
           'should return result when handler is a callback which is deferred',
         expected: 'foo',
-        handler: 'fixtures/lambdaFunction.fixture.callbackHandlerDeferred',
+        handler: 'fixtures/lambdaFunction-fixture.callbackHandlerDeferred',
       },
       {
         description: 'should return result when handler returns a promise',
         expected: 'foo',
-        handler: 'fixtures/lambdaFunction.fixture.promiseHandler',
+        handler: 'fixtures/lambdaFunction-fixture.promiseHandler',
       },
       {
         description:
           'should return result when handler returns a promise which is deferred',
         expected: 'foo',
-        handler: 'fixtures/lambdaFunction.fixture.promiseHandlerDeferred',
+        handler: 'fixtures/lambdaFunction-fixture.promiseHandlerDeferred',
       },
       {
         description: 'should return result when handler is an async function',
         expected: 'foo',
-        handler: 'fixtures/lambdaFunction.fixture.asyncFunctionHandler',
+        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
@@ -81,33 +81,33 @@ describe('LambdaFunction', () => {
           'should return result when handler returns a callback but defines a callback parameter',
         expected: 'Hello Promise!',
         handler:
-          'fixtures/lambdaFunction.fixture.promiseWithDefinedCallbackHandler',
+          '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',
+          'fixtures/lambdaFunction-fixture.contextSucceedWithContextDoneHandler',
       },
       {
         description:
           'should return result when handler calls callback and context.done',
         expected: 'Hello Callback!',
         handler:
-          'fixtures/lambdaFunction.fixture.callbackWithContextDoneHandler',
+          'fixtures/lambdaFunction-fixture.callbackWithContextDoneHandler',
       },
       {
         description:
           'should return result when handler calls callback and returns Promise',
         expected: 'Hello Callback!',
-        handler: 'fixtures/lambdaFunction.fixture.callbackWithPromiseHandler',
+        handler: 'fixtures/lambdaFunction-fixture.callbackWithPromiseHandler',
       },
       {
         description:
           'should return result when handler calls callback inside returned Promise',
         expected: 'Hello Callback!',
-        handler: 'fixtures/lambdaFunction.fixture.callbackInsidePromiseHandler',
+        handler: 'fixtures/lambdaFunction-fixture.callbackInsidePromiseHandler',
       },
     ].forEach(({ description, expected, handler }) => {
       it(description, async () => {
@@ -132,7 +132,7 @@ describe('LambdaFunction', () => {
 
   it('should pass remaining time to LambdaContext', async () => {
     const functionDefinition = {
-      handler: 'fixtures/lambdaFunction.fixture.remainingExecutionTimeHandler',
+      handler: 'fixtures/lambdaFunction-fixture.remainingExecutionTimeHandler',
     }
     const options = {}
     const lambdaFunction = new LambdaFunction(
@@ -152,7 +152,7 @@ describe('LambdaFunction', () => {
 
   it.skip('should use default lambda timeout when timeout is not provided', async () => {
     const functionDefinition = {
-      handler: 'fixtures/lambdaFunction.fixture.defaultTimeoutHandler',
+      handler: 'fixtures/lambdaFunction-fixture.defaultTimeoutHandler',
     }
     const options = {}
     const lambdaFunction = new LambdaFunction(
@@ -175,7 +175,7 @@ describe('LambdaFunction', () => {
   // // might run flaky (unreliable)
   // test('executionTimeInMillis should return execution time', async () => {
   //   const functionDefinition = {
-  //     handler: 'fixtures/lambdaFunction.fixture.executionTimeInMillisHandler',
+  //     handler: 'fixtures/lambdaFunction-fixture.executionTimeInMillisHandler',
   //   }
   //   const options = {}
   //   const lambdaFunction = new LambdaFunction(

package/src/lambda/__tests__/fixtures/Lambda/{LambdaFunctionThatReturnsJSONObject.fixture.js → LambdaFunctionThatReturnsJSONObject-fixture.js}

@@ -12,7 +12,7 @@ export default class LambdaFunctionThatReturnsJSONObject {
   serverless = {
     config: {
       serverlessPath: '',
-      servicePath: resolve(__dirname),
+      servicePath: resolve(__dirname, '../..'),
     },
     service: {
       provider: {
@@ -27,8 +27,7 @@ export default class LambdaFunctionThatReturnsJSONObject {
 
   getByFunctionName(functionName) {
     const functionDefinition = {
-      handler:
-        '../../fixtures/lambdaFunction.fixture.asyncFunctionHandlerObject',
+      handler: 'fixtures/lambdaFunction-fixture.asyncFunctionHandlerObject',
     }
 
     this.#lambdaFunction = new LambdaFunction(

package/src/lambda/__tests__/fixtures/Lambda/{LambdaFunctionThatReturnsNativeString.fixture.js → LambdaFunctionThatReturnsNativeString-fixture.js}

@@ -12,7 +12,7 @@ export default class LambdaFunctionThatReturnsNativeString {
   serverless = {
     config: {
       serverlessPath: '',
-      servicePath: resolve(__dirname),
+      servicePath: resolve(__dirname, '../..'),
     },
     service: {
       provider: {
@@ -27,7 +27,7 @@ export default class LambdaFunctionThatReturnsNativeString {
 
   getByFunctionName(functionName) {
     const functionDefinition = {
-      handler: '../../fixtures/lambdaFunction.fixture.asyncFunctionHandler',
+      handler: 'fixtures/lambdaFunction-fixture.asyncFunctionHandler',
     }
 
     this.#lambdaFunction = new LambdaFunction(

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

@@ -1,7 +1,7 @@
 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'
+import LambdaFunctionThatReturnsJSONObject from '../../fixtures/Lambda/LambdaFunctionThatReturnsJSONObject-fixture.js'
+import LambdaFunctionThatReturnsNativeString from '../../fixtures/Lambda/LambdaFunctionThatReturnsNativeString-fixture.js'
 
 describe('InvocationController', () => {
   const functionName = 'foo'

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

@@ -24,11 +24,9 @@ export default class HandlerRunner {
 
   async #loadRunner() {
     const { useChildProcesses, useDocker, useInProcess } = this.#options
+    const { handler, runtime } = this.#funOptions
 
-    const { functionKey, handlerName, handlerPath, runtime, timeout } =
-      this.#funOptions
-
-    log.debug(`Loading handler... (${handlerPath})`)
+    log.debug(`Loading handler... (${handler})`)
 
     if (useDocker) {
       // https://github.com/lambci/docker-lambda/issues/329
@@ -71,13 +69,7 @@ export default class HandlerRunner {
           './in-process-runner/index.js'
         )
 
-        return new InProcessRunner(
-          functionKey,
-          handlerPath,
-          handlerName,
-          this.#env,
-          timeout,
-        )
+        return new InProcessRunner(this.#funOptions, this.#env)
       }
 
       const { default: WorkerThreadRunner } = await import(

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

@@ -7,23 +7,26 @@ const __dirname = dirname(fileURLToPath(import.meta.url))
 const childProcessHelperPath = resolve(__dirname, 'childProcessHelper.js')
 
 export default class ChildProcessRunner {
+  #codeDir = null
+
   #env = null
 
   #functionKey = null
 
-  #handlerName = null
+  #handler = null
 
-  #handlerPath = null
+  #servicePath = null
 
   #timeout = null
 
   constructor(funOptions, env) {
-    const { functionKey, handlerName, handlerPath, timeout } = funOptions
+    const { codeDir, functionKey, handler, servicePath, timeout } = funOptions
 
+    this.#codeDir = codeDir
     this.#env = env
     this.#functionKey = functionKey
-    this.#handlerName = handlerName
-    this.#handlerPath = handlerPath
+    this.#handler = handler
+    this.#servicePath = servicePath
     this.#timeout = timeout
   }
 
@@ -34,7 +37,7 @@ export default class ChildProcessRunner {
   async run(event, context) {
     const childProcess = execaNode(
       childProcessHelperPath,
-      [this.#functionKey, this.#handlerName, this.#handlerPath],
+      [this.#functionKey, this.#handler, this.#servicePath, this.#codeDir],
       {
         env: this.#env,
         stdio: 'inherit',

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

@@ -21,18 +21,21 @@ process.on('uncaughtException', (err) => {
   })
 })
 
-const [, , functionKey, handlerName, handlerPath] = argv
+const [, , functionKey, handler, servicePath, codeDir] = 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,
+    {
+      codeDir,
+      functionKey,
+      handler,
+      servicePath,
+      timeout,
+    },
     process.env,
-    timeout,
   )
 
   const result = await inProcessRunner.run(event, context)

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

@@ -4,6 +4,7 @@ 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 } from 'execa'
+import { splitHandlerPathAndName } from '../../../utils/index.js'
 
 const { parse, stringify } = JSON
 
@@ -23,7 +24,8 @@ export default class GoRunner {
   #tmpPath = null
 
   constructor(funOptions, env) {
-    const { handlerPath, codeDir } = funOptions
+    const { handler, codeDir } = funOptions
+    const [handlerPath] = splitHandlerPathAndName(handler)
 
     this.#codeDir = codeDir
     this.#env = env

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

@@ -1,29 +1,32 @@
-import { createRequire } from 'node:module'
+import { join } from 'node:path'
 import { performance } from 'node:perf_hooks'
 import process from 'node:process'
-import { log } from '@serverless/utils/log.js'
+import { load } from './aws-lambda-ric/UserFunction.js'
 
 const { floor } = Math
 const { assign } = Object
 
-const require = createRequire(import.meta.url)
-
 export default class InProcessRunner {
+  #codeDir = null
+
   #env = null
 
   #functionKey = null
 
-  #handlerName = null
+  #handler = null
 
-  #handlerPath = null
+  #servicePath = null
 
   #timeout = null
 
-  constructor(functionKey, handlerPath, handlerName, env, timeout) {
+  constructor(funOptions, env) {
+    const { codeDir, functionKey, handler, servicePath, timeout } = funOptions
+
+    this.#codeDir = codeDir
     this.#env = env
     this.#functionKey = functionKey
-    this.#handlerName = handlerName
-    this.#handlerPath = handlerPath
+    this.#handler = handler
+    this.#servicePath = servicePath
     this.#timeout = timeout
   }
 
@@ -32,37 +35,16 @@ export default class InProcessRunner {
   cleanup() {}
 
   async run(event, context) {
-    // check if the handler module path exists
-    if (!require.resolve(this.#handlerPath)) {
-      throw new Error(
-        `Could not find handler module '${this.#handlerPath}' for function '${
-          this.#functionKey
-        }'.`,
-      )
-    }
-
     // process.env should be available in the handler module scope as well as in the handler function scope
     // NOTE: Don't use Object spread (...) here!
     // otherwise the values of the attached props are not coerced to a string
     // e.g. process.env.foo = 1 should be coerced to '1' (string)
     assign(process.env, this.#env)
 
-    let handler
-
-    try {
-      // eslint-disable-next-line import/no-dynamic-require
-      ;({ [this.#handlerName]: handler } = require(this.#handlerPath))
-    } catch (err) {
-      log.error(err)
-    }
-
-    if (typeof handler !== 'function') {
-      throw new Error(
-        `offline: handler '${this.#handlerName}' in ${
-          this.#handlerPath
-        } is not a function`,
-      )
-    }
+    const handler = await load(
+      this.#servicePath,
+      join(this.#codeDir, this.#handler),
+    )
 
     let callback
 

package/src/lambda/handler-runner/in-process-runner/aws-lambda-ric/UserFunction.js

@@ -0,0 +1,359 @@
+'use strict'
+
+const { pathToFileURL } = require('node:url')
+
+// node_modules/lambda-runtime/dist/node16/UserFunction.js
+;(function () {
+  const __getOwnPropNames = Object.getOwnPropertyNames
+  const __commonJS = (cb, mod) =>
+    function __require() {
+      return (
+        mod ||
+          (0, cb[__getOwnPropNames(cb)[0]])(
+            (mod = { exports: {} }).exports,
+            mod,
+          ),
+        mod.exports
+      )
+    }
+  const require_Errors = __commonJS({
+    'Errors.js': function (exports2, module2) {
+      'use strict'
+
+      const util = require('util')
+      function _isError(obj) {
+        return (
+          obj &&
+          obj.name &&
+          obj.message &&
+          obj.stack &&
+          typeof obj.name === 'string' &&
+          typeof obj.message === 'string' &&
+          typeof obj.stack === 'string'
+        )
+      }
+      function intoError(err) {
+        if (err instanceof Error) {
+          return err
+        }
+        return new Error(err)
+      }
+      module2.exports.intoError = intoError
+      function toRapidResponse(error) {
+        try {
+          if (util.types.isNativeError(error) || _isError(error)) {
+            return {
+              errorType: error.name,
+              errorMessage: error.message,
+              trace: error.stack.split('\n'),
+            }
+          }
+          return {
+            errorType: typeof error,
+            errorMessage: error.toString(),
+            trace: [],
+          }
+        } catch (_err) {
+          return {
+            errorType: 'handled',
+            errorMessage:
+              'callback called with Error argument, but there was a problem while retrieving one or more of its message, name, and stack',
+          }
+        }
+      }
+      module2.exports.toRapidResponse = toRapidResponse
+      module2.exports.toFormatted = (error) => {
+        try {
+          return `      ${JSON.stringify(error, (_k, v) =>
+            _withEnumerableProperties(v),
+          )}`
+        } catch (err) {
+          return `      ${JSON.stringify(toRapidResponse(error))}`
+        }
+      }
+      function _withEnumerableProperties(error) {
+        if (error instanceof Error) {
+          const ret = {
+            errorType: error.name,
+            errorMessage: error.message,
+            code: error.code,
+            ...error,
+          }
+          if (typeof error.stack === 'string') {
+            ret.stack = error.stack.split('\n')
+          }
+          return ret
+        }
+        return error
+      }
+      const errorClasses = [
+        class ImportModuleError extends Error {},
+        class HandlerNotFound extends Error {},
+        class MalformedHandlerName extends Error {},
+        class UserCodeSyntaxError extends Error {},
+        class MalformedStreamingHandler extends Error {},
+        class InvalidStreamingOperation extends Error {},
+        class UnhandledPromiseRejection extends Error {
+          constructor(reason, promise) {
+            super(reason)
+            this.reason = reason
+            this.promise = promise
+          }
+        },
+      ]
+      errorClasses.forEach((e) => {
+        module2.exports[e.name] = e
+        e.prototype.name = `Runtime.${e.name}`
+      })
+    },
+  })
+  const require_VerboseLog = __commonJS({
+    'VerboseLog.js': function (exports2) {
+      'use strict'
+
+      const EnvVarName = 'AWS_LAMBDA_RUNTIME_VERBOSE'
+      const Tag = 'RUNTIME'
+      const Verbosity = (() => {
+        if (!process.env[EnvVarName]) {
+          return 0
+        }
+        try {
+          const verbosity = parseInt(process.env[EnvVarName])
+          return verbosity < 0 ? 0 : verbosity > 3 ? 3 : verbosity
+        } catch (_) {
+          return 0
+        }
+      })()
+      exports2.logger = function (category) {
+        return {
+          verbose() {
+            if (Verbosity >= 1) {
+              console.log.apply(null, [Tag, category, ...arguments])
+            }
+          },
+          vverbose() {
+            if (Verbosity >= 2) {
+              console.log.apply(null, [Tag, category, ...arguments])
+            }
+          },
+          vvverbose() {
+            if (Verbosity >= 3) {
+              console.log.apply(null, [Tag, category, ...arguments])
+            }
+          },
+        }
+      }
+    },
+  })
+  const require_HttpResponseStream = __commonJS({
+    'HttpResponseStream.js': function (exports2, module2) {
+      'use strict'
+
+      const METADATA_PRELUDE_CONTENT_TYPE =
+        'application/vnd.awslambda.http-integration-response'
+      const DELIMITER_LEN = 8
+      const HttpResponseStream2 = class {
+        static from(underlyingStream, prelude) {
+          underlyingStream.setContentType(METADATA_PRELUDE_CONTENT_TYPE)
+          const metadataPrelude = JSON.stringify(prelude)
+          underlyingStream._onBeforeFirstWrite = (write) => {
+            write(metadataPrelude)
+            write(new Uint8Array(DELIMITER_LEN))
+          }
+          return underlyingStream
+        }
+      }
+      module2.exports.HttpResponseStream = HttpResponseStream2
+    },
+  })
+  const path = require('path')
+  const fs = require('fs')
+  const {
+    HandlerNotFound,
+    MalformedHandlerName,
+    ImportModuleError,
+    UserCodeSyntaxError,
+  } = require_Errors()
+  const { verbose } = require_VerboseLog().logger('LOADER')
+  const { HttpResponseStream } = require_HttpResponseStream()
+  const FUNCTION_EXPR = /^([^.]*)\.(.*)$/
+  const RELATIVE_PATH_SUBSTRING = '..'
+  const HANDLER_STREAMING = Symbol.for('aws.lambda.runtime.handler.streaming')
+  const STREAM_RESPONSE = 'response'
+  const NoGlobalAwsLambda =
+    process.env.AWS_LAMBDA_NODEJS_NO_GLOBAL_AWSLAMBDA === '1' ||
+    process.env.AWS_LAMBDA_NODEJS_NO_GLOBAL_AWSLAMBDA === 'true'
+  function _moduleRootAndHandler(fullHandlerString) {
+    const handlerString = path.basename(fullHandlerString)
+    const moduleRoot = fullHandlerString.substring(
+      0,
+      fullHandlerString.indexOf(handlerString),
+    )
+    return [moduleRoot, handlerString]
+  }
+  function _splitHandlerString(handler) {
+    const match = handler.match(FUNCTION_EXPR)
+    if (!match || match.length != 3) {
+      throw new MalformedHandlerName('Bad handler')
+    }
+    return [match[1], match[2]]
+  }
+  function _resolveHandler(object, nestedProperty) {
+    return nestedProperty.split('.').reduce((nested, key) => {
+      return nested && nested[key]
+    }, object)
+  }
+  function _tryRequireFile(file, extension) {
+    const path2 = file + (extension || '')
+    verbose('Try loading as commonjs:', path2)
+    return fs.existsSync(path2) ? require(path2) : void 0
+  }
+  async function _tryAwaitImport(file, extension) {
+    const path2 = file + (extension || '')
+    verbose('Try loading as esmodule:', path2)
+    if (fs.existsSync(path2)) {
+      return await import(pathToFileURL(path2).href)
+    }
+    return void 0
+  }
+  function _hasFolderPackageJsonTypeModule(folder) {
+    if (folder.endsWith('/node_modules')) {
+      return false
+    }
+    const pj = path.join(folder, '/package.json')
+    if (fs.existsSync(pj)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pj))
+        if (pkg) {
+          if (pkg.type === 'module') {
+            verbose(`'type: module' detected in ${pj}`)
+            return true
+          }
+          verbose(`'type: module' not detected in ${pj}`)
+          return false
+        }
+      } catch (e) {
+        console.warn(
+          `${pj} cannot be read, it will be ignored for ES module detection purposes.`,
+          e,
+        )
+        return false
+      }
+    }
+    if (folder === '/') {
+      return false
+    }
+    return _hasFolderPackageJsonTypeModule(path.resolve(folder, '..'))
+  }
+  function _hasPackageJsonTypeModule(file) {
+    const jsPath = `${file}.js`
+    return fs.existsSync(jsPath)
+      ? _hasFolderPackageJsonTypeModule(path.resolve(path.dirname(jsPath)))
+      : false
+  }
+  async function _tryRequire(appRoot, moduleRoot, module2) {
+    verbose(
+      'Try loading as commonjs: ',
+      module2,
+      ' with paths: ,',
+      appRoot,
+      moduleRoot,
+    )
+    const lambdaStylePath = path.resolve(appRoot, moduleRoot, module2)
+    const extensionless = _tryRequireFile(lambdaStylePath)
+    if (extensionless) {
+      return extensionless
+    }
+    const pjHasModule = _hasPackageJsonTypeModule(lambdaStylePath)
+    if (!pjHasModule) {
+      const loaded2 = _tryRequireFile(lambdaStylePath, '.js')
+      if (loaded2) {
+        return loaded2
+      }
+    }
+    const loaded =
+      (pjHasModule && (await _tryAwaitImport(lambdaStylePath, '.js'))) ||
+      (await _tryAwaitImport(lambdaStylePath, '.mjs')) ||
+      _tryRequireFile(lambdaStylePath, '.cjs')
+    if (loaded) {
+      return loaded
+    }
+    verbose(
+      'Try loading as commonjs: ',
+      module2,
+      ' with path(s): ',
+      appRoot,
+      moduleRoot,
+    )
+    const nodeStylePath = require.resolve(module2, {
+      paths: [appRoot, moduleRoot],
+    })
+    return require(nodeStylePath)
+  }
+  async function _loadUserApp(appRoot, moduleRoot, module2) {
+    if (!NoGlobalAwsLambda) {
+      globalThis.awslambda = {
+        streamifyResponse: (handler) => {
+          handler[HANDLER_STREAMING] = STREAM_RESPONSE
+          return handler
+        },
+        HttpResponseStream,
+      }
+    }
+    try {
+      return await _tryRequire(appRoot, moduleRoot, module2)
+    } catch (e) {
+      if (e instanceof SyntaxError) {
+        throw new UserCodeSyntaxError(e)
+      } else if (e.code !== void 0 && e.code === 'MODULE_NOT_FOUND') {
+        verbose('globalPaths', JSON.stringify(require('module').globalPaths))
+        throw new ImportModuleError(e)
+      } else {
+        throw e
+      }
+    }
+  }
+  function _throwIfInvalidHandler(fullHandlerString) {
+    if (fullHandlerString.includes(RELATIVE_PATH_SUBSTRING)) {
+      throw new MalformedHandlerName(
+        `'${fullHandlerString}' is not a valid handler name. Use absolute paths when specifying root directories in handler names.`,
+      )
+    }
+  }
+  function _isHandlerStreaming(handler) {
+    if (
+      typeof handler[HANDLER_STREAMING] === 'undefined' ||
+      handler[HANDLER_STREAMING] === null ||
+      handler[HANDLER_STREAMING] === false
+    ) {
+      return false
+    }
+    if (handler[HANDLER_STREAMING] === STREAM_RESPONSE) {
+      return STREAM_RESPONSE
+    }
+    throw new MalformedStreamingHandler('Only response streaming is supported.')
+  }
+  module.exports.load = async function (appRoot, fullHandlerString) {
+    _throwIfInvalidHandler(fullHandlerString)
+    const [moduleRoot, moduleAndHandler] =
+      _moduleRootAndHandler(fullHandlerString)
+    const [module2, handlerPath] = _splitHandlerString(moduleAndHandler)
+    const userApp = await _loadUserApp(appRoot, moduleRoot, module2)
+    const handlerFunc = _resolveHandler(userApp, handlerPath)
+    if (!handlerFunc) {
+      throw new HandlerNotFound(
+        `${fullHandlerString} is undefined or not exported`,
+      )
+    }
+    if (typeof handlerFunc !== 'function') {
+      throw new HandlerNotFound(`${fullHandlerString} is not a function`)
+    }
+    return handlerFunc
+  }
+  module.exports.getHandlerMetadata = function (handlerFunc) {
+    return {
+      streaming: _isHandlerStreaming(handlerFunc),
+    }
+  }
+  module.exports.STREAM_RESPONSE = STREAM_RESPONSE
+})()

package/src/lambda/handler-runner/in-process-runner/aws-lambda-ric/package.json

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

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