reqon-dsl 0.2.0 → 0.4.0

package/src/parser/schedule.test.ts

@@ -1,287 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { ReqonLexer } from '../lexer/index.js';
-import { ReqonParser } from './parser.js';
-import type { MissionDefinition, ScheduleDefinition } from '../ast/nodes.js';
-
-function parseSchedule(source: string): ScheduleDefinition | undefined {
-  const lexer = new ReqonLexer(source);
-  const tokens = lexer.tokenize();
-  const parser = new ReqonParser(tokens);
-  const program = parser.parse();
-  const mission = program.statements.find((s) => s.type === 'MissionDefinition') as
-    | MissionDefinition
-    | undefined;
-  return mission?.schedule;
-}
-
-describe('Schedule parsing', () => {
-  describe('interval schedules', () => {
-    it('should parse schedule: every N hours', () => {
-      const source = `
-        mission Test {
-          schedule: every 6 hours
-          source API { auth: none, base: "http://api.example.com" }
-          action Sync { get "/data" }
-          run Sync
-        }
-      `;
-
-      const schedule = parseSchedule(source);
-
-      expect(schedule).toBeDefined();
-      expect(schedule!.scheduleType).toBe('interval');
-      expect(schedule!.interval).toEqual({ value: 6, unit: 'hours' });
-    });
-
-    it('should parse schedule: every N minutes', () => {
-      const source = `
-        mission Test {
-          schedule: every 30 minutes
-          source API { auth: none, base: "http://api.example.com" }
-          action Sync { get "/data" }
-          run Sync
-        }
-      `;
-
-      const schedule = parseSchedule(source);
-
-      expect(schedule).toBeDefined();
-      expect(schedule!.scheduleType).toBe('interval');
-      expect(schedule!.interval).toEqual({ value: 30, unit: 'minutes' });
-    });
-
-    it('should parse schedule: every N seconds', () => {
-      const source = `
-        mission Test {
-          schedule: every 60 seconds
-          source API { auth: none, base: "http://api.example.com" }
-          action Sync { get "/data" }
-          run Sync
-        }
-      `;
-
-      const schedule = parseSchedule(source);
-
-      expect(schedule).toBeDefined();
-      expect(schedule!.scheduleType).toBe('interval');
-      expect(schedule!.interval).toEqual({ value: 60, unit: 'seconds' });
-    });
-
-    it('should parse schedule: every N days', () => {
-      const source = `
-        mission Test {
-          schedule: every 1 days
-          source API { auth: none, base: "http://api.example.com" }
-          action Sync { get "/data" }
-          run Sync
-        }
-      `;
-
-      const schedule = parseSchedule(source);
-
-      expect(schedule).toBeDefined();
-      expect(schedule!.scheduleType).toBe('interval');
-      expect(schedule!.interval).toEqual({ value: 1, unit: 'days' });
-    });
-
-    it('should parse schedule: every N weeks', () => {
-      const source = `
-        mission Test {
-          schedule: every 2 weeks
-          source API { auth: none, base: "http://api.example.com" }
-          action Sync { get "/data" }
-          run Sync
-        }
-      `;
-
-      const schedule = parseSchedule(source);
-
-      expect(schedule).toBeDefined();
-      expect(schedule!.scheduleType).toBe('interval');
-      expect(schedule!.interval).toEqual({ value: 2, unit: 'weeks' });
-    });
-  });
-
-  describe('cron schedules', () => {
-    it('should parse schedule: cron expression', () => {
-      const source = `
-        mission Test {
-          schedule: cron "0 */6 * * *"
-          source API { auth: none, base: "http://api.example.com" }
-          action Sync { get "/data" }
-          run Sync
-        }
-      `;
-
-      const schedule = parseSchedule(source);
-
-      expect(schedule).toBeDefined();
-      expect(schedule!.scheduleType).toBe('cron');
-      expect(schedule!.cronExpression).toBe('0 */6 * * *');
-    });
-
-    it('should parse complex cron expressions', () => {
-      const source = `
-        mission Test {
-          schedule: cron "30 9 15 * 1-5"
-          source API { auth: none, base: "http://api.example.com" }
-          action Sync { get "/data" }
-          run Sync
-        }
-      `;
-
-      const schedule = parseSchedule(source);
-
-      expect(schedule).toBeDefined();
-      expect(schedule!.scheduleType).toBe('cron');
-      expect(schedule!.cronExpression).toBe('30 9 15 * 1-5');
-    });
-  });
-
-  describe('one-time schedules', () => {
-    it('should parse schedule: at datetime', () => {
-      const source = `
-        mission Test {
-          schedule: at "2025-01-25T15:00:00Z"
-          source API { auth: none, base: "http://api.example.com" }
-          action Sync { get "/data" }
-          run Sync
-        }
-      `;
-
-      const schedule = parseSchedule(source);
-
-      expect(schedule).toBeDefined();
-      expect(schedule!.scheduleType).toBe('once');
-      expect(schedule!.runAt).toBe('2025-01-25T15:00:00Z');
-    });
-  });
-
-  describe('schedule options', () => {
-    it('should parse schedule with timezone option', () => {
-      const source = `
-        mission Test {
-          schedule: every 6 hours {
-            timezone: "America/New_York"
-          }
-          source API { auth: none, base: "http://api.example.com" }
-          action Sync { get "/data" }
-          run Sync
-        }
-      `;
-
-      const schedule = parseSchedule(source);
-
-      expect(schedule).toBeDefined();
-      expect(schedule!.timezone).toBe('America/New_York');
-    });
-
-    it('should parse schedule with maxConcurrency option', () => {
-      const source = `
-        mission Test {
-          schedule: every 6 hours {
-            maxConcurrency: 2
-          }
-          source API { auth: none, base: "http://api.example.com" }
-          action Sync { get "/data" }
-          run Sync
-        }
-      `;
-
-      const schedule = parseSchedule(source);
-
-      expect(schedule).toBeDefined();
-      expect(schedule!.maxConcurrency).toBe(2);
-    });
-
-    it('should parse schedule with skipIfRunning option', () => {
-      const source = `
-        mission Test {
-          schedule: every 6 hours {
-            skipIfRunning: false
-          }
-          source API { auth: none, base: "http://api.example.com" }
-          action Sync { get "/data" }
-          run Sync
-        }
-      `;
-
-      const schedule = parseSchedule(source);
-
-      expect(schedule).toBeDefined();
-      expect(schedule!.skipIfRunning).toBe(false);
-    });
-
-    it('should parse schedule with retry config', () => {
-      const source = `
-        mission Test {
-          schedule: every 6 hours {
-            retry: {
-              maxRetries: 5,
-              delaySeconds: 120
-            }
-          }
-          source API { auth: none, base: "http://api.example.com" }
-          action Sync { get "/data" }
-          run Sync
-        }
-      `;
-
-      const schedule = parseSchedule(source);
-
-      expect(schedule).toBeDefined();
-      expect(schedule!.retryOnFailure).toEqual({
-        maxRetries: 5,
-        delaySeconds: 120,
-      });
-    });
-
-    it('should parse schedule with multiple options', () => {
-      const source = `
-        mission Test {
-          schedule: cron "0 9 * * 1-5" {
-            timezone: "Europe/London",
-            maxConcurrency: 1,
-            skipIfRunning: true,
-            retry: {
-              maxRetries: 3,
-              delaySeconds: 60
-            }
-          }
-          source API { auth: none, base: "http://api.example.com" }
-          action Sync { get "/data" }
-          run Sync
-        }
-      `;
-
-      const schedule = parseSchedule(source);
-
-      expect(schedule).toBeDefined();
-      expect(schedule!.scheduleType).toBe('cron');
-      expect(schedule!.cronExpression).toBe('0 9 * * 1-5');
-      expect(schedule!.timezone).toBe('Europe/London');
-      expect(schedule!.maxConcurrency).toBe(1);
-      expect(schedule!.skipIfRunning).toBe(true);
-      expect(schedule!.retryOnFailure).toEqual({
-        maxRetries: 3,
-        delaySeconds: 60,
-      });
-    });
-  });
-
-  describe('mission without schedule', () => {
-    it('should parse mission without schedule', () => {
-      const source = `
-        mission Test {
-          source API { auth: none, base: "http://api.example.com" }
-          action Sync { get "/data" }
-          run Sync
-        }
-      `;
-
-      const schedule = parseSchedule(source);
-
-      expect(schedule).toBeUndefined();
-    });
-  });
-});

