Phase 2 & 3: Decouple Validator and Formula engines from repository via plugin architecture

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

Author: Copilot

packages/foundation/core/src/formula-plugin.ts

@@ -53,6 +53,9 @@ export class FormulaPlugin implements RuntimePlugin {
 
     console.log(`[${this.name}] Installing formula plugin...`);
 
+    // Make formula engine accessible from the kernel for direct usage
+    (kernel as any).formulaEngine = this.engine;
+    
     // Register formula provider if the kernel supports it
     this.registerFormulaProvider(kernel);
 

packages/foundation/core/src/repository.ts

@@ -14,19 +14,41 @@ import { FormulaEngine } from './formula-engine';
 import { QueryBuilder } from './query';
 
 export class ObjectRepository {
-    private validator: Validator;
-    private formulaEngine: FormulaEngine;
     private queryBuilder: QueryBuilder;
 
     constructor(
         private objectName: string,
         private context: ObjectQLContext,
         private app: IObjectQL
     ) {
-        this.validator = new Validator();
-        this.formulaEngine = new FormulaEngine();
         this.queryBuilder = new QueryBuilder();
     }
+    
+    /**
+     * Get validator instance from kernel (via plugin)
+     * Falls back to creating a new instance if not available
+     */
+    private getValidator(): Validator {
+        const kernel = this.getKernel() as any;
+        if (kernel.validator) {
+            return kernel.validator;
+        }
+        // Fallback for backward compatibility
+        return new Validator();
+    }
+    
+    /**
+     * Get formula engine instance from kernel (via plugin)
+     * Falls back to creating a new instance if not available
+     */
+    private getFormulaEngine(): FormulaEngine {
+        const kernel = this.getKernel() as any;
+        if (kernel.formulaEngine) {
+            return kernel.formulaEngine;
+        }
+        // Fallback for backward compatibility
+        return new FormulaEngine();
+    }
 
     private getDriver(): Driver {
         const obj = this.getSchema();
@@ -106,7 +128,7 @@ export class ObjectRepository {
             }
 
             const value = record[fieldName];
-            const fieldResults = await this.validator.validateField(
+            const fieldResults = await this.getValidator().validateField(
                 fieldName,
                 fieldConfig,
                 value,
@@ -145,7 +167,7 @@ export class ObjectRepository {
                 changedFields,
             };
 
-            const result = await this.validator.validate(schema.validation.rules, validationContext);
+            const result = await this.getValidator().validate(schema.validation.rules, validationContext);
             allResults.push(...result.results);
         }
 
@@ -192,7 +214,7 @@ export class ObjectRepository {
         // Evaluate each formula field
         for (const [fieldName, fieldConfig] of Object.entries(schema.fields)) {
             if (fieldConfig.type === 'formula' && fieldConfig.formula) {
-                const result = this.formulaEngine.evaluate(
+                const result = this.getFormulaEngine().evaluate(
                     fieldConfig.formula,
                     formulaContext,
                     fieldConfig.data_type || 'text',

packages/foundation/core/src/validator-plugin.ts

@@ -62,6 +62,9 @@ export class ValidatorPlugin implements RuntimePlugin {
 
     console.log(`[${this.name}] Installing validator plugin...`);
 
+    // Make validator accessible from the kernel for direct usage
+    (kernel as any).validator = this.validator;
+    
     // Register validation middleware for queries (if enabled)
     if (this.config.enableQueryValidation !== false) {
       this.registerQueryValidation(kernel);

packages/foundation/core/test/__mocks__/@objectstack/runtime.ts

@@ -57,25 +57,32 @@ class MockMetadataRegistry {
 class MockHookManager {
     private hooks = new Map<string, any[]>();
 
-    register(hookName: string, handler: any, packageName?: string): void {
+    register(hookName: string, objectName: string, handler: any, packageName?: string): void {
         if (!this.hooks.has(hookName)) {
             this.hooks.set(hookName, []);
         }
-        this.hooks.get(hookName)!.push({ handler, packageName });
+        this.hooks.get(hookName)!.push({ objectName, handler, packageName });
     }
 
-    async trigger(hookName: string, context: any): Promise<void> {
+    async trigger(hookName: string, objectName: string, context: any): Promise<void> {
         const handlers = this.hooks.get(hookName) || [];
-        for (const { handler } of handlers) {
-            await handler(context);
+        for (const entry of handlers) {
+            // Match on wildcard '*' or specific object name
+            if (entry.objectName === '*' || entry.objectName === objectName) {
+                await entry.handler(context);
+            }
         }
     }
 
-    unregisterPackage(packageName: string): void {
+    removePackage(packageName: string): void {
         for (const [hookName, handlers] of this.hooks.entries()) {
             this.hooks.set(hookName, handlers.filter(h => h.packageName !== packageName));
         }
     }
+    
+    clear(): void {
+        this.hooks.clear();
+    }
 }
 
 class MockActionManager {
@@ -100,7 +107,7 @@ class MockActionManager {
         return this.actions.get(key)?.handler;
     }
 
-    unregisterPackage(packageName: string): void {
+    removePackage(packageName: string): void {
         const toDelete: string[] = [];
         for (const [key, action] of this.actions.entries()) {
             if (action.packageName === packageName) {
@@ -109,6 +116,10 @@ class MockActionManager {
         }
         toDelete.forEach(key => this.actions.delete(key));
     }
+    
+    clear(): void {
+        this.actions.clear();
+    }
 }
 
 export class ObjectStackKernel {