reqon-dsl 0.2.0

package/dist/scheduler/scheduler.js

@@ -0,0 +1,376 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { MissionExecutor } from '../interpreter/executor.js';
+import { getNextRunTime, shouldRunNow } from './cron-parser.js';
+/**
+ * Scheduler for running missions on a schedule
+ */
+export class Scheduler {
+    config;
+    missions = new Map();
+    state;
+    running = false;
+    checkTimer = null;
+    retryTimers = new Set();
+    executorConfig;
+    constructor(config = {}, executorConfig = {}) {
+        this.config = {
+            stateDir: config.stateDir ?? '.reqon-data/scheduler',
+            checkInterval: config.checkInterval ?? 1000,
+            verbose: config.verbose ?? false,
+            callbacks: config.callbacks ?? {},
+        };
+        this.executorConfig = executorConfig;
+        this.state = {
+            jobs: {},
+            startedAt: new Date(),
+            lastUpdated: new Date(),
+        };
+    }
+    /**
+     * Register a mission for scheduling
+     */
+    register(mission, filePath) {
+        if (!mission.schedule) {
+            throw new Error(`Mission '${mission.name}' has no schedule defined`);
+        }
+        this.missions.set(mission.name, { mission, filePath });
+        // Create or update job state
+        const existingJob = this.state.jobs[mission.name];
+        const nextRun = getNextRunTime(mission.schedule);
+        this.state.jobs[mission.name] = {
+            id: mission.name,
+            missionName: mission.name,
+            schedule: mission.schedule,
+            enabled: true,
+            lastRun: existingJob?.lastRun,
+            nextRun: nextRun ?? undefined,
+            runCount: existingJob?.runCount ?? 0,
+            failureCount: existingJob?.failureCount ?? 0,
+            consecutiveFailures: existingJob?.consecutiveFailures ?? 0,
+            isRunning: false,
+        };
+        this.log(`Registered mission '${mission.name}' with ${this.formatSchedule(mission.schedule)}`);
+    }
+    /**
+     * Register all scheduled missions from a program
+     */
+    registerProgram(program, filePath) {
+        for (const statement of program.statements) {
+            if (statement.type === 'MissionDefinition' && statement.schedule) {
+                this.register(statement, filePath);
+            }
+        }
+    }
+    /**
+     * Start the scheduler
+     */
+    async start() {
+        if (this.running) {
+            this.log('Scheduler is already running');
+            return;
+        }
+        this.running = true;
+        this.state.startedAt = new Date();
+        // Load persisted state
+        await this.loadState();
+        this.log(`Scheduler started with ${Object.keys(this.state.jobs).length} jobs`);
+        // Start the check loop
+        this.checkTimer = setInterval(() => {
+            this.checkAndRun().catch((error) => {
+                this.log(`Scheduler check error: ${error.message}`);
+            });
+        }, this.config.checkInterval);
+        // Run initial check
+        await this.checkAndRun();
+    }
+    /**
+     * Stop the scheduler
+     */
+    async stop() {
+        if (!this.running)
+            return;
+        this.running = false;
+        if (this.checkTimer) {
+            clearInterval(this.checkTimer);
+            this.checkTimer = null;
+        }
+        // Clear all pending retry timers to prevent memory leaks
+        for (const timer of this.retryTimers) {
+            clearTimeout(timer);
+        }
+        this.retryTimers.clear();
+        // Save state
+        await this.saveState();
+        this.log('Scheduler stopped');
+    }
+    /**
+     * Check all jobs and run any that are due
+     */
+    async checkAndRun() {
+        const now = new Date();
+        for (const [name, job] of Object.entries(this.state.jobs)) {
+            if (!job.enabled)
+                continue;
+            const scheduledMission = this.missions.get(name);
+            if (!scheduledMission)
+                continue;
+            const schedule = scheduledMission.mission.schedule;
+            if (!schedule)
+                continue; // Mission must have schedule
+            // Check if job should run
+            if (shouldRunNow(schedule, job.lastRun, this.config.checkInterval)) {
+                // Check if already running
+                if (job.isRunning && (schedule.skipIfRunning !== false)) {
+                    this.emitEvent({
+                        type: 'skipped',
+                        jobId: job.id,
+                        missionName: job.missionName,
+                        timestamp: now,
+                        reason: 'Previous run still in progress',
+                    });
+                    continue;
+                }
+                // Run the job
+                await this.runJob(job, scheduledMission);
+            }
+        }
+    }
+    /**
+     * Run a scheduled job
+     */
+    async runJob(job, scheduledMission) {
+        const startTime = Date.now();
+        job.isRunning = true;
+        job.lastRun = new Date();
+        this.state.lastUpdated = new Date();
+        this.emitEvent({
+            type: 'started',
+            jobId: job.id,
+            missionName: job.missionName,
+            timestamp: job.lastRun,
+        });
+        try {
+            // Create executor and run mission
+            const executor = new MissionExecutor({
+                ...this.executorConfig,
+                verbose: this.config.verbose,
+            });
+            // Create a minimal program with just this mission
+            const program = {
+                type: 'ReqonProgram',
+                statements: [scheduledMission.mission],
+            };
+            const result = await executor.execute(program);
+            const duration = Date.now() - startTime;
+            if (result.success) {
+                job.runCount++;
+                job.consecutiveFailures = 0;
+                this.emitEvent({
+                    type: 'completed',
+                    jobId: job.id,
+                    missionName: job.missionName,
+                    timestamp: new Date(),
+                    duration,
+                });
+            }
+            else {
+                job.failureCount++;
+                job.consecutiveFailures++;
+                const errorMessage = result.errors.map((e) => e.message).join('; ');
+                this.emitEvent({
+                    type: 'failed',
+                    jobId: job.id,
+                    missionName: job.missionName,
+                    timestamp: new Date(),
+                    duration,
+                    error: errorMessage,
+                });
+                // Handle retry logic
+                await this.handleFailure(job, scheduledMission.mission.schedule);
+            }
+        }
+        catch (error) {
+            job.failureCount++;
+            job.consecutiveFailures++;
+            this.emitEvent({
+                type: 'failed',
+                jobId: job.id,
+                missionName: job.missionName,
+                timestamp: new Date(),
+                duration: Date.now() - startTime,
+                error: error.message,
+            });
+            // Handle retry logic
+            await this.handleFailure(job, scheduledMission.mission.schedule);
+        }
+        finally {
+            job.isRunning = false;
+            // Calculate next run time
+            job.nextRun = getNextRunTime(scheduledMission.mission.schedule, new Date()) ?? undefined;
+            await this.saveState();
+        }
+    }
+    /**
+     * Handle job failure with optional retry
+     */
+    async handleFailure(job, schedule) {
+        const retryConfig = schedule.retryOnFailure;
+        if (!retryConfig)
+            return;
+        if (job.consecutiveFailures <= retryConfig.maxRetries) {
+            this.log(`Job '${job.missionName}' failed, retrying in ${retryConfig.delaySeconds}s ` +
+                `(attempt ${job.consecutiveFailures}/${retryConfig.maxRetries})`);
+            // Schedule retry and track the timer to prevent memory leaks
+            const timer = setTimeout(() => {
+                this.retryTimers.delete(timer);
+                const scheduledMission = this.missions.get(job.missionName);
+                if (scheduledMission && this.running) {
+                    this.runJob(job, scheduledMission).catch((error) => {
+                        this.log(`Retry failed for '${job.missionName}': ${error.message}`);
+                    });
+                }
+            }, retryConfig.delaySeconds * 1000);
+            this.retryTimers.add(timer);
+        }
+        else {
+            this.log(`Job '${job.missionName}' exceeded max retries (${retryConfig.maxRetries}), waiting for next scheduled run`);
+        }
+    }
+    /**
+     * Enable a job
+     */
+    enable(missionName) {
+        const job = this.state.jobs[missionName];
+        if (job) {
+            job.enabled = true;
+            this.log(`Enabled job '${missionName}'`);
+        }
+    }
+    /**
+     * Disable a job
+     */
+    disable(missionName) {
+        const job = this.state.jobs[missionName];
+        if (job) {
+            job.enabled = false;
+            this.log(`Disabled job '${missionName}'`);
+        }
+    }
+    /**
+     * Get job status
+     */
+    getJob(missionName) {
+        return this.state.jobs[missionName];
+    }
+    /**
+     * Get all jobs
+     */
+    getJobs() {
+        return Object.values(this.state.jobs);
+    }
+    /**
+     * Trigger a job to run immediately
+     */
+    async trigger(missionName) {
+        const job = this.state.jobs[missionName];
+        const scheduledMission = this.missions.get(missionName);
+        if (!job || !scheduledMission) {
+            this.log(`Job '${missionName}' not found`);
+            return null;
+        }
+        if (job.isRunning) {
+            this.log(`Job '${missionName}' is already running`);
+            return null;
+        }
+        await this.runJob(job, scheduledMission);
+        // Return the last execution result (simplified - in practice would need to capture it)
+        return null;
+    }
+    /**
+     * Load state from disk
+     */
+    async loadState() {
+        try {
+            const statePath = join(this.config.stateDir, 'state.json');
+            const content = await readFile(statePath, 'utf-8');
+            const savedState = JSON.parse(content);
+            // Merge saved state with registered jobs
+            for (const [name, savedJob] of Object.entries(savedState.jobs)) {
+                if (this.state.jobs[name]) {
+                    this.state.jobs[name].lastRun = savedJob.lastRun ? new Date(savedJob.lastRun) : undefined;
+                    this.state.jobs[name].runCount = savedJob.runCount;
+                    this.state.jobs[name].failureCount = savedJob.failureCount;
+                    this.state.jobs[name].consecutiveFailures = savedJob.consecutiveFailures;
+                }
+            }
+            this.log('Loaded scheduler state from disk');
+        }
+        catch {
+            // No existing state, that's fine
+            this.log('No existing scheduler state found, starting fresh');
+        }
+    }
+    /**
+     * Save state to disk
+     */
+    async saveState() {
+        try {
+            await mkdir(this.config.stateDir, { recursive: true });
+            const statePath = join(this.config.stateDir, 'state.json');
+            await writeFile(statePath, JSON.stringify(this.state, null, 2));
+        }
+        catch (error) {
+            this.log(`Failed to save scheduler state: ${error.message}`);
+        }
+    }
+    /**
+     * Emit a schedule event
+     */
+    emitEvent(event) {
+        const { callbacks } = this.config;
+        if (!callbacks)
+            return;
+        switch (event.type) {
+            case 'started':
+                callbacks.onJobStarted?.(event);
+                break;
+            case 'completed':
+                callbacks.onJobCompleted?.(event);
+                break;
+            case 'failed':
+                callbacks.onJobFailed?.(event);
+                break;
+            case 'skipped':
+                callbacks.onJobSkipped?.(event);
+                break;
+        }
+        // Always log events in verbose mode
+        if (this.config.verbose) {
+            const details = event.duration ? ` (${event.duration}ms)` : '';
+            const error = event.error ? `: ${event.error}` : '';
+            const reason = event.reason ? `: ${event.reason}` : '';
+            this.log(`[${event.type.toUpperCase()}] ${event.missionName}${details}${error}${reason}`);
+        }
+    }
+    /**
+     * Format schedule for display
+     */
+    formatSchedule(schedule) {
+        switch (schedule.scheduleType) {
+            case 'interval':
+                return `every ${schedule.interval.value} ${schedule.interval.unit}`;
+            case 'cron':
+                return `cron "${schedule.cronExpression}"`;
+            case 'once':
+                return `at "${schedule.runAt}"`;
+            default:
+                return 'unknown schedule';
+        }
+    }
+    log(message) {
+        if (this.config.verbose) {
+            console.log(`[Reqon Scheduler] ${message}`);
+        }
+    }
+}

