@sentio/runtime 2.57.12-rc.c → 2.57.12-rc.d

package/lib/service-worker.d.ts

@@ -1,2 +1,7 @@
+import { DataBinding, ProcessResult } from '@sentio/protos';
 
-export {  }
+declare function export_default({ request }: {
+    request: DataBinding;
+}): Promise<ProcessResult>;
+
+export { export_default as default };

package/lib/service-worker.js

@@ -1,24 +1,23 @@
 import { createRequire as createRequireShim } from 'module'; const require = createRequireShim(import.meta.url);
 import {
-  command_line_args_default,
-  optionDefinitions
-} from "./chunk-ANRIDUBX.js";
-import {
-  PluginManager,
-  ProcessConfigResponse,
-  __toESM,
   errorString,
   freezeGlobalConfig,
+  recordRuntimeInfo,
   require_lib2 as require_lib,
   require_lib3 as require_lib2
-} from "./chunk-HBDDXJ53.js";
+} from "./chunk-CPC37CZL.js";
+import {
+  PluginManager,
+  ProcessConfigResponse,
+  __toESM
+} from "./chunk-6YBY6GSE.js";
 
 // src/service-worker.ts
 var import_nice_grpc = __toESM(require_lib(), 1);
 var import_nice_grpc_error_details = __toESM(require_lib2(), 1);
 import { BroadcastChannel } from "worker_threads";
+import { Piscina } from "piscina";
 var started = false;
