reqon-dsl 0.2.0 → 0.3.0

package/dist/loader/loader.test.js

@@ -1,287 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdir, writeFile, rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { loadMission, isMissionFolder, getMissionName } from './index.js';
-const TEST_DIR = '.test-missions';
-describe('Mission Loader', () => {
-    beforeEach(async () => {
-        await mkdir(TEST_DIR, { recursive: true });
-    });
-    afterEach(async () => {
-        await rm(TEST_DIR, { recursive: true, force: true });
-    });
-    describe('single file loading', () => {
-        it('loads a single .reqon file', async () => {
-            const filePath = join(TEST_DIR, 'simple.reqon');
-            await writeFile(filePath, `
-        mission Simple {
-          source Api {
-            auth: none,
-            base: "https://api.example.com"
-          }
-
-          store data: memory("items")
-
-          action Fetch {
-            fetch GET "/items" { source: Api }
-            store response -> data
-          }
-
-          run Fetch
-        }
-      `);
-            const result = await loadMission(filePath);
-            expect(result.sourceFiles).toHaveLength(1);
-            expect(result.sourceFiles[0]).toContain('simple.reqon');
-            const mission = result.program.statements.find(s => s.type === 'MissionDefinition');
-            expect(mission).toBeDefined();
-            expect(mission.name).toBe('Simple');
-            expect(mission.actions).toHaveLength(1);
-        });
-        it('loads a single .vague file', async () => {
-            const filePath = join(TEST_DIR, 'simple.vague');
-            await writeFile(filePath, `
-        mission Simple {
-          source Api {
-            auth: none,
-            base: "https://api.example.com"
-          }
-
-          store data: memory("items")
-
-          action Fetch {
-            fetch GET "/items" { source: Api }
-            store response -> data
-          }
-
-          run Fetch
-        }
-      `);
-            const result = await loadMission(filePath);
-            expect(result.sourceFiles).toHaveLength(1);
-            expect(result.sourceFiles[0]).toContain('simple.vague');
-            const mission = result.program.statements.find(s => s.type === 'MissionDefinition');
-            expect(mission).toBeDefined();
-            expect(mission.name).toBe('Simple');
-        });
-    });
-    describe('folder loading', () => {
-        it('loads mission from folder with separate action files', async () => {
-            const missionDir = join(TEST_DIR, 'sync-invoices');
-            await mkdir(missionDir, { recursive: true });
-            // Root mission file
-            await writeFile(join(missionDir, 'mission.reqon'), `
-        mission SyncInvoices {
-          source Xero {
-            auth: oauth2,
-            base: "https://api.xero.com"
-          }
-
-          store invoices: memory("invoices")
-          store details: memory("invoice_details")
-
-          run FetchList then Hydrate
-        }
-      `);
-            // Action files
-            await writeFile(join(missionDir, 'fetch-list.reqon'), `
-        action FetchList {
-          fetch GET "/invoices" { source: Xero }
-          store response -> invoices
-        }
-      `);
-            await writeFile(join(missionDir, 'hydrate.reqon'), `
-        action Hydrate {
-          for invoice in invoices {
-            fetch GET "/invoices/{invoice.id}" { source: Xero }
-            store response -> details
-          }
-        }
-      `);
-            const result = await loadMission(missionDir);
-            expect(result.sourceFiles).toHaveLength(3);
-            expect(result.baseDir).toContain('sync-invoices');
-            const mission = result.program.statements.find(s => s.type === 'MissionDefinition');
-            expect(mission).toBeDefined();
-            expect(mission.name).toBe('SyncInvoices');
-            expect(mission.actions).toHaveLength(2);
-            const actionNames = mission.actions.map((a) => a.name);
-            expect(actionNames).toContain('FetchList');
-            expect(actionNames).toContain('Hydrate');
-        });
-        it('errors if mission.reqon is missing from folder', async () => {
-            const missionDir = join(TEST_DIR, 'no-root');
-            await mkdir(missionDir, { recursive: true });
-            await writeFile(join(missionDir, 'action.reqon'), `
-        action SomeAction {
-          fetch GET "/test" { source: Api }
-        }
-      `);
-            await expect(loadMission(missionDir)).rejects.toThrow(/must contain a root file/);
-        });
-        it('errors if action file contains a mission definition', async () => {
-            const missionDir = join(TEST_DIR, 'bad-action');
-            await mkdir(missionDir, { recursive: true });
-            await writeFile(join(missionDir, 'mission.reqon'), `
-        mission Main {
-          source Api { auth: none, base: "https://api.example.com" }
-          store data: memory("data")
-          run Fetch
-        }
-      `);
-            await writeFile(join(missionDir, 'nested.reqon'), `
-        mission NestedMission {
-          source Api { auth: none, base: "https://other.com" }
-          store data: memory("data")
-          run Something
-        }
-      `);
-            await expect(loadMission(missionDir)).rejects.toThrow(/should not contain a mission definition/);
-        });
-        it('errors on duplicate action names', async () => {
-            const missionDir = join(TEST_DIR, 'duplicate');
-            await mkdir(missionDir, { recursive: true });
-            await writeFile(join(missionDir, 'mission.reqon'), `
-        mission Main {
-          source Api { auth: none, base: "https://api.example.com" }
-          store data: memory("data")
-
-          action Fetch {
-            fetch GET "/a" { source: Api }
-          }
-
-          run Fetch
-        }
-      `);
-            await writeFile(join(missionDir, 'fetch.reqon'), `
-        action Fetch {
-          fetch GET "/b" { source: Api }
-        }
-      `);
-            await expect(loadMission(missionDir)).rejects.toThrow(/Duplicate action definition: 'Fetch'/);
-        });
-        it('errors if pipeline references unknown action', async () => {
-            const missionDir = join(TEST_DIR, 'unknown-action');
-            await mkdir(missionDir, { recursive: true });
-            await writeFile(join(missionDir, 'mission.reqon'), `
-        mission Main {
-          source Api { auth: none, base: "https://api.example.com" }
-          store data: memory("data")
-
-          action Fetch {
-            fetch GET "/items" { source: Api }
-          }
-
-          run Fetch then NonExistent
-        }
-      `);
-            await expect(loadMission(missionDir)).rejects.toThrow(/Pipeline references unknown action: 'NonExistent'/);
-        });
-        it('supports inline actions alongside external files', async () => {
-            const missionDir = join(TEST_DIR, 'mixed');
-            await mkdir(missionDir, { recursive: true });
-            await writeFile(join(missionDir, 'mission.reqon'), `
-        mission Mixed {
-          source Api { auth: none, base: "https://api.example.com" }
-          store data: memory("data")
-
-          action InlineAction {
-            fetch GET "/inline" { source: Api }
-          }
-
-          run InlineAction then ExternalAction
-        }
-      `);
-            await writeFile(join(missionDir, 'external.reqon'), `
-        action ExternalAction {
-          fetch GET "/external" { source: Api }
-          store response -> data
-        }
-      `);
-            const result = await loadMission(missionDir);
-            const mission = result.program.statements.find(s => s.type === 'MissionDefinition');
-            expect(mission.actions).toHaveLength(2);
-        });
-    });
-    describe('isMissionFolder', () => {
-        it('returns true for folder with mission.reqon', async () => {
-            const missionDir = join(TEST_DIR, 'valid-folder');
-            await mkdir(missionDir, { recursive: true });
-            await writeFile(join(missionDir, 'mission.reqon'), 'mission X { run A }');
-            expect(await isMissionFolder(missionDir)).toBe(true);
-        });
-        it('returns true for folder with mission.vague', async () => {
-            const missionDir = join(TEST_DIR, 'vague-folder');
-            await mkdir(missionDir, { recursive: true });
-            await writeFile(join(missionDir, 'mission.vague'), 'mission X { run A }');
-            expect(await isMissionFolder(missionDir)).toBe(true);
-        });
-        it('returns false for folder without mission.reqon', async () => {
-            const missionDir = join(TEST_DIR, 'invalid-folder');
-            await mkdir(missionDir, { recursive: true });
-            expect(await isMissionFolder(missionDir)).toBe(false);
-        });
-        it('returns false for a file', async () => {
-            const filePath = join(TEST_DIR, 'file.reqon');
-            await writeFile(filePath, 'mission X { run A }');
-            expect(await isMissionFolder(filePath)).toBe(false);
-        });
-    });
-    describe('getMissionName', () => {
-        it('extracts name from folder path', () => {
-            expect(getMissionName('/path/to/sync-invoices')).toBe('sync-invoices');
-        });
-        it('extracts name from .reqon file path', () => {
-            expect(getMissionName('/path/to/sync-invoices.reqon')).toBe('sync-invoices');
-        });
-        it('extracts name from .vague file path', () => {
-            expect(getMissionName('/path/to/sync-invoices.vague')).toBe('sync-invoices');
-        });
-    });
-    describe('.vague file priority', () => {
-        it('prefers .vague over .reqon in folder mode', async () => {
-            const missionDir = join(TEST_DIR, 'both-extensions');
-            await mkdir(missionDir, { recursive: true });
-            // Create both files - .vague should be preferred
-            await writeFile(join(missionDir, 'mission.vague'), `
-        mission FromVague {
-          source Api { auth: none, base: "https://api.example.com" }
-          store data: memory("data")
-          action Fetch { fetch GET "/vague" { source: Api } }
-          run Fetch
-        }
-      `);
-            await writeFile(join(missionDir, 'mission.reqon'), `
-        mission FromReqon {
-          source Api { auth: none, base: "https://api.example.com" }
-          store data: memory("data")
-          action Fetch { fetch GET "/reqon" { source: Api } }
-          run Fetch
-        }
-      `);
-            const result = await loadMission(missionDir);
-            const mission = result.program.statements.find(s => s.type === 'MissionDefinition');
-            expect(mission.name).toBe('FromVague');
-        });
-        it('loads folder with mission.vague and .vague action files', async () => {
-            const missionDir = join(TEST_DIR, 'vague-folder-mode');
-            await mkdir(missionDir, { recursive: true });
-            await writeFile(join(missionDir, 'mission.vague'), `
-        mission VagueMode {
-          source Api { auth: none, base: "https://api.example.com" }
-          store data: memory("data")
-          run Fetch
-        }
-      `);
-            await writeFile(join(missionDir, 'fetch.vague'), `
-        action Fetch {
-          fetch GET "/items" { source: Api }
-        }
-      `);
-            const result = await loadMission(missionDir);
-            expect(result.sourceFiles).toHaveLength(2);
-            expect(result.sourceFiles[0]).toContain('mission.vague');
-            expect(result.sourceFiles[1]).toContain('fetch.vague');
-        });
-    });
-});

