@xtr-dev/payload-automation 0.0.43 → 0.0.46

package/dist/core/expression-engine.js

@@ -0,0 +1,191 @@
+import jsonata from 'jsonata';
+// Cache compiled expressions for performance
+const expressionCache = new Map();
+const MAX_CACHE_SIZE = 1000;
+/**
+ * Compile a JSONata expression with caching
+ */ function compileExpression(expression) {
+    let compiled = expressionCache.get(expression);
+    if (!compiled) {
+        compiled = jsonata(expression);
+        // Register custom functions
+        registerCustomFunctions(compiled);
+        // Manage cache size
+        if (expressionCache.size >= MAX_CACHE_SIZE) {
+            const firstKey = expressionCache.keys().next().value;
+            if (firstKey) expressionCache.delete(firstKey);
+        }
+        expressionCache.set(expression, compiled);
+    }
+    return compiled;
+}
+/**
+ * Register custom functions on a JSONata expression
+ */ function registerCustomFunctions(expr) {
+    // $env(name) - Get environment variable (only non-sensitive ones)
+    expr.registerFunction('env', (name)=>{
+        // Only allow specific prefixes for security
+        if (typeof name === 'string' && name.startsWith('PUBLIC_')) {
+            return process.env[name];
+        }
+        return undefined;
+    }, '<s:s>');
+    // $now() - Current ISO timestamp
+    expr.registerFunction('now', ()=>new Date().toISOString(), '<:s>');
+    // $timestamp() - Current Unix timestamp in milliseconds
+    expr.registerFunction('timestamp', ()=>Date.now(), '<:n>');
+    // $uuid() - Generate a UUID v4
+    expr.registerFunction('uuid', ()=>{
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c)=>{
+            const r = Math.random() * 16 | 0;
+            const v = c === 'x' ? r : r & 0x3 | 0x8;
+            return v.toString(16);
+        });
+    }, '<:s>');
+    // $default(value, defaultValue) - Return default if value is null/undefined
+    expr.registerFunction('default', (value, defaultValue)=>{
+        return value === null || value === undefined ? defaultValue : value;
+    }, '<xx:x>');
+    // $json(value) - Parse JSON string
+    expr.registerFunction('json', (value)=>{
+        try {
+            return JSON.parse(value);
+        } catch  {
+            return undefined;
+        }
+    }, '<s:x>');
+    // $stringify(value) - Convert to JSON string
+    expr.registerFunction('stringify', (value)=>{
+        try {
+            return JSON.stringify(value);
+        } catch  {
+            return undefined;
+        }
+    }, '<x:s>');
+    // $keys(object) - Get object keys
+    expr.registerFunction('keys', (obj)=>{
+        if (obj && typeof obj === 'object' && !Array.isArray(obj)) {
+            return Object.keys(obj);
+        }
+        return [];
+    }, '<o:a>');
+    // $values(object) - Get object values
+    expr.registerFunction('values', (obj)=>{
+        if (obj && typeof obj === 'object' && !Array.isArray(obj)) {
+            return Object.values(obj);
+        }
+        return [];
+    }, '<o:a>');
+    // $has(object, key) - Check if object has key
+    expr.registerFunction('has', (obj, key)=>{
+        if (obj && typeof obj === 'object') {
+            return key in obj;
+        }
+        return false;
+    }, '<os:b>');
+    // $coalesce(values...) - Return first non-null value
+    expr.registerFunction('coalesce', (...values)=>{
+        for (const v of values){
+            if (v !== null && v !== undefined) {
+                return v;
+            }
+        }
+        return null;
+    }, '<x+:x>');
+}
+/**
+ * Evaluate a JSONata expression against a context
+ */ export async function evaluate(expression, context, options = {}) {
+    const { timeout = 5000 } = options;
+    const compiled = compileExpression(expression);
+    // Create a promise that rejects on timeout
+    const timeoutPromise = new Promise((_, reject)=>{
+        setTimeout(()=>reject(new Error(`Expression evaluation timed out after ${timeout}ms`)), timeout);
+    });
+    // Race between evaluation and timeout
+    return Promise.race([
+        compiled.evaluate(context),
+        timeoutPromise
+    ]);
+}
+/**
+ * Evaluate a condition expression and return a boolean
+ */ export async function evaluateCondition(expression, context, options = {}) {
+    try {
+        const result = await evaluate(expression, context, options);
+        // Convert result to boolean
+        if (result === undefined || result === null) {
+            return false;
+        }
+        if (typeof result === 'boolean') {
+            return result;
+        }
+        if (typeof result === 'number') {
+            return result !== 0;
+        }
+        if (typeof result === 'string') {
+            return result.length > 0;
+        }
+        if (Array.isArray(result)) {
+            return result.length > 0;
+        }
+        return true;
+    } catch (error) {
+        // Log error but return false for failed conditions
+        console.warn('Condition evaluation failed:', error instanceof Error ? error.message : error);
+        return false;
+    }
+}
+/**
+ * Transform data using a JSONata expression
+ * The expression can be a JSONata query or a JSON object with embedded expressions
+ */ export async function transform(template, context, options = {}) {
+    if (typeof template === 'string') {
+        // Check if it looks like a JSONata expression (starts with common patterns)
+        if (template.startsWith('{') || template.startsWith('[') || template.startsWith('$') || template.includes('.') || template.includes('(')) {
+            try {
+                return await evaluate(template, context, options);
+            } catch  {
+                // If it fails to evaluate, return as literal string
+                return template;
+            }
+        }
+        return template;
+    }
+    if (Array.isArray(template)) {
+        return Promise.all(template.map((item)=>transform(item, context, options)));
+    }
+    if (template && typeof template === 'object') {
+        const result = {};
+        for (const [key, value] of Object.entries(template)){
+            result[key] = await transform(value, context, options);
+        }
+        return result;
+    }
+    return template;
+}
+/**
+ * Resolve a step input configuration using JSONata
+ * Handles both simple values and expressions
+ */ export async function resolveStepInput(config, context, options = {}) {
+    const result = {};
+    for (const [key, value] of Object.entries(config)){
+        result[key] = await transform(value, context, options);
+    }
+    return result;
+}
+/**
+ * Clear the expression cache
+ */ export function clearCache() {
+    expressionCache.clear();
+}
+/**
+ * Get cache statistics
+ */ export function getCacheStats() {
+    return {
+        size: expressionCache.size,
+        maxSize: MAX_CACHE_SIZE
+    };
+}
+
+//# sourceMappingURL=expression-engine.js.map

