feat: Add registerDatasource method and create plugin wrappers for all drivers

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

Author: Copilot

packages/drivers/excel/src/index.ts

@@ -966,3 +966,48 @@ export class ExcelDriver implements Driver {
         return `${objectName}-${timestamp}-${counter}`;
     }
 }
+
+/**
+ * Excel Driver Plugin for ObjectQL
+ * 
+ * A plugin wrapper that registers an Excel driver as a datasource in ObjectQL.
+ * This follows the @objectstack/spec plugin protocol.
+ * 
+ * @example
+ * ```typescript
+ * import { ObjectQL } from '@objectql/core';
+ * import { createExcelDriverPlugin } from '@objectql/driver-excel';
+ * 
+ * const app = new ObjectQL({
+ *   plugins: [
+ *     createExcelDriverPlugin({
+ *       name: 'default',
+ *       config: {
+ *         filePath: './data.xlsx',
+ *         storageMode: 'single-file'
+ *       }
+ *     })
+ *   ]
+ * });
+ * 
+ * await app.init();
+ * ```
+ */
+import { ObjectQLPlugin, IObjectQL } from '@objectql/types';
+
+export interface ExcelDriverPluginConfig {
+    /** Name of the datasource (e.g., 'default', 'export') */
+    name: string;
+    /** Excel driver configuration */
+    config: ExcelDriverConfig;
+}
+
+export function createExcelDriverPlugin(options: ExcelDriverPluginConfig): ObjectQLPlugin {
+    return {
+        name: `excel-driver:${options.name}`,
+        setup(app: IObjectQL) {
+            const driver = new ExcelDriver(options.config);
+            app.registerDatasource(options.name, driver);
+        }
+    };
+}

packages/drivers/fs/src/index.ts

@@ -708,3 +708,49 @@ export class FileSystemDriver implements Driver {
         return `${objectName}-${timestamp}-${counter}`;
     }
 }
+
+/**
+ * FileSystem Driver Plugin for ObjectQL
+ * 
+ * A plugin wrapper that registers a FileSystem driver as a datasource in ObjectQL.
+ * This follows the @objectstack/spec plugin protocol.
+ * 
+ * @example
+ * ```typescript
+ * import { ObjectQL } from '@objectql/core';
+ * import { createFileSystemDriverPlugin } from '@objectql/driver-fs';
+ * 
+ * const app = new ObjectQL({
+ *   plugins: [
+ *     createFileSystemDriverPlugin({
+ *       name: 'default',
+ *       config: {
+ *         dataDir: './data',
+ *         prettyPrint: true,
+ *         enableBackup: true
+ *       }
+ *     })
+ *   ]
+ * });
+ * 
+ * await app.init();
+ * ```
+ */
+import { ObjectQLPlugin, IObjectQL } from '@objectql/types';
+
+export interface FileSystemDriverPluginConfig {
+    /** Name of the datasource (e.g., 'default', 'backup') */
+    name: string;
+    /** FileSystem driver configuration */
+    config: FileSystemDriverConfig;
+}
+
+export function createFileSystemDriverPlugin(options: FileSystemDriverPluginConfig): ObjectQLPlugin {
+    return {
+        name: `fs-driver:${options.name}`,
+        setup(app: IObjectQL) {
+            const driver = new FileSystemDriver(options.config);
+            app.registerDatasource(options.name, driver);
+        }
+    };
+}

packages/drivers/localstorage/src/index.ts

@@ -631,3 +631,48 @@ export class LocalStorageDriver implements Driver {
         return `${objectName}-${timestamp}-${counter}`;
     }
 }
+
+/**
+ * LocalStorage Driver Plugin for ObjectQL
+ * 
+ * A plugin wrapper that registers a LocalStorage driver as a datasource in ObjectQL.
+ * This follows the @objectstack/spec plugin protocol.
+ * 
+ * @example
+ * ```typescript
+ * import { ObjectQL } from '@objectql/core';
+ * import { createLocalStorageDriverPlugin } from '@objectql/driver-localstorage';
+ * 
+ * const app = new ObjectQL({
+ *   plugins: [
+ *     createLocalStorageDriverPlugin({
+ *       name: 'default',
+ *       config: {
+ *         namespace: 'myapp',
+ *         strictMode: true
+ *       }
+ *     })
+ *   ]
+ * });
+ * 
+ * await app.init();
+ * ```
+ */
+import { ObjectQLPlugin, IObjectQL } from '@objectql/types';
+
+export interface LocalStorageDriverPluginConfig {
+    /** Name of the datasource (e.g., 'default', 'cache') */
+    name: string;
+    /** LocalStorage driver configuration */
+    config?: LocalStorageDriverConfig;
+}
+
+export function createLocalStorageDriverPlugin(options: LocalStorageDriverPluginConfig): ObjectQLPlugin {
+    return {
+        name: `localstorage-driver:${options.name}`,
+        setup(app: IObjectQL) {
+            const driver = new LocalStorageDriver(options.config);
+            app.registerDatasource(options.name, driver);
+        }
+    };
+}