package/dist/scheduler/types.d.ts

@@ -0,0 +1,65 @@
+import type { ScheduleDefinition, MissionDefinition } from '../ast/nodes.js';
+/**
+ * Represents a scheduled job
+ */
+export interface ScheduledJob {
+    id: string;
+    missionName: string;
+    schedule: ScheduleDefinition;
+    enabled: boolean;
+    lastRun?: Date;
+    nextRun?: Date;
+    runCount: number;
+    failureCount: number;
+    consecutiveFailures: number;
+    isRunning: boolean;
+}
+/**
+ * Scheduler state persisted to disk
+ */
+export interface SchedulerState {
+    jobs: Record<string, ScheduledJob>;
+    startedAt: Date;
+    lastUpdated: Date;
+}
+/**
+ * Event emitted when a scheduled job runs
+ */
+export interface ScheduleEvent {
+    type: 'started' | 'completed' | 'failed' | 'skipped';
+    jobId: string;
+    missionName: string;
+    timestamp: Date;
+    duration?: number;
+    error?: string;
+    reason?: string;
+}
+/**
+ * Callbacks for schedule events
+ */
+export interface SchedulerCallbacks {
+    onJobStarted?: (event: ScheduleEvent) => void;
+    onJobCompleted?: (event: ScheduleEvent) => void;
+    onJobFailed?: (event: ScheduleEvent) => void;
+    onJobSkipped?: (event: ScheduleEvent) => void;
+}
+/**
+ * Configuration for the scheduler
+ */
+export interface SchedulerConfig {
+    /** Directory to store scheduler state (default: '.reqon-data/scheduler') */
+    stateDir?: string;
+    /** Callbacks for schedule events */
+    callbacks?: SchedulerCallbacks;
+    /** Check interval in milliseconds (default: 1000) */
+    checkInterval?: number;
+    /** Verbose logging */
+    verbose?: boolean;
+}
+/**
+ * Mission with its parsed program for execution
+ */
+export interface ScheduledMission {
+    mission: MissionDefinition;
+    filePath: string;
+}