package/dist/core/expression-engine.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/expression-engine.ts"],"sourcesContent":["import jsonata from 'jsonata'\n\n/**\n * Expression engine using JSONata for safe, sandboxed expression evaluation.\n * Used for both conditions and data transformation in workflows.\n *\n * @example Conditions\n * ```\n * trigger.doc._status = \"published\"\n * trigger.doc.count > 10 and trigger.doc.enabled\n * $exists(steps.validate.output.error) = false\n * ```\n *\n * @example Data Transformation\n * ```\n * {\n *   \"id\": trigger.doc.id,\n *   \"title\": $uppercase(trigger.doc.title),\n *   \"tags\": trigger.doc.tags[category = \"featured\"].name\n * }\n * ```\n */\n\nexport interface ExpressionContext {\n  trigger: Record<string, unknown>\n  steps: Record<string, unknown>\n  [key: string]: unknown\n}\n\nexport interface EvaluateOptions {\n  /** Timeout in milliseconds (default: 5000) */\n  timeout?: number\n}\n\n// Cache compiled expressions for performance\nconst expressionCache = new Map<string, jsonata.Expression>()\nconst MAX_CACHE_SIZE = 1000\n\n/**\n * Compile a JSONata expression with caching\n */\nfunction compileExpression(expression: string): jsonata.Expression {\n  let compiled = expressionCache.get(expression)\n\n  if (!compiled) {\n    compiled = jsonata(expression)\n\n    // Register custom functions\n    registerCustomFunctions(compiled)\n\n    // Manage cache size\n    if (expressionCache.size >= MAX_CACHE_SIZE) {\n      const firstKey = expressionCache.keys().next().value\n      if (firstKey) expressionCache.delete(firstKey)\n    }\n\n    expressionCache.set(expression, compiled)\n  }\n\n  return compiled\n}\n\n/**\n * Register custom functions on a JSONata expression\n */\nfunction registerCustomFunctions(expr: jsonata.Expression): void {\n  // $env(name) - Get environment variable (only non-sensitive ones)\n  expr.registerFunction('env', (name: string) => {\n    // Only allow specific prefixes for security\n    if (typeof name === 'string' && name.startsWith('PUBLIC_')) {\n      return process.env[name]\n    }\n    return undefined\n  }, '<s:s>')\n\n  // $now() - Current ISO timestamp\n  expr.registerFunction('now', () => new Date().toISOString(), '<:s>')\n\n  // $timestamp() - Current Unix timestamp in milliseconds\n  expr.registerFunction('timestamp', () => Date.now(), '<:n>')\n\n  // $uuid() - Generate a UUID v4\n  expr.registerFunction('uuid', () => {\n    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {\n      const r = (Math.random() * 16) | 0\n      const v = c === 'x' ? r : (r & 0x3) | 0x8\n      return v.toString(16)\n    })\n  }, '<:s>')\n\n  // $default(value, defaultValue) - Return default if value is null/undefined\n  expr.registerFunction('default', (value: unknown, defaultValue: unknown) => {\n    return value === null || value === undefined ? defaultValue : value\n  }, '<xx:x>')\n\n  // $json(value) - Parse JSON string\n  expr.registerFunction('json', (value: string) => {\n    try {\n      return JSON.parse(value)\n    } catch {\n      return undefined\n    }\n  }, '<s:x>')\n\n  // $stringify(value) - Convert to JSON string\n  expr.registerFunction('stringify', (value: unknown) => {\n    try {\n      return JSON.stringify(value)\n    } catch {\n      return undefined\n    }\n  }, '<x:s>')\n\n  // $keys(object) - Get object keys\n  expr.registerFunction('keys', (obj: Record<string, unknown>) => {\n    if (obj && typeof obj === 'object' && !Array.isArray(obj)) {\n      return Object.keys(obj)\n    }\n    return []\n  }, '<o:a>')\n\n  // $values(object) - Get object values\n  expr.registerFunction('values', (obj: Record<string, unknown>) => {\n    if (obj && typeof obj === 'object' && !Array.isArray(obj)) {\n      return Object.values(obj)\n    }\n    return []\n  }, '<o:a>')\n\n  // $has(object, key) - Check if object has key\n  expr.registerFunction('has', (obj: Record<string, unknown>, key: string) => {\n    if (obj && typeof obj === 'object') {\n      return key in obj\n    }\n    return false\n  }, '<os:b>')\n\n  // $coalesce(values...) - Return first non-null value\n  expr.registerFunction('coalesce', (...values: unknown[]) => {\n    for (const v of values) {\n      if (v !== null && v !== undefined) {\n        return v\n      }\n    }\n    return null\n  }, '<x+:x>')\n}\n\n/**\n * Evaluate a JSONata expression against a context\n */\nexport async function evaluate(\n  expression: string,\n  context: ExpressionContext,\n  options: EvaluateOptions = {}\n): Promise<unknown> {\n  const { timeout = 5000 } = options\n\n  const compiled = compileExpression(expression)\n\n  // Create a promise that rejects on timeout\n  const timeoutPromise = new Promise<never>((_, reject) => {\n    setTimeout(() => reject(new Error(`Expression evaluation timed out after ${timeout}ms`)), timeout)\n  })\n\n  // Race between evaluation and timeout\n  return Promise.race([\n    compiled.evaluate(context),\n    timeoutPromise\n  ])\n}\n\n/**\n * Evaluate a condition expression and return a boolean\n */\nexport async function evaluateCondition(\n  expression: string,\n  context: ExpressionContext,\n  options: EvaluateOptions = {}\n): Promise<boolean> {\n  try {\n    const result = await evaluate(expression, context, options)\n\n    // Convert result to boolean\n    if (result === undefined || result === null) {\n      return false\n    }\n    if (typeof result === 'boolean') {\n      return result\n    }\n    if (typeof result === 'number') {\n      return result !== 0\n    }\n    if (typeof result === 'string') {\n      return result.length > 0\n    }\n    if (Array.isArray(result)) {\n      return result.length > 0\n    }\n    return true\n  } catch (error) {\n    // Log error but return false for failed conditions\n    console.warn('Condition evaluation failed:', error instanceof Error ? error.message : error)\n    return false\n  }\n}\n\n/**\n * Transform data using a JSONata expression\n * The expression can be a JSONata query or a JSON object with embedded expressions\n */\nexport async function transform(\n  template: unknown,\n  context: ExpressionContext,\n  options: EvaluateOptions = {}\n): Promise<unknown> {\n  if (typeof template === 'string') {\n    // Check if it looks like a JSONata expression (starts with common patterns)\n    if (\n      template.startsWith('{') ||\n      template.startsWith('[') ||\n      template.startsWith('$') ||\n      template.includes('.') ||\n      template.includes('(')\n    ) {\n      try {\n        return await evaluate(template, context, options)\n      } catch {\n        // If it fails to evaluate, return as literal string\n        return template\n      }\n    }\n    return template\n  }\n\n  if (Array.isArray(template)) {\n    return Promise.all(template.map(item => transform(item, context, options)))\n  }\n\n  if (template && typeof template === 'object') {\n    const result: Record<string, unknown> = {}\n    for (const [key, value] of Object.entries(template)) {\n      result[key] = await transform(value, context, options)\n    }\n    return result\n  }\n\n  return template\n}\n\n/**\n * Resolve a step input configuration using JSONata\n * Handles both simple values and expressions\n */\nexport async function resolveStepInput(\n  config: Record<string, unknown>,\n  context: ExpressionContext,\n  options: EvaluateOptions = {}\n): Promise<Record<string, unknown>> {\n  const result: Record<string, unknown> = {}\n\n  for (const [key, value] of Object.entries(config)) {\n    result[key] = await transform(value, context, options)\n  }\n\n  return result\n}\n\n/**\n * Clear the expression cache\n */\nexport function clearCache(): void {\n  expressionCache.clear()\n}\n\n/**\n * Get cache statistics\n */\nexport function getCacheStats(): { size: number; maxSize: number } {\n  return {\n    size: expressionCache.size,\n    maxSize: MAX_CACHE_SIZE\n  }\n}\n"],"names":["jsonata","expressionCache","Map","MAX_CACHE_SIZE","compileExpression","expression","compiled","get","registerCustomFunctions","size","firstKey","keys","next","value","delete","set","expr","registerFunction","name","startsWith","process","env","undefined","Date","toISOString","now","replace","c","r","Math","random","v","toString","defaultValue","JSON","parse","stringify","obj","Array","isArray","Object","values","key","evaluate","context","options","timeout","timeoutPromise","Promise","_","reject","setTimeout","Error","race","evaluateCondition","result","length","error","console","warn","message","transform","template","includes","all","map","item","entries","resolveStepInput","config","clearCache","clear","getCacheStats","maxSize"],"mappings":"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"}

