reqon-dsl 0.2.0

package/dist/interpreter/step-handlers/for-handler.js

@@ -0,0 +1,51 @@
+import { evaluate } from '../evaluator.js';
+import { childContext, setVariable, getVariable } from '../context.js';
+/**
+ * Handles for...in...where iteration steps
+ */
+export class ForHandler {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async execute(step) {
+        const collection = await this.getCollection(step);
+        // Apply filter if present
+        const filtered = step.condition
+            ? collection.filter((item) => evaluate(step.condition, this.deps.ctx, item))
+            : collection;
+        this.deps.log(`Iterating over ${filtered.length} items`);
+        // Execute steps for each item
+        for (const item of filtered) {
+            await this.executeForItem(step, item);
+        }
+    }
+    async getCollection(step) {
+        let collection;
+        if (step.collection.type === 'Identifier') {
+            // It's a store reference
+            const store = this.deps.ctx.stores.get(step.collection.name);
+            if (store) {
+                collection = await store.list();
+            }
+            else {
+                collection = getVariable(this.deps.ctx, step.collection.name) ?? [];
+            }
+        }
+        else {
+            collection = evaluate(step.collection, this.deps.ctx);
+        }
+        if (!Array.isArray(collection)) {
+            throw new Error('For loop collection must be an array');
+        }
+        return collection;
+    }
+    async executeForItem(step, item) {
+        const childCtx = childContext(this.deps.ctx);
+        setVariable(childCtx, step.variable, item);
+        // Execute each inner step with child context
+        for (const innerStep of step.steps) {
+            await this.deps.executeStep(innerStep, this.deps.actionName, childCtx);
+        }
+    }
+}

package/dist/interpreter/step-handlers/index.d.ts

@@ -0,0 +1,8 @@
+export { type StepHandler, type StepHandlerDeps } from './types.js';
+export { ForHandler, type ForHandlerDeps } from './for-handler.js';
+export { MapHandler } from './map-handler.js';
+export { ValidateHandler } from './validate-handler.js';
+export { StoreHandler } from './store-handler.js';
+export { MatchHandler, type MatchHandlerDeps, type MatchResult } from './match-handler.js';
+export { WebhookHandler, type WebhookHandlerDeps, type WebhookHandlerResult } from './webhook-handler.js';
+export { NoMatchError, AbortError, SkipSignal, RetrySignal, JumpSignal, QueueSignal, } from '../signals.js';

package/dist/interpreter/step-handlers/index.js

@@ -0,0 +1,8 @@
+export { ForHandler } from './for-handler.js';
+export { MapHandler } from './map-handler.js';
+export { ValidateHandler } from './validate-handler.js';
+export { StoreHandler } from './store-handler.js';
+export { MatchHandler } from './match-handler.js';
+export { WebhookHandler } from './webhook-handler.js';
+// Export signals from the canonical location
+export { NoMatchError, AbortError, SkipSignal, RetrySignal, JumpSignal, QueueSignal, } from '../signals.js';

package/dist/interpreter/step-handlers/map-handler.d.ts

@@ -0,0 +1,10 @@
+import type { MapStep } from '../../ast/nodes.js';
+import type { StepHandler, StepHandlerDeps } from './types.js';
+/**
+ * Handles map...-> transformation steps
+ */
+export declare class MapHandler implements StepHandler<MapStep> {
+    private deps;
+    constructor(deps: StepHandlerDeps);
+    execute(step: MapStep): Promise<void>;
+}

package/dist/interpreter/step-handlers/map-handler.js

@@ -0,0 +1,20 @@
+import { evaluate } from '../evaluator.js';
+/**
+ * Handles map...-> transformation steps
+ */
+export class MapHandler {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async execute(step) {
+        const source = evaluate(step.source, this.deps.ctx);
+        const mapped = {};
+        for (const mapping of step.mappings) {
+            mapped[mapping.field] = evaluate(mapping.expression, this.deps.ctx, source);
+        }
+        // Store mapped result in response for next step
+        this.deps.ctx.response = mapped;
+        this.deps.log(`Mapped to ${step.targetSchema}`);
+    }
+}

package/dist/interpreter/step-handlers/match-handler.d.ts

