reqon-dsl 0.2.0

package/src/scheduler/scheduler.ts

@@ -0,0 +1,443 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import type { ReqonProgram, MissionDefinition, ScheduleDefinition } from '../ast/nodes.js';
+import type { ExecutorConfig, ExecutionResult } from '../interpreter/executor.js';
+import { MissionExecutor } from '../interpreter/executor.js';
+import type {
+  ScheduledJob,
+  SchedulerState,
+  ScheduleEvent,
+  SchedulerCallbacks,
+  SchedulerConfig,
+  ScheduledMission,
+} from './types.js';
+import { getNextRunTime, shouldRunNow } from './cron-parser.js';
+
+/**
+ * Scheduler for running missions on a schedule
+ */
+export class Scheduler {
+  private config: SchedulerConfig;
+  private missions: Map<string, ScheduledMission> = new Map();
+  private state: SchedulerState;
+  private running = false;
+  private checkTimer: NodeJS.Timeout | null = null;
+  private retryTimers: Set<NodeJS.Timeout> = new Set();
+  private executorConfig: ExecutorConfig;
+
+  constructor(config: SchedulerConfig = {}, executorConfig: 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: MissionDefinition, filePath: string): void {
+    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: ReqonProgram, filePath: string): void {
+    for (const statement of program.statements) {
+      if (statement.type === 'MissionDefinition' && statement.schedule) {
+        this.register(statement, filePath);
+      }
+    }
+  }
+
+  /**
+   * Start the scheduler
+   */
+  async start(): Promise<void> {
+    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(): Promise<void> {
+    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
+   */
+  private async checkAndRun(): Promise<void> {
+    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
+   */
+  private async runJob(job: ScheduledJob, scheduledMission: ScheduledMission): Promise<void> {
+    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: ReqonProgram = {
+        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 as 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
+   */
+  private async handleFailure(job: ScheduledJob, schedule: ScheduleDefinition): Promise<void> {
+    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: string): void {
+    const job = this.state.jobs[missionName];
+    if (job) {
+      job.enabled = true;
+      this.log(`Enabled job '${missionName}'`);
+    }
+  }
+
+  /**
+   * Disable a job
+   */
+  disable(missionName: string): void {
+    const job = this.state.jobs[missionName];
+    if (job) {
+      job.enabled = false;
+      this.log(`Disabled job '${missionName}'`);
+    }
+  }
+
+  /**
+   * Get job status
+   */
+  getJob(missionName: string): ScheduledJob | undefined {
+    return this.state.jobs[missionName];
+  }
+
+  /**
+   * Get all jobs
+   */
+  getJobs(): ScheduledJob[] {
+    return Object.values(this.state.jobs);
+  }
+
+  /**
+   * Trigger a job to run immediately
+   */
+  async trigger(missionName: string): Promise<ExecutionResult | null> {
+    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
+   */
+  private async loadState(): Promise<void> {
+    try {
+      const statePath = join(this.config.stateDir!, 'state.json');
+      const content = await readFile(statePath, 'utf-8');
+      const savedState = JSON.parse(content) as SchedulerState;
+
+      // 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
+   */
+  private async saveState(): Promise<void> {
+    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 as Error).message}`);
+    }
+  }
+
+  /**
+   * Emit a schedule event
+   */
+  private emitEvent(event: ScheduleEvent): void {
+    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
+   */
+  private formatSchedule(schedule: ScheduleDefinition): string {
+    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';
+    }
+  }
+
+  private log(message: string): void {
+    if (this.config.verbose) {
+      console.log(`[Reqon Scheduler] ${message}`);
+    }
+  }
+}

package/src/scheduler/types.ts

@@ -0,0 +1,71 @@
+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; // For skipped events (e.g., "still running")
+}
+
+/**
+ * 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/src/stores/factory.ts

@@ -0,0 +1,104 @@
+import type { StoreAdapter } from './types.js';
+import { MemoryStore } from './memory.js';
+import { FileStore, type FileStoreOptions } from './file.js';
+import { PostgRESTStore, type PostgRESTOptions } from './postgrest.js';
+import { type Logger, createLogger } 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 function createStore(options: CreateStoreOptions): StoreAdapter {
+  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: 'sql' | 'nosql' | 'memory',
+  developmentMode = true
+): StoreType {
+  if (dslType === 'memory') {
+    return 'memory';
+  }
+
+  if (developmentMode) {
+    // Use file stores for local development
+    return 'file';
+  }
+
+  // In production, use the actual type
+  return dslType;
+}