@abyss-project/main 1.0.93 → 1.0.95

package/dist/workflow/expression/expression-tokenizer.utils.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePathSegments = exports.tokenize = exports.detectDataSource = void 0;
+const expression_types_1 = require("./expression.types");
+const EXPRESSION_PATTERN = /\{\{(.+?)\}\}/g;
+const REFERENCE_PATTERN = /@(\w+):([a-zA-Z0-9-_]+)/g;
+const DATA_SOURCE_PREFIXES = {
+    trigger: expression_types_1.DataSourceType.WORKFLOW_TRIGGER,
+    triggerData: expression_types_1.DataSourceType.WORKFLOW_TRIGGER,
+    steps: expression_types_1.DataSourceType.WORKFLOW_STEPS,
+    variables: expression_types_1.DataSourceType.WORKFLOW_VARIABLES,
+    secret: expression_types_1.DataSourceType.SECRETS,
+    ipAddress: expression_types_1.DataSourceType.IP_ADDRESSES,
+    domain: expression_types_1.DataSourceType.DOMAINS,
+    abyss: expression_types_1.DataSourceType.ABYSS_CONFIG,
+    app: expression_types_1.DataSourceType.APPLICATIONS,
+    project: expression_types_1.DataSourceType.PROJECT,
+    env: expression_types_1.DataSourceType.ENV,
+    fn: expression_types_1.DataSourceType.FUNCTIONS,
+};
+function detectDataSource(path) {
+    const firstDot = path.indexOf('.');
+    const firstBracket = path.indexOf('[');
+    let prefix;
+    if (firstDot === -1 && firstBracket === -1) {
+        prefix = path;
+    }
+    else if (firstDot === -1) {
+        prefix = path.substring(0, firstBracket);
+    }
+    else if (firstBracket === -1) {
+        prefix = path.substring(0, firstDot);
+    }
+    else {
+        prefix = path.substring(0, Math.min(firstDot, firstBracket));
+    }
+    return DATA_SOURCE_PREFIXES[prefix] || null;
+}
+exports.detectDataSource = detectDataSource;
+function tokenize(text) {
+    const tokens = [];
+    let lastIndex = 0;
+    const expressionMatches = Array.from(text.matchAll(EXPRESSION_PATTERN));
+    for (const match of expressionMatches) {
+        const matchIndex = match.index;
+        if (matchIndex > lastIndex) {
+            tokens.push({
+                type: 'text',
+                value: text.substring(lastIndex, matchIndex),
+            });
+        }
+        tokens.push({
+            type: 'expression',
+            value: match[1].trim(),
+            raw: match[0],
+        });
+        lastIndex = matchIndex + match[0].length;
+    }
+    if (lastIndex < text.length) {
+        tokens.push({
+            type: 'text',
+            value: text.substring(lastIndex),
+        });
+    }
+    const referenceMatches = Array.from(text.matchAll(REFERENCE_PATTERN));
+    for (const match of referenceMatches) {
+        tokens.push({
+            type: 'reference',
+            entityType: match[1],
+            entityId: match[2],
+        });
+    }
+    return tokens;
+}
+exports.tokenize = tokenize;
+function parsePathSegments(path) {
+    const segments = [];
+    let current = '';
+    let inBrackets = false;
+    let quoteChar = null;
+    for (let i = 0; i < path.length; i++) {
+        const char = path[i];
+        if (quoteChar) {
+            if (char === quoteChar && path[i - 1] !== '\\') {
+                quoteChar = null;
+            }
+            else if (char !== quoteChar) {
+                current += char;
+            }
+        }
+        else if (char === '"' || char === "'") {
+            quoteChar = char;
+        }
+        else if (char === '[') {
+            if (current) {
+                segments.push(current);
+                current = '';
+            }
+            inBrackets = true;
+        }
+        else if (char === ']') {
+            if (current) {
+                segments.push(current);
+                current = '';
+            }
+            inBrackets = false;
+        }
+        else if (char === '.' && !inBrackets) {
+            if (current) {
+                segments.push(current);
+                current = '';
+            }
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current) {
+        segments.push(current);
+    }
+    return segments;
+}
+exports.parsePathSegments = parsePathSegments;

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

@@ -0,0 +1,33 @@
+import type { ResourceMapping as GenericResourceMapping } from '../../expressions';
+export declare enum DataSourceType {
+    WORKFLOW_TRIGGER = "trigger",
+    WORKFLOW_STEPS = "steps",
+    WORKFLOW_VARIABLES = "variables",
+    SECRETS = "secret",
+    IP_ADDRESSES = "ipAddress",
+    DOMAINS = "domain",
+    APPLICATIONS = "app",
+    ABYSS_CONFIG = "abyss",
+    PROJECT = "project",
+    ENV = "env",
+    FUNCTIONS = "fn"
+}
+export type WorkflowResourceMapping = GenericResourceMapping<DataSourceType>;
+export interface WorkflowExpressionContext {
+    trigger?: Record<string, unknown>;
+    steps?: Record<string, unknown>;
+    variables?: Record<string, unknown>;
+    secret?: Record<string, unknown>;
+    ipAddress?: Record<string, unknown>;
+    domain?: Record<string, unknown>;
+    app?: Record<string, unknown>;
+    abyss?: Record<string, unknown>;
+    project?: Record<string, unknown>;
+    env?: Record<string, unknown>;
+}
+export interface WorkflowExpressionResult {
+    value: unknown;
+    success: boolean;
+    error?: string;
+    accessedSources: DataSourceType[];
+}

package/dist/workflow/expression/expression.types.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataSourceType = void 0;
+var DataSourceType;
+(function (DataSourceType) {
+    DataSourceType["WORKFLOW_TRIGGER"] = "trigger";
+    DataSourceType["WORKFLOW_STEPS"] = "steps";
+    DataSourceType["WORKFLOW_VARIABLES"] = "variables";
+    DataSourceType["SECRETS"] = "secret";
+    DataSourceType["IP_ADDRESSES"] = "ipAddress";
+    DataSourceType["DOMAINS"] = "domain";
+    DataSourceType["APPLICATIONS"] = "app";
+    DataSourceType["ABYSS_CONFIG"] = "abyss";
+    DataSourceType["PROJECT"] = "project";
+    DataSourceType["ENV"] = "env";
+    DataSourceType["FUNCTIONS"] = "fn";
+})(DataSourceType || (exports.DataSourceType = DataSourceType = {}));

package/dist/workflow/expression/index.d.ts

@@ -0,0 +1,10 @@
+export type { WorkflowResourceMapping, WorkflowExpressionContext, WorkflowExpressionResult, } from './expression.types';
+export { DataSourceType } from './expression.types';
+export { convertToDisplayFormat, convertToSaveFormat, extractMappings, validateExpression, createWorkflowResourceMapping, buildPathSegment, } from './expression-mapper';
+export { resolveWorkflowExpression, isWorkflowExpressionDynamic, extractDataSources, validateWorkflowExpression, } from './workflow-resolver';
+export type { ExpressionMappingOptions, ExpressionParserConfig, ResolverOptions, } from '../../expressions';
+export { parseExpression, stringifyExpression, isDynamicExpression, extractPaths, } from '../../expressions';
+export * from './expression-resolver.utils';
+export * from './expression-tokenizer.utils';
+export * from './expression-functions.utils';
+export * from './expression-mapping.utils';

package/dist/workflow/expression/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractPaths = exports.isDynamicExpression = exports.stringifyExpression = exports.parseExpression = exports.validateWorkflowExpression = exports.extractDataSources = exports.isWorkflowExpressionDynamic = exports.resolveWorkflowExpression = exports.buildPathSegment = exports.createWorkflowResourceMapping = exports.validateExpression = exports.extractMappings = exports.convertToSaveFormat = exports.convertToDisplayFormat = exports.DataSourceType = void 0;
+var expression_types_1 = require("./expression.types");
+Object.defineProperty(exports, "DataSourceType", { enumerable: true, get: function () { return expression_types_1.DataSourceType; } });
+var expression_mapper_1 = require("./expression-mapper");
+Object.defineProperty(exports, "convertToDisplayFormat", { enumerable: true, get: function () { return expression_mapper_1.convertToDisplayFormat; } });
+Object.defineProperty(exports, "convertToSaveFormat", { enumerable: true, get: function () { return expression_mapper_1.convertToSaveFormat; } });
+Object.defineProperty(exports, "extractMappings", { enumerable: true, get: function () { return expression_mapper_1.extractMappings; } });
+Object.defineProperty(exports, "validateExpression", { enumerable: true, get: function () { return expression_mapper_1.validateExpression; } });
+Object.defineProperty(exports, "createWorkflowResourceMapping", { enumerable: true, get: function () { return expression_mapper_1.createWorkflowResourceMapping; } });
+Object.defineProperty(exports, "buildPathSegment", { enumerable: true, get: function () { return expression_mapper_1.buildPathSegment; } });
+var workflow_resolver_1 = require("./workflow-resolver");
+Object.defineProperty(exports, "resolveWorkflowExpression", { enumerable: true, get: function () { return workflow_resolver_1.resolveWorkflowExpression; } });
+Object.defineProperty(exports, "isWorkflowExpressionDynamic", { enumerable: true, get: function () { return workflow_resolver_1.isWorkflowExpressionDynamic; } });
+Object.defineProperty(exports, "extractDataSources", { enumerable: true, get: function () { return workflow_resolver_1.extractDataSources; } });
+Object.defineProperty(exports, "validateWorkflowExpression", { enumerable: true, get: function () { return workflow_resolver_1.validateWorkflowExpression; } });
+var expressions_1 = require("../../expressions");
+Object.defineProperty(exports, "parseExpression", { enumerable: true, get: function () { return expressions_1.parseExpression; } });
+Object.defineProperty(exports, "stringifyExpression", { enumerable: true, get: function () { return expressions_1.stringifyExpression; } });
+Object.defineProperty(exports, "isDynamicExpression", { enumerable: true, get: function () { return expressions_1.isDynamicExpression; } });
+Object.defineProperty(exports, "extractPaths", { enumerable: true, get: function () { return expressions_1.extractPaths; } });
+__exportStar(require("./expression-resolver.utils"), exports);
+__exportStar(require("./expression-tokenizer.utils"), exports);
+__exportStar(require("./expression-functions.utils"), exports);
+__exportStar(require("./expression-mapping.utils"), exports);

package/dist/workflow/expression/workflow-resolver.d.ts

@@ -0,0 +1,9 @@
+import { type ResolverOptions } from '../../expressions';
+import type { WorkflowExpressionContext, WorkflowExpressionResult, DataSourceType } from './expression.types';
+export declare function resolveWorkflowExpression(expression: string, context: WorkflowExpressionContext, options?: ResolverOptions): WorkflowExpressionResult;
+export declare function isWorkflowExpressionDynamic(expression: string): boolean;
+export declare function extractDataSources(expression: string): DataSourceType[];
+export declare function validateWorkflowExpression(expression: string): {
+    valid: boolean;
+    error?: string;
+};

package/dist/workflow/expression/workflow-resolver.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateWorkflowExpression = exports.extractDataSources = exports.isWorkflowExpressionDynamic = exports.resolveWorkflowExpression = void 0;
+const expressions_1 = require("../../expressions");
+function resolveWorkflowExpression(expression, context, options) {
+    try {
+        const paths = (0, expressions_1.extractPaths)(expression);
+        const accessedSources = new Set();
+        for (const path of paths) {
+            const source = path.split('.')[0];
+            accessedSources.add(source);
+        }
+        const value = (0, expressions_1.resolveExpression)(expression, context, {
+            ...options,
+            functions: {
+                ...workflowFunctions,
+                ...((options === null || options === void 0 ? void 0 : options.functions) || {}),
+            },
+        });
+        return {
+            value,
+            success: true,
+            accessedSources: Array.from(accessedSources),
+        };
+    }
+    catch (error) {
+        return {
+            value: undefined,
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+            accessedSources: [],
+        };
+    }
+}
+exports.resolveWorkflowExpression = resolveWorkflowExpression;
+const workflowFunctions = {
+    upper: (str) => String(str).toUpperCase(),
+    lower: (str) => String(str).toLowerCase(),
+    trim: (str) => String(str).trim(),
+    length: (str) => String(str).length,
+    join: (arr, separator = ',') => {
+        if (!Array.isArray(arr))
+            return String(arr);
+        return arr.join(String(separator));
+    },
+    first: (arr) => {
+        if (!Array.isArray(arr))
+            return arr;
+        return arr[0];
+    },
+    last: (arr) => {
+        if (!Array.isArray(arr))
+            return arr;
+        return arr[arr.length - 1];
+    },
+    now: () => new Date().toISOString(),
+    timestamp: () => Date.now(),
+    json: (obj) => JSON.stringify(obj),
+    default: (value, defaultValue) => {
+        return value === undefined || value === null ? defaultValue : value;
+    },
+};
+function isWorkflowExpressionDynamic(expression) {
+    return (0, expressions_1.isDynamicExpression)(expression);
+}
+exports.isWorkflowExpressionDynamic = isWorkflowExpressionDynamic;
+function extractDataSources(expression) {
+    const paths = (0, expressions_1.extractPaths)(expression);
+    const sources = new Set();
+    for (const path of paths) {
+        const source = path.split('.')[0];
+        sources.add(source);
+    }
+    return Array.from(sources);
+}
+exports.extractDataSources = extractDataSources;
+function validateWorkflowExpression(expression) {
+    try {
+        const openCount = (expression.match(/\{\{/g) || []).length;
+        const closeCount = (expression.match(/\}\}/g) || []).length;
+        if (openCount !== closeCount) {
+            return {
+                valid: false,
+                error: 'Mismatched expression delimiters',
+            };
+        }
+        if (/\{\{\s*\}\}/.test(expression)) {
+            return {
+                valid: false,
+                error: 'Empty expression found',
+            };
+        }
+        return { valid: true };
+    }
+    catch (error) {
+        return {
+            valid: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+exports.validateWorkflowExpression = validateWorkflowExpression;

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

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

package/dist/workflow/expressions/functions/array.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayFunctions = void 0;
+exports.arrayFunctions = {
+    length: {
+        name: 'length',
+        description: 'Returns the length of a string or array',
+        category: 'array',
+        signature: 'length(value)',
+        args: [
+            {
+                name: 'value',
+                type: 'string|array',
+                required: true,
+                description: 'String or array',
+            },
+        ],
+        returnType: 'number',
+        examples: ['{{fn.length(trigger.items)}}'],
+        execute: (value) => {
+            if (typeof value === 'string') {
+                return value.length;
+            }
+            if (Array.isArray(value)) {
+                return value.length;
+            }
+            return 0;
+        },
+    },
+    first: {
+        name: 'first',
+        description: 'Returns the first element of an array',
+        category: 'array',
+        signature: 'first(arr)',
+        args: [
+            {
+                name: 'arr',
+                type: 'array',
+                required: true,
+                description: 'Input array',
+            },
+        ],
+        returnType: 'any',
+        examples: ['{{fn.first(trigger.items)}}'],
+        execute: (arr) => {
+            if (Array.isArray(arr) && arr.length > 0) {
+                return arr[0];
+            }
+            return undefined;
+        },
+    },
+    last: {
+        name: 'last',
+        description: 'Returns the last element of an array',
+        category: 'array',
+        signature: 'last(arr)',
+        args: [
+            {
+                name: 'arr',
+                type: 'array',
+                required: true,
+                description: 'Input array',
+            },
+        ],
+        returnType: 'any',
+        examples: ['{{fn.last(trigger.items)}}'],
+        execute: (arr) => {
+            if (Array.isArray(arr) && arr.length > 0) {
+                return arr[arr.length - 1];
+            }
+            return undefined;
+        },
+    },
+    join: {
+        name: 'join',
+        description: 'Joins array elements into a string',
+        category: 'array',
+        signature: 'join(arr, separator)',
+        args: [
+            {
+                name: 'arr',
+                type: 'array',
+                required: true,
+                description: 'Input array',
+            },
+            {
+                name: 'separator',
+                type: 'string',
+                required: false,
+                description: 'Separator (default: ",")',
+            },
+        ],
+        returnType: 'string',
+        examples: ['{{fn.join(trigger.tags, ", ")}}'],
+        execute: (arr, separator) => {
+            if (!Array.isArray(arr)) {
+                return '';
+            }
+            return arr.join(separator !== undefined ? String(separator) : ',');
+        },
+    },
+    slice: {
+        name: 'slice',
+        description: 'Extracts a section of an array',
+        category: 'array',
+        signature: 'slice(arr, start, end?)',
+        args: [
+            {
+                name: 'arr',
+                type: 'array',
+                required: true,
+                description: 'Input array',
+            },
+            {
+                name: 'start',
+                type: 'number',
+                required: true,
+                description: 'Start index',
+            },
+            {
+                name: 'end',
+                type: 'number',
+                required: false,
+                description: 'End index',
+            },
+        ],
+        returnType: 'array',
+        examples: ['{{fn.slice(trigger.items, 0, 3)}}'],
+        execute: (arr, start, end) => {
+            if (!Array.isArray(arr)) {
+                return [];
+            }
+            return arr.slice(Number(start), end !== undefined ? Number(end) : undefined);
+        },
+    },
+    includes: {
+        name: 'includes',
+        description: 'Checks if an array includes a value',
+        category: 'array',
+        signature: 'includes(arr, value)',
+        args: [
+            {
+                name: 'arr',
+                type: 'array',
+                required: true,
+                description: 'Input array',
+            },
+            {
+                name: 'value',
+                type: 'any',
+                required: true,
+                description: 'Value to search for',
+            },
+        ],
+        returnType: 'boolean',
+        examples: ['{{fn.includes(trigger.roles, "admin")}}'],
+        execute: (arr, value) => {
+            if (!Array.isArray(arr)) {
+                return false;
+            }
+            return arr.includes(value);
+        },
+    },
+    reverse: {
+        name: 'reverse',
+        description: 'Reverses the order of array elements',
+        category: 'array',
+        signature: 'reverse(arr)',
+        args: [
+            {
+                name: 'arr',
+                type: 'array',
+                required: true,
+                description: 'Input array',
+            },
+        ],
+        returnType: 'array',
+        examples: ['{{fn.reverse(trigger.items)}}'],
+        execute: (arr) => {
+            if (!Array.isArray(arr)) {
+                return [];
+            }
+            return [...arr].reverse();
+        },
+    },
+    unique: {
+        name: 'unique',
+        description: 'Returns unique elements from an array',
+        category: 'array',
+        signature: 'unique(arr)',
+        args: [
+            {
+                name: 'arr',
+                type: 'array',
+                required: true,
+                description: 'Input array',
+            },
+        ],
+        returnType: 'array',
+        examples: ['{{fn.unique(trigger.tags)}}'],
+        execute: (arr) => {
+            if (!Array.isArray(arr)) {
+                return [];
+            }
+            return Array.from(new Set(arr));
+        },
+    },
+    flatten: {
+        name: 'flatten',
+        description: 'Flattens a nested array by one level',
+        category: 'array',
+        signature: 'flatten(arr)',
+        args: [
+            {
+                name: 'arr',
+                type: 'array',
+                required: true,
+                description: 'Input array',
+            },
+        ],
+        returnType: 'array',
+        examples: ['{{fn.flatten([[1, 2], [3, 4]])}}'],
+        execute: (arr) => {
+            if (!Array.isArray(arr)) {
+                return [];
+            }
+            return arr.flat();
+        },
+    },
+    compact: {
+        name: 'compact',
+        description: 'Removes falsy values from an array',
+        category: 'array',
+        signature: 'compact(arr)',
+        args: [
+            {
+                name: 'arr',
+                type: 'array',
+                required: true,
+                description: 'Input array',
+            },
+        ],
+        returnType: 'array',
+        examples: ['{{fn.compact([0, 1, false, 2, "", 3])}}'],
+        execute: (arr) => {
+            if (!Array.isArray(arr)) {
+                return [];
+            }
+            return arr.filter(Boolean);
+        },
+    },
+};

package/dist/workflow/expressions/functions/crypto.d.ts

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