@object-ui/core 0.5.0 → 2.0.0

package/dist/actions/ActionRunner.js

@@ -9,6 +9,9 @@
  * @object-ui/core - Action Runner
  *
  * Executes actions defined in ActionSchema and EventHandler.
+ * Supports all spec v2.0.1 action types: script, url, modal, flow, api.
+ * Features: conditional execution, confirmation, toast notifications,
+ * redirect handling, action chaining, custom handler registration.
  */
 import { ExpressionEvaluator } from '../evaluator/ExpressionEvaluator';
 export class ActionRunner {
@@ -31,14 +34,87 @@ export class ActionRunner {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "confirmHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "toastHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modalHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "navigationHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "paramCollectionHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.context = context;
         this.evaluator = new ExpressionEvaluator(context);
+        // Default confirmation: window.confirm (can be overridden)
+        this.confirmHandler = async (message) => window.confirm(message);
+        this.toastHandler = null;
+        this.modalHandler = null;
+        this.navigationHandler = null;
+        this.paramCollectionHandler = null;
+    }
+    /**
+     * Set a custom confirmation handler (e.g., Shadcn AlertDialog).
+     */
+    setConfirmHandler(handler) {
+        this.confirmHandler = handler;
+    }
+    /**
+     * Set a custom toast handler (e.g., Sonner).
+     */
+    setToastHandler(handler) {
+        this.toastHandler = handler;
+    }
+    /**
+     * Set a modal handler (e.g., render a Dialog via React state).
+     */
+    setModalHandler(handler) {
+        this.modalHandler = handler;
+    }
+    /**
+     * Set a navigation handler (e.g., React Router navigate).
+     */
+    setNavigationHandler(handler) {
+        this.navigationHandler = handler;
+    }
+    /**
+     * Set a param collection handler — shows a dialog to collect
+     * ActionParam values before action execution.
+     */
+    setParamCollectionHandler(handler) {
+        this.paramCollectionHandler = handler;
     }
     registerHandler(actionName, handler) {
         this.handlers.set(actionName, handler);
     }
+    unregisterHandler(actionName) {
+        this.handlers.delete(actionName);
+    }
     async execute(action) {
         try {
+            // Resolve the action type
+            const actionType = action.type || action.actionType || action.name || '';
+            // Conditional execution
             if (action.condition) {
                 const shouldExecute = this.evaluator.evaluateCondition(action.condition);
                 if (!shouldExecute) {
@@ -53,34 +129,245 @@ export class ActionRunner {
                     return { success: false, error: 'Action is disabled' };
                 }
             }
-            if (action.type === 'action' || action.actionType) {
-                return await this.executeActionSchema(action);
+            // Confirmation (structured or simple)
+            const confirmMessage = action.confirm?.message || action.confirmText;
+            if (confirmMessage) {
+                const confirmed = await this.confirmHandler(this.evaluator.evaluate(confirmMessage), action.confirm ? {
+                    title: action.confirm.title,
+                    confirmText: action.confirm.confirmText,
+                    cancelText: action.confirm.cancelText,
+                } : undefined);
+                if (!confirmed) {
+                    return { success: false, error: 'Action cancelled by user' };
+                }
             }
-            else if (action.type === 'navigation' || action.navigate) {
-                return await this.executeNavigation(action);
+            // Param collection: if the action defines ActionParam[] to collect,
+            // show a dialog to gather user input before executing.
+            if (action.actionParams && Array.isArray(action.actionParams) && action.actionParams.length > 0) {
+                if (this.paramCollectionHandler) {
+                    const collected = await this.paramCollectionHandler(action.actionParams);
+                    if (collected === null) {
+                        return { success: false, error: 'Action cancelled by user (params)' };
+                    }
+                    // Merge collected params into action.params
+                    action.params = { ...(action.params || {}), ...collected };
+                }
             }
-            else if (action.type === 'api' || action.api) {
-                return await this.executeAPI(action);
+            // Check for a registered custom handler first
+            if (actionType && this.handlers.has(actionType)) {
+                const handler = this.handlers.get(actionType);
+                const result = await handler(action, this.context);
+                await this.handlePostExecution(action, result);
+                return result;
             }
-            else if (action.onClick) {
-                await action.onClick();
-                return { success: true };
+            // Built-in action execution by type
+            let result;
+            switch (actionType) {
+                case 'script':
+                    result = await this.executeScript(action);
+                    break;
+                case 'url':
+                    result = await this.executeUrl(action);
+                    break;
+                case 'modal':
+                    result = await this.executeModal(action);
+                    break;
+                case 'flow':
+                    result = await this.executeFlow(action);
+                    break;
+                case 'api':
+                    result = await this.executeAPI(action);
+                    break;
+                case 'navigation':
+                    result = await this.executeNavigation(action);
+                    break;
+                default:
+                    // Legacy fallback: check for navigate, api, or onClick
+                    if (action.navigate) {
+                        result = await this.executeNavigation(action);
+                    }
+                    else if (action.api || action.endpoint) {
+                        result = await this.executeAPI(action);
+                    }
+                    else if (action.onClick) {
+                        await action.onClick();
+                        result = { success: true };
+                    }
+                    else {
+                        result = await this.executeActionSchema(action);
+                    }
             }
-            return { success: false, error: 'Unknown action type' };
+            await this.handlePostExecution(action, result);
+            return result;
         }
         catch (error) {
-            return { success: false, error: error.message };
+            const result = { success: false, error: error.message };
+            await this.handlePostExecution(action, result);
+            return result;
         }
     }
-    async executeActionSchema(action) {
-        const result = { success: true };
-        if (action.confirmText) {
-            const confirmed = await this.showConfirmation(action.confirmText);
-            if (!confirmed) {
-                return { success: false, error: 'Action cancelled by user' };
+    /**
+     * Execute multiple actions in sequence or parallel.
+     */
+    async executeChain(actions, mode = 'sequential') {
+        if (actions.length === 0) {
+            return { success: true };
+        }
+        if (mode === 'parallel') {
+            const results = await Promise.allSettled(actions.map(a => this.execute(a)));
+            const failures = results.filter(r => r.status === 'rejected' || (r.status === 'fulfilled' && !r.value.success));
+            if (failures.length > 0) {
+                const firstFail = results.find(r => r.status === 'fulfilled' && !r.value.success);
+                return {
+                    success: false,
+                    error: firstFail?.value?.error || 'One or more parallel actions failed',
+                };
+            }
+            const lastResult = results[results.length - 1];
+            return lastResult.status === 'fulfilled'
+                ? lastResult.value
+                : { success: false, error: 'Action failed' };
+        }
+        // Sequential execution — stop on first failure
+        let lastResult = { success: true };
+        for (const action of actions) {
+            lastResult = await this.execute(action);
+            if (!lastResult.success) {
+                return lastResult;
+            }
+        }
+        return lastResult;
+    }
+    /**
+     * Post-execution: emit toast notifications, handle chaining, callbacks.
+     */
+    async handlePostExecution(action, result) {
+        // Toast notifications
+        if (this.toastHandler) {
+            const showToast = action.toast ?? { showOnSuccess: true, showOnError: true };
+            const duration = action.toast?.duration;
+            if (result.success && showToast.showOnSuccess !== false) {
+                const message = action.successMessage || 'Action completed successfully';
+                this.toastHandler(message, { type: 'success', duration });
+            }
+            if (!result.success && showToast.showOnError !== false && result.error) {
+                const message = action.errorMessage || result.error;
+                this.toastHandler(message, { type: 'error', duration });
+            }
+        }
+        // Apply refreshAfter from UIActionSchema
+        if (action.refreshAfter && result.success) {
+            result.reload = true;
+        }
+        // Execute chained actions
+        if (action.chain && action.chain.length > 0 && result.success) {
+            const chainResult = await this.executeChain(action.chain, action.chainMode || 'sequential');
+            // Merge chain result
+            if (!chainResult.success) {
+                result.success = false;
+                result.error = chainResult.error;
             }
+            if (chainResult.data)
+                result.data = chainResult.data;
+            if (chainResult.redirect)
+                result.redirect = chainResult.redirect;
+            if (chainResult.reload)
+                result.reload = true;
+        }
+        // Execute onSuccess/onFailure callbacks
+        if (result.success && action.onSuccess) {
+            const callbacks = Array.isArray(action.onSuccess) ? action.onSuccess : [action.onSuccess];
+            await this.executeChain(callbacks, 'sequential');
+        }
+        if (!result.success && action.onFailure) {
+            const callbacks = Array.isArray(action.onFailure) ? action.onFailure : [action.onFailure];
+            await this.executeChain(callbacks, 'sequential');
+        }
+    }
+    /**
+     * Execute script action — evaluates client-side expression via ExpressionEvaluator.
+     * Supports ${} template expressions referencing data, record, user context.
+     */
+    async executeScript(action) {
+        const script = action.execute || action.target;
+        if (!script) {
+            return { success: false, error: 'No script provided for script action' };
+        }
+        try {
+            const result = this.evaluator.evaluate(`\${${script}}`);
+            return { success: true, data: result };
+        }
+        catch (error) {
+            return { success: false, error: `Script execution failed: ${error.message}` };
+        }
+    }
+    /**
+     * Execute URL action — navigate to a URL.
+     * Uses navigationHandler for SPA routing, falls back to window.location.
+     */
+    async executeUrl(action) {
+        const rawUrl = action.target || action.redirect;
+        if (!rawUrl) {
+            return { success: false, error: 'No URL provided for url action' };
+        }
+        const url = this.evaluator.evaluate(rawUrl);
+        if (!this.isValidUrl(url)) {
+            return {
+                success: false,
+                error: 'Invalid URL scheme. Only http://, https://, and relative URLs are allowed.',
+            };
+        }
+        const isExternal = url.startsWith('http://') || url.startsWith('https://');
+        const newTab = action.params?.newTab ?? isExternal;
+        if (this.navigationHandler) {
+            this.navigationHandler(url, { external: isExternal, newTab });
+            return { success: true };
+        }
+        if (newTab) {
+            window.open(url, '_blank', 'noopener,noreferrer');
+        }
+        else {
+            return { success: true, redirect: url };
+        }
+        return { success: true };
+    }
+    /**
+     * Execute modal action — open a dialog.
+     * Delegates to the registered modalHandler; returns modal schema if no handler.
+     */
+    async executeModal(action) {
+        const modalSchema = action.modal || action.target || action.params?.schema;
+        if (!modalSchema) {
+            return { success: false, error: 'No modal schema or target provided for modal action' };
         }
-        if (action.api) {
+        if (this.modalHandler) {
+            return await this.modalHandler(modalSchema, this.context);
+        }
+        // Return the modal schema for the consumer to render
+        return { success: true, modal: modalSchema };
+    }
+    /**
+     * Execute flow action — trigger a workflow/automation.
+     * Delegates to a registered 'flow' handler; otherwise returns not-implemented.
+     */
+    async executeFlow(action) {
+        const flowName = action.target || action.name;
+        if (!flowName) {
+            return { success: false, error: 'No flow target provided for flow action' };
+        }
+        // Check for a registered flow handler (consumers register via registerHandler)
+        if (this.handlers.has('flow')) {
+            const handler = this.handlers.get('flow');
+            return await handler(action, this.context);
+        }
+        return {
+            success: false,
+            error: `Flow handler not registered. Cannot execute flow: ${flowName}`,
+        };
+    }
+    async executeActionSchema(action) {
+        const result = { success: true };
+        if (action.api || action.endpoint) {
             const apiResult = await this.executeAPI(action);
             if (!apiResult.success)
                 return apiResult;
@@ -101,19 +388,23 @@ export class ActionRunner {
      */
     async executeNavigation(action) {
         const nav = action.navigate || action;
-        const to = this.evaluator.evaluate(nav.to);
-        // Validate URL to prevent javascript: or data: schemes
-        const isValidUrl = typeof to === 'string' && (to.startsWith('http://') ||
-            to.startsWith('https://') ||
-            to.startsWith('/') ||
-            to.startsWith('./'));
-        if (!isValidUrl) {
+        const to = this.evaluator.evaluate(nav.to || nav.target);
+        if (!this.isValidUrl(to)) {
             return {
                 success: false,
-                error: 'Invalid URL scheme. Only http://, https://, and relative URLs are allowed.'
+                error: 'Invalid URL scheme. Only http://, https://, and relative URLs are allowed.',
             };
         }
-        if (nav.external) {
+        const isExternal = nav.external || (typeof to === 'string' && (to.startsWith('http://') || to.startsWith('https://')));
+        if (this.navigationHandler) {
+            this.navigationHandler(to, {
+                external: isExternal,
+                newTab: nav.newTab ?? isExternal,
+                replace: nav.replace,
+            });
+            return { success: true };
+        }
+        if (isExternal) {
             window.open(to, '_blank', 'noopener,noreferrer');
         }
         else {
@@ -121,30 +412,82 @@ export class ActionRunner {
         }
         return { success: true };
     }
+    /**
+     * Execute API action — supports both simple string endpoint and complex ApiConfig.
+     */
     async executeAPI(action) {
-        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}`);
+        // Resolve the endpoint: api (string/object), endpoint, or target
+        const apiConfig = action.api || action.endpoint || action.target;
+        if (!apiConfig) {
+            return { success: false, error: 'No API endpoint provided' };
+        }
+        try {
+            let url;
+            let method;
+            let headers = { 'Content-Type': 'application/json' };
+            let body = undefined;
+            let responseType = 'json';
+            if (typeof apiConfig === 'string') {
+                // Simple string endpoint
+                url = apiConfig;
+                method = action.method || 'POST';
+                body = JSON.stringify(action.params || this.context.data || {});
+            }
+            else {
+                // Complex ApiConfig
+                const config = apiConfig;
+                url = config.url;
+                method = config.method || action.method || 'POST';
+                headers = { ...headers, ...config.headers };
+                responseType = config.responseType || 'json';
+                // Build query params
+                if (config.queryParams) {
+                    const searchParams = new URLSearchParams(config.queryParams);
+                    url = `${url}${url.includes('?') ? '&' : '?'}${searchParams.toString()}`;
                 }
-                const data = await response.json();
-                return { success: true, data };
+                // Build body
+                if (config.body) {
+                    body = typeof config.body === 'string'
+                        ? config.body
+                        : JSON.stringify(config.body);
+                }
+                else if (method !== 'GET' && method !== 'HEAD') {
+                    body = JSON.stringify(action.params || this.context.data || {});
+                }
+            }
+            const fetchInit = { method, headers };
+            if (body && method !== 'GET' && method !== 'HEAD') {
+                fetchInit.body = body;
+            }
+            const response = await fetch(url, fetchInit);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
             }
-            catch (error) {
-                return { success: false, error: error.message };
+            let data;
+            switch (responseType) {
+                case 'text':
+                    data = await response.text();
+                    break;
+                case 'blob':
+                    data = await response.blob();
+                    break;
+                default:
+                    data = await response.json();
             }
+            return { success: true, data };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
         }
-        return { success: false, error: 'Complex API configuration not yet implemented' };
     }
-    async showConfirmation(message) {
-        const evaluatedMessage = this.evaluator.evaluate(message);
-        return window.confirm(evaluatedMessage);
+    /**
+     * Validate URL to prevent javascript: or data: protocol injection.
+     */
+    isValidUrl(url) {
+        return typeof url === 'string' && (url.startsWith('http://') ||
+            url.startsWith('https://') ||
+            url.startsWith('/') ||
+            url.startsWith('./'));
     }
     updateContext(newContext) {
         this.context = { ...this.context, ...newContext };
@@ -153,7 +496,16 @@ export class ActionRunner {
     getContext() {
         return this.context;
     }
+    /**
+     * Get the expression evaluator (for components that need to evaluate visibility, etc.)
+     */
+    getEvaluator() {
+        return this.evaluator;
+    }
 }
+/**
+ * Convenience function to execute a single action with a one-off runner.
+ */
 export async function executeAction(action, context = {}) {
     const runner = new ActionRunner(context);
     return await runner.execute(action);