@abyss-project/console 1.0.28 → 1.0.30

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

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

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

@@ -0,0 +1,260 @@
+"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);
+                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}]`;
+            }
+        }
+    }
+    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

@@ -0,0 +1,141 @@
+import type { ResourceMapping as GenericResourceMapping } from '../expressions/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",
+    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 extends Omit<GenericResourceMapping<DataSourceType>, 'source'> {
+    source: DataSourceType;
+}

package/dist/workflow-expressions/types.js

@@ -0,0 +1,33 @@
+"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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abyss-project/console",
-  "version": "1.0.28",
+  "version": "1.0.30",
   "description": "Core package to interact with AbyssConsole",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,6 +14,7 @@
   "dependencies": {
     "axios": "^1.2.2",
     "axios-retry": "^3.4.0",
+    "date-fns": "^2.30.0",
     "fs-extra": "^11.1.1",
     "lodash": "^4.17.21",
     "reflect-metadata": "^0.1.13",