reqon-dsl 0.3.0 → 0.4.0

package/dist/interpreter/evaluator.js

@@ -160,11 +160,14 @@ export function evaluate(expr, ctx, current) {
         }
         case 'LogicalExpression': {
             const left = evaluate(expr.left, ctx, current);
+            // Return operand values (like JS &&/||), not coerced booleans, so
+            // idioms like `x or default` work. Short-circuit: only evaluate the
+            // right operand when the left doesn't already decide the result.
             if (expr.operator === 'and') {
-                return left ? evaluate(expr.right, ctx, current) : false;
+                return left ? evaluate(expr.right, ctx, current) : left;
             }
             else {
-                return left ? true : evaluate(expr.right, ctx, current);
+                return left ? left : evaluate(expr.right, ctx, current);
             }
         }
         case 'NotExpression':
@@ -227,8 +230,16 @@ export function evaluate(expr, ctx, current) {
                     return Math.ceil(toNumber(args[0], 'ceil'));
                 case 'now':
                     return new Date().toISOString();
-                case 'env':
-                    return process.env[args[0]] ?? '';
+                case 'env': {
+                    // The variable name must be a static string literal. A dynamic argument
+                    // (e.g. env(response.field)) would let fetched/untrusted data choose
+                    // which environment variable is read, exfiltrating secrets.
+                    const nameExpr = expr.arguments[0];
+                    if (!nameExpr || nameExpr.type !== 'Literal') {
+                        throw new EvaluatorError(`env() requires a string-literal variable name, not a dynamic expression`, { expression: 'env' });
+                    }
+                    return process.env[String(args[0])] ?? '';
+                }
                 default:
                     throw new UnsupportedOperationError(`function: ${expr.callee}`, 'call expression');
             }
@@ -297,7 +308,11 @@ export function interpolatePath(path, ctx, current) {
                 value = getVariable(ctx, part);
             }
         }
