@abyss-project/console 1.0.29 → 1.0.31

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>;

package/dist/workflow-expressions/pipes/array-pipes.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayPipes = void 0;
+exports.arrayPipes = {
+    first: {
+        name: 'first',
+        description: 'Gets the first element',
+        category: 'array',
+        signature: 'first',
+        examples: ['{{trigger.items | first}}'],
+        execute: (value) => {
+            if (Array.isArray(value) && value.length > 0) {
+                return value[0];
+            }
+            return undefined;
+        },
+    },
+    last: {
+        name: 'last',
+        description: 'Gets the last element',
+        category: 'array',
+        signature: 'last',
+        examples: ['{{trigger.items | last}}'],
+        execute: (value) => {
+            if (Array.isArray(value) && value.length > 0) {
+                return value[value.length - 1];
+            }
+            return undefined;
+        },
+    },
+    length: {
+        name: 'length',
+        description: 'Returns the length',
+        category: 'array',
+        signature: 'length',
+        examples: ['{{trigger.items | length}}'],
+        execute: (value) => {
+            if (Array.isArray(value)) {
+                return value.length;
+            }
+            if (typeof value === 'string') {
+                return value.length;
+            }
+            return 0;
+        },
+    },
+    join: {
+        name: 'join',
+        description: 'Joins array elements',
+        category: 'array',
+        signature: 'join(separator?)',
+        examples: ['{{trigger.tags | join(", ")}}'],
+        execute: (value, separator) => {
+            if (!Array.isArray(value)) {
+                return '';
+            }
+            return value.join(separator !== undefined ? String(separator) : ',');
+        },
+    },
+    slice: {
+        name: 'slice',
+        description: 'Extracts a section',
+        category: 'array',
+        signature: 'slice(start, end?)',
+        examples: ['{{trigger.items | slice(0, 3)}}'],
+        execute: (value, start, end) => {
+            if (!Array.isArray(value)) {
+                return [];
+            }
+            return value.slice(Number(start), end !== undefined ? Number(end) : undefined);
+        },
+    },
+    reverse: {
+        name: 'reverse',
+        description: 'Reverses the order',
+        category: 'array',
+        signature: 'reverse',
+        examples: ['{{trigger.items | reverse}}'],
+        execute: (value) => {
+            if (!Array.isArray(value)) {
+                return [];
+            }
+            return [...value].reverse();
+        },
+    },
+    sort: {
+        name: 'sort',
+        description: 'Sorts the array',
+        category: 'array',
+        signature: 'sort',
+        examples: ['{{trigger.numbers | sort}}'],
+        execute: (value) => {
+            if (!Array.isArray(value)) {
+                return [];
+            }
+            return [...value].sort();
+        },
+    },
+    unique: {
+        name: 'unique',
+        description: 'Returns unique elements',
+        category: 'array',
+        signature: 'unique',
+        examples: ['{{trigger.tags | unique}}'],
+        execute: (value) => {
+            if (!Array.isArray(value)) {
+                return [];
+            }
+            return Array.from(new Set(value));
+        },
+    },
+    flatten: {
+        name: 'flatten',
+        description: 'Flattens nested arrays',
+        category: 'array',
+        signature: 'flatten',
+        examples: ['{{trigger.nested | flatten}}'],
+        execute: (value) => {
+            if (!Array.isArray(value)) {
+                return [];
+            }
+            return value.flat();
+        },
+    },
+    compact: {
+        name: 'compact',
+        description: 'Removes falsy values',
+        category: 'array',
+        signature: 'compact',
+        examples: ['{{trigger.items | compact}}'],
+        execute: (value) => {
+            if (!Array.isArray(value)) {
+                return [];
+            }
+            return value.filter(Boolean);
+        },
+    },
+    sum: {
+        name: 'sum',
+        description: 'Sums numeric values',
+        category: 'array',
+        signature: 'sum',
+        examples: ['{{trigger.numbers | sum}}'],
+        execute: (value) => {
+            if (!Array.isArray(value)) {
+                return 0;
+            }
+            return value.reduce((acc, val) => acc + Number(val), 0);
+        },
+    },
+    avg: {
+        name: 'avg',
+        description: 'Calculates average',
+        category: 'array',
+        signature: 'avg',
+        examples: ['{{trigger.scores | avg}}'],
+        execute: (value) => {
+            if (!Array.isArray(value) || value.length === 0) {
+                return 0;
+            }
+            const sum = value.reduce((acc, val) => acc + Number(val), 0);
+            return sum / value.length;
+        },
+    },
+    min: {
+        name: 'min',
+        description: 'Returns minimum value',
+        category: 'array',
+        signature: 'min',
+        examples: ['{{trigger.numbers | min}}'],
+        execute: (value) => {
+            if (!Array.isArray(value) || value.length === 0) {
+                return undefined;
+            }
+            return Math.min(...value.map(Number));
+        },
+    },
+    max: {
+        name: 'max',
+        description: 'Returns maximum value',
+        category: 'array',
+        signature: 'max',
+        examples: ['{{trigger.numbers | max}}'],
+        execute: (value) => {
+            if (!Array.isArray(value) || value.length === 0) {
+                return undefined;
+            }
+            return Math.max(...value.map(Number));
+        },
+    },
+    map: {
+        name: 'map',
+        description: 'Maps over array elements',
+        category: 'array',
+        signature: 'map(property)',
+        examples: ['{{trigger.users | map("name")}}'],
+        execute: (value, property) => {
+            if (!Array.isArray(value)) {
+                return [];
+            }
+            const prop = String(property);
+            return value.map((item) => {
+                if (item && typeof item === 'object') {
+                    return item[prop];
+                }
+                return undefined;
+            });
+        },
+    },
+    filter: {
+        name: 'filter',
+        description: 'Filters array elements by property',
+        category: 'array',
+        signature: 'filter(property, value)',
+        examples: ['{{trigger.users | filter("active", true)}}'],
+        execute: (value, property, filterValue) => {
+            if (!Array.isArray(value)) {
+                return [];
+            }
+            const prop = String(property);
+            return value.filter((item) => {
+                if (item && typeof item === 'object') {
+                    return item[prop] === filterValue;
+                }
+                return false;
+            });
+        },
+    },
+    pluck: {
+        name: 'pluck',
+        description: 'Extracts property from each object',
+        category: 'array',
+        signature: 'pluck(property)',
+        examples: ['{{trigger.users | pluck("email")}}'],
+        execute: (value, property) => {
+            if (!Array.isArray(value)) {
+                return [];
+            }
+            const prop = String(property);
+            return value.map((item) => {
+                if (item && typeof item === 'object') {
+                    return item[prop];
+                }
+                return undefined;
+            });
+        },
+    },
+};

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

@@ -0,0 +1,8 @@
+import type { PipeDefinition } from './string-pipes';
+import type { OperationCategory } from '../types';
+export declare const PIPE_OPERATIONS: Record<string, PipeDefinition>;
+export declare function executePipeOperation(name: string, value: unknown, args: unknown[]): unknown;
+export declare function getPipesByCategory(category: OperationCategory): Record<string, PipeDefinition>;
+export declare function getPipeNames(): string[];
+export declare function hasPipe(name: string): boolean;
+export declare function getPipe(name: string): PipeDefinition | undefined;