refactor: use worker threads by default, remove flag, introduce in-pr…

…ocess flag

src/config/commandOptions.js

@@ -134,9 +134,10 @@ export default {
     type: 'boolean',
     usage: 'Uses docker for node/python/ruby/provided',
   },
-  useWorkerThreads: {
+  useInProcess: {
     type: 'boolean',
-    usage: "Use 'worker threads' to run handlers.",
+    usage:
+      "Run handlers in the same process as 'serverless-offline'. NOTE: This can cause memory leaks and is not recommended. This option will likely be removed in future versions.",
   },
   webSocketHardTimeout: {
     type: 'string',

src/config/defaultOptions.js

@@ -30,7 +30,7 @@ export default {
   resourceRoutes: false,
   useChildProcesses: false,
   useDocker: false,
-  useWorkerThreads: false,
+  useInProcess: false,
   webSocketHardTimeout: 7200,
   webSocketIdleTimeout: 600,
   websocketPort: 3001,

src/lambda/handler-runner/HandlerRunner.js

@@ -23,7 +23,7 @@ export default class HandlerRunner {
   }
 
   async #loadRunner() {
-    const { useDocker, useChildProcesses, useWorkerThreads, allowCache } =
+    const { allowCache, useChildProcesses, useDocker, useInProcess } =
       this.#options
 
     const { functionKey, handlerName, handlerPath, runtime, timeout } =
@@ -67,26 +67,26 @@ export default class HandlerRunner {
         return new ChildProcessRunner(this.#funOptions, this.#env, allowCache)
       }
 
-      if (useWorkerThreads) {
-        const { default: WorkerThreadRunner } = await import(
-          './worker-thread-runner/index.js'
+      if (useInProcess) {
+        const { default: InProcessRunner } = await import(
+          './in-process-runner/index.js'
         )
 
-        return new WorkerThreadRunner(this.#funOptions, this.#env, allowCache)
+        return new InProcessRunner(
+          functionKey,
+          handlerPath,
+          handlerName,
+          this.#env,
+          timeout,
+          allowCache,
+        )
       }
 
-      const { default: InProcessRunner } = await import(
-        './in-process-runner/index.js'
+      const { default: WorkerThreadRunner } = await import(
+        './worker-thread-runner/index.js'
       )
 
-      return new InProcessRunner(
-        functionKey,
-        handlerPath,
-        handlerName,
-        this.#env,
-        timeout,
-        allowCache,
-      )
+      return new WorkerThreadRunner(this.#funOptions, this.#env, allowCache)
     }
 
     if (supportedGo.has(runtime)) {

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

@@ -41,7 +41,7 @@ export default class InProcessRunner {
     if (this.#memoryLeakWarning) {
       log.warning()
       log.warning(
-        `Running 'serverless-offline' and the handlers side-by-side in the same process with reloading enabled will cause memory leaks!`,
+        `Running the handlers in-process with 'serverless-offline' with reloading enabled is not recommended as it causes memory leaks!`,
       )
       log.warning()
       this.#memoryLeakWarning = false

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

@@ -40,7 +40,14 @@ export default class WorkerThreadRunner {
       const { port1, port2 } = new MessageChannel()
 
       port1
-        .on('message', res)
+        .on('message', (value) => {
+          if (value instanceof Error) {
+            rej(value)
+            return
+          }
+
+          res(value)
+        })
         // emitted if the worker thread throws an uncaught exception.
         // In that case, the worker will be terminated.
         .on('error', rej)

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

@@ -17,7 +17,13 @@ parentPort.on('message', async (messageData) => {
     allowCache,
   )
 
-  const result = await inProcessRunner.run(event, context)
+  let result
+
+  try {
+    result = await inProcessRunner.run(event, context)
+  } catch (err) {
+    port.postMessage(err)
+  }
 
   // TODO check serializeability (contains function, symbol etc)
   port.postMessage(result)