package/dist/scheduler/types.js

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

package/dist/stores/factory.d.ts

@@ -0,0 +1,36 @@
+import type { StoreAdapter } from './types.js';
+import { type FileStoreOptions } from './file.js';
+import { type PostgRESTOptions } from './postgrest.js';
+import { type Logger } from '../utils/logger.js';
+export type StoreType = 'memory' | 'file' | 'sql' | 'nosql' | 'postgrest';
+export interface CreateStoreOptions {
+    /** Store type */
+    type: StoreType;
+    /** Store/collection name */
+    name: string;
+    /** Base directory for file stores (default: '.reqon-data') */
+    baseDir?: string;
+    /** File store options */
+    fileOptions?: FileStoreOptions;
+    /** PostgREST/Supabase options */
+    postgrest?: Omit<PostgRESTOptions, 'table'>;
+    /** Logger instance */
+    logger?: Logger;
+}
+/**
+ * Create a store adapter based on type
+ *
+ * For local development:
+ * - 'memory' - In-memory, lost on restart (good for tests)
+ * - 'file' - JSON files in .reqon-data/ (good for local dev)
+ *
+ * For production (not yet implemented):
+ * - 'sql' - PostgreSQL/MySQL
+ * - 'nosql' - MongoDB/DynamoDB
+ */
+export declare function createStore(options: CreateStoreOptions): StoreAdapter;
+/**
+ * Map DSL store type to adapter type
+ * In development mode, sql/nosql fall back to file stores
+ */
+export declare function resolveStoreType(dslType: 'sql' | 'nosql' | 'memory', developmentMode?: boolean): StoreType;

