reqon-dsl 0.2.0

package/dist/webhook/server.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Webhook Server
+ *
+ * HTTP server for receiving webhook callbacks.
+ * Supports dynamic registration of webhook endpoints.
+ */
+import type { WebhookServerConfig, WebhookServerCallbacks, WebhookRegistration, WaitResult } from './types.js';
+import type { WebhookStore } from './store.js';
+/**
+ * Webhook Server
+ *
+ * Provides HTTP endpoints for receiving webhook callbacks.
+ */
+export declare class WebhookServer {
+    private config;
+    private store;
+    private callbacks;
+    private server?;
+    private pendingWaits;
+    private cleanupInterval?;
+    private running;
+    constructor(config?: WebhookServerConfig, store?: WebhookStore, callbacks?: WebhookServerCallbacks);
+    /**
+     * Start the webhook server
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the webhook server
+     */
+    stop(): Promise<void>;
+    /**
+     * Register a webhook endpoint
+     */
+    register(executionId: string, options?: {
+        path?: string;
+        timeout?: number;
+        expectedEvents?: number;
+        filter?: string;
+    }): Promise<WebhookRegistration>;
+    /**
+     * Get the full URL for a webhook endpoint
+     */
+    getWebhookUrl(registration: WebhookRegistration): string;
+    /**
+     * Wait for webhook events
+     */
+    waitForEvents(registrationId: string, timeout?: number): Promise<WaitResult>;
+    /**
+     * Unregister a webhook endpoint
+     */
+    unregister(registrationId: string): Promise<void>;
+    /**
+     * Check if the server is running
+     */
+    isRunning(): boolean;
+    /**
+     * Get the server port
+     */
+    getPort(): number;
+    /**
+     * Get the base URL
+     */
+    getBaseUrl(): string;
+    /**
+     * Handle incoming HTTP request
+     */
+    private handleRequest;
+    /**
+     * Read request body
+     */
+    private readBody;
+    /**
+     * Extract headers from request
+     */
+    private extractHeaders;
+    /**
+     * Clean up expired registrations
+     */
+    private cleanup;
+    /**
+     * Log message if verbose mode enabled
+     */
+    private log;
+}

package/dist/webhook/server.js

