@abyss-project/main 1.0.109 → 1.0.111

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

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

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

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