@abyss-project/console 1.0.40 → 1.0.42

package/dist/index.d.ts

@@ -13,7 +13,6 @@ import * as secretPublicApi from './api/secret-public.api';
 export * from './utils/cidr.util';
 export * from './types';
 export * from './utils';
-export * as GenericExpression from './expressions';
 export * as WorkflowExpression from './workflow-expressions';
 export declare const API_KEY_APPLICATION_HEADER = "abyss-console-api-key-application";
 export declare const ADMIN_TOKEN_HEADER = "abyss-admin-token";

package/dist/index.js

@@ -29,7 +29,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbyssConsoleCore = exports.WEBHOOK_SIGNATURE_ALGORITHM = exports.HEADER_WEBHOOK_SIGNATURE_NAME = exports.ADMIN_TOKEN_HEADER = exports.API_KEY_APPLICATION_HEADER = exports.WorkflowExpression = exports.GenericExpression = void 0;
+exports.AbyssConsoleCore = exports.WEBHOOK_SIGNATURE_ALGORITHM = exports.HEADER_WEBHOOK_SIGNATURE_NAME = exports.ADMIN_TOKEN_HEADER = exports.API_KEY_APPLICATION_HEADER = exports.WorkflowExpression = void 0;
 const axios_1 = __importDefault(require("axios"));
 const axios_retry_1 = __importStar(require("axios-retry"));
 const domainVerificationApi = __importStar(require("./api/domain-verification.api"));