@@ -0,0 +1,319 @@
+/**
+ * Webhook Server
+ *
+ * HTTP server for receiving webhook callbacks.
+ * Supports dynamic registration of webhook endpoints.
+ */
+import { createServer } from 'node:http';
+import { parse as parseUrl } from 'node:url';
+import { randomUUID } from 'node:crypto';
+import { MemoryWebhookStore } from './store.js';
+/**
+ * Webhook Server
+ *
+ * Provides HTTP endpoints for receiving webhook callbacks.
+ */
+export class WebhookServer {
+    config;
+    store;
+    callbacks;
+    server;
+    pendingWaits = new Map();
+    cleanupInterval;
+    running = false;
+    constructor(config = {}, store, callbacks = {}) {
+        this.config = {
+            port: config.port ?? 3000,
+            host: config.host ?? '0.0.0.0',
+            baseUrl: config.baseUrl ?? `http://localhost:${config.port ?? 3000}`,
+            defaultTimeout: config.defaultTimeout ?? 300000, // 5 minutes
+            verbose: config.verbose ?? false,
+        };
+        this.store = store ?? new MemoryWebhookStore();
+        this.callbacks = callbacks;
+    }
+    /**
+     * Start the webhook server
+     */
+    async start() {
+        if (this.running)
+            return;
+        return new Promise((resolve, reject) => {
+            this.server = createServer((req, res) => this.handleRequest(req, res));
+            this.server.on('error', (error) => {
+                reject(error);
+            });
+            this.server.listen(this.config.port, this.config.host, () => {
+                this.running = true;
+                this.log(`Webhook server listening on ${this.config.host}:${this.config.port}`);
+                // Start cleanup interval (every minute)
+                this.cleanupInterval = setInterval(() => this.cleanup(), 60000);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Stop the webhook server
+     */
+    async stop() {
+        if (!this.running)
+            return;
+        // Clear cleanup interval
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = undefined;
+        }
+        // Cancel all pending waits
+        for (const [id, pending] of this.pendingWaits) {
+            clearTimeout(pending.timeoutId);
+            pending.resolve({
+                success: false,
+                events: [],
+                error: 'Server shutting down',
+            });
+        }
+        this.pendingWaits.clear();
+        // Close server
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => {
+                    this.running = false;
+                    this.log('Webhook server stopped');
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    /**
+     * Register a webhook endpoint
+     */
+    async register(executionId, options = {}) {
+        const id = randomUUID();
+        const timeout = options.timeout ?? this.config.defaultTimeout;
+        const path = options.path ?? `/webhook/${executionId}/${id}`;
+        const registration = {
+            id,
+            executionId,
+            path,
+            createdAt: new Date(),
+            expiresAt: new Date(Date.now() + timeout),
+            expectedEvents: options.expectedEvents ?? 1,
+            receivedEvents: 0,
+            filter: options.filter,
+        };
+        await this.store.saveRegistration(registration);
+        this.callbacks.onRegistrationCreated?.(registration);
+        this.log(`Registered webhook: ${path} (expires: ${registration.expiresAt.toISOString()})`);
+        return registration;
+    }
+    /**
+     * Get the full URL for a webhook endpoint
+     */
+    getWebhookUrl(registration) {
+        return `${this.config.baseUrl}${registration.path}`;
+    }
+    /**
+     * Wait for webhook events
+     */
+    async waitForEvents(registrationId, timeout) {
+        const registration = await this.store.getRegistration(registrationId);
+        if (!registration) {
+            return {
+                success: false,
+                events: [],
+                error: `Registration not found: ${registrationId}`,
+            };
+        }
+        // Check if already received enough events
+        const events = await this.store.getEvents(registrationId);
+        if (events.length >= registration.expectedEvents) {
+            return { success: true, events };
+        }
+        // Wait for more events
+        const waitTimeout = timeout ?? (registration.expiresAt.getTime() - Date.now());
+        return new Promise((resolve) => {
+            const timeoutId = setTimeout(() => {
+                this.pendingWaits.delete(registrationId);
+                this.store.getEvents(registrationId).then((events) => {
+                    resolve({
+                        success: events.length >= registration.expectedEvents,
+                        events,
+                        timedOut: true,
+                    });
+                });
+            }, waitTimeout);
+            this.pendingWaits.set(registrationId, {
+                registrationId,
+                resolve,
+                timeoutId,
+            });
+        });
+    }
+    /**
+     * Unregister a webhook endpoint
+     */
+    async unregister(registrationId) {
+        await this.store.deleteRegistration(registrationId);
+        await this.store.deleteEvents(registrationId);
+        // Cancel pending wait if any
+        const pending = this.pendingWaits.get(registrationId);
+        if (pending) {
+            clearTimeout(pending.timeoutId);
+            this.pendingWaits.delete(registrationId);
+        }
+        this.log(`Unregistered webhook: ${registrationId}`);
+    }
+    /**
+     * Check if the server is running
+     */
+    isRunning() {
+        return this.running;
+    }
+    /**
+     * Get the server port
+     */
+    getPort() {
+        return this.config.port;
+    }
+    /**
+     * Get the base URL
+     */
+    getBaseUrl() {
+        return this.config.baseUrl;
+    }
+    /**
+     * Handle incoming HTTP request
+     */
+    async handleRequest(req, res) {
+        const url = parseUrl(req.url ?? '/', true);
+        const path = url.pathname ?? '/';
+        // Health check endpoint
+        if (path === '/health' || path === '/_health') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ status: 'ok', timestamp: new Date().toISOString() }));
+            return;
+        }
+        // Find matching registration
+        const registration = await this.store.getRegistrationByPath(path);
+        if (!registration) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Not found', path }));
+            return;
+        }
+        // Check if registration is expired
+        if (registration.expiresAt < new Date()) {
+            res.writeHead(410, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Webhook registration expired' }));
+            await this.store.deleteRegistration(registration.id);
+            return;
+        }
+        // Parse request body
+        let rawBody = '';
+        let body = null;
+        try {
+            rawBody = await this.readBody(req);
+            if (rawBody) {
+                const contentType = req.headers['content-type'] ?? '';
+                if (contentType.includes('application/json')) {
+                    body = JSON.parse(rawBody);
+                }
+                else if (contentType.includes('application/x-www-form-urlencoded')) {
+                    body = Object.fromEntries(new URLSearchParams(rawBody));
+                }
+                else {
+                    body = rawBody;
+                }
+            }
+        }
+        catch (error) {
+            body = rawBody;
+        }
+        // Create event
+        const event = {
+            id: randomUUID(),
+            registrationId: registration.id,
+            receivedAt: new Date(),
+            method: req.method ?? 'POST',
+            headers: this.extractHeaders(req),
+            body,
+            rawBody,
+            query: url.query,
+        };
+        // Save event
+        await this.store.saveEvent(event);
+        registration.receivedEvents++;
+        await this.store.saveRegistration(registration);
+        this.log(`Webhook received: ${path} (${registration.receivedEvents}/${registration.expectedEvents})`);
+        this.callbacks.onWebhookReceived?.(event);
+        // Check if all expected events received
+        if (registration.receivedEvents >= registration.expectedEvents) {
+            const events = await this.store.getEvents(registration.id);
+            this.callbacks.onRegistrationComplete?.(registration, events);
+            // Resolve pending wait
+            const pending = this.pendingWaits.get(registration.id);
+            if (pending) {
+                clearTimeout(pending.timeoutId);
+                this.pendingWaits.delete(registration.id);
+                pending.resolve({ success: true, events });
+            }
+        }
+        // Send response
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            success: true,
+            eventId: event.id,
+            received: registration.receivedEvents,
+            expected: registration.expectedEvents,
+        }));
+    }
+    /**
+     * Read request body
+     */
+    readBody(req) {
+        return new Promise((resolve, reject) => {
+            let data = '';
+            req.on('data', (chunk) => {
+                data += chunk;
+            });
+            req.on('end', () => {
+                resolve(data);
+            });
+            req.on('error', reject);
+        });
+    }
+    /**
+     * Extract headers from request
+     */
+    extractHeaders(req) {
+        const headers = {};
+        for (const [key, value] of Object.entries(req.headers)) {
+            if (typeof value === 'string') {
+                headers[key] = value;
+            }
+            else if (Array.isArray(value)) {
+                headers[key] = value.join(', ');
+            }
+        }
+        return headers;
+    }
+    /**
+     * Clean up expired registrations
+     */
+    async cleanup() {
+        const cleaned = await this.store.cleanupExpired();
+        if (cleaned > 0) {
+            this.log(`Cleaned up ${cleaned} expired webhook registration(s)`);
+        }
+    }
+    /**
+     * Log message if verbose mode enabled
+     */
+    log(message) {
+        if (this.config.verbose) {
+            console.log(`[Webhook] ${message}`);
+        }
+    }
+}

