reqon-dsl 0.2.0

package/dist/parser/parser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/parser/parser.test.js

@@ -0,0 +1,333 @@
+import { describe, it, expect } from 'vitest';
+import { ReqonLexer } from '../lexer/index.js';
+import { ReqonParser } from './parser.js';
+describe('ReqonParser', () => {
+    function parse(source) {
+        const lexer = new ReqonLexer(source);
+        const tokens = lexer.tokenize();
+        const parser = new ReqonParser(tokens);
+        return parser.parse();
+    }
+    it('parses a simple mission', () => {
+        const source = `
+      mission TestMission {
+        source API {
+          auth: bearer,
+          base: "https://api.example.com"
+        }
+
+        store items: memory("items")
+
+        action FetchItems {
+          fetch GET "/items"
+
+          store response -> items {
+            key: .id
+          }
+        }
+
+        run FetchItems
+      }
+    `;
+        const program = parse(source);
+        expect(program.type).toBe('ReqonProgram');
+        expect(program.statements).toHaveLength(1);
+        const mission = program.statements[0];
+        expect(mission.type).toBe('MissionDefinition');
+        if (mission.type === 'MissionDefinition') {
+            expect(mission.name).toBe('TestMission');
+            expect(mission.sources).toHaveLength(1);
+            expect(mission.stores).toHaveLength(1);
+            expect(mission.actions).toHaveLength(1);
+            expect(mission.pipeline.stages).toHaveLength(1);
+        }
+    });
+    it('parses fetch with pagination', () => {
+        const source = `
+      mission PaginatedFetch {
+        source API {
+          auth: oauth2,
+          base: "https://api.example.com"
+        }
+
+        store items: memory("items")
+
+        action FetchAll {
+          fetch GET "/items" {
+            paginate: offset(page, 50),
+            until: response.items.length == 0
+          }
+
+          store response.items -> items {
+            key: .id
+          }
+        }
+
+        run FetchAll
+      }
+    `;
+        const program = parse(source);
+        const mission = program.statements[0];
+        if (mission.type === 'MissionDefinition') {
+            const action = mission.actions[0];
+            const fetchStep = action.steps[0];
+            if (fetchStep.type === 'FetchStep') {
+                expect(fetchStep.paginate).toBeDefined();
+                expect(fetchStep.paginate?.type).toBe('offset');
+                expect(fetchStep.paginate?.pageSize).toBe(50);
+                expect(fetchStep.until).toBeDefined();
+            }
+        }
+    });
+    it('parses for loops with conditions', () => {
+        const source = `
+      mission IterateItems {
+        source API {
+          auth: bearer,
+          base: "https://api.example.com"
+        }
+
+        store items: memory("items")
+
+        action ProcessItems {
+          for item in items where .status == "pending" {
+            fetch GET "/items/{item.id}"
+
+            store response -> items {
+              key: .id,
+              upsert: true
+            }
+          }
+        }
+
+        run ProcessItems
+      }
+    `;
+        const program = parse(source);
+        const mission = program.statements[0];
+        if (mission.type === 'MissionDefinition') {
+            const action = mission.actions[0];
+            const forStep = action.steps[0];
+            if (forStep.type === 'ForStep') {
+                expect(forStep.variable).toBe('item');
+                expect(forStep.condition).toBeDefined();
+                expect(forStep.steps).toHaveLength(2);
+            }
+        }
+    });
+    it('parses map steps with match expressions', () => {
+        const source = `
+      mission MapItems {
+        source API {
+          auth: bearer,
+          base: "https://api.example.com"
+        }
+
+        store raw: memory("raw")
+        store normalized: memory("normalized")
+
+        action Normalize {
+          for item in raw {
+            map item -> StandardItem {
+              id: .external_id,
+              status: match .state {
+                "active" => "enabled",
+                "inactive" => "disabled",
+                _ => "unknown"
+              }
+            }
+
+            store response -> normalized {
+              key: .id
+            }
+          }
+        }
+
+        run Normalize
+      }
+    `;
+        const program = parse(source);
+        const mission = program.statements[0];
+        if (mission.type === 'MissionDefinition') {
+            const action = mission.actions[0];
+            const forStep = action.steps[0];
+            if (forStep.type === 'ForStep') {
+                const mapStep = forStep.steps[0];
+                if (mapStep.type === 'MapStep') {
+                    expect(mapStep.targetSchema).toBe('StandardItem');
+                    expect(mapStep.mappings).toHaveLength(2);
+                }
+            }
+        }
+    });
+    it('parses validation steps', () => {
+        const source = `
+      mission ValidateData {
+        source API {
+          auth: bearer,
+          base: "https://api.example.com"
+        }
+
+        store data: memory("data")
+
+        action Fetch {
+          fetch GET "/data"
+
+          validate response {
+            assume length(.items) > 0,
+            assume .count > 0
+          }
+
+          store response.items -> data {
+            key: .id
+          }
+        }
+
+        run Fetch
+      }
+    `;
+        const program = parse(source);
+        const mission = program.statements[0];
+        if (mission.type === 'MissionDefinition') {
+            const action = mission.actions[0];
+            const validateStep = action.steps[1];
+            if (validateStep.type === 'ValidateStep') {
+                expect(validateStep.constraints).toHaveLength(2);
+            }
+        }
+    });
+    it('parses pipeline with multiple stages', () => {
+        const source = `
+      mission MultiStage {
+        source API {
+          auth: bearer,
+          base: "https://api.example.com"
+        }
+
+        store data: memory("data")
+
+        action Step1 {
+          fetch GET "/step1"
+          store response -> data { key: .id }
+        }
+
+        action Step2 {
+          fetch GET "/step2"
+          store response -> data { key: .id }
+        }
+
+        action Step3 {
+          fetch GET "/step3"
+          store response -> data { key: .id }
+        }
+
+        run Step1 then Step2 then Step3
+      }
+    `;
+        const program = parse(source);
+        const mission = program.statements[0];
+        if (mission.type === 'MissionDefinition') {
+            expect(mission.pipeline.stages).toHaveLength(3);
+            expect(mission.pipeline.stages[0].action).toBe('Step1');
+            expect(mission.pipeline.stages[1].action).toBe('Step2');
+            expect(mission.pipeline.stages[2].action).toBe('Step3');
+        }
+    });
+    it('parses parallel stages with bracket syntax', () => {
+        const source = `
+      mission ParallelSync {
+        source API {
+          auth: bearer,
+          base: "https://api.example.com"
+        }
+
+        store orders: memory("orders")
+        store payments: memory("payments")
+        store reconciled: memory("reconciled")
+
+        action FetchOrders {
+          fetch GET "/orders"
+          store response -> orders { key: .id }
+        }
+
+        action FetchPayments {
+          fetch GET "/payments"
+          store response -> payments { key: .id }
+        }
+
+        action Reconcile {
+          fetch GET "/reconcile"
+          store response -> reconciled { key: .id }
+        }
+
+        run [FetchOrders, FetchPayments] then Reconcile
+      }
+    `;
+        const program = parse(source);
+        const mission = program.statements[0];
+        if (mission.type === 'MissionDefinition') {
+            expect(mission.pipeline.stages).toHaveLength(2);
+            // First stage is parallel
+            const parallelStage = mission.pipeline.stages[0];
+            expect(parallelStage.actions).toBeDefined();
+            expect(parallelStage.actions).toEqual(['FetchOrders', 'FetchPayments']);
+            expect(parallelStage.action).toBeUndefined();
+            // Second stage is sequential
+            const sequentialStage = mission.pipeline.stages[1];
+            expect(sequentialStage.action).toBe('Reconcile');
+            expect(sequentialStage.actions).toBeUndefined();
+        }
+    });
+    it('parses multiple parallel stages', () => {
+        const source = `
+      mission ComplexPipeline {
+        source API {
+          auth: bearer,
+          base: "https://api.example.com"
+        }
+
+        store data: memory("data")
+
+        action A { fetch GET "/a" }
+        action B { fetch GET "/b" }
+        action C { fetch GET "/c" }
+        action D { fetch GET "/d" }
+        action E { fetch GET "/e" }
+
+        run A then [B, C, D] then E
+      }
+    `;
+        const program = parse(source);
+        const mission = program.statements[0];
+        if (mission.type === 'MissionDefinition') {
+            expect(mission.pipeline.stages).toHaveLength(3);
+            expect(mission.pipeline.stages[0].action).toBe('A');
+            expect(mission.pipeline.stages[1].actions).toEqual(['B', 'C', 'D']);
+            expect(mission.pipeline.stages[2].action).toBe('E');
+        }
+    });
+    it('parses parallel stage with three actions', () => {
+        const source = `
+      mission TripleParallel {
+        source API {
+          auth: bearer,
+          base: "https://api.example.com"
+        }
+
+        store data: memory("data")
+
+        action X { fetch GET "/x" }
+        action Y { fetch GET "/y" }
+        action Z { fetch GET "/z" }
+
+        run [X, Y, Z]
+      }
+    `;
+        const program = parse(source);
+        const mission = program.statements[0];
+        if (mission.type === 'MissionDefinition') {
+            expect(mission.pipeline.stages).toHaveLength(1);
+            expect(mission.pipeline.stages[0].actions).toEqual(['X', 'Y', 'Z']);
+        }
+    });
+});