package/dist/core/workflow-executor.d.ts

@@ -1,90 +1,104 @@
 import type { Payload, PayloadRequest } from 'payload';
+/**
+ * Type for workflow data from the refactored collection
+ */
 export type PayloadWorkflow = {
-    id: number;
+    id: number | string;
     name: string;
-    description?: null | string;
-    triggers?: Array<{
-        type?: null | string;
-        condition?: null | string;
-        parameters?: {
-            collectionSlug?: null | string;
-            operation?: null | string;
-            global?: null | string;
-            globalOperation?: null | string;
-            [key: string]: unknown;
-        } | null;
-        [key: string]: unknown;
-    }> | null;
+    description?: string | null;
+    enabled?: boolean;
+    triggers?: Array<any> | null;
     steps?: Array<{
-        type?: null | string;
-        name?: null | string;
-        input?: unknown;
-        dependencies?: null | string[];
-        condition?: null | string;
-        [key: string]: unknown;
+        id?: string;
+        step: any;
+        stepName?: string | null;
+        inputOverrides?: Record<string, unknown> | null;
+        condition?: string | null;
+        dependencies?: Array<{
+            stepIndex: number;
+        }> | null;
+        position?: {
+            x: number;
+            y: number;
+        } | null;
     }> | null;
+    errorHandling?: 'stop' | 'continue' | 'retry' | null;
+    maxRetries?: number | null;
+    retryDelay?: number | null;
+    timeout?: number | null;
     [key: string]: unknown;
 };
