@abyss-project/main 1.0.110 → 1.0.111

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

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

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

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

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

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

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

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