@memberjunction/core-actions 2.54.0 → 2.55.0

package/dist/custom/workflow/delay.action.js

@@ -0,0 +1,187 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadDelayAction = exports.DelayAction = void 0;
+const global_1 = require("@memberjunction/global");
+const actions_1 = require("@memberjunction/actions");
+/**
+ * Action that adds delays to workflows
+ *
+ * @example
+ * ```typescript
+ * // Fixed delay
+ * await runAction({
+ *   ActionName: 'Delay',
+ *   Params: [{
+ *     Name: 'DelayMs',
+ *     Value: 5000
+ *   }]
+ * });
+ *
+ * // Random delay between min and max
+ * await runAction({
+ *   ActionName: 'Delay',
+ *   Params: [{
+ *     Name: 'DelayType',
+ *     Value: 'random'
+ *   }, {
+ *     Name: 'MinDelayMs',
+ *     Value: 1000
+ *   }, {
+ *     Name: 'MaxDelayMs',
+ *     Value: 5000
+ *   }]
+ * });
+ *
+ * // Delay with message
+ * await runAction({
+ *   ActionName: 'Delay',
+ *   Params: [{
+ *     Name: 'DelayMs',
+ *     Value: 3000
+ *   }, {
+ *     Name: 'Message',
+ *     Value: 'Waiting for external system to process...'
+ *   }]
+ * });
+ * ```
+ */
+let DelayAction = class DelayAction extends actions_1.BaseAction {
+    /**
+     * Adds a delay to the workflow
+     *
+     * @param params - The action parameters containing:
+     *   - DelayMs: Delay in milliseconds (required for fixed delay)
+     *   - DelayType: "fixed" | "random" (default: "fixed")
+     *   - MinDelayMs: Minimum delay for random delays (required for random)
+     *   - MaxDelayMs: Maximum delay for random delays (required for random)
+     *   - Message: Optional message to include in result
+     *
+     * @returns Success with actual delay applied
+     */
+    async InternalRunAction(params) {
+        try {
+            const delayType = (this.getParamValue(params, 'delaytype') || 'fixed').toLowerCase();
+            const message = this.getParamValue(params, 'message');
+            let actualDelay;
+            if (delayType === 'random') {
+                // Random delay
+                const minDelay = this.getNumericParam(params, 'mindelayms', 0);
+                const maxDelay = this.getNumericParam(params, 'maxdelayms', 0);
+                if (minDelay < 0 || maxDelay < 0) {
+                    return {
+                        Success: false,
+                        Message: "Delay values must be non-negative",
+                        ResultCode: "INVALID_DELAY"
+                    };
+                }
+                if (minDelay > maxDelay) {
+                    return {
+                        Success: false,
+                        Message: "MinDelayMs must be less than or equal to MaxDelayMs",
+                        ResultCode: "INVALID_DELAY_RANGE"
+                    };
+                }
+                // Calculate random delay
+                actualDelay = Math.floor(minDelay + Math.random() * (maxDelay - minDelay + 1));
+            }
+            else {
+                // Fixed delay
+                actualDelay = this.getNumericParam(params, 'delayms', 0);
+                if (actualDelay < 0) {
+                    return {
+                        Success: false,
+                        Message: "DelayMs must be non-negative",
+                        ResultCode: "INVALID_DELAY"
+                    };
+                }
+            }
+            // Record start time
+            const startTime = Date.now();
+            // Perform the delay
+            await this.delay(actualDelay);
+            // Calculate actual elapsed time
+            const elapsedTime = Date.now() - startTime;
+            // Add output parameters
+            params.Params.push({
+                Name: 'ActualDelayMs',
+                Type: 'Output',
+                Value: actualDelay
+            });
+            params.Params.push({
+                Name: 'ElapsedTimeMs',
+                Type: 'Output',
+                Value: elapsedTime
+            });
+            params.Params.push({
+                Name: 'DelayType',
+                Type: 'Output',
+                Value: delayType
+            });
+            // Build result message
+            const resultData = {
+                message: message || `Delay completed`,
+                delayType: delayType,
+                requestedDelayMs: actualDelay,
+                actualElapsedMs: elapsedTime,
+                timeDifference: elapsedTime - actualDelay
+            };
+            if (delayType === 'random') {
+                resultData.minDelayMs = this.getNumericParam(params, 'mindelayms', 0);
+                resultData.maxDelayMs = this.getNumericParam(params, 'maxdelayms', 0);
+            }
+            return {
+                Success: true,
+                ResultCode: "DELAY_COMPLETED",
+                Message: JSON.stringify(resultData, null, 2)
+            };
+        }
+        catch (error) {
+            return {
+                Success: false,
+                Message: `Delay action failed: ${error instanceof Error ? error.message : String(error)}`,
+                ResultCode: "DELAY_FAILED"
+            };
+        }
+    }
+    /**
+     * Perform the actual delay
+     */
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Get numeric parameter with default
+     */
+    getNumericParam(params, name, defaultValue) {
+        const value = this.getParamValue(params, name);
+        if (value === undefined || value === null)
+            return defaultValue;
+        const num = Number(value);
+        return isNaN(num) ? defaultValue : num;
+    }
+    /**
+     * Get parameter value by name (case-insensitive)
+     */
+    getParamValue(params, name) {
+        const param = params.Params.find(p => p.Name.toLowerCase() === name.toLowerCase());
+        return param?.Value;
+    }
+};
+exports.DelayAction = DelayAction;
+exports.DelayAction = DelayAction = __decorate([
+    (0, global_1.RegisterClass)(actions_1.BaseAction, "Delay")
+], DelayAction);
+/**
+ * Loader function to ensure the DelayAction class is included in the bundle
+ */
+function LoadDelayAction() {
+    // Stub function to prevent tree shaking
+}
+exports.LoadDelayAction = LoadDelayAction;
+//# sourceMappingURL=delay.action.js.map