-export type WorkflowStep = {
-    name: string;
-} & NonNullable<PayloadWorkflow['steps']>[0];
-export type WorkflowTrigger = {
-    type: string;
-} & NonNullable<PayloadWorkflow['triggers']>[0];
+/**
+ * Type for a resolved workflow step (with base step data merged)
+ */
+export type ResolvedStep = {
+    stepIndex: number;
+    stepId: string | number;
+    stepName: string;
+    stepType: string;
+    config: Record<string, unknown>;
+    condition?: string | null;
+    dependencies: number[];
+    retryOnFailure?: boolean;
+    maxRetries?: number;
+    retryDelay?: number;
+};
 export interface ExecutionContext {
     steps: Record<string, any>;
     trigger: Record<string, any>;
 }
+export interface StepResult {
+    step?: string | number;
+    stepName: string;
+    stepIndex: number;
+    status: 'pending' | 'running' | 'succeeded' | 'failed' | 'skipped';
+    startedAt?: string;
+    completedAt?: string;
+    duration?: number;
+    input?: Record<string, unknown>;
+    output?: Record<string, unknown>;
+    error?: string;
+    retryCount?: number;
+}
+/**
+ * Workflow context stored on jobs created by workflow execution.
+ * Uses relationship IDs that link to the respective collections.
+ */
+export interface WorkflowJobMeta {
+    automationWorkflowId: string | number;
+    automationWorkflowRunId: string | number;
+    automationTriggerId?: string | number;
+}
 export declare class WorkflowExecutor {
     private payload;
     private logger;
     constructor(payload: Payload, logger: Payload['logger']);
     /**
-     * Convert string values to appropriate types based on common patterns
-     */
-    private convertValueType;
-    /**
-     * Classifies error types based on error messages
+     * Resolve workflow steps by loading base step configurations and merging with overrides
      */
-    private classifyErrorType;
+    private resolveWorkflowSteps;
     /**
-     * Evaluate a step condition using JSONPath
+     * Resolve step execution order based on dependencies
      */
-    private evaluateStepCondition;
+    private resolveExecutionOrder;
     /**
      * Execute a single workflow step
      */
     private executeStep;
     /**
-     * Extracts detailed error information from job logs and input
-     */
-    private extractErrorDetailsFromJob;
-    /**
-     * Resolve step execution order based on dependencies
-     */
-    private resolveExecutionOrder;
-    /**
-     * Resolve step input using Handlebars templates with automatic type conversion
+     * Resolve step input using JSONata expressions
      */
     private resolveStepInput;
     /**
-     * Safely serialize an object, handling circular references and non-serializable values
+     * Evaluate a condition using JSONata
      */
-    private safeSerialize;
+    evaluateCondition(condition: string, context: ExecutionContext): Promise<boolean>;
     /**
-     * Update workflow run with current context
+     * Safely serialize an object for storage
      */
-    private updateWorkflowRunContext;
-    /**
-     * Evaluate a condition using Handlebars templates and comparison operators
-     */
-    evaluateCondition(condition: string, context: ExecutionContext): boolean;
-    /**
-     * Resolve a condition value using Handlebars templates or JSONPath
-     */
-    private resolveConditionValue;
+    private safeSerialize;
     /**
      * Execute a workflow with the given context
      */
-    execute(workflow: PayloadWorkflow, context: ExecutionContext, req: PayloadRequest): Promise<void>;
+    execute(workflow: PayloadWorkflow, context: ExecutionContext, req: PayloadRequest, firedTrigger?: any): Promise<void>;
 }