@hotmeshio/hotmesh 0.0.10 → 0.0.11

package/README.md

@@ -11,9 +11,9 @@ npm install @hotmeshio/hotmesh
 ```
 
 ## Design
-The HotMesh SDK is designed to keep your code front-and-center. Write functions as you normally would, then use the HotMesh to make them durable.
+The HotMesh SDK is designed to keep your code front-and-center. Write functions as you normally would, then use HotMesh to make them durable.
 
-1. Start by defining **activities**. Activities are those functions that will be invoked by your workflow. They are commonly used to read and write to databases and invoke external services. 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.
+1. Start by defining **activities**. Activities are those functions that will be invoked by your workflow. They are commonly used to read and write to databases and invoke external services. 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. *Note how the `saludar` example throws an error 50% of the time. It doesn't matter how unpredictable your functions are, HotMesh will retry as necessary until they succeed.*
     ```javascript
     //activities.ts
 
@@ -22,6 +22,7 @@ The HotMesh SDK is designed to keep your code front-and-center. Write functions
     }
 
     export async function saludar(nombre: string): Promise<string> {
+      Math.random() > 0.5 && throw new Error('Random error');
       return `¡Hola, ${nombre}!`;
     }
     ```
@@ -74,7 +75,7 @@ The HotMesh SDK is designed to keep your code front-and-center. Write functions
     }
     ```
 