package/dist/parser/schedule.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/parser/schedule.test.js

@@ -0,0 +1,241 @@
+import { describe, it, expect } from 'vitest';
+import { ReqonLexer } from '../lexer/index.js';
+import { ReqonParser } from './parser.js';
+function parseSchedule(source) {
+    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');
+    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 { fetch 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 { fetch 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 { fetch 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 { fetch 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 { fetch 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 { fetch 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 { fetch 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 { fetch 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 { fetch 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 { fetch 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 { fetch 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 { fetch 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 { fetch 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 { fetch GET "/data" }
+          run Sync
+        }
+      `;
+            const schedule = parseSchedule(source);
+            expect(schedule).toBeUndefined();
+        });
+    });
+});

package/dist/plugin.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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 { type VaguePlugin } from 'vague-lang';
+/**
+ * The Reqon plugin for Vague.
+ *
+ * Registers all Reqon keywords with Vague's lexer, allowing Vague's
+ * lexer to tokenize Reqon source code.
+ */
+export declare const reqonPlugin: VaguePlugin;
+/**
+ * Register Reqon with Vague's plugin system.
+ * Safe to call multiple times - will only register once.
+ */
+export declare function registerReqonPlugin(): void;
+/**
+ * Unregister Reqon from Vague's plugin system.
+ */
+export declare function unregisterReqonPlugin(): void;
+/**
+ * Check if Reqon plugin is currently registered.
+ */
+export declare function isReqonPluginRegistered(): boolean;

package/dist/plugin.js

@@ -0,0 +1,68 @@
+/**
+ * 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, } from 'vague-lang';
+import { REQON_KEYWORDS } from './lexer/tokens.js';
+/**
+ * Convert REQON_KEYWORDS map to PluginKeyword array for Vague plugin system.
+ */
+function buildKeywords() {
+    const keywords = [];
+    for (const [keyword, tokenType] of Object.entries(REQON_KEYWORDS)) {
+        keywords.push({
+            keyword,
+            tokenType: tokenType,
+        });
+    }
+    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 = {
+    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() {
+    if (!isRegistered) {
+        registerPlugin(reqonPlugin);
+        isRegistered = true;
+    }
+}
+/**
+ * Unregister Reqon from Vague's plugin system.
+ */
+export function unregisterReqonPlugin() {
+    if (isRegistered) {
+        unregisterPlugin('reqon');
+        isRegistered = false;
+    }
+}
+/**
+ * Check if Reqon plugin is currently registered.
+ */
+export function isReqonPluginRegistered() {
+    return isRegistered;
+}
+// Auto-register on import
+registerReqonPlugin();