@abyss-project/main 1.0.93 → 1.0.95

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

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

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

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

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.datetimeFunctions = void 0;
+const date_fns_1 = require("date-fns");
+exports.datetimeFunctions = {
+    now: {
+        name: 'now',
+        description: 'Returns the current date and time in ISO format',
+        category: 'datetime',
+        signature: 'now()',
+        args: [],
+        returnType: 'string',
+        examples: ['{{fn.now()}}', '{{now()}}'],
+        execute: () => new Date().toISOString(),
+    },
+    timestamp: {
+        name: 'timestamp',
+        description: 'Returns the current Unix timestamp in milliseconds',
+        category: 'datetime',
+        signature: 'timestamp()',
+        args: [],
+        returnType: 'number',
+        examples: ['{{fn.timestamp()}}', '{{timestamp()}}'],
+        execute: () => Date.now(),
+    },
+    formatDate: {
+        name: 'formatDate',
+        description: 'Formats a date string with the specified format',
+        category: 'datetime',
+        signature: 'formatDate(date, format)',
+        args: [
+            {
+                name: 'date',
+                type: 'string',
+                required: true,
+                description: 'ISO date string',
+            },
+            {
+                name: 'format',
+                type: 'string',
+                required: true,
+                description: 'Format pattern (e.g., yyyy-MM-dd)',
+            },
+        ],
+        returnType: 'string',
+        examples: ['{{fn.formatDate(trigger.createdAt, "yyyy-MM-dd")}}'],
+        execute: (date, formatStr) => {
+            const d = new Date(date);
+            return (0, date_fns_1.format)(d, formatStr);
+        },
+    },
+    addDays: {
+        name: 'addDays',
+        description: 'Adds days to a date',
+        category: 'datetime',
+        signature: 'addDays(date, days)',
+        args: [
+            {
+                name: 'date',
+                type: 'string',
+                required: true,
+                description: 'ISO date string',
+            },
+            {
+                name: 'days',
+                type: 'number',
+                required: true,
+                description: 'Number of days to add',
+            },
+        ],
+        returnType: 'string',
+        examples: ['{{fn.addDays(fn.now(), 7)}}'],
+        execute: (date, days) => {
+            const d = new Date(date);
+            return (0, date_fns_1.addDays)(d, days).toISOString();
+        },
+    },
+    addHours: {
+        name: 'addHours',
+        description: 'Adds hours to a date',
+        category: 'datetime',
+        signature: 'addHours(date, hours)',
+        args: [
+            {
+                name: 'date',
+                type: 'string',
+                required: true,
+                description: 'ISO date string',
+            },
+            {
+                name: 'hours',
+                type: 'number',
+                required: true,
+                description: 'Number of hours to add',
+            },
+        ],
+        returnType: 'string',
+        examples: ['{{fn.addHours(fn.now(), 24)}}'],
+        execute: (date, hours) => {
+            const d = new Date(date);
+            return (0, date_fns_1.addHours)(d, hours).toISOString();
+        },
+    },
+    addMinutes: {
+        name: 'addMinutes',
+        description: 'Adds minutes to a date',
+        category: 'datetime',
+        signature: 'addMinutes(date, minutes)',
+        args: [
+            {
+                name: 'date',
+                type: 'string',
+                required: true,
+                description: 'ISO date string',
+            },
+            {
+                name: 'minutes',
+                type: 'number',
+                required: true,
+                description: 'Number of minutes to add',
+            },
+        ],
+        returnType: 'string',
+        examples: ['{{fn.addMinutes(fn.now(), 30)}}'],
+        execute: (date, minutes) => {
+            const d = new Date(date);
+            return (0, date_fns_1.addMinutes)(d, minutes).toISOString();
+        },
+    },
+    addSeconds: {
+        name: 'addSeconds',
+        description: 'Adds seconds to a date',
+        category: 'datetime',
+        signature: 'addSeconds(date, seconds)',
+        args: [
+            {
+                name: 'date',
+                type: 'string',
+                required: true,
+                description: 'ISO date string',
+            },
+            {
+                name: 'seconds',
+                type: 'number',
+                required: true,
+                description: 'Number of seconds to add',
+            },
+        ],
+        returnType: 'string',
+        examples: ['{{fn.addSeconds(fn.now(), 60)}}'],
+        execute: (date, seconds) => {
+            const d = new Date(date);
+            return (0, date_fns_1.addSeconds)(d, seconds).toISOString();
+        },
+    },
+    diffDays: {
+        name: 'diffDays',
+        description: 'Returns the difference in days between two dates',
+        category: 'datetime',
+        signature: 'diffDays(date1, date2)',
+        args: [
+            {
+                name: 'date1',
+                type: 'string',
+                required: true,
+                description: 'First ISO date string',
+            },
+            {
+                name: 'date2',
+                type: 'string',
+                required: true,
+                description: 'Second ISO date string',
+            },
+        ],
+        returnType: 'number',
+        examples: ['{{fn.diffDays(trigger.startDate, fn.now())}}'],
+        execute: (date1, date2) => {
+            return (0, date_fns_1.differenceInDays)(new Date(date1), new Date(date2));
+        },
+    },
+    diffHours: {
+        name: 'diffHours',
+        description: 'Returns the difference in hours between two dates',
+        category: 'datetime',
+        signature: 'diffHours(date1, date2)',
+        args: [
+            {
+                name: 'date1',
+                type: 'string',
+                required: true,
+                description: 'First ISO date string',
+            },
+            {
+                name: 'date2',
+                type: 'string',
+                required: true,
+                description: 'Second ISO date string',
+            },
+        ],
+        returnType: 'number',
+        examples: ['{{fn.diffHours(trigger.startDate, fn.now())}}'],
+        execute: (date1, date2) => {
+            return (0, date_fns_1.differenceInHours)(new Date(date1), new Date(date2));
+        },
+    },
+    diffMinutes: {
+        name: 'diffMinutes',
+        description: 'Returns the difference in minutes between two dates',
+        category: 'datetime',
+        signature: 'diffMinutes(date1, date2)',
+        args: [
+            {
+                name: 'date1',
+                type: 'string',
+                required: true,
+                description: 'First ISO date string',
+            },
+            {
+                name: 'date2',
+                type: 'string',
+                required: true,
+                description: 'Second ISO date string',
+            },
+        ],
+        returnType: 'number',
+        examples: ['{{fn.diffMinutes(trigger.startDate, fn.now())}}'],
+        execute: (date1, date2) => {
+            return (0, date_fns_1.differenceInMinutes)(new Date(date1), new Date(date2));
+        },
+    },
+    diffSeconds: {
+        name: 'diffSeconds',
+        description: 'Returns the difference in seconds between two dates',
+        category: 'datetime',
+        signature: 'diffSeconds(date1, date2)',
+        args: [
+            {
+                name: 'date1',
+                type: 'string',
+                required: true,
+                description: 'First ISO date string',
+            },
+            {
+                name: 'date2',
+                type: 'string',
+                required: true,
+                description: 'Second ISO date string',
+            },
+        ],
+        returnType: 'number',
+        examples: ['{{fn.diffSeconds(trigger.startDate, fn.now())}}'],
+        execute: (date1, date2) => {
+            return (0, date_fns_1.differenceInSeconds)(new Date(date1), new Date(date2));
+        },
+    },
+};

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

