feat: Integrate optimizations directly into core codebase

Copilot · hotlong · Copilot · commit 20cceea0a3d1 · 2026-01-30T09:00:58.000Z
- Replaced MetadataRegistry with optimized version using secondary index
- Integrated CompiledHookManager for pre-compiled hook pipelines
- Added QueryCompiler caching to ObjectRepository
- No longer maintaining backward compatibility as requested

This directly enables optimizations instead of providing them as drop-in replacements.

Co-authored-by: hotlong &lt;50353452+hotlong@users.noreply.github.com&gt;
diff --git a/packages/foundation/core/src/app.ts b/packages/foundation/core/src/app.ts
@@ -27,6 +27,7 @@ import { ObjectQL as RuntimeObjectQL, SchemaRegistry } from '@objectstack/object
 import { ObjectRepository } from './repository';
 import { ObjectQLPlugin } from './plugin';
 import { convertIntrospectedSchemaToObjects } from './util';
+import { CompiledHookManager } from './optimizations/CompiledHookManager';
 
 /**
  * ObjectQL
@@ -48,9 +49,9 @@ export class ObjectQL implements IObjectQL {
     private ql: any;
     private kernelPlugins: any[] = [];
     
-    // Local Action and Hook Registry (shim for missing/inaccessible Kernel functionality)
+    // Optimized managers
+    private hookManager = new CompiledHookManager();
     private localActions = new Map<string, any>();
-    private localHooks = new Map<string, any[]>();
     
     // Store config for lazy loading in init()
     private config: ObjectQLConfig;
@@ -141,31 +142,13 @@ export class ObjectQL implements IObjectQL {
         const kernelHooks = (this.kernel as any).hooks || {};
         Object.assign(kernelHooks, {
             register: (event: string, objectName: string, handler: any, packageName?: string) => {
-                const key = `${event}:${objectName}`;
-                if (!this.localHooks.has(key)) {
-                    this.localHooks.set(key, []);
-                }
-                const handlers = this.localHooks.get(key)!;
-                // Store wrapper to track package
-                (handler as any)._package = packageName;
-                handlers.push(handler);
+                this.hookManager.registerHook(event, objectName, handler, packageName);
             },
             removePackage: (packageName: string) => {
-                for (const handlers of this.localHooks.values()) {
-                    // Remove handlers belonging to package
-                    for (let i = handlers.length - 1; i >= 0; i--) {
-                        if ((handlers[i] as any)._package === packageName) {
-                            handlers.splice(i, 1);
-                        }
-                    }
-                }
+                this.hookManager.removePackage(packageName);
             },
             trigger: async (event: string, objectName: string, ctx: any) => {
-                const key = `${event}:${objectName}`;
-                const handlers = this.localHooks.get(key) || [];
-                for (const handler of handlers) {
-                    await handler(ctx);
-                }
+                await this.hookManager.runHooks(event, objectName, ctx);
             }
         });
         if (!(this.kernel as any).hooks) {
diff --git a/packages/foundation/core/src/repository.ts b/packages/foundation/core/src/repository.ts
@@ -14,6 +14,7 @@ type SortNode = Data.SortNode;
 import { Validator } from '@objectql/plugin-validator';
 import { FormulaEngine } from '@objectql/plugin-formula';
 import { QueryBuilder } from './query';
+import { QueryCompiler } from './optimizations/QueryCompiler';
 
 /**
  * Extended ObjectStack Kernel with optional ObjectQL plugin capabilities.
@@ -31,6 +32,8 @@ interface ExtendedKernel extends ObjectKernel {
 
 export class ObjectRepository {
     private queryBuilder: QueryBuilder;
+    // Shared query compiler for caching compiled queries
+    private static queryCompiler = new QueryCompiler(1000);
 
     constructor(
         private objectName: string,
@@ -85,9 +88,13 @@ export class ObjectRepository {
 
     /**
      * Translates ObjectQL UnifiedQuery to ObjectStack QueryAST format
+     * Uses query compiler for caching and optimization
      */
     private buildQueryAST(query: UnifiedQuery): QueryAST {
-        return this.queryBuilder.build(this.objectName, query);
+        const ast = this.queryBuilder.build(this.objectName, query);
+        // Use query compiler to cache and optimize the AST
+        const compiled = ObjectRepository.queryCompiler.compile(this.objectName, ast);
+        return compiled.ast;
     }
 
     getSchema(): ObjectConfig {
diff --git a/packages/foundation/types/src/registry.ts b/packages/foundation/types/src/registry.ts
@@ -7,13 +7,25 @@
  */
 
 /**
- * Re-export MetadataRegistry and MetadataItem from @objectstack/runtime
+ * Metadata reference for secondary index
+ */
+interface MetadataRef {
+    type: string;
+    name: string;
+}
+
+/**
+ * Optimized Metadata Registry with O(k) package uninstall complexity
  * 
- * As of Week 3 refactoring, metadata management has been moved to the
- * @objectstack/runtime package to enable sharing across the ecosystem.
+ * Uses secondary indexes to achieve O(k) complexity for unregisterPackage
+ * operation (where k is the number of items in the package) instead of
+ * O(n*m) (where n is types and m is items per type).
  */
 export class MetadataRegistry {
     private items: any = {};
+    
+    // Secondary index: package name -> list of metadata references
+    private packageIndex = new Map<string, Set<MetadataRef>>();
 
     constructor() {}
 
@@ -35,6 +47,15 @@ export class MetadataRegistry {
 
         if (name) {
             this.items[type][name] = item;
+            
+            // Update package index
+            const packageName = item.package || (item as any)._package || (item as any).packageName;
+            if (packageName) {
+                if (!this.packageIndex.has(packageName)) {
+                    this.packageIndex.set(packageName, new Set());
+                }
+                this.packageIndex.get(packageName)!.add({ type, name });
+            }
         }
     }
 
@@ -65,22 +86,49 @@ export class MetadataRegistry {
     }
 
     unregister(type: string, name: string) {
-        if (this.items[type]?.[name]) {
+        const item = this.items[type]?.[name];
+        if (item) {
+            // Update package index
+            const packageName = item.package || (item as any)._package || (item as any).packageName;
+            if (packageName) {
+                const refs = this.packageIndex.get(packageName);
+                if (refs) {
+                    // Remove this specific reference
+                    for (const ref of refs) {
+                        if (ref.type === type && ref.name === name) {
+                            refs.delete(ref);
+                            break;
+                        }
+                    }
+                    // Clean up empty package entries
+                    if (refs.size === 0) {
+                        this.packageIndex.delete(packageName);
+                    }
+                }
+            }
             delete this.items[type][name];
         }
     }
 
+    /**
+     * Optimized package unregistration with O(k) complexity
+     * where k is the number of items in the package.
+     * 
+     * Previous complexity: O(n*m) - iterate all types and all items
+     * New complexity: O(k) - direct lookup via secondary index
+     */
     unregisterPackage(packageName: string) {
-        // Optimized implementation using secondary index
-        // This is now O(k) instead of O(n*m) where k is items in package
-        for (const type of Object.keys(this.items)) {
-            for (const key of Object.keys(this.items[type])) {
-                const item = this.items[type][key];
-                // Check widely for packaging metadata (package or _package)
-                if (item.package === packageName || (item as any)._package === packageName || (item as any).packageName === packageName) {
-                    delete this.items[type][key];
+        // Direct lookup via secondary index ✅
+        const refs = this.packageIndex.get(packageName);
+        if (refs) {
+            // Delete each item referenced by this package
+            for (const ref of refs) {
+                if (this.items[ref.type]?.[ref.name]) {
+                    delete this.items[ref.type][ref.name];
                 }
             }
+            // Remove package from index
+            this.packageIndex.delete(packageName);
         }
     }
 }
