@objectql/core 1.0.0 → 1.2.0

package/src/index.ts

@@ -1,59 +1,208 @@
-import * as path from 'path';
-
-export * from './metadata';
-export * from './types';
-export * from './driver';
-export * from './repository';
-export * from './query';
-
-import { ObjectConfig } from './metadata';
-import { ObjectQLContext, ObjectQLContextOptions, IObjectQL, ObjectQLConfig } from './types';
+import { 
+    ObjectRegistry, 
+    Driver, 
+    ObjectConfig, 
+    ObjectQLContext, 
+    ObjectQLContextOptions, 
+    IObjectQL, 
+    ObjectQLConfig,
+    ObjectQLPlugin,
+    HookName,
+    HookHandler,
+    HookContext,
+    ActionHandler,
+    ActionContext
+} from '@objectql/types';
+import { ObjectLoader } from './loader';
+export * from './loader';
 import { ObjectRepository } from './repository';
-import { Driver } from './driver';
-import { loadObjectConfigs } from './loader';
 
 export class ObjectQL implements IObjectQL {
-    private objects: Record<string, ObjectConfig> = {};
+    public metadata: ObjectRegistry;
+    private loader: ObjectLoader;
     private datasources: Record<string, Driver> = {};
+    private hooks: Record<string, Array<{ objectName: string, handler: HookHandler, packageName?: string }>> = {};
+    private actions: Record<string, { handler: ActionHandler, packageName?: string }> = {};
+    private pluginsList: ObjectQLPlugin[] = [];
 
     constructor(config: ObjectQLConfig) {
-        this.datasources = config.datasources;
+        this.metadata = config.registry || new ObjectRegistry();
+        this.loader = new ObjectLoader(this.metadata);
+        this.datasources = config.datasources || {};
+        
+        if (config.connection) {
+            this.loadDriverFromConnection(config.connection);
+        }
+
+        // 1. Load Presets/Packages first (Base Layer)
+        if (config.packages) {
+            for (const name of config.packages) {
+                this.addPackage(name);
+            }
+        }
+        if (config.presets) {
+            for (const name of config.presets) {
+                this.addPackage(name);
+            }
+        }
+        
+        if (config.plugins) {
+            for (const plugin of config.plugins) {
+                if (typeof plugin === 'string') {
+                    this.loadPluginFromPackage(plugin);
+                } else {
+                    this.use(plugin);
+                }
+            }
+        }
+
+        // 2. Load Local Sources (Application Layer - can override presets)
+        if (config.source) {
+            const sources = Array.isArray(config.source) ? config.source : [config.source];
+            for (const src of sources) {
+                this.loader.load(src);
+            }
+        }
+
+        // 3. Load In-Memory Objects (Dynamic Layer - highest priority)
         if (config.objects) {
             for (const [key, obj] of Object.entries(config.objects)) {
                 this.registerObject(obj);
             }
         }
-        if (config.packages) {
-            for (const name of config.packages) {
-                try {
-                    this.loadFromPackage(name);
-                } catch (e) {
-                    this.loadFromDirectory(name);
-                }
+    }
+
+    private loadPluginFromPackage(packageName: string) {
+        let mod: any;
+        try {
+            const modulePath = require.resolve(packageName, { paths: [process.cwd()] });
+            mod = require(modulePath);
+        } catch (e) {
+            throw new Error(`Failed to resolve plugin '${packageName}': ${e}`);
+        }
+
+        // Helper to find plugin instance
+        const findPlugin = (candidate: any): ObjectQLPlugin | undefined => {
+             if (!candidate) return undefined;
+             
+             // 1. Try treating as Class
+             if (typeof candidate === 'function') {
+                 try {
+                     const inst = new candidate();
+                     if (inst && typeof inst.setup === 'function') {
+                         return inst; // Found it!
+                     }
+                 } catch (e) {
+                     // Not a constructor or instantiation failed
+                 }
+             }
+
+             // 2. Try treating as Instance
+             if (candidate && typeof candidate.setup === 'function') {
+                 if (candidate.name) return candidate;
+             }
+             return undefined;
+        };
+
+        // Search in default, module root, and all named exports
+        let instance = findPlugin(mod.default) || findPlugin(mod);
+        
+        if (!instance && mod && typeof mod === 'object') {
+            for (const key of Object.keys(mod)) {
+                if (key === 'default') continue;
+                instance = findPlugin(mod[key]);
+                if (instance) break;
             }
         }
+
+        if (instance) {
+            (instance as any)._packageName = packageName;
+            this.use(instance);
+        } else {
+            console.error(`[PluginLoader] Failed to find ObjectQLPlugin in '${packageName}'. Exports:`, Object.keys(mod));
+            throw new Error(`Plugin '${packageName}' must export a class or object implementing ObjectQLPlugin.`);
+        }
+    }
+
+    addPackage(name: string) {
+        this.loader.loadPackage(name);
     }
 
-    loadFromPackage(name: string) {
-        const entryPath = require.resolve(name, { paths: [process.cwd()] });
-        const packageDir = path.dirname(entryPath);
-        this.loadFromDirectory(packageDir);
+    use(plugin: ObjectQLPlugin) {
+        this.pluginsList.push(plugin);
     }
 
-    loadFromDirectory(dir: string) {
-        const objects = loadObjectConfigs(dir);
-        for (const obj of Object.values(objects)) {
-            this.registerObject(obj);
+    removePackage(name: string) {
+        this.metadata.unregisterPackage(name);
+        
+        // Remove hooks
+        for (const event of Object.keys(this.hooks)) {
+            this.hooks[event] = this.hooks[event].filter(h => h.packageName !== name);
+        }
+        
+        // Remove actions
+        for (const key of Object.keys(this.actions)) {
+            if (this.actions[key].packageName === name) {
+                delete this.actions[key];
+            }
         }
     }
 
+    on(event: HookName, objectName: string, handler: HookHandler, packageName?: string) {
+        if (!this.hooks[event]) {
+            this.hooks[event] = [];
+        }
+        this.hooks[event].push({ objectName, handler, packageName });
+    }
+
+    async triggerHook(event: HookName, objectName: string, ctx: HookContext) {
+        // 1. Registry Hooks (File-based)
+        const fileHooks = this.metadata.get<any>('hook', objectName);
+        if (fileHooks && typeof fileHooks[event] === 'function') {
+            await fileHooks[event](ctx);
+        }
+
+        // 2. Programmatic Hooks
+        const hooks = this.hooks[event] || [];
+        for (const hook of hooks) {
+            if (hook.objectName === '*' || hook.objectName === objectName) {
+                await hook.handler(ctx);
+            }
+        }
+    }
+
+    registerAction(objectName: string, actionName: string, handler: ActionHandler, packageName?: string) {
+        const key = `${objectName}:${actionName}`;
+        this.actions[key] = { handler, packageName };
+    }
+
+    async executeAction(objectName: string, actionName: string, ctx: ActionContext) {
+        // 1. Programmatic
+        const key = `${objectName}:${actionName}`;
+        const actionEntry = this.actions[key];
+        if (actionEntry) {
+            return await actionEntry.handler(ctx);
+        }
+
+        // 2. Registry (File-based)
+        const fileActions = this.metadata.get<any>('action', objectName);
+        if (fileActions && typeof fileActions[actionName] === 'function') {
+            return await fileActions[actionName](ctx);
+        }
+
+        throw new Error(`Action '${actionName}' not found for object '${objectName}'`);
+    }
+
+    loadFromDirectory(dir: string, packageName?: string) {
+        this.loader.load(dir, packageName);
+    }
+
     createContext(options: ObjectQLContextOptions): ObjectQLContext {
         const ctx: ObjectQLContext = {
             userId: options.userId,
             spaceId: options.spaceId,
             roles: options.roles || [],
             isSystem: options.isSystem,
-            ignoreTriggers: options.ignoreTriggers,
             object: (name: string) => {
                 return new ObjectRepository(name, ctx, this);
             },
@@ -67,14 +216,12 @@ export class ObjectQL implements IObjectQL {
                  try {
                      trx = await driver.beginTransaction();
                  } catch (e) {
-                     // If beginTransaction fails, fail.
                      throw e;
                  }
 
                  const trxCtx: ObjectQLContext = {
                      ...ctx,
                      transactionHandle: trx,
-                     // Nested transaction simply reuses the current one (flat transaction)
                      transaction: async (cb) => cb(trxCtx)
                  };
 
@@ -103,15 +250,28 @@ export class ObjectQL implements IObjectQL {
                 }
             }
         }
-        this.objects[object.name] = object;
+        this.metadata.register('object', {
+            type: 'object',
+            id: object.name,
+            content: object
+        });
+    }
+
+    unregisterObject(name: string) {
+        this.metadata.unregister('object', name);
     }
 
     getObject(name: string): ObjectConfig | undefined {
-        return this.objects[name];
+        return this.metadata.get<ObjectConfig>('object', name);
     }
 
     getConfigs(): Record<string, ObjectConfig> {
-        return this.objects;
+        const result: Record<string, ObjectConfig> = {};
+        const objects = this.metadata.list<ObjectConfig>('object');
+        for (const obj of objects) {
+            result[obj.name] = obj;
+        }
+        return result;
     }
 
     datasource(name: string): Driver {
@@ -123,27 +283,97 @@ export class ObjectQL implements IObjectQL {
     }
 
     async init() {
-        const ctx = this.createContext({ isSystem: true });
-        for (const objectName in this.objects) {
-            const obj = this.objects[objectName];
-            if (obj.data && obj.data.length > 0) {
-                console.log(`Initializing data for object ${objectName}...`);
-                const repo = ctx.object(objectName);
-                for (const record of obj.data) {
-                    try {
-                        if (record._id) {
-                             const existing = await repo.findOne(record._id);
-                             if (existing) {
-                                 continue;
-                             }
+        // 0. Init Plugins
+        for (const plugin of this.pluginsList) {
+            console.log(`Initializing plugin '${plugin.name}'...`);
+            
+            let app: IObjectQL = this;
+            const pkgName = (plugin as any)._packageName;
+
+            if (pkgName) {
+                app = new Proxy(this, {
+                    get(target, prop) {
+                        if (prop === 'on') {
+                            return (event: HookName, obj: string, handler: HookHandler) => 
+                                target.on(event, obj, handler, pkgName);
+                        }
+                        if (prop === 'registerAction') {
+                            return (obj: string, act: string, handler: ActionHandler) => 
+                                target.registerAction(obj, act, handler, pkgName);
                         }
-                        await repo.create(record);
-                        console.log(`Inserted init data for ${objectName}: ${record._id || 'unknown id'}`);
-                    } catch (e) {
-                        console.error(`Failed to insert init data for ${objectName}:`, e);
+                        const value = (target as any)[prop];
+                        return typeof value === 'function' ? value.bind(target) : value;
                     }
-                }
+                });
+            }
+
+            await plugin.setup(app);
+        }
+
+        const objects = this.metadata.list<ObjectConfig>('object');
+        
+        // 1. Init Drivers (e.g. Sync Schema)
+        // 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);
             }
         }
     }
+
+    private loadDriverFromConnection(connection: string) {
+        let driverPackage = '';
+        let driverClass = '';
+        let driverConfig: any = {};
+        
+        if (connection.startsWith('mongodb://')) {
+            driverPackage = '@objectql/driver-mongo';
+            driverClass = 'MongoDriver';
+            driverConfig = { url: connection };
+        } 
+        else if (connection.startsWith('sqlite://')) {
+            driverPackage = '@objectql/driver-knex';
+            driverClass = 'KnexDriver';
+            const filename = connection.replace('sqlite://', '');
+            driverConfig = {
+                client: 'sqlite3',
+                connection: { filename },
+                useNullAsDefault: true
+            };
+        }
+        else if (connection.startsWith('postgres://') || connection.startsWith('postgresql://')) {
+            driverPackage = '@objectql/driver-knex';
+            driverClass = 'KnexDriver';
+            driverConfig = {
+                client: 'pg',
+                connection: connection
+            };
+        }
+        else if (connection.startsWith('mysql://')) {
+            driverPackage = '@objectql/driver-knex';
+            driverClass = 'KnexDriver';
+            driverConfig = {
+                client: 'mysql2',
+                connection: connection
+            };
+        }
+        else {
+            throw new Error(`Unsupported connection protocol: ${connection}`);
+        }
+
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const pkg = require(driverPackage);
+            const DriverClass = pkg[driverClass];
+            if (!DriverClass) {
+                throw new Error(`${driverClass} not found in ${driverPackage}`);
+            }
+            this.datasources['default'] = new DriverClass(driverConfig);
+        } catch (e: any) {
+            throw new Error(`Failed to load driver ${driverPackage}. Please install it: npm install ${driverPackage}. Error: ${e.message}`);
+        }
+    }
 }
+
+export * from './repository';