@forgerapi/parser 0.0.1

package/dist/analyzer.d.ts

@@ -0,0 +1,5 @@
+import type { ForgerSchema } from "@forgerapi/ast";
+export declare class ForgerSemanticError extends Error {
+    constructor(message: string);
+}
+export declare function analyze(schema: ForgerSchema): void;

package/dist/analyzer.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForgerSemanticError = void 0;
+exports.analyze = analyze;
+class ForgerSemanticError extends Error {
+    constructor(message) {
+        super(`[Semantic Error] ${message}`);
+    }
+}
+exports.ForgerSemanticError = ForgerSemanticError;
+function analyze(schema) {
+    const allNames = new Set();
+    for (const enm of schema.enums) {
+        if (allNames.has(enm.name)) {
+            throw new ForgerSemanticError(`Duplicate enum name: ${enm.name}`);
+        }
+        if (enm.values.length === 0) {
+            throw new ForgerSemanticError(`Enum ${enm.name} has no values`);
+        }
+        const seen = new Set();
+        for (const v of enm.values) {
+            if (seen.has(v)) {
+                throw new ForgerSemanticError(`Duplicate value ${v} in enum ${enm.name}`);
+            }
+            seen.add(v);
+        }
+        allNames.add(enm.name);
+    }
+    for (const model of schema.models) {
+        if (allNames.has(model.name)) {
+            throw new ForgerSemanticError(`Duplicate model name: ${model.name}`);
+        }
+        allNames.add(model.name);
+    }
+    for (const model of schema.models) {
+        const fieldNames = new Set();
+        for (const field of model.fields) {
+            if (fieldNames.has(field.name)) {
+                throw new ForgerSemanticError(`Duplicate field '${field.name}' in model ${model.name}`);
+            }
+            fieldNames.add(field.name);
+            const rel = field.relation;
+            if (rel && !allNames.has(rel.target)) {
+                throw new ForgerSemanticError(`Model ${model.name}: relation target '${rel.target}' not found`);
+            }
+            if (rel?.field && !fieldNames.has(rel.field)) {
+                throw new ForgerSemanticError(`Model ${model.name}: relation field '${rel.field}' not found in model`);
+            }
+            const hasId = field.constraints.some((c) => c.type === "id");
+            if (hasId && field.type !== "uuid") {
+                throw new ForgerSemanticError(`Model ${model.name}: @id field '${field.name}' must be uuid type`);
+            }
+        }
+    }
+    for (const action of schema.actions) {
+        if (action.emits) {
+            for (const eventName of action.emits) {
+                const hasEvent = schema.events.some((e) => e.name === eventName);
+                if (!hasEvent) {
+                    schema.events.push({ name: eventName });
+                }
+            }
+        }
+    }
+    for (const guard of schema.guards) {
+        if (!guard.import) {
+            throw new ForgerSemanticError(`Guard ${guard.name} has no import — custom guard stubs not yet supported`);
+        }
+        for (const g of schema.guards) {
+            if (g.name === guard.name && g !== guard) {
+                throw new ForgerSemanticError(`Duplicate guard name: ${guard.name}`);
+            }
+        }
+        const guardNames = new Set(schema.guards.map((g) => g.name));
+        if (guardNames.size !== schema.guards.length) {
+            // already handled above
+        }
+    }
+    const modelNames = new Set(schema.models.map((m) => m.name));
+    const guardNames = new Set(schema.guards.map((g) => g.name));
+    for (const mod of schema.modules) {
+        for (const mName of mod.models) {
+            if (!modelNames.has(mName)) {
+                throw new ForgerSemanticError(`Module ${mod.name}: model '${mName}' not found`);
+            }
+        }
+        for (const gName of mod.guards) {
+            if (!guardNames.has(gName)) {
+                throw new ForgerSemanticError(`Module ${mod.name}: guard '${gName}' not found`);
+            }
+        }
+        const actionNames = new Set();
+        for (const action of mod.actions) {
+            if (actionNames.has(action.name)) {
+                throw new ForgerSemanticError(`Module ${mod.name}: duplicate action name '${action.name}'`);
+            }
+            actionNames.add(action.name);
+            if (action.emits) {
+                for (const eventName of action.emits) {
+                    const hasEvent = schema.events.some((e) => e.name === eventName);
+                    if (!hasEvent) {
+                        schema.events.push({ name: eventName });
+                    }
+                }
+            }
+        }
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,5 @@
+export declare class ForgerError extends Error {
+    line: number;
+    column: number;
+    constructor(message: string, line: number, column: number);
+}

package/dist/errors.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForgerError = void 0;
+class ForgerError extends Error {
+    constructor(message, line, column) {
+        super(`[ForgerError ${line}:${column}] ${message}`);
+        this.line = line;
+        this.column = column;
+    }
+}
+exports.ForgerError = ForgerError;

package/dist/fs.d.ts

@@ -0,0 +1 @@
+export declare function parseFile(path: string): import("@forgerapi/ast").ForgerSchema;

package/dist/fs.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFile = parseFile;
+const node_fs_1 = require("node:fs");
+const analyzer_1 = require("./analyzer");
+const parser_1 = require("./parser");
+function parseFile(path) {
+    const source = (0, node_fs_1.readFileSync)(path, "utf-8");
+    const schema = (0, parser_1.parse)(source);
+    (0, analyzer_1.analyze)(schema);
+    return schema;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./analyzer";
+export * from "./fs";
+export * from "./lexer";
+export * from "./parser";

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./analyzer"), exports);
+__exportStar(require("./fs"), exports);
+__exportStar(require("./lexer"), exports);
+__exportStar(require("./parser"), exports);

package/dist/lexer.d.ts

@@ -0,0 +1,2 @@
+import type { Token } from "./tokens";
+export declare function tokenize(input: string): Token[];

package/dist/lexer.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenize = tokenize;
+const KEYWORDS = new Set([
+    "model",
+    "enum",
+    "action",
+    "guard",
+    "module",
+    "input",
+    "steps",
+    "emits",
+    "route",
+    "method",
+    "import",
+    "guards",
+    "models",
+]);
+const TYPES = new Set(["string", "number", "boolean", "uuid", "datetime"]);
+const SYMBOLS = new Set(["{", "}", ":", "(", ")", "[", "]", ","]);
+function tokenize(input) {
+    const tokens = [];
+    const lines = input.split("\n");
+    for (let line = 0; line < lines.length; line++) {
+        const raw = lines[line];
+        let i = 0;
+        while (i < raw.length) {
+            if (raw[i] === "/" && i + 1 < raw.length && raw[i + 1] === "/") {
+                break;
+            }
+            if (raw[i] === '"') {
+                const close = raw.indexOf('"', i + 1);
+                const end = close === -1 ? raw.length : close + 1;
+                const value = raw.slice(i, end);
+                tokens.push({
+                    type: classify(value),
+                    value,
+                    line: line + 1,
+                    column: i + 1,
+                });
+                i = end;
+                continue;
+            }
+            if (SYMBOLS.has(raw[i])) {
+                tokens.push({
+                    type: "symbol",
+                    value: raw[i],
+                    line: line + 1,
+                    column: i + 1,
+                });
+                i++;
+                continue;
+            }
+            if (raw[i] === " " || raw[i] === "\t" || raw[i] === "\r") {
+                i++;
+                continue;
+            }
+            let end = i + 1;
+            while (end < raw.length &&
+                !(SYMBOLS.has(raw[end]) || raw[end] === " " || raw[end] === "\t" || raw[end] === "\r")) {
+                end++;
+            }
+            const value = raw.slice(i, end);
+            tokens.push({
+                type: classify(value),
+                value,
+                line: line + 1,
+                column: i + 1,
+            });
+            i = end;
+        }
+    }
+    tokens.push({ type: "eof", value: "", line: lines.length + 1, column: 0 });
+    return tokens;
+}
+function classify(word) {
+    if (word.startsWith("@"))
+        return "annotation";
+    if (KEYWORDS.has(word))
+        return "keyword";
+    if (TYPES.has(word))
+        return "type";
+    if (SYMBOLS.has(word))
+        return "symbol";
+    return "identifier";
+}

package/dist/parser.d.ts

@@ -0,0 +1,2 @@
+import type { ForgerSchema } from "@forgerapi/ast";
+export declare function parse(input: string): ForgerSchema;

package/dist/parser.js

@@ -0,0 +1,314 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = parse;
+const lexer_1 = require("./lexer");
+function parse(input) {
+    const tokens = (0, lexer_1.tokenize)(input);
+    let pos = 0;
+    function peek(offset = 0) {
+        return tokens[pos + offset] ?? null;
+    }
+    function next() {
+        const token = tokens[pos++];
+        if (!token)
+            throw new Error("Unexpected end of input");
+        return token;
+    }
+    function expect(type, value) {
+        const token = next();
+        if (token.type !== type) {
+            throw new Error(`Expected ${type}, got ${token.type} (${token.value}) at ${token.line}:${token.column}`);
+        }
+        if (value && token.value !== value) {
+            throw new Error(`Expected '${value}', got '${token.value}' at ${token.line}:${token.column}`);
+        }
+        return token;
+    }
+    function parseSchema() {
+        const enums = [];
+        const models = [];
+        const actions = [];
+        const events = [];
+        const guards = [];
+        const modules = [];
+        while (peek() && peek()?.type !== "eof") {
+            const kw = peek();
+            if (!kw)
+                break;
+            if (kw.type === "keyword" && kw.value === "enum") {
+                enums.push(parseEnum());
+            }
+            else if (kw.type === "keyword" && kw.value === "model") {
+                models.push(parseModel());
+            }
+            else if (kw.type === "keyword" && kw.value === "action") {
+                actions.push(parseAction());
+            }
+            else if (kw.type === "keyword" && kw.value === "guard") {
+                guards.push(parseGuard());
+            }
+            else if (kw.type === "keyword" && kw.value === "module") {
+                modules.push(parseModule());
+            }
+            else {
+                next();
+            }
+        }
+        return { enums, models, actions, events, guards, modules };
+    }
+    function parseEnum() {
+        expect("keyword", "enum");
+        const name = expect("identifier").value;
+        expect("symbol", "{");
+        const values = [];
+        while (peek() && !(peek()?.type === "symbol" && peek()?.value === "}")) {
+            const token = next();
+            if (token.type !== "identifier") {
+                throw new Error(`Expected identifier, got ${token.type} at ${token.line}:${token.column}`);
+            }
+            values.push(token.value);
+        }
+        expect("symbol", "}");
+        return { name, values };
+    }
+    function parseModel() {
+        expect("keyword", "model");
+        const name = expect("identifier").value;
+        expect("symbol", "{");
+        const fields = [];
+        while (peek() && !(peek()?.type === "symbol" && peek()?.value === "}")) {
+            fields.push(parseField());
+        }
+        expect("symbol", "}");
+        return { name, fields };
+    }
+    function parseField() {
+        const fieldName = expect("identifier").value;
+        expect("symbol", ":");
+        const { type, relation } = parseFieldType();
+        const constraints = parseConstraints();
+        const relField = parseRelationField();
+        const result = {
+            name: fieldName,
+            type,
+            constraints,
+            relation,
+        };
+        if (relField && result.relation) {
+            result.relation.field = relField;
+        }
+        return result;
+    }
+    function parseFieldType() {
+        const token = next();
+        if (token.type === "type") {
+            return { type: token.value };
+        }
+        if (token.type === "identifier") {
+            const isArray = peek()?.type === "symbol" && peek()?.value === "[";
+            if (isArray) {
+                next();
+                expect("symbol", "]");
+                return {
+                    type: "uuid",
+                    relation: { target: token.value, isArray: true },
+                };
+            }
+            return {
+                type: token.value,
+                relation: { target: token.value, isArray: false },
+            };
+        }
+        throw new Error(`Expected type or identifier, got ${token.type} at ${token.line}:${token.column}`);
+    }
+    function parseConstraints() {
+        const constraints = [];
+        while (peek()?.type === "annotation" &&
+            !isRelationAnnotation(peek().value)) {
+            const annotation = next();
+            const name = annotation.value.slice(1);
+            if (name === "id") {
+                constraints.push({ type: "id" });
+            }
+            else if (name === "unique") {
+                constraints.push({ type: "unique" });
+            }
+            else if (name === "default") {
+                expect("symbol", "(");
+                const valueToken = next();
+                expect("symbol", ")");
+                constraints.push({ type: "default", value: valueToken.value });
+            }
+            else {
+                throw new Error(`Unknown annotation @${name} at ${annotation.line}:${annotation.column}`);
+            }
+        }
+        return constraints;
+    }
+    function parseRelationField() {
+        if (peek()?.type === "annotation" && isRelationAnnotation(peek().value)) {
+            next();
+            expect("symbol", "(");
+            const fieldValue = expect("identifier").value;
+            expect("symbol", ")");
+            return fieldValue;
+        }
+        return undefined;
+    }
+    function isRelationAnnotation(value) {
+        return value === "@relation";
+    }
+    function parseAction() {
+        expect("keyword", "action");
+        const name = expect("identifier").value;
+        expect("symbol", "{");
+        let inputs = [];
+        let steps = [];
+        let emits = [];
+        let route;
+        let method;
+        while (peek() && !(peek()?.type === "symbol" && peek()?.value === "}")) {
+            const kw = peek();
+            if (!kw)
+                break;
+            if (kw.type === "keyword" && kw.value === "route") {
+                next();
+                route = parseStringValue();
+            }
+            else if (kw.type === "keyword" && kw.value === "method") {
+                next();
+                expect("symbol", ":");
+                method = expect("identifier").value;
+            }
+            else if (kw.type === "keyword" && kw.value === "input") {
+                next();
+                inputs = parseActionInputs();
+            }
+            else if (kw.type === "keyword" && kw.value === "steps") {
+                next();
+                steps = parseBlock();
+            }
+            else if (kw.type === "keyword" && kw.value === "emits") {
+                next();
+                emits = parseBlock();
+            }
+            else {
+                next();
+            }
+        }
+        expect("symbol", "}");
+        const result = { name, inputs, steps };
+        if (emits.length > 0)
+            result.emits = emits;
+        if (route !== undefined)
+            result.route = route;
+        if (method !== undefined)
+            result.method = method;
+        return result;
+    }
+    function parseActionInputs() {
+        expect("symbol", ":");
+        if (peek()?.type === "symbol" && peek()?.value === "[") {
+            next();
+            const inputs = [];
+            while (peek() &&
+                !(peek()?.type === "symbol" && peek()?.value === "]")) {
+                const name = expect("identifier").value;
+                expect("symbol", ":");
+                const typeToken = next();
+                if (typeToken.type !== "type" && typeToken.type !== "identifier") {
+                    throw new Error(`Expected type for input '${name}', got ${typeToken.type} (${typeToken.value})`);
+                }
+                inputs.push({ name, type: typeToken.value });
+                if (peek()?.type === "symbol" && peek()?.value === ",") {
+                    next();
+                }
+            }
+            expect("symbol", "]");
+            return inputs;
+        }
+        const names = [];
+        while (peek() && peek()?.type === "identifier") {
+            names.push(next().value);
+        }
+        return names.map((n) => ({ name: n, type: "string" }));
+    }
+    function parseBlock() {
+        expect("symbol", ":");
+        const items = [];
+        while (peek() && peek()?.type === "identifier") {
+            items.push(next().value);
+        }
+        return items;
+    }
+    function parseStringValue() {
+        expect("symbol", ":");
+        const token = next();
+        let value = token.value;
+        if (value.startsWith('"') && value.endsWith('"')) {
+            value = value.slice(1, -1);
+        }
+        return value;
+    }
+    function parseGuard() {
+        expect("keyword", "guard");
+        const name = expect("identifier").value;
+        expect("symbol", "{");
+        let importStr;
+        while (peek() && !(peek()?.type === "symbol" && peek()?.value === "}")) {
+            const kw = peek();
+            if (!kw)
+                break;
+            if (kw.type === "keyword" && kw.value === "import") {
+                next();
+                importStr = parseStringValue();
+            }
+            else {
+                next();
+            }
+        }
+        expect("symbol", "}");
+        return { name, import: importStr };
+    }
+    function parseModule() {
+        expect("keyword", "module");
+        const name = expect("identifier").value;
+        expect("symbol", "{");
+        let route = "";
+        const models = [];
+        const guards = [];
+        const actions = [];
+        while (peek() && !(peek()?.type === "symbol" && peek()?.value === "}")) {
+            const kw = peek();
+            if (!kw)
+                break;
+            if (kw.type === "keyword" && kw.value === "route") {
+                next();
+                route = parseStringValue();
+            }
+            else if (kw.type === "keyword" && kw.value === "models") {
+                next();
+                expect("symbol", ":");
+                while (peek() && peek()?.type === "identifier") {
+                    models.push(next().value);
+                }
+            }
+            else if (kw.type === "keyword" && kw.value === "guards") {
+                next();
+                expect("symbol", ":");
+                while (peek() && peek()?.type === "identifier") {
+                    guards.push(next().value);
+                }
+            }
+            else if (kw.type === "keyword" && kw.value === "action") {
+                actions.push(parseAction());
+            }
+            else {
+                next();
+            }
+        }
+        expect("symbol", "}");
+        return { name, route, models, guards, actions };
+    }
+    return parseSchema();
+}

package/dist/tokenStream.d.ts

@@ -0,0 +1,9 @@
+import type { Token } from "./tokens";
+export declare class TokenStream {
+    private tokens;
+    private pos;
+    constructor(tokens: Token[]);
+    peek(offset?: number): Token | null;
+    next(): Token;
+    expect(type: string, value?: string): Token;
+}

package/dist/tokenStream.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenStream = void 0;
+const errors_1 = require("./errors");
+class TokenStream {
+    constructor(tokens) {
+        this.tokens = tokens;
+        this.pos = 0;
+    }
+    peek(offset = 0) {
+        return this.tokens[this.pos + offset] ?? null;
+    }
+    next() {
+        const token = this.tokens[this.pos++];
+        if (!token) {
+            throw new Error("Unexpected end of input");
+        }
+        return token;
+    }
+    expect(type, value) {
+        const token = this.next();
+        if (token.type !== type) {
+            throw new errors_1.ForgerError(`Expected ${type}, got ${token.type}`, token.line, token.column);
+        }
+        if (value && token.value !== value) {
+            throw new errors_1.ForgerError(`Expected '${value}', got '${token.value}'`, token.line, token.column);
+        }
+        return token;
+    }
+}
+exports.TokenStream = TokenStream;

package/dist/tokens.d.ts

@@ -0,0 +1,7 @@
+export type TokenType = "keyword" | "identifier" | "symbol" | "type" | "annotation" | "eof";
+export interface Token {
+    type: TokenType;
+    value: string;
+    line: number;
+    column: number;
+}

package/dist/tokens.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,24 @@
+{
+	"name": "@forgerapi/parser",
+	"version": "0.0.1",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"files": [
+		"dist"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/linecodesxx/forgerapi.git",
+		"directory": "packages/parser"
+	},
+	"scripts": {
+		"build": "tsc"
+	},
+	"dependencies": {
+		"@forgerapi/ast": "^0.0.1"
+	}
+}