@abyss-project/main 1.0.109 → 1.0.111

package/dist/workflow/expressions/pipes/index.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPipe = exports.hasPipe = exports.getPipeNames = exports.getPipesByCategory = exports.executePipeOperation = exports.PIPE_OPERATIONS = void 0;
-const string_pipes_1 = require("./string-pipes");
-const array_pipes_1 = require("./array-pipes");
-const object_pipes_1 = require("./object-pipes");
-exports.PIPE_OPERATIONS = {
-    ...string_pipes_1.stringPipes,
-    ...array_pipes_1.arrayPipes,
-    ...object_pipes_1.objectPipes,
-};
-function executePipeOperation(name, value, args) {
-    const pipe = exports.PIPE_OPERATIONS[name];
-    if (!pipe) {
-        throw new Error(`Unknown pipe operation: ${name}`);
-    }
-    return pipe.execute(value, ...args);
-}
-exports.executePipeOperation = executePipeOperation;
-function getPipesByCategory(category) {
-    return Object.entries(exports.PIPE_OPERATIONS)
-        .filter(([, pipe]) => pipe.category === category)
-        .reduce((acc, [name, pipe]) => {
-        acc[name] = pipe;
-        return acc;
-    }, {});
-}
-exports.getPipesByCategory = getPipesByCategory;
-function getPipeNames() {
-    return Object.keys(exports.PIPE_OPERATIONS);
-}
-exports.getPipeNames = getPipeNames;
-function hasPipe(name) {
-    return name in exports.PIPE_OPERATIONS;
-}
-exports.hasPipe = hasPipe;
-function getPipe(name) {
-    return exports.PIPE_OPERATIONS[name];
-}
-exports.getPipe = getPipe;

package/dist/workflow/expressions/pipes/object-pipes.d.ts

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

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

