@hotmeshio/hotmesh 0.0.8 → 0.0.9

package/LICENSE

@@ -178,13 +178,10 @@ Terms and Conditions for Use, Reproduction, and Distribution
       product that includes the Work or any part of it, as a commercial
       service to third parties, or in any other commercial context where
       you derive direct or indirect financial benefit from the use of the
-      Work. This includes, but is not limited to, providing 
-      routing-as-a-service, bpm-as-a-service, workflow-as-a-service,
-      integration-as-a-service, operational-data-as-a-service
-      or any other similar service that would compete with 
-      HotMesh's commercial offering of workflow and routing services.
-      Any such use requires explicit written permission from the
-      Licensor.
+      Work in a manner that would compete with the Licensor's commercial 
+      service-mesh-as-a-service, bpm-as-a-service, workflow-as-a-service,
+      integration-as-a-service or similar orchestration-type service.
+      Any such use requires explicit written permission from the Licensor.
 
    END OF TERMS AND CONDITIONS
 

package/README.md

@@ -1,7 +1,7 @@
 # HotMesh
 ![alpha release](https://img.shields.io/badge/release-alpha-yellow)
 
-Build sophisticated, durable workflows without the overhead of a dedicated server cluster. With HotMesh, your code remains front and center using [infrastructure](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/faq.md#what-is-hotmesh) you already own.
+Elevate Redis from an in-memory data store to a game-changing **service mesh**, delivering *durable* workflows without the overhead of a dedicated control plane. With HotMesh, you can keep your code at the forefront, utilizing [Redis infrastructure](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/faq.md#what-is-hotmesh) you already trust and own.
 
 ## Install
 [![npm version](https://badge.fury.io/js/%40hotmeshio%2Fhotmesh.svg)](https://badge.fury.io/js/%40hotmeshio%2Fhotmesh)
@@ -11,7 +11,9 @@ npm install @hotmeshio/hotmesh
 ```
 
 ## Design
-HotMesh's TypeScript SDK is modeled after [Temporal IO's](https://github.com/temporalio) developer-friendly approach. Design and deploy durable workflows using familiar paradigms that keep your code delightful to maintain. Deploying Temporal's [hello-world tutorial](https://github.com/temporalio/samples-typescript/tree/main/hello-world/src), for example, requires few changes beyond using the HotMesh SDK and saving to Redis.
+HotMesh's TypeScript SDK is modeled after Temporal IO's developer-friendly approach. Design and deploy durable workflows using your preferred coding style. Write your functions as you normally would, then use the HotMesh to make them durable. Temporal's [hello-world tutorial](https://github.com/temporalio/samples-typescript/tree/main/hello-world/src), for example, requires few changes beyond importing the HotMesh SDK.
+
+>Start by defining activities. These are the functions that will be invoked by your workflow. They can be written in any style, using any framework, and can even be legacy functions you've already written. The only requirement is that they return a Promise.
 
 **./activities.ts**
 ```javascript
@@ -20,85 +22,74 @@ export async function greet(name: string): Promise<string> {
 }
 ```
 
+>Next, define your workflow. Include conditional logic, loops, etc. It's vanilla code written in your own coding style--just make sure to call `proxyActivities` to run your activities durably.
+
 **./workflows.ts**
 ```javascript
 import { Durable } from '@hotmeshio/hotmesh';
-import type * as activities from './activities';
+import * as activities from './activities';
 
-const { greet } = Durable.workflow.proxyActivities<typeof activities>();
+const { greet } = Durable.workflow
+  .proxyActivities<typeof activities>({
+    activities
+  });
 
 export async function example(name: string): Promise<string> {
   return await greet(name);
 }
 ```
 
-**./worker.ts**
-```javascript
-import { Durable } from '@hotmeshio/hotmesh';
-import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
-import * as activities from './activities';
-
-async function run() {
-  const connection = await Durable.NativeConnection.connect({
-    class: Redis,
-    options: {
-      host: 'localhost',
-      port: 6379,
-    },
-  });
-  const worker = await Durable.Worker.create({
-    connection,
-    namespace: 'default',
-    taskQueue: 'hello-world',
-    workflowsPath: require.resolve('./workflows'),
-    activities,
-  });
-  await worker.run();
-}
-
-run().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
-```
+>Finally, create a worker and client. The *client* triggers workflows, while the *worker* runs them, retrying as necessary until the workflow succeeds--all without the need for complicated retry logic.
 
 **./client.ts**
 ```javascript
 import { Durable } from '@hotmeshio/hotmesh';
-import Redis from 'ioredis';
+import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
 import { v4 as uuidv4 } from 'uuid';
 
 async function run() {
   const connection = await Durable.Connection.connect({
     class: Redis,
-    options: {
-      host: 'localhost',
-      port: 6379,
-    },
+    options: { host: 'localhost', port: 6379 }
   });
 
   const client = new Durable.Client({
-    connection,
+    connection
   });
 
   const handle = await client.workflow.start({
     args: ['HotMesh'],
     taskQueue: 'hello-world',
     workflowName: 'example',
-    workflowId: 'workflow-' + uuidv4(),
+    workflowId: 'workflow-' + uuidv4()
   });
 
-  console.log(`Started workflow ${handle.workflowId}`);
   console.log(await handle.result());
 }
+```
 
-run().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
+**./worker.ts**
+```javascript
+import { Durable } from '@hotmeshio/hotmesh';
+import Redis from 'ioredis';
+import * as workflows from './workflows';
+
+async function run() {
+  const connection = await Durable.NativeConnection.connect({
+    class: Redis,
+    options: { host: 'localhost', port: 6379 },
+  });
+  const worker = await Durable.Worker.create({
+    connection,
+    namespace: 'default',
+    taskQueue: 'hello-world',
+    workflow: workflows.example,
+  });
+  await worker.run();
+}
 ```
 
->HotMesh delivers durable function execution using a [distributed service mesh](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/distributed_orchestration.md). The design consumes leftover CPU on your microservices to execute workflows without the cost and complexity of a central server/control plane.
+>HotMesh delivers durable function execution using a [distributed service mesh](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/distributed_orchestration.md). The design delivers durable workflows without the cost and complexity of a centralized service mesh/control plane. Refer to the [hotmeshio/samples-typescript](https://github.com/hotmeshio/samples-typescript) Git Repo for a range of examples, including nested workflows.
 
 ## Advanced Design
 HotMesh's TypeScript SDK is the easiest way to make your functions durable. But if you need full control over your function lifecycles (including high-volume, high-speed use cases), you can use HotMesh's underlying YAML models to optimize your durable workflows. The following model depicts a sequence of activities orchestrated by HotMesh. Any function you associate with a `topic` in your YAML definition is guaranteed to be durable.

package/build/{esm/package.json → package.json}

@@ -1,14 +1,9 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.0.8",
+    "version": "0.0.9",
     "description": "Durable Workflows",
-    "main": "build/cjs/index.js",
-    "module": "build/esm/index.js",
-    "types": "build/cjs/index.d.ts",
-    "exports": {
-        "import": "./build/esm/index.js",
-        "require": "./build/cjs/index.js"
-    },
+    "main": "build/index.js",
+    "types": "build/index.d.ts",
     "repository": {
         "type": "git",
         "url": "https://github.com/hotmeshio/sdk-typescript.git"
@@ -19,9 +14,7 @@
     },
     "scripts": {
         "clean": "rimraf ./build",
-        "build:cjs": "tsc --build tsconfig.cjs.json",
-        "build:esm": "tsc --build tsconfig.esm.json",
-        "build": "npm run build:cjs && npm run build:esm",
+        "build": "tsc --build tsconfig.json",
         "clean-build": "npm run clean && npm run build",
         "lint": "eslint . --ext .ts",
         "lint:fix": "eslint . --fix --ext .ts",

package/build/{cjs/services → services}/durable/native.js

@@ -10,7 +10,7 @@ Here is an example of how the methods in this file are used:
 import { Durable: { NativeConnection, Worker } } from '@hotmeshio/hotmesh';
 import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
 
-import * as activities from './activities';
+import * as workflows from './workflows';
 
 async function run() {
   const connection = await NativeConnection.connect({
@@ -24,7 +24,7 @@ async function run() {
     connection,
     namespace: 'default',
     taskQueue: 'hello-world',
-    workflowsPath: require.resolve('./workflows'),
+    workflow: workflows.example,
     activities,
   });
   await worker.run();

package/build/{esm/services → services}/durable/worker.d.ts

@@ -13,9 +13,7 @@ export declare class WorkerService {
      * dynamically importing the user's workflow module. That file
      * contains a call, `proxyActivities`, which needs this info.
      *
-     * NOTE: The `worker` and `client` both call `proxyActivities`,
-     * as a natural result of importing worflows.ts. However,
-     * because the worker imports the workflows dynamically AFTER
+     * NOTE: Because the worker imports the workflows dynamically AFTER
      * the activities are loaded, there will be items in the registry,
      * allowing proxyActivities to succeed.
      */

package/build/{cjs/services → services}/durable/worker.js

@@ -1,27 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerService = void 0;
@@ -37,7 +14,7 @@ Here is an example of how the methods in this file are used:
 import { Durable: { NativeConnection, Worker } } from '@hotmeshio/hotmesh';
 import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
 
-import * as activities from './activities';
+import * as workflows from './workflows';
 
 async function run() {
   const connection = await NativeConnection.connect({
@@ -51,7 +28,7 @@ async function run() {
     connection,
     namespace: 'default',
     taskQueue: 'hello-world',
-    workflowsPath: require.resolve('./workflows'),
+    workflow: workflows.example,
     activities,
   });
   await worker.run();
@@ -92,19 +69,19 @@ class WorkerService {
      * dynamically importing the user's workflow module. That file
      * contains a call, `proxyActivities`, which needs this info.
      *
-     * NOTE: The `worker` and `client` both call `proxyActivities`,
-     * as a natural result of importing worflows.ts. However,
-     * because the worker imports the workflows dynamically AFTER
+     * NOTE: Because the worker imports the workflows dynamically AFTER
      * the activities are loaded, there will be items in the registry,
      * allowing proxyActivities to succeed.
      */
     static registerActivities(activities) {
-        if (typeof activities === 'function') {
+        if (typeof activities === 'function' && typeof WorkerService.activityRegistry[activities.name] !== 'function') {
             WorkerService.activityRegistry[activities.name] = activities;
         }
         else {
             Object.keys(activities).forEach(key => {
-                WorkerService.activityRegistry[activities[key].name] = activities[key];
+                if (activities[key].name && typeof WorkerService.activityRegistry[activities[key].name] !== 'function') {
+                    WorkerService.activityRegistry[activities[key].name] = activities[key];
+                }
             });
         }
         return WorkerService.activityRegistry;
@@ -112,8 +89,8 @@ class WorkerService {
     static async create(config) {
         //always call `registerActivities` before `import`
         WorkerService.connection = config.connection;
-        WorkerService.registerActivities(config.activities);
-        const workflow = await Promise.resolve(`${config.workflowsPath}`).then(s => __importStar(require(s)));
+        //user can provide the workflow file directly
+        const workflow = config.workflow;
         const [workflowFunctionName, workflowFunction] = WorkerService.resolveWorkflowTarget(workflow);
         const baseTopic = `${config.taskQueue}-${workflowFunctionName}`;
         const activityTopic = `${baseTopic}-activity`;

package/build/{cjs/services → services}/durable/workflow.js

@@ -33,8 +33,10 @@ Here is an example of how the methods in this file are used:
 ./workflows.ts
 
 import { Durable } from '@hotmeshio/hotmesh';
-import type * as activities from './activities';
+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
@@ -71,6 +73,9 @@ class WorkflowService {
         return result;
     }
     static proxyActivities(options) {
+        if (options.activities) {
+            worker_1.WorkerService.registerActivities(options.activities);
+        }
         const proxy = {};
         const keys = Object.keys(worker_1.WorkerService.activityRegistry);
         if (keys.length) {

package/build/{cjs/types → types}/durable.d.ts

@@ -34,10 +34,7 @@ type WorkerConfig = {
     connection: Connection;
     namespace: string;
     taskQueue: string;
-    workflowsPath: string;
-    activities: {
-        [key: string]: Function;
-    };
+    workflow: Function;
 };
 type ContextType = {
     workflowId: string;
@@ -48,8 +45,9 @@ type ProxyType<ACT> = {
     [K in keyof ACT]: FunctionSignature<ACT[K]>;
 };
 type ActivityConfig = {
-    startToCloseTimeout: string;
-    retryPolicy: {
+    startToCloseTimeout?: string;
+    activities?: any;
+    retryPolicy?: {
         initialInterval: string;
         maximumAttempts: number;
         backoffCoefficient: number;

package/package.json

@@ -1,14 +1,9 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "Durable Workflows",
-  "main": "build/cjs/index.js",
-  "module": "build/esm/index.js",
-  "types": "build/cjs/index.d.ts",
-  "exports": {
-    "import": "./build/esm/index.js",
-    "require": "./build/cjs/index.js"
-  },
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
   "repository": {
     "type": "git",
     "url": "https://github.com/hotmeshio/sdk-typescript.git"
@@ -19,9 +14,7 @@
   },
   "scripts": {
     "clean": "rimraf ./build",
-    "build:cjs": "tsc --build tsconfig.cjs.json",
-    "build:esm": "tsc --build tsconfig.esm.json",
-    "build": "npm run build:cjs && npm run build:esm",
+    "build": "tsc --build tsconfig.json",
     "clean-build": "npm run clean && npm run build",
     "lint": "eslint . --ext .ts",
     "lint:fix": "eslint . --fix --ext .ts",

package/services/durable/native.ts

@@ -9,7 +9,7 @@ Here is an example of how the methods in this file are used:
 import { Durable: { NativeConnection, Worker } } from '@hotmeshio/hotmesh';
 import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
 
-import * as activities from './activities';
+import * as workflows from './workflows';
 
 async function run() {
   const connection = await NativeConnection.connect({
@@ -23,7 +23,7 @@ async function run() {
     connection,
     namespace: 'default',
     taskQueue: 'hello-world',
-    workflowsPath: require.resolve('./workflows'),
+    workflow: workflows.example,
     activities,
   });
   await worker.run();

package/services/durable/worker.ts

@@ -13,7 +13,7 @@ Here is an example of how the methods in this file are used:
 import { Durable: { NativeConnection, Worker } } from '@hotmeshio/hotmesh';
 import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
 
-import * as activities from './activities';
+import * as workflows from './workflows';
 
 async function run() {
   const connection = await NativeConnection.connect({
@@ -27,7 +27,7 @@ async function run() {
     connection,
     namespace: 'default',
     taskQueue: 'hello-world',
-    workflowsPath: require.resolve('./workflows'),
+    workflow: workflows.example,
     activities,
   });
   await worker.run();
@@ -86,18 +86,18 @@ export class WorkerService {
    * dynamically importing the user's workflow module. That file
    * contains a call, `proxyActivities`, which needs this info.
    * 
-   * NOTE: The `worker` and `client` both call `proxyActivities`,
-   * as a natural result of importing worflows.ts. However,
-   * because the worker imports the workflows dynamically AFTER
+   * NOTE: Because the worker imports the workflows dynamically AFTER
    * the activities are loaded, there will be items in the registry,
    * allowing proxyActivities to succeed.
    */
   static registerActivities<ACT>(activities: ACT): Registry  {
-    if (typeof activities === 'function') {
+    if (typeof activities === 'function' && typeof WorkerService.activityRegistry[activities.name] !== 'function') {
       WorkerService.activityRegistry[activities.name] = activities as Function;
     } else {
       Object.keys(activities).forEach(key => {
-        WorkerService.activityRegistry[activities[key].name] = (activities as any)[key] as Function;
+        if (activities[key].name && typeof WorkerService.activityRegistry[activities[key].name] !== 'function') {
+          WorkerService.activityRegistry[activities[key].name] = (activities as any)[key] as Function;
+        }
       });
     }
     return WorkerService.activityRegistry;
@@ -106,8 +106,8 @@ export class WorkerService {
   static async create(config: WorkerConfig) {
     //always call `registerActivities` before `import`
     WorkerService.connection = config.connection;
-    WorkerService.registerActivities<typeof config.activities>(config.activities);
-    const workflow = await import(config.workflowsPath);
+    //user can provide the workflow file directly
+    const workflow = config.workflow;
     const [workflowFunctionName, workflowFunction] = WorkerService.resolveWorkflowTarget(workflow);
     const baseTopic = `${config.taskQueue}-${workflowFunctionName}`;
     const activityTopic = `${baseTopic}-activity`;

package/services/durable/workflow.ts

@@ -31,8 +31,10 @@ Here is an example of how the methods in this file are used:
 ./workflows.ts
 
 import { Durable } from '@hotmeshio/hotmesh';
-import type * as activities from './activities';
+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
@@ -72,6 +74,10 @@ export class WorkflowService {
   }
 
   static proxyActivities<ACT>(options?: ActivityConfig): ProxyType<ACT> {
+    if (options.activities) {
+      WorkerService.registerActivities(options.activities)
+    }
+
     const proxy: any = {};
     const keys = Object.keys(WorkerService.activityRegistry);
     if (keys.length) {

package/types/durable.ts

@@ -41,8 +41,7 @@ type WorkerConfig = {
   connection: Connection;
   namespace: string; //`appid` in the YAML (e.g, 'default')
   taskQueue: string; //`subscribes` in the YAML (e.g, 'hello-world')
-  workflowsPath: string; //resolved abs path to dyn import()
-  activities: { [key: string]: Function }; //vanilla activity exports
+  workflow: Function //target function to run
 }
 
 type ContextType = {
@@ -56,8 +55,9 @@ type ProxyType<ACT> = {
 };
 
 type ActivityConfig = {
-  startToCloseTimeout: string;
-  retryPolicy: {
+  startToCloseTimeout?: string;
+  activities?: any;
+  retryPolicy?: {
     initialInterval: string;
     maximumAttempts: number;
     backoffCoefficient: number;

package/build/cjs/package.json

@@ -1,82 +0,0 @@
-{
-    "name": "@hotmeshio/hotmesh",
-    "version": "0.0.8",
-    "description": "Durable Workflows",
-    "main": "build/cjs/index.js",
-    "module": "build/esm/index.js",
-    "types": "build/cjs/index.d.ts",
-    "exports": {
-        "import": "./build/esm/index.js",
-        "require": "./build/cjs/index.js"
-    },
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/hotmeshio/sdk-typescript.git"
-    },
-    "homepage": "https://github.com/hotmeshio/sdk-typescript#readme",
-    "publishConfig": {
-        "access": "public"
-    },
-    "scripts": {
-        "clean": "rimraf ./build",
-        "build:cjs": "tsc --build tsconfig.cjs.json",
-        "build:esm": "tsc --build tsconfig.esm.json",
-        "build": "npm run build:cjs && npm run build:esm",
-        "clean-build": "npm run clean && npm run build",
-        "lint": "eslint . --ext .ts",
-        "lint:fix": "eslint . --fix --ext .ts",
-        "start": "ts-node src/index.ts",
-        "test": "NODE_ENV=test jest --detectOpenHandles --forceExit --verbose",
-        "test:hmsh": "NODE_ENV=test jest ./tests/functional/index.test.ts --detectOpenHandles --verbose",
-        "test:compile": "NODE_ENV=test jest ./tests/functional/compile/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:cycle": "NODE_ENV=test jest ./tests/functional/cycle/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:connect": "NODE_ENV=test jest ./tests/unit/services/connector/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:connect:redis": "NODE_ENV=test jest ./tests/unit/services/connector/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:connect:ioredis": "NODE_ENV=test jest ./tests/unit/services/connector/clients/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:parallel": "NODE_ENV=test jest ./tests/functional/parallel/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:sequence": "NODE_ENV=test jest ./tests/functional/sequence/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:quorum": "NODE_ENV=test jest ./tests/functional/quorum/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:reclaim": "NODE_ENV=test jest ./tests/functional/reclaim/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:redeploy": "NODE_ENV=test jest ./tests/functional/redeploy/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:retry": "NODE_ENV=test jest ./tests/functional/retry/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:status": "NODE_ENV=test jest ./tests/functional/status/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:store:redis": "NODE_ENV=test jest ./tests/functional/store/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:store:ioredis": "NODE_ENV=test jest ./tests/functional/store/clients/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:stream:redis": "NODE_ENV=test jest ./tests/functional/stream/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:stream:ioredis": "NODE_ENV=test jest ./tests/functional/stream/clients/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:sub:redis": "NODE_ENV=test jest ./tests/functional/sub/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:sub:ioredis": "NODE_ENV=test jest ./tests/functional/sub/clients/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:durable": "NODE_ENV=test jest ./tests/durable/*/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:durable:hello": "NODE_ENV=test jest ./tests/durable/helloworld/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:durable:goodbye": "NODE_ENV=test jest ./tests/durable/goodbye/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:durable:retry": "NODE_ENV=test jest ./tests/durable/retry/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:durable:loopactivity": "NODE_ENV=test jest ./tests/durable/loopactivity/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:durable:nested": "NODE_ENV=test jest ./tests/durable/nested/index.test.ts --detectOpenHandles --forceExit --verbose"
-    },
-    "keywords": [],
-    "author": "luke.birdeau@gmail.com",
-    "license": "SEE LICENSE IN LICENSE",
-    "dependencies": {
-        "@apidevtools/json-schema-ref-parser": "^10.1.0",
-        "@opentelemetry/api": "^1.4.1",
-        "js-yaml": "^4.1.0",
-        "ms": "^2.1.3",
-        "uuid": "^9.0.1",
-        "winston": "^3.8.2"
-    },
-    "devDependencies": {
-        "@types/jest": "^29.5.0",
-        "@types/node": "^18.15.11",
-        "@typescript-eslint/eslint-plugin": "^5.56.0",
-        "@typescript-eslint/parser": "^5.56.0",
-        "eslint": "^8.36.0",
-        "ioredis": "^5.3.2",
-        "jest": "^29.5.0",
-        "redis": "^4.6.6",
-        "rimraf": "^4.4.1",
-        "ts-jest": "^29.0.5",
-        "ts-node": "^10.9.1",
-        "ts-node-dev": "^2.0.0",
-        "typescript": "^5.0.4"
-    }
-}

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

@@ -1,38 +0,0 @@
-import { HotMeshService as HotMesh } from '../hotmesh';
-import { Connection, Registry, WorkerConfig } from "../../types/durable";
-export declare class WorkerService {
-    static activityRegistry: Registry;
-    static connection: Connection;
-    static instances: Map<string, HotMesh | Promise<HotMesh>>;
-    workflowRunner: HotMesh;
-    activityRunner: HotMesh;
-    static getHotMesh: (worflowTopic: string) => Promise<HotMesh>;
-    static activateWorkflow(hotMesh: HotMesh, topic: string, factory: Function): Promise<void>;
-    /**
-     * The `worker` calls `registerActivities` immediately BEFORE
-     * dynamically importing the user's workflow module. That file
-     * contains a call, `proxyActivities`, which needs this info.
-     *
-     * NOTE: The `worker` and `client` both call `proxyActivities`,
-     * as a natural result of importing worflows.ts. However,
-     * because the worker imports the workflows dynamically AFTER
-     * the activities are loaded, there will be items in the registry,
-     * allowing proxyActivities to succeed.
-     */
-    static registerActivities<ACT>(activities: ACT): Registry;
-    static create(config: WorkerConfig): Promise<WorkerService>;
-    static resolveWorkflowTarget(workflow: object | Function): [string, Function];
-    run(): Promise<void>;
-    initActivityWorkflow(config: WorkerConfig, activityTopic: string): Promise<HotMesh>;
-    wrapActivityFunctions(): Function;
-    activateActivityWorkflow(hotMesh: HotMesh, activityTopic: string): Promise<void>;
-    initWorkerWorkflow(config: WorkerConfig, workflowTopic: string, workflowFunction: Function): Promise<HotMesh>;
-    static Context: {
-        info: () => {
-            workflowId: string;
-            workflowTopic: string;
-        };
-    };
-    wrapWorkflowFunction(workflowFunction: Function, workflowTopic: string): Function;
-    static shutdown(): Promise<void>;
-}

package/build/esm/index.d.ts

@@ -1,4 +0,0 @@
-import { Durable } from './services/durable';
-import { HotMeshService as HotMesh } from './services/hotmesh';
-import { HotMeshConfig } from './types/hotmesh';
-export { Durable, HotMesh, HotMeshConfig };

package/build/esm/index.js

@@ -1,3 +0,0 @@
-import { Durable } from './services/durable';
-import { HotMeshService as HotMesh } from './services/hotmesh';
-export { Durable, HotMesh };