package/dist/custom/workflow/delay.action.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delay.action.js","sourceRoot":"","sources":["../../../src/custom/workflow/delay.action.ts"],"names":[],"mappings":"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"}

package/dist/custom/workflow/loop.action.d.ts

@@ -0,0 +1,112 @@
+import { ActionResultSimple, RunActionParams } from "@memberjunction/actions-base";
+import { BaseAction } from "@memberjunction/actions";
+/**
+ * Action that iterates over collections executing actions for each item
+ *
+ * @example
+ * ```typescript
+ * // Process array of items
+ * await runAction({
+ *   ActionName: 'Loop',
+ *   Params: [{
+ *     Name: 'Items',
+ *     Value: [
+ *       { name: 'John', email: 'john@example.com' },
+ *       { name: 'Jane', email: 'jane@example.com' }
+ *     ]
+ *   }, {
+ *     Name: 'ItemVariableName',
+ *     Value: 'user'
+ *   }, {
+ *     Name: 'Action',
+ *     Value: {
+ *       ActionName: 'Send Single Message',
+ *       Params: {
+ *         To: '{{user.email}}',
+ *         Subject: 'Welcome {{user.name}}'
+ *       }
+ *     }
+ *   }]
+ * });
+ *
+ * // Parallel processing with limit
+ * await runAction({
+ *   ActionName: 'Loop',
+ *   Params: [{
+ *     Name: 'Items',
+ *     Value: fileUrls
+ *   }, {
+ *     Name: 'Parallel',
+ *     Value: true
+ *   }, {
+ *     Name: 'MaxConcurrent',
+ *     Value: 5
+ *   }, {
+ *     Name: 'Action',
+ *     Value: {
+ *       ActionName: 'Web Page Content',
+ *       Params: { URL: '{{item}}' }
+ *     }
+ *   }]
+ * });
+ * ```
+ */
+export declare class LoopAction extends BaseAction {
+    /**
+     * Iterates over collections executing actions
+     *
+     * @param params - The action parameters containing:
+     *   - Items: Array to iterate over (required)
+     *   - ItemVariableName: Variable name for current item (default: 'item')
+     *   - IndexVariableName: Variable name for current index (default: 'index')
+     *   - Action: Action configuration to execute per item (required)
+     *   - Parallel: Boolean - run iterations in parallel (default: false)
+     *   - MaxConcurrent: Max parallel executions (default: 10)
+     *   - ContinueOnError: Boolean - continue if an iteration fails (default: false)
+     *   - IncludeContext: Additional context to pass to each action (optional)
+     *
+     * @returns Array of results from each iteration
+     */
+    protected InternalRunAction(params: RunActionParams): Promise<ActionResultSimple>;
+    /**
+     * Execute a single iteration
+     */
+    private executeIteration;
+    /**
+     * Prepare action configuration with template replacement
+     */
+    private prepareActionConfig;
+    /**
+     * Replace template variables in object recursively
+     */
+    private replaceTemplates;
+    /**
+     * Replace template variables in a string
+     */
+    private replaceTemplateString;
+    /**
+     * Get value from object by dot-notation path
+     */
+    private getValueByPath;
+    /**
+     * Chunk array into smaller arrays
+     */
+    private chunkArray;
+    /**
+     * Get numeric parameter with default
+     */
+    private getNumericParam;
+    /**
+     * Get boolean parameter with default
+     */
+    private getBooleanParam;
+    /**
+     * Get parameter value by name (case-insensitive)
+     */
+    private getParamValue;
+}
+/**
+ * Loader function to ensure the LoopAction class is included in the bundle
+ */
+export declare function LoadLoopAction(): void;
+//# sourceMappingURL=loop.action.d.ts.map