packages/drivers/memory/src/index.ts

@@ -533,3 +533,50 @@ export class MemoryDriver implements Driver {
         return `${objectName}-${timestamp}-${counter}`;
     }
 }
+
+/**
+ * Memory Driver Plugin for ObjectQL
+ * 
+ * A plugin wrapper that registers a Memory driver as a datasource in ObjectQL.
+ * This follows the @objectstack/spec plugin protocol.
+ * 
+ * @example
+ * ```typescript
+ * import { ObjectQL } from '@objectql/core';
+ * import { createMemoryDriverPlugin } from '@objectql/driver-memory';
+ * 
+ * const app = new ObjectQL({
+ *   plugins: [
+ *     createMemoryDriverPlugin({
+ *       name: 'default',
+ *       config: {
+ *         strictMode: true,
+ *         initialData: {
+ *           users: [{ id: '1', name: 'Alice' }]
+ *         }
+ *       }
+ *     })
+ *   ]
+ * });
+ * 
+ * await app.init();
+ * ```
+ */
+import { ObjectQLPlugin, IObjectQL } from '@objectql/types';
+
+export interface MemoryDriverPluginConfig {
+    /** Name of the datasource (e.g., 'default', 'cache') */
+    name: string;
+    /** Memory driver configuration */
+    config?: MemoryDriverConfig;
+}
+
+export function createMemoryDriverPlugin(options: MemoryDriverPluginConfig): ObjectQLPlugin {
+    return {
+        name: `memory-driver:${options.name}`,
+        setup(app: IObjectQL) {
+            const driver = new MemoryDriver(options.config);
+            app.registerDatasource(options.name, driver);
+        }
+    };
+}

packages/drivers/mongo/src/index.ts

@@ -309,3 +309,53 @@ export class MongoDriver implements Driver {
     }
 }
 
+/**
+ * MongoDB Driver Plugin for ObjectQL
+ * 
+ * A plugin wrapper that registers a MongoDB driver as a datasource in ObjectQL.
+ * This follows the @objectstack/spec plugin protocol.
+ * 
+ * @example
+ * ```typescript
+ * import { ObjectQL } from '@objectql/core';
+ * import { createMongoDriverPlugin } from '@objectql/driver-mongo';
+ * 
+ * const app = new ObjectQL({
+ *   plugins: [
+ *     createMongoDriverPlugin({
+ *       name: 'default',
+ *       config: {
+ *         url: 'mongodb://localhost:27017',
+ *         dbName: 'mydb'
+ *       }
+ *     })
+ *   ]
+ * });
+ * 
+ * await app.init();
+ * ```
+ */
+import { ObjectQLPlugin, IObjectQL } from '@objectql/types';
+
+export interface MongoDriverPluginConfig {
+    /** Name of the datasource (e.g., 'default', 'analytics') */
+    name: string;
+    /** MongoDB connection configuration */
+    config: {
+        /** MongoDB connection URL */
+        url: string;
+        /** Database name */
+        dbName?: string;
+    };
+}
+
+export function createMongoDriverPlugin(options: MongoDriverPluginConfig): ObjectQLPlugin {
+    return {
+        name: `mongo-driver:${options.name}`,
+        setup(app: IObjectQL) {
+            const driver = new MongoDriver(options.config);
+            app.registerDatasource(options.name, driver);
+        }
+    };
+}
+

packages/drivers/redis/src/index.ts

@@ -428,3 +428,47 @@ export class RedisDriver implements Driver {
         });
     }
 }
