reqon-dsl 0.2.0

package/src/parser/schedule.test.ts

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

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

@@ -0,0 +1,83 @@
+/**
+ * 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();