@abyss-project/main 1.0.110 → 1.0.111

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

@@ -1,15 +0,0 @@
-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

@@ -1,61 +0,0 @@
-"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

@@ -1,8 +0,0 @@
-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

@@ -1,436 +0,0 @@
-"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

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