@hotmeshio/hotmesh 0.0.18 → 0.0.19

package/build/modules/utils.js

@@ -6,6 +6,13 @@ async function sleepFor(ms) {
 }
 exports.sleepFor = sleepFor;
 function identifyRedisType(redisInstance) {
+    const prototype = Object.getPrototypeOf(redisInstance);
+    if ('defineCommand' in prototype || Object.keys(prototype).includes('multi')) {
+        return 'ioredis';
+    }
+    else if (Object.keys(prototype).includes('Multi')) {
+        return 'redis';
+    }
     if (redisInstance.constructor) {
         if (redisInstance.constructor.name === 'Redis' || redisInstance.constructor.name === 'EventEmitter') {
             if ('hset' in redisInstance) {

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.0.18",
+    "version": "0.0.19",
     "description": "Unbreakable Workflows",
     "main": "build/index.js",
     "types": "build/index.d.ts",

package/build/services/activities/hook.d.ts

@@ -1,9 +1,9 @@
+import { Activity } from './activity';
 import { EngineService } from '../engine';
 import { ActivityData, ActivityMetadata, ActivityType, HookActivity } from '../../types/activity';
+import { HookRule } from '../../types/hook';
 import { JobState, JobStatus } from '../../types/job';
 import { RedisMulti } from '../../types/redis';
-import { HookRule } from '../../types/hook';
-import { Activity } from './activity';
 /**
  * Listens for `webhook`, `timehook`, and `cycle` (repeat) signals
  */

package/build/services/activities/hook.js

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Hook = void 0;
 const errors_1 = require("../../modules/errors");
+const activity_1 = require("./activity");
 const collator_1 = require("../collator");
 const pipe_1 = require("../pipe");
 const store_1 = require("../signaler/store");
 const telemetry_1 = require("../telemetry");
-const activity_1 = require("./activity");
-const types_1 = require("../../types");
+const stream_1 = require("../../types/stream");
 /**
  * Listens for `webhook`, `timehook`, and `cycle` (repeat) signals
  */
@@ -107,7 +107,7 @@ class Hook extends activity_1.Activity {
         if (jobId) {
             //if a webhook signal is sent that includes 'keep_alive' the hook will remain open
             const code = data.keep_alive ? 202 : 200;
-            await this.processEvent(types_1.StreamStatus.SUCCESS, code, 'hook', jobId);
+            await this.processEvent(stream_1.StreamStatus.SUCCESS, code, 'hook', jobId);
             if (code === 200) {
                 await signaler.deleteWebHookSignal(this.config.hook.topic, data);
             }
@@ -118,7 +118,7 @@ class Hook extends activity_1.Activity {
             jid: jobId,
             aid: this.metadata.aid
         });
-        await this.processEvent(types_1.StreamStatus.SUCCESS, 200, 'hook');
+        await this.processEvent(stream_1.StreamStatus.SUCCESS, 200, 'hook');
     }
 }
 exports.Hook = Hook;

package/build/services/durable/client.js

@@ -6,46 +6,7 @@ const factory_1 = require("./factory");
 const handle_1 = require("./handle");
 const hotmesh_1 = require("../hotmesh");
 const key_1 = require("../../modules/key");
-/*
-Here is an example of how the methods in this file are used:
-
-./client.ts
-
-import { Durable } from '@hotmeshio/hotmesh';
-import Redis from 'ioredis';
-import { example } from './workflows';
-import { nanoid } from 'nanoid';
-
-async function run() {
-  const connection = await Durable.Connection.connect({
-    class: Redis,
-    options: {
-      host: 'localhost',
-      port: 6379,
-    },
-  });
-
-  const client = new Durable.Client({
-    connection,
-  });
-
-  const handle = await client.workflow.start({
-    args: ['HotMesh'],
-    taskQueue: 'hello-world',
-    workflowName: 'example',
-    workflowId: 'workflow-' + nanoid(),
-  });
-
-  console.log(`Started workflow ${handle.workflowId}`);
-  console.log(await handle.result());
-}
-
-run().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
-
-*/
+const search_1 = require("./search");
 class ClientService {
     constructor(config) {
         this.getHotMeshClient = async (worflowTopic) => {
@@ -81,7 +42,7 @@ class ClientService {
          * this method will configure the search index for the workflow.
          */
         this.configureSearchIndex = async (hotMeshClient, search) => {
-            if (search) {
+            if (search?.schema) {
                 const store = hotMeshClient.engine.store;
                 const schema = [];
                 for (const [key, value] of Object.entries(search.schema)) {
@@ -129,6 +90,13 @@ class ClientService {
                 };
                 const context = { metadata: { trc, spn }, data: {} };
                 const jobId = await hotMeshClient.pub(factory_1.SUBSCRIBES_TOPIC, payload, context);
+                if (jobId && options.search?.data) {
+                    //job successfully kicked off; there is default job data to persist
+                    const search = new search_1.Search(jobId, hotMeshClient);
+                    for (const [key, value] of Object.entries(options.search.data)) {
+                        search.set(key, value);
+                    }
+                }
                 return new handle_1.WorkflowHandleService(hotMeshClient, workflowTopic, jobId);
             },
             signal: async (signalId, data) => {

package/build/services/durable/worker.d.ts

@@ -1,5 +1,5 @@
 import { HotMeshService as HotMesh } from '../hotmesh';
-import { Connection, Registry, WorkerConfig, WorkerOptions } from "../../types/durable";
+import { Connection, Registry, WorkerConfig, WorkerOptions, WorkflowSearchOptions } from "../../types/durable";
 export declare class WorkerService {
     static activityRegistry: Registry;
     static connection: Connection;
@@ -14,6 +14,11 @@ export declare class WorkerService {
      * allowing proxyActivities to succeed.
      */
     static registerActivities<ACT>(activities: ACT): Registry;
+    /**
+     * For those deployments with a redis stack backend (with the FT module),
+     * this method will configure the search index for the workflow.
+     */
+    static configureSearchIndex(hotMeshClient: HotMesh, search?: WorkflowSearchOptions): Promise<void>;
     static create(config: WorkerConfig): Promise<WorkerService>;
     static resolveWorkflowTarget(workflow: object | Function): [string, Function];
     run(): Promise<void>;

package/build/services/durable/worker.js

@@ -7,36 +7,7 @@ const asyncLocalStorage_1 = require("./asyncLocalStorage");
 const factory_1 = require("./factory");
 const hotmesh_1 = require("../hotmesh");
 const stream_1 = require("../../types/stream");
-/*
-Here is an example of how the methods in this file are used:
-
-./worker.ts
-
-import { Durable } from '@hotmeshio/hotmesh';
-import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
-
-import * as workflows from './workflows';
-
-async function run() {
-  const worker = await Durable.Worker.create({
-    connection: {
-      class: Redis,
-      options: {
-        host: 'localhost',
-        port: 6379,
-      },
-    },
-    taskQueue: 'hello-world',
-    workflow: workflows.example,
-  });
-  await worker.run();
-}
-
-run().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
-*/
+const key_1 = require("../../modules/key");
 class WorkerService {
     static async activateWorkflow(hotMesh) {
         const app = await hotMesh.engine.store.getApp(factory_1.APP_ID);
@@ -79,6 +50,38 @@ class WorkerService {
         }
         return WorkerService.activityRegistry;
     }
+    /**
+     * For those deployments with a redis stack backend (with the FT module),
+     * this method will configure the search index for the workflow.
+     */
+    //todo: bind this to the Search service; update constructor to expect hotMeshClient as first param (id is optional
+    //refactor and delete other one as well)
+    static async configureSearchIndex(hotMeshClient, search) {
+        if (search?.schema) {
+            const store = hotMeshClient.engine.store;
+            const schema = [];
+            for (const [key, value] of Object.entries(search.schema)) {
+                //prefix with a comma (avoids collisions with hotmesh reserved words)
+                schema.push(`_${key}`);
+                schema.push(value.type);
+                if (value.sortable) {
+                    schema.push('SORTABLE');
+                }
+            }
+            try {
+                const keyParams = {
+                    appId: hotMeshClient.appId,
+                    jobId: ''
+                };
+                const hotMeshPrefix = key_1.KeyService.mintKey(hotMeshClient.namespace, key_1.KeyType.JOB_STATE, keyParams);
+                const prefixes = search.prefix.map((prefix) => `${hotMeshPrefix}${prefix}`);
+                await store.exec('FT.CREATE', `${search.index}`, 'ON', 'HASH', 'PREFIX', prefixes.length, ...prefixes, 'SCHEMA', ...schema);
+            }
+            catch (err) {
+                hotMeshClient.engine.logger.info('durable-client-search-err', { err });
+            }
+        }
+    }
     static async create(config) {
         //always call `registerActivities` before `import`
         WorkerService.connection = config.connection;
@@ -91,6 +94,7 @@ class WorkerService {
         const worker = new WorkerService();
         worker.activityRunner = await worker.initActivityWorker(config, activityTopic);
         worker.workflowRunner = await worker.initWorkflowWorker(config, workflowTopic, workflowFunction);
+        WorkerService.configureSearchIndex(worker.workflowRunner, config.search);
         await WorkerService.activateWorkflow(worker.workflowRunner);
         return worker;
     }

package/build/services/durable/workflow.d.ts

@@ -1,11 +1,12 @@
 import { ActivityConfig, ProxyType, WorkflowOptions } from "../../types/durable";
+import { Search } from './search';
 export declare class WorkflowService {
     /**
      * Spawn a child workflow. await the result.
      */
     static executeChild<T>(options: WorkflowOptions): Promise<T>;
     static proxyActivities<ACT>(options?: ActivityConfig): ProxyType<ACT>;
-    static data(command: 'del' | 'get' | 'set' | 'incr' | 'mult', ...args: string[]): Promise<number | boolean | string>;
+    static search(): Promise<Search>;
     static sleep(duration: string): Promise<number>;
     static waitForSignal(signals: string[], options?: Record<string, string>): Promise<Record<any, any>[]>;
     static wrapActivity<T>(activityName: string, options?: ActivityConfig): T;

package/build/services/durable/workflow.js

@@ -12,34 +12,6 @@ const connection_1 = require("./connection");
 const factory_1 = require("./factory");
 const errors_1 = require("../../modules/errors");
 const search_1 = require("./search");
-/*
-`proxyActivities` returns a wrapped instance of the
-target activity, so that when the workflow calls a
-proxied activity, it is actually calling the proxy
-function, which in turn calls the activity function.
-
-Here is an example of how the methods in this file are used:
-
-./workflows.ts
-
-import { Durable } from '@hotmeshio/hotmesh';
-import * as activities from './activities';
-
-const { greet } = Durable.workflow.proxyActivities<typeof activities>({
-  activities: activities,
-  startToCloseTimeout: '1 minute',
-  retryPolicy: {
-    initialInterval: '5 seconds',  // Initial delay between retries
-    maximumAttempts: 3,            // Max number of retry attempts
-    backoffCoefficient: 2.0,       // Backoff factor for delay between retries: delay = initialInterval * (backoffCoefficient ^ retry_attempt)
-    maximumInterval: '30 seconds', // Max delay between retries
-  },
-});
-
-export async function example(name: string): Promise<string> {
-  return await greet(name);
-}
-*/
 class WorkflowService {
     /**
      * Spawn a child workflow. await the result.
@@ -89,38 +61,15 @@ class WorkflowService {
         }
         return proxy;
     }
-    static async data(command, ...args) {
+    static async search() {
         const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
         if (!store) {
             throw new Error('durable-store-not-found');
         }
         const workflowId = store.get('workflowId');
         const workflowTopic = store.get('workflowTopic');
-        try {
-            const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic);
-            const search = new search_1.Search(workflowId, hotMeshClient);
-            if (command === 'get') {
-                return await search.get(args[0]);
-            }
-            else if (command === 'set') {
-                await search.set(args[0], args[1]);
-                return true;
-            }
-            else if (command === 'del') {
-                await search.del(args[0]);
-                return true;
-            }
-            else if (command === 'incr') {
-                return await search.incr(args[0], Number(args[1]));
-            }
-            else if (command === 'mult') {
-                return await search.mult(args[0], Number(args[1]));
-            }
-        }
-        catch (e) {
-            console.error(e);
-            return '';
-        }
+        const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic);
+        return new search_1.Search(workflowId, hotMeshClient);
     }
     static async sleep(duration) {
         const seconds = (0, ms_1.default)(duration) / 1000;

package/build/types/durable.d.ts

@@ -6,12 +6,13 @@ type WorkflowConfig = {
     initialInterval?: string;
 };
 type WorkflowSearchOptions = {
-    index: string;
-    prefix: string[];
-    schema: Record<string, {
+    index?: string;
+    prefix?: string[];
+    schema?: Record<string, {
         type: 'TEXT' | 'NUMERIC' | 'TAG';
         sortable: boolean;
     }>;
+    data?: Record<string, string>;
 };
 type WorkflowOptions = {
     taskQueue: string;
@@ -59,6 +60,7 @@ type WorkerConfig = {
     taskQueue: string;
     workflow: Function;
     options?: WorkerOptions;
+    search?: WorkflowSearchOptions;
 };
 type WorkerOptions = {
     maxSystemRetries?: number;

package/modules/utils.ts

@@ -9,6 +9,12 @@ export async function sleepFor(ms: number) {
 }
 
 export function identifyRedisType(redisInstance: any): 'redis' | 'ioredis' | null {
+  const prototype = Object.getPrototypeOf(redisInstance);
+  if ('defineCommand' in prototype || Object.keys(prototype).includes('multi')) {
+    return 'ioredis';
+  } else if (Object.keys(prototype).includes('Multi')) {
+    return 'redis';
+  }
   if (redisInstance.constructor) {
     if (redisInstance.constructor.name === 'Redis' || redisInstance.constructor.name === 'EventEmitter') {
       if ('hset' in redisInstance) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.0.18",
+  "version": "0.0.19",
   "description": "Unbreakable Workflows",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/services/activities/hook.ts

@@ -1,4 +1,5 @@
-import { CollationError, GetStateError } from '../../modules/errors';
+import { GetStateError } from '../../modules/errors';
+import { Activity } from './activity';
 import { CollatorService } from '../collator';
 import { EngineService } from '../engine';
 import { Pipe } from '../pipe';
@@ -8,15 +9,14 @@ import {
   ActivityData,
   ActivityMetadata,
   ActivityType,
-  HookActivity} from '../../types/activity';
+  HookActivity } from '../../types/activity';
+import { HookRule } from '../../types/hook';
 import { JobState, JobStatus } from '../../types/job';
 import {
   MultiResponseFlags,
   RedisMulti } from '../../types/redis';
 import { StringScalarType } from '../../types/serializer';
-import { HookRule } from '../../types/hook';
-import { Activity } from './activity';
-import { StreamStatus } from '../../types';
+import { StreamStatus } from '../../types/stream';
 
 /**
  * Listens for `webhook`, `timehook`, and `cycle` (repeat) signals

package/services/durable/client.ts

@@ -9,47 +9,7 @@ import {
   WorkflowSearchOptions} from '../../types/durable';
 import { JobState } from '../../types/job';
 import { KeyService, KeyType } from '../../modules/key';
-
-/*
-Here is an example of how the methods in this file are used:
-
-./client.ts
-
-import { Durable } from '@hotmeshio/hotmesh';
-import Redis from 'ioredis';
-import { example } from './workflows';
-import { nanoid } from 'nanoid';
-
-async function run() {
-  const connection = await Durable.Connection.connect({
-    class: Redis,
-    options: {
-      host: 'localhost',
-      port: 6379,
-    },
-  });
-
-  const client = new Durable.Client({
-    connection,
-  });
-
-  const handle = await client.workflow.start({
-    args: ['HotMesh'],
-    taskQueue: 'hello-world',
-    workflowName: 'example',
-    workflowId: 'workflow-' + nanoid(),
-  });
-
-  console.log(`Started workflow ${handle.workflowId}`);
-  console.log(await handle.result());
-}
-
-run().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
-
-*/
+import { Search } from './search';
 
 export class ClientService {
 
@@ -96,7 +56,7 @@ export class ClientService {
    * this method will configure the search index for the workflow.
    */
   configureSearchIndex = async (hotMeshClient: HotMesh, search?: WorkflowSearchOptions): Promise<void> => {
-    if (search) {
+    if (search?.schema) {
       const store = hotMeshClient.engine.store;
       const schema: string[] = [];
       for (const [key, value] of Object.entries(search.schema)) {
@@ -148,6 +108,13 @@ export class ClientService {
         SUBSCRIBES_TOPIC,
         payload,
         context as JobState);
+       if (jobId && options.search?.data) {
+        //job successfully kicked off; there is default job data to persist
+        const search = new Search(jobId, hotMeshClient);
+        for (const [key, value] of Object.entries(options.search.data)) {
+          search.set(key, value);
+        }
+      }
       return new WorkflowHandleService(hotMeshClient, workflowTopic, jobId);
     },
 

package/services/durable/worker.ts

@@ -15,43 +15,14 @@ import {
   Registry,
   WorkerConfig,
   WorkerOptions,
-  WorkflowDataType } from "../../types/durable";
+  WorkflowDataType, 
+  WorkflowSearchOptions} from "../../types/durable";
 import { RedisClass, RedisOptions } from '../../types/redis';
 import {
   StreamData,
   StreamDataResponse,
   StreamStatus } from '../../types/stream';
-
-/*
-Here is an example of how the methods in this file are used:
-
-./worker.ts
-
-import { Durable } from '@hotmeshio/hotmesh';
-import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
-
-import * as workflows from './workflows';
-
-async function run() {
-  const worker = await Durable.Worker.create({
-    connection: {
-      class: Redis,
-      options: {
-        host: 'localhost',
-        port: 6379,
-      },
-    },
-    taskQueue: 'hello-world',
-    workflow: workflows.example,
-  });
-  await worker.run();
-}
-
-run().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
-*/
+import { KeyService, KeyType } from '../../modules/key';
 
 export class WorkerService {
   static activityRegistry: Registry = {}; //user's activities
@@ -112,6 +83,38 @@ export class WorkerService {
     return WorkerService.activityRegistry;
   }
 
+  /**
+   * For those deployments with a redis stack backend (with the FT module),
+   * this method will configure the search index for the workflow.
+   */
+  //todo: bind this to the Search service; update constructor to expect hotMeshClient as first param (id is optional
+  //refactor and delete other one as well)
+  static async configureSearchIndex(hotMeshClient: HotMesh, search?: WorkflowSearchOptions): Promise<void> {
+    if (search?.schema) {
+      const store = hotMeshClient.engine.store;
+      const schema: string[] = [];
+      for (const [key, value] of Object.entries(search.schema)) {
+        //prefix with a comma (avoids collisions with hotmesh reserved words)
+        schema.push(`_${key}`);
+        schema.push(value.type);
+        if (value.sortable) {
+          schema.push('SORTABLE');
+        }
+      }
+      try {
+        const keyParams = {
+          appId: hotMeshClient.appId,
+          jobId: ''
+        }
+        const hotMeshPrefix = KeyService.mintKey(hotMeshClient.namespace, KeyType.JOB_STATE, keyParams);
+        const prefixes = search.prefix.map((prefix) => `${hotMeshPrefix}${prefix}`);
+        await store.exec('FT.CREATE', `${search.index}`, 'ON', 'HASH', 'PREFIX', prefixes.length, ...prefixes, 'SCHEMA', ...schema);
+      } catch (err) {
+        hotMeshClient.engine.logger.info('durable-client-search-err', { err });
+      }
+    }
+  }
+
   static async create(config: WorkerConfig) {
     //always call `registerActivities` before `import`
     WorkerService.connection = config.connection;
@@ -125,6 +128,7 @@ export class WorkerService {
     const worker = new WorkerService();
     worker.activityRunner = await worker.initActivityWorker(config, activityTopic);
     worker.workflowRunner = await worker.initWorkflowWorker(config, workflowTopic, workflowFunction);
+    WorkerService.configureSearchIndex(worker.workflowRunner, config.search)
     await WorkerService.activateWorkflow(worker.workflowRunner);
     return worker;
   }

package/services/durable/workflow.ts

@@ -10,35 +10,6 @@ import { ACTIVITY_PUBLISHES_TOPIC, ACTIVITY_SUBSCRIBES_TOPIC, SLEEP_SUBSCRIBES_T
 import { DurableIncompleteSignalError, DurableSleepError, DurableWaitForSignalError } from '../../modules/errors';
 import { Search } from './search';
 
-/*
-`proxyActivities` returns a wrapped instance of the 
-target activity, so that when the workflow calls a
-proxied activity, it is actually calling the proxy
-function, which in turn calls the activity function.
-
-Here is an example of how the methods in this file are used:
-
-./workflows.ts
-
-import { Durable } from '@hotmeshio/hotmesh';
-import * as activities from './activities';
-
-const { greet } = Durable.workflow.proxyActivities<typeof activities>({
-  activities: activities,
-  startToCloseTimeout: '1 minute',
-  retryPolicy: {
-    initialInterval: '5 seconds',  // Initial delay between retries
-    maximumAttempts: 3,            // Max number of retry attempts
-    backoffCoefficient: 2.0,       // Backoff factor for delay between retries: delay = initialInterval * (backoffCoefficient ^ retry_attempt)
-    maximumInterval: '30 seconds', // Max delay between retries
-  },
-});
-
-export async function example(name: string): Promise<string> {
-  return await greet(name);
-}
-*/
-
 export class WorkflowService {
 
   /**
@@ -98,7 +69,7 @@ export class WorkflowService {
     return proxy;
   }
 
-  static async data(command: 'del' | 'get' | 'set' | 'incr' | 'mult', ...args: string[]): Promise<number | boolean | string> {
+  static async search(): Promise<Search> {
     const store = asyncLocalStorage.getStore();
     if (!store) {
       throw new Error('durable-store-not-found');
@@ -106,26 +77,8 @@ export class WorkflowService {
     const workflowId = store.get('workflowId');
     const workflowTopic = store.get('workflowTopic');
 
-    try {
-      const hotMeshClient = await WorkerService.getHotMesh(workflowTopic);
-      const search = new Search(workflowId, hotMeshClient);
-      if (command === 'get') {
-        return await search.get(args[0]) as string;
-      } else if (command === 'set') {
-        await search.set(args[0], args[1]);
-        return true;
-      } else if (command === 'del') {
-        await search.del(args[0]);
-        return true;
-      } else if (command === 'incr') {
-        return await search.incr(args[0], Number(args[1])) as number;
-      } else if (command === 'mult') {
-        return await search.mult(args[0], Number(args[1])) as number;
-      }
-    } catch (e) {
-      console.error(e);
-      return '';
-    }
+    const hotMeshClient = await WorkerService.getHotMesh(workflowTopic);
+    return new Search(workflowId, hotMeshClient);
   }
 
   static async sleep(duration: string): Promise<number> {

package/types/durable.ts

@@ -8,9 +8,10 @@ type WorkflowConfig = {
 }
 
 type WorkflowSearchOptions = {
-  index: string;         //FT index name (myapp:myindex)
-  prefix: string[];      //FT prefixes (['myapp:myindex:prefix1', 'myapp:myindex:prefix2'])
-  schema: Record<string, {type: 'TEXT' | 'NUMERIC' | 'TAG', sortable: boolean}>;
+  index?: string;         //FT index name (myapp:myindex)
+  prefix?: string[];      //FT prefixes (['myapp:myindex:prefix1', 'myapp:myindex:prefix2'])
+  schema?: Record<string, {type: 'TEXT' | 'NUMERIC' | 'TAG', sortable: boolean}>;
+  data?: Record<string, string>;
 }
 
 type WorkflowOptions = {
@@ -66,6 +67,7 @@ type WorkerConfig = {
   taskQueue: string; //`subscribes` in the YAML (e.g, 'hello-world')
   workflow: Function; //target function to run
   options?: WorkerOptions;
+  search?: WorkflowSearchOptions;
 }
 
 type WorkerOptions = {