schematic-pg 0.1.0

package/dist/db/where-translator.js

@@ -0,0 +1,141 @@
+export class WhereTranslator {
+    model;
+    scalarFields;
+    paramIndex;
+    startParamIndex;
+    constructor(model, startParamIndex = 1) {
+        this.model = model;
+        this.scalarFields = new Set(model.fields.map((field) => field.name));
+        this.startParamIndex = startParamIndex;
+        this.paramIndex = startParamIndex;
+    }
+    translate(where) {
+        this.paramIndex = this.startParamIndex;
+        if (!where || Object.keys(where).length === 0) {
+            return { sql: '', params: [] };
+        }
+        const params = [];
+        const clauses = [];
+        for (const [key, value] of Object.entries(where)) {
+            if (key === 'AND') {
+                clauses.push(this.translateLogical(value, 'AND', params));
+                continue;
+            }
+            if (key === 'OR') {
+                clauses.push(this.translateLogical(value, 'OR', params));
+                continue;
+            }
+            if (key === 'NOT') {
+                const nested = this.translateNested(value, params);
+                clauses.push(`NOT (${nested})`);
+                continue;
+            }
+            if (!this.scalarFields.has(key)) {
+                throw new Error(`Unknown where field "${key}" on model ${this.model.name}`);
+            }
+            clauses.push(this.translateField(key, value, params));
+        }
+        return {
+            sql: clauses.join(' AND '),
+            params,
+        };
+    }
+    getNextParamIndex() {
+        return this.paramIndex;
+    }
+    translateLogical(value, operator, params) {
+        if (!Array.isArray(value)) {
+            throw new Error(`${operator} expects an array of where clauses`);
+        }
+        const parts = value.map((entry) => this.translateNested(entry, params));
+        return `(${parts.join(` ${operator} `)})`;
+    }
+    translateNested(where, params) {
+        const nestedClauses = [];
+        for (const [key, value] of Object.entries(where)) {
+            if (key === 'AND') {
+                nestedClauses.push(this.translateLogical(value, 'AND', params));
+                continue;
+            }
+            if (key === 'OR') {
+                nestedClauses.push(this.translateLogical(value, 'OR', params));
+                continue;
+            }
+            if (key === 'NOT') {
+                const nested = this.translateNested(value, params);
+                nestedClauses.push(`NOT (${nested})`);
+                continue;
+            }
+            nestedClauses.push(this.translateField(key, value, params));
+        }
+        return nestedClauses.join(' AND ');
+    }
+    translateField(fieldName, value, params) {
+        const field = this.model.fieldByName.get(fieldName);
+        if (!field) {
+            throw new Error(`Unknown field "${fieldName}"`);
+        }
+        const column = field.columnName;
+        if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+            return this.translateOperator(field, column, value, params);
+        }
+        params.push(value);
+        return `${column} = ${this.nextPlaceholder()}`;
+    }
+    translateOperator(field, column, operators, params) {
+        const entries = Object.entries(operators);
+        if (entries.length !== 1) {
+            throw new Error(`Field "${field.name}" expects a single filter operator`);
+        }
+        const [operator, rawValue] = entries[0];
+        if (operator === 'equals') {
+            params.push(rawValue);
+            return `${column} = ${this.nextPlaceholder()}`;
+        }
+        if (operator === 'in') {
+            if (!Array.isArray(rawValue) || rawValue.length === 0) {
+                throw new Error(`Field "${field.name}" "in" expects a non-empty array`);
+            }
+            const placeholders = rawValue.map((item) => {
+                params.push(item);
+                return this.nextPlaceholder();
+            });
+            return `${column} IN (${placeholders.join(', ')})`;
+        }
+        if (operator === 'contains' || operator === 'startsWith' || operator === 'endsWith') {
+            if (!field.isString) {
+                throw new Error(`Operator "${operator}" is only supported on string fields`);
+            }
+            params.push(wrapLikePattern(String(rawValue), operator));
+            return `${column} LIKE ${this.nextPlaceholder()}`;
+        }
+        if (operator === 'gt' || operator === 'gte' || operator === 'lt' || operator === 'lte') {
+            if (!field.isNumeric && !field.isEnum) {
+                throw new Error(`Operator "${operator}" is only supported on numeric or enum fields`);
+            }
+            const sqlOperator = {
+                gt: '>',
+                gte: '>=',
+                lt: '<',
+                lte: '<=',
+            }[operator];
+            params.push(rawValue);
+            return `${column} ${sqlOperator} ${this.nextPlaceholder()}`;
+        }
+        throw new Error(`Unsupported operator "${operator}" for field "${field.name}"`);
+    }
+    nextPlaceholder() {
+        const placeholder = `$${this.paramIndex}`;
+        this.paramIndex += 1;
+        return placeholder;
+    }
+}
+function wrapLikePattern(value, operator) {
+    if (operator === 'contains') {
+        return `%${value}%`;
+    }
+    if (operator === 'startsWith') {
+        return `${value}%`;
+    }
+    return `%${value}`;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './schema-dsl/index.js';

package/dist/index.js

@@ -0,0 +1 @@
+export * from './schema-dsl/index.js';

package/dist/routes/health.d.ts

@@ -0,0 +1,4 @@
+import { Hono } from 'hono';
+import type { AppEnv } from 'schematic-pg/api/types';
+declare const router: Hono<AppEnv, import("hono/types").BlankSchema, "/">;
+export default router;

package/dist/routes/health.js

@@ -0,0 +1,4 @@
+import { Hono } from 'hono';
+const router = new Hono();
+router.get('/', (c) => c.json({ ok: true }));
+export default router;

package/dist/schema-dsl/ast.d.ts

@@ -0,0 +1,108 @@
+export interface SourceLocation {
+    line: number;
+    col: number;
+    endLine?: number;
+    endCol?: number;
+}
+export interface Schema {
+    kind: 'Schema';
+    extensions: Extension[];
+    enums: Enum[];
+    models: Model[];
+    loc: SourceLocation;
+}
+export interface Extension {
+    kind: 'Extension';
+    name: string;
+    options?: BlockLiteral;
+    loc: SourceLocation;
+}
+export interface Enum {
+    kind: 'Enum';
+    name: string;
+    values: string[];
+    loc: SourceLocation;
+}
+export interface Model {
+    kind: 'Model';
+    name: string;
+    fields: Field[];
+    attributes: Attribute[];
+    directives: Directive[];
+    loc: SourceLocation;
+}
+export interface Field {
+    kind: 'Field';
+    name: string;
+    type: TypeExpr;
+    attributes: Attribute[];
+    loc: SourceLocation;
+}
+export interface TypeExpr {
+    kind: 'TypeExpr';
+    name: string;
+    args?: Value[];
+    optional?: boolean;
+    array?: boolean;
+    loc: SourceLocation;
+}
+export interface Attribute {
+    kind: 'Attribute';
+    name: string;
+    args?: AttributeArgs;
+    loc: SourceLocation;
+}
+export type AttributeArgs = KeyValueArgs | ExpressionArgs;
+export interface KeyValueArgs {
+    kind: 'KeyValueArgs';
+    pairs: KeyValuePair[];
+}
+export interface ExpressionArgs {
+    kind: 'ExpressionArgs';
+    expressions: Value[];
+}
+export interface Directive {
+    kind: 'Directive';
+    name: string;
+    args?: AttributeArgs;
+    loc: SourceLocation;
+}
+export interface KeyValuePair {
+    key: string;
+    value: Value;
+    loc?: SourceLocation;
+}
+export type Value = StringLiteral | TripleStringLiteral | NumberLiteral | BooleanLiteral | Identifier | ArrayLiteral | BlockLiteral | CallExpression;
+export interface StringLiteral {
+    kind: 'StringLiteral';
+    value: string;
+}
+export interface TripleStringLiteral {
+    kind: 'TripleStringLiteral';
+    value: string;
+}
+export interface NumberLiteral {
+    kind: 'NumberLiteral';
+    value: number;
+}
+export interface BooleanLiteral {
+    kind: 'BooleanLiteral';
+    value: boolean;
+}
+export interface Identifier {
+    kind: 'Identifier';
+    name: string;
+}
+export interface ArrayLiteral {
+    kind: 'ArrayLiteral';
+    elements: Value[];
+}
+export interface BlockLiteral {
+    kind: 'BlockLiteral';
+    pairs: KeyValuePair[];
+}
+export interface CallExpression {
+    kind: 'CallExpression';
+    callee: string;
+    args: Value[];
+}

package/dist/schema-dsl/ast.js

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

package/dist/schema-dsl/cli.d.ts

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

package/dist/schema-dsl/cli.js

@@ -0,0 +1,25 @@
+import { readFileSync } from 'node:fs';
+import { inspect, parse, tokenize } from './index.js';
+const args = process.argv.slice(2);
+const showTokens = args.includes('--tokens');
+const filePath = args.find((arg) => !arg.startsWith('--'));
+if (!filePath) {
+    console.error('Usage: tsx src/schema-dsl/cli.ts [--tokens] <file.schema>');
+    process.exit(1);
+}
+const source = readFileSync(filePath, 'utf8');
+try {
+    if (showTokens) {
+        const tokens = tokenize(source);
+        for (const token of tokens) {
+            console.log(`${token.line}:${token.col}\t${token.type}\t${JSON.stringify(token.value)}`);
+        }
+        process.exit(0);
+    }
+    const schema = parse(source);
+    console.log(inspect(schema));
+}
+catch (error) {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+}

package/dist/schema-dsl/index.d.ts

@@ -0,0 +1,8 @@
+import type { Schema } from './ast.js';
+export { Lexer, LexError } from './lexer.js';
+export { Parser, ParseError } from './parser.js';
+export { inspect } from './inspect.js';
+export * from './ast.js';
+export * from './tokens.js';
+export declare function parse(source: string): Schema;
+export declare function tokenize(source: string): import("./tokens.js").Token[];

package/dist/schema-dsl/index.js

@@ -0,0 +1,16 @@
+import { Lexer } from './lexer.js';
+import { Parser } from './parser.js';
+export { Lexer, LexError } from './lexer.js';
+export { Parser, ParseError } from './parser.js';
+export { inspect } from './inspect.js';
+export * from './ast.js';
+export * from './tokens.js';
+export function parse(source) {
+    const lexer = new Lexer(source);
+    const tokens = lexer.tokenizeAll();
+    const parser = new Parser(tokens);
+    return parser.parseSchema();
+}
+export function tokenize(source) {
+    return new Lexer(source).tokenizeAll();
+}

package/dist/schema-dsl/inspect.d.ts

@@ -0,0 +1 @@
+export declare function inspect(node: unknown): string;

package/dist/schema-dsl/inspect.js

@@ -0,0 +1,9 @@
+export function inspect(node) {
+    return JSON.stringify(node, replacer, 2);
+}
+function replacer(_key, value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return value;
+}

package/dist/schema-dsl/lexer.d.ts

@@ -0,0 +1,31 @@
+import { Token } from './tokens.js';
+export declare class LexError extends Error {
+    readonly line: number;
+    readonly col: number;
+    constructor(message: string, line: number, col: number);
+}
+export declare class Lexer {
+    private readonly source;
+    private pos;
+    private line;
+    private col;
+    private cached;
+    constructor(source: string);
+    peek(): Token;
+    nextToken(): Token;
+    tokenizeAll(): Token[];
+    private scanToken;
+    private scanString;
+    private scanTripleString;
+    private scanNumber;
+    private scanIdentifier;
+    private skipWhitespaceAndComments;
+    private makeToken;
+    private isAtEnd;
+    private peekChar;
+    private advance;
+    private match;
+    private isDigit;
+    private isIdentStart;
+    private isIdentPart;
+}

package/dist/schema-dsl/lexer.js

@@ -0,0 +1,216 @@
+import { keywordTokenType, TokenType } from './tokens.js';
+export class LexError extends Error {
+    line;
+    col;
+    constructor(message, line, col) {
+        super(`${message} at line ${line}, col ${col}`);
+        this.name = 'LexError';
+        this.line = line;
+        this.col = col;
+    }
+}
+export class Lexer {
+    source;
+    pos = 0;
+    line = 1;
+    col = 1;
+    cached = null;
+    constructor(source) {
+        this.source = source;
+    }
+    peek() {
+        if (!this.cached) {
+            this.cached = this.scanToken();
+        }
+        return this.cached;
+    }
+    nextToken() {
+        const token = this.peek();
+        this.cached = null;
+        return token;
+    }
+    tokenizeAll() {
+        const tokens = [];
+        let token = this.nextToken();
+        while (token.type !== TokenType.EOF) {
+            tokens.push(token);
+            token = this.nextToken();
+        }
+        tokens.push(token);
+        return tokens;
+    }
+    scanToken() {
+        this.skipWhitespaceAndComments();
+        const startLine = this.line;
+        const startCol = this.col;
+        if (this.isAtEnd()) {
+            return this.makeToken(TokenType.EOF, '', startLine, startCol);
+        }
+        const char = this.advance();
+        switch (char) {
+            case '{':
+                return this.makeToken(TokenType.LBRACE, char, startLine, startCol);
+            case '}':
+                return this.makeToken(TokenType.RBRACE, char, startLine, startCol);
+            case '[':
+                return this.makeToken(TokenType.LBRACKET, char, startLine, startCol);
+            case ']':
+                return this.makeToken(TokenType.RBRACKET, char, startLine, startCol);
+            case '(':
+                return this.makeToken(TokenType.LPAREN, char, startLine, startCol);
+            case ')':
+                return this.makeToken(TokenType.RPAREN, char, startLine, startCol);
+            case ':':
+                return this.makeToken(TokenType.COLON, char, startLine, startCol);
+            case ',':
+                return this.makeToken(TokenType.COMMA, char, startLine, startCol);
+            case '?':
+                return this.makeToken(TokenType.QUESTION, char, startLine, startCol);
+            case '@':
+                if (this.match('@')) {
+                    return this.makeToken(TokenType.ATAT, '@@', startLine, startCol);
+                }
+                return this.makeToken(TokenType.AT, char, startLine, startCol);
+            case '"':
+                if (this.match('"') && this.match('"')) {
+                    return this.scanTripleString(startLine, startCol);
+                }
+                return this.scanString(startLine, startCol);
+            default:
+                if (this.isDigit(char)) {
+                    return this.scanNumber(startLine, startCol);
+                }
+                if (this.isIdentStart(char)) {
+                    return this.scanIdentifier(startLine, startCol);
+                }
+                throw new LexError(`Unexpected character '${char}'`, startLine, startCol);
+        }
+    }
+    scanString(startLine, startCol) {
+        let value = '';
+        while (!this.isAtEnd()) {
+            const char = this.advance();
+            if (char === '"') {
+                return this.makeToken(TokenType.STRING, value, startLine, startCol);
+            }
+            if (char === '\\') {
+                if (this.isAtEnd()) {
+                    throw new LexError('Unterminated string escape', startLine, startCol);
+                }
+                const escaped = this.advance();
+                switch (escaped) {
+                    case 'n':
+                        value += '\n';
+                        break;
+                    case 't':
+                        value += '\t';
+                        break;
+                    case 'r':
+                        value += '\r';
+                        break;
+                    case '"':
+                        value += '"';
+                        break;
+                    case '\\':
+                        value += '\\';
+                        break;
+                    default:
+                        value += escaped;
+                        break;
+                }
+                continue;
+            }
+            if (char === '\n') {
+                throw new LexError('Unterminated string', startLine, startCol);
+            }
+            value += char;
+        }
+        throw new LexError('Unterminated string', startLine, startCol);
+    }
+    scanTripleString(startLine, startCol) {
+        let value = '';
+        while (!this.isAtEnd()) {
+            if (this.match('"') && this.match('"') && this.match('"')) {
+                return this.makeToken(TokenType.TRIPLE_STRING, value, startLine, startCol);
+            }
+            value += this.advance();
+        }
+        throw new LexError('Unterminated triple-quoted string', startLine, startCol);
+    }
+    scanNumber(startLine, startCol) {
+        let value = this.source[this.pos - 1];
+        while (!this.isAtEnd() && this.isDigit(this.peekChar())) {
+            value += this.advance();
+        }
+        if (this.peekChar() === '.' && this.isDigit(this.peekChar(1))) {
+            value += this.advance();
+            while (!this.isAtEnd() && this.isDigit(this.peekChar())) {
+                value += this.advance();
+            }
+        }
+        return this.makeToken(TokenType.NUMBER, value, startLine, startCol);
+    }
+    scanIdentifier(startLine, startCol) {
+        let value = this.source[this.pos - 1];
+        while (!this.isAtEnd() && this.isIdentPart(this.peekChar())) {
+            value += this.advance();
+        }
+        const type = keywordTokenType(value);
+        return this.makeToken(type, value, startLine, startCol);
+    }
+    skipWhitespaceAndComments() {
+        while (!this.isAtEnd()) {
+            const char = this.peekChar();
+            if (char === ' ' || char === '\t' || char === '\r') {
+                this.advance();
+                continue;
+            }
+            if (char === '\n') {
+                this.advance();
+                this.line += 1;
+                this.col = 1;
+                continue;
+            }
+            if (char === '/' && this.peekChar(1) === '/') {
+                while (!this.isAtEnd() && this.peekChar() !== '\n') {
+                    this.advance();
+                }
+                continue;
+            }
+            break;
+        }
+    }
+    makeToken(type, value, line, col) {
+        return { type, value, line, col };
+    }
+    isAtEnd() {
+        return this.pos >= this.source.length;
+    }
+    peekChar(offset = 0) {
+        return this.source[this.pos + offset] ?? '\0';
+    }
+    advance() {
+        const char = this.source[this.pos];
+        this.pos += 1;
+        if (char !== '\n') {
+            this.col += 1;
+        }
+        return char;
+    }
+    match(expected) {
+        if (this.isAtEnd() || this.source[this.pos] !== expected) {
+            return false;
+        }
+        this.advance();
+        return true;
+    }
+    isDigit(char) {
+        return char >= '0' && char <= '9';
+    }
+    isIdentStart(char) {
+        return (char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z') || char === '_';
+    }
+    isIdentPart(char) {
+        return this.isIdentStart(char) || this.isDigit(char) || char === '-';
+    }
+}

package/dist/schema-dsl/parser.d.ts

@@ -0,0 +1,49 @@
+import type { Attribute, Field, Model, Schema } from './ast.js';
+import { Token } from './tokens.js';
+export declare class ParseError extends Error {
+    readonly line: number;
+    readonly col: number;
+    readonly expected: string;
+    readonly found: Token;
+    constructor(expected: string, found: Token);
+}
+export declare class Parser {
+    private readonly tokens;
+    private index;
+    constructor(tokens: Token[]);
+    parseSchema(): Schema;
+    parseModel(): Model;
+    parseField(): Field;
+    parseAttribute(): Attribute;
+    private parseExtensionsSection;
+    private parseExtension;
+    private parseEnumsSection;
+    private parseEnum;
+    private parseModelsSection;
+    private parseModelBody;
+    private parseTypeExpr;
+    private parseFieldAttributes;
+    private parseAttributeInternal;
+    private parseDirective;
+    private parseAttributeArgs;
+    private parseValue;
+    private parseIdentOrCall;
+    private parseArrayLiteral;
+    private parseBlockLiteral;
+    private parseKeyValueList;
+    private parseValueList;
+    private parseIdentList;
+    private isKeyValueListStart;
+    private isListEnd;
+    private consumeTrailingComma;
+    private loc;
+    private current;
+    private previous;
+    private advance;
+    private match;
+    private check;
+    private peekType;
+    private expect;
+    private isAtEnd;
+    private eofToken;
+}