WIP: Update types to use DriverInterface from @objectstack/spec

Co-authored-by: hotlong <50353452+hotlong@users.noreply.github.com>

Author: Copilot

packages/drivers/sql/package.json

@@ -23,6 +23,7 @@
   },
   "dependencies": {
     "@objectql/types": "workspace:*",
+    "@objectstack/spec": "^0.1.2",
     "knex": "^3.1.0"
   },
   "devDependencies": {

packages/drivers/sql/src/index.ts

@@ -6,10 +6,21 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import { Driver, IntrospectedSchema, IntrospectedTable, IntrospectedColumn, IntrospectedForeignKey } from '@objectql/types';
+import { IntrospectedSchema, IntrospectedTable, IntrospectedColumn, IntrospectedForeignKey } from '@objectql/types';
+import type { DriverInterface } from '@objectstack/spec';
 import knex, { Knex } from 'knex';
 
-export class SqlDriver implements Driver {
+export class SqlDriver implements DriverInterface {
+    readonly name = 'sql';
+    readonly version = '3.0.1';
+    readonly supports = {
+        transactions: true,
+        joins: true,
+        fullTextSearch: false,
+        jsonFields: true,
+        arrayFields: false
+    };
+    
     private knex: Knex;
     private config: any;
     private jsonFields: Record<string, string[]> = {};
@@ -219,16 +230,41 @@ export class SqlDriver implements Driver {
         return 0;
     }
 
+    // Connection Management
+    async connect(): Promise<void> {
+        // Knex initializes connection pool automatically
+        // We can test the connection here
+        await this.knex.raw('SELECT 1');
+    }
+    
+    async checkHealth(): Promise<boolean> {
+        try {
+            await this.knex.raw('SELECT 1');
+            return true;
+        } catch {
+            return false;
+        }
+    }
+    
+    async execute(command: any, parameters?: any[], options?: any): Promise<any> {
+        // For SQL driver, execute raw SQL
+        if (typeof command === 'string') {
+            return await this.knex.raw(command, parameters);
+        }
+        // For object commands, could be knex query builder
+        throw new Error('Execute with non-string commands not supported in SQL driver');
+    }
+
     // Transaction Support
     async beginTransaction(): Promise<any> {
         return await this.knex.transaction();
     }
 
-    async commitTransaction(trx: Knex.Transaction): Promise<void> {
+    async commit(trx: Knex.Transaction): Promise<void> {
         await trx.commit();
     }
 
-    async rollbackTransaction(trx: Knex.Transaction): Promise<void> {
+    async rollback(trx: Knex.Transaction): Promise<void> {
         await trx.rollback();
     }
 
@@ -277,23 +313,45 @@ export class SqlDriver implements Driver {
         }
     }
 
-    // Bulk
-    async createMany(objectName: string, data: any[], options?: any): Promise<any> {
+    // Bulk Operations
+    async bulkCreate(objectName: string, data: any[], options?: any): Promise<any> {
         const builder = this.getBuilder(objectName, options);
         return await builder.insert(data).returning('*');
     }
 
-    async updateMany(objectName: string, filters: any, data: any, options?: any): Promise<any> {
+    async bulkUpdate(objectName: string, filters: any, data: any, options?: any): Promise<any> {
         const builder = this.getBuilder(objectName, options);
         if(filters) this.applyFilters(builder, filters);
         return await builder.update(data);
     }
 
-    async deleteMany(objectName: string, filters: any, options?: any): Promise<any> {
+    async bulkDelete(objectName: string, filters: any, options?: any): Promise<any> {
         const builder = this.getBuilder(objectName, options);
         if(filters) this.applyFilters(builder, filters);
         return await builder.delete();
     }
+    
+    // Aliases for backward compatibility
+    async createMany(objectName: string, data: any[], options?: any): Promise<any> {
+        return this.bulkCreate(objectName, data, options);
+    }
+    
+    async updateMany(objectName: string, filters: any, data: any, options?: any): Promise<any> {
+        return this.bulkUpdate(objectName, filters, data, options);
+    }
+    
+    async deleteMany(objectName: string, filters: any, options?: any): Promise<any> {
+        return this.bulkDelete(objectName, filters, options);
+    }
+    
+    // Transaction aliases for backward compatibility
+    async commitTransaction(trx: Knex.Transaction): Promise<void> {
+        return this.commit(trx);
+    }
+
+    async rollbackTransaction(trx: Knex.Transaction): Promise<void> {
+        return this.rollback(trx);
+    }
 
     async init(objects: any[]): Promise<void> {
         await this.ensureDatabaseExists();
@@ -506,6 +564,23 @@ export class SqlDriver implements Driver {
         return data;
     }
 
+    /**
+     * Synchronize schema - alias for init for DriverInterface compatibility
+     */
+    async syncSchema(objects: any[]): Promise<void> {
+        return this.init(objects);
+    }
+    
+    /**
+     * Drop a table from the database
+     */
+    async dropTable(tableName: string): Promise<void> {
+        const exists = await this.knex.schema.hasTable(tableName);
+        if (exists) {
+            await this.knex.schema.dropTable(tableName);
+        }
+    }
+
     /**
      * Introspect the database schema to discover existing tables, columns, and relationships.
      */

packages/foundation/core/src/app.ts

@@ -159,10 +159,10 @@ export class ObjectQL implements IObjectQL {
 
                  try {
                      const result = await callback(trxCtx);
-                     if (driver.commitTransaction) await driver.commitTransaction(trx);
+                     if (driver.commit) await driver.commit(trx);
                      return result;
                  } catch (error) {
-                     if (driver.rollbackTransaction) await driver.rollbackTransaction(trx);
+                     if (driver.rollback) await driver.rollback(trx);
                      throw error;
                  }
             },

packages/foundation/core/src/repository.ts

@@ -6,7 +6,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import { ObjectQLContext, IObjectQL, ObjectConfig, Driver, UnifiedQuery, ActionContext, HookAPI, RetrievalHookContext, MutationHookContext, UpdateHookContext, ValidationContext, ValidationError, ValidationRuleResult, FormulaContext } from '@objectql/types';
+import { ObjectQLContext, IObjectQL, ObjectConfig, UnifiedQuery, ActionContext, HookAPI, RetrievalHookContext, MutationHookContext, UpdateHookContext, ValidationContext, ValidationError, ValidationRuleResult, FormulaContext } from '@objectql/types';
+import type { DriverInterface } from '@objectstack/spec';
 import { Validator } from './validator';
 import { FormulaEngine } from './formula-engine';
 
@@ -23,7 +24,7 @@ export class ObjectRepository {
         this.formulaEngine = new FormulaEngine();
     }
 
-    private getDriver(): Driver {
+    private getDriver(): DriverInterface {
         const obj = this.getSchema();
         const datasourceName = obj.datasource || 'default';
         return this.app.datasource(datasourceName);

packages/foundation/types/src/app.ts

@@ -7,16 +7,16 @@
  */
 
 import { ObjectConfig } from "./object";
-import { Driver } from "./driver";
 import { MetadataRegistry } from "./registry";
 import { HookName, HookHandler, HookContext } from "./hook";
 import { ActionHandler, ActionContext } from "./action";
 import { LoaderPlugin } from "./loader";
+import type { DriverInterface } from "@objectstack/spec";
 
 export interface IObjectQL {
     getObject(name: string): ObjectConfig | undefined;
     getConfigs(): Record<string, ObjectConfig>;
-    datasource(name: string): Driver;
+    datasource(name: string): DriverInterface;
     init(): Promise<void>;
     close?(): Promise<void>;
     removePackage(name: string): void;