-var options = command_line_args_default(optionDefinitions, { partial: true });
 var unhandled;
 process.on("uncaughtException", (err) => {
   console.error("Uncaught Exception, please checking if await is properly used", err);
@@ -38,32 +37,64 @@ async function getConfig(request, context) {
   await PluginManager.INSTANCE.configure(newConfig);
   return newConfig;
 }
-var loader = async () => {
-  const m = await import(options.target);
-  console.debug("Module loaded", m);
-  return m;
+var loader = async (options) => {
+  if (options.target) {
+    const m = await import(options.target);
+    console.debug("Module loaded", m);
+    return m;
+  }
 };
 var configureChannel = new BroadcastChannel("configure_channel");
 configureChannel.onmessage = (request) => {
   getConfig(request);
 };
-async function start(request) {
+async function start(request, options) {
   if (started) {
     return {};
   }
   freezeGlobalConfig();
   try {
-    await loader();
+    await loader(options);
   } catch (e) {
     throw new import_nice_grpc.ServerError(import_nice_grpc.Status.INVALID_ARGUMENT, "Failed to load processor: " + errorString(e));
   }
   await PluginManager.INSTANCE.start(request);
-  started = true;
   return {};
 }
-var startChannel = new BroadcastChannel("start_channel");
-startChannel.onmessage = (request) => {
-  start(request);
-};
+async function service_worker_default({ request }) {
+  if (!started) {
+    const { startRequest, configRequest, options } = Piscina.workerData;
+    if (startRequest) {
+      await start(startRequest, options);
+    }
+    if (configRequest) {
+      await getConfig(configRequest);
+    }
+    started = true;
+    console.info("new processor worker started");
+  }
+  if (unhandled) {
+    throw new import_nice_grpc_error_details.RichServerError(
+      import_nice_grpc.Status.UNAVAILABLE,
+      "Unhandled exception/rejection in previous request: " + errorString(unhandled),
+      [
+        import_nice_grpc_error_details.DebugInfo.fromPartial({
+          detail: unhandled.message,
+          stackEntries: unhandled.stack?.split("\n")
+        })
+      ]
+    );
+  }
+  const result = await PluginManager.INSTANCE.processBinding(
+    request,
+    void 0
+    // PluginManager.INSTANCE.dbContextLocalStorage.getStore()
+  );
+  recordRuntimeInfo(result, request.handlerType);
+  return result;
+}
 import("node:process").then((p) => p.stdout.write(""));
+export {
+  service_worker_default as default
+};
 //# sourceMappingURL=service-worker.js.map

package/lib/service-worker.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/service-worker.ts"],"sourcesContent":["import {\n  DataBinding,\n  Empty,\n  HandlerType,\n  PreparedData,\n  ProcessConfigRequest,\n  ProcessConfigResponse,\n  ProcessResult,\n  StartRequest\n} from '@sentio/protos'\nimport { CallContext, ServerError, Status } from 'nice-grpc'\nimport { PluginManager } from './plugin.js'\nimport commandLineArgs from 'command-line-args'\nimport { optionDefinitions } from './processor-runner.js'\nimport { errorString } from './utils.js'\nimport { freezeGlobalConfig } from './global-config.js'\nimport { DebugInfo, RichServerError } from 'nice-grpc-error-details'\nimport { recordRuntimeInfo } from './service.js'\nimport { BroadcastChannel } from 'worker_threads'\n\nlet started = false\nconst options = commandLineArgs(optionDefinitions, { partial: true })\n\nlet unhandled: Error | undefined\n\nprocess\n  .on('uncaughtException', (err) => {\n    console.error('Uncaught Exception, please checking if await is properly used', err)\n    unhandled = err\n  })\n  .on('unhandledRejection', (reason, p) => {\n    // @ts-ignore ignore invalid ens error\n    if (reason?.message.startsWith('invalid ENS name (disallowed character: \"*\"')) {\n      return\n    }\n    console.error('Unhandled Rejection, please checking if await is properly', reason)\n    unhandled = reason as Error\n    // shutdownServers(1)\n  })\n\nasync function getConfig(request: ProcessConfigRequest, context?: CallContext): Promise<ProcessConfigResponse> {\n  if (!started) {\n    throw new ServerError(Status.UNAVAILABLE, 'Service Not started.')\n  }\n\n  const newConfig = ProcessConfigResponse.fromPartial({})\n  await PluginManager.INSTANCE.configure(newConfig)\n  return newConfig\n}\n\nconst loader = async () => {\n  const m = await import(options.target)\n  console.debug('Module loaded', m)\n  return m\n}\n\nconst configureChannel = new BroadcastChannel('configure_channel')\nconfigureChannel.onmessage = (request: ProcessConfigRequest) => {\n  getConfig(request)\n}\n\nasync function start(request: StartRequest): Promise<Empty> {\n  if (started) {\n    return {}\n  }\n  freezeGlobalConfig()\n\n  try {\n    await loader()\n  } catch (e) {\n    throw new ServerError(Status.INVALID_ARGUMENT, 'Failed to load processor: ' + errorString(e))\n  }\n\n  await PluginManager.INSTANCE.start(request)\n  started = true\n  return {}\n}\n\nconst startChannel = new BroadcastChannel('start_channel')\nstartChannel.onmessage = (request: StartRequest) => {\n  start(request)\n}\n\nasync function stop(request: Empty, context: CallContext): Promise<Empty> {\n  return {}\n}\n\nasync function processBinding(\n  request: DataBinding,\n  preparedData: PreparedData | undefined,\n  options?: CallContext\n): Promise<ProcessResult> {\n  if (!started) {\n    throw new ServerError(Status.UNAVAILABLE, 'Service Not started.')\n  }\n  if (unhandled) {\n    throw new RichServerError(\n      Status.UNAVAILABLE,\n      'Unhandled exception/rejection in previous request: ' + errorString(unhandled),\n      [\n        DebugInfo.fromPartial({\n          detail: unhandled.message,\n          stackEntries: unhandled.stack?.split('\\n')\n        })\n      ]\n    )\n  }\n\n  const result = await PluginManager.INSTANCE.processBinding(\n    request,\n    preparedData\n    // PluginManager.INSTANCE.dbContextLocalStorage.getStore()\n  )\n  recordRuntimeInfo(result, request.handlerType)\n  return result\n}\n;import(\"node:process\").then((p) => p.stdout.write(\"\"));"],"mappings":";;;;;;;;;;;;;;;;AAUA,uBAAiD;AAMjD,qCAA2C;AAE3C,SAAS,wBAAwB;AAEjC,IAAI,UAAU;AACd,IAAM,UAAU,0BAAgB,mBAAmB,EAAE,SAAS,KAAK,CAAC;AAEpE,IAAI;AAEJ,QACG,GAAG,qBAAqB,CAAC,QAAQ;AAChC,UAAQ,MAAM,iEAAiE,GAAG;AAClF,cAAY;AACd,CAAC,EACA,GAAG,sBAAsB,CAAC,QAAQ,MAAM;AAEvC,MAAI,QAAQ,QAAQ,WAAW,6CAA6C,GAAG;AAC7E;AAAA,EACF;AACA,UAAQ,MAAM,6DAA6D,MAAM;AACjF,cAAY;AAEd,CAAC;AAEH,eAAe,UAAU,SAA+B,SAAuD;AAC7G,MAAI,CAAC,SAAS;AACZ,UAAM,IAAI,6BAAY,wBAAO,aAAa,sBAAsB;AAAA,EAClE;AAEA,QAAM,YAAY,sBAAsB,YAAY,CAAC,CAAC;AACtD,QAAM,cAAc,SAAS,UAAU,SAAS;AAChD,SAAO;AACT;AAEA,IAAM,SAAS,YAAY;AACzB,QAAM,IAAI,MAAM,OAAO,QAAQ;AAC/B,UAAQ,MAAM,iBAAiB,CAAC;AAChC,SAAO;AACT;AAEA,IAAM,mBAAmB,IAAI,iBAAiB,mBAAmB;AACjE,iBAAiB,YAAY,CAAC,YAAkC;AAC9D,YAAU,OAAO;AACnB;AAEA,eAAe,MAAM,SAAuC;AAC1D,MAAI,SAAS;AACX,WAAO,CAAC;AAAA,EACV;AACA,qBAAmB;AAEnB,MAAI;AACF,UAAM,OAAO;AAAA,EACf,SAAS,GAAG;AACV,UAAM,IAAI,6BAAY,wBAAO,kBAAkB,+BAA+B,YAAY,CAAC,CAAC;AAAA,EAC9F;AAEA,QAAM,cAAc,SAAS,MAAM,OAAO;AAC1C,YAAU;AACV,SAAO,CAAC;AACV;AAEA,IAAM,eAAe,IAAI,iBAAiB,eAAe;AACzD,aAAa,YAAY,CAAC,YAA0B;AAClD,QAAM,OAAO;AACf;AAmCC,OAAO,cAAc,EAAE,KAAK,CAAC,MAAM,EAAE,OAAO,MAAM,EAAE,CAAC;","names":[]}
+{"version":3,"sources":["../src/service-worker.ts"],"sourcesContent":["import {\n  DataBinding,\n  Empty,\n  HandlerType,\n  PreparedData,\n  ProcessConfigRequest,\n  ProcessConfigResponse,\n  ProcessResult,\n  StartRequest\n} from '@sentio/protos'\nimport { CallContext, ServerError, Status } from 'nice-grpc'\nimport { PluginManager } from './plugin.js'\nimport commandLineArgs from 'command-line-args'\nimport { optionDefinitions } from './processor-runner.js'\nimport { errorString } from './utils.js'\nimport { freezeGlobalConfig } from './global-config.js'\nimport { DebugInfo, RichServerError } from 'nice-grpc-error-details'\nimport { recordRuntimeInfo } from './service.js'\nimport { BroadcastChannel } from 'worker_threads'\nimport { Piscina } from 'piscina'\n\nlet started = false\n\nlet unhandled: Error | undefined\n\nprocess\n  .on('uncaughtException', (err) => {\n    console.error('Uncaught Exception, please checking if await is properly used', err)\n    unhandled = err\n  })\n  .on('unhandledRejection', (reason, p) => {\n    // @ts-ignore ignore invalid ens error\n    if (reason?.message.startsWith('invalid ENS name (disallowed character: \"*\"')) {\n      return\n    }\n    console.error('Unhandled Rejection, please checking if await is properly', reason)\n    unhandled = reason as Error\n    // shutdownServers(1)\n  })\n\nasync function getConfig(request: ProcessConfigRequest, context?: CallContext): Promise<ProcessConfigResponse> {\n  if (!started) {\n    throw new ServerError(Status.UNAVAILABLE, 'Service Not started.')\n  }\n\n  const newConfig = ProcessConfigResponse.fromPartial({})\n  await PluginManager.INSTANCE.configure(newConfig)\n  return newConfig\n}\n\nconst loader = async (options: any) => {\n  if (options.target) {\n    const m = await import(options.target)\n    console.debug('Module loaded', m)\n    return m\n  }\n}\n\nconst configureChannel = new BroadcastChannel('configure_channel')\nconfigureChannel.onmessage = (request: ProcessConfigRequest) => {\n  getConfig(request)\n}\n\nasync function start(request: StartRequest, options: any): Promise<Empty> {\n  if (started) {\n    return {}\n  }\n  freezeGlobalConfig()\n\n  try {\n    await loader(options)\n  } catch (e) {\n    throw new ServerError(Status.INVALID_ARGUMENT, 'Failed to load processor: ' + errorString(e))\n  }\n\n  await PluginManager.INSTANCE.start(request)\n  return {}\n}\n\nexport default async function ({ request }: { request: DataBinding }) {\n  if (!started) {\n    const { startRequest, configRequest, options } = Piscina.workerData\n    if (startRequest) {\n      await start(startRequest, options)\n    }\n    if (configRequest) {\n      await getConfig(configRequest)\n    }\n    started = true\n    console.info('new processor worker started')\n  }\n\n  if (unhandled) {\n    throw new RichServerError(\n      Status.UNAVAILABLE,\n      'Unhandled exception/rejection in previous request: ' + errorString(unhandled),\n      [\n        DebugInfo.fromPartial({\n          detail: unhandled.message,\n          stackEntries: unhandled.stack?.split('\\n')\n        })\n      ]\n    )\n  }\n\n  const result = await PluginManager.INSTANCE.processBinding(\n    request,\n    undefined\n    // PluginManager.INSTANCE.dbContextLocalStorage.getStore()\n  )\n  recordRuntimeInfo(result, request.handlerType)\n  return result\n}\n;import(\"node:process\").then((p) => p.stdout.write(\"\"));"],"mappings":";;;;;;;;;;;;;;;AAUA,uBAAiD;AAMjD,qCAA2C;AAE3C,SAAS,wBAAwB;AACjC,SAAS,eAAe;AAExB,IAAI,UAAU;AAEd,IAAI;AAEJ,QACG,GAAG,qBAAqB,CAAC,QAAQ;AAChC,UAAQ,MAAM,iEAAiE,GAAG;AAClF,cAAY;AACd,CAAC,EACA,GAAG,sBAAsB,CAAC,QAAQ,MAAM;AAEvC,MAAI,QAAQ,QAAQ,WAAW,6CAA6C,GAAG;AAC7E;AAAA,EACF;AACA,UAAQ,MAAM,6DAA6D,MAAM;AACjF,cAAY;AAEd,CAAC;AAEH,eAAe,UAAU,SAA+B,SAAuD;AAC7G,MAAI,CAAC,SAAS;AACZ,UAAM,IAAI,6BAAY,wBAAO,aAAa,sBAAsB;AAAA,EAClE;AAEA,QAAM,YAAY,sBAAsB,YAAY,CAAC,CAAC;AACtD,QAAM,cAAc,SAAS,UAAU,SAAS;AAChD,SAAO;AACT;AAEA,IAAM,SAAS,OAAO,YAAiB;AACrC,MAAI,QAAQ,QAAQ;AAClB,UAAM,IAAI,MAAM,OAAO,QAAQ;AAC/B,YAAQ,MAAM,iBAAiB,CAAC;AAChC,WAAO;AAAA,EACT;AACF;AAEA,IAAM,mBAAmB,IAAI,iBAAiB,mBAAmB;AACjE,iBAAiB,YAAY,CAAC,YAAkC;AAC9D,YAAU,OAAO;AACnB;AAEA,eAAe,MAAM,SAAuB,SAA8B;AACxE,MAAI,SAAS;AACX,WAAO,CAAC;AAAA,EACV;AACA,qBAAmB;AAEnB,MAAI;AACF,UAAM,OAAO,OAAO;AAAA,EACtB,SAAS,GAAG;AACV,UAAM,IAAI,6BAAY,wBAAO,kBAAkB,+BAA+B,YAAY,CAAC,CAAC;AAAA,EAC9F;AAEA,QAAM,cAAc,SAAS,MAAM,OAAO;AAC1C,SAAO,CAAC;AACV;AAEA,eAAO,uBAAwB,EAAE,QAAQ,GAA6B;AACpE,MAAI,CAAC,SAAS;AACZ,UAAM,EAAE,cAAc,eAAe,QAAQ,IAAI,QAAQ;AACzD,QAAI,cAAc;AAChB,YAAM,MAAM,cAAc,OAAO;AAAA,IACnC;AACA,QAAI,eAAe;AACjB,YAAM,UAAU,aAAa;AAAA,IAC/B;AACA,cAAU;AACV,YAAQ,KAAK,8BAA8B;AAAA,EAC7C;AAEA,MAAI,WAAW;AACb,UAAM,IAAI;AAAA,MACR,wBAAO;AAAA,MACP,wDAAwD,YAAY,SAAS;AAAA,MAC7E;AAAA,QACE,yCAAU,YAAY;AAAA,UACpB,QAAQ,UAAU;AAAA,UAClB,cAAc,UAAU,OAAO,MAAM,IAAI;AAAA,QAC3C,CAAC;AAAA,MACH;AAAA,IACF;AAAA,EACF;AAEA,QAAM,SAAS,MAAM,cAAc,SAAS;AAAA,IAC1C;AAAA,IACA;AAAA;AAAA,EAEF;AACA,oBAAkB,QAAQ,QAAQ,WAAW;AAC7C,SAAO;AACT;AACC,OAAO,cAAc,EAAE,KAAK,CAAC,MAAM,EAAE,OAAO,MAAM,EAAE,CAAC;","names":[]}

package/lib/test-processor.test.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/lib/test-processor.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/test-processor.test.ts"],"sourcesContent":["import { Plugin, PluginManager } from './plugin.js'\nimport { DataBinding, HandlerType, ProcessResult } from './gen/processor/protos/processor.js'\n\nclass TestPlugin extends Plugin {\n  async processBinding(request: DataBinding): Promise<ProcessResult> {\n    return ProcessResult.fromPartial({\n      states: {\n        configUpdated: true\n      }\n    })\n  }\n  supportedHandlers = [HandlerType.UNKNOWN, HandlerType.APT_EVENT]\n}\n\nPluginManager.INSTANCE.plugins = []\nPluginManager.INSTANCE.register(new TestPlugin())\n;import(\"node:process\").then((p) => p.stdout.write(\"\"));"],"mappings":";;;;;;;;AAGA,IAAM,aAAN,cAAyB,OAAO;AAAA,EAC9B,MAAM,eAAe,SAA8C;AACjE,WAAO,cAAc,YAAY;AAAA,MAC/B,QAAQ;AAAA,QACN,eAAe;AAAA,MACjB;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EACA,oBAAoB,mCAA2C;AACjE;AAEA,cAAc,SAAS,UAAU,CAAC;AAClC,cAAc,SAAS,SAAS,IAAI,WAAW,CAAC;AAC/C,OAAO,cAAc,EAAE,KAAK,CAAC,MAAM,EAAE,OAAO,MAAM,EAAE,CAAC;","names":[]}

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "@sentio/runtime",
-  "version": "2.57.12-rc.c",
+  "version": "2.57.12-rc.d",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
-    ".": "./lib/index.js",
-    "./service-worker": "./lib/service-worker.js"
+    ".": "./lib/index.js"
   },
   "bin": {
     "processor-runner": "./lib/processor-runner.js"

package/src/service-manager.ts

@@ -42,20 +42,13 @@ export class ServiceManager implements ProcessorServiceImplementation {
   // When there is unhandled error, stop process and return unavailable error
   unhandled: Error
   // private processorConfig: ProcessConfigResponse
-  private readonly pool: Piscina<any, any>
+  private pool: Piscina<any, any>
 
   constructor(
     readonly options: any,
     readonly loader: () => Promise<any>,
     readonly shutdownHandler?: () => void
-  ) {
-    this.pool = new Piscina({
-      maxThreads: options.worker,
-      minThreads: options.worker,
-      filename: new URL('./service-worker.js', import.meta.url).href,
-      argv: process.argv
-    })
-  }
+  ) {}
 
   async *preprocessBindingsStream(requests: AsyncIterable<PreprocessStreamRequest>, context: CallContext) {
     throw new Error('not supported')
@@ -73,15 +66,13 @@ export class ServiceManager implements ProcessorServiceImplementation {
     // also configure the main thread
     const newConfig = ProcessConfigResponse.fromPartial({})
     await PluginManager.INSTANCE.configure(newConfig)
+    this.pool.options.workerData = {
+      configRequest: request,
+      ...this.pool.options.workerData
+    }
     return newConfig
   }
 
-  //
-  // async configure() {
-  //   this.processorConfig = ProcessConfigResponse.fromPartial({})
-  //   await PluginManager.INSTANCE.configure(this.processorConfig)
-  // }
-
   async start(request: StartRequest, context: CallContext): Promise<Empty> {
     if (this.started) {
       return {}
@@ -93,9 +84,16 @@ export class ServiceManager implements ProcessorServiceImplementation {
       throw new ServerError(Status.INVALID_ARGUMENT, 'Failed to load processor: ' + errorString(e))
     }
 
-    // broadcast to all worker
-    const bc = new BroadcastChannel('start_channel')
-    bc.postMessage(request)
+    this.pool = new Piscina({
+      maxThreads: this.options.worker,
+      minThreads: this.options.worker,
+      filename: new URL('./service-worker.js', import.meta.url).href.replaceAll('runtime/src', 'runtime/lib'),
+      argv: process.argv,
+      workerData: {
+        startRequest: request,
+        options: this.options
+      }
+    })
 
     // also start the processor in main thread
     await PluginManager.INSTANCE.start(request)
@@ -114,7 +112,7 @@ export class ServiceManager implements ProcessorServiceImplementation {
   async processBindings(request: ProcessBindingsRequest, options?: CallContext): Promise<ProcessBindingResponse> {
     const promises = []
     for (const binding of request.bindings) {
-      const promise = this.processBinding(binding, undefined)
+      const promise = this.processBinding(binding)
       if (GLOBAL_CONFIG.execution.sequential) {
         await promise
       }
@@ -141,11 +139,7 @@ export class ServiceManager implements ProcessorServiceImplementation {
     }
   }
 
-  async processBinding(
-    request: DataBinding,
-    preparedData: PreparedData | undefined,
-    options?: CallContext
-  ): Promise<ProcessResult> {
+  async processBinding(request: DataBinding): Promise<ProcessResult> {
     if (!this.started) {
       throw new ServerError(Status.UNAVAILABLE, 'Service Not started.')
     }
@@ -162,7 +156,7 @@ export class ServiceManager implements ProcessorServiceImplementation {
       )
     }
 
-    return await this.pool.run({ request, preparedData }, { name: 'processBinding' })
+    return await this.pool.run({ request })
   }
 
   async *processBindingsStream(requests: AsyncIterable<ProcessStreamRequest>, context: CallContext) {
@@ -207,7 +201,7 @@ export class ServiceManager implements ProcessorServiceImplementation {
           // todo support db request
           // const dbContext = contexts.new(request.processId, subject)
           const start = Date.now()
-          await this.processBinding(binding, undefined)
+          await this.processBinding(binding)
             .then(async (result) => {
               // await all pending db requests
               // await dbContext.awaitPendings()

package/src/service-worker.ts

@@ -17,9 +17,9 @@ import { freezeGlobalConfig } from './global-config.js'
 import { DebugInfo, RichServerError } from 'nice-grpc-error-details'
 import { recordRuntimeInfo } from './service.js'
 import { BroadcastChannel } from 'worker_threads'
+import { Piscina } from 'piscina'
 
 let started = false
-const options = commandLineArgs(optionDefinitions, { partial: true })
 
 let unhandled: Error | undefined
 
@@ -48,10 +48,12 @@ async function getConfig(request: ProcessConfigRequest, context?: CallContext):
   return newConfig
 }
 
-const loader = async () => {
-  const m = await import(options.target)
-  console.debug('Module loaded', m)
-  return m
+const loader = async (options: any) => {
+  if (options.target) {
+    const m = await import(options.target)
+    console.debug('Module loaded', m)
+    return m
+  }
 }
 
 const configureChannel = new BroadcastChannel('configure_channel')
@@ -59,40 +61,35 @@ configureChannel.onmessage = (request: ProcessConfigRequest) => {
   getConfig(request)
 }
 
-async function start(request: StartRequest): Promise<Empty> {
+async function start(request: StartRequest, options: any): Promise<Empty> {
   if (started) {
     return {}
   }
   freezeGlobalConfig()
 
   try {
-    await loader()
+    await loader(options)
   } catch (e) {
     throw new ServerError(Status.INVALID_ARGUMENT, 'Failed to load processor: ' + errorString(e))
   }
 
   await PluginManager.INSTANCE.start(request)
-  started = true
-  return {}
-}
-
-const startChannel = new BroadcastChannel('start_channel')
-startChannel.onmessage = (request: StartRequest) => {
-  start(request)
-}
-
-async function stop(request: Empty, context: CallContext): Promise<Empty> {
   return {}
 }
 
-async function processBinding(
-  request: DataBinding,
-  preparedData: PreparedData | undefined,
-  options?: CallContext
-): Promise<ProcessResult> {
+export default async function ({ request }: { request: DataBinding }) {
   if (!started) {
-    throw new ServerError(Status.UNAVAILABLE, 'Service Not started.')
+    const { startRequest, configRequest, options } = Piscina.workerData
+    if (startRequest) {
+      await start(startRequest, options)
+    }
+    if (configRequest) {
+      await getConfig(configRequest)
+    }
+    started = true
+    console.info('new processor worker started')
   }
+
   if (unhandled) {
     throw new RichServerError(
       Status.UNAVAILABLE,
@@ -108,7 +105,7 @@ async function processBinding(
 
   const result = await PluginManager.INSTANCE.processBinding(
     request,
-    preparedData
+    undefined
     // PluginManager.INSTANCE.dbContextLocalStorage.getStore()
   )
   recordRuntimeInfo(result, request.handlerType)

package/src/tsup.config.ts

@@ -6,7 +6,7 @@ export default defineConfig({
       js: `import { createRequire as createRequireShim } from 'module'; const require = createRequireShim(import.meta.url);`
     }
   },
-  entry: ['src/index.ts', 'src/processor-runner.ts', 'src/service-worker.ts'],
+  entry: ['src/index.ts', 'src/processor-runner.ts', 'src/service-worker.ts', 'src/test-processor.test.ts'],
   outDir: 'lib',
   minify: process.env['BRANCH'] === 'release',
   sourcemap: true,