webpipe-js 0.1.0

package/dist/parser.js

@@ -0,0 +1,594 @@
+class Parser {
+    text;
+    len;
+    pos = 0;
+    diagnostics = [];
+    pipelineRanges = new Map();
+    variableRanges = new Map();
+    constructor(text) {
+        this.text = text;
+        this.len = text.length;
+    }
+    getDiagnostics() {
+        return this.diagnostics.slice();
+    }
+    getPipelineRanges() {
+        return new Map(this.pipelineRanges);
+    }
+    getVariableRanges() {
+        return new Map(this.variableRanges);
+    }
+    report(message, start, end, severity) {
+        this.diagnostics.push({ message, start, end, severity });
+    }
+    findLineStart(pos) {
+        let i = Math.max(0, Math.min(pos, this.len));
+        while (i > 0 && this.text[i - 1] !== '\n')
+            i--;
+        return i;
+    }
+    findLineEnd(pos) {
+        let i = Math.max(0, Math.min(pos, this.len));
+        while (i < this.text.length && this.text[i] !== '\n')
+            i++;
+        return i;
+    }
+    parseProgram() {
+        this.skipSpaces();
+        const configs = [];
+        const pipelines = [];
+        const variables = [];
+        const routes = [];
+        const describes = [];
+        while (!this.eof()) {
+            this.skipSpaces();
+            if (this.eof())
+                break;
+            const start = this.pos;
+            const cfg = this.tryParse(() => this.parseConfig());
+            if (cfg) {
+                configs.push(cfg);
+                continue;
+            }
+            const namedPipe = this.tryParse(() => this.parseNamedPipeline());
+            if (namedPipe) {
+                pipelines.push(namedPipe);
+                continue;
+            }
+            const variable = this.tryParse(() => this.parseVariable());
+            if (variable) {
+                variables.push(variable);
+                continue;
+            }
+            const route = this.tryParse(() => this.parseRoute());
+            if (route) {
+                routes.push(route);
+                continue;
+            }
+            const describe = this.tryParse(() => this.parseDescribe());
+            if (describe) {
+                describes.push(describe);
+                continue;
+            }
+            if (this.pos === start) {
+                const lineStart = this.findLineStart(this.pos);
+                const lineEnd = this.findLineEnd(this.pos);
+                this.report('Unrecognized or unsupported syntax', lineStart, lineEnd, 'warning');
+                this.skipToEol();
+                if (this.cur() === '\n')
+                    this.pos++;
+                this.consumeWhile((c) => c === '\n');
+            }
+        }
+        const backtickCount = (this.text.match(/`/g) || []).length;
+        if (backtickCount % 2 === 1) {
+            const idx = this.text.lastIndexOf('`');
+            const start = Math.max(0, idx);
+            this.report('Unclosed backtick-delimited string', start, start + 1, 'warning');
+        }
+        return { configs, pipelines, variables, routes, describes };
+    }
+    eof() { return this.pos >= this.len; }
+    peek() { return this.text[this.pos] ?? '\0'; }
+    cur() { return this.text[this.pos] ?? '\0'; }
+    ahead(n) { return this.text[this.pos + n] ?? '\0'; }
+    tryParse(fn) {
+        const save = this.pos;
+        try {
+            const value = fn();
+            return value;
+        }
+        catch (_e) {
+            this.pos = save;
+            return null;
+        }
+    }
+    skipSpaces() {
+        while (true) {
+            this.consumeWhile((ch) => ch === ' ' || ch === '\t' || ch === '\r' || ch === '\n');
+            if (this.text.startsWith('#', this.pos)) {
+                this.skipToEol();
+                if (this.cur() === '\n')
+                    this.pos++;
+                continue;
+            }
+            if (this.text.startsWith('//', this.pos)) {
+                this.skipToEol();
+                if (this.cur() === '\n')
+                    this.pos++;
+                continue;
+            }
+            break;
+        }
+    }
+    skipInlineSpaces() {
+        this.consumeWhile((ch) => ch === ' ' || ch === '\t' || ch === '\r');
+    }
+    consumeWhile(pred) {
+        const start = this.pos;
+        while (!this.eof() && pred(this.text[this.pos]))
+            this.pos++;
+        return this.text.slice(start, this.pos);
+    }
+    match(str) {
+        if (this.text.startsWith(str, this.pos)) {
+            this.pos += str.length;
+            return true;
+        }
+        return false;
+    }
+    expect(str) {
+        if (!this.match(str))
+            throw new ParseFailure(`expected '${str}'`, this.pos);
+    }
+    skipToEol() {
+        while (!this.eof() && this.cur() !== '\n')
+            this.pos++;
+    }
+    isIdentStart(ch) {
+        return /[A-Za-z_]/.test(ch);
+    }
+    isIdentCont(ch) {
+        return /[A-Za-z0-9_\-]/.test(ch);
+    }
+    parseIdentifier() {
+        if (!this.isIdentStart(this.cur()))
+            throw new ParseFailure('identifier', this.pos);
+        const start = this.pos;
+        this.pos++;
+        while (!this.eof() && this.isIdentCont(this.cur()))
+            this.pos++;
+        return this.text.slice(start, this.pos);
+    }
+    parseNumber() {
+        const start = this.pos;
+        const digits = this.consumeWhile((c) => /[0-9]/.test(c));
+        if (digits.length === 0)
+            throw new ParseFailure('number', this.pos);
+        return parseInt(this.text.slice(start, this.pos), 10);
+    }
+    parseQuotedString() {
+        this.expect('"');
+        const start = this.pos;
+        while (!this.eof()) {
+            const ch = this.cur();
+            if (ch === '"')
+                break;
+            this.pos++;
+        }
+        const content = this.text.slice(start, this.pos);
+        this.expect('"');
+        return content;
+    }
+    parseBacktickString() {
+        this.expect('`');
+        const start = this.pos;
+        while (!this.eof()) {
+            const ch = this.cur();
+            if (ch === '`')
+                break;
+            this.pos++;
+        }
+        const content = this.text.slice(start, this.pos);
+        this.expect('`');
+        return content;
+    }
+    parseMethod() {
+        const methods = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'];
+        for (const m of methods) {
+            if (this.text.startsWith(m, this.pos)) {
+                this.pos += m.length;
+                return m;
+            }
+        }
+        throw new ParseFailure('method', this.pos);
+    }
+    parseStepConfig() {
+        const bt = this.tryParse(() => this.parseBacktickString());
+        if (bt !== null)
+            return bt;
+        const dq = this.tryParse(() => this.parseQuotedString());
+        if (dq !== null)
+            return dq;
+        const id = this.tryParse(() => this.parseIdentifier());
+        if (id !== null)
+            return id;
+        throw new ParseFailure('step-config', this.pos);
+    }
+    parseConfigValue() {
+        const envWithDefault = this.tryParse(() => {
+            this.expect('$');
+            const variable = this.parseIdentifier();
+            this.skipInlineSpaces();
+            this.expect('||');
+            this.skipInlineSpaces();
+            const def = this.parseQuotedString();
+            return { kind: 'EnvVar', var: variable, default: def };
+        });
+        if (envWithDefault)
+            return envWithDefault;
+        const envNoDefault = this.tryParse(() => {
+            this.expect('$');
+            const variable = this.parseIdentifier();
+            return { kind: 'EnvVar', var: variable };
+        });
+        if (envNoDefault)
+            return envNoDefault;
+        const str = this.tryParse(() => this.parseQuotedString());
+        if (str !== null)
+            return { kind: 'String', value: str };
+        const bool = this.tryParse(() => {
+            if (this.match('true'))
+                return true;
+            if (this.match('false'))
+                return false;
+            throw new ParseFailure('bool', this.pos);
+        });
+        if (bool !== null)
+            return { kind: 'Boolean', value: bool };
+        const num = this.tryParse(() => this.parseNumber());
+        if (num !== null)
+            return { kind: 'Number', value: num };
+        throw new ParseFailure('config-value', this.pos);
+    }
+    parseConfigProperty() {
+        this.skipSpaces();
+        const key = this.parseIdentifier();
+        this.skipInlineSpaces();
+        this.expect(':');
+        this.skipInlineSpaces();
+        const value = this.parseConfigValue();
+        return { key, value };
+    }
+    parseConfig() {
+        this.expect('config');
+        this.skipInlineSpaces();
+        const name = this.parseIdentifier();
+        this.skipInlineSpaces();
+        this.expect('{');
+        this.skipSpaces();
+        const properties = [];
+        while (true) {
+            const prop = this.tryParse(() => this.parseConfigProperty());
+            if (!prop)
+                break;
+            properties.push(prop);
+            this.skipSpaces();
+        }
+        this.skipSpaces();
+        this.expect('}');
+        this.skipSpaces();
+        return { name, properties };
+    }
+    parsePipelineStep() {
+        const result = this.tryParse(() => this.parseResultStep());
+        if (result)
+            return result;
+        return this.parseRegularStep();
+    }
+    parseRegularStep() {
+        this.skipSpaces();
+        this.expect('|>');
+        this.skipInlineSpaces();
+        const name = this.parseIdentifier();
+        this.expect(':');
+        this.skipInlineSpaces();
+        const config = this.parseStepConfig();
+        this.skipSpaces();
+        return { kind: 'Regular', name, config };
+    }
+    parseResultStep() {
+        this.skipSpaces();
+        this.expect('|>');
+        this.skipInlineSpaces();
+        this.expect('result');
+        this.skipSpaces();
+        const branches = [];
+        while (true) {
+            const br = this.tryParse(() => this.parseResultBranch());
+            if (!br)
+                break;
+            branches.push(br);
+        }
+        return { kind: 'Result', branches };
+    }
+    parseResultBranch() {
+        this.skipSpaces();
+        const branchIdent = this.parseIdentifier();
+        let branchType;
+        if (branchIdent === 'ok')
+            branchType = { kind: 'Ok' };
+        else if (branchIdent === 'default')
+            branchType = { kind: 'Default' };
+        else
+            branchType = { kind: 'Custom', name: branchIdent };
+        this.expect('(');
+        const statusCode = this.parseNumber();
+        if (statusCode < 100 || statusCode > 599) {
+            this.report(`Invalid HTTP status code: ${statusCode}`, this.pos - String(statusCode).length, this.pos, 'error');
+        }
+        this.expect(')');
+        this.expect(':');
+        this.skipSpaces();
+        const pipeline = this.parsePipeline();
+        return { branchType, statusCode, pipeline };
+    }
+    parsePipeline() {
+        const steps = [];
+        while (true) {
+            const save = this.pos;
+            this.skipSpaces();
+            if (!this.text.startsWith('|>', this.pos)) {
+                this.pos = save;
+                break;
+            }
+            const step = this.parsePipelineStep();
+            steps.push(step);
+        }
+        return { steps };
+    }
+    parseNamedPipeline() {
+        const start = this.pos;
+        this.expect('pipeline');
+        this.skipInlineSpaces();
+        const name = this.parseIdentifier();
+        this.skipInlineSpaces();
+        this.expect('=');
+        this.skipInlineSpaces();
+        const beforePipeline = this.pos;
+        const pipeline = this.parsePipeline();
+        const end = this.pos;
+        this.pipelineRanges.set(name, { start, end });
+        this.skipSpaces();
+        return { name, pipeline };
+    }
+    parsePipelineRef() {
+        const inline = this.tryParse(() => this.parsePipeline());
+        if (inline && inline.steps.length > 0)
+            return { kind: 'Inline', pipeline: inline };
+        const named = this.tryParse(() => {
+            this.skipSpaces();
+            this.expect('|>');
+            this.skipInlineSpaces();
+            this.expect('pipeline:');
+            this.skipInlineSpaces();
+            const name = this.parseIdentifier();
+            return { kind: 'Named', name };
+        });
+        if (named)
+            return named;
+        throw new Error('pipeline-ref');
+    }
+    parseVariable() {
+        const start = this.pos;
+        const varType = this.parseIdentifier();
+        this.skipInlineSpaces();
+        const name = this.parseIdentifier();
+        this.skipInlineSpaces();
+        this.expect('=');
+        this.skipInlineSpaces();
+        const value = this.parseBacktickString();
+        const end = this.pos;
+        this.variableRanges.set(`${varType}::${name}`, { start, end });
+        this.skipSpaces();
+        return { varType, name, value };
+    }
+    parseRoute() {
+        const method = this.parseMethod();
+        this.skipInlineSpaces();
+        const path = this.consumeWhile((c) => c !== ' ' && c !== '\n');
+        this.skipSpaces();
+        const pipeline = this.parsePipelineRef();
+        this.skipSpaces();
+        return { method, path, pipeline };
+    }
+    parseWhen() {
+        const calling = this.tryParse(() => {
+            this.expect('calling');
+            this.skipInlineSpaces();
+            const method = this.parseMethod();
+            this.skipInlineSpaces();
+            const path = this.consumeWhile((c) => c !== '\n');
+            return { kind: 'CallingRoute', method, path };
+        });
+        if (calling)
+            return calling;
+        const executingPipeline = this.tryParse(() => {
+            this.expect('executing');
+            this.skipInlineSpaces();
+            this.expect('pipeline');
+            this.skipInlineSpaces();
+            const name = this.parseIdentifier();
+            return { kind: 'ExecutingPipeline', name };
+        });
+        if (executingPipeline)
+            return executingPipeline;
+        const executingVariable = this.tryParse(() => {
+            this.expect('executing');
+            this.skipInlineSpaces();
+            this.expect('variable');
+            this.skipInlineSpaces();
+            const varType = this.parseIdentifier();
+            this.skipInlineSpaces();
+            const name = this.parseIdentifier();
+            return { kind: 'ExecutingVariable', varType, name };
+        });
+        if (executingVariable)
+            return executingVariable;
+        throw new ParseFailure('when', this.pos);
+    }
+    parseCondition() {
+        this.skipSpaces();
+        const ct = (() => {
+            if (this.match('then'))
+                return 'Then';
+            if (this.match('and'))
+                return 'And';
+            throw new Error('condition-type');
+        })();
+        this.skipInlineSpaces();
+        const field = this.consumeWhile((c) => c !== ' ' && c !== '\n' && c !== '`');
+        this.skipInlineSpaces();
+        const jqExpr = this.tryParse(() => this.parseBacktickString());
+        this.skipInlineSpaces();
+        const comparison = this.consumeWhile((c) => c !== ' ' && c !== '\n');
+        this.skipInlineSpaces();
+        const value = (() => {
+            const v1 = this.tryParse(() => this.parseBacktickString());
+            if (v1 !== null)
+                return v1;
+            const v2 = this.tryParse(() => this.parseQuotedString());
+            if (v2 !== null)
+                return v2;
+            return this.consumeWhile((c) => c !== '\n');
+        })();
+        return { conditionType: ct, field, jqExpr: jqExpr ?? undefined, comparison, value };
+    }
+    parseMockHead(prefixWord) {
+        this.skipSpaces();
+        this.expect(prefixWord);
+        this.skipInlineSpaces();
+        this.expect('mock');
+        this.skipInlineSpaces();
+        const target = this.consumeWhile((c) => c !== ' ' && c !== '\n');
+        this.skipInlineSpaces();
+        this.expect('returning');
+        this.skipInlineSpaces();
+        const returnValue = this.parseBacktickString();
+        this.skipSpaces();
+        return { target, returnValue };
+    }
+    parseMock() {
+        return this.parseMockHead('with');
+    }
+    parseAndMock() {
+        return this.parseMockHead('and');
+    }
+    parseIt() {
+        this.skipSpaces();
+        this.expect('it');
+        this.skipInlineSpaces();
+        this.expect('"');
+        const name = this.consumeWhile((c) => c !== '"');
+        this.expect('"');
+        this.skipSpaces();
+        const mocks = [];
+        while (true) {
+            const m = this.tryParse(() => this.parseMock());
+            if (!m)
+                break;
+            mocks.push(m);
+        }
+        this.expect('when');
+        this.skipInlineSpaces();
+        const when = this.parseWhen();
+        this.skipSpaces();
+        const input = this.tryParse(() => {
+            this.expect('with');
+            this.skipInlineSpaces();
+            this.expect('input');
+            this.skipInlineSpaces();
+            const v = this.parseBacktickString();
+            this.skipSpaces();
+            return v;
+        }) ?? undefined;
+        const extraMocks = [];
+        while (true) {
+            const m = this.tryParse(() => this.parseAndMock());
+            if (!m)
+                break;
+            extraMocks.push(m);
+            this.skipSpaces();
+        }
+        const conditions = [];
+        while (true) {
+            const c = this.tryParse(() => this.parseCondition());
+            if (!c)
+                break;
+            conditions.push(c);
+        }
+        return { name, mocks: [...mocks, ...extraMocks], when, input, conditions };
+    }
+    parseDescribe() {
+        this.skipSpaces();
+        this.expect('describe');
+        this.skipInlineSpaces();
+        this.expect('"');
+        const name = this.consumeWhile((c) => c !== '"');
+        this.expect('"');
+        this.skipSpaces();
+        const mocks = [];
+        while (true) {
+            const m = this.tryParse(() => this.parseMock());
+            if (!m)
+                break;
+            mocks.push(m);
+            this.skipSpaces();
+        }
+        const tests = [];
+        while (true) {
+            const it = this.tryParse(() => this.parseIt());
+            if (!it)
+                break;
+            tests.push(it);
+        }
+        return { name, mocks, tests };
+    }
+}
+export function parseProgram(text) {
+    const parser = new Parser(text);
+    return parser.parseProgram();
+}
+export function parseProgramWithDiagnostics(text) {
+    const parser = new Parser(text);
+    const program = parser.parseProgram();
+    return { program, diagnostics: parser.getDiagnostics() };
+}
+export function getPipelineRanges(text) {
+    const parser = new Parser(text);
+    parser.parseProgram();
+    return parser.getPipelineRanges();
+}
+export function getVariableRanges(text) {
+    const parser = new Parser(text);
+    parser.parseProgram();
+    return parser.getVariableRanges();
+}
+class ParseFailure extends Error {
+    at;
+    constructor(message, at) {
+        super(message);
+        this.at = at;
+    }
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const fs = await import('node:fs/promises');
+    const path = process.argv[2];
+    if (!path) {
+        console.error('Usage: node dist/parser.js <file.wp>');
+        process.exit(1);
+    }
+    const src = await fs.readFile(path, 'utf8');
+    const program = parseProgram(src);
+    console.log(JSON.stringify(program, null, 2));
+}

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

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

package/dist/tests/parser.test.js

@@ -0,0 +1,106 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { describe, it, expect, beforeAll } from 'vitest';
+import { parseProgram } from '../parser';
+function loadFixture(name) {
+    const file = resolve(process.cwd(), name);
+    return readFileSync(file, 'utf8');
+}
+describe('parseProgram - comprehensive_test.wp', () => {
+    let program;
+    beforeAll(() => {
+        const src = loadFixture('comprehensive_test.wp');
+        program = parseProgram(src);
+    });
+    it('parses at least one route', () => {
+        expect(program.routes.length).toBeGreaterThan(0);
+        const hello = program.routes.find(r => r.path.startsWith('/hello'));
+        expect(hello).toBeTruthy();
+        expect(hello.method).toBe('GET');
+        // First step should be jq with config string
+        if (hello.pipeline.kind === 'Inline') {
+            const first = hello.pipeline.pipeline.steps[0];
+            expect(first.kind).toBe('Regular');
+            if (first.kind === 'Regular') {
+                expect(first.name).toBe('jq');
+                expect(typeof first.config).toBe('string');
+            }
+        }
+    });
+    it('parses configs', () => {
+        expect(program.configs.length).toBeGreaterThan(0);
+        const pg = program.configs.find(c => c.name === 'pg');
+        expect(pg).toBeTruthy();
+        expect(pg.properties.length).toBeGreaterThan(3);
+        const host = pg.properties.find(p => p.key === 'host');
+        expect(host).toBeTruthy();
+        expect(host.value.kind === 'EnvVar' || host.value.kind === 'String').toBe(true);
+    });
+    it('parses named pipelines and references', () => {
+        const np = program.pipelines.find(p => p.name === 'getTeams');
+        expect(np).toBeTruthy();
+        const route = program.routes.find(r => r.path.startsWith('/page/'));
+        expect(route).toBeTruthy();
+        expect(route.pipeline.kind).toBe('Inline');
+        if (route.pipeline.kind === 'Inline') {
+            const step = route.pipeline.pipeline.steps[0];
+            expect(step.kind).toBe('Regular');
+            if (step.kind === 'Regular') {
+                expect(step.name).toBe('pipeline');
+                expect(step.config).toBe('getTeams');
+            }
+        }
+    });
+    it('parses variables', () => {
+        expect(program.variables.length).toBeGreaterThan(0);
+        const teamsQuery = program.variables.find(v => v.name === 'teamsQuery');
+        expect(teamsQuery).toBeTruthy();
+        expect(teamsQuery.varType).toBe('pg');
+        expect(typeof teamsQuery.value).toBe('string');
+    });
+    it('parses describes and tests with conditions', () => {
+        expect(program.describes.length).toBeGreaterThan(0);
+        const d = program.describes.find(dd => dd.name.includes('hello'));
+        expect(d).toBeTruthy();
+        expect(d.tests.length).toBeGreaterThan(0);
+        const t0 = d.tests[0];
+        expect(t0.when).toBeTruthy();
+        expect(t0.conditions.length).toBeGreaterThan(0);
+    });
+});
+describe('parseProgram - focused samples', () => {
+    it('parses result branches', () => {
+        const src = `GET /test\n  |> jq: \`{message: "x"}\`\n  |> result\n    ok(200):\n      |> jq: \`{ok: true}\`\n    default(500):\n      |> jq: \`{ok: false}\``;
+        const program = parseProgram(src);
+        expect(program.routes.length).toBe(1);
+        const steps = program.routes[0].pipeline.pipeline.steps;
+        const res = steps.find(s => s.kind === 'Result');
+        expect(res).toBeTruthy();
+        expect(res.branches.length).toBe(2);
+        expect(res.branches[0].statusCode).toBe(200);
+        expect(res.branches[1].statusCode).toBe(500);
+    });
+    it('parses POST with body conversion pipeline', () => {
+        const src = `POST /users\n  |> jq: \`{ name: .body.name }\``;
+        const program = parseProgram(src);
+        expect(program.routes[0].method).toBe('POST');
+        const first = program.routes[0].pipeline.pipeline.steps[0];
+        expect(first.name).toBe('jq');
+    });
+    it('parses inline and named pipeline refs', () => {
+        const src = `pipeline p =\n  |> jq: \`{x:1}\`\n\nGET /a\n  |> pipeline: p`;
+        const program = parseProgram(src);
+        const p = program.pipelines.find(pp => pp.name === 'p');
+        expect(p).toBeTruthy();
+        const route = program.routes[0];
+        expect(route.pipeline.kind).toBe('Inline');
+        if (route.pipeline.kind === 'Inline') {
+            const step = route.pipeline.pipeline.steps[0];
+            expect(step.kind).toBe('Regular');
+            if (step.kind === 'Regular') {
+                expect(step.name).toBe('pipeline');
+                expect(step.config).toBe('p');
+            }
+        }
+    });
+});