@@ -0,0 +1,7 @@
+import type { BuiltInFunction, FunctionCategory } from '../types';
+export declare const BUILT_IN_FUNCTIONS: Record<string, BuiltInFunction>;
+export declare function executeFunction(name: string, args: unknown[]): unknown;
+export declare function getFunctionsByCategory(category: FunctionCategory): Record<string, BuiltInFunction>;
+export declare function getFunctionNames(): string[];
+export declare function hasFunction(name: string): boolean;
+export declare function getFunction(name: string): BuiltInFunction | undefined;

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFunction = exports.hasFunction = exports.getFunctionNames = exports.getFunctionsByCategory = exports.executeFunction = exports.BUILT_IN_FUNCTIONS = void 0;
+const datetime_1 = require("./datetime");
+const string_1 = require("./string");
+const math_1 = require("./math");
+const crypto_1 = require("./crypto");
+const array_1 = require("./array");
+const utility_1 = require("./utility");
+exports.BUILT_IN_FUNCTIONS = {
+    ...datetime_1.datetimeFunctions,
+    ...string_1.stringFunctions,
+    ...math_1.mathFunctions,
+    ...crypto_1.cryptoFunctions,
+    ...array_1.arrayFunctions,
+    ...utility_1.utilityFunctions,
+};
+function executeFunction(name, args) {
+    const func = exports.BUILT_IN_FUNCTIONS[name];
+    if (!func) {
+        throw new Error(`Unknown function: ${name}`);
+    }
+    return func.execute(...args);
+}
+exports.executeFunction = executeFunction;
+function getFunctionsByCategory(category) {
+    return Object.entries(exports.BUILT_IN_FUNCTIONS)
+        .filter(([, func]) => func.category === category)
+        .reduce((acc, [name, func]) => {
+        acc[name] = func;
+        return acc;
+    }, {});
+}
+exports.getFunctionsByCategory = getFunctionsByCategory;
+function getFunctionNames() {
+    return Object.keys(exports.BUILT_IN_FUNCTIONS);
+}
+exports.getFunctionNames = getFunctionNames;
+function hasFunction(name) {
+    return name in exports.BUILT_IN_FUNCTIONS;
+}
+exports.hasFunction = hasFunction;
+function getFunction(name) {
+    return exports.BUILT_IN_FUNCTIONS[name];
+}
+exports.getFunction = getFunction;

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

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

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

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mathFunctions = void 0;
+exports.mathFunctions = {
+    abs: {
+        name: 'abs',
+        description: 'Returns the absolute value of a number',
+        category: 'math',
+        signature: 'abs(num)',
+        args: [
+            {
+                name: 'num',
+                type: 'number',
+                required: true,
+                description: 'Input number',
+            },
+        ],
+        returnType: 'number',
+        examples: ['{{fn.abs(-5)}}'],
+        execute: (num) => Math.abs(Number(num)),
+    },
+    ceil: {
+        name: 'ceil',
+        description: 'Rounds a number up to the nearest integer',
+        category: 'math',
+        signature: 'ceil(num)',
+        args: [
+            {
+                name: 'num',
+                type: 'number',
+                required: true,
+                description: 'Input number',
+            },
+        ],
+        returnType: 'number',
+        examples: ['{{fn.ceil(4.3)}}'],
+        execute: (num) => Math.ceil(Number(num)),
+    },
+    floor: {
+        name: 'floor',
+        description: 'Rounds a number down to the nearest integer',
+        category: 'math',
+        signature: 'floor(num)',
+        args: [
+            {
+                name: 'num',
+                type: 'number',
+                required: true,
+                description: 'Input number',
+            },
+        ],
+        returnType: 'number',
+        examples: ['{{fn.floor(4.7)}}'],
+        execute: (num) => Math.floor(Number(num)),
+    },
+    round: {
+        name: 'round',
+        description: 'Rounds a number to the nearest integer',
+        category: 'math',
+        signature: 'round(num)',
+        args: [
+            {
+                name: 'num',
+                type: 'number',
+                required: true,
+                description: 'Input number',
+            },
+        ],
+        returnType: 'number',
+        examples: ['{{fn.round(4.5)}}'],
+        execute: (num) => Math.round(Number(num)),
+    },
+    min: {
+        name: 'min',
+        description: 'Returns the smallest of the given numbers',
+        category: 'math',
+        signature: 'min(...nums)',
+        args: [
+            {
+                name: 'numbers',
+                type: 'number',
+                required: true,
+                description: 'Numbers to compare',
+            },
+        ],
+        returnType: 'number',
+        examples: ['{{fn.min(5, 10, 2, 8)}}'],
+        execute: (...args) => Math.min(...args.map(Number)),
+    },
+    max: {
+        name: 'max',
+        description: 'Returns the largest of the given numbers',
+        category: 'math',
+        signature: 'max(...nums)',
+        args: [
+            {
+                name: 'numbers',
+                type: 'number',
+                required: true,
+                description: 'Numbers to compare',
+            },
+        ],
+        returnType: 'number',
+        examples: ['{{fn.max(5, 10, 2, 8)}}'],
+        execute: (...args) => Math.max(...args.map(Number)),
+    },
+    pow: {
+        name: 'pow',
+        description: 'Returns the base to the exponent power',
+        category: 'math',
+        signature: 'pow(base, exponent)',
+        args: [
+            {
+                name: 'base',
+                type: 'number',
+                required: true,
+                description: 'Base number',
+            },
+            {
+                name: 'exponent',
+                type: 'number',
+                required: true,
+                description: 'Exponent',
+            },
+        ],
+        returnType: 'number',
+        examples: ['{{fn.pow(2, 3)}}'],
+        execute: (base, exponent) => Math.pow(Number(base), Number(exponent)),
+    },
+    sqrt: {
+        name: 'sqrt',
+        description: 'Returns the square root of a number',
+        category: 'math',
+        signature: 'sqrt(num)',
+        args: [
+            {
+                name: 'num',
+                type: 'number',
+                required: true,
+                description: 'Input number',
+            },
+        ],
+        returnType: 'number',
+        examples: ['{{fn.sqrt(16)}}'],
+        execute: (num) => Math.sqrt(Number(num)),
+    },
+    random: {
+        name: 'random',
+        description: 'Generates a random integer between min and max (inclusive)',
+        category: 'math',
+        signature: 'random(min, max)',
+        args: [
+            {
+                name: 'min',
+                type: 'number',
+                required: true,
+                description: 'Minimum value',
+            },
+            {
+                name: 'max',
+                type: 'number',
+                required: true,
+                description: 'Maximum value',
+            },
+        ],
+        returnType: 'number',
+        examples: ['{{fn.random(1, 100)}}'],
+        execute: (min, max) => {
+            const minNum = Number(min);
+            const maxNum = Number(max);
+            return Math.floor(Math.random() * (maxNum - minNum + 1)) + minNum;
+        },
+    },
+};

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

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