@delma/fylo 1.1.2 → 2.0.1

package/src/core/parser.ts

@@ -1,5 +1,3 @@
-
-
 // Token types for SQL lexing
 enum TokenType {
     CREATE = 'CREATE',
@@ -78,16 +76,16 @@ class SQLLexer {
         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
     }
 
@@ -111,32 +109,32 @@ class SQLLexer {
 
     private getKeywordType(word: string): TokenType {
         const keywords: Record<string, TokenType> = {
-            '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
+            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
     }
@@ -146,7 +144,7 @@ class SQLLexer {
 
         while (this.current) {
             this.skipWhitespace()
-            
+
             if (!this.current) break
 
             const position = this.position
@@ -169,7 +167,11 @@ class SQLLexer {
             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])) {
+                while (
+                    this.current === '.' &&
+                    this.position + 1 < this.input.length &&
+                    /[a-zA-Z_]/.test(this.input[this.position + 1])
+                ) {
                     this.advance() // skip '.'
                     value += '/' + this.readIdentifier()
                 }
@@ -257,7 +259,11 @@ class SQLParser {
 
     private advance(): void {
         this.position++
-        this.current = this.tokens[this.position] || { type: TokenType.EOF, value: '', position: -1 }
+        this.current = this.tokens[this.position] || {
+            type: TokenType.EOF,
+            value: '',
+            position: -1
+        }
     }
 
     private expect(type: TokenType): Token {
@@ -312,7 +318,7 @@ class SQLParser {
             this.advance()
             return op ?? ''
         }
-        
+
         throw new Error(`Unknown operator: ${this.current.type}`)
     }
 
@@ -320,14 +326,14 @@ class SQLParser {
         const column = this.expect(TokenType.IDENTIFIER).value
         const operator = this.parseOperator()
         const value = this.parseValue()
-        
+
         return { column, operator, value }
     }
 
     private parseWhereClause<T>(): Array<_op<T>> {
         this.expect(TokenType.WHERE)
         const conditions: Array<_op<T>> = []
-        
+
         do {
             const condition = this.parseCondition()
             const op: _op<T> = {
@@ -336,26 +342,26 @@ class SQLParser {
                 } as _operand
             } as _op<T>
             conditions.push(op)
-            
+
             if (this.match(TokenType.AND, TokenType.OR)) {
                 this.advance()
             } else {
                 break
             }
         } while (true)
-        
+
         return conditions
     }
 
     private parseSelectClause(): string[] {
         this.expect(TokenType.SELECT)
         const columns: string[] = []
-        
+
         if (this.current.type === TokenType.ASTERISK) {
             this.advance()
             return ['*']
         }
-        
+
         do {
             columns.push(this.expect(TokenType.IDENTIFIER).value)
             if (this.current.type === TokenType.COMMA) {
@@ -364,7 +370,7 @@ class SQLParser {
                 break
             }
         } while (true)
-        
+
         return columns
     }
 
@@ -372,131 +378,139 @@ class SQLParser {
         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)) {
+        if (
+            this.match(
+                TokenType.JOIN,
+                TokenType.INNER,
+                TokenType.LEFT,
+                TokenType.RIGHT,
+                TokenType.OUTER
+            )
+        ) {
             return this.parseJoinQuery<T, any>(select, collection)
         }
-        
+
         const query: _storeQuery<T> = {
             $collection: collection,
-            $select: select.includes('*') ? undefined : select as Array<keyof T>,
+            $select: select.includes('*') ? undefined : (select as Array<keyof T>),
             $onlyIds: select.includes('_id')
         }
-        
+
         if (this.match(TokenType.WHERE)) {
             query.$ops = this.parseWhereClause<T>()
         }
-        
+
         if (this.match(TokenType.GROUP)) {
             this.advance()
             this.expect(TokenType.BY)
             query.$groupby = this.expect(TokenType.IDENTIFIER).value as keyof T
         }
-        
+
         if (this.match(TokenType.LIMIT)) {
             this.advance()
             query.$limit = parseInt(this.expect(TokenType.NUMBER).value)
         }
-        
+
         return query
     }
 
     parseJoinQuery<T extends Record<string, any>, U extends Record<string, any>>(
-        select: string[], 
+        select: string[],
         leftCollection: string
     ): _join<T, U> {
         // Parse join type
-        let joinMode: "inner" | "left" | "right" | "outer" = "inner"
-        
+        let joinMode: 'inner' | 'left' | 'right' | 'outer' = 'inner'
+
         if (this.match(TokenType.INNER)) {
             this.advance()
-            joinMode = "inner"
+            joinMode = 'inner'
         } else if (this.match(TokenType.LEFT)) {
             this.advance()
-            joinMode = "left"
+            joinMode = 'left'
         } else if (this.match(TokenType.RIGHT)) {
             this.advance()
-            joinMode = "right"
+            joinMode = 'right'
         } else if (this.match(TokenType.OUTER)) {
             this.advance()
-            joinMode = "outer"
+            joinMode = 'outer'
         }
-        
+
         this.expect(TokenType.JOIN)
         const rightCollection = this.expect(TokenType.IDENTIFIER).value
         this.expect(TokenType.ON)
-        
+
         // Parse join conditions
         const onConditions = this.parseJoinConditions<T, U>()
-        
+
         const joinQuery: _join<T, U> = {
             $leftCollection: leftCollection,
             $rightCollection: rightCollection,
             $mode: joinMode,
             $on: onConditions,
-            $select: select.includes('*') ? undefined : select as Array<keyof T | keyof U>
+            $select: select.includes('*') ? undefined : (select as Array<keyof T | keyof U>)
         }
-        
+
         // 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<T>()
         }
-        
+
         if (this.match(TokenType.GROUP)) {
             this.advance()
             this.expect(TokenType.BY)
             joinQuery.$groupby = this.expect(TokenType.IDENTIFIER).value as keyof T | keyof U
         }
-        
+
         if (this.match(TokenType.LIMIT)) {
             this.advance()
             joinQuery.$limit = parseInt(this.expect(TokenType.NUMBER).value)
         }
-        
+
         return joinQuery
     }
 
     private parseJoinConditions<T, U>(): _on<T, U> {
         const conditions: _on<T, U> = {}
-        
+
         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 as keyof T
             const rightColumn = rightSide.column as keyof U
-            
+
             if (!conditions[leftColumn]) {
                 conditions[leftColumn] = {} as _joinOperand<U>
             }
-            
-            (conditions[leftColumn] as any)[operator] = rightColumn
-            
+
+            ;(conditions[leftColumn] as any)[operator] = rightColumn
+
             if (this.match(TokenType.AND)) {
                 this.advance()
             } else {
                 break
             }
         } while (true)
-        
+
         return conditions
     }
 
-    private parseJoinColumn(): { table?: string, column: string } {
+    private parseJoinColumn(): { table?: string; column: string } {
         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 }
     }
 
@@ -515,7 +529,7 @@ class SQLParser {
             this.advance()
             return op
         }
-        
+
         throw new Error(`Unknown join operator: ${this.current.type}`)
     }
 
@@ -523,7 +537,7 @@ class SQLParser {
         this.expect(TokenType.INSERT)
         this.expect(TokenType.INTO)
         const collection = this.expect(TokenType.IDENTIFIER).value
-        
+
         // Parse column list
         let columns: string[] = []
         if (this.current.type === TokenType.LPAREN) {
@@ -539,28 +553,28 @@ class SQLParser {
             } while (true)
             this.expect(TokenType.RPAREN)
         }
-        
+
         this.expect(TokenType.VALUES)
         this.expect(TokenType.LPAREN)
-        
+
         const values: any = {}
         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 as { [K in keyof T]: T[K] }
@@ -571,27 +585,27 @@ class SQLParser {
         this.expect(TokenType.UPDATE)
         const collection = this.expect(TokenType.IDENTIFIER).value
         this.expect(TokenType.SET)
-        
+
         const set: any = {}
-        
+
         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: _storeUpdate<T> = {
             $collection: collection,
             $set: set as { [K in keyof Partial<T>]: T[K] }
         }
-        
+
         if (this.match(TokenType.WHERE)) {
             const whereQuery: _storeQuery<T> = {
                 $collection: collection,
@@ -599,7 +613,7 @@ class SQLParser {
             }
             update.$where = whereQuery
         }
-        
+
         return update
     }
 
@@ -607,31 +621,31 @@ class SQLParser {
         this.expect(TokenType.DELETE)
         this.expect(TokenType.FROM)
         const collection = this.expect(TokenType.IDENTIFIER).value
-        
+
         const deleteQuery: _storeDelete<T> = {
             $collection: collection
         }
-        
+
         if (this.match(TokenType.WHERE)) {
             deleteQuery.$ops = this.parseWhereClause<T>()
         }
-        
+
         return deleteQuery
     }
 }
 
 // Main SQL to AST converter
 export class Parser {
-    static parse<T extends Record<string, any>, U extends Record<string, any> = any>(sql: string): 
-        _storeQuery<T> | _storeInsert<T> | _storeUpdate<T> | _storeDelete<T> | _join<T, U> {
-        
+    static parse<T extends Record<string, any>, U extends Record<string, any> = any>(
+        sql: string
+    ): _storeQuery<T> | _storeInsert<T> | _storeUpdate<T> | _storeDelete<T> | _join<T, U> {
         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 }
@@ -657,7 +671,7 @@ export class Parser {
 
     // Join query builder
     static join<T extends Record<string, any>, U extends Record<string, any>>(
-        leftCollection: string, 
+        leftCollection: string,
         rightCollection: string
     ): JoinBuilder<T, U> {
         return new JoinBuilder<T, U>(leftCollection, rightCollection)
@@ -706,51 +720,58 @@ export class QueryBuilder<T extends Record<string, any>> {
     // Convert to SQL string (reverse operation)
     toSQL(): string {
         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 as _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 ')
+            const conditions = this.queryAst.$ops
+                .map((op) => {
+                    const entries = Object.entries(op)
+                    return entries
+                        .map(([column, operand]) => {
+                            const opEntries = Object.entries(operand as _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
     }
 
     private operatorToSQL(operator: string): string {
         const opMap: Record<string, string> = {
-            '$eq': '=',
-            '$ne': '!=',
-            '$gt': '>',
-            '$lt': '<',
-            '$gte': '>=',
-            '$lte': '<=',
-            '$like': 'LIKE'
+            $eq: '=',
+            $ne: '!=',
+            $gt: '>',
+            $lt: '<',
+            $gte: '>=',
+            $lte: '<=',
+            $like: 'LIKE'
         }
         return opMap[operator] || '='
     }
@@ -826,51 +847,55 @@ export class JoinBuilder<T extends Record<string, any>, U extends Record<string,
     // Convert to SQL string
     toSQL(): string {
         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 as _joinOperand<U>).map(([operator, rightCol]) => {
-                    const sqlOp = this.operatorToSQL(operator)
-                    return `${this.joinAst.$leftCollection}.${leftCol} ${sqlOp} ${this.joinAst.$rightCollection}.${String(rightCol)}`
-                }).join(' AND ')
-            }).join(' AND ')
+            const conditions = Object.entries(this.joinAst.$on)
+                .map(([leftCol, operand]) => {
+                    return Object.entries(operand as _joinOperand<U>)
+                        .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
     }
 
     private operatorToSQL(operator: string): string {
         const opMap: Record<string, string> = {
-            '$eq': '=',
-            '$ne': '!=',
-            '$gt': '>',
-            '$lt': '<',
-            '$gte': '>=',
-            '$lte': '<=',
+            $eq: '=',
+            $ne: '!=',
+            $gt: '>',
+            $lt: '<',
+            $gte: '>=',
+            $lte: '<='
         }
         return opMap[operator] || '='
     }
-}
+}