@abyss-project/console 1.0.23 → 1.0.26

package/dist/types/dto/workflow.dto.d.ts

@@ -1,4 +1,4 @@
-import { FilterOperator, SwitchConditionOperator, HttpMethod, WorkflowActionType } from '../enum';
+import { HttpMethod, WorkflowActionType } from '../enum';
 export interface IUserRegistrationWorkflowTriggerData {
     userId: string;
     email: string;
@@ -14,19 +14,13 @@ export interface IWebhookWorkflowTriggerData {
 }
 export type WorkflowTriggerData = IUserRegistrationWorkflowTriggerData | IWebhookWorkflowTriggerData | Record<string, any>;
 export interface IFilterStepConfig {
-    filters: Array<{
-        field: string;
-        operator: FilterOperator;
-        value: any;
-    }>;
+    expression: string;
 }
 export interface ISleepStepConfig {
-    duration: number;
+    duration: string | number;
 }
 export interface ISwitchCondition {
-    field: string;
-    operator: SwitchConditionOperator;
-    value: any;
+    expression: string;
     targetStepId: string | null;
 }
 export interface ISwitchStepConfig {

package/dist/types/interface/api/requests/workflow.request.d.ts

@@ -83,6 +83,7 @@ export interface IUpdateWorkflowStepBody {
     continueOnError?: boolean;
     afterStepId?: string | null;
     beforeStepId?: string | null;
+    swapStepId?: string;
     condition?: {
         field: string;
         operator: 'equals' | 'not_equals' | 'contains' | 'greater_than' | 'less_than';

package/dist/types/interface/models/workflow-step-connection.model.d.ts

@@ -1,15 +1,10 @@
-export interface WorkflowCondition {
-    field: string;
-    operator: 'equals' | 'not_equals' | 'contains' | 'greater_than' | 'less_than';
-    value: any;
-}
 export interface IWorkflowStepConnection {
     id: string;
     workflowId: string;
     fromStepId: string | null;
     toStepId: string | null;
     label: string | null;
-    condition: WorkflowCondition | null;
+    expression: string | null;
     order: number;
     createdAt?: Date;
     updatedAt?: Date;

package/dist/types/interface/models/workflow-trigger.model.d.ts

@@ -1,9 +1,10 @@
 import { WorkflowTriggerType, FilterOperator } from '../../enum/workflow.enum';
 import { IWorkflow } from './workflow.model';
 export interface ITriggerFilter {
-    field: string;
-    operator: FilterOperator;
-    value: any;
+    expression?: string;
+    field?: string;
+    operator?: FilterOperator;
+    value?: any;
 }
 export interface ITriggerExecutionStats {
     total: number;

package/dist/utils/webhook-trigger.utils.d.ts

@@ -1,4 +1,7 @@
 import { WorkflowTriggerData, FilterOperator, IWorkflowTrigger } from '../types';
+type ExpressionValue = string | number | boolean | null | undefined | unknown[] | Record<string, unknown>;
 export declare const matchesTriggerFilters: (trigger: IWorkflowTrigger, triggerData: WorkflowTriggerData) => boolean;
+export declare const evaluateExpression: (expression: string, context: Record<string, unknown>) => ExpressionValue;
 export declare const getNestedValue: (obj: Record<string, unknown>, path: string) => unknown;
 export declare const evaluateFilter: (value: unknown, operator: FilterOperator, expected: unknown) => boolean;
+export {};

package/dist/utils/webhook-trigger.utils.js

@@ -1,17 +1,298 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.evaluateFilter = exports.getNestedValue = exports.matchesTriggerFilters = void 0;
+exports.evaluateFilter = exports.getNestedValue = exports.evaluateExpression = exports.matchesTriggerFilters = void 0;
 const types_1 = require("../types");
+const OPERATOR_PRECEDENCE = {
+    '||': 1,
+    '&&': 2,
+    '==': 3,
+    '===': 3,
+    '!=': 3,
+    '!==': 3,
+    '<': 4,
+    '<=': 4,
+    '>': 4,
+    '>=': 4,
+    '+': 5,
+    '-': 5,
+    '*': 6,
+    '/': 6,
+    '%': 6,
+    '**': 7,
+};
 const matchesTriggerFilters = (trigger, triggerData) => {
     if (!trigger.filters || trigger.filters.length === 0) {
         return true;
     }
     return trigger.filters.every((filter) => {
-        const value = (0, exports.getNestedValue)(triggerData, filter.field);
-        return (0, exports.evaluateFilter)(value, filter.operator, filter.value);
+        if (filter.expression) {
+            try {
+                const context = { trigger: triggerData };
+                const result = (0, exports.evaluateExpression)(filter.expression, context);
+                return Boolean(result);
+            }
+            catch (error) {
+                console.error('Expression evaluation error:', error);
+                return false;
+            }
+        }
+        if (filter.field && filter.operator) {
+            const value = (0, exports.getNestedValue)(triggerData, filter.field);
+            return (0, exports.evaluateFilter)(value, filter.operator, filter.value);
+        }
+        return true;
     });
 };
 exports.matchesTriggerFilters = matchesTriggerFilters;
+const evaluateExpression = (expression, context) => {
+    const trimmed = expression.trim();
+    const simpleRefMatch = trimmed.match(/^\{\{([^}]+)\}\}$/);
+    if (simpleRefMatch) {
+        return (0, exports.getNestedValue)(context, simpleRefMatch[1].trim());
+    }
+    const tokens = tokenizeExpression(trimmed, context);
+    return evaluateTokens(tokens);
+};
+exports.evaluateExpression = evaluateExpression;
+const tokenizeExpression = (expression, context) => {
+    const tokens = [];
+    let pos = 0;
+    const len = expression.length;
+    while (pos < len) {
+        while (pos < len && /\s/.test(expression[pos])) {
+            pos++;
+        }
+        if (pos >= len)
+            break;
+        const char = expression[pos];
+        if (expression.slice(pos, pos + 2) === '{{') {
+            const endIdx = expression.indexOf('}}', pos + 2);
+            if (endIdx === -1) {
+                throw new Error(`Unclosed expression at position ${pos}`);
+            }
+            const path = expression.slice(pos + 2, endIdx).trim();
+            if (path.includes('|')) {
+                const [refPath, ...pipes] = path.split('|').map(s => s.trim());
+                let value = (0, exports.getNestedValue)(context, refPath);
+                for (const pipe of pipes) {
+                    value = applyPipeOperator(value, pipe);
+                }
+                tokens.push({ type: 'reference', value: value });
+            }
+            else {
+                const value = (0, exports.getNestedValue)(context, path);
+                tokens.push({ type: 'reference', value: value });
+            }
+            pos = endIdx + 2;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            const quote = char;
+            let str = '';
+            pos++;
+            while (pos < len && expression[pos] !== quote) {
+                if (expression[pos] === '\\' && pos + 1 < len) {
+                    pos++;
+                    str += expression[pos];
+                }
+                else {
+                    str += expression[pos];
+                }
+                pos++;
+            }
+            pos++;
+            tokens.push({ type: 'literal', value: str });
+            continue;
+        }
+        if (/[\d.]/.test(char)) {
+            let numStr = '';
+            while (pos < len && /[\d.eE+-]/.test(expression[pos])) {
+                numStr += expression[pos];
+                pos++;
+            }
+            tokens.push({ type: 'literal', value: parseFloat(numStr) });
+            continue;
+        }
+        const restExpr = expression.slice(pos);
+        if (restExpr.startsWith('true') && !/\w/.test(restExpr[4] || '')) {
+            tokens.push({ type: 'literal', value: true });
+            pos += 4;
+            continue;
+        }
+        if (restExpr.startsWith('false') && !/\w/.test(restExpr[5] || '')) {
+            tokens.push({ type: 'literal', value: false });
+            pos += 5;
+            continue;
+        }
+        if (restExpr.startsWith('null') && !/\w/.test(restExpr[4] || '')) {
+            tokens.push({ type: 'literal', value: null });
+            pos += 4;
+            continue;
+        }
+        const twoChar = expression.slice(pos, pos + 2);
+        const threeChar = expression.slice(pos, pos + 3);
+        if (['===', '!=='].includes(threeChar)) {
+            tokens.push({ type: 'operator', value: threeChar });
+            pos += 3;
+            continue;
+        }
+        if (['==', '!=', '<=', '>=', '&&', '||', '**'].includes(twoChar)) {
+            tokens.push({ type: 'operator', value: twoChar });
+            pos += 2;
+            continue;
+        }
+        if (['+', '-', '*', '/', '%', '<', '>', '!'].includes(char)) {
+            tokens.push({ type: 'operator', value: char });
+            pos++;
+            continue;
+        }
+        if (char === '(' || char === ')') {
+            tokens.push({ type: 'paren', value: char });
+            pos++;
+            continue;
+        }
+        if (char === '?' || char === ':') {
+            tokens.push({ type: 'operator', value: char });
+            pos++;
+            continue;
+        }
+        pos++;
+    }
+    return tokens;
+};
+const applyPipeOperator = (value, pipe) => {
+    const pipeMatch = pipe.match(/^(\w+)(?:\(([^)]*)\))?$/);
+    if (!pipeMatch)
+        return value;
+    const [, operator, args] = pipeMatch;
+    const strValue = String(value !== null && value !== void 0 ? value : '');
+    switch (operator) {
+        case 'contains':
+            return strValue.includes(args || '');
+        case 'startsWith':
+            return strValue.startsWith(args || '');
+        case 'endsWith':
+            return strValue.endsWith(args || '');
+        case 'isEmpty':
+            return value === null || value === undefined || value === '' ||
+                (Array.isArray(value) && value.length === 0);
+        case 'isNotEmpty':
+            return value !== null && value !== undefined && value !== '' &&
+                (!Array.isArray(value) || value.length > 0);
+        case 'length':
+            return Array.isArray(value) ? value.length : strValue.length;
+        case 'lower':
+        case 'toLowerCase':
+            return strValue.toLowerCase();
+        case 'upper':
+        case 'toUpperCase':
+            return strValue.toUpperCase();
+        case 'trim':
+            return strValue.trim();
+        default:
+            return value;
+    }
+};
+const evaluateTokens = (tokens) => {
+    var _a, _b;
+    if (tokens.length === 0)
+        return null;
+    if (tokens.length === 1) {
+        return tokens[0].value;
+    }
+    const questionIdx = tokens.findIndex(t => t.type === 'operator' && t.value === '?');
+    if (questionIdx !== -1) {
+        const colonIdx = tokens.findIndex((t, i) => i > questionIdx && t.type === 'operator' && t.value === ':');
+        if (colonIdx !== -1) {
+            const condition = evaluateTokens(tokens.slice(0, questionIdx));
+            const trueValue = evaluateTokens(tokens.slice(questionIdx + 1, colonIdx));
+            const falseValue = evaluateTokens(tokens.slice(colonIdx + 1));
+            return condition ? trueValue : falseValue;
+        }
+    }
+    let lowestPrecedence = Infinity;
+    let opIndex = -1;
+    let parenDepth = 0;
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (token.type === 'paren') {
+            parenDepth += token.value === '(' ? 1 : -1;
+            continue;
+        }
+        if (parenDepth > 0)
+            continue;
+        if (token.type === 'operator' && typeof token.value === 'string') {
+            const precedence = OPERATOR_PRECEDENCE[token.value];
+            if (precedence !== undefined && precedence <= lowestPrecedence) {
+                lowestPrecedence = precedence;
+                opIndex = i;
+            }
+        }
+    }
+    if (opIndex !== -1) {
+        const op = tokens[opIndex].value;
+        const left = evaluateTokens(tokens.slice(0, opIndex));
+        const right = evaluateTokens(tokens.slice(opIndex + 1));
+        return applyOperator(op, left, right);
+    }
+    if (((_a = tokens[0]) === null || _a === void 0 ? void 0 : _a.type) === 'paren' && tokens[0].value === '(') {
+        let depth = 1;
+        let endIdx = 1;
+        while (endIdx < tokens.length && depth > 0) {
+            if (tokens[endIdx].type === 'paren') {
+                depth += tokens[endIdx].value === '(' ? 1 : -1;
+            }
+            endIdx++;
+        }
+        return evaluateTokens(tokens.slice(1, endIdx - 1));
+    }
+    if (((_b = tokens[0]) === null || _b === void 0 ? void 0 : _b.type) === 'operator' && tokens[0].value === '!') {
+        const operand = evaluateTokens(tokens.slice(1));
+        return !operand;
+    }
+    return tokens[0].value;
+};
+const applyOperator = (op, left, right) => {
+    switch (op) {
+        case '+':
+            if (typeof left === 'string' || typeof right === 'string') {
+                return String(left !== null && left !== void 0 ? left : '') + String(right !== null && right !== void 0 ? right : '');
+            }
+            return (Number(left) || 0) + (Number(right) || 0);
+        case '-':
+            return (Number(left) || 0) - (Number(right) || 0);
+        case '*':
+            return (Number(left) || 0) * (Number(right) || 0);
+        case '/':
+            return (Number(left) || 0) / (Number(right) || 1);
+        case '%':
+            return (Number(left) || 0) % (Number(right) || 1);
+        case '**':
+            return Math.pow(Number(left) || 0, Number(right) || 0);
+        case '==':
+            return left == right;
+        case '===':
+            return left === right;
+        case '!=':
+            return left != right;
+        case '!==':
+            return left !== right;
+        case '<':
+            return (Number(left) || 0) < (Number(right) || 0);
+        case '<=':
+            return (Number(left) || 0) <= (Number(right) || 0);
+        case '>':
+            return (Number(left) || 0) > (Number(right) || 0);
+        case '>=':
+            return (Number(left) || 0) >= (Number(right) || 0);
+        case '&&':
+            return Boolean(left) && Boolean(right);
+        case '||':
+            return Boolean(left) || Boolean(right);
+        default:
+            return null;
+    }
+};
 const getNestedValue = (obj, path) => {
     return path
         .split('.')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abyss-project/console",
-  "version": "1.0.23",
+  "version": "1.0.26",
   "description": "Core package to interact with AbyssConsole",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",