@abyss-project/console 1.0.28 → 1.0.30

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

@@ -0,0 +1,15 @@
+export { DataSourceType, OPERATOR_PRECEDENCE } from './types';
+export type { ParsedExpression, PathExpression, FunctionExpression, BinaryExpression, UnaryExpression, TernaryExpression, LiteralExpression, GroupExpression, BuiltInFunction, FunctionCategory, FunctionArg, PipeOperation, OperationCategory, WorkflowContext, StepExecution, WorkflowStep, 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, } 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[];

package/dist/workflow-expressions/index.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractReferences = exports.hasDynamicContent = exports.interpolate = exports.evaluate = 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.OPERATOR_PRECEDENCE = 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 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; } });
+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) {
+    return /\{\{.+?\}\}/.test(str);
+}
+exports.hasDynamicContent = hasDynamicContent;
+function extractReferences(str) {
+    const matches = str.matchAll(/\{\{(.+?)\}\}/g);
+    return Array.from(matches, (m) => m[1].trim());
+}
+exports.extractReferences = extractReferences;

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

@@ -0,0 +1,8 @@
+import type { ParsedExpression, DataSourceType } from './types';
+export declare function detectDataSource(path: string): DataSourceType | null;
+export declare function parsePathSegments(path: string): string[];
+export declare function parseExpression(expression: string): ParsedExpression;
+export declare function tokenizeTemplate(template: string): Array<{
+    type: 'text' | 'expression';
+    value: string;
+}>;

package/dist/workflow-expressions/parser.js

