Refactor core to delegate to kernel managers (partial - types need alignment)

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

Author: Copilot

packages/foundation/core/src/app.ts

@@ -24,12 +24,6 @@ import {
 import { ObjectStackKernel, type RuntimePlugin } from '@objectstack/runtime';
 import { ObjectRepository } from './repository';
 import { ObjectQLPlugin } from './plugin';
-// import { createDriverFromConnection } from './driver'; // REMOVE THIS
-
-// import { loadRemoteFromUrl } from './remote';
-import { executeActionHelper, registerActionHelper, ActionEntry } from './action';
-import { registerHookHelper, triggerHookHelper, HookEntry } from './hook';
-import { registerObjectHelper, getConfigsHelper } from './object';
 import { convertIntrospectedSchemaToObjects } from './util';
 
 /**
@@ -39,11 +33,13 @@ import { convertIntrospectedSchemaToObjects } from './util';
  * to provide the plugin architecture.
  */
 export class ObjectQL implements IObjectQL {
-    public metadata: MetadataRegistry;
+    // Delegate to kernel for metadata, hooks, and actions
+    public get metadata(): MetadataRegistry {
+        return this.kernel.metadata;
+    }
+    
     private datasources: Record<string, Driver> = {};
     private remotes: string[] = [];
-    private hooks: Record<string, HookEntry[]> = {};
-    private actions: Record<string, ActionEntry> = {};
 
     // ObjectStack Kernel Integration
     private kernel!: ObjectStackKernel;
@@ -54,9 +50,7 @@ export class ObjectQL implements IObjectQL {
 
     constructor(config: ObjectQLConfig) {
         this.config = config;
-        this.metadata = config.registry || new MetadataRegistry();
         this.datasources = config.datasources || {};
-        // this.remotes = config.remotes || [];
 
         if (config.connection) {
              throw new Error("Connection strings are not supported in core directly. Use @objectql/platform-node's createDriverFromConnection or pass a driver instance to 'datasources'.");
@@ -75,42 +69,54 @@ export class ObjectQL implements IObjectQL {
                 }
             }
         }
+        
+        // Create the kernel
+        this.kernel = new ObjectStackKernel(this.kernelPlugins);
+        
+        // Register initial metadata if provided
+        if (config.registry) {
+            // Copy metadata from provided registry to kernel's registry
+            for (const type of config.registry.getTypes()) {
+                for (const item of config.registry.list(type)) {
+                    this.kernel.metadata.register(type, {
+                        type,
+                        id: (item as any).name || (item as any).id,
+                        content: item
+                    });
+                }
+            }
+        }
     }
 
     use(plugin: RuntimePlugin) {
         this.kernelPlugins.push(plugin);
     }
 
     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];
-            }
-        }
+        // Delegate to kernel managers
+        this.kernel.metadata.unregisterPackage(name);
+        this.kernel.hooks.removePackage(name);
+        this.kernel.actions.removePackage(name);
     }
 
     on(event: HookName, objectName: string, handler: HookHandler, packageName?: string) {
-        registerHookHelper(this.hooks, event, objectName, handler, packageName);
+        // Delegate to kernel hook manager
+        this.kernel.hooks.register(event, objectName, handler, packageName);
     }
 
     async triggerHook(event: HookName, objectName: string, ctx: HookContext) {
-        await triggerHookHelper(this.metadata, this.hooks, event, objectName, ctx);
+        // Delegate to kernel hook manager
+        await this.kernel.hooks.trigger(event, objectName, ctx);
     }
 
     registerAction(objectName: string, actionName: string, handler: ActionHandler, packageName?: string) {
-        registerActionHelper(this.actions, objectName, actionName, handler, packageName);
+        // Delegate to kernel action manager
+        this.kernel.actions.register(objectName, actionName, handler, packageName);
     }
 
     async executeAction(objectName: string, actionName: string, ctx: ActionContext) {
-        return await executeActionHelper(this.metadata, this.actions, objectName, actionName, ctx);
+        // Delegate to kernel action manager
+        return await this.kernel.actions.execute(objectName, actionName, ctx);
     }
 
     createContext(options: ObjectQLContextOptions): ObjectQLContext {
@@ -174,19 +180,36 @@ export class ObjectQL implements IObjectQL {
     }
 
     registerObject(object: ObjectConfig) {
-        registerObjectHelper(this.metadata, object);
+        // Normalize fields
+        if (object.fields) {
+            for (const [key, field] of Object.entries(object.fields)) {
+                if (!field.name) {
+                    field.name = key;
+                }
+            }
+        }
+        this.kernel.metadata.register('object', {
+            type: 'object',
+            id: object.name,
+            content: object
+        });
     }
 
     unregisterObject(name: string) {
-        this.metadata.unregister('object', name);
+        this.kernel.metadata.unregister('object', name);
     }
 
     getObject(name: string): ObjectConfig | undefined {
-        return this.metadata.get<ObjectConfig>('object', name);
+        return this.kernel.metadata.get<ObjectConfig>('object', name);
     }
 
     getConfigs(): Record<string, ObjectConfig> {
-        return getConfigsHelper(this.metadata);
+        const result: Record<string, ObjectConfig> = {};
+        const objects = this.kernel.metadata.list<ObjectConfig>('object');
+        for (const obj of objects) {
+            result[obj.name] = obj;
+        }
+        return result;
     }
 
     datasource(name: string): Driver {
@@ -247,8 +270,8 @@ export class ObjectQL implements IObjectQL {
     async init() {
         console.log('[ObjectQL] Initializing with ObjectStackKernel...');
 
-        // Create the kernel instance with all collected plugins
-        this.kernel = new ObjectStackKernel(this.kernelPlugins);
+        // Start the kernel - this will install and start all plugins
+        await this.kernel.start();
 
         // TEMPORARY: Set driver for backward compatibility during migration
         // This allows the kernel mock to delegate to the driver
@@ -258,9 +281,6 @@ export class ObjectQL implements IObjectQL {
                 (this.kernel as any).setDriver(defaultDriver);
             }
         }
-        
-        // Start the kernel - this will install and start all plugins
-        await this.kernel.start();
 
         // Load In-Memory Objects (Dynamic Layer)
         if (this.config.objects) {
@@ -269,7 +289,7 @@ export class ObjectQL implements IObjectQL {
             }
         }
 
-        const objects = this.metadata.list<ObjectConfig>('object');
+        const objects = this.kernel.metadata.list<ObjectConfig>('object');
 
         // Init Datasources
         // Let's pass all objects to all configured drivers.
@@ -287,7 +307,7 @@ export class ObjectQL implements IObjectQL {
     }
 
     private async processInitialData() {
-        const dataEntries = this.metadata.list<any>('data');
+        const dataEntries = this.kernel.metadata.list<any>('data');
         if (dataEntries.length === 0) return;
 
         console.log(`Processing ${dataEntries.length} initial data files...`);

packages/objectstack/runtime/src/metadata.ts

@@ -19,34 +19,40 @@ export interface MetadataItem {
     content: any;
     /** Package name this metadata belongs to */
     packageName?: string;
+    /** Optional path to the metadata source file */
+    path?: string;
+    /** Alternative package name field for compatibility */
+    package?: string;
 }
 
 /**
  * Metadata Registry
  * Central registry for all metadata in the ObjectStack ecosystem
  */
 export class MetadataRegistry {
-    private items: Map<string, Map<string, MetadataItem>> = new Map();
+    // Expose store for compatibility
+    public store: Map<string, Map<string, MetadataItem>> = new Map();
     private packages: Map<string, string[]> = new Map();
 
     /**
      * Register a metadata item
      */
     register(type: string, item: MetadataItem): void {
-        if (!this.items.has(type)) {
-            this.items.set(type, new Map());
+        if (!this.store.has(type)) {
+            this.store.set(type, new Map());
         }
 
-        const typeMap = this.items.get(type)!;
+        const typeMap = this.store.get(type)!;
         typeMap.set(item.id, item);
 
-        // Track package association
-        if (item.packageName) {
-            if (!this.packages.has(item.packageName)) {
-                this.packages.set(item.packageName, []);
+        // Track package association (support both packageName and package fields)
+        const pkgName = item.packageName || item.package;
+        if (pkgName) {
+            if (!this.packages.has(pkgName)) {
+                this.packages.set(pkgName, []);
             }
             const key = `${type}:${item.id}`;
-            const packageItems = this.packages.get(item.packageName)!;
+            const packageItems = this.packages.get(pkgName)!;
             if (!packageItems.includes(key)) {
                 packageItems.push(key);
             }
@@ -57,7 +63,7 @@ export class MetadataRegistry {
      * Get a specific metadata item
      */
     get<T = any>(type: string, id: string): T | undefined {
-        const typeMap = this.items.get(type);
+        const typeMap = this.store.get(type);
         if (!typeMap) return undefined;
 
         const item = typeMap.get(id);
@@ -68,7 +74,7 @@ export class MetadataRegistry {
      * List all items of a specific type
      */
     list<T = any>(type: string): T[] {
-        const typeMap = this.items.get(type);
+        const typeMap = this.store.get(type);
         if (!typeMap) return [];
 
         return Array.from(typeMap.values()).map(item => item.content as T);
@@ -78,26 +84,48 @@ export class MetadataRegistry {
      * Check if a metadata item exists
      */
     has(type: string, id: string): boolean {
-        const typeMap = this.items.get(type);
+        const typeMap = this.store.get(type);
         return typeMap?.has(id) ?? false;
     }
 
     /**
      * Unregister a specific item
      */
     unregister(type: string, id: string): void {
-        const typeMap = this.items.get(type);
+        const typeMap = this.store.get(type);
         if (typeMap) {
             typeMap.delete(id);
         }
     }
 
+    /**
+     * Get the full metadata entry (not just content)
+     */
+    getEntry(type: string, id: string): MetadataItem | undefined {
+        const typeMap = this.store.get(type);
+        return typeMap ? typeMap.get(id) : undefined;
+    }
+
     /**
      * Unregister all items from a package
      */
     unregisterPackage(packageName: string): void {
         const items = this.packages.get(packageName);
-        if (!items) return;
+        if (!items) {
+            // Also try to find by scanning all entries (for compatibility)
+            for (const [type, typeMap] of this.store.entries()) {
+                const entriesToDelete: string[] = [];
+                for (const [id, item] of typeMap.entries()) {
+                    if (item.package === packageName || item.packageName === packageName) {
+                        entriesToDelete.push(id);
+                    }
+                }
+                for (const id of entriesToDelete) {
+                    typeMap.delete(id);
+                }
+            }
+            return;
+        }
 
         for (const key of items) {
             const [type, id] = key.split(':');
@@ -111,14 +139,14 @@ export class MetadataRegistry {
      * Clear all metadata
      */
     clear(): void {
-        this.items.clear();
+        this.store.clear();
         this.packages.clear();
     }
 
     /**
      * Get all types
      */
     getTypes(): string[] {
-        return Array.from(this.items.keys());
+        return Array.from(this.store.keys());
     }
 }