reqon-dsl 0.2.0 → 0.4.0

package/src/execution/store.ts

@@ -1,188 +0,0 @@
-import { join } from 'node:path';
-import type { ExecutionState } from './state.js';
-import {
-  ensureDirectory,
-  writeJsonFile,
-  readJsonFile,
-  listFiles,
-  deleteFile,
-  restoreDates,
-  restoreDatesInArray,
-} from '../utils/file.js';
-
-/**
- * Execution state store interface
- */
-export interface ExecutionStore {
-  /** Save execution state */
-  save(state: ExecutionState): Promise<void>;
-
-  /** Load execution state by ID */
-  load(id: string): Promise<ExecutionState | null>;
-
-  /** List all executions for a mission */
-  listByMission(mission: string): Promise<ExecutionState[]>;
-
-  /** List recent executions */
-  listRecent(limit?: number): Promise<ExecutionState[]>;
-
-  /** Delete execution state */
-  delete(id: string): Promise<void>;
-
-  /** Find the latest execution for a mission */
-  findLatest(mission: string): Promise<ExecutionState | null>;
-
-  /** Find resumable executions (failed/paused) */
-  findResumable(mission: string): Promise<ExecutionState[]>;
-}
-
-/**
- * File-based execution state store
- * Stores each execution as a JSON file in .reqon-data/executions/
- */
-export class FileExecutionStore implements ExecutionStore {
-  private baseDir: string;
-  private initialized: Promise<void>;
-
-  constructor(baseDir = '.reqon-data/executions') {
-    this.baseDir = baseDir;
-    this.initialized = ensureDirectory(this.baseDir);
-  }
-
-  private getFilePath(id: string): string {
-    return join(this.baseDir, `${id}.json`);
-  }
-
-  private deserialize(parsed: Record<string, unknown>): ExecutionState {
-    // Restore Date objects
-    restoreDates(parsed, ['startedAt', 'completedAt']);
-    if (parsed.checkpoint && typeof parsed.checkpoint === 'object') {
-      restoreDates(parsed.checkpoint as Record<string, unknown>, ['createdAt']);
-    }
-    restoreDatesInArray(
-      parsed.stages as Record<string, unknown>[],
-      ['startedAt', 'completedAt']
-    );
-    restoreDatesInArray(
-      parsed.errors as Record<string, unknown>[],
-      ['timestamp']
-    );
-
-    return parsed as unknown as ExecutionState;
-  }
-
-  async save(state: ExecutionState): Promise<void> {
-    await this.initialized;
-    const filePath = this.getFilePath(state.id);
-    await writeJsonFile(filePath, state);
-  }
-
-  async load(id: string): Promise<ExecutionState | null> {
-    await this.initialized;
-    const filePath = this.getFilePath(id);
-    const parsed = await readJsonFile<Record<string, unknown>>(filePath);
-    return parsed ? this.deserialize(parsed) : null;
-  }
-
-  async listByMission(mission: string): Promise<ExecutionState[]> {
-    const all = await this.listRecent();
-    return all.filter((s) => s.mission === mission);
-  }
-
-  async listRecent(limit = 50): Promise<ExecutionState[]> {
-    await this.initialized;
-
-    const files = await listFiles(this.baseDir, '.json');
-    const states: ExecutionState[] = [];
-
-    for (const file of files) {
-      const parsed = await readJsonFile<Record<string, unknown>>(file);
-      if (parsed) {
-        states.push(this.deserialize(parsed));
-      }
-    }
-
-    // Sort by start time, newest first
-    states.sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());
-
-    return states.slice(0, limit);
-  }
-
-  async delete(id: string): Promise<void> {
-    await this.initialized;
-    await deleteFile(this.getFilePath(id));
-  }
-
-  async findLatest(mission: string): Promise<ExecutionState | null> {
-    const executions = await this.listByMission(mission);
-    return executions[0] ?? null;
-  }
-
-  async findResumable(mission: string): Promise<ExecutionState[]> {
-    const executions = await this.listByMission(mission);
-    return executions.filter((e) => e.status === 'failed' || e.status === 'paused');
-  }
-}
-
-/**
- * In-memory execution store (for testing)
- */
-export class MemoryExecutionStore implements ExecutionStore {
-  private states: Map<string, ExecutionState> = new Map();
-
-  async save(state: ExecutionState): Promise<void> {
-    // Deep clone to avoid reference issues
-    this.states.set(state.id, JSON.parse(JSON.stringify(state)));
-  }
-
-  async load(id: string): Promise<ExecutionState | null> {
-    const state = this.states.get(id);
-    if (!state) return null;
-
-    // Restore Date objects
-    const restored = JSON.parse(JSON.stringify(state));
-    restored.startedAt = new Date(restored.startedAt);
-    if (restored.completedAt) {
-      restored.completedAt = new Date(restored.completedAt);
-    }
-
-    return restored;
-  }
-
-  async listByMission(mission: string): Promise<ExecutionState[]> {
-    const all = await this.listRecent();
-    return all.filter((s) => s.mission === mission);
-  }
-
-  async listRecent(limit = 50): Promise<ExecutionState[]> {
-    const states = Array.from(this.states.values()).map((s) => {
-      const restored = JSON.parse(JSON.stringify(s));
-      restored.startedAt = new Date(restored.startedAt);
-      if (restored.completedAt) {
-        restored.completedAt = new Date(restored.completedAt);
-      }
-      return restored as ExecutionState;
-    });
-
-    states.sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());
-    return states.slice(0, limit);
-  }
-
-  async delete(id: string): Promise<void> {
-    this.states.delete(id);
-  }
-
-  async findLatest(mission: string): Promise<ExecutionState | null> {
-    const executions = await this.listByMission(mission);
-    return executions[0] ?? null;
-  }
-
-  async findResumable(mission: string): Promise<ExecutionState[]> {
-    const executions = await this.listByMission(mission);
-    return executions.filter((e) => e.status === 'failed' || e.status === 'paused');
-  }
-
-  clear(): void {
-    this.states.clear();
-  }
-}