package/dist/webhook/store.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Webhook Store
+ *
+ * Stores webhook registrations and received events.
+ * Supports both in-memory and file-based persistence.
+ */
+import type { WebhookRegistration, WebhookEvent } from './types.js';
+/**
+ * Interface for webhook storage
+ */
+export interface WebhookStore {
+    /** Save a webhook registration */
+    saveRegistration(registration: WebhookRegistration): Promise<void>;
+    /** Get a registration by ID */
+    getRegistration(id: string): Promise<WebhookRegistration | undefined>;
+    /** Get a registration by path */
+    getRegistrationByPath(path: string): Promise<WebhookRegistration | undefined>;
+    /** Delete a registration */
+    deleteRegistration(id: string): Promise<void>;
+    /** List all registrations */
+    listRegistrations(): Promise<WebhookRegistration[]>;
+    /** Save a webhook event */
+    saveEvent(event: WebhookEvent): Promise<void>;
+    /** Get events for a registration */
+    getEvents(registrationId: string): Promise<WebhookEvent[]>;
+    /** Delete events for a registration */
+    deleteEvents(registrationId: string): Promise<void>;
+    /** Clean up expired registrations */
+    cleanupExpired(): Promise<number>;
+}
+/**
+ * In-memory webhook store
+ */
+export declare class MemoryWebhookStore implements WebhookStore {
+    private registrations;
+    private events;
+    private pathIndex;
+    saveRegistration(registration: WebhookRegistration): Promise<void>;
+    getRegistration(id: string): Promise<WebhookRegistration | undefined>;
+    getRegistrationByPath(path: string): Promise<WebhookRegistration | undefined>;
+    deleteRegistration(id: string): Promise<void>;
+    listRegistrations(): Promise<WebhookRegistration[]>;
+    saveEvent(event: WebhookEvent): Promise<void>;
+    getEvents(registrationId: string): Promise<WebhookEvent[]>;
+    deleteEvents(registrationId: string): Promise<void>;
+    cleanupExpired(): Promise<number>;
+}
+/**
+ * File-based webhook store for persistence across restarts
+ */
+export declare class FileWebhookStore implements WebhookStore {
+    private baseDir;
+    private registrationsDir;
+    private eventsDir;
+    private initialized;
+    constructor(baseDir?: string);
+    private ensureInit;
+    saveRegistration(registration: WebhookRegistration): Promise<void>;
+    getRegistration(id: string): Promise<WebhookRegistration | undefined>;
+    getRegistrationByPath(path: string): Promise<WebhookRegistration | undefined>;
+    deleteRegistration(id: string): Promise<void>;
+    listRegistrations(): Promise<WebhookRegistration[]>;
+    saveEvent(event: WebhookEvent): Promise<void>;
+    getEvents(registrationId: string): Promise<WebhookEvent[]>;
+    deleteEvents(registrationId: string): Promise<void>;
+    cleanupExpired(): Promise<number>;
+}

