@abyss-project/console 1.0.29 → 1.0.31

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

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

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

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

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

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

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

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