package/src/index.ts

@@ -1,169 +0,0 @@
-export { ReqonLexer, ReqonTokenType, type ReqonToken } from './lexer/index.js';
-export { reqonPlugin, registerReqonPlugin } from './plugin.js';
-export { ReqonParser } from './parser/index.js';
-export * from './ast/index.js';
-export {
-  MissionExecutor,
-  HttpClient,
-  BearerAuthProvider,
-  OAuth2AuthProvider,
-  createContext,
-  evaluate,
-  type ExecutionResult,
-  type ExecutionError,
-  type ExecutorConfig,
-  type ExecutionContext,
-  type ProgressCallbacks,
-  type ExecutionStartEvent,
-  type ExecutionCompleteEvent,
-  type StageStartEvent,
-  type StageCompleteEvent,
-} from './interpreter/index.js';
-export {
-  MemoryStore,
-  FileStore,
-  createStore,
-  type StoreAdapter,
-  type StoreFilter,
-  type StoreConfig,
-} from './stores/index.js';
-export {
-  createExecutionState,
-  findResumePoint,
-  canResume,
-  getProgress,
-  getExecutionSummary,
-  FileExecutionStore,
-  MemoryExecutionStore,
-  type ExecutionState,
-  type ExecutionStore,
-  type StageState,
-} from './execution/index.js';
-export {
-  Scheduler,
-  parseCronExpression,
-  getNextRunTime,
-  intervalToMs,
-  shouldRunNow,
-  type ScheduledJob,
-  type SchedulerState,
-  type ScheduleEvent,
-  type SchedulerCallbacks,
-  type SchedulerConfig,
-  type ScheduledMission,
-} from './scheduler/index.js';
-export {
-  generateCheckpointKey,
-  formatSinceDate,
-  parseSinceDate,
-  EPOCH,
-  FileSyncStore,
-  MemorySyncStore,
-  type SyncCheckpoint,
-  type SyncStore,
-} from './sync/index.js';
-export {
-  ReqonError,
-  ParseError,
-  LexerError,
-  RuntimeError,
-  ValidationError,
-  formatErrors,
-  getSourceLine,
-  getSourceContext,
-  type SourceLocation,
-  type ErrorContext,
-} from './errors/index.js';
-export {
-  loadMission,
-  isMissionFolder,
-  getMissionName,
-  type LoadResult,
-  type LoadOptions,
-} from './loader/index.js';
-export {
-  loadEnv,
-  loadCredentials,
-  resolveCredentials,
-  resolveEnvString,
-  hasEnvReference,
-  credentialsFromEnv,
-  type CredentialsConfig,
-  type LoadEnvResult,
-  type AuthCredentials,
-  type SourceCredentials,
-} from './auth/credentials.js';
-export {
-  WebhookServer,
-  MemoryWebhookStore,
-  FileWebhookStore,
-  type WebhookStore,
-  type WebhookServerConfig,
-  type WebhookServerCallbacks,
-  type WebhookRegistration,
-  type WebhookEvent,
-  type WaitResult,
-} from './webhook/index.js';
-
-import { readFile } from 'node:fs/promises';
-import { resolve } from 'node:path';
-import { ReqonLexer } from './lexer/index.js';
-import { ReqonParser } from './parser/index.js';
-import { MissionExecutor, type ExecutorConfig } from './interpreter/index.js';
-import { loadMission } from './loader/index.js';
-import type { ReqonProgram } from './ast/index.js';
-
-export function parse(source: string, filePath?: string): ReqonProgram {
-  const lexer = new ReqonLexer(source);
-  const tokens = lexer.tokenize();
-  const parser = new ReqonParser(tokens, source, filePath);
-  return parser.parse();
-}
-
-export async function execute(
-  source: string,
-  config: ExecutorConfig = {}
-): Promise<import('./interpreter/index.js').ExecutionResult> {
-  const program = parse(source);
-  const executor = new MissionExecutor(config);
-  return executor.execute(program);
-}
-
-export async function fromFile(
-  filePath: string,
-  config: ExecutorConfig = {}
-): Promise<import('./interpreter/index.js').ExecutionResult> {
-  const absolutePath = resolve(filePath);
-  const source = await readFile(absolutePath, 'utf-8');
-  const program = parse(source, absolutePath);
-  const executor = new MissionExecutor(config);
-  return executor.execute(program);
-}
-
-/**
- * Load and execute a mission from a file or folder.
- *
- * Supports both:
- * - Single file: ./sync-invoices.reqon
- * - Folder: ./sync-invoices/ (with mission.reqon + action files)
- */
-export async function fromPath(
-  path: string,
-  config: ExecutorConfig = {}
-): Promise<import('./interpreter/index.js').ExecutionResult> {
-  const { program } = await loadMission(path);
-  const executor = new MissionExecutor(config);
-  return executor.execute(program);
-}
-
-// Tagged template literal for inline missions
-export function reqon(
-  strings: TemplateStringsArray,
-  ...values: unknown[]
-): ReqonProgram {
-  let source = strings[0];
-  for (let i = 0; i < values.length; i++) {
-    source += String(values[i]) + strings[i + 1];
-  }
-  return parse(source);
-}

