更新 Knex 驱动的数据库初始化逻辑，添加表和列的创建功能

Author: hotlong

examples/apps/nestjs/src/objectql/objectql.instance.ts

@@ -5,7 +5,7 @@ export const objectql = new ObjectQL({
   datasources: {
       default: new KnexDriver({ 
           client: 'pg',
-          connection: process.env.DATABASE_URL || 'postgres://postgres:postgres@localhost:5432/objectql_example'
+          connection: process.env.DATABASE_URL || 'postgres://postgres:postgres@localhost:5432/objectql'
       })
   },
   packages: [

packages/core/src/driver.ts

@@ -6,6 +6,9 @@ export interface Driver {
     delete(objectName: string, id: string | number, options?: any): Promise<any>;
     count(objectName: string, filters: any, options?: any): Promise<number>;
 
+    // Schema / Lifecycle
+    init?(objects: any[]): Promise<void>;
+
     // Advanced
     aggregate?(objectName: string, query: any, options?: any): Promise<any>;
     distinct?(objectName: string, field: string, filters?: any, options?: any): Promise<any[]>;

packages/core/src/index.ts

@@ -133,8 +133,23 @@ export class ObjectQL implements IObjectQL {
     }
 
     async init() {
-        const ctx = this.createContext({ isSystem: true });
         const objects = this.metadata.list<ObjectConfig>('object');
+        
+        // 1. Init Drivers (e.g. Sync Schema)
+        // We probably should pass all objects to all drivers, or split them by datasource if objects were assigned to specific DS.
+        // For now, assume all objects go to default driver or driver handles filtering if needed (but driver doesn't know mapping usually).
+        // Actually, ObjectQL currently doesn't seem to support multiple datasources per object mapping strictly yet (default is used).
+        // Let's pass all objects to all configured drivers.
+        for (const [name, driver] of Object.entries(this.datasources)) {
+            if (driver.init) {
+                console.log(`Initializing driver '${name}'...`);
+                await driver.init(objects);
+            }
+        }
+
+        const ctx = this.createContext({ isSystem: true });
+        
+        // 2. Init Data
         for (const obj of objects) {
             if (obj.data && obj.data.length > 0) {
                 console.log(`Initializing data for object ${obj.name}...`);

packages/driver-knex/src/index.ts

@@ -3,8 +3,10 @@ import knex, { Knex } from 'knex';
 
 export class KnexDriver implements Driver {
     private knex: Knex;
+    private config: any;
 
     constructor(config: any) {
+        this.config = config;
         this.knex = knex(config);
     }
 
@@ -167,5 +169,106 @@ 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;
+            const exists = await this.knex.schema.hasTable(tableName);
+            
+            if (!exists) {
+                await this.knex.schema.createTable(tableName, (table) => {
+                    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) {
+        const type = field.type || 'string';
+        let col;
+        switch(type) {
+            case 'string': col = table.string(name); break;
+            case 'text': col = table.text(name); break;
+            case 'integer': 
+            case 'int': col = table.integer(name); break;
+            case 'float': 
+            case 'number': 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 'json': 
+            case 'object':
+            case 'array': col = table.json(name); break;
+            default: col = table.string(name);
+        }
+    }
+
+    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);
+             throw e;
+        } finally {
+            await adminKnex.destroy();
+        }
+    }
 }