package/dist/webhook/store.js

@@ -0,0 +1,193 @@
+/**
+ * Webhook Store
+ *
+ * Stores webhook registrations and received events.
+ * Supports both in-memory and file-based persistence.
+ */
+import { mkdir, readFile, writeFile, readdir, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+/**
+ * In-memory webhook store
+ */
+export class MemoryWebhookStore {
+    registrations = new Map();
+    events = new Map();
+    pathIndex = new Map(); // path -> registrationId
+    async saveRegistration(registration) {
+        this.registrations.set(registration.id, registration);
+        this.pathIndex.set(registration.path, registration.id);
+    }
+    async getRegistration(id) {
+        return this.registrations.get(id);
+    }
+    async getRegistrationByPath(path) {
+        const id = this.pathIndex.get(path);
+        if (!id)
+            return undefined;
+        return this.registrations.get(id);
+    }
+    async deleteRegistration(id) {
+        const reg = this.registrations.get(id);
+        if (reg) {
+            this.pathIndex.delete(reg.path);
+        }
+        this.registrations.delete(id);
+    }
+    async listRegistrations() {
+        return Array.from(this.registrations.values());
+    }
+    async saveEvent(event) {
+        const events = this.events.get(event.registrationId) ?? [];
+        events.push(event);
+        this.events.set(event.registrationId, events);
+    }
+    async getEvents(registrationId) {
+        return this.events.get(registrationId) ?? [];
+    }
+    async deleteEvents(registrationId) {
+        this.events.delete(registrationId);
+    }
+    async cleanupExpired() {
+        const now = new Date();
+        let cleaned = 0;
+        for (const [id, reg] of this.registrations) {
+            if (reg.expiresAt < now) {
+                await this.deleteRegistration(id);
+                await this.deleteEvents(id);
+                cleaned++;
+            }
+        }
+        return cleaned;
+    }
+}
+/**
+ * File-based webhook store for persistence across restarts
+ */
+export class FileWebhookStore {
+    baseDir;
+    registrationsDir;
+    eventsDir;
+    initialized = false;
+    constructor(baseDir = '.reqon-data/webhooks') {
+        this.baseDir = baseDir;
+        this.registrationsDir = join(baseDir, 'registrations');
+        this.eventsDir = join(baseDir, 'events');
+    }
+    async ensureInit() {
+        if (this.initialized)
+            return;
+        await mkdir(this.registrationsDir, { recursive: true });
+        await mkdir(this.eventsDir, { recursive: true });
+        this.initialized = true;
+    }
+    async saveRegistration(registration) {
+        await this.ensureInit();
+        const filePath = join(this.registrationsDir, `${registration.id}.json`);
+        await writeFile(filePath, JSON.stringify(registration, null, 2));
+    }
+    async getRegistration(id) {
+        await this.ensureInit();
+        try {
+            const filePath = join(this.registrationsDir, `${id}.json`);
+            const content = await readFile(filePath, 'utf-8');
+            const data = JSON.parse(content);
+            return {
+                ...data,
+                createdAt: new Date(data.createdAt),
+                expiresAt: new Date(data.expiresAt),
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async getRegistrationByPath(path) {
+        const registrations = await this.listRegistrations();
+        return registrations.find((r) => r.path === path);
+    }
+    async deleteRegistration(id) {
+        await this.ensureInit();
+        try {
+            const filePath = join(this.registrationsDir, `${id}.json`);
+            await unlink(filePath);
+        }
+        catch {
+            // Ignore if file doesn't exist
+        }
+    }
+    async listRegistrations() {
+        await this.ensureInit();
+        try {
+            const files = await readdir(this.registrationsDir);
+            const registrations = [];
+            for (const file of files) {
+                if (!file.endsWith('.json'))
+                    continue;
+                const id = file.replace('.json', '');
+                const reg = await this.getRegistration(id);
+                if (reg)
+                    registrations.push(reg);
+            }
+            return registrations;
+        }
+        catch {
+            return [];
+        }
+    }
+    async saveEvent(event) {
+        await this.ensureInit();
+        const eventDir = join(this.eventsDir, event.registrationId);
+        await mkdir(eventDir, { recursive: true });
+        const filePath = join(eventDir, `${event.id}.json`);
+        await writeFile(filePath, JSON.stringify(event, null, 2));
+    }
+    async getEvents(registrationId) {
+        await this.ensureInit();
+        try {
+            const eventDir = join(this.eventsDir, registrationId);
+            const files = await readdir(eventDir);
+            const events = [];
+            for (const file of files) {
+                if (!file.endsWith('.json'))
+                    continue;
+                const filePath = join(eventDir, file);
+                const content = await readFile(filePath, 'utf-8');
+                const data = JSON.parse(content);
+                events.push({
+                    ...data,
+                    receivedAt: new Date(data.receivedAt),
+                });
+            }
+            return events.sort((a, b) => a.receivedAt.getTime() - b.receivedAt.getTime());
+        }
+        catch {
+            return [];
+        }
+    }
+    async deleteEvents(registrationId) {
+        await this.ensureInit();
+        try {
+            const eventDir = join(this.eventsDir, registrationId);
+            const files = await readdir(eventDir);
+            for (const file of files) {
+                await unlink(join(eventDir, file));
+            }
+        }
+        catch {
+            // Ignore if directory doesn't exist
+        }
+    }
+    async cleanupExpired() {
+        const now = new Date();
+        const registrations = await this.listRegistrations();
+        let cleaned = 0;
+        for (const reg of registrations) {
+            if (reg.expiresAt < now) {
+                await this.deleteRegistration(reg.id);
+                await this.deleteEvents(reg.id);
+                cleaned++;
+            }
+        }
+        return cleaned;
+    }
+}