package/dist/stores/factory.js

@@ -0,0 +1,73 @@
+import { MemoryStore } from './memory.js';
+import { FileStore } from './file.js';
+import { PostgRESTStore } from './postgrest.js';
+import { createLogger } from '../utils/logger.js';
+/**
+ * Create a store adapter based on type
+ *
+ * For local development:
+ * - 'memory' - In-memory, lost on restart (good for tests)
+ * - 'file' - JSON files in .reqon-data/ (good for local dev)
+ *
+ * For production (not yet implemented):
+ * - 'sql' - PostgreSQL/MySQL
+ * - 'nosql' - MongoDB/DynamoDB
+ */
+export function createStore(options) {
+    const logger = options.logger ?? createLogger();
+    switch (options.type) {
+        case 'memory':
+            return new MemoryStore(options.name);
+        case 'file':
+            return new FileStore(options.name, {
+                ...options.fileOptions,
+                baseDir: options.baseDir ?? '.reqon-data',
+            });
+        case 'postgrest':
+            if (!options.postgrest) {
+                throw new Error(`PostgREST store requires 'postgrest' options with url and apiKey`);
+            }
+            return new PostgRESTStore({
+                ...options.postgrest,
+                table: options.name,
+            });
+        case 'sql':
+            // If postgrest options provided, use PostgREST adapter (works with Supabase)
+            if (options.postgrest) {
+                return new PostgRESTStore({
+                    ...options.postgrest,
+                    table: options.name,
+                });
+            }
+            // TODO: Implement raw SQL adapter (pg, mysql2, etc.)
+            logger.warn(`SQL store not yet implemented, falling back to file store for '${options.name}'`);
+            return new FileStore(options.name, {
+                ...options.fileOptions,
+                baseDir: options.baseDir ?? '.reqon-data/sql',
+            });
+        case 'nosql':
+            // TODO: Implement NoSQL adapter
+            logger.warn(`NoSQL store not yet implemented, falling back to file store for '${options.name}'`);
+            return new FileStore(options.name, {
+                ...options.fileOptions,
+                baseDir: options.baseDir ?? '.reqon-data/nosql',
+            });
+        default:
+            throw new Error(`Unknown store type: ${options.type}`);
+    }
+}
+/**
+ * Map DSL store type to adapter type
+ * In development mode, sql/nosql fall back to file stores
+ */
+export function resolveStoreType(dslType, developmentMode = true) {
+    if (dslType === 'memory') {
+        return 'memory';
+    }
+    if (developmentMode) {
+        // Use file stores for local development
+        return 'file';
+    }
+    // In production, use the actual type
+    return dslType;
+}