@@ -46,7 +46,6 @@ const secretPublicApi = __importStar(require("./api/secret-public.api"));
 __exportStar(require("./utils/cidr.util"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils"), exports);
-exports.GenericExpression = __importStar(require("./expressions"));
 exports.WorkflowExpression = __importStar(require("./workflow-expressions"));
 const MONITOR_DEFAULT_BASE_URL = 'https://console-api.abyss-project.fr/api/';
 exports.API_KEY_APPLICATION_HEADER = 'abyss-console-api-key-application';

package/dist/types/constants/index.d.ts

@@ -1 +1,2 @@
 export * from './webhook.constants';
+export * from './workflow.constants';

package/dist/types/constants/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./webhook.constants"), exports);
+__exportStar(require("./workflow.constants"), exports);

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

@@ -0,0 +1,9 @@
+export declare const WORKFLOW_EXECUTION_TIMEOUT: number;
+export declare const WORKFLOW_STEP_TIMEOUT: number;
+export declare const SLEEP_DURATION_MIN = 0;
+export declare const SLEEP_DURATION_MAX = 900;
+export declare const SLEEP_DURATION_DEFAULT = 1;
+export declare const EXPRESSION_TIMEOUT_DEFAULT = 5000;
+export declare const EXPRESSION_TIMEOUT_MAX = 30000;
+export declare const EXPRESSION_CPU_TIMEOUT = 10000;
+export declare const EXPRESSION_MEMORY_LIMIT = 128;

package/dist/types/constants/workflow.constants.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXPRESSION_MEMORY_LIMIT = exports.EXPRESSION_CPU_TIMEOUT = exports.EXPRESSION_TIMEOUT_MAX = exports.EXPRESSION_TIMEOUT_DEFAULT = exports.SLEEP_DURATION_DEFAULT = exports.SLEEP_DURATION_MAX = exports.SLEEP_DURATION_MIN = exports.WORKFLOW_STEP_TIMEOUT = exports.WORKFLOW_EXECUTION_TIMEOUT = void 0;
+exports.WORKFLOW_EXECUTION_TIMEOUT = 60 * 60 * 1000;
+exports.WORKFLOW_STEP_TIMEOUT = 15 * 60 * 1000;
+exports.SLEEP_DURATION_MIN = 0;
+exports.SLEEP_DURATION_MAX = 900;
+exports.SLEEP_DURATION_DEFAULT = 1;
+exports.EXPRESSION_TIMEOUT_DEFAULT = 5000;
+exports.EXPRESSION_TIMEOUT_MAX = 30000;
+exports.EXPRESSION_CPU_TIMEOUT = 10000;
+exports.EXPRESSION_MEMORY_LIMIT = 128;

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

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

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

@@ -18,6 +18,7 @@ export interface IWorkflowWebhook {
     processedAt: Date | null;
     signatureHeader: string | null;
     signatureSecret: string | null;
+    timeout: number;
     maxRetries: number;
     retryDelay: number;
     createdAt?: Date;

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

@@ -1,7 +1,2 @@
-import { WorkflowTriggerData, FilterOperator, IWorkflowTrigger } from '../types';
-type ExpressionValue = string | number | boolean | null | undefined | unknown[] | Record<string, unknown>;
+import { WorkflowTriggerData, IWorkflowTrigger } from '../types';
 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,25 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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,
-};
+exports.matchesTriggerFilters = void 0;
 const matchesTriggerFilters = (trigger, triggerData) => {
     if (!trigger.filters || trigger.filters.length === 0) {
         return true;
@@ -28,7 +9,7 @@ const matchesTriggerFilters = (trigger, triggerData) => {
         if (filter.expression) {
             try {
                 const context = { trigger: triggerData };
-                const result = (0, exports.evaluateExpression)(filter.expression, context);
+                const result = evaluateSimpleExpression(filter.expression, context);
                 return Boolean(result);
             }
             catch (error) {
@@ -36,304 +17,38 @@ const matchesTriggerFilters = (trigger, triggerData) => {
                 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('.')
-        .reduce((current, key) => current === null || current === void 0 ? void 0 : current[key], obj);
-};
-exports.getNestedValue = getNestedValue;
-const evaluateFilter = (value, operator, expected) => {
-    switch (operator) {
-        case types_1.FilterOperator.EQUALS:
-            return value === expected;
-        case types_1.FilterOperator.NOT_EQUALS:
-            return value !== expected;
-        case types_1.FilterOperator.CONTAINS:
-            return String(value).includes(String(expected));
-        case types_1.FilterOperator.NOT_CONTAINS:
-            return !String(value).includes(String(expected));
-        case types_1.FilterOperator.STARTS_WITH:
-            return String(value).startsWith(String(expected));
-        case types_1.FilterOperator.ENDS_WITH:
-            return String(value).endsWith(String(expected));
-        case types_1.FilterOperator.IN:
-            return Array.isArray(expected) && expected.includes(value);
-        case types_1.FilterOperator.NOT_IN:
-            return Array.isArray(expected) && !expected.includes(value);
-        case types_1.FilterOperator.IS_EMPTY:
-            return value === null || value === undefined || value === '';
-        case types_1.FilterOperator.IS_NOT_EMPTY:
-            return value !== null && value !== undefined && value !== '';
-        case types_1.FilterOperator.MATCHES_REGEX:
-            try {
-                return new RegExp(expected).test(String(value));
-            }
-            catch {
-                return false;
-            }
-        default:
-            return true;
-    }
-};
-exports.evaluateFilter = evaluateFilter;
+function evaluateSimpleExpression(expression, context) {
+    let evaluated = expression;
+    const pattern = /\{\{([^}]+)\}\}/g;
+    const matches = [...expression.matchAll(pattern)];
+    for (const match of matches) {
+        const [fullMatch, path] = match;
+        const value = getNestedValue(context, path.trim());
+        const valueStr = typeof value === 'string'
+            ? `"${value.replace(/"/g, '\\"')}"`
+            : JSON.stringify(value);
+        evaluated = evaluated.replace(fullMatch, valueStr);
+    }
+    try {
+        return new Function(`return ${evaluated}`)();
+    }
+    catch (error) {
+        console.error('Failed to evaluate expression:', evaluated, error);
+        return false;
+    }
+}
+function getNestedValue(obj, path) {
+    const segments = path.split('.');
+    let current = obj;
+    for (const segment of segments) {
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        current = current[segment];
+    }
+    return current;
+}

package/dist/workflow-expressions/index.d.ts

@@ -1,17 +1,5 @@
-export { DataSourceType, OPERATOR_PRECEDENCE } from './types';
-export { WorkflowTriggerType } from '../types/enum/workflow.enum';
-export type { ParsedExpression, PathExpression, FunctionExpression, BinaryExpression, UnaryExpression, TernaryExpression, LiteralExpression, GroupExpression, BuiltInFunction, FunctionCategory, FunctionArg, PipeOperation, OperationCategory, WorkflowContext, StepExecution, WorkflowStep, TriggerInfo, ValidationResult, ValidationError, ValidationWarning, ExpressionToken, WorkflowResourceMapping, } from './types';
-export { parseExpression, detectDataSource, parsePathSegments, tokenizeTemplate } from './parser';
-export { buildResolverContext, resolvePathValue, evaluateExpression, interpolateString, resolveExpression, } from './resolver';
-export { BUILT_IN_FUNCTIONS, executeFunction, getFunctionsByCategory, getFunctionNames, hasFunction, getFunction, } from './functions';
-export { PIPE_OPERATIONS, executePipeOperation, getPipesByCategory, getPipeNames, hasPipe, getPipe, } from './pipes';
-export type { PipeDefinition } from './pipes/string-pipes';
-import type { WorkflowContext } from './types';
-export { buildExpressionString, buildReferenceString, hasExpressions, hasReferences, isInsideExpression, extractPaths, parseOperations, getCurrentExpressionContext, getValueType, tokenizeEnriched, validateExpression, generatePreview, convertExpressionToSaveFormat, convertExpressionToDisplayFormat, } from './helpers';
-export type { ResourceMapping, EnrichedToken } from './helpers';
-export declare function evaluate(expression: string, workflowContext: WorkflowContext, secretsMap?: Map<string, string>): unknown;
-export declare function interpolate(template: string, workflowContext: WorkflowContext, secretsMap?: Map<string, string>, options?: {
-    maskSecrets?: boolean;
-}): string;
-export declare function hasDynamicContent(str: string): boolean;
-export declare function extractReferences(str: string): string[];
+export { DataSourceType } from './types';
+export type { WorkflowContext, StepExecution, WorkflowStep, TriggerInfo, } from './types';
+export { buildResolverContext, resolvePathValue, interpolateTemplate, } from './resolver';
+export declare function hasTemplates(str: string): boolean;
+export declare function extractTemplates(str: string): string[];

package/dist/workflow-expressions/index.js

@@ -1,68 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractReferences = exports.hasDynamicContent = exports.interpolate = exports.evaluate = exports.convertExpressionToDisplayFormat = exports.convertExpressionToSaveFormat = exports.generatePreview = exports.validateExpression = exports.tokenizeEnriched = exports.getValueType = exports.getCurrentExpressionContext = exports.parseOperations = exports.extractPaths = exports.isInsideExpression = exports.hasReferences = exports.hasExpressions = exports.buildReferenceString = exports.buildExpressionString = exports.getPipe = exports.hasPipe = exports.getPipeNames = exports.getPipesByCategory = exports.executePipeOperation = exports.PIPE_OPERATIONS = exports.getFunction = exports.hasFunction = exports.getFunctionNames = exports.getFunctionsByCategory = exports.executeFunction = exports.BUILT_IN_FUNCTIONS = exports.resolveExpression = exports.interpolateString = exports.evaluateExpression = exports.resolvePathValue = exports.buildResolverContext = exports.tokenizeTemplate = exports.parsePathSegments = exports.detectDataSource = exports.parseExpression = exports.WorkflowTriggerType = exports.OPERATOR_PRECEDENCE = exports.DataSourceType = void 0;
+exports.extractTemplates = exports.hasTemplates = exports.interpolateTemplate = exports.resolvePathValue = exports.buildResolverContext = exports.DataSourceType = void 0;
 var types_1 = require("./types");
 Object.defineProperty(exports, "DataSourceType", { enumerable: true, get: function () { return types_1.DataSourceType; } });
-Object.defineProperty(exports, "OPERATOR_PRECEDENCE", { enumerable: true, get: function () { return types_1.OPERATOR_PRECEDENCE; } });
-var workflow_enum_1 = require("../types/enum/workflow.enum");
-Object.defineProperty(exports, "WorkflowTriggerType", { enumerable: true, get: function () { return workflow_enum_1.WorkflowTriggerType; } });
-var parser_1 = require("./parser");
-Object.defineProperty(exports, "parseExpression", { enumerable: true, get: function () { return parser_1.parseExpression; } });
-Object.defineProperty(exports, "detectDataSource", { enumerable: true, get: function () { return parser_1.detectDataSource; } });
-Object.defineProperty(exports, "parsePathSegments", { enumerable: true, get: function () { return parser_1.parsePathSegments; } });
-Object.defineProperty(exports, "tokenizeTemplate", { enumerable: true, get: function () { return parser_1.tokenizeTemplate; } });
 var resolver_1 = require("./resolver");
 Object.defineProperty(exports, "buildResolverContext", { enumerable: true, get: function () { return resolver_1.buildResolverContext; } });
 Object.defineProperty(exports, "resolvePathValue", { enumerable: true, get: function () { return resolver_1.resolvePathValue; } });
-Object.defineProperty(exports, "evaluateExpression", { enumerable: true, get: function () { return resolver_1.evaluateExpression; } });
-Object.defineProperty(exports, "interpolateString", { enumerable: true, get: function () { return resolver_1.interpolateString; } });
-Object.defineProperty(exports, "resolveExpression", { enumerable: true, get: function () { return resolver_1.resolveExpression; } });
-var functions_1 = require("./functions");
-Object.defineProperty(exports, "BUILT_IN_FUNCTIONS", { enumerable: true, get: function () { return functions_1.BUILT_IN_FUNCTIONS; } });
-Object.defineProperty(exports, "executeFunction", { enumerable: true, get: function () { return functions_1.executeFunction; } });
-Object.defineProperty(exports, "getFunctionsByCategory", { enumerable: true, get: function () { return functions_1.getFunctionsByCategory; } });
-Object.defineProperty(exports, "getFunctionNames", { enumerable: true, get: function () { return functions_1.getFunctionNames; } });
-Object.defineProperty(exports, "hasFunction", { enumerable: true, get: function () { return functions_1.hasFunction; } });
-Object.defineProperty(exports, "getFunction", { enumerable: true, get: function () { return functions_1.getFunction; } });
-var pipes_1 = require("./pipes");
-Object.defineProperty(exports, "PIPE_OPERATIONS", { enumerable: true, get: function () { return pipes_1.PIPE_OPERATIONS; } });
-Object.defineProperty(exports, "executePipeOperation", { enumerable: true, get: function () { return pipes_1.executePipeOperation; } });
-Object.defineProperty(exports, "getPipesByCategory", { enumerable: true, get: function () { return pipes_1.getPipesByCategory; } });
-Object.defineProperty(exports, "getPipeNames", { enumerable: true, get: function () { return pipes_1.getPipeNames; } });
-Object.defineProperty(exports, "hasPipe", { enumerable: true, get: function () { return pipes_1.hasPipe; } });
-Object.defineProperty(exports, "getPipe", { enumerable: true, get: function () { return pipes_1.getPipe; } });
-const resolver_2 = require("./resolver");
-var helpers_1 = require("./helpers");
-Object.defineProperty(exports, "buildExpressionString", { enumerable: true, get: function () { return helpers_1.buildExpressionString; } });
-Object.defineProperty(exports, "buildReferenceString", { enumerable: true, get: function () { return helpers_1.buildReferenceString; } });
-Object.defineProperty(exports, "hasExpressions", { enumerable: true, get: function () { return helpers_1.hasExpressions; } });
-Object.defineProperty(exports, "hasReferences", { enumerable: true, get: function () { return helpers_1.hasReferences; } });
-Object.defineProperty(exports, "isInsideExpression", { enumerable: true, get: function () { return helpers_1.isInsideExpression; } });
-Object.defineProperty(exports, "extractPaths", { enumerable: true, get: function () { return helpers_1.extractPaths; } });
-Object.defineProperty(exports, "parseOperations", { enumerable: true, get: function () { return helpers_1.parseOperations; } });
-Object.defineProperty(exports, "getCurrentExpressionContext", { enumerable: true, get: function () { return helpers_1.getCurrentExpressionContext; } });
-Object.defineProperty(exports, "getValueType", { enumerable: true, get: function () { return helpers_1.getValueType; } });
-Object.defineProperty(exports, "tokenizeEnriched", { enumerable: true, get: function () { return helpers_1.tokenizeEnriched; } });
-Object.defineProperty(exports, "validateExpression", { enumerable: true, get: function () { return helpers_1.validateExpression; } });
-Object.defineProperty(exports, "generatePreview", { enumerable: true, get: function () { return helpers_1.generatePreview; } });
-Object.defineProperty(exports, "convertExpressionToSaveFormat", { enumerable: true, get: function () { return helpers_1.convertExpressionToSaveFormat; } });
-Object.defineProperty(exports, "convertExpressionToDisplayFormat", { enumerable: true, get: function () { return helpers_1.convertExpressionToDisplayFormat; } });
-function evaluate(expression, workflowContext, secretsMap) {
-    const context = (0, resolver_2.buildResolverContext)(workflowContext);
-    return (0, resolver_2.resolveExpression)(expression, context, secretsMap);
-}
-exports.evaluate = evaluate;
-function interpolate(template, workflowContext, secretsMap, options) {
-    const context = (0, resolver_2.buildResolverContext)(workflowContext);
-    return (0, resolver_2.interpolateString)(template, context, secretsMap, options);
-}
-exports.interpolate = interpolate;
-function hasDynamicContent(str) {
+Object.defineProperty(exports, "interpolateTemplate", { enumerable: true, get: function () { return resolver_1.interpolateTemplate; } });
+function hasTemplates(str) {
     return /\{\{.+?\}\}/.test(str);
 }
-exports.hasDynamicContent = hasDynamicContent;
-function extractReferences(str) {
-    const matches = str.matchAll(/\{\{(.+?)\}\}/g);
-    return Array.from(matches, (m) => m[1].trim());
+exports.hasTemplates = hasTemplates;
+function extractTemplates(str) {
+    const pattern = /\{\{(.+?)\}\}/g;
+    const matches = [...str.matchAll(pattern)];
+    return matches.map(m => m[1].trim());
 }
-exports.extractReferences = extractReferences;
+exports.extractTemplates = extractTemplates;

package/dist/workflow-expressions/resolver.d.ts

@@ -1,8 +1,4 @@
-import type { ParsedExpression, WorkflowContext } from './types';
+import type { WorkflowContext } from './types';
 export declare function buildResolverContext(workflowContext?: WorkflowContext): Record<string, unknown>;
 export declare function resolvePathValue(path: string, context: Record<string, unknown>): unknown;
-export declare function evaluateExpression(parsed: ParsedExpression, context: Record<string, unknown>, secretsMap?: Map<string, string>): unknown;
-export declare function interpolateString(template: string, context: Record<string, unknown>, secretsMap?: Map<string, string>, options?: {
-    maskSecrets?: boolean;
-}): string;
-export declare function resolveExpression(expression: string, context: Record<string, unknown>, secretsMap?: Map<string, string>): unknown;
+export declare function interpolateTemplate(template: string, context: Record<string, unknown>): string;