Implement Expression Evaluator and Action Runner in core package with React hooks

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

Author: Copilot

packages/core/src/actions/ActionRunner.ts

@@ -0,0 +1,177 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * @object-ui/core - Action Runner
+ * 
+ * Executes actions defined in ActionSchema and EventHandler.
+ */
+
+import { ExpressionEvaluator } from '../evaluator/ExpressionEvaluator';
+
+export interface ActionResult {
+  success: boolean;
+  data?: any;
+  error?: string;
+  reload?: boolean;
+  close?: boolean;
+  redirect?: string;
+}
+
+export interface ActionContext {
+  data?: Record<string, any>;
+  record?: any;
+  user?: any;
+  [key: string]: any;
+}
+
+export type ActionHandler = (
+  action: any,
+  context: ActionContext
+) => Promise<ActionResult> | ActionResult;
+
+export class ActionRunner {
+  private handlers = new Map<string, ActionHandler>();
+  private evaluator: ExpressionEvaluator;
+  private context: ActionContext;
+
+  constructor(context: ActionContext = {}) {
+    this.context = context;
+    this.evaluator = new ExpressionEvaluator(context);
+  }
+
+  registerHandler(actionName: string, handler: ActionHandler): void {
+    this.handlers.set(actionName, handler);
+  }
+
+  async execute(action: any): Promise<ActionResult> {
+    try {
+      if (action.condition) {
+        const shouldExecute = this.evaluator.evaluateCondition(action.condition);
+        if (!shouldExecute) {
+          return { success: false, error: 'Action condition not met' };
+        }
+      }
+
+      if (action.disabled) {
+        const isDisabled = typeof action.disabled === 'string'
+          ? this.evaluator.evaluateCondition(action.disabled)
+          : action.disabled;
+        
+        if (isDisabled) {
+          return { success: false, error: 'Action is disabled' };
+        }
+      }
+
+      if (action.type === 'action' || action.actionType) {
+        return await this.executeActionSchema(action);
+      } else if (action.type === 'navigation' || action.navigate) {
+        return await this.executeNavigation(action);
+      } else if (action.type === 'api' || action.api) {
+        return await this.executeAPI(action);
+      } else if (action.onClick) {
+        await action.onClick();
+        return { success: true };
+      }
+
+      return { success: false, error: 'Unknown action type' };
+    } catch (error) {
+      return { success: false, error: (error as Error).message };
+    }
+  }
+
+  private async executeActionSchema(action: any): Promise<ActionResult> {
+    const result: ActionResult = { success: true };
+
+    if (action.confirmText) {
+      const confirmed = await this.showConfirmation(action.confirmText);
+      if (!confirmed) {
+        return { success: false, error: 'Action cancelled by user' };
+      }
+    }
+
+    if (action.api) {
+      const apiResult = await this.executeAPI(action);
+      if (!apiResult.success) return apiResult;
+      result.data = apiResult.data;
+    }
+
+    if (action.onClick) {
+      await action.onClick();
+    }
+
+    result.reload = action.reload !== false;
+    result.close = action.close !== false;
+
+    if (action.redirect) {
+      result.redirect = this.evaluator.evaluate(action.redirect) as string;
+    }
+
+    return result;
+  }
+
+  private async executeNavigation(action: any): Promise<ActionResult> {
+    const nav = action.navigate || action;
+    const to = this.evaluator.evaluate(nav.to) as string;
+
+    if (nav.external) {
+      window.open(to, '_blank');
+    } else {
+      return { success: true, redirect: to };
+    }
+
+    return { success: true };
+  }
+
+  private async executeAPI(action: any): Promise<ActionResult> {
+    const apiConfig = action.api;
+    
+    if (typeof apiConfig === 'string') {
+      try {
+        const response = await fetch(apiConfig, {
+          method: action.method || 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(this.context.data || {})
+        });
+
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+
+        const data = await response.json();
+        return { success: true, data };
+      } catch (error) {
+        return { success: false, error: (error as Error).message };
+      }
+    }
+
+    return { success: false, error: 'Complex API configuration not yet implemented' };
+  }
+
+  private async showConfirmation(message: string): Promise<boolean> {
+    const evaluatedMessage = this.evaluator.evaluate(message) as string;
+    return window.confirm(evaluatedMessage);
+  }
+
+  updateContext(newContext: Partial<ActionContext>): void {
+    this.context = { ...this.context, ...newContext };
+    this.evaluator.updateContext(newContext);
+  }
+
+  getContext(): ActionContext {
+    return this.context;
+  }
+}
+
+export async function executeAction(
+  action: any,
+  context: ActionContext = {}
+): Promise<ActionResult> {
+  const runner = new ActionRunner(context);
+  return await runner.execute(action);
+}

packages/core/src/actions/index.ts

@@ -0,0 +1,9 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+export * from './ActionRunner';

packages/core/src/evaluator/ExpressionContext.ts

@@ -0,0 +1,118 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * @object-ui/core - Expression Context
+ * 
+ * Manages variable scope and data context for expression evaluation.
+ * 
+ * @module evaluator
+ * @packageDocumentation
+ */
+
+/**
+ * Expression context for variable resolution
+ */
+export class ExpressionContext {
+  private scopes: Map<string, any>[] = [];
+
+  constructor(initialData: Record<string, any> = {}) {
+    this.scopes.push(new Map(Object.entries(initialData)));
+  }
+
+  /**
+   * Push a new scope onto the context stack
+   */
+  pushScope(data: Record<string, any>): void {
+    this.scopes.push(new Map(Object.entries(data)));
+  }
+
+  /**
+   * Pop the current scope from the context stack
+   */
+  popScope(): void {
+    if (this.scopes.length > 1) {
+      this.scopes.pop();
+    }
+  }
+
+  /**
+   * Get a variable value from the context
+   * Searches from innermost to outermost scope
+   */
+  get(path: string): any {
+    // Split path by dots for nested access
+    const parts = path.split('.');
+    const varName = parts[0];
+
+    // Search scopes from innermost to outermost
+    for (let i = this.scopes.length - 1; i >= 0; i--) {
+      if (this.scopes[i].has(varName)) {
+        let value = this.scopes[i].get(varName);
+        
+        // Navigate nested path
+        for (let j = 1; j < parts.length; j++) {
+          if (value && typeof value === 'object') {
+            value = value[parts[j]];
+          } else {
+            return undefined;
+          }
+        }
+        
+        return value;
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Set a variable value in the current scope
+   */
+  set(name: string, value: any): void {
+    if (this.scopes.length > 0) {
+      this.scopes[this.scopes.length - 1].set(name, value);
+    }
+  }
+
+  /**
+   * Check if a variable exists in any scope
+   */
+  has(name: string): boolean {
+    const varName = name.split('.')[0];
+    for (let i = this.scopes.length - 1; i >= 0; i--) {
+      if (this.scopes[i].has(varName)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Get all variables from all scopes as a flat object
+   */
+  toObject(): Record<string, any> {
+    const result: Record<string, any> = {};
+    // Merge from outermost to innermost (later scopes override earlier ones)
+    for (const scope of this.scopes) {
+      for (const [key, value] of scope.entries()) {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Create a child context with additional data
+   */
+  createChild(data: Record<string, any> = {}): ExpressionContext {
+    const child = new ExpressionContext();
+    child.scopes = [...this.scopes, new Map(Object.entries(data))];
+    return child;
+  }
+}