@abyss-project/main 1.0.110 → 1.0.111

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

@@ -1,178 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringPipes = void 0;
-exports.stringPipes = {
-    upper: {
-        name: 'upper',
-        description: 'Converts to uppercase',
-        category: 'string',
-        signature: 'upper',
-        examples: ['{{trigger.name | upper}}'],
-        execute: (value) => String(value).toUpperCase(),
-    },
-    lower: {
-        name: 'lower',
-        description: 'Converts to lowercase',
-        category: 'string',
-        signature: 'lower',
-        examples: ['{{trigger.email | lower}}'],
-        execute: (value) => String(value).toLowerCase(),
-    },
-    capitalize: {
-        name: 'capitalize',
-        description: 'Capitalizes the first letter',
-        category: 'string',
-        signature: 'capitalize',
-        examples: ['{{trigger.name | capitalize}}'],
-        execute: (value) => {
-            const str = String(value);
-            return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
-        },
-    },
-    trim: {
-        name: 'trim',
-        description: 'Removes whitespace from both ends',
-        category: 'string',
-        signature: 'trim',
-        examples: ['{{trigger.input | trim}}'],
-        execute: (value) => String(value).trim(),
-    },
-    truncate: {
-        name: 'truncate',
-        description: 'Truncates a string to a specified length',
-        category: 'string',
-        signature: 'truncate(length)',
-        examples: ['{{trigger.description | truncate(100)}}'],
-        execute: (value, length) => {
-            const str = String(value);
-            const len = Number(length);
-            return str.length > len ? str.substring(0, len) + '...' : str;
-        },
-    },
-    replace: {
-        name: 'replace',
-        description: 'Replaces occurrences of a pattern',
-        category: 'string',
-        signature: 'replace(search, replacement)',
-        examples: ['{{trigger.text | replace("old", "new")}}'],
-        execute: (value, search, replacement) => {
-            const searchStr = String(search);
-            const replaceStr = String(replacement);
-            return String(value).replace(new RegExp(searchStr.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), replaceStr);
-        },
-    },
-    split: {
-        name: 'split',
-        description: 'Splits a string into an array',
-        category: 'string',
-        signature: 'split(separator)',
-        examples: ['{{trigger.tags | split(",")}}'],
-        execute: (value, separator) => {
-            return String(value).split(String(separator));
-        },
-    },
-    substring: {
-        name: 'substring',
-        description: 'Extracts a substring',
-        category: 'string',
-        signature: 'substring(start, end?)',
-        examples: ['{{trigger.id | substring(0, 8)}}'],
-        execute: (value, start, end) => {
-            return String(value).substring(Number(start), end !== undefined ? Number(end) : undefined);
-        },
-    },
-    padStart: {
-        name: 'padStart',
-        description: 'Pads a string from the start',
-        category: 'string',
-        signature: 'padStart(length, padString?)',
-        examples: ['{{trigger.id | padStart(10, "0")}}'],
-        execute: (value, length, padString) => {
-            return String(value).padStart(Number(length), padString !== undefined ? String(padString) : ' ');
-        },
-    },
-    padEnd: {
-        name: 'padEnd',
-        description: 'Pads a string from the end',
-        category: 'string',
-        signature: 'padEnd(length, padString?)',
-        examples: ['{{trigger.code | padEnd(5, "X")}}'],
-        execute: (value, length, padString) => {
-            return String(value).padEnd(Number(length), padString !== undefined ? String(padString) : ' ');
-        },
-    },
-    repeat: {
-        name: 'repeat',
-        description: 'Repeats a string n times',
-        category: 'string',
-        signature: 'repeat(count)',
-        examples: ['{{trigger.char | repeat(3)}}'],
-        execute: (value, count) => {
-            return String(value).repeat(Number(count));
-        },
-    },
-    reverse: {
-        name: 'reverse',
-        description: 'Reverses a string',
-        category: 'string',
-        signature: 'reverse',
-        examples: ['{{trigger.text | reverse}}'],
-        execute: (value) => {
-            return String(value).split('').reverse().join('');
-        },
-    },
-    slugify: {
-        name: 'slugify',
-        description: 'Converts to URL-friendly slug',
-        category: 'string',
-        signature: 'slugify',
-        examples: ['{{trigger.title | slugify}}'],
-        execute: (value) => {
-            return String(value)
-                .toLowerCase()
-                .trim()
-                .replace(/[^\w\s-]/g, '')
-                .replace(/[\s_-]+/g, '-')
-                .replace(/^-+|-+$/g, '');
-        },
-    },
-    camelCase: {
-        name: 'camelCase',
-        description: 'Converts to camelCase',
-        category: 'string',
-        signature: 'camelCase',
-        examples: ['{{trigger.text | camelCase}}'],
-        execute: (value) => {
-            return String(value)
-                .replace(/[^\w\s]/g, '')
-                .replace(/\s+(.)/g, (_, char) => char.toUpperCase())
-                .replace(/^\w/, (char) => char.toLowerCase());
-        },
-    },
-    kebabCase: {
-        name: 'kebabCase',
-        description: 'Converts to kebab-case',
-        category: 'string',
-        signature: 'kebabCase',
-        examples: ['{{trigger.text | kebabCase}}'],
-        execute: (value) => {
-            return String(value)
-                .replace(/([a-z])([A-Z])/g, '$1-$2')
-                .replace(/[\s_]+/g, '-')
-                .toLowerCase();
-        },
-    },
-    snakeCase: {
-        name: 'snakeCase',
-        description: 'Converts to snake_case',
-        category: 'string',
-        signature: 'snakeCase',
-        examples: ['{{trigger.text | snakeCase}}'],
-        execute: (value) => {
-            return String(value)
-                .replace(/([a-z])([A-Z])/g, '$1_$2')
-                .replace(/[\s-]+/g, '_')
-                .toLowerCase();
-        },
-    },
-};

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

