Improve type safety - replace unsafe type assertions with proper interfaces

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

Author: Copilot

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,12 +56,12 @@ 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 as any).formulaEngine = this.engine;
+    kernel.formulaEngine = this.engine;
 
     // Register formula provider if the kernel supports it
     this.registerFormulaProvider(kernel);
@@ -71,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
@@ -96,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,6 +13,15 @@ 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 queryBuilder: QueryBuilder;
 
@@ -29,7 +38,7 @@ export class ObjectRepository {
      * Falls back to creating a new instance if not available
      */
     private getValidator(): Validator {
-        const kernel = this.getKernel() as any;
+        const kernel = this.getKernel() as ExtendedKernel;
         if (kernel.validator) {
             return kernel.validator;
         }
@@ -42,7 +51,7 @@ export class ObjectRepository {
      * Falls back to creating a new instance if not available
      */
     private getFormulaEngine(): FormulaEngine {
-        const kernel = this.getKernel() as any;
+        const kernel = this.getKernel() as ExtendedKernel;
         if (kernel.formulaEngine) {
             return kernel.formulaEngine;
         }

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,12 +65,12 @@ 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 as any).validator = this.validator;
+    kernel.validator = this.validator;
 
     // Register validation middleware for queries (if enabled)
     if (this.config.enableQueryValidation !== false) {
@@ -82,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) => {
@@ -104,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) => {