@objectql/driver-knex 1.1.0 → 1.2.1

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,5 +1,5 @@
 import { KnexDriver } from '../src';
-import { UnifiedQuery } from '@objectql/core';
+import { UnifiedQuery } from '@objectql/types';
 
 describe('KnexDriver (SQLite Integration)', () => {
     let driver: KnexDriver;
@@ -17,16 +17,16 @@ describe('KnexDriver (SQLite Integration)', () => {
         const k = (driver as any).knex;
         
         await k.schema.createTable('users', (t: any) => {
-            t.increments('id');
+            t.string('id').primary();
             t.string('name');
             t.integer('age');
         });
 
         await k('users').insert([
-            { name: 'Alice', age: 25 },
-            { name: 'Bob', age: 17 },
-            { name: 'Charlie', age: 30 },
-            { name: 'Dave', age: 17 }
+            { id: '1', name: 'Alice', age: 25 },
+            { id: '2', name: 'Bob', age: 17 },
+            { id: '3', name: 'Charlie', age: 30 },
+            { id: '4', name: 'Dave', age: 17 }
         ]);
     });
 
@@ -105,5 +105,16 @@ describe('KnexDriver (SQLite Integration)', () => {
         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');
+    });
 });
 

package/test/schema.test.ts

@@ -0,0 +1,253 @@
+import { KnexDriver } from '../src';
+
+describe('KnexDriver Schema Sync (SQLite)', () => {
+    let driver: KnexDriver;
+    let knexInstance: any;
+
+    beforeEach(async () => {
+        // Init ephemeral in-memory database
+        driver = new KnexDriver({
+            client: 'sqlite3',
+            connection: {
+                filename: ':memory:'
+            },
+            useNullAsDefault: true
+        });
+        knexInstance = (driver as any).knex;
+    });
+
+    afterEach(async () => {
+        await knexInstance.destroy();
+    });
+
+    it('should create table if not exists', async () => {
+        const objects = [{
+            name: 'test_obj',
+            fields: {
+                name: { type: 'string' },
+                age: { type: 'integer' }
+            }
+        }];
+
+        await driver.init(objects);
+
+        const exists = await knexInstance.schema.hasTable('test_obj');
+        expect(exists).toBe(true);
+
+        const columns = await knexInstance('test_obj').columnInfo();
+        expect(columns).toHaveProperty('id');
+        expect(columns).toHaveProperty('created_at');
+        expect(columns).toHaveProperty('updated_at');
+        expect(columns).toHaveProperty('name');
+        expect(columns).toHaveProperty('age');
+    });
+
+    it('should add new columns if table exists', async () => {
+        // 1. Setup existing table with subset of columns
+        await knexInstance.schema.createTable('test_obj', (t: any) => {
+            t.string('id').primary();
+            t.string('name');
+        });
+
+        // 2. Insert some data
+        await knexInstance('test_obj').insert({ id: '1', name: 'Old Data' });
+
+        // 3. Init with new fields
+        const objects = [{
+            name: 'test_obj',
+            fields: {
+                name: { type: 'string' },
+                age: { type: 'integer' }, // New field
+                active: { type: 'boolean' } // New field
+            }
+        }];
+
+        await driver.init(objects);
+
+        // 4. Verify columns
+        const columns = await knexInstance('test_obj').columnInfo();
+        expect(columns).toHaveProperty('age');
+        expect(columns).toHaveProperty('active');
+
+        // 5. Verify data is intact
+        const row = await knexInstance('test_obj').where('id', '1').first();
+        expect(row.name).toBe('Old Data');
+    });
+
+    it('should not delete existing columns', async () => {
+         // 1. Setup table with extra column
+         await knexInstance.schema.createTable('test_obj', (t: any) => {
+            t.string('id').primary();
+            t.string('name');
+            t.string('extra_column'); // Should stay
+        });
+
+        // 2. Init with only 'name'
+        const objects = [{
+            name: 'test_obj',
+            fields: {
+                name: { type: 'string' }
+            }
+        }];
+
+        await driver.init(objects);
+
+        const columns = await knexInstance('test_obj').columnInfo();
+        expect(columns).toHaveProperty('name');
+        expect(columns).toHaveProperty('extra_column'); // Preservation check
+    });
+
+    it('should not fail if table creation is repeated', async () => {
+        const objects = [{
+            name: 'test_obj',
+            fields: {
+                name: { type: 'string' }
+            }
+        }];
+
+        // First init
+        await driver.init(objects);
+        
+        // Second init (should be idempotent-ish, or just skip creation)
+        await driver.init(objects);
+
+        const exists = await knexInstance.schema.hasTable('test_obj');
+        expect(exists).toBe(true);
+    });
+
+    it('should create json column for multiple=true fields', async () => {
+        const objects = [{
+            name: 'multi_test',
+            fields: {
+                tags: { type: 'select', multiple: true } as any,
+                users: { type: 'lookup', reference_to: 'user', multiple: true } as any
+            }
+        }];
+
+        await driver.init(objects);
+
+        const columns = await knexInstance('multi_test').columnInfo();
+        // Types in SQLite might be generic, but verifying we can insert/read array is best.
+        
+        // Try inserting array data
+        await driver.create('multi_test', {
+            tags: ['a', 'b'],
+            users: ['u1', 'u2']
+        });
+
+        const results = await driver.find('multi_test', {});
+        const row = results[0];
+
+        // Driver should automatically parse JSON columns for SQLite
+        expect(row.tags).toEqual(['a', 'b']);
+        expect(row.users).toEqual(['u1', 'u2']);
+    });
+
+    it('should create percent column', async () => {
+        const objects = [{
+            name: 'percent_test',
+            fields: {
+                completion: { type: 'percent' } as any
+            }
+        }];
+
+        await driver.init(objects);
+
+        const columns = await knexInstance('percent_test').columnInfo();
+        expect(columns).toHaveProperty('completion');
+        
+        // Insert a percentage
+        await driver.create('percent_test', { completion: 0.85 });
+        const res = await driver.find('percent_test', {});
+        expect(res[0].completion).toBe(0.85);
+    });
+
+    it('should handle special fields (formula, summary, auto_number)', async () => {
+        const objects = [{
+            name: 'special_fields_test',
+            fields: {
+                // Formula should NOT create a column
+                total: { type: 'formula', expression: 'price * qty', data_type: 'number' } as any,
+                // Summary should create a numeric column
+                child_count: { type: 'summary', summary_object: 'child_obj', summary_type: 'count' } as any,
+                // Auto Number should create a string column
+                invoice_no: { type: 'auto_number', auto_number_format: 'INV-{0000}' } as any
+            }
+        }];
+
+        await driver.init(objects);
+
+        const columns = await knexInstance('special_fields_test').columnInfo();
+        
+        expect(columns).not.toHaveProperty('total');
+        expect(columns).toHaveProperty('child_count');
+        expect(columns).toHaveProperty('invoice_no');
+    });
+
+    it('should create database constraints (unique, required)', async () => {
+        const objects = [{
+            name: 'constraint_test',
+            fields: {
+                unique_field: { type: 'string', unique: true } as any,
+                required_field: { type: 'string', required: true } as any
+            }
+        }];
+
+        await driver.init(objects);
+
+        // Verify Unique using negative test?
+        // SQLite enforces unique.
+        await driver.create('constraint_test', { unique_field: 'u1', required_field: 'r1' });
+        
+        try {
+            await driver.create('constraint_test', { unique_field: 'u1', required_field: 'r2' });
+            fail('Should throw error for unique violation');
+        } catch (e: any) {
+            expect(e.message).toMatch(/UNIQUE constraint failed|duplicate key value/);
+        }
+
+        try {
+            await driver.create('constraint_test', { unique_field: 'u2' });
+            fail('Should throw error for not null violation');
+        } catch (e: any) {
+             expect(e.message).toMatch(/NOT NULL constraint failed|null value in column/);
+        }
+    });
+
+    it('should handle new field types (email, file, location)', async () => {
+        const objects = [{
+            name: 'new_types_test',
+            fields: {
+                email: { type: 'email' } as any,
+                profile_pic: { type: 'image' } as any,
+                resume: { type: 'file' } as any,
+                office_loc: { type: 'location' } as any,
+                work_hours: { type: 'time' } as any
+            }
+        }];
+
+        await driver.init(objects);
+        const cols = await knexInstance('new_types_test').columnInfo();
+        
+        expect(cols).toHaveProperty('email');
+        // File/Image/Location/Avatar are stored as JSON in KnexDriver mapping
+        // But columnInfo might report 'text' for sqlite or 'json' for postgres.
+        // We just ensure they were created.
+        expect(cols).toHaveProperty('profile_pic');
+        expect(cols).toHaveProperty('resume');
+        
+        // Test Insert for complex types
+        await driver.create('new_types_test', {
+            email: 'test@example.com',
+            profile_pic: { url: 'http://img.com/1.png' },
+            office_loc: { lat: 10, lng: 20 },
+            work_hours: '09:00:00'
+        });
+        
+        const res = await driver.find('new_types_test', {});
+        const row = res[0];
+        
+        expect(row.email).toBe('test@example.com');
+        expect(row.office_loc).toEqual({ lat: 10, lng: 20 }); // Auto-parsed by driver logic
+    });
+});