package/dist/oas/oas.test.d.ts

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

package/dist/oas/oas.test.js

@@ -1,218 +0,0 @@
-import { describe, it, expect, beforeAll } from 'vitest';
-import { loadOAS, resolveOperation, getResponseSchema, clearCache } from './loader.js';
-import { validateResponse } from './validator.js';
-import { ReqonLexer } from '../lexer/index.js';
-import { ReqonParser } from '../parser/parser.js';
-describe('OAS Loader', () => {
-    beforeAll(() => {
-        clearCache();
-    });
-    it('loads and parses an OpenAPI spec', async () => {
-        const source = await loadOAS('./examples/petstore/openapi.yaml');
-        expect(source.baseUrl).toBe('https://api.petstore.example.com/v1');
-        expect(source.operations.size).toBe(3);
-        expect(source.schemas.size).toBe(2);
-    });
-    it('resolves operations by operationId', async () => {
-        const source = await loadOAS('./examples/petstore/openapi.yaml');
-        const listPets = resolveOperation(source, 'listPets');
-        expect(listPets.method).toBe('GET');
-        expect(listPets.path).toBe('/pets');
-        const getPet = resolveOperation(source, 'getPet');
-        expect(getPet.method).toBe('GET');
-        expect(getPet.path).toBe('/pets/{petId}');
-        const createPet = resolveOperation(source, 'createPet');
-        expect(createPet.method).toBe('POST');
-        expect(createPet.path).toBe('/pets');
-    });
-    it('throws for unknown operationId', async () => {
-        const source = await loadOAS('./examples/petstore/openapi.yaml');
-        expect(() => resolveOperation(source, 'unknownOp')).toThrow(/not found/);
-    });
-    it('extracts response schemas', async () => {
-        const source = await loadOAS('./examples/petstore/openapi.yaml');
-        const schema = getResponseSchema(source, 'getPet');
-        expect(schema).toBeDefined();
-        expect(schema?.type).toBe('object');
-        expect(schema?.properties).toHaveProperty('id');
-        expect(schema?.properties).toHaveProperty('name');
-    });
-});
-describe('OAS Validator', () => {
-    it('validates a valid response', () => {
-        const schema = {
-            type: 'object',
-            required: ['id', 'name'],
-            properties: {
-                id: { type: 'string' },
-                name: { type: 'string' },
-                age: { type: 'integer', minimum: 0 },
-            },
-        };
-        const data = { id: '123', name: 'Fluffy', age: 3 };
-        const result = validateResponse(data, schema);
-        expect(result.valid).toBe(true);
-        expect(result.errors).toHaveLength(0);
-    });
-    it('catches missing required properties', () => {
-        const schema = {
-            type: 'object',
-            required: ['id', 'name'],
-            properties: {
-                id: { type: 'string' },
-                name: { type: 'string' },
-            },
-        };
-        const data = { id: '123' }; // missing 'name'
-        const result = validateResponse(data, schema);
-        expect(result.valid).toBe(false);
-        expect(result.errors.some(e => e.path === 'name')).toBe(true);
-    });
-    it('catches type mismatches', () => {
-        const schema = {
-            type: 'object',
-            properties: {
-                age: { type: 'integer' },
-            },
-        };
-        const data = { age: 'not a number' };
-        const result = validateResponse(data, schema);
-        expect(result.valid).toBe(false);
-        expect(result.errors[0].path).toBe('age');
-    });
-    it('validates arrays', () => {
-        const schema = {
-            type: 'array',
-            items: {
-                type: 'object',
-                required: ['id'],
-                properties: {
-                    id: { type: 'string' },
-                },
-            },
-        };
-        const validData = [{ id: '1' }, { id: '2' }];
-        expect(validateResponse(validData, schema).valid).toBe(true);
-        const invalidData = [{ id: '1' }, { noId: true }];
-        const result = validateResponse(invalidData, schema);
-        expect(result.valid).toBe(false);
-        expect(result.errors[0].path).toBe('[1].id');
-    });
-});
-describe('OAS Parser Integration', () => {
-    function parse(source) {
-        const lexer = new ReqonLexer(source);
-        const tokens = lexer.tokenize();
-        const parser = new ReqonParser(tokens);
-        return parser.parse();
-    }
-    it('parses source with OAS spec path', () => {
-        const source = `
-      mission TestOAS {
-        source Petstore from "./examples/petstore.yaml" {
-          auth: bearer
-        }
-
-        store pets: memory("pets")
-
-        action FetchPets {
-          fetch Petstore.listPets
-
-          store response.pets -> pets {
-            key: .id
-          }
-        }
-
-        run FetchPets
-      }
-    `;
-        const program = parse(source);
-        expect(program.type).toBe('ReqonProgram');
-        const mission = program.statements[0];
-        if (mission.type === 'MissionDefinition') {
-            expect(mission.sources[0].specPath).toBe('./examples/petstore.yaml');
-            expect(mission.sources[0].config.base).toBeUndefined();
-            const action = mission.actions[0];
-            const fetchStep = action.steps[0];
-            if (fetchStep.type === 'FetchStep') {
-                expect(fetchStep.operationRef).toBeDefined();
-                expect(fetchStep.operationRef?.source).toBe('Petstore');
-                expect(fetchStep.operationRef?.operationId).toBe('listPets');
-                expect(fetchStep.method).toBeUndefined();
-                expect(fetchStep.path).toBeUndefined();
-            }
-        }
-    });
-    it('parses source with OAS and explicit base URL override', () => {
-        const source = `
-      mission TestOAS {
-        source Petstore from "./examples/petstore.yaml" {
-          auth: bearer,
-          base: "https://staging.petstore.com/v1"
-        }
-
-        store pets: memory("pets")
-
-        action Fetch {
-          fetch GET "/custom-path"
-          store response -> pets { key: .id }
-        }
-
-        run Fetch
-      }
-    `;
-        const program = parse(source);
-        const mission = program.statements[0];
-        if (mission.type === 'MissionDefinition') {
-            expect(mission.sources[0].specPath).toBe('./examples/petstore.yaml');
-            expect(mission.sources[0].config.base).toBe('https://staging.petstore.com/v1');
-        }
-    });
-    it('supports both OAS and traditional fetch in same mission', () => {
-        const source = `
-      mission MixedFetch {
-        source Petstore from "./examples/petstore.yaml" {
-          auth: bearer
-        }
-
-        source Legacy {
-          auth: bearer,
-          base: "https://legacy.api.com"
-        }
-
-        store pets: memory("pets")
-
-        action FetchFromOAS {
-          fetch Petstore.listPets
-          store response.pets -> pets { key: .id }
-        }
-
-        action FetchFromLegacy {
-          fetch GET "/old-endpoint" {
-            source: Legacy
-          }
-          store response -> pets { key: .id }
-        }
-
-        run FetchFromOAS then FetchFromLegacy
-      }
-    `;
-        const program = parse(source);
-        const mission = program.statements[0];
-        if (mission.type === 'MissionDefinition') {
-            expect(mission.sources).toHaveLength(2);
-            const oasAction = mission.actions[0];
-            const legacyAction = mission.actions[1];
-            const oasFetch = oasAction.steps[0];
-            const legacyFetch = legacyAction.steps[0];
-            if (oasFetch.type === 'FetchStep' && legacyFetch.type === 'FetchStep') {
-                // OAS fetch
-                expect(oasFetch.operationRef).toBeDefined();
-                expect(oasFetch.method).toBeUndefined();
-                // Traditional fetch
-                expect(legacyFetch.operationRef).toBeUndefined();
-                expect(legacyFetch.method).toBe('GET');
-            }
-        }
-    });
-});

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

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