+
+/**
+ * Redis Driver Plugin for ObjectQL
+ * 
+ * A plugin wrapper that registers a Redis driver as a datasource in ObjectQL.
+ * This follows the @objectstack/spec plugin protocol.
+ * 
+ * @example
+ * ```typescript
+ * import { ObjectQL } from '@objectql/core';
+ * import { createRedisDriverPlugin } from '@objectql/driver-redis';
+ * 
+ * const app = new ObjectQL({
+ *   plugins: [
+ *     createRedisDriverPlugin({
+ *       name: 'default',
+ *       config: {
+ *         url: 'redis://localhost:6379'
+ *       }
+ *     })
+ *   ]
+ * });
+ * 
+ * await app.init();
+ * ```
+ */
+import { ObjectQLPlugin, IObjectQL } from '@objectql/types';
+
+export interface RedisDriverPluginConfig {
+    /** Name of the datasource (e.g., 'default', 'cache') */
+    name: string;
+    /** Redis connection configuration */
+    config: RedisDriverConfig;
+}
+
+export function createRedisDriverPlugin(options: RedisDriverPluginConfig): ObjectQLPlugin {
+    return {
+        name: `redis-driver:${options.name}`,
+        setup(app: IObjectQL) {
+            const driver = new RedisDriver(options.config);
+            app.registerDatasource(options.name, driver);
+        }
+    };
+}

packages/drivers/sdk/src/index.ts

@@ -428,3 +428,48 @@ export class MetadataApiClient implements IMetadataApiClient {
         );
     }
 }
+
+/**
+ * SDK Driver Plugin for ObjectQL
+ * 
+ * A plugin wrapper that registers an SDK driver as a datasource in ObjectQL.
+ * This follows the @objectstack/spec plugin protocol.
+ * 
+ * @example
+ * ```typescript
+ * import { ObjectQL } from '@objectql/core';
+ * import { createSdkDriverPlugin } from '@objectql/driver-sdk';
+ * 
+ * const app = new ObjectQL({
+ *   plugins: [
+ *     createSdkDriverPlugin({
+ *       name: 'remote',
+ *       config: {
+ *         baseUrl: 'https://api.example.com',
+ *         apiKey: 'your-api-key'
+ *       }
+ *     })
+ *   ]
+ * });
+ * 
+ * await app.init();
+ * ```
+ */
+import { ObjectQLPlugin, IObjectQL } from '@objectql/types';
+
+export interface SdkDriverPluginConfig {
+    /** Name of the datasource (e.g., 'remote', 'api') */
+    name: string;
+    /** SDK driver configuration */
+    config: DataApiClientConfig;
+}
+
+export function createSdkDriverPlugin(options: SdkDriverPluginConfig): ObjectQLPlugin {
+    return {
+        name: `sdk-driver:${options.name}`,
+        setup(app: IObjectQL) {
+            const driver = new DataApiClient(options.config);
+            app.registerDatasource(options.name, driver);
+        }
+    };
+}

packages/drivers/sql/src/index.ts

@@ -837,3 +837,49 @@ export class SqlDriver implements Driver {
  * @deprecated Use SqlDriver instead.
  */
 export { SqlDriver as KnexDriver };
+
+/**
+ * SQL Driver Plugin for ObjectQL
+ * 
+ * A plugin wrapper that registers an SQL driver as a datasource in ObjectQL.
+ * This follows the @objectstack/spec plugin protocol.
+ * 
+ * @example
+ * ```typescript
+ * import { ObjectQL } from '@objectql/core';
+ * import { createSqlDriverPlugin } from '@objectql/driver-sql';
+ * 
+ * const app = new ObjectQL({
+ *   plugins: [
+ *     createSqlDriverPlugin({
+ *       name: 'default',
+ *       config: {
+ *         client: 'sqlite3',
+ *         connection: { filename: ':memory:' },
+ *         useNullAsDefault: true
+ *       }
+ *     })
+ *   ]
+ * });
+ * 
+ * await app.init();
+ * ```
+ */
+import { ObjectQLPlugin, IObjectQL } from '@objectql/types';
+
+export interface SqlDriverPluginConfig {
+    /** Name of the datasource (e.g., 'default', 'analytics') */
+    name: string;
+    /** Knex configuration */
+    config: any;
+}
+
+export function createSqlDriverPlugin(options: SqlDriverPluginConfig): ObjectQLPlugin {
+    return {
+        name: `sql-driver:${options.name}`,
+        setup(app: IObjectQL) {
+            const driver = new SqlDriver(options.config);
+            app.registerDatasource(options.name, driver);
+        }
+    };
+}