@abyss-project/console 1.0.41 → 1.0.43

package/dist/workflow-expressions/resolver.js

@@ -1,275 +1,92 @@
 "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");
+exports.interpolateTemplate = exports.resolvePathValue = exports.buildResolverContext = void 0;
 function buildResolverContext(workflowContext) {
     var _a;
     if (!workflowContext) {
         return {};
     }
     const context = {};
-    if (workflowContext.triggerData) {
-        context.trigger = workflowContext.triggerData;
-        context.triggerData = workflowContext.triggerData;
+    if (workflowContext.trigger) {
+        context.trigger = workflowContext.trigger;
     }
     if (workflowContext.triggers) {
         context.triggers = workflowContext.triggers;
     }
     if (workflowContext.stepExecutions) {
-        const steps = {};
+        const stepExecutions = {};
         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;
+            stepExecutions[stepKey] = execution.outputData;
         }
-        context.steps = steps;
+        context.stepExecutions = stepExecutions;
     }
-    if (workflowContext.variables) {
-        context.variables = workflowContext.variables;
+    if (workflowContext.steps) {
+        context.steps = workflowContext.steps;
     }
     if (workflowContext.ipAddresses) {
-        context.ipAddress = workflowContext.ipAddresses;
+        context.ipAddresses = workflowContext.ipAddresses;
     }
     if (workflowContext.domains) {
-        context.domain = workflowContext.domains;
+        context.domains = workflowContext.domains;
     }
     if (workflowContext.applications) {
-        context.app = workflowContext.applications;
+        context.applications = workflowContext.applications;
     }
     if (workflowContext.secrets) {
-        context.secret = workflowContext.secrets;
+        context.secrets = workflowContext.secrets;
     }
-    context.project = {
-        id: workflowContext.projectId,
-        ...(workflowContext.projectName ? { name: workflowContext.projectName } : {}),
-    };
-    if (workflowContext.workflowId) {
-        context.workflow = {
-            id: workflowContext.workflowId,
-        };
+    if (workflowContext.project) {
+        context.project = workflowContext.project;
+    }
+    if (workflowContext.workflow) {
+        context.workflow = workflowContext.workflow;
+    }
+    if (workflowContext.workflowExecution) {
+        context.workflowExecution = workflowContext.workflowExecution;
+    }
+    if (workflowContext.abyss) {
+        context.abyss = workflowContext.abyss;
     }
     return context;
 }
 exports.buildResolverContext = buildResolverContext;
 function resolvePathValue(path, context) {
-    const segments = (0, parser_1.parsePathSegments)(path);
+    if (!path)
+        return undefined;
+    const segments = path.split('.');
     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;
-        }
+        current = current[segment];
     }
     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;
+function interpolateTemplate(template, context) {
+    if (!template || typeof template !== 'string') {
+        return String(template || '');
+    }
+    const pattern = /\{\{(.+?)\}\}/g;
+    const matches = [...template.matchAll(pattern)];
+    if (matches.length === 0) {
+        return template;
+    }
+    let result = template;
+    for (const match of matches) {
+        const [fullMatch, expression] = match;
+        try {
+            const value = resolvePathValue(expression.trim(), context);
+            result = result.replace(fullMatch, String(value !== null && value !== void 0 ? value : ''));
         }
-        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);
-                const 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}]`;
-            }
+        catch (error) {
+            console.error(`Failed to interpolate ${expression}:`, error);
+            result = result.replace(fullMatch, `{{${expression}}}`);
         }
     }
     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;
+exports.interpolateTemplate = interpolateTemplate;

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

@@ -1,153 +1,36 @@
-import type { ResourceMapping as GenericResourceMapping } from '../expressions/types';
-import type { WorkflowTriggerType } from '../types/enum/workflow.enum';
+import type { IProject, IWorkflow, IWorkflowTrigger, IWorkflowStep, IWorkflowStepExecution, IWorkflowExecution, IIpAddress, IDomainVerification, ISecret } from '../types';
 export declare enum DataSourceType {
     WORKFLOW_TRIGGER = "trigger",
     WORKFLOW_STEPS = "steps",
-    WORKFLOW_VARIABLES = "variables",
     IP_ADDRESSES = "ipAddress",
     DOMAINS = "domain",
     APPLICATIONS = "app",
     SECRETS = "secret",
     PROJECT = "project",
-    ABYSS_CONFIG = "abyss",
-    FUNCTIONS = "fn",
-    OPERATORS = "op"
-}
-export interface TriggerInfo {
-    id: string;
-    name: string;
-    type: WorkflowTriggerType;
-    isActive: boolean;
-}
-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;
+    WORKFLOW = "workflow",
+    ABYSS = "abyss"
 }
 export interface WorkflowContext {
-    projectId: string;
-    projectName?: string;
-    workflowId?: string;
-    triggerData?: Record<string, unknown>;
-    triggers?: Record<string, Record<string, unknown>>;
-    stepExecutions?: Record<string, StepExecution>;
-    variables?: Record<string, unknown>;
-    steps?: WorkflowStep[];
-    ipAddresses?: Record<string, Record<string, unknown>>;
-    domains?: Record<string, Record<string, unknown>>;
-    applications?: Record<string, Record<string, unknown>>;
-    secrets?: Record<string, string>;
-}
-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 extends Omit<GenericResourceMapping<DataSourceType>, 'source'> {
-    source: DataSourceType;
+    project: Pick<IProject, 'id'> & {
+        name: string;
+    };
+    workflow: Pick<IWorkflow, 'id' | 'name' | 'description' | 'template' | 'status' | 'settings'>;
+    workflowExecution?: Pick<IWorkflowExecution, 'id' | 'status' | 'startedAt' | 'completedAt' | 'context' | 'metadata'>;
+    trigger?: IWorkflowTrigger & {
+        data: unknown;
+    };
+    triggers?: Record<string, IWorkflowTrigger>;
+    stepExecutions?: Record<string, IWorkflowStepExecution>;
+    steps?: IWorkflowStep[];
+    ipAddresses?: Record<string, IIpAddress>;
+    domains?: Record<string, IDomainVerification>;
+    applications?: Record<string, Record<string, {
+        id: string;
+        name: string;
+    }>>;
+    secrets?: Record<string, Pick<ISecret, 'id' | 'key' | 'name'>>;
+    abyss?: Record<string, {
+        api: string;
+        site?: string;
+    }>;
 }

package/dist/workflow-expressions/types.js

@@ -1,33 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OPERATOR_PRECEDENCE = exports.DataSourceType = void 0;
+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["ABYSS_CONFIG"] = "abyss";
-    DataSourceType["FUNCTIONS"] = "fn";
-    DataSourceType["OPERATORS"] = "op";
+    DataSourceType["WORKFLOW"] = "workflow";
+    DataSourceType["ABYSS"] = "abyss";
 })(DataSourceType || (exports.DataSourceType = DataSourceType = {}));
-exports.OPERATOR_PRECEDENCE = {
-    '||': 1,
-    '&&': 2,
-    '==': 3,
-    '!=': 3,
-    '<': 4,
-    '>': 4,
-    '<=': 4,
-    '>=': 4,
-    '+': 5,
-    '-': 5,
-    '*': 6,
-    '/': 6,
-    '%': 6,
-    '**': 7,
-};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abyss-project/console",
-  "version": "1.0.41",
+  "version": "1.0.43",
   "description": "Core package to interact with AbyssConsole",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/expressions/functions/array.d.ts

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