@@ -0,0 +1,27 @@
+import type { MatchStep, ActionStep, FlowDirective } from '../../ast/nodes.js';
+import type { StepHandlerDeps } from './types.js';
+import type { ExecutionContext } from '../context.js';
+/**
+ * Result of executing a match step
+ */
+export interface MatchResult {
+    /** The schema that matched (or '_' for wildcard) */
+    matchedSchema: string;
+    /** Flow directive if the arm specifies one */
+    flow?: FlowDirective;
+    /** Whether steps were executed (vs flow directive) */
+    stepsExecuted: boolean;
+}
+export interface MatchHandlerDeps extends StepHandlerDeps {
+    executeStep: (step: ActionStep, actionName: string, ctx: ExecutionContext) => Promise<void>;
+    actionName: string;
+}
+/**
+ * Handles match steps (schema overloading with flow control)
+ */
+export declare class MatchHandler {
+    private deps;
+    constructor(deps: MatchHandlerDeps);
+    execute(step: MatchStep): Promise<void>;
+    private handleFlowDirective;
+}

package/dist/interpreter/step-handlers/match-handler.js

@@ -0,0 +1,61 @@
+import { evaluate } from '../evaluator.js';
+import { findMatchingSchema } from '../schema-matcher.js';
+import { NoMatchError, AbortError, SkipSignal, RetrySignal, JumpSignal, QueueSignal, } from '../signals.js';
+/**
+ * Handles match steps (schema overloading with flow control)
+ */
+export class MatchHandler {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async execute(step) {
+        const value = evaluate(step.target, this.deps.ctx);
+        // Get schema names from arms in order
+        const schemaNames = step.arms.map(arm => arm.schema);
+        // Find matching schema
+        const matchedSchema = findMatchingSchema(value, this.deps.ctx.schemas, schemaNames);
+        if (!matchedSchema) {
+            throw new NoMatchError(value);
+        }
+        this.deps.log(`Matched schema: ${matchedSchema}`);
+        // Find the matching arm
+        const arm = step.arms.find(a => a.schema === matchedSchema);
+        if (!arm) {
+            // Shouldn't happen if findMatchingSchema works correctly
+            throw new NoMatchError(value);
+        }
+        // Handle flow directive
+        if (arm.flow) {
+            // 'continue' means proceed normally - don't throw
+            if (arm.flow.type === 'continue') {
+                return;
+            }
+            this.handleFlowDirective(arm.flow, value);
+        }
+        // Execute steps
+        if (arm.steps) {
+            for (const innerStep of arm.steps) {
+                await this.deps.executeStep(innerStep, this.deps.actionName, this.deps.ctx);
+            }
+        }
+    }
+    handleFlowDirective(flow, value) {
+        switch (flow.type) {
+            case 'skip':
+                throw new SkipSignal();
+            case 'abort':
+                throw new AbortError(flow.message);
+            case 'retry':
+                throw new RetrySignal(flow.backoff);
+            case 'jump':
+                throw new JumpSignal(flow.action, flow.then);
+            case 'queue':
+                throw new QueueSignal(value, flow.target);
+            default:
+                // This should never happen if TypeScript is working correctly
+                const _exhaustive = flow;
+                throw new Error(`Unknown flow directive: ${_exhaustive.type}`);
+        }
+    }
+}

package/dist/interpreter/step-handlers/store-handler.d.ts

@@ -0,0 +1,13 @@
+import type { StoreStep } from '../../ast/nodes.js';
+import type { StepHandler, StepHandlerDeps } from './types.js';
+/**
+ * Handles store steps for persisting data
+ */
+export declare class StoreHandler implements StepHandler<StoreStep> {
+    private deps;
+    constructor(deps: StepHandlerDeps);
+    execute(step: StoreStep): Promise<void>;
+    private storeMany;
+    private storeOne;
+    private storeRecord;
+}

package/dist/interpreter/step-handlers/store-handler.js

@@ -0,0 +1,66 @@
+import { evaluate } from '../evaluator.js';
+/**
+ * Handles store steps for persisting data
+ */
+export class StoreHandler {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async execute(step) {
+        const store = this.deps.ctx.stores.get(step.target);
+        if (!store) {
+            throw new Error(`Store not found: ${step.target}`);
+        }
+        const source = evaluate(step.source, this.deps.ctx);
+        if (Array.isArray(source)) {
+            await this.storeMany(step, store, source);
+        }
+        else {
+            await this.storeOne(step, store, source);
+        }
+    }
+    async storeMany(step, store, items) {
+        // Use bulk operation if available and not doing upserts (which need individual handling)
+        if (store.bulkSet && !step.options.upsert) {
+            const records = [];
+            for (const item of items) {
+                const record = item;
+                const key = step.options.key
+                    ? String(evaluate(step.options.key, this.deps.ctx, record))
+                    : String(record.id ?? Math.random());
+                if (step.options.partial !== undefined) {
+                    record._partial = step.options.partial;
+                }
+                records.push({ key, value: record });
+            }
+            await store.bulkSet(records);
+        }
+        else {
+            // Fall back to individual operations for upserts or stores without bulkSet
+            for (const item of items) {
+                const record = item;
+                await this.storeRecord(step, store, record);
+            }
+        }
+        this.deps.log(`Stored ${items.length} items to ${step.target}`);
+    }
+    async storeOne(step, store, record) {
+        await this.storeRecord(step, store, record);
+        this.deps.log(`Stored item to ${step.target}`);
+    }
+    async storeRecord(step, store, record) {
+        const key = step.options.key
+            ? String(evaluate(step.options.key, this.deps.ctx, record))
+            : String(record.id ?? Math.random());
+        if (step.options.partial !== undefined) {
+            record._partial = step.options.partial;
+        }
+        if (step.options.upsert) {
+            await store.update(key, record);
+        }
+        else {
+            await store.set(key, record);
+        }
+    }
+}

