@rytass/bpm-core-nestjs-module 0.18.1 → 0.20.0

package/src/lib/condition/adapters/cel-legacy.adapter.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.celLegacyAdapter = exports.createCelLegacyAdapter = exports.readCelLegacyFunctions = void 0;
+exports.loadCelEngine = loadCelEngine;
+exports.parseCelLegacy = parseCelLegacy;
+const expression_function_registry_1 = require("../../expression-function/expression-function.registry");
+const expression_engine_failure_1 = require("../expression-engine-failure");
+const expression_function_invocation_1 = require("../expression-function-invocation");
+let celEngine = null;
+/**
+ * Loads `cel-js` on first use rather than when this module is imported.
+ *
+ * `cel-js` is ESM-only and its `chevrotain` dependency ships an exports map
+ * that `jest-resolve` cannot follow. While the import sat at the top of this
+ * file, the package root pulled it in through
+ * `index → bpm-root → delegation → condition`, so *any* consumer test that
+ * imported anything from `@rytass/bpm-core-nestjs-module` failed to load with
+ * `Cannot find module 'chevrotain'` — pointing deep into `node_modules`, far
+ * from the code under test. Hosts had to stub `cel-js` before they could write
+ * a single test.
+ *
+ * Deferring the load means a host that never evaluates a CEL expression never
+ * resolves the package at all. `require` (not `await import`) keeps every
+ * caller in this file synchronous.
+ *
+ * The engine is loaded before a budget starts, so an interrupt can never land
+ * halfway through loading a module.
+ */
+function loadCelEngine() {
+    if (celEngine === null) {
+        try {
+            celEngine = require('cel-js');
+        }
+        catch (error) {
+            // Deferring the load also defers this failure: it used to surface at
+            // boot as a bare ERR_REQUIRE_ESM, and would now surface as a 500 on
+            // whichever request first evaluated a condition. Name the cause where it
+            // is thrown.
+            if (isRequireEsmError(error)) {
+                throw new Error(`[@rytass/bpm-core-nestjs-module] This Node version cannot require the ESM-only 'cel-js'. BPM needs Node >=20.19 or >=22.12 to evaluate CEL conditions. Original error: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            throw error;
+        }
+    }
+    return celEngine;
+}
+function isRequireEsmError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        error.code === 'ERR_REQUIRE_ESM');
+}
+/**
+ * Parses with `cel-js`. Returns `null` when the expression does not parse.
+ *
+ * `cel-js` can throw instead of reporting failure: a deeply nested expression
+ * (about 200 levels, still under the length limit) overflows the parser's stack
+ * with a bare `RangeError`. That is a syntax refusal, not a crash, so it maps to
+ * `null`. The engine is loaded outside the `try`: a failure to load it is a
+ * configuration error and must not be reported as a bad expression.
+ */
+function parseCelLegacy(expression) {
+    const engine = loadCelEngine();
+    let parseResult;
+    try {
+        parseResult = engine.parse(expression);
+    }
+    catch {
+        return null;
+    }
+    return parseResult.isSuccess ? { native: parseResult.cst } : null;
+}
+const isCstNode = (value) => typeof value === 'object' &&
+    value !== null &&
+    typeof value.name === 'string' &&
+    typeof value.children === 'object' &&
+    value.children !== null;
+const readTokenImage = (token) => typeof token === 'object' &&
+    token !== null &&
+    typeof token.image === 'string'
+    ? token.image
+    : null;
+/**
+ * Names of the global functions a `cel-js` CST calls: its `macrosExpression`
+ * nodes, which is where `cel-js` looks a global call up in the function table.
+ * Anything that is not a CST node yields nothing, so the jest shim's stand-in
+ * CST simply has no calls.
+ */
+const readCalledFunctionNames = (node) => {
+    if (!isCstNode(node)) {
+        return [];
+    }
+    const identifier = node.name === 'macrosExpression'
+        ? readTokenImage(node.children.Identifier?.[0])
+        : null;
+    return [
+        ...(identifier === null ? [] : [identifier]),
+        ...Object.values(node.children).flatMap((children) => children.flatMap(readCalledFunctionNames)),
+    ];
+};
+const celLegacyFunctionTables = new WeakMap();
+/**
+ * The function table handed to `cel-js` for a registry, built once: every
+ * function the registry lists, wrapped for cel-legacy. Verified on the real
+ * engine (2026-11-07): `cel-js` 0.8.2 accepts the table and calls it.
+ *
+ * Exported so `ConditionService.prepareEngine` can build it before a budget
+ * starts; otherwise the first evaluation builds it inside its budget.
+ */
+const readCelLegacyFunctions = (registry) => {
+    const cached = celLegacyFunctionTables.get(registry);
+    if (cached) {
+        return cached;
+    }
+    const functions = Object.freeze(Object.fromEntries((0, expression_function_invocation_1.readExpressionFunctionTable)(registry).functions.map((fn) => [
+        fn.name,
+        (0, expression_function_invocation_1.createExpressionFunctionInvoker)(fn, 'cel-legacy'),
+    ])));
+    celLegacyFunctionTables.set(registry, functions);
+    return functions;
+};
+exports.readCelLegacyFunctions = readCelLegacyFunctions;
+/**
+ * The cel-legacy adapter for a registry. A host function the registry no
+ * longer has fails the evaluation with `EXPRESSION_FUNCTION_FAILED` before the
+ * engine runs; any other unknown name keeps `cel-js`'s own error.
+ */
+const createCelLegacyAdapter = (registry) => ({
+    compile: parseCelLegacy,
+    evaluate: (handle, roots) => {
+        if ((0, expression_function_invocation_1.callsUnavailableFunction)(readCalledFunctionNames(handle.native), (0, expression_function_invocation_1.readExpressionFunctionTable)(registry))) {
+            throw new expression_engine_failure_1.ExpressionEngineFailure('EXPRESSION_FUNCTION_FAILED');
+        }
+        const functions = (0, exports.readCelLegacyFunctions)(registry);
+        return (0, expression_function_invocation_1.runWithExpressionFunctionFrame)(() => loadCelEngine().evaluate(handle.native, { ...roots }, functions));
+    },
+});
+exports.createCelLegacyAdapter = createCelLegacyAdapter;
+/** The built-ins-only adapter, used wherever no registry was handed in. */
+exports.celLegacyAdapter = (0, exports.createCelLegacyAdapter)(expression_function_registry_1.BUILT_IN_EXPRESSION_FUNCTION_REGISTRY);
+//# sourceMappingURL=cel-legacy.adapter.js.map

package/src/lib/condition/adapters/cel-legacy.adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cel-legacy.adapter.js","sourceRoot":"","sources":["../../../../../../../libs/bpm-core/src/lib/condition/adapters/cel-legacy.adapter.ts"],"names":[],"mappings":";;;AAqDA,sCAsBC;AAoBD,wCAWC;AAzGD,yGAA+G;AAE/G,4EAAuE;AACvE,sFAK2C;AAuB3C,IAAI,SAAS,GAAqB,IAAI,CAAC;AAEvC;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAgB,aAAa;IAC3B,IAAI,SAAS,KAAK,IAAI,EAAE,CAAC;QACvB,IAAI,CAAC;YACH,SAAS,GAAG,OAAO,CAAC,QAAQ,CAAc,CAAC;QAC7C,CAAC;QAAC,OAAO,KAAc,EAAE,CAAC;YACxB,qEAAqE;YACrE,oEAAoE;YACpE,yEAAyE;YACzE,aAAa;YACb,IAAI,iBAAiB,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC7B,MAAM,IAAI,KAAK,CACb,0KACE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CACvD,EAAE,CACH,CAAC;YACJ,CAAC;YAED,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,SAAS,iBAAiB,CAAC,KAAc;IACvC,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,MAAM,IAAI,KAAK;QACd,KAAqC,CAAC,IAAI,KAAK,iBAAiB,CAClE,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,cAAc,CAAC,UAAkB;IAC/C,MAAM,MAAM,GAAG,aAAa,EAAE,CAAC;IAC/B,IAAI,WAAwB,CAAC;IAE7B,IAAI,CAAC;QACH,WAAW,GAAG,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IACzC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;AACpE,CAAC;AAOD,MAAM,SAAS,GAAG,CAAC,KAAc,EAAyB,EAAE,CAC1D,OAAO,KAAK,KAAK,QAAQ;IACzB,KAAK,KAAK,IAAI;IACd,OAAQ,KAAqC,CAAC,IAAI,KAAK,QAAQ;IAC/D,OAAQ,KAAyC,CAAC,QAAQ,KAAK,QAAQ;IACtE,KAAyC,CAAC,QAAQ,KAAK,IAAI,CAAC;AAE/D,MAAM,cAAc,GAAG,CAAC,KAAc,EAAiB,EAAE,CACvD,OAAO,KAAK,KAAK,QAAQ;IACzB,KAAK,KAAK,IAAI;IACd,OAAQ,KAAsC,CAAC,KAAK,KAAK,QAAQ;IAC/D,CAAC,CAAE,KAAoC,CAAC,KAAK;IAC7C,CAAC,CAAC,IAAI,CAAC;AAEX;;;;;GAKG;AACH,MAAM,uBAAuB,GAAG,CAAC,IAAa,EAAqB,EAAE;IACnE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;QACrB,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,UAAU,GACd,IAAI,CAAC,IAAI,KAAK,kBAAkB;QAC9B,CAAC,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,CAAC;QAC/C,CAAC,CAAC,IAAI,CAAC;IAEX,OAAO;QACL,GAAG,CAAC,UAAU,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;QAC5C,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE,CACnD,QAAQ,CAAC,OAAO,CAAC,uBAAuB,CAAC,CAC1C;KACF,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,uBAAuB,GAAG,IAAI,OAAO,EAGxC,CAAC;AAEJ;;;;;;;GAOG;AACI,MAAM,sBAAsB,GAAG,CACpC,QAAuC,EACM,EAAE;IAC/C,MAAM,MAAM,GAAG,uBAAuB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAErD,IAAI,MAAM,EAAE,CAAC;QACX,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAC7B,MAAM,CAAC,WAAW,CAChB,IAAA,4DAA2B,EAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,CACjD,CAAC,EAAE,EAAwC,EAAE,CAAC;QAC5C,EAAE,CAAC,IAAI;QACP,IAAA,gEAA+B,EAAC,EAAE,EAAE,YAAY,CAAC;KAClD,CACF,CACF,CACF,CAAC;IAEF,uBAAuB,CAAC,GAAG,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;IAEjD,OAAO,SAAS,CAAC;AACnB,CAAC,CAAC;AAvBW,QAAA,sBAAsB,0BAuBjC;AAEF;;;;GAIG;AACI,MAAM,sBAAsB,GAAG,CACpC,QAAuC,EACd,EAAE,CAAC,CAAC;IAC7B,OAAO,EAAE,cAAc;IACvB,QAAQ,EAAE,CAAC,MAAM,EAAE,KAAK,EAAW,EAAE;QACnC,IACE,IAAA,yDAAwB,EACtB,uBAAuB,CAAC,MAAM,CAAC,MAAM,CAAC,EACtC,IAAA,4DAA2B,EAAC,QAAQ,CAAC,CACtC,EACD,CAAC;YACD,MAAM,IAAI,mDAAuB,CAAC,4BAA4B,CAAC,CAAC;QAClE,CAAC;QAED,MAAM,SAAS,GAAG,IAAA,8BAAsB,EAAC,QAAQ,CAAC,CAAC;QAEnD,OAAO,IAAA,+DAA8B,EAAC,GAAY,EAAE,CAClD,aAAa,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,SAAS,CAAC,CACjE,CAAC;IACJ,CAAC;CACF,CAAC,CAAC;AApBU,QAAA,sBAAsB,0BAoBhC;AAEH,2EAA2E;AAC9D,QAAA,gBAAgB,GAA4B,IAAA,8BAAsB,EAC7E,oEAAqC,CACtC,CAAC"}

package/src/lib/condition/adapters/cel-v2.adapter.d.ts

@@ -0,0 +1,76 @@
+import type { Environment } from '@marcbachmann/cel-js';
+import type { BPMExpressionValueType } from '@rytass/bpm-core-shared';
+import type { BPMExpressionFunctionRegistry } from '../../expression-function/expression-function.types';
+import type { ExpressionEngineAdapter, ExpressionHandle } from '../expression-runtime';
+/**
+ * Parse-time structure limits (ADR 22 §3.4, docs/24 §2.7). They are applied by
+ * the engine while parsing, so an over-large expression never reaches the
+ * budget. Comprehension nesting is not an engine limit; P2 checks it on the AST.
+ */
+export declare const CEL_V2_LIMITS: {
+    readonly maxAstNodes: 200;
+    readonly maxDepth: 32;
+};
+/**
+ * The cel-v2 environment for a registry: the base environment plus every
+ * function the registry lists (the nine built-ins and the host's), built once
+ * per registry and cached. Without a registry it is the built-ins-only one.
+ *
+ * Every function is registered as a global call (`round(x)`), never as a
+ * method. The name `trim` therefore sits beside cel-v2's own `string.trim()`
+ * method without replacing it; no other built-in name exists in cel-v2.
+ *
+ * The returned environment is frozen: registering on it throws. For a
+ * type check with declared variables (P2's `env.check()`), `clone()` it and
+ * register the variables on the clone.
+ */
+export declare function loadCelV2Environment(registry?: BPMExpressionFunctionRegistry): Environment;
+/** A call argument whose checked type its declared parameter never accepts. */
+export interface CelV2ArgumentTypeMismatch {
+    /** The argument's AST node, for the caller to read the fields it uses. */
+    readonly argument: unknown;
+    readonly functionName: string;
+    readonly parameterType: BPMExpressionValueType;
+}
+/**
+ * The first global call to a registered function whose argument the type
+ * check typed as something the declared parameter refuses (ADR 22 §3.5): a
+ * text field handed to a `double` parameter, say. Only meaningful on the AST
+ * of an expression `check()` accepted, parsed in a clone of
+ * `loadCelV2Environment(...)`'s environment (`environment` is that
+ * environment, not the clone); an argument without a checked type, or a
+ * function the environment does not know, is skipped.
+ *
+ * The engine checks every other parameter type itself through the
+ * signature; numbers are registered as `dyn` there, which is what this
+ * closes for the publish lint.
+ *
+ * `readArgumentType`, when given, may name the type to compare instead of
+ * the checked one (a base type, `null` to keep the checked one): the lint
+ * passes the schema type of a field it had to check as `dyn`, so that
+ * `form.title != null && f(form.title)` is compared as the text it is.
+ */
+export declare function findCelV2ArgumentTypeMismatch(ast: unknown, environment: Environment, readArgumentType?: (argument: unknown) => string | null): CelV2ArgumentTypeMismatch | null;
+/**
+ * Parses with cel-v2. Returns `null` when the expression does not parse or
+ * breaks a structure limit. The engine is loaded outside the `try`: a failure
+ * to load it is a configuration error, not a bad expression.
+ *
+ * Parsing does not check that a called function exists; evaluation does.
+ */
+export declare function parseCelV2(expression: string, registry?: BPMExpressionFunctionRegistry): ExpressionHandle | null;
+/**
+ * Maps an error cel-v2 threw to a classified failure, by its `code` only. Any
+ * code not listed is a type or evaluation error. Errors that are not cel-v2's
+ * (an operator handler's own failure, a stack overflow) pass through unchanged
+ * and are classified by the runtime.
+ */
+export declare function classifyCelV2Error(error: unknown): unknown;
+/**
+ * The cel-v2 adapter for a registry. A host function the registry no longer
+ * has (withdrawn after publishing) fails the evaluation with
+ * `EXPRESSION_FUNCTION_FAILED` before the engine runs, wherever the call sits.
+ */
+export declare const createCelV2Adapter: (registry: BPMExpressionFunctionRegistry) => ExpressionEngineAdapter;
+/** The built-ins-only adapter, used wherever no registry was handed in. */
+export declare const celV2Adapter: ExpressionEngineAdapter;

package/src/lib/condition/adapters/cel-v2.adapter.js

@@ -0,0 +1,371 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.celV2Adapter = exports.createCelV2Adapter = exports.CEL_V2_LIMITS = void 0;
+exports.loadCelV2Environment = loadCelV2Environment;
+exports.findCelV2ArgumentTypeMismatch = findCelV2ArgumentTypeMismatch;
+exports.parseCelV2 = parseCelV2;
+exports.classifyCelV2Error = classifyCelV2Error;
+const expression_function_registry_1 = require("../../expression-function/expression-function.registry");
+const expression_engine_failure_1 = require("../expression-engine-failure");
+const expression_function_invocation_1 = require("../expression-function-invocation");
+/**
+ * Parse-time structure limits (ADR 22 §3.4, docs/24 §2.7). They are applied by
+ * the engine while parsing, so an over-large expression never reaches the
+ * budget. Comprehension nesting is not an engine limit; P2 checks it on the AST.
+ */
+exports.CEL_V2_LIMITS = {
+    maxAstNodes: 200,
+    maxDepth: 32,
+};
+const MIXED_ARITHMETIC_OPERATORS = ['+', '-', '*', '/', '%'];
+/**
+ * A CEL `int` (a `bigint`) or `double` (a `number`) as a JS number. An int
+ * outside the safe range cannot become a double without silently changing,
+ * so it is refused (docs/24 §2.1: out of safe range is `EXPRESSION_INVALID_RESULT`).
+ */
+const toDouble = (value) => {
+    if (typeof value === 'number') {
+        return value;
+    }
+    if (typeof value === 'bigint' &&
+        value <= BigInt(Number.MAX_SAFE_INTEGER) &&
+        value >= BigInt(Number.MIN_SAFE_INTEGER)) {
+        return Number(value);
+    }
+    throw new expression_engine_failure_1.ExpressionEngineFailure('EXPRESSION_INVALID_RESULT');
+};
+/**
+ * The mixed `int`/`double` arithmetic cel-legacy gives for free (it only has
+ * JS numbers) and cel-v2 refuses with `no such overload`. Form values arrive as
+ * JS numbers, which cel-v2 types as `double`, while integer literals are `int`,
+ * so without these `form.amount * 2` fails (ADR 22 §3.3). The result is a
+ * `double`, as in cel-legacy.
+ *
+ * A zero divisor throws `EXPRESSION_TYPE_ERROR` (docs/24 §2.1) instead of
+ * returning `Infinity`/`NaN`, which a comparison would quietly turn into a
+ * routing decision.
+ */
+const MIXED_ARITHMETIC = {
+    '%': (left, right) => left % right,
+    '*': (left, right) => left * right,
+    '+': (left, right) => left + right,
+    '-': (left, right) => left - right,
+    '/': (left, right) => left / right,
+};
+const runMixedArithmetic = (operator, left, right) => {
+    const leftNumber = toDouble(left);
+    const rightNumber = toDouble(right);
+    if ((operator === '/' || operator === '%') && rightNumber === 0) {
+        throw new expression_engine_failure_1.ExpressionEngineFailure('EXPRESSION_TYPE_ERROR');
+    }
+    return MIXED_ARITHMETIC[operator](leftNumber, rightNumber);
+};
+/**
+ * `int == double`, exact: the int is compared as a `bigint`, so a large int is
+ * never rounded into equality with a nearby double. Registering it also gives
+ * the reverse order and `!=` (the engine derives them).
+ */
+const isIntEqualToDouble = (left, right) => {
+    const [int, double] = typeof left === 'bigint' ? [left, right] : [right, left];
+    return (typeof int === 'bigint' &&
+        typeof double === 'number' &&
+        Number.isInteger(double) &&
+        BigInt(double) === int);
+};
+/**
+ * Options that make cel-v2 read a BPM context the way cel-legacy did:
+ * undeclared roots are `dyn` (the roots are checked by the runtime's
+ * allowlist, not by declaration), and list and map literals may mix value
+ * types (`{"a": "x", "b": 2}`, which cel-legacy refuses).
+ */
+const ENVIRONMENT_OPTIONS = {
+    homogeneousAggregateLiterals: false,
+    limits: exports.CEL_V2_LIMITS,
+    unlistedVariablesAreDyn: true,
+};
+const createEnvironment = (module) => {
+    const environment = new module.Environment(ENVIRONMENT_OPTIONS);
+    MIXED_ARITHMETIC_OPERATORS.forEach((operator) => {
+        environment.registerOperator(`double ${operator} int: double`, (left, right) => runMixedArithmetic(operator, left, right));
+        environment.registerOperator(`int ${operator} double: double`, (left, right) => runMixedArithmetic(operator, left, right));
+    });
+    // `in` is deliberately not registered for mixed lists: an `int in
+    // list<double>` overload makes the engine's own `V in list<V>` ambiguous for
+    // `dyn` values, and `form.qty in [1, 2.5]` then fails at evaluation.
+    environment.registerOperator('int == double', isIntEqualToDouble);
+    return environment;
+};
+let celV2BaseEnvironment = null;
+/**
+ * Loads `@marcbachmann/cel-js` on first use, like `loadCelEngine` does for
+ * cel-legacy, and for the same reasons: a host that never evaluates a cel-v2
+ * expression never resolves the package, and the ESM-only package is loaded
+ * with `require` so every caller stays synchronous (Node >=20.19 / >=22.12).
+ *
+ * This is the environment every function environment is cloned from: options,
+ * limits and the mixed-number operators, no functions. Cloning freezes it, so
+ * it is complete before the first clone.
+ */
+const loadCelV2BaseEnvironment = () => {
+    if (celV2BaseEnvironment === null) {
+        let module;
+        try {
+            module = require('@marcbachmann/cel-js');
+        }
+        catch (error) {
+            if (typeof error === 'object' &&
+                error !== null &&
+                error.code === 'ERR_REQUIRE_ESM') {
+                throw new Error(`[@rytass/bpm-core-nestjs-module] This Node version cannot require the ESM-only '@marcbachmann/cel-js'. BPM needs Node >=20.19 or >=22.12 to evaluate cel-v2 expressions. Original error: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            throw error;
+        }
+        celV2BaseEnvironment = createEnvironment(module);
+    }
+    return celV2BaseEnvironment;
+};
+/*
+ * How a declared type is written in a cel-v2 signature. Numbers are `dyn`:
+ * cel-v2 tells an `int` literal (`1000`) from a `double` (a form value, which
+ * is a JS number), so a `double` parameter would refuse `f_v1(1000)` and an
+ * `int` one would refuse `f_v1(form.qty)`. The wrapper checks the number
+ * against the declared type instead. Every other type is enforced by the
+ * engine's overload resolution, which reports a mismatch as a type error.
+ */
+const toSignatureParameterType = (type) => type === 'double' || type === 'int' ? 'dyn' : type;
+const toSignature = (fn) => `${fn.name}(${fn.parameters
+    .map((parameter) => toSignatureParameterType(parameter.type))
+    .join(', ')}): ${fn.returnType}`;
+const celV2Environments = new WeakMap();
+/**
+ * The declared parameter types of every function registered on a function
+ * environment, by name. Kept beside the environment because numbers are
+ * registered as `dyn` (see `toSignatureParameterType`), so the engine's own
+ * check cannot tell a `string` argument handed to a `double` parameter.
+ */
+const celV2FunctionParameters = new WeakMap();
+/**
+ * The cel-v2 environment for a registry: the base environment plus every
+ * function the registry lists (the nine built-ins and the host's), built once
+ * per registry and cached. Without a registry it is the built-ins-only one.
+ *
+ * Every function is registered as a global call (`round(x)`), never as a
+ * method. The name `trim` therefore sits beside cel-v2's own `string.trim()`
+ * method without replacing it; no other built-in name exists in cel-v2.
+ *
+ * The returned environment is frozen: registering on it throws. For a
+ * type check with declared variables (P2's `env.check()`), `clone()` it and
+ * register the variables on the clone.
+ */
+function loadCelV2Environment(registry = expression_function_registry_1.BUILT_IN_EXPRESSION_FUNCTION_REGISTRY) {
+    const cached = celV2Environments.get(registry);
+    if (cached) {
+        return cached;
+    }
+    const environment = loadCelV2BaseEnvironment().clone();
+    const { functions } = (0, expression_function_invocation_1.readExpressionFunctionTable)(registry);
+    functions.forEach((fn) => {
+        environment.registerFunction(toSignature(fn), (0, expression_function_invocation_1.createExpressionFunctionInvoker)(fn, 'cel-v2'));
+    });
+    // Cloning stops the parent from registering more (documented engine
+    // behaviour), so the shared environment cannot be changed by a caller.
+    environment.clone();
+    celV2FunctionParameters.set(environment, new Map(functions.map((fn) => [
+        fn.name,
+        fn.parameters.map((parameter) => parameter.type),
+    ])));
+    celV2Environments.set(registry, environment);
+    return environment;
+}
+const isAstNode = (value) => typeof value === 'object' &&
+    value !== null &&
+    typeof value.op === 'string';
+const NUMERIC_CHECKED_TYPES = new Set([
+    'double',
+    'int',
+    'uint',
+]);
+/*
+ * The checked types (their base, `list<string>` is `list`) a parameter of
+ * each declared type accepts. `dyn` is accepted everywhere: a value the check
+ * cannot type is decided at evaluation, as before. A `double` parameter takes
+ * an `int` and an `int` one a `double` (a form number is a `double` even when
+ * it is whole); the wrapper decides those at evaluation.
+ */
+const isCheckedTypeAccepted = (checkedType, parameterType) => {
+    if (checkedType === 'dyn' || parameterType === 'dyn') {
+        return true;
+    }
+    switch (parameterType) {
+        case 'double':
+        case 'int':
+            return NUMERIC_CHECKED_TYPES.has(checkedType);
+        case 'null':
+            return checkedType === 'null';
+        default:
+            return checkedType === parameterType;
+    }
+};
+const readCheckedBaseType = (node) => {
+    const checked = node
+        ?.checkedType;
+    const name = typeof checked === 'object' && checked !== null
+        ? checked.name
+        : undefined;
+    return typeof name === 'string' ? name.split('<')[0].trim() : null;
+};
+/**
+ * The first global call to a registered function whose argument the type
+ * check typed as something the declared parameter refuses (ADR 22 §3.5): a
+ * text field handed to a `double` parameter, say. Only meaningful on the AST
+ * of an expression `check()` accepted, parsed in a clone of
+ * `loadCelV2Environment(...)`'s environment (`environment` is that
+ * environment, not the clone); an argument without a checked type, or a
+ * function the environment does not know, is skipped.
+ *
+ * The engine checks every other parameter type itself through the
+ * signature; numbers are registered as `dyn` there, which is what this
+ * closes for the publish lint.
+ *
+ * `readArgumentType`, when given, may name the type to compare instead of
+ * the checked one (a base type, `null` to keep the checked one): the lint
+ * passes the schema type of a field it had to check as `dyn`, so that
+ * `form.title != null && f(form.title)` is compared as the text it is.
+ */
+function findCelV2ArgumentTypeMismatch(ast, environment, readArgumentType = () => null) {
+    const parameters = celV2FunctionParameters.get(environment);
+    if (!parameters) {
+        return null;
+    }
+    const visit = (node) => {
+        if (Array.isArray(node)) {
+            return node.reduce((found, child) => found ?? visit(child), null);
+        }
+        if (!isAstNode(node)) {
+            return null;
+        }
+        const args = node.args;
+        if (node.op === 'call' &&
+            Array.isArray(args) &&
+            typeof args[0] === 'string' &&
+            Array.isArray(args[1])) {
+            const declared = parameters.get(args[0]);
+            const callArguments = args[1];
+            const mismatchIndex = declared && declared.length === callArguments.length
+                ? callArguments.findIndex((argument, index) => {
+                    const checkedType = readArgumentType(argument) ?? readCheckedBaseType(argument);
+                    return (checkedType !== null &&
+                        !isCheckedTypeAccepted(checkedType, declared[index]));
+                })
+                : -1;
+            if (declared && mismatchIndex >= 0) {
+                return {
+                    argument: callArguments[mismatchIndex],
+                    functionName: args[0],
+                    parameterType: declared[mismatchIndex],
+                };
+            }
+        }
+        return visit(args);
+    };
+    return visit(ast);
+}
+/**
+ * Parses with cel-v2. Returns `null` when the expression does not parse or
+ * breaks a structure limit. The engine is loaded outside the `try`: a failure
+ * to load it is a configuration error, not a bad expression.
+ *
+ * Parsing does not check that a called function exists; evaluation does.
+ */
+function parseCelV2(expression, registry = expression_function_registry_1.BUILT_IN_EXPRESSION_FUNCTION_REGISTRY) {
+    const environment = loadCelV2Environment(registry);
+    try {
+        return { native: environment.parse(expression) };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Names of the global functions an expression calls (`call` nodes; methods are
+ * `rcall` and never host functions). A small walk of the engine's AST, only
+ * for the evaluation-time check; the publish lint reads references through
+ * P2's AST module.
+ */
+const readCalledFunctionNames = (node) => {
+    if (Array.isArray(node)) {
+        return node.flatMap(readCalledFunctionNames);
+    }
+    if (!isAstNode(node)) {
+        return [];
+    }
+    const args = node.args;
+    const own = node.op === 'call' && Array.isArray(args) && typeof args[0] === 'string'
+        ? [args[0]]
+        : [];
+    return [...own, ...readCalledFunctionNames(args)];
+};
+const isCelError = (error) => error instanceof Error &&
+    (error.name === 'EvaluationError' ||
+        error.name === 'TypeError' ||
+        error.name === 'ParseError') &&
+    typeof error.code === 'string' &&
+    typeof error.summary === 'string';
+/*
+ * The only engine summaries a key name is read from. Anchored at both ends;
+ * the candidate is checked against the expression before anyone sees it.
+ * `No such key: index out of bounds, ...` does not match, by design.
+ */
+const KEY_NAME_PATTERNS = [
+    /^No such key: ([A-Za-z_][A-Za-z0-9_]*)$/u,
+    /^Unknown variable: ([A-Za-z_][A-Za-z0-9_]*)$/u,
+];
+const readKeyNameCandidate = (summary) => KEY_NAME_PATTERNS.reduce((found, pattern) => found ?? pattern.exec(summary)?.[1] ?? null, null);
+const CEL_V2_CODE_MAP = {
+    index_out_of_bounds: 'EXPRESSION_MISSING_KEY',
+    index_out_of_range: 'EXPRESSION_MISSING_KEY',
+    no_such_key: 'EXPRESSION_MISSING_KEY',
+    numeric_overflow: 'EXPRESSION_INVALID_RESULT',
+    unknown_variable: 'EXPRESSION_MISSING_KEY',
+};
+/**
+ * Maps an error cel-v2 threw to a classified failure, by its `code` only. Any
+ * code not listed is a type or evaluation error. Errors that are not cel-v2's
+ * (an operator handler's own failure, a stack overflow) pass through unchanged
+ * and are classified by the runtime.
+ */
+function classifyCelV2Error(error) {
+    if (!isCelError(error)) {
+        return error;
+    }
+    const code = CEL_V2_CODE_MAP[error.code] ?? 'EXPRESSION_TYPE_ERROR';
+    return new expression_engine_failure_1.ExpressionEngineFailure(code, code === 'EXPRESSION_MISSING_KEY'
+        ? readKeyNameCandidate(error.summary)
+        : null);
+}
+/**
+ * The cel-v2 adapter for a registry. A host function the registry no longer
+ * has (withdrawn after publishing) fails the evaluation with
+ * `EXPRESSION_FUNCTION_FAILED` before the engine runs, wherever the call sits.
+ */
+const createCelV2Adapter = (registry) => ({
+    compile: (expression) => parseCelV2(expression, registry),
+    evaluate: (handle, roots) => {
+        const parsed = handle.native;
+        if ((0, expression_function_invocation_1.callsUnavailableFunction)(readCalledFunctionNames(parsed.ast), (0, expression_function_invocation_1.readExpressionFunctionTable)(registry))) {
+            throw new expression_engine_failure_1.ExpressionEngineFailure('EXPRESSION_FUNCTION_FAILED');
+        }
+        return (0, expression_function_invocation_1.runWithExpressionFunctionFrame)(() => {
+            try {
+                return parsed({ ...roots });
+            }
+            catch (error) {
+                throw classifyCelV2Error(error);
+            }
+        });
+    },
+});
+exports.createCelV2Adapter = createCelV2Adapter;
+/** The built-ins-only adapter, used wherever no registry was handed in. */
+exports.celV2Adapter = (0, exports.createCelV2Adapter)(expression_function_registry_1.BUILT_IN_EXPRESSION_FUNCTION_REGISTRY);
+//# sourceMappingURL=cel-v2.adapter.js.map

package/src/lib/condition/adapters/cel-v2.adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cel-v2.adapter.js","sourceRoot":"","sources":["../../../../../../../libs/bpm-core/src/lib/condition/adapters/cel-v2.adapter.ts"],"names":[],"mappings":"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"}