package/dist/custom/workflow/loop.action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop.action.d.ts","sourceRoot":"","sources":["../../../src/custom/workflow/loop.action.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEnF,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAIrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,qBACa,UAAW,SAAQ,UAAU;IAEtC;;;;;;;;;;;;;;OAcG;cACa,iBAAiB,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA8LvF;;OAEG;YACW,gBAAgB;IAgC9B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAU3B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAqBxB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAS7B;;OAEG;IACH,OAAO,CAAC,cAAc;IAetB;;OAEG;IACH,OAAO,CAAC,UAAU;IAQlB;;OAEG;IACH,OAAO,CAAC,eAAe;IAOvB;;OAEG;IACH,OAAO,CAAC,eAAe;IAUvB;;OAEG;IACH,OAAO,CAAC,aAAa;CAIxB;AAED;;GAEG;AACH,wBAAgB,cAAc,SAE7B"}

package/dist/custom/workflow/loop.action.js

@@ -0,0 +1,380 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadLoopAction = exports.LoopAction = void 0;
+const global_1 = require("@memberjunction/global");
+const actions_1 = require("@memberjunction/actions");
+const actions_2 = require("@memberjunction/actions");
+const json_param_helper_1 = require("../utilities/json-param-helper");
+/**
+ * Action that iterates over collections executing actions for each item
+ *
+ * @example
+ * ```typescript
+ * // Process array of items
+ * await runAction({
+ *   ActionName: 'Loop',
+ *   Params: [{
+ *     Name: 'Items',
+ *     Value: [
+ *       { name: 'John', email: 'john@example.com' },
+ *       { name: 'Jane', email: 'jane@example.com' }
+ *     ]
+ *   }, {
+ *     Name: 'ItemVariableName',
+ *     Value: 'user'
+ *   }, {
+ *     Name: 'Action',
+ *     Value: {
+ *       ActionName: 'Send Single Message',
+ *       Params: {
+ *         To: '{{user.email}}',
+ *         Subject: 'Welcome {{user.name}}'
+ *       }
+ *     }
+ *   }]
+ * });
+ *
+ * // Parallel processing with limit
+ * await runAction({
+ *   ActionName: 'Loop',
+ *   Params: [{
+ *     Name: 'Items',
+ *     Value: fileUrls
+ *   }, {
+ *     Name: 'Parallel',
+ *     Value: true
+ *   }, {
+ *     Name: 'MaxConcurrent',
+ *     Value: 5
+ *   }, {
+ *     Name: 'Action',
+ *     Value: {
+ *       ActionName: 'Web Page Content',
+ *       Params: { URL: '{{item}}' }
+ *     }
+ *   }]
+ * });
+ * ```
+ */
+let LoopAction = class LoopAction extends actions_1.BaseAction {
+    /**
+     * Iterates over collections executing actions
+     *
+     * @param params - The action parameters containing:
+     *   - Items: Array to iterate over (required)
+     *   - ItemVariableName: Variable name for current item (default: 'item')
+     *   - IndexVariableName: Variable name for current index (default: 'index')
+     *   - Action: Action configuration to execute per item (required)
+     *   - Parallel: Boolean - run iterations in parallel (default: false)
+     *   - MaxConcurrent: Max parallel executions (default: 10)
+     *   - ContinueOnError: Boolean - continue if an iteration fails (default: false)
+     *   - IncludeContext: Additional context to pass to each action (optional)
+     *
+     * @returns Array of results from each iteration
+     */
+    async InternalRunAction(params) {
+        try {
+            const items = json_param_helper_1.JSONParamHelper.getJSONParam(params, 'items');
+            const itemVariableName = this.getParamValue(params, 'itemvariablename') || 'item';
+            const indexVariableName = this.getParamValue(params, 'indexvariablename') || 'index';
+            const actionConfig = json_param_helper_1.JSONParamHelper.getJSONParam(params, 'action');
+            const parallel = this.getBooleanParam(params, 'parallel', false);
+            const maxConcurrent = this.getNumericParam(params, 'maxconcurrent', 10);
+            const continueOnError = this.getBooleanParam(params, 'continueonerror', false);
+            const includeContext = json_param_helper_1.JSONParamHelper.getJSONParam(params, 'includecontext') || {};
+            // Validate required parameters
+            if (!items) {
+                return {
+                    Success: false,
+                    Message: "Items parameter is required",
+                    ResultCode: "MISSING_ITEMS"
+                };
+            }
+            if (!Array.isArray(items)) {
+                return {
+                    Success: false,
+                    Message: "Items must be an array",
+                    ResultCode: "INVALID_ITEMS"
+                };
+            }
+            if (!actionConfig) {
+                return {
+                    Success: false,
+                    Message: "Action parameter is required",
+                    ResultCode: "MISSING_ACTION"
+                };
+            }
+            if (!actionConfig.ActionName) {
+                return {
+                    Success: false,
+                    Message: "Action configuration must include ActionName",
+                    ResultCode: "INVALID_ACTION"
+                };
+            }
+            // Track results
+            const results = [];
+            const errors = [];
+            let successCount = 0;
+            let errorCount = 0;
+            // Execute iterations
+            if (parallel) {
+                // Parallel execution with concurrency limit
+                const chunks = this.chunkArray(items, maxConcurrent);
+                for (const chunk of chunks) {
+                    const chunkPromises = chunk.map((item, chunkIndex) => {
+                        const globalIndex = chunks.indexOf(chunk) * maxConcurrent + chunkIndex;
+                        return this.executeIteration(item, globalIndex, itemVariableName, indexVariableName, actionConfig, includeContext, params.ContextUser);
+                    });
+                    const chunkResults = await Promise.allSettled(chunkPromises);
+                    for (let i = 0; i < chunkResults.length; i++) {
+                        const result = chunkResults[i];
+                        const globalIndex = chunks.indexOf(chunk) * maxConcurrent + i;
+                        if (result.status === 'fulfilled') {
+                            results[globalIndex] = result.value;
+                            if (result.value.Success) {
+                                successCount++;
+                            }
+                            else {
+                                errorCount++;
+                                errors.push({ index: globalIndex, error: result.value.Message });
+                                if (!continueOnError)
+                                    break;
+                            }
+                        }
+                        else {
+                            errorCount++;
+                            const errorResult = {
+                                Success: false,
+                                Message: result.reason?.message || String(result.reason),
+                                ResultCode: "ITERATION_ERROR"
+                            };
+                            results[globalIndex] = errorResult;
+                            errors.push({ index: globalIndex, error: result.reason });
+                            if (!continueOnError)
+                                break;
+                        }
+                    }
+                    if (!continueOnError && errorCount > 0)
+                        break;
+                }
+            }
+            else {
+                // Sequential execution
+                for (let i = 0; i < items.length; i++) {
+                    try {
+                        const result = await this.executeIteration(items[i], i, itemVariableName, indexVariableName, actionConfig, includeContext, params.ContextUser);
+                        results.push(result);
+                        if (result.Success) {
+                            successCount++;
+                        }
+                        else {
+                            errorCount++;
+                            errors.push({ index: i, error: result.Message });
+                            if (!continueOnError)
+                                break;
+                        }
+                    }
+                    catch (error) {
+                        errorCount++;
+                        const errorResult = {
+                            Success: false,
+                            Message: error instanceof Error ? error.message : String(error),
+                            ResultCode: "ITERATION_ERROR"
+                        };
+                        results.push(errorResult);
+                        errors.push({ index: i, error: error });
+                        if (!continueOnError)
+                            break;
+                    }
+                }
+            }
+            // Add output parameters
+            params.Params.push({
+                Name: 'Results',
+                Type: 'Output',
+                Value: results
+            });
+            params.Params.push({
+                Name: 'SuccessCount',
+                Type: 'Output',
+                Value: successCount
+            });
+            params.Params.push({
+                Name: 'ErrorCount',
+                Type: 'Output',
+                Value: errorCount
+            });
+            if (errors.length > 0) {
+                params.Params.push({
+                    Name: 'Errors',
+                    Type: 'Output',
+                    Value: errors
+                });
+            }
+            // Determine overall success
+            const allSuccessful = errorCount === 0;
+            const someSuccessful = successCount > 0;
+            return {
+                Success: continueOnError ? someSuccessful : allSuccessful,
+                ResultCode: allSuccessful ? "ALL_SUCCESS" : (someSuccessful ? "PARTIAL_SUCCESS" : "ALL_FAILED"),
+                Message: JSON.stringify({
+                    message: `Loop completed: ${successCount} successful, ${errorCount} failed`,
+                    totalItems: items.length,
+                    successCount: successCount,
+                    errorCount: errorCount,
+                    parallel: parallel,
+                    continueOnError: continueOnError,
+                    errors: errors.length > 0 ? errors : undefined
+                }, null, 2)
+            };
+        }
+        catch (error) {
+            return {
+                Success: false,
+                Message: `Loop action failed: ${error instanceof Error ? error.message : String(error)}`,
+                ResultCode: "LOOP_FAILED"
+            };
+        }
+    }
+    /**
+     * Execute a single iteration
+     */
+    async executeIteration(item, index, itemVariableName, indexVariableName, actionConfig, includeContext, contextUser) {
+        // Build context for this iteration
+        const iterationContext = {
+            ...includeContext,
+            [itemVariableName]: item,
+            [indexVariableName]: index
+        };
+        // Prepare action configuration with context
+        const preparedConfig = this.prepareActionConfig(actionConfig, iterationContext);
+        // Execute the action
+        const engine = new actions_2.ActionEngineServer();
+        const result = await engine.RunAction(preparedConfig);
+        // Convert ActionResult to ActionResultSimple
+        return {
+            Success: result.Success,
+            ResultCode: result.Result?.ResultCode || (result.Success ? "SUCCESS" : "FAILED"),
+            Message: result.Message,
+            Params: result.Params
+        };
+    }
+    /**
+     * Prepare action configuration with template replacement
+     */
+    prepareActionConfig(actionConfig, context) {
+        // Deep clone the config
+        const preparedConfig = JSON.parse(JSON.stringify(actionConfig));
+        // Replace templates in the configuration
+        this.replaceTemplates(preparedConfig, context);
+        return preparedConfig;
+    }
+    /**
+     * Replace template variables in object recursively
+     */
+    replaceTemplates(obj, context) {
+        if (typeof obj === 'string') {
+            // Can't modify string in place, would need parent reference
+            return;
+        }
+        for (const key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                const value = obj[key];
+                if (typeof value === 'string') {
+                    // Replace template variables
+                    obj[key] = this.replaceTemplateString(value, context);
+                }
+                else if (typeof value === 'object' && value !== null) {
+                    // Recurse into objects and arrays
+                    this.replaceTemplates(value, context);
+                }
+            }
+        }
+    }
+    /**
+     * Replace template variables in a string
+     */
+    replaceTemplateString(template, context) {
+        // Simple template replacement for {{variable}} and {{object.property}}
+        return template.replace(/\{\{([^}]+)\}\}/g, (match, path) => {
+            const trimmedPath = path.trim();
+            const value = this.getValueByPath(context, trimmedPath);
+            return value !== undefined ? String(value) : match;
+        });
+    }
+    /**
+     * Get value from object by dot-notation path
+     */
+    getValueByPath(obj, path) {
+        const parts = path.split('.');
+        let current = obj;
+        for (const part of parts) {
+            if (current && typeof current === 'object' && part in current) {
+                current = current[part];
+            }
+            else {
+                return undefined;
+            }
+        }
+        return current;
+    }
+    /**
+     * Chunk array into smaller arrays
+     */
+    chunkArray(array, size) {
+        const chunks = [];
+        for (let i = 0; i < array.length; i += size) {
+            chunks.push(array.slice(i, i + size));
+        }
+        return chunks;
+    }
+    /**
+     * Get numeric parameter with default
+     */
+    getNumericParam(params, name, defaultValue) {
+        const value = this.getParamValue(params, name);
+        if (value === undefined || value === null)
+            return defaultValue;
+        const num = Number(value);
+        return isNaN(num) ? defaultValue : num;
+    }
+    /**
+     * Get boolean parameter with default
+     */
+    getBooleanParam(params, name, defaultValue) {
+        const value = this.getParamValue(params, name);
+        if (value === undefined || value === null)
+            return defaultValue;
+        if (typeof value === 'boolean')
+            return value;
+        if (typeof value === 'string') {
+            return value.toLowerCase() === 'true';
+        }
+        return defaultValue;
+    }
+    /**
+     * Get parameter value by name (case-insensitive)
+     */
+    getParamValue(params, name) {
+        const param = params.Params.find(p => p.Name.toLowerCase() === name.toLowerCase());
+        return param?.Value;
+    }
+};
+exports.LoopAction = LoopAction;
+exports.LoopAction = LoopAction = __decorate([
+    (0, global_1.RegisterClass)(actions_1.BaseAction, "Loop")
+], LoopAction);
+/**
+ * Loader function to ensure the LoopAction class is included in the bundle
+ */
+function LoadLoopAction() {
+    // Stub function to prevent tree shaking
+}
+exports.LoadLoopAction = LoadLoopAction;
+//# sourceMappingURL=loop.action.js.map