-4. The last step is to create a **worker** that executes the workflow. Workers listen for tasks on their assigned channel, executing their assigned workflow function until it succeeds.
+4. The last step is to create a **worker** and link it to your workflow function. Workers listen for tasks on their assigned channel, executing the linked workflow function until it succeeds.
     ```javascript
     //worker.ts
 
@@ -232,7 +233,7 @@ For a deep dive into HotMesh's distributed orchestration philosophy, refer to th
 HotMesh is a distributed orchestration engine. Refer to the [Distributed Orchestration Guide](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/distributed_orchestration.md) for a detailed breakdown of the approach.
 
 ## System Lifecycle
-Gain insight into the HotMesh's monitoring, exception handling, and alarm configurations via the [System Lifecycle Guide](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/system_lifecycle.md).
+Gain insight into HotMesh's monitoring, exception handling, and alarm configurations via the [System Lifecycle Guide](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/system_lifecycle.md).
 
 ## Alpha Release
 So what exacty is an [alpha release](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/alpha.md)?!

package/build/modules/errors.d.ts

@@ -6,6 +6,22 @@ declare class GetStateError extends Error {
 declare class SetStateError extends Error {
     constructor();
 }
+declare class DurableTimeoutError extends Error {
+    code: number;
+    constructor(message: string);
+}
+declare class DurableMaxedError extends Error {
+    code: number;
+    constructor(message: string);
+}
+declare class DurableFatalError extends Error {
+    code: number;
+    constructor(message: string);
+}
+declare class DurableRetryError extends Error {
+    code: number;
+    constructor(message: string);
+}
 declare class MapDataError extends Error {
     constructor();
 }
@@ -25,4 +41,4 @@ declare class CollationError extends Error {
     fault: CollationFaultType;
     constructor(status: number, leg: ActivityDuplex, stage: CollationStage, fault?: CollationFaultType);
 }
-export { CollationError, DuplicateJobError, GetStateError, SetStateError, MapDataError, RegisterTimeoutError, ExecActivityError };
+export { CollationError, DurableTimeoutError, DurableMaxedError, DurableFatalError, DurableRetryError, DuplicateJobError, GetStateError, SetStateError, MapDataError, RegisterTimeoutError, ExecActivityError };

package/build/modules/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExecActivityError = exports.RegisterTimeoutError = exports.MapDataError = exports.SetStateError = exports.GetStateError = exports.DuplicateJobError = exports.CollationError = void 0;
+exports.ExecActivityError = exports.RegisterTimeoutError = exports.MapDataError = exports.SetStateError = exports.GetStateError = exports.DuplicateJobError = exports.DurableRetryError = exports.DurableFatalError = exports.DurableMaxedError = exports.DurableTimeoutError = exports.CollationError = void 0;
 class GetStateError extends Error {
     constructor() {
         super("Error occurred while getting job state");
@@ -13,6 +13,34 @@ class SetStateError extends Error {
     }
 }
 exports.SetStateError = SetStateError;
+class DurableTimeoutError extends Error {
+    constructor(message) {
+        super(message);
+        this.code = 596;
+    }
+}
+exports.DurableTimeoutError = DurableTimeoutError;
+class DurableMaxedError extends Error {
+    constructor(message) {
+        super(message);
+        this.code = 597;
+    }
+}
+exports.DurableMaxedError = DurableMaxedError;
+class DurableFatalError extends Error {
+    constructor(message) {
+        super(message);
+        this.code = 598;
+    }
+}
+exports.DurableFatalError = DurableFatalError;
+class DurableRetryError extends Error {
+    constructor(message) {
+        super(message);
+        this.code = 599;
+    }
+}
+exports.DurableRetryError = DurableRetryError;
 class MapDataError extends Error {
     constructor() {
         super("Error occurred while mapping data");

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.0.10",
+    "version": "0.0.11",
     "description": "Durable Workflows",
     "main": "build/index.js",
     "types": "build/index.d.ts",
@@ -43,6 +43,7 @@
         "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:fatal": "NODE_ENV=test jest ./tests/durable/fatal/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"
     },

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

@@ -40,6 +40,7 @@ declare class Activity {
     resolveStatus(multiResponse: MultiResponseFlags): number;
     mapJobData(): void;
     mapInputData(): void;
+    mapOutputData(): void;
     registerTimeout(): Promise<void>;
     bindActivityError(data: Record<string, unknown>): void;
     getTriggerConfig(): Promise<ActivityType>;

package/build/services/activities/activity.js

@@ -4,7 +4,6 @@ exports.Activity = void 0;
 const errors_1 = require("../../modules/errors");
 const utils_1 = require("../../modules/utils");
 const collator_1 = require("../collator");
-const dimension_1 = require("../dimension");
 const mapper_1 = require("../mapper");
 const pipe_1 = require("../pipe");
 const serializer_1 = require("../serializer");
@@ -43,6 +42,7 @@ class Activity {
             if (this.doesHook()) {
                 //sleep and wait to awaken upon a signal
                 await this.registerHook(multi);
+                this.mapOutputData();
                 this.mapJobData();
                 await this.setState(multi);
                 await collator_1.CollatorService.authorizeReentry(this, multi);
@@ -53,6 +53,7 @@ class Activity {
             else {
                 //end the activity and transition to its children
                 this.adjacencyList = await this.filterAdjacent();
+                this.mapOutputData();
                 this.mapJobData();
                 await this.setState(multi);
                 await collator_1.CollatorService.notarizeEarlyCompletion(this, multi);
@@ -265,6 +266,16 @@ class Activity {
             this.context.data = mapper.mapRules();
         }
     }
+    mapOutputData() {
+        //activity YAML may include output map data that produces/extends activity output data.
+        if (this.config.output?.maps) {
+            const mapper = new mapper_1.MapperService(this.config.output.maps, this.context);
+            const actOutData = mapper.mapRules();
+            const activityId = this.metadata.aid;
+            const data = { ...this.context[activityId].output, ...actOutData };
+            this.context[activityId].output.data = data;
+        }
+    }
     async registerTimeout() {
         //set timeout in support of hook and/or duplex
     }
@@ -442,7 +453,7 @@ class Activity {
     }
     resolveAdjacentDad() {
         //concat self and child dimension (all children (leg 1) begin life at 0)
-        return `${this.resolveDad()}${dimension_1.DimensionService.getSeed(0)}`;
+        return `${this.resolveDad()}${collator_1.CollatorService.getDimensionalSeed(0)}`;
     }
     ;
     async filterAdjacent() {

package/build/services/activities/cycle.js

@@ -63,13 +63,18 @@ class Cycle extends activity_1.Activity {
      * pattern allows for retries without violating the DAG.
      */
     async cycleAncestorActivity(multi) {
+        //Cycle activity L1 is a standin for the target ancestor L1.
+        //Input data mapping (mapInputData) allows for the 
+        //next dimensonal thread to execute with different
+        //input data than the current dimensional thread
+        this.mapInputData();
         const streamData = {
             metadata: {
                 dad: collator_1.CollatorService.resolveReentryDimension(this),
                 jid: this.context.metadata.jid,
                 aid: this.config.ancestor,
             },
-            data: {} //todo: verify immutability, before enabling: `this.context.data`
+            data: this.context.data
         };
         return (await this.engine.streamSignaler?.publishMessage(null, streamData, multi));
     }

package/build/services/activities/trigger.js

@@ -6,7 +6,6 @@ const errors_1 = require("../../modules/errors");
 const utils_1 = require("../../modules/utils");
 const activity_1 = require("./activity");
 const collator_1 = require("../collator");
-const dimension_1 = require("../dimension");
 const pipe_1 = require("../pipe");
 const reporter_1 = require("../reporter");
 const serializer_1 = require("../serializer");
@@ -80,7 +79,7 @@ class Trigger extends activity_1.Activity {
         const jobKey = this.resolveJobKey(inputContext);
         const utc = (0, utils_1.formatISODate)(new Date());
         const { id, version } = await this.engine.getVID();
-        this.initDimensionalAddress(dimension_1.DimensionService.getSeed());
+        this.initDimensionalAddress(collator_1.CollatorService.getDimensionalSeed());
         const activityMetadata = {
             ...this.metadata,
             jid: jobId,
@@ -100,7 +99,7 @@ class Trigger extends activity_1.Activity {
                 trc: this.context.metadata.trc,
                 spn: this.context.metadata.spn,
                 jid: jobId,
-                dad: dimension_1.DimensionService.getSeed(),
+                dad: collator_1.CollatorService.getDimensionalSeed(),
                 key: jobKey,
                 jc: utc,
                 ju: utc,

package/build/services/collator/index.d.ts

@@ -69,5 +69,13 @@ declare class CollatorService {
      */
     static bindAncestorArray(graphs: HotMeshGraph[]): void;
     static isActivityComplete(status: number): boolean;
+    /**
+     * All activities exist on a dimensional plane. Zero
+     * is the default. A value of
+     * `AxY,0,0,0,0,1,0,0` would reflect that
+     * an ancestor activity was dimensionalized beyond
+     * the default.
+     */
+    static getDimensionalSeed(index?: number): string;
 }
 export { CollatorService };

package/build/services/collator/index.js

@@ -75,7 +75,7 @@ class CollatorService {
     static async notarizeCompletion(activity, multi) {
         //1) ALWAYS actualize leg2 dimension (+1)
         //2) IF the activity is used in a cycle, don't close leg 2!
-        const decrement = activity.config.cycle ? 0 : -1000000000000;
+        const decrement = activity.config.cycle ? 0 : 1000000000000;
         return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1 - decrement, this.getDimensionalAddress(activity), multi);
     }
     ;
@@ -218,6 +218,16 @@ class CollatorService {
     static isActivityComplete(status) {
         return (status - 0) <= 0;
     }
+    /**
+     * All activities exist on a dimensional plane. Zero
+     * is the default. A value of
+     * `AxY,0,0,0,0,1,0,0` would reflect that
+     * an ancestor activity was dimensionalized beyond
+     * the default.
+     */
+    static getDimensionalSeed(index = 0) {
+        return `,${index}`;
+    }
 }
 exports.CollatorService = CollatorService;
 //max int digit count that supports `hincrby`

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

@@ -1,3 +1,20 @@
-declare const getWorkflowYAML: (topic: string, version?: string) => string;
+/**
+ * 1) `maxSystemRetries` | can be 0 to 3 and represents milliseconds;
+ * if there is an error, the workflow will retry up to `maxSystemRetries` times
+ * delaying by 10, 100, and 1000ms; this is a system level retry
+ * and is not configurable. It exists to handle intermittent network
+ * errors. (NOTE: each retry spawns a new transition stream)
+ *
+ * 2) `backoffExponent` | can be any number and represents `seconds` when applied;
+ * retries will happen indefinitely and adhere to the
+ * exponential backoff algorithm by multiplying by `backoffExponent`.
+ * For example, if `backoffExponent` is 10, the workflow will retry
+ * in 10s, 100s, 1000s, 10000s, etc.
+ *
+ * EXAMPLE | Using `maxSystemRetries = 3` and `backoffExponent = 10`, errant
+ * workflows will be retried on the following schedule (8 times in 27 hours):
+ * => 10ms, 100ms, 1000ms, 10s, 100s, 1_000s, 10_000s, 100_000s
+ */
+declare const getWorkflowYAML: (topic: string, version?: string, maxSystemRetries?: number, backoffExponent?: number) => string;
 declare const getActivityYAML: (topic: string, version?: string) => string;
 export { getActivityYAML, getWorkflowYAML };

package/build/services/durable/factory.js

@@ -1,7 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getWorkflowYAML = exports.getActivityYAML = void 0;
-const getWorkflowYAML = (topic, version = '1') => {
+/**
+ * 1) `maxSystemRetries` | can be 0 to 3 and represents milliseconds;
+ * if there is an error, the workflow will retry up to `maxSystemRetries` times
+ * delaying by 10, 100, and 1000ms; this is a system level retry
+ * and is not configurable. It exists to handle intermittent network
+ * errors. (NOTE: each retry spawns a new transition stream)
+ *
+ * 2) `backoffExponent` | can be any number and represents `seconds` when applied;
+ * retries will happen indefinitely and adhere to the
+ * exponential backoff algorithm by multiplying by `backoffExponent`.
+ * For example, if `backoffExponent` is 10, the workflow will retry
+ * in 10s, 100s, 1000s, 10000s, etc.
+ *
+ * EXAMPLE | Using `maxSystemRetries = 3` and `backoffExponent = 10`, errant
+ * workflows will be retried on the following schedule (8 times in 27 hours):
+ * => 10ms, 100ms, 1000ms, 10s, 100s, 1_000s, 10_000s, 100_000s
+ */
+const getWorkflowYAML = (topic, version = '1', maxSystemRetries = 2, backoffExponent = 10) => {
     return `app:
   id: ${topic}
   version: '${version}'
