fix: formula plugin middleware and mock to fix integration tests

Copilot · hotlong · Copilot · commit ed43fe12a9e3 · 2026-02-14T12:17:41.000Z
Fix FormulaPlugin to register as engine middleware (covers both find
and findOne) instead of relying solely on afterFind hooks. Fix the
@objectstack/objectql mock to support middleware registration, execution
chain, and hook triggering - matching the upstream engine behavior.

Fixes 6 pre-existing plugin-formula integration test failures.

Co-authored-by: hotlong &lt;50353452+hotlong@users.noreply.github.com&gt;
diff --git a/packages/foundation/core/test/__mocks__/@objectstack/objectql.ts b/packages/foundation/core/test/__mocks__/@objectstack/objectql.ts
@@ -14,6 +14,7 @@ export class ObjectQL {
   private drivers = new Map<string, any>();
   private defaultDriver: any = null;
   private hooks = new Map<string, any[]>();
+  private middlewares: Array<{ fn: any; object?: string }> = [];
   
   constructor(public config: any) {}
   
@@ -66,24 +67,66 @@ export class ObjectQL {
     }
     this.hooks.get(event)!.push({ handler, options });
   }
+
+  registerMiddleware(fn: any, options?: { object?: string }) {
+    this.middlewares.push({ fn, object: options?.object });
+  }
+
+  private async executeWithMiddleware(opCtx: any, executor: () => Promise<any>) {
+    const applicable = this.middlewares.filter(
+      (m) => !m.object || m.object === '*' || m.object === opCtx.object
+    );
+    let index = 0;
+    const next = async () => {
+      if (index < applicable.length) {
+        const mw = applicable[index++];
+        await mw.fn(opCtx, next);
+      } else {
+        opCtx.result = await executor();
+      }
+    };
+    await next();
+    return opCtx.result;
+  }
+
+  private async triggerHooks(event: string, context: any) {
+    const entries = this.hooks.get(event) || [];
+    for (const entry of entries) {
+      if (entry.options?.object) {
+        const targets = Array.isArray(entry.options.object) ? entry.options.object : [entry.options.object];
+        if (!targets.includes('*') && !targets.includes(context.object)) {
+          continue;
+        }
+      }
+      await entry.handler(context);
+    }
+  }
   
   createContext(options: any = {}) {
     return {
       isSystem: options.isSystem || false,
       object: (name: string) => ({
         find: async (filter: any) => {
           const driver = this.drivers.get(this.defaultDriver || this.drivers.keys().next().value);
-          if (driver && driver.find) {
-            return driver.find(name, filter);
-          }
-          return [];
+          const opCtx = { object: name, operation: 'find', options: filter, context: options, result: undefined as any };
+          await this.executeWithMiddleware(opCtx, async () => {
+            const hookContext = { object: name, event: 'beforeFind', input: { options: filter }, session: options };
+            await this.triggerHooks('beforeFind', hookContext);
+            const result = driver?.find ? await driver.find(name, filter) : [];
+            hookContext.event = 'afterFind';
+            (hookContext as any).result = result;
+            await this.triggerHooks('afterFind', hookContext);
+            return (hookContext as any).result;
+          });
+          return opCtx.result;
         },
         findOne: async (filter: any) => {
           const driver = this.drivers.get(this.defaultDriver || this.drivers.keys().next().value);
-          if (driver && driver.findOne) {
-            return driver.findOne(name, filter);
-          }
-          return null;
+          const opCtx = { object: name, operation: 'findOne', options: filter, context: options, result: undefined as any };
+          await this.executeWithMiddleware(opCtx, async () => {
+            return driver?.findOne ? await driver.findOne(name, filter) : null;
+          });
+          return opCtx.result;
         },
         insert: async (data: any) => {
           const driver = this.drivers.get(this.defaultDriver || this.drivers.keys().next().value);
diff --git a/packages/foundation/plugin-formula/src/formula-plugin.ts b/packages/foundation/plugin-formula/src/formula-plugin.ts
@@ -126,95 +126,113 @@ export class FormulaPlugin implements RuntimePlugin {
     // Note: formulaEngine is already registered in install() method above
   }
   
+  /**
+   * Evaluate formula fields on a set of records for a given object.
+   * @private
+   */
+  private evaluateFormulas(objectName: string, result: any, session?: any): void {
+      if (!result) return;
+
+      // Get schema from MetadataRegistry or kernel.getObject()
+      const schemaItem = this.kernel.metadata?.get?.('object', objectName)
+        ?? (typeof this.kernel.getObject === 'function' ? this.kernel.getObject(objectName) : undefined);
+      const schema = schemaItem?.content || schemaItem;
+      if (!schema || !schema.fields) return;
+
+      // Identify formula fields
+      const formulaFields: [string, any][] = [];
+      for (const [key, field] of Object.entries(schema.fields) as any[]) {
+          if (field.type === 'formula' && field.expression) {
+              formulaFields.push([key, field]);
+          }
+      }
+      if (formulaFields.length === 0) return;
+
+      const results = Array.isArray(result) ? result : [result];
+      const now = new Date();
+      const systemInfo = {
+            today: new Date(now.getFullYear(), now.getMonth(), now.getDate()),
+            now: now,
+            year: now.getFullYear(),
+            month: now.getMonth() + 1,
+            day: now.getDate(),
+            hour: now.getHours(),
+            minute: now.getMinutes(),
+            second: now.getSeconds(),
+      };
+
+      for (const record of results) {
+          if (!record) continue;
+
+          const formulaContext: FormulaContext = {
+              record,
+              system: systemInfo,
+              current_user: {
+                  id: session?.userId || '',
+                  name: session?.name,
+                  email: session?.email,
+                  role: session?.roles?.[0]
+              },
+              is_new: false,
+              record_id: record._id || record.id
+          };
+
+          for (const [fieldName, fieldConfig] of formulaFields) {
+              const evalResult = this.engine.evaluate(
+                  fieldConfig.expression,
+                  formulaContext,
+                  fieldConfig.data_type || 'text',
+                  { strict: true }
+              );
+
+              if (evalResult.success) {
+                  record[fieldName] = evalResult.value;
+              } else {
+                  record[fieldName] = null;
+                  this.logger.error('[ObjectQL][FormulaEngine] Formula evaluation failed', undefined, {
+                    objectName,
+                    fieldName,
+                    recordId: formulaContext.record_id,
+                    expression: fieldConfig.expression,
+                    error: evalResult.error,
+                    stack: evalResult.stack,
+                  });
+              }
+          }
+      }
+  }
+
   /**
    * Register formula evaluation middleware
    * @private
    */
   private registerFormulaMiddleware(kernel: KernelWithFormulas, ctx: any): void {
+      // Strategy 1: Register as engine middleware (covers both find and findOne)
+      const engine = ctx.engine || kernel;
+      if (typeof engine.registerMiddleware === 'function') {
+          engine.registerMiddleware(async (opCtx: any, next: () => Promise<void>) => {
+              await next();
+              if ((opCtx.operation === 'find' || opCtx.operation === 'findOne') && opCtx.result) {
+                  this.evaluateFormulas(opCtx.object, opCtx.result, opCtx.context);
+              }
+          });
+          return;
+      }
+
+      // Strategy 2: Register as afterFind hook (find only, no findOne coverage)
       const registerHook = (name: string, handler: any) => {
         if (typeof ctx.hook === 'function') {
             ctx.hook(name, handler);
         } else if (kernel.hooks && typeof kernel.hooks.register === 'function') {
-            // Register for all objects using wildcard
             kernel.hooks.register(name, '*', handler);
         }
       };
 
       registerHook('afterFind', async (context: any) => {
-          // context is RetrievalHookContext
-          const { objectName, result, user } = context;
-          if (!result) return;
-          
-          // Get schema
-          const schemaItem = this.kernel.metadata.get('object', objectName);
-          const schema = schemaItem?.content || schemaItem;
-          if (!schema || !schema.fields) {
-               return;
-          }
-          
-          // Identify formula fields
-          const formulaFields: [string, any][] = [];
-          for (const [key, field] of Object.entries(schema.fields) as any[]) {
-              if (field.type === 'formula' && field.expression) {
-                  formulaFields.push([key, field]);
-              }
-          }
-          
-          if (formulaFields.length === 0) return;
-
-          const results = Array.isArray(result) ? result : [result];
-          const now = new Date();
-          const systemInfo = {
-                today: new Date(now.getFullYear(), now.getMonth(), now.getDate()),
-                now: now,
-                year: now.getFullYear(),
-                month: now.getMonth() + 1,
-                day: now.getDate(),
-                hour: now.getHours(),
-                minute: now.getMinutes(),
-                second: now.getSeconds(),
-          };
-
-          for (const record of results) {
-              if (!record) continue;
-              
-              const formulaContext: FormulaContext = {
-                  record,
-                  system: systemInfo,
-                  current_user: {
-                      id: user?.id || '',
-                      name: user?.name,
-                      email: user?.email,
-                      role: user?.roles?.[0]
-                  },
-                  is_new: false,
-                  record_id: record._id || record.id
-              };
-              
-              for (const [fieldName, fieldConfig] of formulaFields) {
-                  const evalResult = this.engine.evaluate(
-                      fieldConfig.expression,
-                      formulaContext,
-                      fieldConfig.data_type || 'text',
-                      { strict: true }
-                  );
-                  
-                  if (evalResult.success) {
-                      record[fieldName] = evalResult.value;
-                  } else {
-                      record[fieldName] = null;
-                      // Log specific error as seen in repository.ts
-                        this.logger.error('[ObjectQL][FormulaEngine] Formula evaluation failed', undefined, {
-                          objectName: objectName,
-                          fieldName,
-                          recordId: formulaContext.record_id,
-                          expression: fieldConfig.expression,
-                          error: evalResult.error,
-                          stack: evalResult.stack,
-                        });
-                  }
-              }
-          }
+          // Upstream hook context uses 'object' (not 'objectName') and 'session' (not 'user')
+          const objectName = context.object || context.objectName;
+          const session = context.session || context.user;
+          this.evaluateFormulas(objectName, context.result, session);
       });
   }
   