package/src/integration.test.ts

@@ -1,192 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parse, execute } from './index.js';
-import { MemoryStore } from './stores/index.js';
-
-describe('Reqon Integration', () => {
-  it('parses and executes a simple mission with dry run', async () => {
-    const source = `
-      mission TestMission {
-        source API {
-          auth: bearer,
-          base: "https://api.example.com"
-        }
-
-        store items: memory("items")
-
-        action FetchItems {
-          get "/items"
-
-          store response -> items {
-            key: .id
-          }
-        }
-
-        run FetchItems
-      }
-    `;
-
-    const program = parse(source);
-    expect(program.type).toBe('ReqonProgram');
-
-    const result = await execute(source, { dryRun: true, verbose: false });
-
-    expect(result.success).toBe(true);
-    expect(result.actionsRun).toContain('FetchItems');
-  });
-
-  it('executes a mission with mock data flow', async () => {
-    const source = `
-      mission MockDataFlow {
-        source API {
-          auth: bearer,
-          base: "https://api.example.com"
-        }
-
-        store raw: memory("raw")
-        store processed: memory("processed")
-
-        action Process {
-          for item in raw {
-            map item -> Processed {
-              id: .id,
-              name: .title,
-              value: .amount
-            }
-
-            store response -> processed {
-              key: .id
-            }
-          }
-        }
-
-        run Process
-      }
-    `;
-
-    // Pre-populate the raw store
-    const rawStore = new MemoryStore('raw');
-    await rawStore.set('1', { id: '1', title: 'Item 1', amount: 100 });
-    await rawStore.set('2', { id: '2', title: 'Item 2', amount: 200 });
-
-    const result = await execute(source, {
-      dryRun: false,
-      verbose: false,
-      stores: { raw: rawStore },
-    });
-
-    expect(result.success).toBe(true);
-    expect(result.actionsRun).toContain('Process');
-
-    // Check processed store
-    const processedStore = result.stores.get('processed');
-    expect(processedStore).toBeDefined();
-
-    const items = await processedStore!.list();
-    expect(items).toHaveLength(2);
-    expect(items[0]).toMatchObject({ id: '1', name: 'Item 1', value: 100 });
-  });
-
-  it('parses the Xero example file', async () => {
-    const fs = await import('node:fs/promises');
-    const source = await fs.readFile('./examples/xero/invoices.reqon', 'utf-8');
-
-    const program = parse(source);
-
-    expect(program.type).toBe('ReqonProgram');
-    expect(program.statements).toHaveLength(1);
-
-    const mission = program.statements[0];
-    if (mission.type === 'MissionDefinition') {
-      expect(mission.name).toBe('SyncXeroInvoices');
-      expect(mission.sources).toHaveLength(1);
-      expect(mission.stores).toHaveLength(2);
-      expect(mission.actions).toHaveLength(3);
-      expect(mission.pipeline.stages).toHaveLength(3);
-    }
-  });
-
-  it('handles validation failures gracefully', async () => {
-    const source = `
-      mission ValidationTest {
-        source API {
-          auth: bearer,
-          base: "https://api.example.com"
-        }
-
-        store items: memory("items")
-
-        action Validate {
-          for item in items {
-            validate item {
-              assume .value > 0
-            }
-          }
-        }
-
-        run Validate
-      }
-    `;
-
-    const itemsStore = new MemoryStore('items');
-    await itemsStore.set('1', { id: '1', value: -5 }); // Invalid: negative value
-
-    const result = await execute(source, {
-      stores: { items: itemsStore },
-    });
-
-    // Validation should fail
-    expect(result.success).toBe(false);
-    expect(result.errors.length).toBeGreaterThan(0);
-  });
-
-  it('processes match expressions in map steps', async () => {
-    const source = `
-      mission MatchTest {
-        source API {
-          auth: bearer,
-          base: "https://api.example.com"
-        }
-
-        store input: memory("input")
-        store output: memory("output")
-
-        action Transform {
-          for item in input {
-            map item -> Output {
-              id: .id,
-              status: match .state {
-                "A" => "active",
-                "I" => "inactive",
-                _ => "unknown"
-              }
-            }
-
-            store response -> output {
-              key: .id
-            }
-          }
-        }
-
-        run Transform
-      }
-    `;
-
-    const inputStore = new MemoryStore('input');
-    await inputStore.set('1', { id: '1', state: 'A' });
-    await inputStore.set('2', { id: '2', state: 'I' });
-    await inputStore.set('3', { id: '3', state: 'X' });
-
-    const result = await execute(source, {
-      stores: { input: inputStore },
-    });
-
-    expect(result.success).toBe(true);
-
-    const outputStore = result.stores.get('output');
-    const items = await outputStore!.list();
-
-    expect(items).toContainEqual(expect.objectContaining({ id: '1', status: 'active' }));
-    expect(items).toContainEqual(expect.objectContaining({ id: '2', status: 'inactive' }));
-    expect(items).toContainEqual(expect.objectContaining({ id: '3', status: 'unknown' }));
-  });
-});

