Refactor ObjectQL and Plugin architecture; add service registration methods and update dependencies

Author: hotlong

packages/core/src/kernel.ts

@@ -50,6 +50,9 @@ export class ObjectKernel {
                 await handler(...args);
             }
         },
+        getServices: () => {
+             return new Map(this.services);
+        },
         logger: console,
         getKernel: () => this,
     };

packages/core/src/types.ts

@@ -25,6 +25,11 @@ export interface PluginContext {
      */
     getService<T>(name: string): T;
 
+    /**
+     * Get all registered services
+     */
+    getServices(): Map<string, any>;
+
     /**
      * Register a hook handler
      * @param name - Hook name (e.g., 'kernel:ready', 'data:beforeInsert')

packages/objectql/package.json

@@ -9,6 +9,7 @@
     "test": "vitest"
   },
   "dependencies": {
+    "@objectstack/core": "workspace:*",
     "@objectstack/spec": "workspace:*",
     "@objectstack/types": "workspace:*"
   },

packages/objectql/src/app-manifest-plugin.ts

@@ -1,8 +1,4 @@
-import { Plugin, PluginContext } from './plugin'; // Import local minimal context or from core if available?
-// Actually ObjectQL probably hasn't added @objectstack/core as dependency yet properly or local imports are preferred.
-// Let's use internal types where possible if they exist, OR ensure @objectstack/core is in package.json
-// But wait, objectql/src/plugin.ts defines PluginContext locally to avoid circular dep?
-// Let's check objectql/package.json
+import { Plugin, PluginContext } from '@objectstack/core';
 import { SchemaRegistry, ObjectQL } from './index';
 
 /**
@@ -38,40 +34,13 @@ export class AppManifestPlugin implements Plugin {
         const sys = this.manifest.manifest || this.manifest;
         ctx.logger.log(`[AppManifestPlugin] Loading App Manifest: ${sys.id || sys.name}`);
 
-        // Register the app/plugin in the schema registry
-        SchemaRegistry.registerPlugin(sys);
-        
-        // Register all objects defined in the manifest
-        if (this.manifest.objects) {
-            for (const obj of this.manifest.objects) {
-                SchemaRegistry.registerObject(obj);
-                ctx.logger.log(`[AppManifestPlugin] Registered Object: ${obj.name}`);
-            }
-        }
+        // Register the app manifest as a service
+        const serviceName = `app.${sys.id || sys.name}`;
+        ctx.registerService(serviceName, this.manifest);
+        ctx.logger.log(`[AppManifestPlugin] Registered App service: ${serviceName}`);
     }
 
     async start(ctx: PluginContext) {
-        // Seed data if provided
-        if (this.manifest.data && Array.isArray(this.manifest.data)) {
-            const sys = this.manifest.manifest || this.manifest;
-            ctx.logger.log(`[AppManifestPlugin] Seeding data for ${sys.name || sys.id}...`);
-            
-            const objectql = ctx.getService<ObjectQL>('objectql');
-            
-            for (const seed of this.manifest.data) {
-                try {
-                    // Check if data already exists
-                    const existing = await objectql.find(seed.object, { top: 1 });
-                    if (existing.length === 0) {
-                        ctx.logger.log(`[AppManifestPlugin] Inserting ${seed.records.length} records into ${seed.object}`);
-                        for (const record of seed.records) {
-                            await objectql.insert(seed.object, record);
-                        }
-                    }
-                } catch (e) {
-                    ctx.logger.warn(`[AppManifestPlugin] Failed to seed ${seed.object}`, e);
-                }
-            }
-        }
+        // Data seeding logic will be handled by the engine when it detects the app
     }
 }

packages/objectql/src/driver-plugin.ts

@@ -1,4 +1,4 @@
-import { Plugin, PluginContext } from './plugin';
+import { Plugin, PluginContext } from '@objectstack/core';
 
 /**
  * Driver Plugin
@@ -27,12 +27,10 @@ export class DriverPlugin implements Plugin {
     }
 
     async init(ctx: PluginContext) {
-        // Get ObjectQL service
-        const objectql = ctx.getService<any>('objectql');
-        
-        // Register driver
-        objectql.registerDriver(this.driver);
-        ctx.logger.log(`[DriverPlugin] Registered driver: ${this.driver.name || 'unknown'}`);
+        // Register driver as a service instead of directly to objectql
+        const serviceName = `driver.${this.driver.name || 'unknown'}`;
+        ctx.registerService(serviceName, this.driver);
+        ctx.logger.log(`[DriverPlugin] Registered driver service: ${serviceName}`);
     }
 
     async start(ctx: PluginContext) {

packages/objectql/src/index.ts

@@ -50,42 +50,7 @@ export class ObjectQL implements IDataEngine {
   async use(manifestPart: any, runtimePart?: any) {
     // 1. Validate / Register Manifest
     if (manifestPart) {
-      // 1. Handle Module Imports (commonjs/esm interop)
-      // If the passed object is a module namespace with a default export, use that.
-      const manifest = manifestPart.default || manifestPart;
-
-      // In a real scenario, we might strictly parse this using Zod
-      // For now, simple ID check
-      const id = manifest.id || manifest.name;
-      if (!id) {
-        console.warn(`[ObjectQL] Plugin manifest missing ID (keys: ${Object.keys(manifest)})`, manifest);
-        // Don't return, try to proceed if it looks like an App (Apps might use 'name' instead of 'id')
-        // return; 
-      }
-      
-      console.log(`[ObjectQL] Loading Plugin: ${id}`);
-      SchemaRegistry.registerPlugin(manifest as ObjectStackManifest);
-
-      // Register Objects from App/Plugin
-      if (manifest.objects) {
-        for (const obj of manifest.objects) {
-            // Ensure object name is registered globally
-            SchemaRegistry.registerObject(obj);
-            console.log(`[ObjectQL] Registered Object: ${obj.name}`);
-        }
-      }
-
-      // Register contributions
-       if (manifest.contributes?.kinds) {
-          for (const kind of manifest.contributes.kinds) {
-            SchemaRegistry.registerKind(kind);
-          }
-       }
-
-       // Register Data Seeding (Lazy execution or immediate?)
-       // We store it in a temporary registry or execute immediately if engine is ready.
-       // Since `use` is init time, we might need to store it and run later in `seed()`.
-       // For this MVP, let's attach it to the manifest object in registry so Kernel can find it.
+      this.registerApp(manifestPart);
     }
 
     // 2. Execute Runtime
@@ -128,6 +93,44 @@ export class ObjectQL implements IDataEngine {
     }
   }
 
+  registerApp(manifestPart: any) {
+      // 1. Handle Module Imports (commonjs/esm interop)
+      // If the passed object is a module namespace with a default export, use that.
+      const raw = manifestPart.default || manifestPart;
+      
+      // Support nested manifest property (Stack Definition)
+      // We merge the inner manifest metadata (id, version, etc) with the outer container (objects, apps)
+      const manifest = raw.manifest ? { ...raw, ...raw.manifest } : raw;
+
+      // In a real scenario, we might strictly parse this using Zod
+      // For now, simple ID check
+      const id = manifest.id || manifest.name;
+      if (!id) {
+        console.warn(`[ObjectQL] Plugin manifest missing ID (keys: ${Object.keys(manifest)})`, manifest);
+        // Don't return, try to proceed if it looks like an App (Apps might use 'name' instead of 'id')
+        // return; 
+      }
+      
+      console.log(`[ObjectQL] Loading App: ${id}`);
+      SchemaRegistry.registerPlugin(manifest as ObjectStackManifest);
+
+      // Register Objects from App/Plugin
+      if (manifest.objects) {
+        for (const obj of manifest.objects) {
+            // Ensure object name is registered globally
+            SchemaRegistry.registerObject(obj);
+            console.log(`[ObjectQL] Registered Object: ${obj.name}`);
+        }
+      }
+
+      // Register contributions
+       if (manifest.contributes?.kinds) {
+          for (const kind of manifest.contributes.kinds) {
+            SchemaRegistry.registerKind(kind);
+          }
+       }
+  }
+
   /**
    * Register a new storage driver
    */

packages/objectql/src/plugin.ts

@@ -1,27 +1,10 @@
 import { ObjectQL } from './index';
 import { ObjectStackProtocolImplementation } from './protocol';
-// IObjectStackProtocol is used for type checking implicitly via ObjectStackProtocolImplementation contract
+import { Plugin, PluginContext } from '@objectstack/core';
 
-// Minimal Context interface to avoid circular dependency on @objectstack/runtime
-export interface PluginContext {
-    registerService(name: string, service: any): void;
-    getService<T>(name: string): T;
-    hook(name: string, handler: any): void;
-    trigger(name: string, ...args: any[]): Promise<void>;
-    logger: Console;
-    [key: string]: any;
-}
-
-export interface Plugin {
-    name: string;
-    version?: string;
-    dependencies?: string[];
-    init?: (ctx: PluginContext) => Promise<void> | void;
-    start?: (ctx: PluginContext) => Promise<void> | void;
-    destroy?: () => Promise<void> | void;
-}
+export type { Plugin, PluginContext };
 
-export class ObjectQLPlugin {
+export class ObjectQLPlugin implements Plugin {
   name = 'com.objectstack.engine.objectql';
   type = 'objectql' as const;
   version = '1.0.0';
@@ -58,5 +41,22 @@ export class ObjectQLPlugin {
 
   async start(ctx: PluginContext) {
     if(ctx.logger) ctx.logger.log(`[ObjectQLPlugin] ObjectQL engine initialized`);
+    
+    // Discover features from Kernel Services
+    if (ctx.getServices && this.ql) {
+        const services = ctx.getServices();
+        for (const [name, service] of services.entries()) {
+            if (name.startsWith('driver.')) {
+                 // Register Driver
+                 this.ql.registerDriver(service);
+                 if(ctx.logger) ctx.logger.log(`[ObjectQLPlugin] Discovered and registered driver service: ${name}`);
+            }
+            if (name.startsWith('app.')) {
+                // Register App
+                this.ql.registerApp(service); // service is Manifest
+                if(ctx.logger) ctx.logger.log(`[ObjectQLPlugin] Discovered and registered app service: ${name}`);
+            }
+        }
+    }
   }
 }