Merge pull request #166 from objectstack-ai/copilot/align-types-and-migrate-engines

Author: hotlong

packages/foundation/core/src/app.ts

@@ -108,26 +108,30 @@ export class ObjectQL implements IObjectQL {
 
     on(event: HookName, objectName: string, handler: HookHandler, packageName?: string) {
         // Delegate to kernel hook manager
-        // Note: Type casting needed due to type incompatibility between ObjectQL HookName (includes beforeCount)
-        // and runtime HookName. This is safe as the kernel will accept all hook types.
-        this.kernel.hooks.register(event as any, objectName, handler as any, packageName);
+        // 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').HookHandler;
+        this.kernel.hooks.register(event, objectName, wrappedHandler, packageName);
     }
 
     async triggerHook(event: HookName, objectName: string, ctx: HookContext) {
         // Delegate to kernel hook manager
-        await this.kernel.hooks.trigger(event as any, objectName, ctx as any);
+        // Runtime HookContext supports ObjectQL-specific fields via index signature
+        await this.kernel.hooks.trigger(event, objectName, ctx);
     }
 
     registerAction(objectName: string, actionName: string, handler: ActionHandler, packageName?: string) {
         // Delegate to kernel action manager
-        // Note: Type casting needed due to type incompatibility between ObjectQL ActionHandler
-        // (includes input/api fields) and runtime ActionHandler. This is safe as runtime is more permissive.
-        this.kernel.actions.register(objectName, actionName, handler as any, packageName);
+        // 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').ActionHandler;
+        this.kernel.actions.register(objectName, actionName, wrappedHandler, packageName);
     }
 
     async executeAction(objectName: string, actionName: string, ctx: ActionContext) {
         // Delegate to kernel action manager
-        return await this.kernel.actions.execute(objectName, actionName, ctx as any);
+        // Runtime ActionContext supports ObjectQL-specific fields via index signature
+        return await this.kernel.actions.execute(objectName, actionName, ctx);
     }
 
     createContext(options: ObjectQLContextOptions): ObjectQLContext {
@@ -211,16 +215,14 @@ export class ObjectQL implements IObjectQL {
     }
 
     getObject(name: string): ObjectConfig | undefined {
-        const item = this.kernel.metadata.get<MetadataItem>('object', name);
-        return item?.content as ObjectConfig | undefined;
+        return this.kernel.metadata.get<ObjectConfig>('object', name);
     }
 
     getConfigs(): Record<string, ObjectConfig> {
         const result: Record<string, ObjectConfig> = {};
-        const items = this.kernel.metadata.list<MetadataItem>('object');
+        const items = this.kernel.metadata.list<ObjectConfig>('object');
         for (const item of items) {
-            const obj = item.content as ObjectConfig;
-            result[obj.name] = obj;
+            result[item.name] = item;
         }
         return result;
     }

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

@@ -10,6 +10,13 @@ import type { RuntimePlugin, RuntimeContext, ObjectStackKernel } from '@objectst
 import { FormulaEngine } from './formula-engine';
 import type { FormulaEngineConfig } from '@objectql/types';
 
+/**
+ * Extended ObjectStack Kernel with formula engine capability
+ */
+interface KernelWithFormulas extends ObjectStackKernel {
+    formulaEngine?: FormulaEngine;
+}
+
 /**
  * Configuration for the Formula Plugin
  */
@@ -49,10 +56,13 @@ export class FormulaPlugin implements RuntimePlugin {
    * Registers formula evaluation capabilities
    */
   async install(ctx: RuntimeContext): Promise<void> {
-    const kernel = ctx.engine as ObjectStackKernel;
+    const kernel = ctx.engine as KernelWithFormulas;
 
     console.log(`[${this.name}] Installing formula plugin...`);
 
+    // Make formula engine accessible from the kernel for direct usage
+    kernel.formulaEngine = this.engine;
+    
     // Register formula provider if the kernel supports it
     this.registerFormulaProvider(kernel);
 
@@ -68,13 +78,10 @@ export class FormulaPlugin implements RuntimePlugin {
    * Register the formula provider with the kernel
    * @private
    */
-  private registerFormulaProvider(kernel: ObjectStackKernel): void {
+  private registerFormulaProvider(kernel: KernelWithFormulas): void {
     // Check if kernel supports formula provider registration
-    // Note: Using type assertion since registerFormulaProvider may not be in the interface
-    const kernelWithFormulas = kernel as any;
-    
-    if (typeof kernelWithFormulas.registerFormulaProvider === 'function') {
-      kernelWithFormulas.registerFormulaProvider({
+    if (typeof (kernel as any).registerFormulaProvider === 'function') {
+      (kernel as any).registerFormulaProvider({
         evaluate: (formula: string, context: any) => {
           // Delegate to the formula engine
           // Note: In a real implementation, we would need to properly construct
@@ -93,24 +100,19 @@ export class FormulaPlugin implements RuntimePlugin {
           return this.engine.extractMetadata(fieldName, expression, dataType);
         }
       });
-    } else {
-      // If the kernel doesn't support formula provider registration yet,
-      // we still register the engine for direct access
-      kernelWithFormulas.formulaEngine = this.engine;
     }
+    // Note: formulaEngine is already registered in install() method above
   }
 
   /**
    * Register formula evaluation middleware
    * @private
    */
-  private registerFormulaMiddleware(kernel: ObjectStackKernel): void {
+  private registerFormulaMiddleware(kernel: KernelWithFormulas): void {
     // Check if kernel supports middleware hooks
-    const kernelWithHooks = kernel as any;
-    
-    if (typeof kernelWithHooks.use === 'function') {
+    if (typeof (kernel as any).use === 'function') {
       // Register middleware to evaluate formulas after queries
-      kernelWithHooks.use('afterQuery', async (context: any) => {
+      (kernel as any).use('afterQuery', async (context: any) => {
         // Formula evaluation logic would go here
         // This would automatically compute formula fields after data is retrieved
         if (context.results && context.metadata?.fields) {

packages/foundation/core/src/repository.ts

@@ -13,20 +13,51 @@ import { Validator } from './validator';
 import { FormulaEngine } from './formula-engine';
 import { QueryBuilder } from './query';
 
+/**
+ * Extended ObjectStack Kernel with optional ObjectQL plugin capabilities.
+ * These properties are attached by ValidatorPlugin and FormulaPlugin during installation.
+ */
+interface ExtendedKernel extends ObjectStackKernel {
+    validator?: Validator;
+    formulaEngine?: FormulaEngine;
+}
+
 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 ExtendedKernel;
+        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 ExtendedKernel;
+        if (kernel.formulaEngine) {
+            return kernel.formulaEngine;
+        }
+        // Fallback for backward compatibility
+        return new FormulaEngine();
+    }
 
     private getDriver(): Driver {
         const obj = this.getSchema();
@@ -106,7 +137,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 +176,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 +223,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

@@ -9,6 +9,13 @@
 import type { RuntimePlugin, RuntimeContext, ObjectStackKernel } from '@objectstack/runtime';
 import { Validator, ValidatorOptions } from './validator';
 
+/**
+ * Extended ObjectStack Kernel with validator capability
+ */
+interface KernelWithValidator extends ObjectStackKernel {
+    validator?: Validator;
+}
+
 /**
  * Configuration for the Validator Plugin
  */
@@ -58,10 +65,13 @@ export class ValidatorPlugin implements RuntimePlugin {
    * Registers validation middleware for queries and mutations
    */
   async install(ctx: RuntimeContext): Promise<void> {
-    const kernel = ctx.engine as ObjectStackKernel;
+    const kernel = ctx.engine as KernelWithValidator;
 
     console.log(`[${this.name}] Installing validator plugin...`);
 
+    // Make validator accessible from the kernel for direct usage
+    kernel.validator = this.validator;
+    
     // Register validation middleware for queries (if enabled)
     if (this.config.enableQueryValidation !== false) {
       this.registerQueryValidation(kernel);
@@ -79,7 +89,7 @@ export class ValidatorPlugin implements RuntimePlugin {
    * Register query validation middleware
    * @private
    */
-  private registerQueryValidation(kernel: ObjectStackKernel): void {
+  private registerQueryValidation(kernel: KernelWithValidator): void {
     // Check if kernel supports middleware hooks
     if (typeof (kernel as any).use === 'function') {
       (kernel as any).use('beforeQuery', async (context: any) => {
@@ -101,7 +111,7 @@ export class ValidatorPlugin implements RuntimePlugin {
    * Register mutation validation middleware
    * @private
    */
-  private registerMutationValidation(kernel: ObjectStackKernel): void {
+  private registerMutationValidation(kernel: KernelWithValidator): void {
     // Check if kernel supports middleware hooks
     if (typeof (kernel as any).use === 'function') {
       (kernel as any).use('beforeMutation', async (context: any) => {

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

@@ -21,13 +21,14 @@ class MockMetadataRegistry {
 
     get<T = any>(type: string, id: string): T | undefined {
         const typeMap = this.store.get(type);
-        return typeMap?.get(id) as T | undefined;
+        const item = typeMap?.get(id);
+        return item?.content as T;
     }
 
     list<T = any>(type: string): T[] {
         const typeMap = this.store.get(type);
         if (!typeMap) return [];
-        return Array.from(typeMap.values()) as T[];
+        return Array.from(typeMap.values()).map(item => item.content as T);
     }
 
     unregister(type: string, id: string): boolean {
@@ -57,25 +58,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 +108,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 +117,10 @@ class MockActionManager {
         }
         toDelete.forEach(key => this.actions.delete(key));
     }
+    
+    clear(): void {
+        this.actions.clear();
+    }
 }
 
 export class ObjectStackKernel {