@abyss-project/console 1.0.41 → 1.0.43

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

@@ -1,178 +0,0 @@
-"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/expressions/resolver.d.ts

@@ -1,12 +0,0 @@
-export interface ExpressionContext {
-    [key: string]: unknown;
-}
-export interface ResolverOptions {
-    strict?: boolean;
-    functions?: Record<string, (...args: unknown[]) => unknown>;
-    allowNested?: boolean;
-    maxDepth?: number;
-}
-export declare function resolveExpression(expression: string, context: ExpressionContext, options?: ResolverOptions): unknown;
-export declare function isDynamicExpression(expression: string): boolean;
-export declare function extractPaths(expression: string): string[];

package/dist/expressions/resolver.js

@@ -1,88 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractPaths = exports.isDynamicExpression = exports.resolveExpression = void 0;
-const parser_1 = require("./parser");
-function resolveExpression(expression, context, options = {}) {
-    const opts = {
-        strict: false,
-        functions: {},
-        allowNested: true,
-        maxDepth: 10,
-        ...options,
-    };
-    if (!expression) {
-        return expression;
-    }
-    const parsed = (0, parser_1.parseExpression)(expression);
-    if (!parsed.isDynamic) {
-        return expression;
-    }
-    if (parsed.tokens.length === 1 && parsed.tokens[0].type === 'expression') {
-        return evaluateExpression(parsed.tokens[0].value, context, opts);
-    }
-    return parsed.tokens
-        .map((token) => {
-        if (token.type === 'text') {
-            return token.value;
-        }
-        if (token.type === 'expression') {
-            const value = evaluateExpression(token.value, context, opts);
-            return value === undefined || value === null ? '' : String(value);
-        }
-        return '';
-    })
-        .join('');
-}
-exports.resolveExpression = resolveExpression;
-function evaluateExpression(expression, context, options) {
-    try {
-        const value = resolvePath(expression, context, options);
-        return value;
-    }
-    catch (error) {
-        if (options.strict) {
-            throw error;
-        }
-        return undefined;
-    }
-}
-function resolvePath(path, context, options, depth = 0) {
-    if (depth > options.maxDepth) {
-        throw new Error(`Maximum depth exceeded for path: ${path}`);
-    }
-    const bracketMatch = path.match(/^([^[]+)\[['"]([^'"]+)['"]\](.*)$/);
-    if (bracketMatch) {
-        const [, base, key, rest] = bracketMatch;
-        const baseValue = resolvePath(base, context, options, depth + 1);
-        if (baseValue === undefined || baseValue === null) {
-            return undefined;
-        }
-        const value = baseValue[key];
-        if (rest && rest.length > 0) {
-            return resolvePath(rest.replace(/^\./, ''), { _: value }, options, depth + 1);
-        }
-        return value;
-    }
-    const parts = path.split('.');
-    let current = context;
-    for (const part of parts) {
-        if (current === undefined || current === null) {
-            return undefined;
-        }
-        if (typeof current !== 'object') {
-            return undefined;
-        }
-        current = current[part];
-    }
-    return current;
-}
-function isDynamicExpression(expression) {
-    const parsed = (0, parser_1.parseExpression)(expression);
-    return parsed.isDynamic;
-}
-exports.isDynamicExpression = isDynamicExpression;
-function extractPaths(expression) {
-    const parsed = (0, parser_1.parseExpression)(expression);
-    return parsed.references.map((ref) => `${ref.source}.${ref.path}`);
-}
-exports.extractPaths = extractPaths;

package/dist/expressions/types.d.ts

@@ -1,36 +0,0 @@
-export interface ResourceMapping<TSource = string> {
-    source: TSource;
-    displayPath: string;
-    savePath: string;
-    resourceId: string;
-    resourceName: string;
-}
-export type ExpressionToken = {
-    type: 'text';
-    value: string;
-} | {
-    type: 'expression';
-    value: string;
-    raw: string;
-} | {
-    type: 'reference';
-    source: string;
-    path: string;
-};
-export interface ExpressionParserConfig {
-    openDelimiter?: string;
-    closeDelimiter?: string;
-    trimExpressions?: boolean;
-}
-export interface ParsedExpression {
-    tokens: ExpressionToken[];
-    isDynamic: boolean;
-    references: Array<{
-        source: string;
-        path: string;
-    }>;
-}
-export interface ExpressionMappingOptions {
-    strict?: boolean;
-    preserveUnknown?: boolean;
-}

package/dist/expressions/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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>;