-        return String(value ?? '');
+        // URL-encode each interpolated value so a path param can't inject path
+        // segments, query strings, or fragments into the request target. Path params
+        // are single segments, so encoding (which escapes '/', '?', '#', etc.) is the
+        // correct treatment.
+        return encodeURIComponent(String(value ?? ''));
     });
 }
 /**
@@ -324,12 +339,27 @@ function toNumber(value, operator) {
         expression: operator,
     });
 }
+/** Coerce for comparison, yielding NaN (not a throw) for nullish/non-numeric. */
+function toComparable(value) {
+    if (typeof value === 'number')
+        return value;
+    if (typeof value === 'boolean')
+        return value ? 1 : 0;
+    if (typeof value === 'string')
+        return Number(value);
+    return NaN;
+}
 /**
- * Safely perform arithmetic comparison, with proper type coercion.
+ * Arithmetic comparison for `where`/`match`/`validate` guards. A missing or
+ * non-numeric operand makes the comparison false (the record is excluded) rather
+ * than throwing — real API data routinely omits fields, and one missing field
+ * shouldn't abort the whole stage.
  */
 function compareNumbers(left, right, operator) {
-    const leftNum = toNumber(left, operator);
-    const rightNum = toNumber(right, operator);
+    const leftNum = toComparable(left);
+    const rightNum = toComparable(right);
+    if (Number.isNaN(leftNum) || Number.isNaN(rightNum))
+        return false;
     switch (operator) {
         case '<':
             return leftNum < rightNum;

package/dist/interpreter/executor.d.ts

@@ -27,6 +27,7 @@ import type { DebugController } from '../debug/index.js';
 import type { ControlServer } from '../control/index.js';
 import { type TraceStore } from '../trace/index.js';
 import { type PauseManager, type PauseStore } from '../pause/index.js';
+import type { ExecutionLogStore } from '../execution-log/index.js';
 export interface ExecutionResult {
     success: boolean;
     duration: number;
@@ -116,6 +117,13 @@ export interface ExecutorConfig {
     traceStore?: TraceStore;
     pauseStore?: PauseStore;
     pauseManager?: PauseManager;
+    executionLog?: ExecutionLogStore;
+    /**
+     * Max items a single run of a `backfill` paginated fetch accumulates before
+     * stopping cleanly (a later resume continues). Bounds memory per run for large
+     * backfills. Defaults to the handler's built-in cap.
+     */
+    backfillMaxItemsPerRun?: number;
 }
 export { type AuthConfig } from './source-manager.js';
 export declare class MissionExecutor {
@@ -123,6 +131,8 @@ export declare class MissionExecutor {
     private ctx;
     private errors;
     private actionsRun;
+    /** Monotonic key generator for queued values lacking an id. */
+    private queueCounter;
     private transforms;
     private rateLimiter;
     private circuitBreaker;
@@ -134,7 +144,15 @@ export declare class MissionExecutor {
     private missionName?;
     private eventEmitter?;
     private logger?;
-    private stepIndex;
+    private executionLog?;
+    /** Stable id used for the execution event log (independent of persistState). */
+    private logExecutionId?;
+    /** Effect ids already applied (from the log) — replay skips these. */
+    private appliedEffects;
+    /** Backfill page progress per step id (from the log) — resumes pagination. */
+    private pageProgress;
+    /** The pause being resumed on this run — its step replays past, not into, a pause. */
+    private resumingPause?;
     private debugController?;
     private traceRecorder?;
     private traceStore?;
@@ -150,14 +168,58 @@ export declare class MissionExecutor {
     private executeMission;
     private getStageName;
     private executeSequentialStage;
+    /**
+     * Run all settled-style tasks with a bounded number in flight at once,
+     * preserving result order. Caps fan-out so a wide `run [...]` can't open an
+     * unbounded number of concurrent HTTP/store operations.
+     */
+    private settleWithLimit;
+    /**
+     * Execute a `run [A, B, ...]` stage.
+     *
+     * Failure semantics are **complete-then-fail**: every branch runs to
+     * completion (bounded by MAX_PARALLEL_ACTIONS in flight), then the stage
+     * fails if any branch failed. There is no cancellation of siblings and no
+     * rollback — a branch that committed store writes keeps them even if another
+     * branch failed. Each branch gets its own action scope (step counter +
+     * checkpoints); stores/sources/schemas are shared, so parallel branches that
+     * write the same key get last-writer-wins and should target disjoint keys.
+     */
     private executeParallelStage;
     private executeAction;
+    /** Compute a retry backoff delay from a RetrySignal's backoff config. */
+    private computeRetryDelay;
+    /** Push a queued value to its target store (queue directive). */
+    private handleQueue;
     private executeStep;
     private executeFetch;
+    /**
+     * Per-action mutable scope (step counter + deferred checkpoints). Lazily
+     * created so a step run with the bare mission context still works; normally
+     * executeAction installs a fresh scope that nested scopes inherit.
+     */
+    private scopeFor;
+    /**
+     * Append an event to the execution log. No-op (zero cost) when no log is
+     * configured. The executionId is supplied from this run's stable log id.
+     */
+    private logEvent;
+    /** Flush deferred sync checkpoints (called after a successful store / action). */
+    private flushPendingCheckpoints;
     private executeFor;
     private executeMap;
     private executeValidate;
     private executeStore;
+    /**
+     * A stable hash of the payload a store step will write, used to make the
+     * store-effect identity content-aware. Resolving the source is a pure read of
+     * the context (the same value the handler stores); on any evaluation failure we
+     * fall back to a constant so behaviour matches the old target-only identity
+     * rather than throwing inside the dedup path.
+     */
+    /** Load a pause's checkpoint into the shape the pause step uses to resume. */
+    private loadResumingPause;
+    private storeContentHash;
     private executeMatch;
     private executeLet;
     private executeApply;