serverless-offline 9.1.7 → 9.2.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "dedicatedTo": "Blue, a great migrating bird.",
   "name": "serverless-offline",
-  "version": "9.1.7",
+  "version": "9.2.0",
   "description": "Emulate AWS λ and API Gateway locally when developing your Serverless project",
   "license": "MIT",
   "main": "./src/index.js",

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

@@ -25,10 +25,10 @@ export default class HandlerRunner {
   async #loadRunner() {
     const { useChildProcesses, useDocker, useInProcess } = this.#options
 
-    const { functionKey, handlerName, handlerPath, runtime, timeout } =
+    const { codeDir, functionKey, handler, runtime, servicePath, timeout } =
       this.#funOptions
 
-    log.debug(`Loading handler... (${handlerPath})`)
+    log.debug(`Loading handler... (${handler})`)
 
     if (useDocker) {
       // https://github.com/lambci/docker-lambda/issues/329
@@ -72,11 +72,14 @@ export default class HandlerRunner {
         )
 
         return new InProcessRunner(
-          functionKey,
-          handlerPath,
-          handlerName,
+          {
+            codeDir,
+            functionKey,
+            handler,
+            servicePath,
+            timeout,
+          },
           this.#env,
-          timeout,
         )
       }
 

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,13 @@ export default class PythonRunner {
 
   #env = null
 
-  #handlerName = null
-
-  #handlerPath = 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) {
@@ -47,8 +43,8 @@ export default class PythonRunner {
       [
         '-u',
         resolve(__dirname, 'invoke.py'),
-        relative(cwd(), this.#handlerPath),
-        this.#handlerName,
+        relative(cwd(), handlerPath),
+        handlerName,
       ],
       {
         env: assign(process.env, this.#env),
@@ -56,7 +52,7 @@ export default class PythonRunner {
       },
     )
 
-    this.handlerProcess.stdout.readline = readline.createInterface({
+    this.handlerProcess.stdout.readline = createInterface({
       input: this.handlerProcess.stdout,
     })
   }

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