@abyss-project/main 1.0.110 → 1.0.117

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,101 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cryptoFunctions = void 0;
-const crypto_1 = require("crypto");
-exports.cryptoFunctions = {
-    md5: {
-        name: 'md5',
-        description: 'Generates an MD5 hash of the input string',
-        category: 'crypto',
-        signature: 'md5(str)',
-        args: [
-            {
-                name: 'str',
-                type: 'string',
-                required: true,
-                description: 'Input string',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.md5(trigger.password)}}'],
-        execute: (str) => {
-            return (0, crypto_1.createHash)('md5').update(String(str)).digest('hex');
-        },
-    },
-    sha1: {
-        name: 'sha1',
-        description: 'Generates a SHA-1 hash of the input string',
-        category: 'crypto',
-        signature: 'sha1(str)',
-        args: [
-            {
-                name: 'str',
-                type: 'string',
-                required: true,
-                description: 'Input string',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.sha1(trigger.data)}}'],
-        execute: (str) => {
-            return (0, crypto_1.createHash)('sha1').update(String(str)).digest('hex');
-        },
-    },
-    sha256: {
-        name: 'sha256',
-        description: 'Generates a SHA-256 hash of the input string',
-        category: 'crypto',
-        signature: 'sha256(str)',
-        args: [
-            {
-                name: 'str',
-                type: 'string',
-                required: true,
-                description: 'Input string',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.sha256(trigger.data)}}'],
-        execute: (str) => {
-            return (0, crypto_1.createHash)('sha256').update(String(str)).digest('hex');
-        },
-    },
-    sha512: {
-        name: 'sha512',
-        description: 'Generates a SHA-512 hash of the input string',
-        category: 'crypto',
-        signature: 'sha512(str)',
-        args: [
-            {
-                name: 'str',
-                type: 'string',
-                required: true,
-                description: 'Input string',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.sha512(trigger.data)}}'],
-        execute: (str) => {
-            return (0, crypto_1.createHash)('sha512').update(String(str)).digest('hex');
-        },
-    },
-    randomBytes: {
-        name: 'randomBytes',
-        description: 'Generates random bytes as a hex string',
-        category: 'crypto',
-        signature: 'randomBytes(size)',
-        args: [
-            {
-                name: 'size',
-                type: 'number',
-                required: true,
-                description: 'Number of bytes',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.randomBytes(16)}}'],
-        execute: (size) => {
-            return (0, crypto_1.randomBytes)(Number(size)).toString('hex');
-        },
-    },
-};

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

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