@@ -0,0 +1,456 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenizeTemplate = exports.parseExpression = exports.parsePathSegments = exports.detectDataSource = void 0;
+const EXPRESSION_PATTERN = /\{\{(.+?)\}\}/g;
+const FUNCTION_PATTERN = /^(?:fn\.)?(\w+)\((.*)\)$/s;
+const PIPE_PATTERN = /\s*\|\s*(\w+)(?:\(([^)]*)\))?/g;
+const DATA_SOURCE_PREFIXES = {
+    trigger: 'trigger',
+    triggerData: 'trigger',
+    steps: 'steps',
+    variables: 'variables',
+    secret: 'secret',
+    ipAddress: 'ipAddress',
+    domain: 'domain',
+    abyss: 'abyss',
+    app: 'app',
+    project: 'project',
+    env: 'env',
+    fn: 'fn',
+};
+function detectDataSource(path) {
+    const firstDot = path.indexOf('.');
+    const firstBracket = path.indexOf('[');
+    let prefix;
+    if (firstDot === -1 && firstBracket === -1) {
+        prefix = path;
+    }
+    else if (firstDot === -1) {
+        prefix = path.substring(0, firstBracket);
+    }
+    else if (firstBracket === -1) {
+        prefix = path.substring(0, firstDot);
+    }
+    else {
+        prefix = path.substring(0, Math.min(firstDot, firstBracket));
+    }
+    return DATA_SOURCE_PREFIXES[prefix] || null;
+}
+exports.detectDataSource = detectDataSource;
+function parsePathSegments(path) {
+    const segments = [];
+    let current = '';
+    let inBracket = false;
+    let bracketContent = '';
+    for (let i = 0; i < path.length; i++) {
+        const char = path[i];
+        if (char === '[') {
+            if (current) {
+                segments.push(current);
+                current = '';
+            }
+            inBracket = true;
+            bracketContent = '';
+        }
+        else if (char === ']' && inBracket) {
+            const cleaned = bracketContent.replace(/^["']|["']$/g, '');
+            segments.push(cleaned);
+            inBracket = false;
+            bracketContent = '';
+        }
+        else if (inBracket) {
+            bracketContent += char;
+        }
+        else if (char === '.') {
+            if (current) {
+                segments.push(current);
+                current = '';
+            }
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current) {
+        segments.push(current);
+    }
+    return segments;
+}
+exports.parsePathSegments = parsePathSegments;
+function parseExpression(expression) {
+    const trimmed = expression.trim();
+    if (!trimmed) {
+        return {
+            type: 'literal',
+            literalType: 'string',
+            literalValue: '',
+            isValid: false,
+            error: 'Empty expression',
+        };
+    }
+    try {
+        return parseExpressionAST(trimmed);
+    }
+    catch (error) {
+        return {
+            type: 'literal',
+            literalType: 'string',
+            literalValue: '',
+            isValid: false,
+            error: error instanceof Error ? error.message : 'Parse error',
+        };
+    }
+}
+exports.parseExpression = parseExpression;
+function parseExpressionAST(expr) {
+    const trimmed = expr.trim();
+    const ternary = findTernaryOperator(trimmed);
+    if (ternary) {
+        return {
+            type: 'ternary',
+            condition: parseExpressionAST(ternary.condition),
+            consequent: parseExpressionAST(ternary.consequent),
+            alternate: parseExpressionAST(ternary.alternate),
+            isValid: true,
+        };
+    }
+    const binary = findBinaryOperator(trimmed);
+    if (binary) {
+        return {
+            type: 'binary',
+            operator: binary.operator,
+            left: parseExpressionAST(binary.left),
+            right: parseExpressionAST(binary.right),
+            isValid: true,
+        };
+    }
+    return parsePrimary(trimmed);
+}
+function parsePrimary(expr) {
+    const trimmed = expr.trim();
+    if (trimmed.startsWith('!') && !trimmed.startsWith('!=')) {
+        return {
+            type: 'unary',
+            operator: '!',
+            operand: parsePrimary(trimmed.substring(1)),
+            isValid: true,
+        };
+    }
+    if (trimmed.startsWith('(') && trimmed.endsWith(')')) {
+        const inner = trimmed.substring(1, trimmed.length - 1);
+        return {
+            type: 'group',
+            expression: parseExpressionAST(inner),
+            isValid: true,
+        };
+    }
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return {
+            type: 'literal',
+            literalType: 'string',
+            literalValue: trimmed.slice(1, -1),
+            isValid: true,
+        };
+    }
+    if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+        return {
+            type: 'literal',
+            literalType: 'number',
+            literalValue: parseFloat(trimmed),
+            isValid: true,
+        };
+    }
+    if (trimmed === 'true' || trimmed === 'false') {
+        return {
+            type: 'literal',
+            literalType: 'boolean',
+            literalValue: trimmed === 'true',
+            isValid: true,
+        };
+    }
+    if (trimmed === 'null') {
+        return {
+            type: 'literal',
+            literalType: 'null',
+            literalValue: null,
+            isValid: true,
+        };
+    }
+    const funcMatch = trimmed.match(FUNCTION_PATTERN);
+    if (funcMatch) {
+        const [, funcName, argsStr] = funcMatch;
+        return {
+            type: 'function',
+            isFunction: true,
+            functionName: funcName,
+            functionArgs: parseArgs(argsStr),
+            isValid: true,
+        };
+    }
+    const pipeIndex = findFirstPipeIndex(trimmed);
+    if (pipeIndex !== -1) {
+        const pathPart = trimmed.substring(0, pipeIndex).trim();
+        const pipesPart = trimmed.substring(pipeIndex);
+        const operations = parsePipeOperations(pipesPart);
+        const source = detectDataSource(pathPart);
+        return {
+            type: 'path',
+            path: pathPart,
+            source,
+            operations,
+            isValid: true,
+        };
+    }
+    const source = detectDataSource(trimmed);
+    return {
+        type: 'path',
+        path: trimmed,
+        source,
+        isValid: true,
+    };
+}
+const OPERATOR_PRECEDENCE_MAP = {
+    '||': 1,
+    '&&': 2,
+    '==': 3,
+    '!=': 3,
+    '<': 4,
+    '>': 4,
+    '<=': 4,
+    '>=': 4,
+    '+': 5,
+    '-': 5,
+    '*': 6,
+    '/': 6,
+    '%': 6,
+    '**': 7,
+};
+function findTernaryOperator(expr) {
+    let depth = 0;
+    let questionIdx = -1;
+    let colonIdx = -1;
+    for (let i = 0; i < expr.length; i++) {
+        const char = expr[i];
+        if (char === '(' || char === '[' || char === '{') {
+            depth++;
+        }
+        if (char === ')' || char === ']' || char === '}') {
+            depth--;
+        }
+        if (depth === 0) {
+            if (char === '?' && questionIdx === -1) {
+                questionIdx = i;
+            }
+            else if (char === ':' && questionIdx !== -1 && colonIdx === -1) {
+                colonIdx = i;
+            }
+        }
+    }
+    if (questionIdx !== -1 && colonIdx !== -1) {
+        return {
+            condition: expr.substring(0, questionIdx).trim(),
+            consequent: expr.substring(questionIdx + 1, colonIdx).trim(),
+            alternate: expr.substring(colonIdx + 1).trim(),
+        };
+    }
+    return null;
+}
+function findBinaryOperator(expr) {
+    const operators = [
+        '||',
+        '&&',
+        '===',
+        '!==',
+        '==',
+        '!=',
+        '>=',
+        '<=',
+        '>',
+        '<',
+        '**',
+        '+',
+        '-',
+        '*',
+        '/',
+        '%',
+    ];
+    let depth = 0;
+    let inString = false;
+    let stringChar = '';
+    let bestOp = null;
+    for (let i = 0; i < expr.length; i++) {
+        const char = expr[i];
+        if ((char === '"' || char === "'") && (i === 0 || expr[i - 1] !== '\\')) {
+            if (!inString) {
+                inString = true;
+                stringChar = char;
+            }
+            else if (char === stringChar) {
+                inString = false;
+            }
+            continue;
+        }
+        if (inString) {
+            continue;
+        }
+        if (char === '(' || char === '[' || char === '{')
+            depth++;
+        if (char === ')' || char === ']' || char === '}')
+            depth--;
+        if (depth !== 0)
+            continue;
+        for (const op of operators) {
+            if (expr.substring(i, i + op.length) === op) {
+                if (i === 0)
+                    continue;
+                const precedence = OPERATOR_PRECEDENCE_MAP[op] || 0;
+                if (!bestOp ||
+                    precedence < bestOp.precedence ||
+                    (precedence === bestOp.precedence && i > bestOp.index)) {
+                    bestOp = { operator: op, index: i, precedence };
+                }
+                break;
+            }
+        }
+    }
+    if (bestOp && bestOp.index > 0) {
+        return {
+            operator: bestOp.operator,
+            left: expr.substring(0, bestOp.index).trim(),
+            right: expr.substring(bestOp.index + bestOp.operator.length).trim(),
+        };
+    }
+    return null;
+}
+function findFirstPipeIndex(str) {
+    let depth = 0;
+    let inString = false;
+    let stringChar = '';
+    for (let i = 0; i < str.length; i++) {
+        const char = str[i];
+        const prevChar = i > 0 ? str[i - 1] : '';
+        if ((char === '"' || char === "'") && prevChar !== '\\') {
+            if (!inString) {
+                inString = true;
+                stringChar = char;
+            }
+            else if (char === stringChar) {
+                inString = false;
+            }
+            continue;
+        }
+        if (inString)
+            continue;
+        if (char === '(' || char === '[' || char === '{')
+            depth++;
+        if (char === ')' || char === ']' || char === '}')
+            depth--;
+        if (char === '|' && depth === 0 && str[i + 1] !== '|') {
+            return i;
+        }
+    }
+    return -1;
+}
+function parseArgs(argsString) {
+    if (!argsString.trim()) {
+        return [];
+    }
+    const args = [];
+    let current = '';
+    let depth = 0;
+    let inString = false;
+    let stringChar = '';
+    for (let i = 0; i < argsString.length; i++) {
+        const char = argsString[i];
+        const prevChar = i > 0 ? argsString[i - 1] : '';
+        if ((char === '"' || char === "'") && prevChar !== '\\') {
+            if (!inString) {
+                inString = true;
+                stringChar = char;
+            }
+            else if (char === stringChar) {
+                inString = false;
+            }
+            current += char;
+            continue;
+        }
+        if (inString) {
+            current += char;
+            continue;
+        }
+        if (char === '(' || char === '[' || char === '{') {
+            depth++;
+            current += char;
+            continue;
+        }
+        if (char === ')' || char === ']' || char === '}') {
+            depth--;
+            current += char;
+            continue;
+        }
+        if (char === ',' && depth === 0) {
+            args.push(parseArgValue(current.trim()));
+            current = '';
+            continue;
+        }
+        current += char;
+    }
+    if (current.trim()) {
+        args.push(parseArgValue(current.trim()));
+    }
+    return args;
+}
+function parseArgValue(value) {
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    if (value === 'null')
+        return null;
+    if (/^-?\d+(\.\d+)?$/.test(value))
+        return parseFloat(value);
+    return value;
+}
+function parsePipeOperations(pipesStr) {
+    const operations = [];
+    const pipePattern = /\s*\|\s*(\w+)(?:\(([^)]*)\))?/g;
+    let match;
+    while ((match = pipePattern.exec(pipesStr)) !== null) {
+        const [, name, argsStr] = match;
+        const args = argsStr ? parseArgs(argsStr) : [];
+        operations.push({ name, args });
+    }
+    return operations;
+}
+function tokenizeTemplate(template) {
+    const tokens = [];
+    let lastIndex = 0;
+    const regex = new RegExp(EXPRESSION_PATTERN);
+    let match;
+    while ((match = regex.exec(template)) !== null) {
+        if (match.index > lastIndex) {
+            tokens.push({
+                type: 'text',
+                value: template.substring(lastIndex, match.index),
+            });
+        }
+        tokens.push({
+            type: 'expression',
+            value: match[1],
+        });
+        lastIndex = match.index + match[0].length;
+    }
+    if (lastIndex < template.length) {
+        tokens.push({
+            type: 'text',
+            value: template.substring(lastIndex),
+        });
+    }
+    return tokens;
+}
+exports.tokenizeTemplate = tokenizeTemplate;

package/dist/workflow-expressions/pipes/array-pipes.d.ts

@@ -0,0 +1,2 @@
+import type { PipeDefinition } from './string-pipes';
+export declare const arrayPipes: Record<string, PipeDefinition>;