@delma/fylo 2.0.1 → 2.1.1

package/dist/core/parser.js

@@ -0,0 +1,764 @@
+// Token types for SQL lexing
+var TokenType;
+(function (TokenType) {
+    TokenType["CREATE"] = "CREATE";
+    TokenType["DROP"] = "DROP";
+    TokenType["SELECT"] = "SELECT";
+    TokenType["FROM"] = "FROM";
+    TokenType["WHERE"] = "WHERE";
+    TokenType["INSERT"] = "INSERT";
+    TokenType["INTO"] = "INTO";
+    TokenType["VALUES"] = "VALUES";
+    TokenType["UPDATE"] = "UPDATE";
+    TokenType["SET"] = "SET";
+    TokenType["DELETE"] = "DELETE";
+    TokenType["JOIN"] = "JOIN";
+    TokenType["INNER"] = "INNER";
+    TokenType["LEFT"] = "LEFT";
+    TokenType["RIGHT"] = "RIGHT";
+    TokenType["OUTER"] = "OUTER";
+    TokenType["ON"] = "ON";
+    TokenType["GROUP"] = "GROUP";
+    TokenType["BY"] = "BY";
+    TokenType["ORDER"] = "ORDER";
+    TokenType["LIMIT"] = "LIMIT";
+    TokenType["AS"] = "AS";
+    TokenType["AND"] = "AND";
+    TokenType["OR"] = "OR";
+    TokenType["EQUALS"] = "=";
+    TokenType["NOT_EQUALS"] = "!=";
+    TokenType["GREATER_THAN"] = ">";
+    TokenType["LESS_THAN"] = "<";
+    TokenType["GREATER_EQUAL"] = ">=";
+    TokenType["LESS_EQUAL"] = "<=";
+    TokenType["LIKE"] = "LIKE";
+    TokenType["IDENTIFIER"] = "IDENTIFIER";
+    TokenType["STRING"] = "STRING";
+    TokenType["NUMBER"] = "NUMBER";
+    TokenType["BOOLEAN"] = "BOOLEAN";
+    TokenType["NULL"] = "NULL";
+    TokenType["COMMA"] = ",";
+    TokenType["SEMICOLON"] = ";";
+    TokenType["LPAREN"] = "(";
+    TokenType["RPAREN"] = ")";
+    TokenType["ASTERISK"] = "*";
+    TokenType["EOF"] = "EOF";
+})(TokenType || (TokenType = {}));
+// SQL Lexer
+class SQLLexer {
+    input;
+    position = 0;
+    current = null;
+    constructor(input) {
+        this.input = input.trim();
+        this.current = this.input[0] || null;
+    }
+    advance() {
+        this.position++;
+        this.current = this.position < this.input.length ? this.input[this.position] : null;
+    }
+    skipWhitespace() {
+        while (this.current && /\s/.test(this.current)) {
+            this.advance();
+        }
+    }
+    readString() {
+        let result = '';
+        const quote = this.current;
+        this.advance(); // Skip opening quote
+        while (this.current && this.current !== quote) {
+            result += this.current;
+            this.advance();
+        }
+        if (this.current === quote) {
+            this.advance(); // Skip closing quote
+        }
+        return result;
+    }
+    readNumber() {
+        let result = '';
+        while (this.current && /[\d.]/.test(this.current)) {
+            result += this.current;
+            this.advance();
+        }
+        return result;
+    }
+    readIdentifier() {
+        let result = '';
+        while (this.current && /[a-zA-Z0-9_\-]/.test(this.current)) {
+            result += this.current;
+            this.advance();
+        }
+        return result;
+    }
+    getKeywordType(word) {
+        const keywords = {
+            SELECT: TokenType.SELECT,
+            FROM: TokenType.FROM,
+            WHERE: TokenType.WHERE,
+            INSERT: TokenType.INSERT,
+            INTO: TokenType.INTO,
+            VALUES: TokenType.VALUES,
+            UPDATE: TokenType.UPDATE,
+            SET: TokenType.SET,
+            DELETE: TokenType.DELETE,
+            JOIN: TokenType.JOIN,
+            INNER: TokenType.INNER,
+            LEFT: TokenType.LEFT,
+            RIGHT: TokenType.RIGHT,
+            OUTER: TokenType.OUTER,
+            ON: TokenType.ON,
+            GROUP: TokenType.GROUP,
+            BY: TokenType.BY,
+            ORDER: TokenType.ORDER,
+            LIMIT: TokenType.LIMIT,
+            AS: TokenType.AS,
+            AND: TokenType.AND,
+            OR: TokenType.OR,
+            LIKE: TokenType.LIKE,
+            TRUE: TokenType.BOOLEAN,
+            FALSE: TokenType.BOOLEAN,
+            NULL: TokenType.NULL
+        };
+        return keywords[word.toUpperCase()] || TokenType.IDENTIFIER;
+    }
+    tokenize() {
+        const tokens = [];
+        while (this.current) {
+            this.skipWhitespace();
+            if (!this.current)
+                break;
+            const position = this.position;
+            // String literals
+            if (this.current === "'" || this.current === '"') {
+                const value = this.readString();
+                tokens.push({ type: TokenType.STRING, value, position });
+                continue;
+            }
+            // Numbers
+            if (/\d/.test(this.current)) {
+                const value = this.readNumber();
+                tokens.push({ type: TokenType.NUMBER, value, position });
+                continue;
+            }
+            // Identifiers and keywords
+            if (/[a-zA-Z_]/.test(this.current)) {
+                let value = this.readIdentifier();
+                // Support dot notation for nested fields (e.g. address.city → address/city)
+                while (this.current === '.' &&
+                    this.position + 1 < this.input.length &&
+                    /[a-zA-Z_]/.test(this.input[this.position + 1])) {
+                    this.advance(); // skip '.'
+                    value += '/' + this.readIdentifier();
+                }
+                const type = this.getKeywordType(value);
+                tokens.push({ type, value, position });
+                continue;
+            }
+            // Operators and punctuation
+            switch (this.current) {
+                case '=':
+                    tokens.push({ type: TokenType.EQUALS, value: '=', position });
+                    this.advance();
+                    break;
+                case '!':
+                    if (this.input[this.position + 1] === '=') {
+                        tokens.push({ type: TokenType.NOT_EQUALS, value: '!=', position });
+                        this.advance();
+                        this.advance();
+                    }
+                    else {
+                        this.advance();
+                    }
+                    break;
+                case '>':
+                    if (this.input[this.position + 1] === '=') {
+                        tokens.push({ type: TokenType.GREATER_EQUAL, value: '>=', position });
+                        this.advance();
+                        this.advance();
+                    }
+                    else {
+                        tokens.push({ type: TokenType.GREATER_THAN, value: '>', position });
+                        this.advance();
+                    }
+                    break;
+                case '<':
+                    if (this.input[this.position + 1] === '=') {
+                        tokens.push({ type: TokenType.LESS_EQUAL, value: '<=', position });
+                        this.advance();
+                        this.advance();
+                    }
+                    else {
+                        tokens.push({ type: TokenType.LESS_THAN, value: '<', position });
+                        this.advance();
+                    }
+                    break;
+                case ',':
+                    tokens.push({ type: TokenType.COMMA, value: ',', position });
+                    this.advance();
+                    break;
+                case ';':
+                    tokens.push({ type: TokenType.SEMICOLON, value: ';', position });
+                    this.advance();
+                    break;
+                case '(':
+                    tokens.push({ type: TokenType.LPAREN, value: '(', position });
+                    this.advance();
+                    break;
+                case ')':
+                    tokens.push({ type: TokenType.RPAREN, value: ')', position });
+                    this.advance();
+                    break;
+                case '*':
+                    tokens.push({ type: TokenType.ASTERISK, value: '*', position });
+                    this.advance();
+                    break;
+                default:
+                    this.advance();
+                    break;
+            }
+        }
+        tokens.push({ type: TokenType.EOF, value: '', position: this.position });
+        return tokens;
+    }
+}
+// SQL Parser
+class SQLParser {
+    tokens;
+    position = 0;
+    current;
+    constructor(tokens) {
+        this.tokens = tokens;
+        this.current = tokens[0];
+    }
+    advance() {
+        this.position++;
+        this.current = this.tokens[this.position] || {
+            type: TokenType.EOF,
+            value: '',
+            position: -1
+        };
+    }
+    expect(type) {
+        if (this.current.type !== type) {
+            throw new Error('Invalid SQL syntax');
+        }
+        const token = this.current;
+        this.advance();
+        return token;
+    }
+    match(...types) {
+        return types.includes(this.current.type);
+    }
+    parseValue() {
+        if (this.current.type === TokenType.STRING) {
+            const value = this.current.value;
+            this.advance();
+            return value;
+        }
+        if (this.current.type === TokenType.NUMBER) {
+            const value = parseFloat(this.current.value);
+            this.advance();
+            return value;
+        }
+        if (this.current.type === TokenType.BOOLEAN) {
+            const value = this.current.value.toLowerCase() === 'true';
+            this.advance();
+            return value;
+        }
+        if (this.current.type === TokenType.NULL) {
+            this.advance();
+            return null;
+        }
+        throw new Error(`Unexpected value type: ${this.current.type}`);
+    }
+    parseOperator() {
+        const operatorMap = {
+            [TokenType.EQUALS]: '$eq',
+            [TokenType.NOT_EQUALS]: '$ne',
+            [TokenType.GREATER_THAN]: '$gt',
+            [TokenType.LESS_THAN]: '$lt',
+            [TokenType.GREATER_EQUAL]: '$gte',
+            [TokenType.LESS_EQUAL]: '$lte',
+            [TokenType.LIKE]: '$like'
+        };
+        if (operatorMap[this.current.type]) {
+            const op = operatorMap[this.current.type];
+            this.advance();
+            return op ?? '';
+        }
+        throw new Error(`Unknown operator: ${this.current.type}`);
+    }
+    parseCondition() {
+        const column = this.expect(TokenType.IDENTIFIER).value;
+        const operator = this.parseOperator();
+        const value = this.parseValue();
+        return { column, operator, value };
+    }
+    parseWhereClause() {
+        this.expect(TokenType.WHERE);
+        const conditions = [];
+        do {
+            const condition = this.parseCondition();
+            const op = {
+                [condition.column]: {
+                    [condition.operator]: condition.value
+                }
+            };
+            conditions.push(op);
+            if (this.match(TokenType.AND, TokenType.OR)) {
+                this.advance();
+            }
+            else {
+                break;
+            }
+        } while (true);
+        return conditions;
+    }
+    parseSelectClause() {
+        this.expect(TokenType.SELECT);
+        const columns = [];
+        if (this.current.type === TokenType.ASTERISK) {
+            this.advance();
+            return ['*'];
+        }
+        do {
+            columns.push(this.expect(TokenType.IDENTIFIER).value);
+            if (this.current.type === TokenType.COMMA) {
+                this.advance();
+            }
+            else {
+                break;
+            }
+        } while (true);
+        return columns;
+    }
+    parseSelect() {
+        const select = this.parseSelectClause();
+        this.expect(TokenType.FROM);
+        const collection = this.expect(TokenType.IDENTIFIER).value;
+        // Check if this is a JOIN query
+        if (this.match(TokenType.JOIN, TokenType.INNER, TokenType.LEFT, TokenType.RIGHT, TokenType.OUTER)) {
+            return this.parseJoinQuery(select, collection);
+        }
+        const query = {
+            $collection: collection,
+            $select: select.includes('*') ? undefined : select,
+            $onlyIds: select.includes('_id')
+        };
+        if (this.match(TokenType.WHERE)) {
+            query.$ops = this.parseWhereClause();
+        }
+        if (this.match(TokenType.GROUP)) {
+            this.advance();
+            this.expect(TokenType.BY);
+            query.$groupby = this.expect(TokenType.IDENTIFIER).value;
+        }
+        if (this.match(TokenType.LIMIT)) {
+            this.advance();
+            query.$limit = parseInt(this.expect(TokenType.NUMBER).value);
+        }
+        return query;
+    }
+    parseJoinQuery(select, leftCollection) {
+        // Parse join type
+        let joinMode = 'inner';
+        if (this.match(TokenType.INNER)) {
+            this.advance();
+            joinMode = 'inner';
+        }
+        else if (this.match(TokenType.LEFT)) {
+            this.advance();
+            joinMode = 'left';
+        }
+        else if (this.match(TokenType.RIGHT)) {
+            this.advance();
+            joinMode = 'right';
+        }
+        else if (this.match(TokenType.OUTER)) {
+            this.advance();
+            joinMode = 'outer';
+        }
+        this.expect(TokenType.JOIN);
+        const rightCollection = this.expect(TokenType.IDENTIFIER).value;
+        this.expect(TokenType.ON);
+        // Parse join conditions
+        const onConditions = this.parseJoinConditions();
+        const joinQuery = {
+            $leftCollection: leftCollection,
+            $rightCollection: rightCollection,
+            $mode: joinMode,
+            $on: onConditions,
+            $select: select.includes('*') ? undefined : select
+        };
+        // Parse additional clauses
+        if (this.match(TokenType.WHERE)) {
+            // For joins, WHERE conditions would need to be handled differently
+            // Skip for now as it's complex with joined tables
+            this.parseWhereClause();
+        }
+        if (this.match(TokenType.GROUP)) {
+            this.advance();
+            this.expect(TokenType.BY);
+            joinQuery.$groupby = this.expect(TokenType.IDENTIFIER).value;
+        }
+        if (this.match(TokenType.LIMIT)) {
+            this.advance();
+            joinQuery.$limit = parseInt(this.expect(TokenType.NUMBER).value);
+        }
+        return joinQuery;
+    }
+    parseJoinConditions() {
+        const conditions = {};
+        do {
+            // Parse: table1.column = table2.column
+            const leftSide = this.parseJoinColumn();
+            const operator = this.parseJoinOperator();
+            const rightSide = this.parseJoinColumn();
+            // Build the join condition
+            const leftColumn = leftSide.column;
+            const rightColumn = rightSide.column;
+            if (!conditions[leftColumn]) {
+                conditions[leftColumn] = {};
+            }
+            ;
+            conditions[leftColumn][operator] = rightColumn;
+            if (this.match(TokenType.AND)) {
+                this.advance();
+            }
+            else {
+                break;
+            }
+        } while (true);
+        return conditions;
+    }
+    parseJoinColumn() {
+        const identifier = this.expect(TokenType.IDENTIFIER).value;
+        // Check if it's table.column format
+        if (this.current.type === TokenType.IDENTIFIER) {
+            // This might be a qualified column name, but we'll treat it as simple for now
+            return { column: identifier };
+        }
+        return { column: identifier };
+    }
+    parseJoinOperator() {
+        const operatorMap = {
+            [TokenType.EQUALS]: '$eq',
+            [TokenType.NOT_EQUALS]: '$ne',
+            [TokenType.GREATER_THAN]: '$gt',
+            [TokenType.LESS_THAN]: '$lt',
+            [TokenType.GREATER_EQUAL]: '$gte',
+            [TokenType.LESS_EQUAL]: '$lte'
+        };
+        if (operatorMap[this.current.type]) {
+            const op = operatorMap[this.current.type];
+            this.advance();
+            return op;
+        }
+        throw new Error(`Unknown join operator: ${this.current.type}`);
+    }
+    parseInsert() {
+        this.expect(TokenType.INSERT);
+        this.expect(TokenType.INTO);
+        const collection = this.expect(TokenType.IDENTIFIER).value;
+        // Parse column list
+        let columns = [];
+        if (this.current.type === TokenType.LPAREN) {
+            this.advance();
+            do {
+                columns.push(this.expect(TokenType.IDENTIFIER).value);
+                // @ts-expect-error - current may be undefined at end of input
+                if (this.current.type === TokenType.COMMA) {
+                    this.advance();
+                }
+                else {
+                    break;
+                }
+            } while (true);
+            this.expect(TokenType.RPAREN);
+        }
+        this.expect(TokenType.VALUES);
+        this.expect(TokenType.LPAREN);
+        const values = {};
+        let valueIndex = 0;
+        do {
+            const value = this.parseValue();
+            const column = columns[valueIndex] || `col${valueIndex}`;
+            values[column] = value;
+            valueIndex++;
+            if (this.current.type === TokenType.COMMA) {
+                this.advance();
+            }
+            else {
+                break;
+            }
+        } while (true);
+        this.expect(TokenType.RPAREN);
+        return {
+            $collection: collection,
+            $values: values
+        };
+    }
+    parseUpdate() {
+        this.expect(TokenType.UPDATE);
+        const collection = this.expect(TokenType.IDENTIFIER).value;
+        this.expect(TokenType.SET);
+        const set = {};
+        do {
+            const column = this.expect(TokenType.IDENTIFIER).value;
+            this.expect(TokenType.EQUALS);
+            const value = this.parseValue();
+            set[column] = value;
+            if (this.current.type === TokenType.COMMA) {
+                this.advance();
+            }
+            else {
+                break;
+            }
+        } while (true);
+        const update = {
+            $collection: collection,
+            $set: set
+        };
+        if (this.match(TokenType.WHERE)) {
+            const whereQuery = {
+                $collection: collection,
+                $ops: this.parseWhereClause()
+            };
+            update.$where = whereQuery;
+        }
+        return update;
+    }
+    parseDelete() {
+        this.expect(TokenType.DELETE);
+        this.expect(TokenType.FROM);
+        const collection = this.expect(TokenType.IDENTIFIER).value;
+        const deleteQuery = {
+            $collection: collection
+        };
+        if (this.match(TokenType.WHERE)) {
+            deleteQuery.$ops = this.parseWhereClause();
+        }
+        return deleteQuery;
+    }
+}
+// Main SQL to AST converter
+export class Parser {
+    static parse(sql) {
+        const lexer = new SQLLexer(sql);
+        const tokens = lexer.tokenize();
+        const parser = new SQLParser(tokens);
+        // Determine query type based on first token
+        const firstToken = tokens[0];
+        switch (firstToken.value) {
+            case TokenType.CREATE:
+                return { $collection: tokens[2].value };
+            case TokenType.SELECT:
+                return parser.parseSelect();
+            case TokenType.INSERT:
+                return parser.parseInsert();
+            case TokenType.UPDATE:
+                return parser.parseUpdate();
+            case TokenType.DELETE:
+                return parser.parseDelete();
+            case TokenType.DROP:
+                return { $collection: tokens[2].value };
+            default:
+                throw new Error(`Unsupported SQL statement type: ${firstToken.value}`);
+        }
+    }
+    // Bun SQL inspired query builder methods
+    static query(collection) {
+        return new QueryBuilder(collection);
+    }
+    // Join query builder
+    static join(leftCollection, rightCollection) {
+        return new JoinBuilder(leftCollection, rightCollection);
+    }
+}
+// Bun SQL inspired query builder
+export class QueryBuilder {
+    collection;
+    queryAst = {};
+    constructor(collection) {
+        this.collection = collection;
+        this.queryAst.$collection = collection;
+    }
+    select(...columns) {
+        this.queryAst.$select = columns;
+        return this;
+    }
+    where(conditions) {
+        this.queryAst.$ops = conditions;
+        return this;
+    }
+    limit(count) {
+        this.queryAst.$limit = count;
+        return this;
+    }
+    groupBy(column) {
+        this.queryAst.$groupby = column;
+        return this;
+    }
+    onlyIds() {
+        this.queryAst.$onlyIds = true;
+        return this;
+    }
+    build() {
+        return this.queryAst;
+    }
+    // Convert to SQL string (reverse operation)
+    toSQL() {
+        let sql = 'SELECT ';
+        if (this.queryAst.$select) {
+            sql += this.queryAst.$select.join(', ');
+        }
+        else {
+            sql += '*';
+        }
+        sql += ` FROM ${this.collection}`;
+        if (this.queryAst.$ops && this.queryAst.$ops.length > 0) {
+            sql += ' WHERE ';
+            const conditions = this.queryAst.$ops
+                .map((op) => {
+                const entries = Object.entries(op);
+                return entries
+                    .map(([column, operand]) => {
+                    const opEntries = Object.entries(operand);
+                    return opEntries
+                        .map(([operator, value]) => {
+                        const sqlOp = this.operatorToSQL(operator);
+                        const sqlValue = typeof value === 'string' ? `'${value}'` : value;
+                        return `${column} ${sqlOp} ${sqlValue}`;
+                    })
+                        .join(' AND ');
+                })
+                    .join(' AND ');
+            })
+                .join(' AND ');
+            sql += conditions;
+        }
+        if (this.queryAst.$groupby) {
+            sql += ` GROUP BY ${String(this.queryAst.$groupby)}`;
+        }
+        if (this.queryAst.$limit) {
+            sql += ` LIMIT ${this.queryAst.$limit}`;
+        }
+        return sql;
+    }
+    operatorToSQL(operator) {
+        const opMap = {
+            $eq: '=',
+            $ne: '!=',
+            $gt: '>',
+            $lt: '<',
+            $gte: '>=',
+            $lte: '<=',
+            $like: 'LIKE'
+        };
+        return opMap[operator] || '=';
+    }
+}
+// Join query builder
+export class JoinBuilder {
+    joinAst = {};
+    constructor(leftCollection, rightCollection) {
+        this.joinAst.$leftCollection = leftCollection;
+        this.joinAst.$rightCollection = rightCollection;
+        this.joinAst.$mode = 'inner'; // default
+    }
+    select(...columns) {
+        this.joinAst.$select = columns;
+        return this;
+    }
+    innerJoin() {
+        this.joinAst.$mode = 'inner';
+        return this;
+    }
+    leftJoin() {
+        this.joinAst.$mode = 'left';
+        return this;
+    }
+    rightJoin() {
+        this.joinAst.$mode = 'right';
+        return this;
+    }
+    outerJoin() {
+        this.joinAst.$mode = 'outer';
+        return this;
+    }
+    on(conditions) {
+        this.joinAst.$on = conditions;
+        return this;
+    }
+    limit(count) {
+        this.joinAst.$limit = count;
+        return this;
+    }
+    groupBy(column) {
+        this.joinAst.$groupby = column;
+        return this;
+    }
+    onlyIds() {
+        this.joinAst.$onlyIds = true;
+        return this;
+    }
+    rename(mapping) {
+        this.joinAst.$rename = mapping;
+        return this;
+    }
+    build() {
+        if (!this.joinAst.$on) {
+            throw new Error('JOIN query must have ON conditions');
+        }
+        return this.joinAst;
+    }
+    // Convert to SQL string
+    toSQL() {
+        let sql = 'SELECT ';
+        if (this.joinAst.$select) {
+            sql += this.joinAst.$select.join(', ');
+        }
+        else {
+            sql += '*';
+        }
+        sql += ` FROM ${this.joinAst.$leftCollection}`;
+        // Add join type
+        const joinType = this.joinAst.$mode?.toUpperCase() || 'INNER';
+        sql += ` ${joinType} JOIN ${this.joinAst.$rightCollection}`;
+        // Add ON conditions
+        if (this.joinAst.$on) {
+            sql += ' ON ';
+            const conditions = Object.entries(this.joinAst.$on)
+                .map(([leftCol, operand]) => {
+                return Object.entries(operand)
+                    .map(([operator, rightCol]) => {
+                    const sqlOp = this.operatorToSQL(operator);
+                    return `${this.joinAst.$leftCollection}.${leftCol} ${sqlOp} ${this.joinAst.$rightCollection}.${String(rightCol)}`;
+                })
+                    .join(' AND ');
+            })
+                .join(' AND ');
+            sql += conditions;
+        }
+        if (this.joinAst.$groupby) {
+            sql += ` GROUP BY ${String(this.joinAst.$groupby)}`;
+        }
+        if (this.joinAst.$limit) {
+            sql += ` LIMIT ${this.joinAst.$limit}`;
+        }
+        return sql;
+    }
+    operatorToSQL(operator) {
+        const opMap = {
+            $eq: '=',
+            $ne: '!=',
+            $gt: '>',
+            $lt: '<',
+            $gte: '>=',
+            $lte: '<='
+        };
+        return opMap[operator] || '=';
+    }
+}
+//# sourceMappingURL=parser.js.map