package/src/parser/webhook.test.ts

@@ -1,248 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { ReqonLexer } from '../lexer/index.js';
-import { ReqonParser } from './parser.js';
-import type { MissionDefinition, ActionDefinition, WebhookStep } from '../ast/nodes.js';
-
-function parse(source: string) {
-  const lexer = new ReqonLexer(source);
-  const tokens = lexer.tokenize();
-  const parser = new ReqonParser(tokens, source);
-  return parser.parse();
-}
-
-describe('WebhookStep Parser', () => {
-  it('should parse a basic wait step', () => {
-    const source = `
-      mission TestWebhook {
-        source API { auth: none, base: "http://localhost" }
-        store events: memory("events")
-
-        action WaitForCallback {
-          wait {
-            timeout: 60000
-          }
-        }
-
-        run WaitForCallback
-      }
-    `;
-
-    const program = parse(source);
-    const mission = program.statements[0] as MissionDefinition;
-    const action = mission.actions[0] as ActionDefinition;
-    const step = action.steps[0] as WebhookStep;
-
-    expect(step.type).toBe('WebhookStep');
-    expect(step.timeout).toBe(60000);
-  });
-
-  it('should parse wait step with path', () => {
-    const source = `
-      mission TestWebhook {
-        source API { auth: none, base: "http://localhost" }
-
-        action WaitForCallback {
-          wait {
-            timeout: 30000,
-            path: "/webhooks/callback"
-          }
-        }
-
-        run WaitForCallback
-      }
-    `;
-
-    const program = parse(source);
-    const mission = program.statements[0] as MissionDefinition;
-    const action = mission.actions[0] as ActionDefinition;
-    const step = action.steps[0] as WebhookStep;
-
-    expect(step.type).toBe('WebhookStep');
-    expect(step.timeout).toBe(30000);
-    expect(step.path).toBe('/webhooks/callback');
-  });
-
-  it('should parse wait step with expectedEvents', () => {
-    const source = `
-      mission TestWebhook {
-        source API { auth: none, base: "http://localhost" }
-
-        action WaitForMultiple {
-          wait {
-            timeout: 120000,
-            expectedEvents: 3
-          }
-        }
-
-        run WaitForMultiple
-      }
-    `;
-
-    const program = parse(source);
-    const mission = program.statements[0] as MissionDefinition;
-    const action = mission.actions[0] as ActionDefinition;
-    const step = action.steps[0] as WebhookStep;
-
-    expect(step.expectedEvents).toBe(3);
-  });
-
-  it('should parse wait step with storage configuration', () => {
-    const source = `
-      mission TestWebhook {
-        source API { auth: none, base: "http://localhost" }
-        store webhook_events: memory("events")
-
-        action WaitAndStore {
-          wait {
-            timeout: 60000,
-            storage: {
-              target: webhook_events,
-              key: .id
-            }
-          }
-        }
-
-        run WaitAndStore
-      }
-    `;
-
-    const program = parse(source);
-    const mission = program.statements[0] as MissionDefinition;
-    const action = mission.actions[0] as ActionDefinition;
-    const step = action.steps[0] as WebhookStep;
-
-    expect(step.storage).toBeDefined();
-    expect(step.storage?.target).toBe('webhook_events');
-    expect(step.storage?.key).toBeDefined();
-  });
-
-  it('should parse wait step with retry configuration', () => {
-    const source = `
-      mission TestWebhook {
-        source API { auth: none, base: "http://localhost" }
-
-        action WaitWithRetry {
-          wait {
-            timeout: 30000,
-            retry: {
-              maxAttempts: 3,
-              backoff: exponential,
-              initialDelay: 1000
-            }
-          }
-        }
-
-        run WaitWithRetry
-      }
-    `;
-
-    const program = parse(source);
-    const mission = program.statements[0] as MissionDefinition;
-    const action = mission.actions[0] as ActionDefinition;
-    const step = action.steps[0] as WebhookStep;
-
-    expect(step.retryOnTimeout).toBeDefined();
-    expect(step.retryOnTimeout?.maxAttempts).toBe(3);
-    expect(step.retryOnTimeout?.backoff).toBe('exponential');
-    expect(step.retryOnTimeout?.initialDelay).toBe(1000);
-  });
-
-  it('should parse wait step with eventFilter', () => {
-    const source = `
-      mission TestWebhook {
-        source API { auth: none, base: "http://localhost" }
-
-        action WaitFiltered {
-          wait {
-            timeout: 60000,
-            eventFilter: .type == "payment.completed"
-          }
-        }
-
-        run WaitFiltered
-      }
-    `;
-
-    const program = parse(source);
-    const mission = program.statements[0] as MissionDefinition;
-    const action = mission.actions[0] as ActionDefinition;
-    const step = action.steps[0] as WebhookStep;
-
-    expect(step.eventFilter).toBeDefined();
-  });
-
-  it('should parse wait step with all options', () => {
-    const source = `
-      mission FullWebhook {
-        source API { auth: none, base: "http://localhost" }
-        store events: memory("events")
-
-        action CompleteWait {
-          wait {
-            timeout: 300000,
-            path: "/webhooks/payment",
-            expectedEvents: 1,
-            eventFilter: .status == "success",
-            storage: {
-              target: events,
-              key: .id
-            },
-            retry: {
-              maxAttempts: 5,
-              backoff: linear,
-              initialDelay: 2000
-            }
-          }
-        }
-
-        run CompleteWait
-      }
-    `;
-
-    const program = parse(source);
-    const mission = program.statements[0] as MissionDefinition;
-    const action = mission.actions[0] as ActionDefinition;
-    const step = action.steps[0] as WebhookStep;
-
-    expect(step.type).toBe('WebhookStep');
-    expect(step.timeout).toBe(300000);
-    expect(step.path).toBe('/webhooks/payment');
-    expect(step.expectedEvents).toBe(1);
-    expect(step.eventFilter).toBeDefined();
-    expect(step.storage?.target).toBe('events');
-    expect(step.retryOnTimeout?.maxAttempts).toBe(5);
-  });
-
-  it('should parse wait step in a multi-step action', () => {
-    const source = `
-      mission WorkflowWithWebhook {
-        source API { auth: none, base: "http://localhost" }
-        store orders: memory("orders")
-
-        action ProcessOrder {
-          post "/orders" {
-            body: { item: "test" }
-          }
-
-          wait {
-            timeout: 60000,
-            path: "/webhooks/order-confirmed"
-          }
-
-          store response -> orders { key: .id }
-        }
-
-        run ProcessOrder
-      }
-    `;
-
-    const program = parse(source);
-    const mission = program.statements[0] as MissionDefinition;
-    const action = mission.actions[0] as ActionDefinition;
-
-    expect(action.steps).toHaveLength(3);
-    expect(action.steps[0].type).toBe('FetchStep');
-    expect(action.steps[1].type).toBe('WebhookStep');
-    expect(action.steps[2].type).toBe('StoreStep');
-  });
-});

