@webda/workflow 0.0.0-stage → 4.0.0-beta.13

package/LICENSE

@@ -0,0 +1,166 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
+

package/README.md

@@ -1,3 +1,55 @@
-# Temporary Holding Version
+# @webda/workflow module
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+This module is part of Webda Application Framework that allows you to quickly develop applications with all modern prerequisites: Security, Extensibility, GraphQL, REST, CloudNative [https://webda.io](https://webda.io)
+
+<img src="https://webda.io/img/webda.svg" width="128" />
+
+<!-- README_HEADER -->
+
+> Durable workflows for Webda: a flow is a sequence of operations with control flow, that survives restarts, retries its tasks, sleeps and runs each step as the user who launched it.
+
+## Install
+
+```bash
+pnpm add @webda/workflow
+```
+
+## Usage
+
+```json
+{
+  "services": {
+    "WorkflowService": {
+      "type": "Webda/WorkflowService"
+    }
+  }
+}
+```
+
+```ts
+useService<WorkflowService>("WorkflowService").registerFlow({
+  id: "Orders.Process",
+  version: "",
+  params: ["uuid"],
+  input: { type: "object", properties: { uuid: { type: "string" } } },
+  body: [
+    {
+      kind: "task",
+      id: "process/Orders.Capture",
+      operation: "Orders.Capture",
+      input: { obj: { uuid: { var: "uuid" } } },
+      options: { retries: 3 }
+    },
+    { kind: "task", id: "process/Workflow.Sleep", operation: "Workflow.Sleep", input: { lit: { duration: "1d" } } },
+    { kind: "task", id: "process/Orders.Remind", operation: "Orders.Remind", input: { obj: { uuid: { var: "uuid" } } } }
+  ],
+  source: "code"
+});
+// The operation Orders.Process launches it and returns { uuid } of the WorkflowInstance
+```
+
+See the [documentation](https://docs.webda.io/pages/Modules/workflow/README) for the graph format, the built-in
+operations, the task options and the engine parameters.
+
+Operations run by a workflow should observe `useAbortSignal()` (aborted on timeout, lost lease and stop) to stop
+early. An attempt that keeps running is ignored and the task may run again: operations are assumed to be idempotent.

package/lib/authoring.d.ts

@@ -0,0 +1,112 @@
+/**
+ * The authoring API of `.flow.ts` files
+ *
+ * A flow is an `async` method of a class extending {@link Workflow}, in a file ending with `.flow.ts`. Its body is
+ * never executed: the build compiles it into a workflow graph that {@link WorkflowService} runs. Everything here is
+ * a typed stub that throws if it is ever called.
+ *
+ * Operations are called as `<ServiceClass>.<Method>(input, options?)` and other flows as
+ * `<FlowClass>.<Method>(input, options?)`: `@webda/content-mapper` declares those calls in each `.flow.ts` file.
+ */
+import type { TaskOptions } from "./graph.js";
+export type { TaskOptions };
+declare global {
+    interface DateConstructor {
+        /**
+         * Current time in milliseconds, recorded by the flow: a retry or a resume reads the recorded value
+         *
+         * Only available in a `.flow.ts` flow.
+         */
+        Now(): Promise<number>;
+    }
+}
+/**
+ * Base class of the flow classes of a `.flow.ts` file: each `async` method is a flow `<Class>.<Method>`
+ */
+export declare abstract class Workflow {
+    /**
+     * Flow classes are never instantiated
+     */
+    constructor();
+    /**
+     * Run a body for each item concurrently (a `map` statement)
+     * @param _items - the items
+     * @param _fn - a single call, or an async block, run for each item
+     * @param _options - options
+     * @param _options.concurrency - maximum number of items running at once
+     * @returns the value of each item, in order
+     */
+    static Parallel<T, R>(_items: T[], _fn: (item: T) => Promise<R>, _options?: {
+        concurrency?: number;
+    }): Promise<R[]>;
+    /**
+     * Start a child flow without waiting for it
+     * @param _flow - the child flow, as `OtherFlows.Method`
+     * @param _input - its input
+     * @returns the uuid of the child instance
+     */
+    static Start<I>(_flow: (input: I, options?: TaskOptions) => Promise<any>, _input: I): Promise<{
+        uuid: string;
+    }>;
+    /**
+     * Call any operation by id, untyped: model operations (`Order.Query`) or operations of other packages
+     * @param _operationId - the operation id, a string literal
+     * @param _input - its input
+     * @param _options - task options
+     * @returns the operation result
+     */
+    static Call<R = any>(_operationId: string, _input?: Record<string, any>, _options?: TaskOptions): Promise<R>;
+}
+/**
+ * Wait for a duration (`"1h"`) or until a time (`{ until: timestamp }`)
+ * @param _duration - the duration, or the end time
+ * @returns when the timer fires
+ */
+export declare function Sleep(_duration: string | {
+    until: number;
+}): Promise<void>;
+/**
+ * Signals
+ */
+export declare const Wait: {
+    /**
+     * Wait for the signal `name` sent with `key` (`Workflow.Signal`): its payload is the result
+     * @param _name - the event name
+     * @param _options - options
+     * @param _options.key - key to match
+     * @param _options.timeout - Duration after which the wait throws
+     * @param _options.allow - user ids that may send it besides the launcher
+     * @returns the signal payload
+     */
+    ForEvent<T = any>(_name: string, _options: {
+        key: string;
+        timeout?: string;
+        allow?: string[];
+    }): Promise<T>;
+};
+/**
+ * Random values, recorded by the flow
+ */
+export declare const Random: {
+    /**
+     * A number in [0, 1)
+     * @returns the number
+     */
+    Number(): Promise<number>;
+    /**
+     * A UUID
+     * @returns the uuid
+     */
+    Uuid(): Promise<string>;
+};
+/**
+ * Launch a flow on a schedule, read by the build: every argument must be a literal
+ *
+ * Several are allowed. The launch runs as the system.
+ * @param _cron - cron expression
+ * @param _description - description
+ * @param _input - the flow input
+ * @returns a decorator that changes nothing
+ */
+export declare function Cron(_cron: string, _description?: string, _input?: Record<string, any>): <T>(value: T, _context: ClassMethodDecoratorContext<Workflow>) => T;
+//# sourceMappingURL=authoring.d.ts.map

package/lib/authoring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authoring.d.ts","sources":["../src/authoring.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,YAAY,EAAE,WAAW,EAAE,CAAC;AAa5B,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,eAAe;QACvB;;;;WAIG;QACH,GAAG,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;KACxB;CACF;AAED;;GAEG;AACH,8BAAsB,QAAQ;IAC5B;;OAEG;IACH,cAEC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAElH;IAED;;;;;OAKG;IACH,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAE9G;IAED;;;;;;OAMG;IACH,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,QAAQ,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC,CAE3G;CACF;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAE1E;AAED;;GAEG;AACH,eAAO,MAAM,IAAI;IACf;;;;;;;;OAQG;IACH,QAAQ,CAAC,CAAC,GAAG,GAAG,SAAS,MAAM,YAAY;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,OAAO,CAAC,CAAC,CAAC;CAG5G,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,MAAM;IACjB;;;OAGG;IACH,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC;IAGzB;;;OAGG;IACH,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;CAGxB,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,IAC7E,CAAC,SAAS,CAAC,YAAY,2BAA2B,CAAC,QAAQ,CAAC,KAAG,CAAC,CACzE"}

package/lib/authoring.js

@@ -0,0 +1,107 @@
+/** Message of every stub. */
+const NOT_EXECUTABLE = "Flows run through WorkflowService";
+/**
+ * Throw: a flow body is compiled, never executed
+ * @returns never
+ */
+function notExecutable() {
+    throw new Error(NOT_EXECUTABLE);
+}
+/**
+ * Base class of the flow classes of a `.flow.ts` file: each `async` method is a flow `<Class>.<Method>`
+ */
+export class Workflow {
+    /**
+     * Flow classes are never instantiated
+     */
+    constructor() {
+        notExecutable();
+    }
+    /**
+     * Run a body for each item concurrently (a `map` statement)
+     * @param _items - the items
+     * @param _fn - a single call, or an async block, run for each item
+     * @param _options - options
+     * @param _options.concurrency - maximum number of items running at once
+     * @returns the value of each item, in order
+     */
+    static Parallel(_items, _fn, _options) {
+        return notExecutable();
+    }
+    /**
+     * Start a child flow without waiting for it
+     * @param _flow - the child flow, as `OtherFlows.Method`
+     * @param _input - its input
+     * @returns the uuid of the child instance
+     */
+    static Start(_flow, _input) {
+        return notExecutable();
+    }
+    /**
+     * Call any operation by id, untyped: model operations (`Order.Query`) or operations of other packages
+     * @param _operationId - the operation id, a string literal
+     * @param _input - its input
+     * @param _options - task options
+     * @returns the operation result
+     */
+    static Call(_operationId, _input, _options) {
+        return notExecutable();
+    }
+}
+/**
+ * Wait for a duration (`"1h"`) or until a time (`{ until: timestamp }`)
+ * @param _duration - the duration, or the end time
+ * @returns when the timer fires
+ */
+export function Sleep(_duration) {
+    return notExecutable();
+}
+/**
+ * Signals
+ */
+export const Wait = {
+    /**
+     * Wait for the signal `name` sent with `key` (`Workflow.Signal`): its payload is the result
+     * @param _name - the event name
+     * @param _options - options
+     * @param _options.key - key to match
+     * @param _options.timeout - Duration after which the wait throws
+     * @param _options.allow - user ids that may send it besides the launcher
+     * @returns the signal payload
+     */
+    ForEvent(_name, _options) {
+        return notExecutable();
+    }
+};
+/**
+ * Random values, recorded by the flow
+ */
+export const Random = {
+    /**
+     * A number in [0, 1)
+     * @returns the number
+     */
+    Number() {
+        return notExecutable();
+    },
+    /**
+     * A UUID
+     * @returns the uuid
+     */
+    Uuid() {
+        return notExecutable();
+    }
+};
+/**
+ * Launch a flow on a schedule, read by the build: every argument must be a literal
+ *
+ * Several are allowed. The launch runs as the system.
+ * @param _cron - cron expression
+ * @param _description - description
+ * @param _input - the flow input
+ * @returns a decorator that changes nothing
+ */
+export function Cron(_cron, _description, _input) {
+    return (value, _context) => value;
+}
+//# sourceMappingURL=authoring.js.map

package/lib/authoring.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"authoring.js","sources":["../src/authoring.ts"],"names":[],"mappings":"AAcA,6BAA6B;AAC7B,MAAM,cAAc,GAAG,mCAAmC,CAAC;AAE3D;;;GAGG;AACH,SAAS,aAAa;IACpB,MAAM,IAAI,KAAK,CAAC,cAAc,CAAC,CAAC;AAClC,CAAC;AAaD;;GAEG;AACH,MAAM,OAAgB,QAAQ;IAC5B;;OAEG;IACH;QACE,aAAa,EAAE,CAAC;IAClB,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,QAAQ,CAAO,MAAW,EAAE,GAA4B,EAAE,QAAmC;QAClG,OAAO,aAAa,EAAE,CAAC;IACzB,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,KAAK,CAAI,KAAwD,EAAE,MAAS;QACjF,OAAO,aAAa,EAAE,CAAC;IACzB,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,IAAI,CAAU,YAAoB,EAAE,MAA4B,EAAE,QAAsB;QAC7F,OAAO,aAAa,EAAE,CAAC;IACzB,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,UAAU,KAAK,CAAC,SAAqC;IACzD,OAAO,aAAa,EAAE,CAAC;AACzB,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG;IAClB;;;;;;;;OAQG;IACH,QAAQ,CAAU,KAAa,EAAE,QAA6D;QAC5F,OAAO,aAAa,EAAE,CAAC;IACzB,CAAC;CACF,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB;;;OAGG;IACH,MAAM;QACJ,OAAO,aAAa,EAAE,CAAC;IACzB,CAAC;IACD;;;OAGG;IACH,IAAI;QACF,OAAO,aAAa,EAAE,CAAC;IACzB,CAAC;CACF,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,UAAU,IAAI,CAAC,KAAa,EAAE,YAAqB,EAAE,MAA4B;IACrF,OAAO,CAAI,KAAQ,EAAE,QAA+C,EAAK,EAAE,CAAC,KAAK,CAAC;AACpF,CAAC"}

package/lib/expression.d.ts

@@ -0,0 +1,21 @@
+import { type Expr } from "./graph.js";
+/** Maximum length of a string produced by a flow expression */
+export declare const MAX_EXPR_STRING_LENGTH = 1048576;
+/**
+ * Evaluate a flow expression
+ *
+ * Pure: it reads `scope` and never changes it.
+ * @param expr - the expression
+ * @param scope - the variables
+ * @returns the value
+ * @throws Error on an invalid expression node
+ */
+export declare function evaluate(expr: Expr, scope: Record<string, any>): any;
+/**
+ * Validate an expression tree, as received from an untrusted source (a stored workflow)
+ * @param expr - the candidate expression
+ * @param path - path of this node, `$` for the root
+ * @returns the paths of the invalid nodes, empty when the expression is valid
+ */
+export declare function validateExpr(expr: unknown, path?: string): string[];
+//# sourceMappingURL=expression.d.ts.map

package/lib/expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression.d.ts","sources":["../src/expression.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,KAAK,IAAI,EAAE,MAAM,YAAY,CAAC;AAElE,+DAA+D;AAC/D,eAAO,MAAM,sBAAsB,UAAY,CAAC;AAkEhD;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,CAkEpE;AAWD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,GAAE,MAAY,GAAG,MAAM,EAAE,CA4CxE"}

package/lib/expression.js

@@ -0,0 +1,196 @@
+import { BINARY_OPS } from "./graph.js";
+/** Maximum length of a string produced by a flow expression */
+export const MAX_EXPR_STRING_LENGTH = 1_048_576;
+/** Object keys that must never be set on evaluated objects */
+const FORBIDDEN_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+/**
+ * Read a member of a value: own properties only, so an expression never reaches a prototype
+ * @param target - the object, array or string
+ * @param key - the member name or index
+ * @returns the member, undefined when the target is null/undefined or has no such own member
+ */
+function member(target, key) {
+    if (target === null || target === undefined) {
+        return undefined;
+    }
+    const name = typeof key === "number" ? key : String(key);
+    return Object.hasOwn(Object(target), name) ? target[name] : undefined;
+}
+/**
+ * Apply a binary operator to evaluated operands (the short-circuit ones are handled by the caller)
+ * @param op - the operator
+ * @param a - left value
+ * @param b - right value
+ * @returns the result
+ */
+function binary(op, a, b) {
+    switch (op) {
+        case "==":
+            return a == b;
+        case "!=":
+            return a != b;
+        case "===":
+            return a === b;
+        case "!==":
+            return a !== b;
+        case "<":
+            return a < b;
+        case "<=":
+            return a <= b;
+        case ">":
+            return a > b;
+        case ">=":
+            return a >= b;
+        case "+": {
+            if (typeof a === "string" || typeof b === "string") {
+                const left = String(a);
+                const right = String(b);
+                if (left.length + right.length > MAX_EXPR_STRING_LENGTH) {
+                    throw new Error("Expression string length limit exceeded");
+                }
+                return left + right;
+            }
+            return a + b;
+        }
+        case "-":
+            return a - b;
+        case "*":
+            return a * b;
+        case "/":
+            return a / b;
+        case "%":
+            return a % b;
+    }
+    throw new Error(`Invalid expression operator ${op}`);
+}
+/**
+ * Evaluate a flow expression
+ *
+ * Pure: it reads `scope` and never changes it.
+ * @param expr - the expression
+ * @param scope - the variables
+ * @returns the value
+ * @throws Error on an invalid expression node
+ */
+export function evaluate(expr, scope) {
+    const e = expr;
+    if (e === null || typeof e !== "object") {
+        throw new Error(`Invalid expression ${JSON.stringify(e)}`);
+    }
+    if ("lit" in e) {
+        return e.lit;
+    }
+    if ("var" in e) {
+        return Object.hasOwn(scope, e.var) ? scope[e.var] : undefined;
+    }
+    if ("get" in e) {
+        return member(evaluate(e.get[0], scope), evaluate(e.get[1], scope));
+    }
+    if ("op" in e) {
+        const [left, right] = e.args;
+        const a = evaluate(left, scope);
+        switch (e.op) {
+            case "&&":
+                return a ? evaluate(right, scope) : a;
+            case "||":
+                return a ? a : evaluate(right, scope);
+            case "??":
+                return a ?? evaluate(right, scope);
+        }
+        return binary(e.op, a, evaluate(right, scope));
+    }
+    if ("not" in e) {
+        return !evaluate(e.not, scope);
+    }
+    if ("neg" in e) {
+        return -evaluate(e.neg, scope);
+    }
+    if ("cond" in e) {
+        return evaluate(e.cond[0], scope) ? evaluate(e.cond[1], scope) : evaluate(e.cond[2], scope);
+    }
+    if ("obj" in e) {
+        const res = {};
+        for (const [key, value] of Object.entries(e.obj)) {
+            if (FORBIDDEN_KEYS.has(key)) {
+                throw new Error(`Forbidden object key ${key}`);
+            }
+            Object.defineProperty(res, key, {
+                value: evaluate(value, scope),
+                enumerable: true,
+                configurable: true,
+                writable: true
+            });
+        }
+        return res;
+    }
+    if ("arr" in e) {
+        return e.arr.map(item => evaluate(item, scope));
+    }
+    if ("tpl" in e) {
+        let out = "";
+        for (const part of e.tpl) {
+            const piece = typeof part === "string" ? part : String(evaluate(part, scope));
+            if (out.length + piece.length > MAX_EXPR_STRING_LENGTH) {
+                throw new Error("Expression string length limit exceeded");
+            }
+            out += piece;
+        }
+        return out;
+    }
+    throw new Error(`Invalid expression ${JSON.stringify(e)}`);
+}
+/**
+ * Whether a value is a plain object (not an array, not null)
+ * @param value - the value
+ * @returns true for an object
+ */
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/**
+ * Validate an expression tree, as received from an untrusted source (a stored workflow)
+ * @param expr - the candidate expression
+ * @param path - path of this node, `$` for the root
+ * @returns the paths of the invalid nodes, empty when the expression is valid
+ */
+export function validateExpr(expr, path = "$") {
+    if (!isObject(expr)) {
+        return [path];
+    }
+    const keys = Object.keys(expr);
+    const tuple = (key, length) => Array.isArray(expr[key]) && expr[key].length === length
+        ? expr[key].flatMap((item, i) => validateExpr(item, `${path}.${key}[${i}]`))
+        : [path];
+    if (keys.length === 2 && keys.includes("op") && keys.includes("args")) {
+        return BINARY_OPS.includes(expr.op) ? tuple("args", 2) : [path];
+    }
+    if (keys.length !== 1) {
+        return [path];
+    }
+    const value = expr[keys[0]];
+    switch (keys[0]) {
+        case "lit":
+            return [];
+        case "var":
+            return typeof value === "string" ? [] : [path];
+        case "get":
+            return tuple("get", 2);
+        case "not":
+        case "neg":
+            return validateExpr(value, `${path}.${keys[0]}`);
+        case "cond":
+            return tuple("cond", 3);
+        case "obj":
+            return isObject(value)
+                ? Object.entries(value).flatMap(([k, v]) => FORBIDDEN_KEYS.has(k) ? [`${path}.obj.${k}`] : validateExpr(v, `${path}.obj.${k}`))
+                : [path];
+        case "arr":
+            return Array.isArray(value) ? value.flatMap((v, i) => validateExpr(v, `${path}.arr[${i}]`)) : [path];
+        case "tpl":
+            return Array.isArray(value)
+                ? value.flatMap((v, i) => typeof v === "string" ? [] : isObject(v) ? validateExpr(v, `${path}.tpl[${i}]`) : [`${path}.tpl[${i}]`])
+                : [path];
+    }
+    return [path];
+}
+//# sourceMappingURL=expression.js.map