package/dist/interpreter/step-handlers/types.d.ts

@@ -0,0 +1,15 @@
+import type { ActionStep } from '../../ast/nodes.js';
+import type { ExecutionContext } from '../context.js';
+/**
+ * Dependencies injected into step handlers
+ */
+export interface StepHandlerDeps {
+    ctx: ExecutionContext;
+    log: (message: string) => void;
+}
+/**
+ * Base interface for step handlers
+ */
+export interface StepHandler<TStep extends ActionStep> {
+    execute(step: TStep): Promise<void>;
+}

package/dist/interpreter/step-handlers/types.js

@@ -0,0 +1 @@
+export {};

package/dist/interpreter/step-handlers/validate-handler.d.ts

@@ -0,0 +1,10 @@
+import type { ValidateStep } from '../../ast/nodes.js';
+import type { StepHandler, StepHandlerDeps } from './types.js';
+/**
+ * Handles validate steps with assume constraints
+ */
+export declare class ValidateHandler implements StepHandler<ValidateStep> {
+    private deps;
+    constructor(deps: StepHandlerDeps);
+    execute(step: ValidateStep): Promise<void>;
+}

package/dist/interpreter/step-handlers/validate-handler.js

@@ -0,0 +1,26 @@
+import { evaluate } from '../evaluator.js';
+/**
+ * Handles validate steps with assume constraints
+ */
+export class ValidateHandler {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async execute(step) {
+        const target = evaluate(step.target, this.deps.ctx);
+        for (const constraint of step.constraints) {
+            const result = evaluate(constraint.condition, this.deps.ctx, target);
+            if (!result) {
+                const message = constraint.message ?? `Validation failed: ${JSON.stringify(constraint.condition)}`;
+                if (constraint.severity === 'error') {
+                    throw new Error(message);
+                }
+                else {
+                    this.deps.log(`Warning: ${message}`);
+                }
+            }
+        }
+        this.deps.log('Validation passed');
+    }
+}

package/dist/interpreter/step-handlers/webhook-handler.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Webhook Handler
+ *
+ * Handles the 'wait' step for waiting on webhook callbacks.
+ */
+import type { WebhookStep } from '../../ast/nodes.js';
+import type { ExecutionContext } from '../context.js';
+import type { WebhookServer, WebhookRegistration, WebhookEvent } from '../../webhook/index.js';
+/**
+ * Dependencies for the webhook handler
+ */
+export interface WebhookHandlerDeps {
+    ctx: ExecutionContext;
+    webhookServer: WebhookServer;
+    executionId: string;
+    log: (message: string) => void;
+}
+/**
+ * Result of webhook handler execution
+ */
+export interface WebhookHandlerResult {
+    registration: WebhookRegistration;
+    events: WebhookEvent[];
+    webhookUrl: string;
+}
+/**
+ * Handler for webhook (wait) steps
+ */
+export declare class WebhookHandler {
+    private deps;
+    constructor(deps: WebhookHandlerDeps);
+    /**
+     * Execute the wait step
+     */
+    execute(step: WebhookStep): Promise<WebhookHandlerResult>;
+}

package/dist/interpreter/step-handlers/webhook-handler.js

