@abyss-project/console 1.0.29 → 1.0.31

package/dist/workflow-expressions/helpers.js

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValueType = exports.convertExpressionToDisplayFormat = exports.convertExpressionToSaveFormat = exports.generatePreview = exports.validateExpression = exports.tokenizeEnriched = exports.getCurrentExpressionContext = exports.parseOperations = exports.extractPaths = exports.isInsideExpression = exports.hasReferences = exports.hasExpressions = exports.buildReferenceString = exports.buildExpressionString = void 0;
+const types_1 = require("./types");
+const parser_1 = require("./parser");
+const parser_2 = require("./parser");
+const resolver_1 = require("./resolver");
+const parser_3 = require("./parser");
+function buildExpressionString(path, operations) {
+    let expr = `{{${path}`;
+    if (operations && operations.length > 0) {
+        const opsStr = operations
+            .map((op) => {
+            if (op.args.length === 0) {
+                return op.name;
+            }
+            const argsStr = op.args
+                .map((arg) => (typeof arg === 'string' ? `"${arg}"` : String(arg)))
+                .join(', ');
+            return `${op.name}(${argsStr})`;
+        })
+            .join(' | ');
+        expr += ` | ${opsStr}`;
+    }
+    expr += '}}';
+    return expr;
+}
+exports.buildExpressionString = buildExpressionString;
+function buildReferenceString(type, id) {
+    return `@${type}:${id}`;
+}
+exports.buildReferenceString = buildReferenceString;
+function hasExpressions(str) {
+    return /\{\{.+?\}\}/.test(str);
+}
+exports.hasExpressions = hasExpressions;
+function hasReferences(str) {
+    return /@\w+:[a-zA-Z0-9-_]+/.test(str);
+}
+exports.hasReferences = hasReferences;
+function isInsideExpression(text, cursorPos) {
+    const beforeCursor = text.substring(0, cursorPos);
+    const lastOpenBrace = beforeCursor.lastIndexOf('{{');
+    const lastCloseBrace = beforeCursor.lastIndexOf('}}');
+    return lastOpenBrace > lastCloseBrace && lastOpenBrace !== -1;
+}
+exports.isInsideExpression = isInsideExpression;
+function extractPaths(str) {
+    const matches = str.matchAll(/\{\{(.+?)\}\}/g);
+    return Array.from(matches, (m) => {
+        const expr = m[1].trim();
+        const [path] = expr.split('|');
+        return path.trim();
+    });
+}
+exports.extractPaths = extractPaths;
+function parseOperations(opsStr) {
+    if (!opsStr || !opsStr.trim()) {
+        return [];
+    }
+    const operations = [];
+    const parts = opsStr.split('|').map((p) => p.trim());
+    for (const part of parts) {
+        if (!part) {
+            continue;
+        }
+        const match = part.match(/^(\w+)(?:\(([^)]*)\))?$/);
+        if (match) {
+            const [, name, argsStr] = match;
+            const args = [];
+            if (argsStr) {
+                const argParts = argsStr.split(',').map((a) => a.trim());
+                for (const arg of argParts) {
+                    if (arg.startsWith('"') || arg.startsWith("'")) {
+                        args.push(arg.slice(1, -1));
+                    }
+                    else if (!isNaN(Number(arg))) {
+                        args.push(Number(arg));
+                    }
+                    else if (arg === 'true' || arg === 'false') {
+                        args.push(arg === 'true');
+                    }
+                    else {
+                        args.push(arg);
+                    }
+                }
+            }
+            operations.push({ name, args });
+        }
+    }
+    return operations;
+}
+exports.parseOperations = parseOperations;
+function getCurrentExpressionContext(text, cursorPos) {
+    if (!isInsideExpression(text, cursorPos)) {
+        return null;
+    }
+    const beforeCursor = text.substring(0, cursorPos);
+    const afterCursor = text.substring(cursorPos);
+    const start = beforeCursor.lastIndexOf('{{') + 2;
+    const endMatch = afterCursor.match(/\}\}/);
+    const end = endMatch && endMatch.index !== undefined ? cursorPos + endMatch.index : text.length;
+    const expression = text.substring(start, end);
+    const [path] = expression.split('|');
+    const expressionContent = expression.trim();
+    const cursorOffsetInExpression = cursorPos - start;
+    const contentUpToCursor = expression.substring(0, cursorOffsetInExpression);
+    const match = contentUpToCursor.match(/([a-zA-Z_][a-zA-Z0-9_]*(?:\["[^"]*"\]|\['[^']*'\]|\[[^\]]*\]|\.(?:[a-zA-Z_][a-zA-Z0-9_]*))*\.?[a-zA-Z0-9_]*)$/);
+    const currentPath = match && match[1] ? match[1] : '';
+    return {
+        isInExpression: true,
+        expressionStart: start,
+        expressionContent,
+        cursorOffsetInExpression,
+        currentPath,
+        expression: expression.trim(),
+        start,
+        end,
+        path: path.trim(),
+    };
+}
+exports.getCurrentExpressionContext = getCurrentExpressionContext;
+function tokenizeEnriched(template) {
+    const backendTokens = (0, parser_1.tokenizeTemplate)(template);
+    const result = [];
+    let currentPos = 0;
+    for (const token of backendTokens) {
+        if (token.type === 'text') {
+            result.push({
+                type: 'text',
+                value: token.value,
+                rawValue: token.value,
+                start: currentPos,
+                end: currentPos + token.value.length,
+            });
+            currentPos += token.value.length;
+        }
+        else {
+            const exprValue = token.value.trim();
+            const parsed = (0, parser_2.parseExpression)(exprValue);
+            const source = (0, parser_3.detectDataSource)(exprValue);
+            const rawValue = `{{${token.value}}}`;
+            result.push({
+                type: parsed.isValid ? 'expression' : 'error',
+                value: exprValue,
+                rawValue: rawValue,
+                start: currentPos,
+                end: currentPos + rawValue.length,
+                parsed,
+                source,
+                isSecret: source === types_1.DataSourceType.SECRETS,
+            });
+            currentPos += rawValue.length;
+        }
+    }
+    return result;
+}
+exports.tokenizeEnriched = tokenizeEnriched;
+function validateExpression(expression, context) {
+    const tokens = tokenizeEnriched(expression);
+    try {
+        const parsed = (0, parser_2.parseExpression)(expression);
+        if (!parsed.isValid) {
+            return {
+                isValid: false,
+                errors: [
+                    {
+                        type: 'error',
+                        message: parsed.error || 'Invalid expression',
+                        start: 0,
+                        end: expression.length,
+                        path: expression,
+                    },
+                ],
+                warnings: [],
+                tokens,
+            };
+        }
+        (0, resolver_1.evaluateExpression)(parsed, context);
+        return {
+            isValid: true,
+            errors: [],
+            warnings: [],
+            tokens,
+        };
+    }
+    catch (error) {
+        return {
+            isValid: false,
+            errors: [
+                {
+                    type: 'error',
+                    message: error instanceof Error ? error.message : 'Validation error',
+                    start: 0,
+                    end: expression.length,
+                    path: expression,
+                },
+            ],
+            warnings: [],
+            tokens,
+        };
+    }
+}
+exports.validateExpression = validateExpression;
+function generatePreview(expression, context) {
+    try {
+        const parsed = (0, parser_2.parseExpression)(expression);
+        if (!parsed.isValid) {
+            return { value: null, type: 'error', error: parsed.error };
+        }
+        const value = (0, resolver_1.evaluateExpression)(parsed, context);
+        const type = value === null ? 'null' : typeof value;
+        return { value, type };
+    }
+    catch (error) {
+        return {
+            value: null,
+            type: 'error',
+            error: error instanceof Error ? error.message : 'Evaluation error',
+        };
+    }
+}
+exports.generatePreview = generatePreview;
+function convertExpressionToSaveFormat(expression, mappings) {
+    if (!expression || mappings.length === 0) {
+        return expression;
+    }
+    let result = expression;
+    const sortedMappings = [...mappings].sort((a, b) => b.displayPath.length - a.displayPath.length);
+    for (const mapping of sortedMappings) {
+        const regex = new RegExp(mapping.displayPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g');
+        result = result.replace(regex, mapping.savePath);
+    }
+    return result;
+}
+exports.convertExpressionToSaveFormat = convertExpressionToSaveFormat;
+function convertExpressionToDisplayFormat(expression, mappings) {
+    if (!expression || mappings.length === 0) {
+        return expression;
+    }
+    let result = expression;
+    const sortedMappings = [...mappings].sort((a, b) => b.savePath.length - a.savePath.length);
+    for (const mapping of sortedMappings) {
+        const regex = new RegExp(mapping.savePath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g');
+        result = result.replace(regex, mapping.displayPath);
+    }
+    return result;
+}
+exports.convertExpressionToDisplayFormat = convertExpressionToDisplayFormat;
+function getValueType(value) {
+    if (value === null) {
+        return 'null';
+    }
+    if (value === undefined) {
+        return 'undefined';
+    }
+    if (Array.isArray(value)) {
+        return 'array';
+    }
+    return typeof value;
+}
+exports.getValueType = getValueType;

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

@@ -0,0 +1,16 @@
+export { DataSourceType, OPERATOR_PRECEDENCE } from './types';
+export type { ParsedExpression, PathExpression, FunctionExpression, BinaryExpression, UnaryExpression, TernaryExpression, LiteralExpression, GroupExpression, BuiltInFunction, FunctionCategory, FunctionArg, PipeOperation, OperationCategory, WorkflowContext, StepExecution, WorkflowStep, ValidationResult, ValidationError, ValidationWarning, ExpressionToken, WorkflowResourceMapping, } from './types';
+export { parseExpression, detectDataSource, parsePathSegments, tokenizeTemplate } from './parser';
+export { buildResolverContext, resolvePathValue, evaluateExpression, interpolateString, resolveExpression, } from './resolver';
+export { BUILT_IN_FUNCTIONS, executeFunction, getFunctionsByCategory, getFunctionNames, hasFunction, getFunction, } from './functions';
+export { PIPE_OPERATIONS, executePipeOperation, getPipesByCategory, getPipeNames, hasPipe, getPipe, } from './pipes';
+export type { PipeDefinition } from './pipes/string-pipes';
+import type { WorkflowContext } from './types';
+export { buildExpressionString, buildReferenceString, hasExpressions, hasReferences, isInsideExpression, extractPaths, parseOperations, getCurrentExpressionContext, getValueType, tokenizeEnriched, validateExpression, generatePreview, convertExpressionToSaveFormat, convertExpressionToDisplayFormat, } from './helpers';
+export type { ResourceMapping, EnrichedToken } from './helpers';
+export declare function evaluate(expression: string, workflowContext: WorkflowContext, secretsMap?: Map<string, string>): unknown;
+export declare function interpolate(template: string, workflowContext: WorkflowContext, secretsMap?: Map<string, string>, options?: {
+    maskSecrets?: boolean;
+}): string;
+export declare function hasDynamicContent(str: string): boolean;
+export declare function extractReferences(str: string): string[];

package/dist/workflow-expressions/index.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractReferences = exports.hasDynamicContent = exports.interpolate = exports.evaluate = exports.convertExpressionToDisplayFormat = exports.convertExpressionToSaveFormat = exports.generatePreview = exports.validateExpression = exports.tokenizeEnriched = exports.getValueType = exports.getCurrentExpressionContext = exports.parseOperations = exports.extractPaths = exports.isInsideExpression = exports.hasReferences = exports.hasExpressions = exports.buildReferenceString = exports.buildExpressionString = exports.getPipe = exports.hasPipe = exports.getPipeNames = exports.getPipesByCategory = exports.executePipeOperation = exports.PIPE_OPERATIONS = exports.getFunction = exports.hasFunction = exports.getFunctionNames = exports.getFunctionsByCategory = exports.executeFunction = exports.BUILT_IN_FUNCTIONS = exports.resolveExpression = exports.interpolateString = exports.evaluateExpression = exports.resolvePathValue = exports.buildResolverContext = exports.tokenizeTemplate = exports.parsePathSegments = exports.detectDataSource = exports.parseExpression = exports.OPERATOR_PRECEDENCE = exports.DataSourceType = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "DataSourceType", { enumerable: true, get: function () { return types_1.DataSourceType; } });
+Object.defineProperty(exports, "OPERATOR_PRECEDENCE", { enumerable: true, get: function () { return types_1.OPERATOR_PRECEDENCE; } });
+var parser_1 = require("./parser");
+Object.defineProperty(exports, "parseExpression", { enumerable: true, get: function () { return parser_1.parseExpression; } });
+Object.defineProperty(exports, "detectDataSource", { enumerable: true, get: function () { return parser_1.detectDataSource; } });
+Object.defineProperty(exports, "parsePathSegments", { enumerable: true, get: function () { return parser_1.parsePathSegments; } });
+Object.defineProperty(exports, "tokenizeTemplate", { enumerable: true, get: function () { return parser_1.tokenizeTemplate; } });
+var resolver_1 = require("./resolver");
+Object.defineProperty(exports, "buildResolverContext", { enumerable: true, get: function () { return resolver_1.buildResolverContext; } });
+Object.defineProperty(exports, "resolvePathValue", { enumerable: true, get: function () { return resolver_1.resolvePathValue; } });
+Object.defineProperty(exports, "evaluateExpression", { enumerable: true, get: function () { return resolver_1.evaluateExpression; } });
+Object.defineProperty(exports, "interpolateString", { enumerable: true, get: function () { return resolver_1.interpolateString; } });
+Object.defineProperty(exports, "resolveExpression", { enumerable: true, get: function () { return resolver_1.resolveExpression; } });
+var functions_1 = require("./functions");
+Object.defineProperty(exports, "BUILT_IN_FUNCTIONS", { enumerable: true, get: function () { return functions_1.BUILT_IN_FUNCTIONS; } });
+Object.defineProperty(exports, "executeFunction", { enumerable: true, get: function () { return functions_1.executeFunction; } });
+Object.defineProperty(exports, "getFunctionsByCategory", { enumerable: true, get: function () { return functions_1.getFunctionsByCategory; } });
+Object.defineProperty(exports, "getFunctionNames", { enumerable: true, get: function () { return functions_1.getFunctionNames; } });
+Object.defineProperty(exports, "hasFunction", { enumerable: true, get: function () { return functions_1.hasFunction; } });
+Object.defineProperty(exports, "getFunction", { enumerable: true, get: function () { return functions_1.getFunction; } });
+var pipes_1 = require("./pipes");
+Object.defineProperty(exports, "PIPE_OPERATIONS", { enumerable: true, get: function () { return pipes_1.PIPE_OPERATIONS; } });
+Object.defineProperty(exports, "executePipeOperation", { enumerable: true, get: function () { return pipes_1.executePipeOperation; } });
+Object.defineProperty(exports, "getPipesByCategory", { enumerable: true, get: function () { return pipes_1.getPipesByCategory; } });
+Object.defineProperty(exports, "getPipeNames", { enumerable: true, get: function () { return pipes_1.getPipeNames; } });
+Object.defineProperty(exports, "hasPipe", { enumerable: true, get: function () { return pipes_1.hasPipe; } });
+Object.defineProperty(exports, "getPipe", { enumerable: true, get: function () { return pipes_1.getPipe; } });
+const resolver_2 = require("./resolver");
+var helpers_1 = require("./helpers");
+Object.defineProperty(exports, "buildExpressionString", { enumerable: true, get: function () { return helpers_1.buildExpressionString; } });
+Object.defineProperty(exports, "buildReferenceString", { enumerable: true, get: function () { return helpers_1.buildReferenceString; } });
+Object.defineProperty(exports, "hasExpressions", { enumerable: true, get: function () { return helpers_1.hasExpressions; } });
+Object.defineProperty(exports, "hasReferences", { enumerable: true, get: function () { return helpers_1.hasReferences; } });
+Object.defineProperty(exports, "isInsideExpression", { enumerable: true, get: function () { return helpers_1.isInsideExpression; } });
+Object.defineProperty(exports, "extractPaths", { enumerable: true, get: function () { return helpers_1.extractPaths; } });
+Object.defineProperty(exports, "parseOperations", { enumerable: true, get: function () { return helpers_1.parseOperations; } });
+Object.defineProperty(exports, "getCurrentExpressionContext", { enumerable: true, get: function () { return helpers_1.getCurrentExpressionContext; } });
+Object.defineProperty(exports, "getValueType", { enumerable: true, get: function () { return helpers_1.getValueType; } });
+Object.defineProperty(exports, "tokenizeEnriched", { enumerable: true, get: function () { return helpers_1.tokenizeEnriched; } });
+Object.defineProperty(exports, "validateExpression", { enumerable: true, get: function () { return helpers_1.validateExpression; } });
+Object.defineProperty(exports, "generatePreview", { enumerable: true, get: function () { return helpers_1.generatePreview; } });
+Object.defineProperty(exports, "convertExpressionToSaveFormat", { enumerable: true, get: function () { return helpers_1.convertExpressionToSaveFormat; } });
+Object.defineProperty(exports, "convertExpressionToDisplayFormat", { enumerable: true, get: function () { return helpers_1.convertExpressionToDisplayFormat; } });
+function evaluate(expression, workflowContext, secretsMap) {
+    const context = (0, resolver_2.buildResolverContext)(workflowContext);
+    return (0, resolver_2.resolveExpression)(expression, context, secretsMap);
+}
+exports.evaluate = evaluate;
+function interpolate(template, workflowContext, secretsMap, options) {
+    const context = (0, resolver_2.buildResolverContext)(workflowContext);
+    return (0, resolver_2.interpolateString)(template, context, secretsMap, options);
+}
+exports.interpolate = interpolate;
+function hasDynamicContent(str) {
+    return /\{\{.+?\}\}/.test(str);
+}
+exports.hasDynamicContent = hasDynamicContent;
+function extractReferences(str) {
+    const matches = str.matchAll(/\{\{(.+?)\}\}/g);
+    return Array.from(matches, (m) => m[1].trim());
+}
+exports.extractReferences = extractReferences;

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

@@ -0,0 +1,8 @@
+import type { ParsedExpression, DataSourceType } from './types';
+export declare function detectDataSource(path: string): DataSourceType | null;
+export declare function parsePathSegments(path: string): string[];
+export declare function parseExpression(expression: string): ParsedExpression;
+export declare function tokenizeTemplate(template: string): Array<{
+    type: 'text' | 'expression';
+    value: string;
+}>;