@@ -33,10 +50,20 @@ const getWorkflowYAML = (topic, version = '1') => {
         a1:
           type: activity
           cycle: true
-  
+          output:
+            schema:
+              type: object
+              properties:
+                duration:
+                  type: number
+            maps:
+              duration: ${backoffExponent}
+
         w1:
           type: worker
           topic: ${topic}
+          retry:
+            '599': [${maxSystemRetries}]
           input:
             schema:
               type: object
@@ -58,18 +85,33 @@ const getWorkflowYAML = (topic, version = '1') => {
             maps:
               response: '{$self.output.data.response}'
 
+        a599:
+          title: Sleep before trying again
+          type: activity
+          sleep: "{a1.output.data.duration}"
+
         c1:
+          title: Goto Activity a1
           type: cycle
           ancestor: a1
+          input:
+            maps:
+              duration:
+                '@pipe':
+                  - ['{a1.output.data.duration}', ${backoffExponent}]
+                  - ['{@math.multiply}']
+
       transitions:
         t1:
           - to: a1
         a1:
           - to: w1
         w1:
-          - to: c1
+          - to: a599
             conditions:
-              code: 500
+              code: 599
+        a599:
+        - to: c1
 `;
 };
 exports.getWorkflowYAML = getWorkflowYAML;

package/build/services/durable/handle.js

@@ -10,22 +10,40 @@ class WorkflowHandleService {
     async result() {
         let status = await this.hotMesh.getStatus(this.workflowId);
         const topic = `${this.workflowTopic}.${this.workflowId}`;
-        if (status == 0) {
-            return (await this.hotMesh.getState(this.workflowTopic, this.workflowId)).data?.response;
-        }
         return new Promise((resolve, reject) => {
             let isResolved = false;
             //common fulfill/unsubscribe
-            const complete = async (response) => {
+            const complete = async (response, err) => {
                 if (isResolved)
                     return;
                 isResolved = true;
                 this.hotMesh.unsub(topic);
-                resolve(response || (await this.hotMesh.getState(this.workflowTopic, this.workflowId)).data?.response);
+                if (err) {
+                    return reject(JSON.parse(err));
+                }
+                else if (!response) {
+                    const state = await this.hotMesh.getState(this.workflowTopic, this.workflowId);
+                    if (!state.data && state.metadata.err) {
+                        return reject(JSON.parse(state.metadata.err));
+                    }
+                    response = state.data?.response;
+                }
+                resolve(response);
             };
-            this.hotMesh.sub(topic, async (topic, message) => {
-                await complete(message.data?.response);
+            //check for done
+            if (status == 0) {
+                return complete();
+            }
+            //subscribe to topic
+            this.hotMesh.sub(topic, async (topic, state) => {
+                if (!state.data && state.metadata.err) {
+                    await complete(null, state.metadata.err);
+                }
+                else {
+                    await complete(state.data?.response);
+                }
             });
+            //resolve for race condition
             setTimeout(async () => {
                 status = await this.hotMesh.getStatus(this.workflowId);
                 if (status == 0) {

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

@@ -1,13 +1,13 @@
 import { HotMeshService as HotMesh } from '../hotmesh';
-import { Connection, Registry, WorkerConfig } from "../../types/durable";
+import { Connection, Registry, WorkerConfig, WorkerOptions } 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>;
+    static getHotMesh: (worflowTopic: string, options?: WorkerOptions) => Promise<HotMesh>;
+    static activateWorkflow(hotMesh: HotMesh, topic: string, dagFactory: Function, options?: WorkerOptions): Promise<void>;
     /**
      * The `worker` calls `registerActivities` immediately BEFORE
      * dynamically importing the user's workflow module. That file

package/build/services/durable/worker.js

@@ -6,6 +6,7 @@ const asyncLocalStorage_1 = require("./asyncLocalStorage");
 const hotmesh_1 = require("../hotmesh");
 const stream_1 = require("../../types/stream");
 const factory_1 = require("./factory");
+const errors_1 = require("../../modules/errors");
 /*
 Here is an example of how the methods in this file are used:
 
@@ -39,13 +40,13 @@ run().catch((err) => {
 });
 */
 class WorkerService {
-    static async activateWorkflow(hotMesh, topic, factory) {
+    static async activateWorkflow(hotMesh, topic, dagFactory, options = {}) {
         const version = '1';
         const app = await hotMesh.engine.store.getApp(topic);
         const appVersion = app?.version;
         if (!appVersion) {
             try {
-                await hotMesh.deploy(factory(topic, version));
+                await hotMesh.deploy(dagFactory(topic, version, options.maxSystemRetries, options.backoffExponent));
                 await hotMesh.activate(version);
             }
             catch (err) {
@@ -99,7 +100,7 @@ class WorkerService {
         worker.activityRunner = await worker.initActivityWorkflow(config, activityTopic);
         await WorkerService.activateWorkflow(worker.activityRunner, activityTopic, factory_1.getActivityYAML);
         worker.workflowRunner = await worker.initWorkerWorkflow(config, workflowTopic, workflowFunction);
-        await WorkerService.activateWorkflow(worker.workflowRunner, workflowTopic, factory_1.getWorkflowYAML);
+        await WorkerService.activateWorkflow(worker.workflowRunner, workflowTopic, factory_1.getWorkflowYAML, config.options);
         return worker;
     }
     static resolveWorkflowTarget(workflow) {
@@ -151,12 +152,16 @@ class WorkerService {
             }
             catch (err) {
                 this.activityRunner.engine.logger.error('durable-worker-activity-err', err);
+                if (!(err instanceof errors_1.DurableTimeoutError) &&
+                    !(err instanceof errors_1.DurableMaxedError) &&
+                    !(err instanceof errors_1.DurableFatalError)) {
+                    err = new errors_1.DurableRetryError(err.message);
+                }
                 return {
                     status: stream_1.StreamStatus.ERROR,
-                    code: 500,
-                    message: err.message,
+                    code: err.code,
                     metadata: { ...data.metadata },
-                    data: { error: err }
+                    data: { message: err.message }
                 };
             }
         };
@@ -227,11 +232,12 @@ class WorkerService {
                 };
             }
             catch (err) {
+                // 59* - Durable*Error
                 return {
                     status: stream_1.StreamStatus.ERROR,
-                    code: 500,
+                    code: err.code || new errors_1.DurableRetryError(err.message).code,
                     metadata: { ...data.metadata },
-                    data: { error: err }
+                    data: { message: err.message, type: err.name }
                 };
             }
         };
@@ -246,7 +252,7 @@ class WorkerService {
 _a = WorkerService;
 WorkerService.activityRegistry = {}; //user's activities
 WorkerService.instances = new Map();
-WorkerService.getHotMesh = async (worflowTopic) => {
+WorkerService.getHotMesh = async (worflowTopic, options) => {
     if (WorkerService.instances.has(worflowTopic)) {
         return await WorkerService.instances.get(worflowTopic);
     }
@@ -255,7 +261,7 @@ WorkerService.getHotMesh = async (worflowTopic) => {
         engine: { redis: { ...WorkerService.connection } }
     });
     WorkerService.instances.set(worflowTopic, hotMesh);
-    await WorkerService.activateWorkflow(await hotMesh, worflowTopic, factory_1.getWorkflowYAML);
+    await WorkerService.activateWorkflow(await hotMesh, worflowTopic, factory_1.getWorkflowYAML, options);
     return hotMesh;
 };
 WorkerService.Context = {

package/build/services/durable/workflow.js

@@ -62,7 +62,7 @@ class WorkflowService {
         const client = new client_1.ClientService({
             connection: await connection_1.ConnectionService.connect(worker_1.WorkerService.connection),
         });
-        //todo: should I allow-cross/app callback (pj:'@DURABLE@hello-world@<pjid>'/pa: <paid>/pd: <pdad>)
+        //todo: allow cross/app callback (pj:'@DURABLE@hello-world@<pjid>'/pa: <paid>/pd: <pdad>)
         const handle = await client.workflow.start({
             ...options,
             workflowId: `${workflowId}${options.workflowId}`,

package/build/services/pipe/functions/math.d.ts

@@ -1,4 +1,8 @@
 declare class MathHandler {
+    add(...operands: (number | number[])[]): number;
+    subtract(...operands: (number | number[])[]): number;
+    multiply(...operands: (number | number[])[]): number;
+    divide(...operands: (number | number[])[]): number;
     abs(x: number): number;
     acos(x: number): number;
     acosh(x: number): number;

package/build/services/pipe/functions/math.js

@@ -2,6 +2,79 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MathHandler = void 0;
 class MathHandler {
+    add(...operands) {
+        // @ts-ignore
+        return operands.reduce((a, b) => {
+            if (Array.isArray(b)) {
+                return a + this.add(...b);
+            }
+            else {
+                return a + b;
+            }
+        }, 0);
+    }
+    subtract(...operands) {
+        if (operands.length === 0) {
+            throw new Error('At least one operand is required.');
+        }
+        let flatOperands = [];
+        operands.forEach((op) => {
+            if (Array.isArray(op)) {
+                flatOperands = [...flatOperands, ...op];
+            }
+            else {
+                flatOperands.push(op);
+            }
+        });
+        if (flatOperands.length === 0) {
+            throw new Error('At least one operand is required after flattening.');
+        }
+        const result = flatOperands.reduce((a, b, i) => {
+            return i === 0 ? a : a - b;
+        });
+        return result;
+    }
+    multiply(...operands) {
+        if (operands.length === 0) {
+            throw new Error('At least one operand is required.');
+        }
+        // @ts-ignore
+        return operands.reduce((a, b) => {
+            if (Array.isArray(b)) {
+                return a * this.multiply(...b);
+            }
+            else {
+                return a * b;
+            }
+        }, 1);
+    }
+    divide(...operands) {
+        if (operands.length === 0) {
+            throw new Error('At least one operand is required.');
+        }
+        let flatOperands = [];
+        operands.forEach((op) => {
+            if (Array.isArray(op)) {
+                flatOperands = [...flatOperands, ...op];
+            }
+            else {
+                flatOperands.push(op);
+            }
+        });
+        if (flatOperands.length === 0) {
+            throw new Error('At least one operand is required after flattening.');
+        }
+        const result = flatOperands.reduce((a, b, i) => {
+            if (b === 0) {
+                return NaN;
+            }
+            return i === 0 ? a : a / b;
+        });
+        if (isNaN(result)) {
+            return NaN;
+        }
+        return result;
+    }
     abs(x) {
         return Math.abs(x);
     }

package/build/services/pipe/functions/number.d.ts

@@ -17,9 +17,5 @@ declare class NumberHandler {
     min(...values: number[]): number;
     pow(base: number, exponent: number): number;
     round(input: number): number;
-    add(...operands: (number | number[])[]): number;
-    subtract(...operands: (number | number[])[]): number;
-    multiply(...operands: (number | number[])[]): number;
-    divide(...operands: (number | number[])[]): number;
 }
 export { NumberHandler };