@@ -0,0 +1,104 @@
+/**
+ * Webhook Handler
+ *
+ * Handles the 'wait' step for waiting on webhook callbacks.
+ */
+import { evaluate } from '../evaluator.js';
+import { RetrySignal } from '../signals.js';
+/**
+ * Handler for webhook (wait) steps
+ */
+export class WebhookHandler {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /**
+     * Execute the wait step
+     */
+    async execute(step) {
+        const { ctx, webhookServer, executionId, log } = this.deps;
+        // Register webhook endpoint
+        const timeout = step.timeout ?? 300000; // 5 minutes default
+        const expectedEvents = step.expectedEvents ?? 1;
+        const registration = await webhookServer.register(executionId, {
+            path: step.path,
+            timeout,
+            expectedEvents,
+            filter: step.eventFilter ? JSON.stringify(step.eventFilter) : undefined,
+        });
+        const webhookUrl = webhookServer.getWebhookUrl(registration);
+        log(`Waiting for webhook: ${webhookUrl} (timeout: ${timeout}ms, expected: ${expectedEvents})`);
+        // Set the webhook URL in context for use in subsequent steps
+        ctx.response = {
+            webhookId: registration.id,
+            webhookUrl,
+            webhookPath: registration.path,
+        };
+        // Wait for webhook events
+        const result = await webhookServer.waitForEvents(registration.id, timeout);
+        if (result.timedOut) {
+            log(`Webhook timeout: ${webhookUrl}`);
+            // Check if retry is configured
+            if (step.retryOnTimeout) {
+                throw new RetrySignal(step.retryOnTimeout);
+            }
+            // If not retrying, still return partial results
+            if (result.events.length === 0) {
+                throw new Error(`Webhook timeout: no events received within ${timeout}ms`);
+            }
+        }
+        // Filter events if filter expression provided
+        let events = result.events;
+        if (step.eventFilter && events.length > 0) {
+            events = events.filter((event) => {
+                try {
+                    const filterCtx = { ...ctx, response: event.body };
+                    return evaluate(step.eventFilter, filterCtx);
+                }
+                catch {
+                    return true; // Include on filter error
+                }
+            });
+        }
+        log(`Received ${events.length} webhook event(s)`);
+        // Set response to webhook events
+        if (events.length === 1) {
+            ctx.response = events[0].body;
+        }
+        else {
+            ctx.response = events.map((e) => e.body);
+        }
+        // Store events if storage configured
+        if (step.storage) {
+            const store = ctx.stores.get(step.storage.target);
+            if (store) {
+                for (const event of events) {
+                    const data = event.body;
+                    let key;
+                    if (step.storage.key) {
+                        const keyCtx = { ...ctx, response: event.body };
+                        const keyValue = evaluate(step.storage.key, keyCtx);
+                        key = String(keyValue);
+                    }
+                    else {
+                        // Generate a key from the event ID
+                        key = event.id;
+                    }
+                    await store.set(key, data);
+                    log(`Stored webhook event: ${key}`);
+                }
+            }
+            else {
+                log(`Warning: Store '${step.storage.target}' not found for webhook storage`);
+            }
+        }
+        // Clean up registration
+        await webhookServer.unregister(registration.id);
+        return {
+            registration,
+            events,
+            webhookUrl,
+        };
+    }
+}

package/dist/lexer/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Lexer module for Reqon.
+ *
+ * Uses Vague's Lexer with Reqon keywords registered via the plugin system.
+ * Importing this module automatically registers the Reqon plugin.
+ */
+import '../plugin.js';
+export { Lexer, Lexer as ReqonLexer, TokenType, type Token } from 'vague-lang';
+export { ReqonTokenType, REQON_KEYWORDS } from './tokens.js';
+export type { Token as ReqonToken } from 'vague-lang';

package/dist/lexer/index.js

@@ -0,0 +1,12 @@
+/**
+ * Lexer module for Reqon.
+ *
+ * Uses Vague's Lexer with Reqon keywords registered via the plugin system.
+ * Importing this module automatically registers the Reqon plugin.
+ */
+// Import plugin to auto-register Reqon keywords with Vague
+import '../plugin.js';
+// Re-export Vague's Lexer and TokenType as the primary lexer
+export { Lexer, Lexer as ReqonLexer, TokenType } from 'vague-lang';
+// Export Reqon-specific token types and keywords
+export { ReqonTokenType, REQON_KEYWORDS } from './tokens.js';

package/dist/lexer/lexer.d.ts

@@ -0,0 +1,24 @@
+import { type ReqonToken } from './tokens.js';
+export declare class ReqonLexer {
+    private source;
+    private pos;
+    private line;
+    private column;
+    constructor(source: string);
+    tokenize(): ReqonToken[];
+    private nextToken;
+    private readString;
+    private readNumber;
+    private readIdentifier;
+    private readOperator;
+    private skipWhitespace;
+    private skipLineComment;
+    private makeToken;
+    private peek;
+    private peekNext;
+    private advance;
+    private isAtEnd;
+    private isDigit;
+    private isAlpha;
+    private isAlphaNumeric;
+}