chore: add control exceptions

Author: inca

src/nodes/Array.FindWhere.ts

@@ -15,7 +15,7 @@ type R = unknown;
 
 export const module: ModuleDefinition<P, R> = {
     moduleName: 'Array / Find Where',
-    version: '1.1.1',
+    version: '1.1.2',
     description: `
         Returns items from the array that match specified conditions.
     `,

src/nodes/Flow.Catch.ts

@@ -10,7 +10,7 @@ type R = Promise<{
 }>;
 
 export const module: ModuleDefinition<P, R> = {
-    version: '1.1.1',
+    version: '1.1.2',
     moduleName: 'Flow / Catch',
     description: `
         Computes the value and catches the error it produces.

src/nodes/Flow.Continue.ts

@@ -0,0 +1,53 @@
+import { SYM_SKIPPED } from '@nodescript/core/runtime';
+import { ModuleCompute, ModuleDefinition } from '@nodescript/core/types';
+
+type P = {
+    value: unknown;
+    skipped: unknown;
+    token: string;
+};
+
+type R = Promise<unknown>;
+
+export const module: ModuleDefinition<P, R> = {
+    version: '1.0.1',
+    moduleName: 'Flow / Continue',
+    description: `
+        Evaluates and returns "skipped" if the evaluation of "value"
+        was previously skipped with Flow / Skip.
+        Otherwise, returns "value" and does not evaluate "skipped".
+        If "token" is set, it must match the "token" used on Flow / Skip.
+    `,
+    params: {
+        value: {
+            deferred: true,
+            schema: { type: 'any' },
+        },
+        skipped: {
+            deferred: true,
+            schema: { type: 'any' },
+        },
+        token: {
+            schema: { type: 'string', default: '' },
+            advanced: true,
+        },
+    },
+    result: {
+        async: true,
+        schema: { type: 'any' },
+    }
+};
+
+export const compute: ModuleCompute<P, R> = async (params, ctx) => {
+    const { value, skipped, token } = params;
+    try {
+        return await ctx.resolveDeferred(value);
+    } catch (error: any) {
+        if (error && error[SYM_SKIPPED]) {
+            if (token === '' || error.token === token) {
+                return await ctx.resolveDeferred(skipped);
+            }
+        }
+        throw error;
+    }
+};

src/nodes/Flow.Skip.ts

@@ -0,0 +1,54 @@
+import { ModuleCompute, ModuleDefinition } from '@nodescript/core/types';
+
+type P = {
+    condition: boolean;
+    value: unknown;
+    token: string;
+    message: string;
+    status: number;
+};
+
+type R = Promise<unknown>;
+
+export const module: ModuleDefinition<P, R> = {
+    version: '1.0.1',
+    moduleName: 'Flow / Skip',
+    description: `
+    Skips the evaluation if condition is true, otherwise returns the value.
+    Skipped evaluation results in a control exception (by default with 204 status).
+    The flow can subsequently be resumed with Flow / Continue.
+    `,
+    params: {
+        condition: {
+            schema: { type: 'boolean' },
+        },
+        value: {
+            schema: { type: 'any' },
+            deferred: true,
+        },
+        token: {
+            schema: { type: 'string', default: '' },
+            advanced: true,
+        },
+        message: {
+            schema: { type: 'string', default: 'Evaluation skipped' },
+            advanced: true,
+        },
+        status: {
+            schema: { type: 'number', default: 204 },
+            advanced: true,
+        },
+    },
+    result: {
+        async: true,
+        schema: { type: 'any' },
+    }
+};
+
+export const compute: ModuleCompute<P, R> = async (params, ctx) => {
+    const { condition, value, token, message, status } = params;
+    if (condition) {
+        return ctx.skipEvaluation(message, token, status);
+    }
+    return await ctx.resolveDeferred(value);
+};

src/nodes/Flow.Try.ts

@@ -7,7 +7,7 @@ type P = {
 type R = Promise<unknown>;
 
 export const module: ModuleDefinition<P, R> = {
-    version: '1.2.0',
+    version: '1.2.1',
     moduleName: 'Flow / Try',
     description: `Runs the steps one-by-one and returns the first result that doesn't throw an error.`,
     params: {