@@ -1,8 +0,0 @@
-import type { ParsedExpression, 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;

package/dist/workflow/expressions/resolver.js

@@ -1,263 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveExpression = exports.interpolateString = exports.evaluateExpression = exports.resolvePathValue = exports.buildResolverContext = void 0;
-const parser_1 = require("./parser");
-const functions_1 = require("./functions");
-const pipes_1 = require("./pipes");
-function buildResolverContext(workflowContext) {
-    var _a;
-    if (!workflowContext) {
-        return {};
-    }
-    const context = {};
-    if (workflowContext.triggerData) {
-        context.trigger = workflowContext.triggerData;
-        context.triggerData = workflowContext.triggerData;
-    }
-    if (workflowContext.stepExecutions) {
-        const steps = {};
-        for (const [stepId, execution] of Object.entries(workflowContext.stepExecutions)) {
-            const step = (_a = workflowContext.steps) === null || _a === void 0 ? void 0 : _a.find((s) => s.id === stepId);
-            const stepKey = (step === null || step === void 0 ? void 0 : step.name) || stepId;
-            steps[stepKey] = execution.outputData;
-        }
-        context.steps = steps;
-    }
-    if (workflowContext.variables) {
-        context.variables = workflowContext.variables;
-    }
-    context.project = {
-        id: workflowContext.projectId,
-        ...(workflowContext.projectName
-            ? { name: workflowContext.projectName }
-            : {}),
-    };
-    if (workflowContext.workflowId) {
-        context.workflow = {
-            id: workflowContext.workflowId,
-        };
-    }
-    return context;
-}
-exports.buildResolverContext = buildResolverContext;
-function resolvePathValue(path, context) {
-    const segments = (0, parser_1.parsePathSegments)(path);
-    let current = context;
-    for (const segment of segments) {
-        if (current === null || current === undefined) {
-            return undefined;
-        }
-        if (/^\d+$/.test(segment) && Array.isArray(current)) {
-            current = current[Number(segment)];
-        }
-        else if (typeof current === 'object') {
-            current = current[segment];
-        }
-        else {
-            return undefined;
-        }
-    }
-    return current;
-}
-exports.resolvePathValue = resolvePathValue;
-function evaluateExpression(parsed, context, secretsMap) {
-    switch (parsed.type) {
-        case 'literal':
-            return parsed.literalValue;
-        case 'path':
-            return evaluatePathExpression(parsed, context, secretsMap);
-        case 'function':
-            return evaluateFunctionExpression(parsed, context, secretsMap);
-        case 'binary':
-            return evaluateBinaryExpression(parsed, context, secretsMap);
-        case 'unary':
-            return evaluateUnaryExpression(parsed, context, secretsMap);
-        case 'ternary':
-            return evaluateTernaryExpression(parsed, context, secretsMap);
-        case 'group':
-            return evaluateExpression(parsed.expression, context, secretsMap);
-        default:
-            return undefined;
-    }
-}
-exports.evaluateExpression = evaluateExpression;
-function evaluatePathExpression(parsed, context, secretsMap) {
-    var _a;
-    if (parsed.source === 'secret' && secretsMap && parsed.path) {
-        const secretKey = parsed.path.replace('secret.', '');
-        let value = (_a = secretsMap.get(secretKey)) !== null && _a !== void 0 ? _a : `[Secret: ${secretKey}]`;
-        if (parsed.operations && parsed.operations.length > 0) {
-            for (const op of parsed.operations) {
-                try {
-                    const resolvedArgs = op.args.map((arg) => {
-                        if (typeof arg === 'string' && arg.includes('.')) {
-                            const resolved = resolvePathValue(arg, context);
-                            return resolved !== undefined ? resolved : arg;
-                        }
-                        return arg;
-                    });
-                    value = (0, pipes_1.executePipeOperation)(op.name, value, resolvedArgs);
-                }
-                catch (error) {
-                    return `[Error: ${error.message}]`;
-                }
-            }
-        }
-        return value;
-    }
-    let value = parsed.path ? resolvePathValue(parsed.path, context) : undefined;
-    if (parsed.operations && parsed.operations.length > 0) {
-        for (const op of parsed.operations) {
-            try {
-                const resolvedArgs = op.args.map((arg) => {
-                    if (typeof arg === 'string' && arg.includes('.')) {
-                        const resolved = resolvePathValue(arg, context);
-                        return resolved !== undefined ? resolved : arg;
-                    }
-                    return arg;
-                });
-                value = (0, pipes_1.executePipeOperation)(op.name, value, resolvedArgs);
-            }
-            catch (error) {
-                return `[Error: ${error.message}]`;
-            }
-        }
-    }
-    return value;
-}
-function evaluateFunctionExpression(parsed, context, secretsMap) {
-    if (!parsed.functionName) {
-        return undefined;
-    }
-    const resolvedArgs = (parsed.functionArgs || []).map((arg) => {
-        if (typeof arg === 'string' && arg.includes('.')) {
-            const resolved = resolvePathValue(arg, context);
-            return resolved !== undefined ? resolved : arg;
-        }
-        return arg;
-    });
-    try {
-        let value = (0, functions_1.executeFunction)(parsed.functionName, resolvedArgs);
-        if (parsed.operations && parsed.operations.length > 0) {
-            for (const op of parsed.operations) {
-                try {
-                    const resolvedPipeArgs = op.args.map((arg) => {
-                        if (typeof arg === 'string' && arg.includes('.')) {
-                            const resolved = resolvePathValue(arg, context);
-                            return resolved !== undefined ? resolved : arg;
-                        }
-                        return arg;
-                    });
-                    value = (0, pipes_1.executePipeOperation)(op.name, value, resolvedPipeArgs);
-                }
-                catch (error) {
-                    return `[Error: ${error.message}]`;
-                }
-            }
-        }
-        return value;
-    }
-    catch (error) {
-        return `[Error: ${error.message}]`;
-    }
-}
-function evaluateBinaryExpression(parsed, context, secretsMap) {
-    const left = evaluateExpression(parsed.left, context, secretsMap);
-    const right = evaluateExpression(parsed.right, context, secretsMap);
-    switch (parsed.operator) {
-        case '+':
-            return left + right;
-        case '-':
-            return left - right;
-        case '*':
-            return left * right;
-        case '/':
-            return left / right;
-        case '%':
-            return left % right;
-        case '**':
-            return Math.pow(left, right);
-        case '==':
-        case '===':
-            return left === right;
-        case '!=':
-        case '!==':
-            return left !== right;
-        case '<':
-            return left < right;
-        case '>':
-            return left > right;
-        case '<=':
-            return left <= right;
-        case '>=':
-            return left >= right;
-        case '&&':
-            return left && right;
-        case '||':
-            return left || right;
-        default:
-            return undefined;
-    }
-}
-function evaluateUnaryExpression(parsed, context, secretsMap) {
-    const operand = evaluateExpression(parsed.operand, context, secretsMap);
-    switch (parsed.operator) {
-        case '!':
-            return !operand;
-        case '-':
-            return -operand;
-        default:
-            return undefined;
-    }
-}
-function evaluateTernaryExpression(parsed, context, secretsMap) {
-    const condition = evaluateExpression(parsed.condition, context, secretsMap);
-    return condition
-        ? evaluateExpression(parsed.consequent, context, secretsMap)
-        : evaluateExpression(parsed.alternate, context, secretsMap);
-}
-function interpolateString(template, context, secretsMap, options = {}) {
-    const tokens = (0, parser_1.tokenizeTemplate)(template);
-    let result = '';
-    for (const token of tokens) {
-        if (token.type === 'text') {
-            result += token.value;
-        }
-        else if (token.type === 'expression') {
-            try {
-                const parsed = (0, parser_1.parseExpression)(token.value);
-                let value = evaluateExpression(parsed, context, secretsMap);
-                if (parsed.type === 'path' &&
-                    parsed.source === 'secret' &&
-                    options.maskSecrets) {
-                    result += '••••••••';
-                }
-                else if (value !== undefined && value !== null) {
-                    result +=
-                        typeof value === 'object' ? JSON.stringify(value) : String(value);
-                }
-                else {
-                    result += `{{${token.value}}}`;
-                }
-            }
-            catch (error) {
-                result += `[Error: ${error.message}]`;
-            }
-        }
-    }
-    return result;
-}
-exports.interpolateString = interpolateString;
-function resolveExpression(expression, context, secretsMap) {
-    if (expression.includes('{{') && expression.includes('}}')) {
-        const tokens = (0, parser_1.tokenizeTemplate)(expression);
-        if (tokens.length === 1 && tokens[0].type === 'expression') {
-            const parsed = (0, parser_1.parseExpression)(tokens[0].value);
-            return evaluateExpression(parsed, context, secretsMap);
-        }
-        return interpolateString(expression, context, secretsMap);
-    }
-    const parsed = (0, parser_1.parseExpression)(expression);
-    return evaluateExpression(parsed, context, secretsMap);
-}
-exports.resolveExpression = resolveExpression;

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

@@ -1,144 +0,0 @@
-export declare enum DataSourceType {
-    WORKFLOW_TRIGGER = "trigger",
-    WORKFLOW_STEPS = "steps",
-    WORKFLOW_VARIABLES = "variables",
-    IP_ADDRESSES = "ipAddress",
-    DOMAINS = "domain",
-    APPLICATIONS = "app",
-    SECRETS = "secret",
-    PROJECT = "project",
-    ENV = "env",
-    ABYSS_CONFIG = "abyss",
-    FUNCTIONS = "fn"
-}
-export declare const OPERATOR_PRECEDENCE: Record<string, number>;
-export type ParsedExpression = PathExpression | FunctionExpression | BinaryExpression | UnaryExpression | TernaryExpression | LiteralExpression | GroupExpression;
-export interface BaseExpression {
-    type: string;
-    isValid: boolean;
-    error?: string;
-}
-export interface PathExpression extends BaseExpression {
-    type: 'path';
-    path: string;
-    source: DataSourceType | null;
-    operations?: PipeOperation[];
-    resolvedValue?: unknown;
-}
-export interface FunctionExpression extends BaseExpression {
-    type: 'function';
-    isFunction: true;
-    functionName: string;
-    functionArgs: unknown[];
-    operations?: PipeOperation[];
-    resolvedValue?: unknown;
-}
-export interface BinaryExpression extends BaseExpression {
-    type: 'binary';
-    operator: string;
-    left: ParsedExpression;
-    right: ParsedExpression;
-}
-export interface UnaryExpression extends BaseExpression {
-    type: 'unary';
-    operator: string;
-    operand: ParsedExpression;
-}
-export interface TernaryExpression extends BaseExpression {
-    type: 'ternary';
-    condition: ParsedExpression;
-    consequent: ParsedExpression;
-    alternate: ParsedExpression;
-}
-export interface LiteralExpression extends BaseExpression {
-    type: 'literal';
-    literalType: 'string' | 'number' | 'boolean' | 'null';
-    literalValue: unknown;
-}
-export interface GroupExpression extends BaseExpression {
-    type: 'group';
-    expression: ParsedExpression;
-}
-export interface PipeOperation {
-    name: string;
-    args: unknown[];
-    description?: string;
-    category?: OperationCategory;
-}
-export type OperationCategory = 'string' | 'array' | 'object' | 'number' | 'date' | 'encoding' | 'formatting';
-export interface BuiltInFunction {
-    name: string;
-    description: string;
-    category: FunctionCategory;
-    signature: string;
-    args: FunctionArg[];
-    returnType: string;
-    examples: string[];
-    execute: (...args: unknown[]) => unknown;
-}
-export type FunctionCategory = 'datetime' | 'string' | 'math' | 'crypto' | 'array' | 'utility' | 'encoding';
-export interface FunctionArg {
-    name: string;
-    type: string;
-    required: boolean;
-    description: string;
-}
-export interface WorkflowContext {
-    projectId: string;
-    projectName?: string;
-    workflowId?: string;
-    triggerData?: Record<string, unknown>;
-    stepExecutions?: Record<string, StepExecution>;
-    variables?: Record<string, unknown>;
-    steps?: WorkflowStep[];
-}
-export interface StepExecution {
-    stepId: string;
-    outputData: unknown;
-    status: 'success' | 'failed' | 'running' | 'pending';
-    startedAt?: Date;
-    completedAt?: Date;
-    error?: string;
-}
-export interface WorkflowStep {
-    id: string;
-    name: string;
-    type: string;
-    config?: Record<string, unknown>;
-}
-export interface ExpressionToken {
-    type: 'text' | 'expression' | 'reference' | 'function' | 'error';
-    value: string;
-    rawValue: string;
-    start: number;
-    end: number;
-    parsed?: ParsedExpression;
-    isSecret?: boolean;
-}
-export interface ValidationResult {
-    isValid: boolean;
-    errors: ValidationError[];
-    warnings: ValidationWarning[];
-}
-export interface ValidationError {
-    type: 'error';
-    message: string;
-    start: number;
-    end: number;
-    path?: string;
-}
-export interface ValidationWarning {
-    type: 'warning';
-    message: string;
-    start: number;
-    end: number;
-    path?: string;
-    suggestion?: string;
-}
-export interface WorkflowResourceMapping {
-    source: DataSourceType;
-    resourceId: string;
-    resourceName: string;
-    displayPath: string;
-    savePath: string;
-}

package/dist/workflow/expressions/types.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OPERATOR_PRECEDENCE = exports.DataSourceType = void 0;
-var DataSourceType;
-(function (DataSourceType) {
-    DataSourceType["WORKFLOW_TRIGGER"] = "trigger";
-    DataSourceType["WORKFLOW_STEPS"] = "steps";
-    DataSourceType["WORKFLOW_VARIABLES"] = "variables";
-    DataSourceType["IP_ADDRESSES"] = "ipAddress";
-    DataSourceType["DOMAINS"] = "domain";
-    DataSourceType["APPLICATIONS"] = "app";
-    DataSourceType["SECRETS"] = "secret";
-    DataSourceType["PROJECT"] = "project";
-    DataSourceType["ENV"] = "env";
-    DataSourceType["ABYSS_CONFIG"] = "abyss";
-    DataSourceType["FUNCTIONS"] = "fn";
-})(DataSourceType || (exports.DataSourceType = DataSourceType = {}));
-exports.OPERATOR_PRECEDENCE = {
-    '||': 1,
-    '&&': 2,
-    '==': 3,
-    '!=': 3,
-    '<': 4,
-    '>': 4,
-    '<=': 4,
-    '>=': 4,
-    '+': 5,
-    '-': 5,
-    '*': 6,
-    '/': 6,
-    '%': 6,
-    '**': 7,
-};

package/dist/workflow/index.d.ts

@@ -1 +0,0 @@
-export * from './expressions';