package/src/interpreter/context.ts

@@ -1,57 +0,0 @@
-import type { Expression, SchemaDefinition } from 'vague-lang';
-import type { StoreAdapter } from '../stores/types.js';
-import type { HttpClient } from './http.js';
-import type { SourceDefinition, StoreDefinition } from '../ast/nodes.js';
-
-export interface ExecutionContext {
-  // Named stores
-  stores: Map<string, StoreAdapter>;
-
-  // Named HTTP clients (sources)
-  sources: Map<string, HttpClient>;
-
-  // Schema definitions (for match step schema matching)
-  schemas: Map<string, SchemaDefinition>;
-
-  // Variable bindings for current scope
-  variables: Map<string, unknown>;
-
-  // Current response from last fetch
-  response?: unknown;
-
-  // Parent context (for nested scopes)
-  parent?: ExecutionContext;
-}
-
-export function createContext(): ExecutionContext {
-  return {
-    stores: new Map(),
-    sources: new Map(),
-    schemas: new Map(),
-    variables: new Map(),
-  };
-}
-
-export function childContext(parent: ExecutionContext): ExecutionContext {
-  return {
-    stores: parent.stores,
-    sources: parent.sources,
-    schemas: parent.schemas,
-    variables: new Map(),
-    parent,
-  };
-}
-
-export function getVariable(ctx: ExecutionContext, name: string): unknown {
-  if (ctx.variables.has(name)) {
-    return ctx.variables.get(name);
-  }
-  if (ctx.parent) {
-    return getVariable(ctx.parent, name);
-  }
-  return undefined;
-}
-
-export function setVariable(ctx: ExecutionContext, name: string, value: unknown): void {
-  ctx.variables.set(name, value);
-}