reqon-dsl 0.2.0 → 0.3.0

package/src/scheduler/scheduler.ts

@@ -1,443 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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

@@ -1,104 +0,0 @@
-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;
-}