package/src/plugin.ts

@@ -1,83 +0,0 @@
-/**
- * Reqon plugin for Vague.
- *
- * This plugin registers Reqon's keywords and statement parsers with Vague,
- * allowing Vague to parse Reqon syntax when the plugin is registered.
- *
- * Usage:
- *   import { registerPlugin } from 'vague-lang';
- *   import { reqonPlugin } from 'reqon';
- *   registerPlugin(reqonPlugin);
- *
- * Or simply import the plugin module to auto-register:
- *   import 'reqon/plugin';
- */
-
-import {
-  registerPlugin,
-  unregisterPlugin,
-  type VaguePlugin,
-  type PluginKeyword,
-} from 'vague-lang';
-import { REQON_KEYWORDS } from './lexer/tokens.js';
-
-/**
- * Convert REQON_KEYWORDS map to PluginKeyword array for Vague plugin system.
- */
-function buildKeywords(): PluginKeyword[] {
-  const keywords: PluginKeyword[] = [];
-
-  for (const [keyword, tokenType] of Object.entries(REQON_KEYWORDS)) {
-    keywords.push({
-      keyword,
-      tokenType: tokenType as string,
-    });
-  }
-
-  return keywords;
-}
-
-/**
- * The Reqon plugin for Vague.
- *
- * Registers all Reqon keywords with Vague's lexer, allowing Vague's
- * lexer to tokenize Reqon source code.
- */
-export const reqonPlugin: VaguePlugin = {
-  name: 'reqon',
-  keywords: buildKeywords(),
-  // Statement parsers will be added when we refactor ReqonParser
-};
-
-let isRegistered = false;
-
-/**
- * Register Reqon with Vague's plugin system.
- * Safe to call multiple times - will only register once.
- */
-export function registerReqonPlugin(): void {
-  if (!isRegistered) {
-    registerPlugin(reqonPlugin);
-    isRegistered = true;
-  }
-}
-
-/**
- * Unregister Reqon from Vague's plugin system.
- */
-export function unregisterReqonPlugin(): void {
-  if (isRegistered) {
-    unregisterPlugin('reqon');
-    isRegistered = false;
-  }
-}
-
-/**
- * Check if Reqon plugin is currently registered.
- */
-export function isReqonPluginRegistered(): boolean {
-  return isRegistered;
-}
-
-// Auto-register on import
-registerReqonPlugin();