@objectql/driver-knex 1.0.0 → 1.2.0

package/src/index.ts

@@ -1,10 +1,13 @@
-import { Driver } from '@objectql/core';
+import { Driver } from '@objectql/types';
 import knex, { Knex } from 'knex';
 
 export class KnexDriver implements Driver {
     private knex: Knex;
+    private config: any;
+    private jsonFields: Record<string, string[]> = {};
 
     constructor(config: any) {
+        this.config = config;
         this.knex = knex(config);
     }
 
@@ -19,8 +22,6 @@ export class KnexDriver implements Driver {
     private applyFilters(builder: Knex.QueryBuilder, filters: any) {
         if (!filters || filters.length === 0) return;
 
-        // Simple linear parser handling [cond, 'or', cond, 'and', cond]
-        // Default join is AND.
         let nextJoin = 'and';
 
         for (const item of filters) {
@@ -31,46 +32,57 @@ export class KnexDriver implements Driver {
              }
 
              if (Array.isArray(item)) {
-                 const [field, op, value] = item;
-                 
-                 // Handle specific operators that map to different knex methods
-                 const apply = (b: any) => {
-                     // b is the builder to apply on (could be root or a where clause)
-                     // But here we call directly on builder using 'where' or 'orWhere'
-                     
-                     // Method selection
-                     let method = nextJoin === 'or' ? 'orWhere' : 'where';
-                     let methodIn = nextJoin === 'or' ? 'orWhereIn' : 'whereIn';
-                     let methodNotIn = nextJoin === 'or' ? 'orWhereNotIn' : 'whereNotIn';
-
-                     switch (op) {
-                         case '=': b[method](field, value); break;
-                         case '!=': b[method](field, '<>', value); break;
-                         case 'in': b[methodIn](field, value); break;
-                         case 'nin': b[methodNotIn](field, value); break;
-                         case 'contains': b[method](field, 'like', `%${value}%`); break; // Simple LIKE
-                         default: b[method](field, op, value);
-                     }
-                 };
+                 // Heuristic to detect if it is a criterion [field, op, value] or a nested group
+                 const [fieldRaw, op, value] = item;
+                 const isCriterion = typeof fieldRaw === 'string' && typeof op === 'string';
 
-                 apply(builder);
+                 if (isCriterion) {
+                     const field = this.mapSortField(fieldRaw);
+                     // Handle specific operators that map to different knex methods
+                     const apply = (b: any) => {
+                         let method = nextJoin === 'or' ? 'orWhere' : 'where';
+                         let methodIn = nextJoin === 'or' ? 'orWhereIn' : 'whereIn';
+                         let methodNotIn = nextJoin === 'or' ? 'orWhereNotIn' : 'whereNotIn';
+                         
+                         // Fix for 'contains' mapping
+                         if (op === 'contains') {
+                             b[method](field, 'like', `%${value}%`);
+                             return;
+                         }
+
+                         switch (op) {
+                             case '=': b[method](field, value); break;
+                             case '!=': b[method](field, '<>', value); break;
+                             case 'in': b[methodIn](field, value); break;
+                             case 'nin': b[methodNotIn](field, value); break;
+                             default: b[method](field, op, value);
+                         }
+                     };
+                     apply(builder);
+                 } else {
+                     // Recursive Group
+                     const method = nextJoin === 'or' ? 'orWhere' : 'where';
+                     builder[method]((qb) => {
+                         this.applyFilters(qb, item);
+                     });
+                 }
                  
-                 // Reset join to 'and' for subsequent terms unless strictly specified?
-                 // In SQL `A or B and C` means `A or (B and C)`.
-                 // If we chain `.where(A).orWhere(B).where(C)` in Knex:
-                 // It produces `... WHERE A OR B AND C`.
-                 // So linear application matches SQL precedence usually if implicit validation is ok.
-                 // But explicit AND after OR is necessary in our array format.
                  nextJoin = 'and'; 
              }
         }
     }
 
+    private mapSortField(field: string): string {
+        if (field === 'createdAt') return 'created_at';
+        if (field === 'updatedAt') return 'updated_at';
+        return field;
+    }
+
     async find(objectName: string, query: any, options?: any): Promise<any[]> {
         const builder = this.getBuilder(objectName, options);
         
         if (query.fields) {
-            builder.select(query.fields);
+            builder.select(query.fields.map((f: string) => this.mapSortField(f)));
         } else {
             builder.select('*');
         }
@@ -81,19 +93,26 @@ export class KnexDriver implements Driver {
 
         if (query.sort) {
             for (const [field, dir] of query.sort) {
-                builder.orderBy(field, dir);
+                builder.orderBy(this.mapSortField(field), dir);
             }
         }
 
         if (query.skip) builder.offset(query.skip);
         if (query.limit) builder.limit(query.limit);
 
-        return await builder;
+        const results = await builder;
+        if (this.config.client === 'sqlite3') {
+             for (const row of results) {
+                 this.formatOutput(objectName, row);
+             }
+        }
+        return results;
     }
 
     async findOne(objectName: string, id: string | number, query?: any, options?: any) {
         if (id) {
-            return await this.getBuilder(objectName, options).where('id', id).first();
+            const res = await this.getBuilder(objectName, options).where('id', id).first();
+            return this.formatOutput(objectName, res);
         }
         if (query) {
              const results = await this.find(objectName, { ...query, limit: 1 }, options);
@@ -103,19 +122,32 @@ export class KnexDriver implements Driver {
     }
 
     async create(objectName: string, data: any, options?: any) {
+        // Handle _id -> id mapping for compatibility
+        const { _id, ...rest } = data;
+        const toInsert = { ...rest };
+        // If _id exists and id doesn't, map _id to id
+        if (_id !== undefined && toInsert.id === undefined) {
+             toInsert.id = _id;
+        } else if (toInsert.id !== undefined) {
+            // normal case
+        }
+        
         // Knex insert returns Result array (e.g. ids)
         // We want the created document. 
-        // Some DBs support .returning('*'), others don't easily.
-        // Assuming Postgres/SQLite/Modern MySQL for now support returning.
         const builder = this.getBuilder(objectName, options);
-        const result = await builder.insert(data).returning('*'); // This might fail on old MySQL
-        return result[0];
+
+        const formatted = this.formatInput(objectName, toInsert);
+
+        // We should insert 'toInsert' instead of 'data'
+        const result = await builder.insert(formatted).returning('*'); 
+        return this.formatOutput(objectName, result[0]);
     }
 
     async update(objectName: string, id: string | number, data: any, options?: any) {
         const builder = this.getBuilder(objectName, options);
-        await builder.where('id', id).update(data);
-        return { id, ...data }; // Return patched data? Or fetch fresh?
+        const formatted = this.formatInput(objectName, data);
+        await builder.where('id', id).update(formatted);
+        return { id, ...data }; 
     }
 
     async delete(objectName: string, id: string | number, options?: any) {
@@ -167,5 +199,208 @@ export class KnexDriver implements Driver {
         if(filters) this.applyFilters(builder, filters);
         return await builder.delete();
     }
+
+    async init(objects: any[]): Promise<void> {
+        await this.ensureDatabaseExists();
+
+        for (const obj of objects) {
+            const tableName = obj.name;
+            
+            // Cache JSON fields
+            const jsonCols: string[] = [];
+            if (obj.fields) {
+                for (const [name, field] of Object.entries<any>(obj.fields)) {
+                     const type = field.type || 'string';
+                     if (this.isJsonField(type, field)) {
+                         jsonCols.push(name);
+                     }
+                }
+            }
+            this.jsonFields[tableName] = jsonCols;
+
+            let exists = await this.knex.schema.hasTable(tableName);
+            
+            if (exists) {
+                 const columnInfo = await this.knex(tableName).columnInfo();
+                 const existingColumns = Object.keys(columnInfo);
+                 
+                 // Check for _id vs id conflict (Legacy _id from mongo-style init)
+                 if (existingColumns.includes('_id') && !existingColumns.includes('id')) {
+                     console.log(`[KnexDriver] Detected legacy '_id' in '${tableName}'. Recreating table for 'id' compatibility...`);
+                     await this.knex.schema.dropTable(tableName);
+                     exists = false;
+                 }
+            }
+            
+            if (!exists) {
+                await this.knex.schema.createTable(tableName, (table) => {
+                    // Use standard 'id' for SQL databases
+                    table.string('id').primary(); 
+                    table.timestamp('created_at').defaultTo(this.knex.fn.now());
+                    table.timestamp('updated_at').defaultTo(this.knex.fn.now());
+                    if (obj.fields) {
+                        for (const [name, field] of Object.entries(obj.fields)) {
+                            this.createColumn(table, name, field);
+                        }
+                    }
+                });
+                console.log(`[KnexDriver] Created table '${tableName}'`);
+            } else {
+                 const columnInfo = await this.knex(tableName).columnInfo();
+                 const existingColumns = Object.keys(columnInfo);
+                 
+                 await this.knex.schema.alterTable(tableName, (table) => {
+                     if (obj.fields) {
+                         for (const [name, field] of Object.entries(obj.fields)) {
+                             if (!existingColumns.includes(name)) {
+                                 this.createColumn(table, name, field);
+                                 console.log(`[KnexDriver] Added column '${name}' to '${tableName}'`);
+                             }
+                         }
+                     }
+                 });
+            }
+        }
+    }
+
+    private createColumn(table: Knex.CreateTableBuilder, name: string, field: any) {
+        if (field.multiple) {
+            table.json(name);
+            return;
+        }
+
+        const type = field.type || 'string';
+        let col;
+        switch(type) {
+            case 'string': 
+            case 'email':
+            case 'url':
+            case 'phone':
+            case 'password':
+                col = table.string(name); break;
+            case 'text': 
+            case 'textarea': 
+            case 'html': 
+            case 'markdown':
+                col = table.text(name); break;
+            case 'integer': 
+            case 'int': col = table.integer(name); break;
+            case 'float': 
+            case 'number': 
+            case 'currency':
+            case 'percent': col = table.float(name); break;
+            case 'boolean': col = table.boolean(name); break;
+            case 'date': col = table.date(name); break;
+            case 'datetime': col = table.timestamp(name); break;
+            case 'time': col = table.time(name); break;
+            case 'json': 
+            case 'object':
+            case 'array': 
+            case 'image':
+            case 'file':
+            case 'avatar':
+            case 'location': col = table.json(name); break;
+            case 'summary': col = table.float(name); break; // Stored calculation result
+            case 'auto_number': col = table.string(name); break; // Generated string
+            case 'formula': return; // Virtual field, do not create column
+            default: col = table.string(name);
+        }
+
+        if (field.unique) {
+            col.unique();
+        }
+        if (field.required) {
+            col.notNullable();
+        }
+    }
+
+    private async ensureDatabaseExists() {
+        if (this.config.client !== 'pg' && this.config.client !== 'postgresql') return;
+        
+        try {
+            await this.knex.raw('SELECT 1');
+        } catch (e: any) {
+            if (e.code === '3D000') { // Database does not exist
+                 await this.createDatabase();
+            } else {
+                throw e;
+            }
+        }
+    }
+
+    private async createDatabase() {
+        const config = this.config;
+        const connection = config.connection;
+        let dbName = '';
+        let adminConfig = { ...config };
+
+        if (typeof connection === 'string') {
+            const url = new URL(connection);
+            dbName = url.pathname.slice(1);
+            url.pathname = '/postgres';
+            adminConfig.connection = url.toString();
+        } else {
+            dbName = connection.database;
+            adminConfig.connection = { ...connection, database: 'postgres' };
+        }
+
+        console.log(`[KnexDriver] Database '${dbName}' does not exist. Creating...`);
+
+        const adminKnex = knex(adminConfig);
+        try {
+            await adminKnex.raw(`CREATE DATABASE "${dbName}"`);
+            console.log(`[KnexDriver] Database '${dbName}' created successfully.`);
+        } catch (e: any) {
+             console.error(`[KnexDriver] Failed to create database '${dbName}':`, e.message);
+             if (e.code === '42501') {
+                 console.error(`[KnexDriver] Hint: The user '${adminConfig.connection.user || 'current user'}' does not have CREATEDB privileges.`);
+                 console.error(`[KnexDriver] Please run: createdb ${dbName}`);
+             }
+             throw e;
+        } finally {
+            await adminKnex.destroy();
+        }
+    }
+
+    private isJsonField(type: string, field: any) {
+        return ['json', 'object', 'array', 'image', 'file', 'avatar', 'location'].includes(type) || field.multiple;
+    }
+
+    private formatInput(objectName: string, data: any) {
+        // Only needed for SQLite usually, PG handles JSON
+        const isSqlite = this.config.client === 'sqlite3';
+        if (!isSqlite) return data;
+        
+        const fields = this.jsonFields[objectName];
+        if (!fields || fields.length === 0) return data;
+
+        const copy = { ...data };
+        for (const field of fields) {
+            if (copy[field] !== undefined && typeof copy[field] === 'object' && copy[field] !== null) {
+                copy[field] = JSON.stringify(copy[field]);
+            }
+        }
+        return copy;
+    }
+
+    private formatOutput(objectName: string, data: any) {
+        const isSqlite = this.config.client === 'sqlite3';
+        if (!isSqlite) return data;
+
+        const fields = this.jsonFields[objectName];
+        if (!fields || fields.length === 0) return data;
+
+        // data is a single row object
+        for (const field of fields) {
+            if (data[field] !== undefined && typeof data[field] === 'string') {
+                try {
+                    data[field] = JSON.parse(data[field]);
+                } catch (e) {
+                    // ignore parse error, keep as string
+                }
+            }
+        }
+        return data;
+    }
 }
 

package/test/index.test.ts

@@ -1,30 +1,38 @@
 import { KnexDriver } from '../src';
-import knex from 'knex';
+import { UnifiedQuery } from '@objectql/types';
 
-const mockChain = (methods: string[]) => {
-    const mock: any = {};
-    methods.forEach(m => {
-        mock[m] = jest.fn().mockReturnThis();
-    });
-    mock.then = jest.fn((resolve) => resolve([]));
-    mock.catch = jest.fn();
-    return mock;
-};
-
-const mockBuilder = mockChain(['select', 'where', 'orWhere', 'orderBy', 'offset', 'limit', 'insert', 'update', 'delete', 'transacting', 'count']);
-const mockFirst = jest.fn();
-mockBuilder.first = mockFirst;
+describe('KnexDriver (SQLite Integration)', () => {
+    let driver: KnexDriver;
 
-jest.mock('knex', () => {
-    return jest.fn(() => (tableName: string) => mockBuilder);
-});
+    beforeEach(async () => {
+        // Init ephemeral in-memory database
+        driver = new KnexDriver({
+            client: 'sqlite3',
+            connection: {
+                filename: ':memory:'
+            },
+            useNullAsDefault: true
+        });
+        
+        const k = (driver as any).knex;
+        
+        await k.schema.createTable('users', (t: any) => {
+            t.string('id').primary();
+            t.string('name');
+            t.integer('age');
+        });
 
-describe('KnexDriver', () => {
-    let driver: KnexDriver;
+        await k('users').insert([
+            { id: '1', name: 'Alice', age: 25 },
+            { id: '2', name: 'Bob', age: 17 },
+            { id: '3', name: 'Charlie', age: 30 },
+            { id: '4', name: 'Dave', age: 17 }
+        ]);
+    });
 
-    beforeEach(() => {
-        driver = new KnexDriver({ client: 'sqlite3' });
-        jest.clearAllMocks();
+    afterEach(async () => {
+        const k = (driver as any).knex;
+        await k.destroy();
     });
 
     it('should be instantiable', () => {
@@ -32,39 +40,81 @@ describe('KnexDriver', () => {
         expect(driver).toBeInstanceOf(KnexDriver);
     });
 
-    it('should find objects', async () => {
-        const query = {
+    it('should find objects with filters', async () => {
+        const query: UnifiedQuery = {
             fields: ['name', 'age'],
             filters: [['age', '>', 18]],
-            sort: [['name', 'asc']],
-            skip: 10,
-            limit: 5
+            sort: [['name', 'asc']]
         };
-        await driver.find('users', query);
+        const results = await driver.find('users', query);
         
-        expect(mockBuilder.select).toHaveBeenCalledWith(['name', 'age']);
-        expect(mockBuilder.where).toHaveBeenCalledWith('age', '>', 18);
-        expect(mockBuilder.orderBy).toHaveBeenCalledWith('name', 'asc');
-        expect(mockBuilder.offset).toHaveBeenCalledWith(10);
-        expect(mockBuilder.limit).toHaveBeenCalledWith(5);
+        expect(results.length).toBe(2);
+        expect(results.map((r: any) => r.name)).toEqual(['Alice', 'Charlie']);
     });
 
-    it('should apply OR filters correctly', async () => {
-        const query = {
-            filters: [['age', '>', 18], 'or', ['role', '=', 'admin']]
+    it('should apply simple AND/OR logic', async () => {
+        // age = 17 OR age > 29
+        const query: UnifiedQuery = {
+            filters: [
+                ['age', '=', 17],
+                'or',
+                ['age', '>', 29]
+            ]
         };
-        await driver.find('users', query);
-        expect(mockBuilder.where).toHaveBeenCalledWith('age', '>', 18);
-        expect(mockBuilder.orWhere).toHaveBeenCalledWith('role', 'admin');
+        const results = await driver.find('users', query);
+        const names = results.map((r: any) => r.name).sort();
+        expect(names).toEqual(['Bob', 'Charlie', 'Dave']);
     });
 
     it('should find one object by id', async () => {
-        mockFirst.mockResolvedValueOnce({ id: 1, name: 'Alice' });
-        const result = await driver.findOne('users', 1);
-        expect(mockBuilder.where).toHaveBeenCalledWith('id', 1);
-        expect(mockFirst).toHaveBeenCalled();
-        expect(result).toEqual({ id: 1, name: 'Alice' });
+        // First get an ID
+        const [alice] = await driver.find('users', { filters: [['name', '=', 'Alice']] });
+        expect(alice).toBeDefined();
+
+        const fetched = await driver.findOne('users', alice.id);
+        expect(fetched).toBeDefined();
+        expect(fetched.name).toBe('Alice');
+    });
+
+    it('should create an object', async () => {
+        const newItem = { name: 'Eve', age: 22 };
+        await driver.create('users', newItem);
+
+        const [eve] = await driver.find('users', { filters: [['name', '=', 'Eve']] });
+        expect(eve).toBeDefined();
+        expect(eve.age).toBe(22);
     });
 
-    // Add more tests for insert, update, delete when implemented in src
+    it('should update an object', async () => {
+        const [bob] = await driver.find('users', { filters: [['name', '=', 'Bob']] });
+        await driver.update('users', bob.id, { age: 18 });
+
+        const updated = await driver.findOne('users', bob.id);
+        expect(updated.age).toBe(18);
+    });
+
+    it('should delete an object', async () => {
+        const [charlie] = await driver.find('users', { filters: [['name', '=', 'Charlie']] });
+        await driver.delete('users', charlie.id);
+
+        const deleted = await driver.findOne('users', charlie.id);
+        expect(deleted).toBeUndefined();
+    });
+
+    it('should count objects', async () => {
+        const count = await driver.count('users', [['age', '=', 17]]);
+        expect(count).toBe(2);
+    });
+
+    it('should map _id to id if provided', async () => {
+        const newItemWithId = { _id: 'custom-id', name: 'Frank', age: 40 };
+        const created = await driver.create('users', newItemWithId);
+
+        expect(created.id).toBe('custom-id');
+        // Check if we can retrieve it by id
+        const fetched = await driver.findOne('users', 'custom-id');
+        expect(fetched).toBeDefined();
+        expect(fetched.name).toBe('Frank');
+    });
 });
+