@objectql/core 4.0.2 → 4.0.4

package/src/app.ts

@@ -22,29 +22,35 @@ import {
     ActionContext,
     LoaderPlugin
 } from '@objectql/types';
-import { ObjectStackKernel, type RuntimePlugin } from '@objectql/runtime';
+import { ObjectKernel, type Plugin } from '@objectstack/core';
+import { ObjectQL as RuntimeObjectQL, SchemaRegistry } from '@objectstack/objectql';
 import { ObjectRepository } from './repository';
-import { ObjectQLPlugin } from './plugin';
 import { convertIntrospectedSchemaToObjects } from './util';
+import { CompiledHookManager } from './optimizations/CompiledHookManager';
 
 /**
  * ObjectQL
  * 
- * ObjectQL implementation that wraps ObjectStackKernel
+ * ObjectQL implementation that wraps ObjectKernel
  * to provide the plugin architecture.
  */
 export class ObjectQL implements IObjectQL {
     // Delegate to kernel for metadata, hooks, and actions
     public get metadata(): MetadataRegistry {
-        return this.kernel.metadata;
+        return (this.kernel as any).metadata;
     }
     
     private datasources: Record<string, Driver> = {};
     private remotes: string[] = [];
     
     // ObjectStack Kernel Integration
-    private kernel!: ObjectStackKernel;
-    private kernelPlugins: RuntimePlugin[] = [];
+    private kernel!: ObjectKernel & Record<string, any>;
+    private ql: any;
+    private kernelPlugins: any[] = [];
+    
+    // Optimized managers
+    private hookManager = new CompiledHookManager();
+    private localActions = new Map<string, any>();
     
     // Store config for lazy loading in init()
     private config: ObjectQLConfig;
@@ -57,10 +63,12 @@ export class ObjectQL implements IObjectQL {
              throw new Error("Connection strings are not supported in core directly. Use @objectql/platform-node's createDriverFromConnection or pass a driver instance to 'datasources'.");
         }
 
-        // Add the ObjectQL plugin to provide enhanced features
-        this.kernelPlugins.push(new ObjectQLPlugin({
-            datasources: this.datasources
-        }));
+        // Use the imported RuntimeObjectQL, assuming it works as intended
+        this.ql = new RuntimeObjectQL(); 
+
+        // Note: ObjectQLPlugin removed as it now uses RuntimePlugin interface
+        // which is incompatible with the legacy Plugin interface from @objectstack/core
+        // For new code, use the microkernel pattern with RuntimePlugin directly
         
         // Add runtime plugins from config
         if (config.plugins) {
@@ -68,13 +76,103 @@ export class ObjectQL implements IObjectQL {
                 if (typeof plugin === 'string') {
                     throw new Error("String plugins are not supported in core. Use @objectql/platform-node or pass plugin instance.");
                 } else {
-                    this.use(plugin);
+                    this.use(plugin as any);
                 }
             }
         }
         
-        // Create the kernel
-        this.kernel = new ObjectStackKernel(this.kernelPlugins);
+        // Create the kernel with registered plugins
+        this.kernel = new (ObjectKernel as any)();
+        for (const plugin of this.kernelPlugins) {
+             if ((this.kernel as any).use) {
+                 (this.kernel as any).use(plugin);
+             }
+        }
+
+        // Helper to unwrap content property (matching MetadataRegistry behavior)
+        const unwrapContent = (item: any) => {
+            if (item && item.content) {
+                return item.content;
+            }
+            return item;
+        };
+
+        // Stub legacy accessors
+        (this.kernel as any).metadata = {
+            register: (type: string, item: any) => SchemaRegistry.registerItem(type, item, item.id ? 'id' : 'name'),
+            get: (type: string, name: string) => {
+                const item = SchemaRegistry.getItem(type, name) as any;
+                return unwrapContent(item);
+            },
+            getEntry: (type: string, name: string) => SchemaRegistry.getItem(type, name),
+            list: (type: string) => {
+                const items = SchemaRegistry.listItems(type);
+                return items.map(unwrapContent);
+            },
+            unregister: (type: string, name: string) => {
+                 // Access private static storage using any cast
+                 const metadata = (SchemaRegistry as any).metadata;
+                 if (metadata instanceof Map) {
+                     const collection = metadata.get(type);
+                     if (collection instanceof Map) {
+                         collection.delete(name);
+                     }
+                 }
+            },
+            unregisterPackage: (packageName: string) => {
+                 const metadata = (SchemaRegistry as any).metadata;
+                 if (metadata instanceof Map) {
+                     for (const [type, collection] of metadata.entries()) {
+                         if (collection instanceof Map) {
+                             for (const [key, item] of collection.entries()) {
+                                 // console.log(`[App] Check ${type} ${key} pkg=${(item as any).package}`);
+                                 if ((item as any).package === packageName) {
+                                     collection.delete(key);
+                                 }
+                             }
+                         }
+                     }
+                 } else {
+                     console.warn('Metadata is not a Map');
+                 }
+            }
+        };
+        const kernelHooks = (this.kernel as any).hooks || {};
+        Object.assign(kernelHooks, {
+            register: (event: string, objectName: string, handler: any, packageName?: string) => {
+                this.hookManager.registerHook(event, objectName, handler, packageName);
+            },
+            removePackage: (packageName: string) => {
+                this.hookManager.removePackage(packageName);
+            },
+            trigger: async (event: string, objectName: string, ctx: any) => {
+                await this.hookManager.runHooks(event, objectName, ctx);
+            }
+        });
+        if (!(this.kernel as any).hooks) {
+            (this.kernel as any).hooks = kernelHooks;
+        }
+        (this.kernel as any).actions = {
+            register: (objectName: string, actionName: string, handler: any, packageName?: string) => {
+                const key = `${objectName}:${actionName}`;
+                (handler as any)._package = packageName;
+                this.localActions.set(key, handler);
+            },
+            removePackage: (packageName: string) => {
+                for (const [key, handler] of this.localActions.entries()) {
+                    if ((handler as any)._package === packageName) {
+                        this.localActions.delete(key);
+                    }
+                }
+            },
+            execute: async (objectName: string, actionName: string, ctx: any) => {
+                const handler = this.localActions.get(`${objectName}:${actionName}`);
+                if (handler) {
+                    return handler(ctx);
+                }
+                throw new Error(`Action '${actionName}' on object '${objectName}' not found`);
+            }
+        };
         
         // Register initial metadata if provided
         if (config.registry) {
@@ -87,7 +185,7 @@ export class ObjectQL implements IObjectQL {
                         ? (item as { name?: string; id?: string }).name || (item as { name?: string; id?: string }).id || 'unknown'
                         : 'unknown';
                     
-                    this.kernel.metadata.register(type, {
+                    (this.kernel as any).metadata.register(type, {
                         type,
                         id: itemId,
                         content: item
@@ -97,43 +195,46 @@ export class ObjectQL implements IObjectQL {
         }
     }
     
-    use(plugin: RuntimePlugin) {
+    use(plugin: Plugin) {
         this.kernelPlugins.push(plugin);
+        if (this.kernel && (this.kernel as any).use) {
+            (this.kernel as any).use(plugin);
+        }
     }
 
     removePackage(name: string) {
         // Delegate to kernel managers
-        this.kernel.metadata.unregisterPackage(name);
-        this.kernel.hooks.removePackage(name);
-        this.kernel.actions.removePackage(name);
+        (this.kernel as any).metadata.unregisterPackage(name);
+        (this.kernel as any).hooks.removePackage(name);
+        (this.kernel as any).actions.removePackage(name);
     }
 
     on(event: HookName, objectName: string, handler: HookHandler, packageName?: string) {
         // Delegate to kernel hook manager
         // We wrap the handler to bridge ObjectQL's rich context types with runtime's base types
         // The runtime HookContext supports all fields via index signature, so this is safe
-        const wrappedHandler = handler as unknown as import('../../../objectstack/runtime/dist').HookHandler;
-        this.kernel.hooks.register(event, objectName, wrappedHandler, packageName);
+        const wrappedHandler = handler as unknown as any;
+        (this.kernel as any).hooks.register(event, objectName, wrappedHandler, packageName);
     }
 
     async triggerHook(event: HookName, objectName: string, ctx: HookContext) {
         // Delegate to kernel hook manager
         // Runtime HookContext supports ObjectQL-specific fields via index signature
-        await this.kernel.hooks.trigger(event, objectName, ctx);
+        await (this.kernel as any).hooks.trigger(event, objectName, ctx);
     }
 
     registerAction(objectName: string, actionName: string, handler: ActionHandler, packageName?: string) {
         // Delegate to kernel action manager
         // We wrap the handler to bridge ObjectQL's rich context types with runtime's base types
         // The runtime ActionContext supports all fields via index signature, so this is safe
-        const wrappedHandler = handler as unknown as import('../../../objectstack/runtime/dist').ActionHandler;
-        this.kernel.actions.register(objectName, actionName, wrappedHandler, packageName);
+        const wrappedHandler = handler as unknown as any;
+        (this.kernel as any).actions.register(objectName, actionName, wrappedHandler, packageName);
     }
 
     async executeAction(objectName: string, actionName: string, ctx: ActionContext) {
         // Delegate to kernel action manager
         // Runtime ActionContext supports ObjectQL-specific fields via index signature
-        return await this.kernel.actions.execute(objectName, actionName, ctx);
+        return await (this.kernel as any).actions.execute(objectName, actionName, ctx);
     }
 
     createContext(options: ObjectQLContextOptions): ObjectQLContext {
@@ -181,15 +282,15 @@ export class ObjectQL implements IObjectQL {
     }
 
     /**
-     * Get the underlying ObjectStackKernel instance
+     * Get the underlying ObjectKernel instance
      * 
      * This provides access to the kernel for advanced usage scenarios
      * where you need direct access to the plugin architecture.
      * 
-     * @returns The ObjectStackKernel instance
+     * @returns The ObjectKernel instance
      * @throws Error if called before init()
      */
-    getKernel(): ObjectStackKernel {
+    getKernel(): ObjectKernel {
         if (!this.kernel) {
             throw new Error('Kernel not initialized. Call init() first.');
         }
@@ -205,26 +306,26 @@ export class ObjectQL implements IObjectQL {
                 }
             }
         }
-        this.kernel.metadata.register('object', {
-            type: 'object',
-            id: object.name,
-            content: object
-        });
+        (this.kernel as any).metadata.register('object', object);
     }
 
     unregisterObject(name: string) {
-        this.kernel.metadata.unregister('object', name);
+        (this.kernel as any).metadata.unregister('object', name);
     }
 
     getObject(name: string): ObjectConfig | undefined {
-        return this.kernel.metadata.get<ObjectConfig>('object', name);
+        const item = (this.kernel as any).metadata.get('object', name);
+        return item?.content || item;
     }
 
     getConfigs(): Record<string, ObjectConfig> {
         const result: Record<string, ObjectConfig> = {};
-        const items = this.kernel.metadata.list<ObjectConfig>('object');
+        const items = (this.kernel as any).metadata.list('object') || [];
         for (const item of items) {
-            result[item.name] = item;
+            const config = item.content || item;
+            if (config?.name) {
+                result[config.name] = config;
+            }
         }
         return result;
     }
@@ -285,20 +386,41 @@ export class ObjectQL implements IObjectQL {
     }
 
     async init() {
-        console.log('[ObjectQL] Initializing with ObjectStackKernel...');
+        console.log('[ObjectQL] Initializing with ObjectKernel...');
         
         // Start the kernel - this will install and start all plugins
-        await this.kernel.start();
+        if ((this.kernel as any).start) {
+            await (this.kernel as any).start();
+        } else if ((this.kernel as any).bootstrap) {
+            await (this.kernel as any).bootstrap();
+        } else {
+             console.warn('ObjectKernel does not have start() or bootstrap() method');
+        }
         
         // TEMPORARY: Set driver for backward compatibility during migration
         // This allows the kernel mock to delegate to the driver
+        const defaultDriver = this.datasources['default'];
         if (typeof (this.kernel as any).setDriver === 'function') {
-            const defaultDriver = this.datasources['default'];
             if (defaultDriver) {
                 (this.kernel as any).setDriver(defaultDriver);
             }
         }
 
+        // TEMPORARY: Patch kernel with CRUD methods dynamically if missing
+        // This ensures the repository can delegate to the kernel even if using the new @objectstack/core kernel
+        if (typeof (this.kernel as any).create !== 'function' && defaultDriver) {
+             (this.kernel as any).create = (object: string, doc: any, options: any) => defaultDriver.create(object, doc, options);
+             (this.kernel as any).update = (object: string, id: any, doc: any, options: any) => defaultDriver.update(object, id, doc, options);
+             (this.kernel as any).delete = (object: string, id: any, options: any) => defaultDriver.delete(object, id, options);
+             (this.kernel as any).find = async (object: string, query: any, options: any) => {
+                 const res = await defaultDriver.find(object, query, options);
+                 return { value: res || [], count: (res || []).length };
+             };
+             (this.kernel as any).findOne = (object: string, id: any, options: any) => defaultDriver.findOne(object, id, options);
+             (this.kernel as any).get = (object: string, id: any) => defaultDriver.findOne(object, id); 
+             (this.kernel as any).count = (object: string, query: any, options: any) => defaultDriver.count(object, query, options);
+        }
+
         // Load In-Memory Objects (Dynamic Layer)
         if (this.config.objects) {
             for (const [key, obj] of Object.entries(this.config.objects)) {
@@ -306,7 +428,8 @@ export class ObjectQL implements IObjectQL {
             }
         }
 
-        const objects = this.kernel.metadata.list<ObjectConfig>('object');
+        const registryItems = (this.kernel as any).metadata.list('object');
+        const objects = (registryItems || []).map((item: any) => item.content || item) as ObjectConfig[];
         
         // Init Datasources
         // Let's pass all objects to all configured drivers.
@@ -324,7 +447,7 @@ export class ObjectQL implements IObjectQL {
     }
 
     private async processInitialData() {
-        const dataEntries = this.kernel.metadata.list<any>('data');
+        const dataEntries = (this.kernel as any).metadata.list('data');
         if (dataEntries.length === 0) return;
 
         console.log(`Processing ${dataEntries.length} initial data files...`);
@@ -333,17 +456,20 @@ export class ObjectQL implements IObjectQL {
         const ctx = this.createContext({ isSystem: true });
 
         for (const entry of dataEntries) {
+            // Unwrapping metadata content if present
+            const dataContent = (entry as any).content || entry;
+
             // Expected format:
             // 1. { object: 'User', records: [...] }
             // 2. [ record1, record2 ] (with name property added by loader inferred from filename)
             
-            let objectName = entry.object;
-            let records = entry.records;
+            let objectName = dataContent.object;
+            let records = dataContent.records;
 
-            if (Array.isArray(entry)) {
-                records = entry;
-                if (!objectName && (entry as any).name) {
-                    objectName = (entry as any).name;
+            if (Array.isArray(dataContent)) {
+                records = dataContent;
+                if (!objectName && (dataContent as any).name) {
+                    objectName = (dataContent as any).name;
                 }
             }
 

package/src/index.ts

@@ -7,29 +7,28 @@
  */
 
 // Re-export types from @objectstack packages for API compatibility
-export type { ObjectStackKernel, ObjectStackRuntimeProtocol } from '@objectql/runtime';
+export type { ObjectKernel } from '@objectstack/runtime';
+export type { ObjectStackProtocolImplementation } from '@objectstack/objectql';
 // Note: @objectstack/objectql types temporarily commented out due to type incompatibilities
 // in the published package. Will be re-enabled when package is updated.
 // export type { ObjectQL as ObjectQLEngine, SchemaRegistry } from '@objectstack/objectql';
 
 // Export ObjectStack spec types for driver development
-import { Data, Driver } from '@objectstack/spec';
+import { Data, System } from '@objectstack/spec';
 export type QueryAST = Data.QueryAST;
-export type DriverInterface = Driver.DriverInterface;
-export type DriverOptions = Driver.DriverOptions;
+export type DriverInterface = Data.DriverInterface;
+export type DriverOptions = Data.DriverOptions;
 
 // Export our enhanced runtime components (actual implementations)
 export * from './repository';
 export * from './app';
 export * from './plugin';
-export * from './validator-plugin';
-export * from './formula-plugin';
 
 // Export query-specific modules (ObjectQL core competency)
 export * from './query';
 
 // Export utilities
-export * from './validator';
 export * from './util';
-export * from './ai-agent';
-export * from './formula-engine';
+
+// Export kernel optimizations
+export * from './optimizations';

package/src/optimizations/CompiledHookManager.ts

@@ -0,0 +1,185 @@
+/**
+ * ObjectQL
+ * Copyright (c) 2026-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * Hook definition
+ */
+export interface Hook {
+    pattern: string;
+    handler: (context: any) => Promise<void> | void;
+    packageName?: string;
+    priority?: number;
+}
+
+/**
+ * Compiled Hook Manager
+ * 
+ * Improvement: Pre-compiles hook pipelines by event pattern at registration time.
+ * No runtime pattern matching required.
+ * 
+ * Expected: 5x faster hook execution, parallel async support
+ */
+export class CompiledHookManager {
+    // Direct event -> hooks mapping (no pattern matching at runtime)
+    private pipelines = new Map<string, Hook[]>();
+    
+    // Keep track of all registered hooks for management
+    private allHooks = new Map<string, Hook>();
+
+    /**
+     * Expand a pattern like "before*" to all matching events
+     */
+    private expandPattern(pattern: string): string[] {
+        // Common event patterns
+        const eventTypes = [
+            'beforeCreate', 'afterCreate',
+            'beforeUpdate', 'afterUpdate',
+            'beforeDelete', 'afterDelete',
+            'beforeFind', 'afterFind',
+            'beforeCount', 'afterCount'
+        ];
+
+        // Handle wildcards
+        if (pattern === '*') {
+            return eventTypes;
+        }
+        
+        if (pattern.includes('*')) {
+            // Use global replace to handle all occurrences of *
+            const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+            return eventTypes.filter(event => regex.test(event));
+        }
+
+        // Exact match
+        return [pattern];
+    }
+
+    /**
+     * Register a hook - pre-groups by event pattern
+     */
+    registerHook(event: string, objectName: string, handler: any, packageName?: string): void {
+        const hook: Hook = {
+            pattern: `${event}:${objectName}`,
+            handler,
+            packageName,
+            priority: 0
+        };
+
+        // Store in all hooks registry
+        const hookId = `${event}:${objectName}:${Date.now()}`;
+        this.allHooks.set(hookId, hook);
+
+        // Expand event patterns
+        const events = this.expandPattern(event);
+        
+        // Handle wildcard object names
+        if (objectName === '*') {
+            for (const concreteEvent of events) {
+                // Register for all potential object names
+                // Since we don't know all object names upfront, we keep a special '*' pipeline
+                const wildcardKey = `${concreteEvent}:*`;
+                if (!this.pipelines.has(wildcardKey)) {
+                    this.pipelines.set(wildcardKey, []);
+                }
+                this.pipelines.get(wildcardKey)!.push(hook);
+            }
+        } else {
+            // Pre-group hooks by concrete event names (only for non-wildcard objects)
+            for (const concreteEvent of events) {
+                const key = `${concreteEvent}:${objectName}`;
+                if (!this.pipelines.has(key)) {
+                    this.pipelines.set(key, []);
+                }
+                this.pipelines.get(key)!.push(hook);
+            }
+        }
+    }
+
+    /**
+     * Run hooks for an event - direct lookup, no pattern matching
+     */
+    async runHooks(event: string, objectName: string, context: any): Promise<void> {
+        const key = `${event}:${objectName}`;
+        const wildcardKey = `${event}:*`;
+        
+        // Collect all applicable hooks
+        const hooks: Hook[] = [];
+        
+        // Add object-specific hooks
+        const objectHooks = this.pipelines.get(key);
+        if (objectHooks) {
+            hooks.push(...objectHooks);
+        }
+        
+        // Add wildcard hooks
+        const wildcardHooks = this.pipelines.get(wildcardKey);
+        if (wildcardHooks) {
+            hooks.push(...wildcardHooks);
+        }
+
+        if (hooks.length === 0) {
+            return;
+        }
+
+        // Sort by priority (higher priority first)
+        hooks.sort((a, b) => (b.priority || 0) - (a.priority || 0));
+
+        // Execute hooks in parallel for better performance
+        // Note: If order matters, change to sequential execution
+        await Promise.all(hooks.map(hook => {
+            try {
+                return Promise.resolve(hook.handler(context));
+            } catch (error) {
+                console.error(`Hook execution failed for ${event}:${objectName}`, error);
+                return Promise.resolve();
+            }
+        }));
+    }
+
+    /**
+     * Remove all hooks from a package
+     */
+    removePackage(packageName: string): void {
+        // Remove from all hooks registry
+        const hooksToRemove: string[] = [];
+        for (const [hookId, hook] of this.allHooks.entries()) {
+            if (hook.packageName === packageName) {
+                hooksToRemove.push(hookId);
+            }
+        }
+        hooksToRemove.forEach(id => this.allHooks.delete(id));
+
+        // Remove from pipelines
+        for (const [key, hooks] of this.pipelines.entries()) {
+            const filtered = hooks.filter(h => h.packageName !== packageName);
+            if (filtered.length === 0) {
+                this.pipelines.delete(key);
+            } else {
+                this.pipelines.set(key, filtered);
+            }
+        }
+    }
+
+    /**
+     * Clear all hooks
+     */
+    clear(): void {
+        this.pipelines.clear();
+        this.allHooks.clear();
+    }
+
+    /**
+     * Get statistics about registered hooks
+     */
+    getStats(): { totalHooks: number; totalPipelines: number } {
+        return {
+            totalHooks: this.allHooks.size,
+            totalPipelines: this.pipelines.size
+        };
+    }
+}