@abyss-project/main 1.0.109 → 1.0.111

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