package/dist/stores/file.d.ts

@@ -0,0 +1,60 @@
+import type { StoreAdapter, StoreFilter } from './types.js';
+export interface FileStoreOptions {
+    /** Base directory for data files (default: '.reqon-data') */
+    baseDir?: string;
+    /** Write mode: 'immediate' writes on every change, 'batch' only on flush/close, 'debounce' batches writes */
+    persist?: 'immediate' | 'batch' | 'debounce';
+    /** Pretty-print JSON for readability (default: true) */
+    pretty?: boolean;
+    /** Debounce delay in milliseconds (default: 100ms, only used with persist: 'debounce') */
+    debounceMs?: number;
+}
+/**
+ * File-based JSON store for local development
+ * Persists data to .reqon-data/{name}.json
+ */
+export declare class FileStore implements StoreAdapter {
+    private data;
+    private filePath;
+    private options;
+    private dirty;
+    private initialized;
+    private debounceTimer;
+    private pendingWrite;
+    constructor(name: string, options?: FileStoreOptions);
+    private init;
+    private load;
+    private persist;
+    private scheduleDebouncedWrite;
+    private writeToDisk;
+    /** Synchronous write for flush/close operations */
+    private writeToDiskSync;
+    get(key: string): Promise<Record<string, unknown> | null>;
+    set(key: string, value: Record<string, unknown>): Promise<void>;
+    bulkSet(records: Array<{
+        key: string;
+        value: Record<string, unknown>;
+    }>): Promise<void>;
+    update(key: string, value: Partial<Record<string, unknown>>): Promise<void>;
+    delete(key: string): Promise<void>;
+    list(filter?: StoreFilter): Promise<Record<string, unknown>[]>;
+    count(filter?: StoreFilter): Promise<number>;
+    clear(): Promise<void>;
+    /**
+     * Flush pending changes to disk (needed in 'batch' or 'debounce' mode)
+     * Uses synchronous I/O to ensure data is written before process exits
+     */
+    flush(): void;
+    /**
+     * Close the store, ensuring all pending changes are written to disk.
+     * Should be called before the process exits to prevent data loss in batch mode.
+     */
+    close(): void;
+    /**
+     * Reload data from disk (useful if file was modified externally)
+     */
+    reload(): Promise<void>;
+    size(): number;
+    dump(): Record<string, unknown>[];
+    getFilePath(): string;
+}