@@ -1,243 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.objectPipes = void 0;
-exports.objectPipes = {
-    keys: {
-        name: 'keys',
-        description: 'Returns object keys',
-        category: 'object',
-        signature: 'keys',
-        examples: ['{{trigger.data | keys}}'],
-        execute: (value) => {
-            if (value && typeof value === 'object') {
-                return Object.keys(value);
-            }
-            return [];
-        },
-    },
-    values: {
-        name: 'values',
-        description: 'Returns object values',
-        category: 'object',
-        signature: 'values',
-        examples: ['{{trigger.data | values}}'],
-        execute: (value) => {
-            if (value && typeof value === 'object') {
-                return Object.values(value);
-            }
-            return [];
-        },
-    },
-    entries: {
-        name: 'entries',
-        description: 'Returns key-value pairs',
-        category: 'object',
-        signature: 'entries',
-        examples: ['{{trigger.data | entries}}'],
-        execute: (value) => {
-            if (value && typeof value === 'object') {
-                return Object.entries(value);
-            }
-            return [];
-        },
-    },
-    get: {
-        name: 'get',
-        description: 'Gets a property value',
-        category: 'object',
-        signature: 'get(path)',
-        examples: ['{{trigger.data | get("user.name")}}'],
-        execute: (value, path) => {
-            if (!value || typeof value !== 'object') {
-                return undefined;
-            }
-            const pathStr = String(path);
-            const keys = pathStr.split('.');
-            let current = value;
-            for (const key of keys) {
-                if (current === null || current === undefined) {
-                    return undefined;
-                }
-                if (typeof current !== 'object') {
-                    return undefined;
-                }
-                current = current[key];
-            }
-            return current;
-        },
-    },
-    has: {
-        name: 'has',
-        description: 'Checks if property exists',
-        category: 'object',
-        signature: 'has(key)',
-        examples: ['{{trigger.data | has("email")}}'],
-        execute: (value, key) => {
-            if (!value || typeof value !== 'object') {
-                return false;
-            }
-            return String(key) in value;
-        },
-    },
-    omit: {
-        name: 'omit',
-        description: 'Omits specified keys',
-        category: 'object',
-        signature: 'omit(...keys)',
-        examples: ['{{trigger.data | omit("password", "token")}}'],
-        execute: (value, ...keys) => {
-            if (!value || typeof value !== 'object') {
-                return value;
-            }
-            const obj = value;
-            const keysToOmit = new Set(keys.map(String));
-            return Object.entries(obj).reduce((acc, [key, val]) => {
-                if (!keysToOmit.has(key)) {
-                    acc[key] = val;
-                }
-                return acc;
-            }, {});
-        },
-    },
-    pick: {
-        name: 'pick',
-        description: 'Picks specified keys',
-        category: 'object',
-        signature: 'pick(...keys)',
-        examples: ['{{trigger.data | pick("id", "name", "email")}}'],
-        execute: (value, ...keys) => {
-            if (!value || typeof value !== 'object') {
-                return {};
-            }
-            const obj = value;
-            const keysToPick = keys.map(String);
-            return keysToPick.reduce((acc, key) => {
-                if (key in obj) {
-                    acc[key] = obj[key];
-                }
-                return acc;
-            }, {});
-        },
-    },
-    merge: {
-        name: 'merge',
-        description: 'Merges with another object',
-        category: 'object',
-        signature: 'merge(object)',
-        examples: ['{{trigger.data | merge(trigger.defaults)}}'],
-        execute: (value, other) => {
-            if (!value || typeof value !== 'object') {
-                return other || {};
-            }
-            if (!other || typeof other !== 'object') {
-                return value;
-            }
-            return { ...value, ...other };
-        },
-    },
-    base64: {
-        name: 'base64',
-        description: 'Encodes to base64',
-        category: 'encoding',
-        signature: 'base64',
-        examples: ['{{trigger.text | base64}}'],
-        execute: (value) => {
-            return Buffer.from(String(value)).toString('base64');
-        },
-    },
-    base64decode: {
-        name: 'base64decode',
-        description: 'Decodes from base64',
-        category: 'encoding',
-        signature: 'base64decode',
-        examples: ['{{trigger.encoded | base64decode}}'],
-        execute: (value) => {
-            try {
-                return Buffer.from(String(value), 'base64').toString('utf-8');
-            }
-            catch {
-                return value;
-            }
-        },
-    },
-    urlEncode: {
-        name: 'urlEncode',
-        description: 'URL encodes a string',
-        category: 'encoding',
-        signature: 'urlEncode',
-        examples: ['{{trigger.query | urlEncode}}'],
-        execute: (value) => {
-            return encodeURIComponent(String(value));
-        },
-    },
-    urlDecode: {
-        name: 'urlDecode',
-        description: 'URL decodes a string',
-        category: 'encoding',
-        signature: 'urlDecode',
-        examples: ['{{trigger.encoded | urlDecode}}'],
-        execute: (value) => {
-            try {
-                return decodeURIComponent(String(value));
-            }
-            catch {
-                return value;
-            }
-        },
-    },
-    json: {
-        name: 'json',
-        description: 'Converts to JSON string',
-        category: 'formatting',
-        signature: 'json',
-        examples: ['{{trigger.data | json}}'],
-        execute: (value) => {
-            return JSON.stringify(value);
-        },
-    },
-    jsonPretty: {
-        name: 'jsonPretty',
-        description: 'Converts to pretty JSON',
-        category: 'formatting',
-        signature: 'jsonPretty',
-        examples: ['{{trigger.data | jsonPretty}}'],
-        execute: (value) => {
-            return JSON.stringify(value, null, 2);
-        },
-    },
-    parseJson: {
-        name: 'parseJson',
-        description: 'Parses JSON string',
-        category: 'formatting',
-        signature: 'parseJson',
-        examples: ['{{trigger.jsonString | parseJson}}'],
-        execute: (value) => {
-            try {
-                return JSON.parse(String(value));
-            }
-            catch {
-                return value;
-            }
-        },
-    },
-    toFixed: {
-        name: 'toFixed',
-        description: 'Formats number with fixed decimals',
-        category: 'number',
-        signature: 'toFixed(decimals)',
-        examples: ['{{trigger.price | toFixed(2)}}'],
-        execute: (value, decimals) => {
-            return Number(value).toFixed(Number(decimals));
-        },
-    },
-    toPrecision: {
-        name: 'toPrecision',
-        description: 'Formats number with precision',
-        category: 'number',
-        signature: 'toPrecision(precision)',
-        examples: ['{{trigger.value | toPrecision(4)}}'],
-        execute: (value, precision) => {
-            return Number(value).toPrecision(Number(precision));
-        },
-    },
-};

package/dist/workflow/expressions/pipes/string-pipes.d.ts

@@ -1,9 +0,0 @@
-export interface PipeDefinition {
-    name: string;
-    description: string;
-    category: 'string' | 'array' | 'object' | 'number' | 'date' | 'encoding' | 'formatting';
-    signature: string;
-    examples: string[];
-    execute: (value: unknown, ...args: unknown[]) => unknown;
-}
-export declare const stringPipes: Record<string, PipeDefinition>;

package/dist/workflow/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/workflow/expressions/resolver.d.ts

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