@synergenius/flow-weaver 0.2.0

package/dist/runtime/builtin-functions.js

@@ -0,0 +1,549 @@
+/**
+ * Built-in Functions for Flow Weaver
+ *
+ * Registers common utility functions in the global function registry.
+ * These functions can be referenced by their string IDs in external HTTP calls.
+ */
+import { functionRegistry } from './function-registry.js';
+// ============================================================================
+// String Transforms
+// ============================================================================
+functionRegistry.register({
+    id: 'string:uppercase',
+    name: 'Uppercase',
+    description: 'Convert string to uppercase',
+    category: 'transform',
+    fn: (input) => input.toUpperCase(),
+    inputType: 'string',
+    outputType: 'string',
+    examples: [{ input: 'hello', output: 'HELLO' }],
+});
+functionRegistry.register({
+    id: 'string:lowercase',
+    name: 'Lowercase',
+    description: 'Convert string to lowercase',
+    category: 'transform',
+    fn: (input) => input.toLowerCase(),
+    inputType: 'string',
+    outputType: 'string',
+    examples: [{ input: 'HELLO', output: 'hello' }],
+});
+functionRegistry.register({
+    id: 'string:trim',
+    name: 'Trim',
+    description: 'Remove whitespace from both ends of a string',
+    category: 'transform',
+    fn: (input) => input.trim(),
+    inputType: 'string',
+    outputType: 'string',
+    examples: [{ input: '  hello  ', output: 'hello' }],
+});
+functionRegistry.register({
+    id: 'string:truncate',
+    name: 'Truncate',
+    description: 'Truncate string to specified length with ellipsis',
+    category: 'transform',
+    fn: (input) => {
+        const { text, maxLength, suffix = '...' } = input;
+        if (text.length <= maxLength)
+            return text;
+        return text.slice(0, maxLength - suffix.length) + suffix;
+    },
+    inputType: 'object',
+    outputType: 'string',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            text: { type: 'string' },
+            maxLength: { type: 'number' },
+            suffix: { type: 'string', default: '...' },
+        },
+        required: ['text', 'maxLength'],
+    },
+    examples: [
+        { input: { text: 'Hello World', maxLength: 8 }, output: 'Hello...' },
+    ],
+});
+functionRegistry.register({
+    id: 'string:split',
+    name: 'Split',
+    description: 'Split string by delimiter',
+    category: 'transform',
+    fn: (input) => input.text.split(input.delimiter),
+    inputType: 'object',
+    outputType: 'array',
+    examples: [
+        { input: { text: 'a,b,c', delimiter: ',' }, output: ['a', 'b', 'c'] },
+    ],
+});
+functionRegistry.register({
+    id: 'string:join',
+    name: 'Join',
+    description: 'Join array elements with delimiter',
+    category: 'transform',
+    fn: (input) => input.items.join(input.delimiter),
+    inputType: 'object',
+    outputType: 'string',
+    examples: [
+        { input: { items: ['a', 'b', 'c'], delimiter: ',' }, output: 'a,b,c' },
+    ],
+});
+functionRegistry.register({
+    id: 'string:prefix',
+    name: 'Prefix',
+    description: 'Add prefix to string',
+    category: 'transform',
+    fn: (input) => input.prefix + input.text,
+    inputType: 'object',
+    outputType: 'string',
+    examples: [
+        { input: { text: 'world', prefix: 'hello ' }, output: 'hello world' },
+    ],
+});
+functionRegistry.register({
+    id: 'string:suffix',
+    name: 'Suffix',
+    description: 'Add suffix to string',
+    category: 'transform',
+    fn: (input) => input.text + input.suffix,
+    inputType: 'object',
+    outputType: 'string',
+    examples: [
+        { input: { text: 'hello', suffix: ' world' }, output: 'hello world' },
+    ],
+});
+// ============================================================================
+// Number Transforms
+// ============================================================================
+functionRegistry.register({
+    id: 'number:double',
+    name: 'Double',
+    description: 'Double a number',
+    category: 'transform',
+    fn: (input) => input * 2,
+    inputType: 'number',
+    outputType: 'number',
+    examples: [{ input: 5, output: 10 }],
+});
+functionRegistry.register({
+    id: 'number:round',
+    name: 'Round',
+    description: 'Round a number to specified decimal places',
+    category: 'transform',
+    fn: (input) => {
+        const { value, decimals = 0 } = input;
+        const factor = Math.pow(10, decimals);
+        return Math.round(value * factor) / factor;
+    },
+    inputType: 'object',
+    outputType: 'number',
+    examples: [
+        { input: { value: 3.14159, decimals: 2 }, output: 3.14 },
+    ],
+});
+functionRegistry.register({
+    id: 'number:clamp',
+    name: 'Clamp',
+    description: 'Clamp a number between min and max values',
+    category: 'transform',
+    fn: (input) => {
+        const { value, min, max } = input;
+        return Math.min(Math.max(value, min), max);
+    },
+    inputType: 'object',
+    outputType: 'number',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            value: { type: 'number' },
+            min: { type: 'number' },
+            max: { type: 'number' },
+        },
+        required: ['value', 'min', 'max'],
+    },
+    examples: [
+        { input: { value: 150, min: 0, max: 100 }, output: 100 },
+        { input: { value: -10, min: 0, max: 100 }, output: 0 },
+        { input: { value: 50, min: 0, max: 100 }, output: 50 },
+    ],
+});
+functionRegistry.register({
+    id: 'number:abs',
+    name: 'Absolute',
+    description: 'Get absolute value of a number',
+    category: 'transform',
+    fn: (input) => Math.abs(input),
+    inputType: 'number',
+    outputType: 'number',
+    examples: [{ input: -5, output: 5 }],
+});
+functionRegistry.register({
+    id: 'number:negate',
+    name: 'Negate',
+    description: 'Negate a number',
+    category: 'transform',
+    fn: (input) => -input,
+    inputType: 'number',
+    outputType: 'number',
+    examples: [{ input: 5, output: -5 }],
+});
+// ============================================================================
+// Array Transforms
+// ============================================================================
+functionRegistry.register({
+    id: 'array:first',
+    name: 'First',
+    description: 'Get first element of array',
+    category: 'transform',
+    fn: (input) => input[0],
+    inputType: 'array',
+    outputType: 'any',
+    examples: [{ input: [1, 2, 3], output: 1 }],
+});
+functionRegistry.register({
+    id: 'array:last',
+    name: 'Last',
+    description: 'Get last element of array',
+    category: 'transform',
+    fn: (input) => input[input.length - 1],
+    inputType: 'array',
+    outputType: 'any',
+    examples: [{ input: [1, 2, 3], output: 3 }],
+});
+functionRegistry.register({
+    id: 'array:reverse',
+    name: 'Reverse',
+    description: 'Reverse array order',
+    category: 'transform',
+    fn: (input) => [...input].reverse(),
+    inputType: 'array',
+    outputType: 'array',
+    examples: [{ input: [1, 2, 3], output: [3, 2, 1] }],
+});
+functionRegistry.register({
+    id: 'array:unique',
+    name: 'Unique',
+    description: 'Remove duplicate elements from array',
+    category: 'transform',
+    fn: (input) => [...new Set(input)],
+    inputType: 'array',
+    outputType: 'array',
+    examples: [{ input: [1, 2, 2, 3, 3, 3], output: [1, 2, 3] }],
+});
+functionRegistry.register({
+    id: 'array:flatten',
+    name: 'Flatten',
+    description: 'Flatten nested arrays by one level',
+    category: 'transform',
+    fn: (input) => input.flat(),
+    inputType: 'array',
+    outputType: 'array',
+    examples: [{ input: [[1, 2], [3, 4]], output: [1, 2, 3, 4] }],
+});
+functionRegistry.register({
+    id: 'array:sort',
+    name: 'Sort',
+    description: 'Sort array elements',
+    category: 'transform',
+    fn: (input) => [...input].sort(),
+    inputType: 'array',
+    outputType: 'array',
+    examples: [{ input: [3, 1, 2], output: [1, 2, 3] }],
+});
+functionRegistry.register({
+    id: 'array:length',
+    name: 'Length',
+    description: 'Get array length',
+    category: 'transform',
+    fn: (input) => input.length,
+    inputType: 'array',
+    outputType: 'number',
+    examples: [{ input: [1, 2, 3], output: 3 }],
+});
+// ============================================================================
+// Object Transforms
+// ============================================================================
+functionRegistry.register({
+    id: 'object:pick',
+    name: 'Pick',
+    description: 'Pick specified keys from object',
+    category: 'transform',
+    fn: (input) => {
+        const { obj, keys } = input;
+        const result = {};
+        for (const key of keys) {
+            if (key in obj) {
+                result[key] = obj[key];
+            }
+        }
+        return result;
+    },
+    inputType: 'object',
+    outputType: 'object',
+    examples: [
+        { input: { obj: { a: 1, b: 2, c: 3 }, keys: ['a', 'c'] }, output: { a: 1, c: 3 } },
+    ],
+});
+functionRegistry.register({
+    id: 'object:omit',
+    name: 'Omit',
+    description: 'Omit specified keys from object',
+    category: 'transform',
+    fn: (input) => {
+        const { obj, keys } = input;
+        const keySet = new Set(keys);
+        const result = {};
+        for (const key in obj) {
+            if (!keySet.has(key)) {
+                result[key] = obj[key];
+            }
+        }
+        return result;
+    },
+    inputType: 'object',
+    outputType: 'object',
+    examples: [
+        { input: { obj: { a: 1, b: 2, c: 3 }, keys: ['b'] }, output: { a: 1, c: 3 } },
+    ],
+});
+functionRegistry.register({
+    id: 'object:get',
+    name: 'Get',
+    description: 'Get value at path from object',
+    category: 'transform',
+    fn: (input) => {
+        const { obj, path } = input;
+        const keys = path.split('.');
+        let current = obj;
+        for (const key of keys) {
+            if (current === null || current === undefined)
+                return undefined;
+            current = current[key];
+        }
+        return current;
+    },
+    inputType: 'object',
+    outputType: 'any',
+    examples: [
+        { input: { obj: { a: { b: { c: 42 } } }, path: 'a.b.c' }, output: 42 },
+    ],
+});
+functionRegistry.register({
+    id: 'object:keys',
+    name: 'Keys',
+    description: 'Get object keys',
+    category: 'transform',
+    fn: (input) => Object.keys(input),
+    inputType: 'object',
+    outputType: 'array',
+    examples: [
+        { input: { a: 1, b: 2 }, output: ['a', 'b'] },
+    ],
+});
+functionRegistry.register({
+    id: 'object:values',
+    name: 'Values',
+    description: 'Get object values',
+    category: 'transform',
+    fn: (input) => Object.values(input),
+    inputType: 'object',
+    outputType: 'array',
+    examples: [
+        { input: { a: 1, b: 2 }, output: [1, 2] },
+    ],
+});
+// ============================================================================
+// Filters
+// ============================================================================
+functionRegistry.register({
+    id: 'filter:truthy',
+    name: 'Truthy',
+    description: 'Filter to only truthy values',
+    category: 'filter',
+    fn: (input) => input.filter(Boolean),
+    inputType: 'array',
+    outputType: 'array',
+    examples: [{ input: [0, 1, '', 'hello', null, true], output: [1, 'hello', true] }],
+});
+functionRegistry.register({
+    id: 'filter:nonEmpty',
+    name: 'Non-Empty',
+    description: 'Filter out empty strings and arrays',
+    category: 'filter',
+    fn: (input) => input.filter((x) => {
+        if (typeof x === 'string')
+            return x.length > 0;
+        if (Array.isArray(x))
+            return x.length > 0;
+        return true;
+    }),
+    inputType: 'array',
+    outputType: 'array',
+    examples: [{ input: ['hello', '', 'world', []], output: ['hello', 'world'] }],
+});
+functionRegistry.register({
+    id: 'filter:greaterThan',
+    name: 'Greater Than',
+    description: 'Filter numbers greater than threshold',
+    category: 'filter',
+    fn: (input) => input.items.filter((n) => n > input.threshold),
+    inputType: 'object',
+    outputType: 'array',
+    examples: [
+        { input: { items: [1, 5, 10, 15], threshold: 7 }, output: [10, 15] },
+    ],
+});
+functionRegistry.register({
+    id: 'filter:lessThan',
+    name: 'Less Than',
+    description: 'Filter numbers less than threshold',
+    category: 'filter',
+    fn: (input) => input.items.filter((n) => n < input.threshold),
+    inputType: 'object',
+    outputType: 'array',
+    examples: [
+        { input: { items: [1, 5, 10, 15], threshold: 7 }, output: [1, 5] },
+    ],
+});
+// ============================================================================
+// Validators
+// ============================================================================
+functionRegistry.register({
+    id: 'validate:email',
+    name: 'Email',
+    description: 'Validate email address format',
+    category: 'validate',
+    fn: (input) => {
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        return emailRegex.test(input);
+    },
+    inputType: 'string',
+    outputType: 'boolean',
+    examples: [
+        { input: 'test@example.com', output: true },
+        { input: 'invalid', output: false },
+    ],
+});
+functionRegistry.register({
+    id: 'validate:url',
+    name: 'URL',
+    description: 'Validate URL format',
+    category: 'validate',
+    fn: (input) => {
+        try {
+            new URL(input);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    inputType: 'string',
+    outputType: 'boolean',
+    examples: [
+        { input: 'https://example.com', output: true },
+        { input: 'not-a-url', output: false },
+    ],
+});
+functionRegistry.register({
+    id: 'validate:nonEmpty',
+    name: 'Non-Empty',
+    description: 'Validate string is not empty',
+    category: 'validate',
+    fn: (input) => input.trim().length > 0,
+    inputType: 'string',
+    outputType: 'boolean',
+    examples: [
+        { input: 'hello', output: true },
+        { input: '', output: false },
+        { input: '   ', output: false },
+    ],
+});
+functionRegistry.register({
+    id: 'validate:numeric',
+    name: 'Numeric',
+    description: 'Validate string is numeric',
+    category: 'validate',
+    fn: (input) => !isNaN(Number(input)) && input.trim() !== '',
+    inputType: 'string',
+    outputType: 'boolean',
+    examples: [
+        { input: '123', output: true },
+        { input: '12.34', output: true },
+        { input: 'abc', output: false },
+    ],
+});
+// ============================================================================
+// Formatters
+// ============================================================================
+functionRegistry.register({
+    id: 'format:json',
+    name: 'JSON',
+    description: 'Format value as JSON string',
+    category: 'format',
+    fn: (input) => JSON.stringify(input, null, 2),
+    inputType: 'any',
+    outputType: 'string',
+    examples: [
+        { input: { a: 1 }, output: '{\n  "a": 1\n}' },
+    ],
+});
+functionRegistry.register({
+    id: 'format:jsonCompact',
+    name: 'JSON Compact',
+    description: 'Format value as compact JSON string',
+    category: 'format',
+    fn: (input) => JSON.stringify(input),
+    inputType: 'any',
+    outputType: 'string',
+    examples: [
+        { input: { a: 1 }, output: '{"a":1}' },
+    ],
+});
+functionRegistry.register({
+    id: 'format:date',
+    name: 'Date',
+    description: 'Format date to ISO string or custom format',
+    category: 'format',
+    fn: (input) => {
+        const date = input instanceof Date ? input : new Date(input);
+        return date.toISOString();
+    },
+    inputType: 'any',
+    outputType: 'string',
+    examples: [
+        { input: '2024-01-15', output: '2024-01-15T00:00:00.000Z' },
+    ],
+});
+functionRegistry.register({
+    id: 'format:currency',
+    name: 'Currency',
+    description: 'Format number as currency',
+    category: 'format',
+    fn: (input) => {
+        const { value, currency = 'USD', locale = 'en-US' } = input;
+        return new Intl.NumberFormat(locale, { style: 'currency', currency }).format(value);
+    },
+    inputType: 'object',
+    outputType: 'string',
+    examples: [
+        { input: { value: 1234.56 }, output: '$1,234.56' },
+    ],
+});
+functionRegistry.register({
+    id: 'format:percentage',
+    name: 'Percentage',
+    description: 'Format number as percentage',
+    category: 'format',
+    fn: (input) => {
+        const { value, decimals = 0 } = input;
+        return `${(value * 100).toFixed(decimals)}%`;
+    },
+    inputType: 'object',
+    outputType: 'string',
+    examples: [
+        { input: { value: 0.75 }, output: '75%' },
+        { input: { value: 0.756, decimals: 1 }, output: '75.6%' },
+    ],
+});
+//# sourceMappingURL=builtin-functions.js.map

package/dist/runtime/events.d.ts

@@ -0,0 +1,50 @@
+export type TStatusType = "RUNNING" | "SCHEDULED" | "SUCCEEDED" | "FAILED" | "CANCELLED" | "PENDING";
+export type TVariableIdentification = {
+    nodeTypeName: string;
+    id: string;
+    scope?: string;
+    side?: "start" | "exit";
+    portName: string;
+    executionIndex: number;
+    key?: string;
+};
+export type TStatusChangedEvent = {
+    type: "STATUS_CHANGED";
+    nodeTypeName: string;
+    id: string;
+    scope?: string;
+    side?: "start" | "exit";
+    executionIndex: number;
+    status: TStatusType;
+    innerFlowInvocation?: boolean;
+};
+export type TVariableSetEvent = {
+    type: "VARIABLE_SET";
+    identifier: TVariableIdentification;
+    value?: unknown;
+    innerFlowInvocation?: boolean;
+};
+export type TErrorLogEvent = {
+    type: "LOG_ERROR";
+    nodeTypeName: string;
+    id: string;
+    scope?: string;
+    side?: "start" | "exit";
+    executionIndex: number;
+    error: string;
+    innerFlowInvocation?: boolean;
+};
+export type TWorkflowCompletedEvent = {
+    type: "WORKFLOW_COMPLETED";
+    executionIndex: number;
+    status: "SUCCEEDED" | "FAILED" | "CANCELLED";
+    result?: unknown;
+    innerFlowInvocation?: boolean;
+};
+export type TEvent = TStatusChangedEvent | TVariableSetEvent | TErrorLogEvent | TWorkflowCompletedEvent;
+export type TDebugger = {
+    sendEvent: (event: TEvent) => void;
+    innerFlowInvocation: boolean;
+    sessionId?: string;
+};
+//# sourceMappingURL=events.d.ts.map

package/dist/runtime/events.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=events.js.map

package/dist/runtime/function-registry.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Function Registry for Flow Weaver
+ *
+ * Provides a global registry of functions that can be referenced by string IDs
+ * in external HTTP calls while allowing direct function passing in internal calls.
+ */
+export type FunctionCategory = 'transform' | 'filter' | 'validate' | 'format' | 'custom';
+export interface RegisteredFunction<TIn = unknown, TOut = unknown> {
+    id: string;
+    name: string;
+    description: string;
+    category: FunctionCategory;
+    fn: (input: TIn) => TOut | Promise<TOut>;
+    inputType: string;
+    outputType: string;
+    inputSchema?: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    examples?: Array<{
+        input: TIn;
+        output: TOut;
+    }>;
+}
+export type RegisteredFunctionMetadata = Omit<RegisteredFunction, 'fn'>;
+export declare class FunctionRegistry {
+    private functions;
+    /**
+     * Register a function with the registry
+     */
+    register<TIn, TOut>(config: RegisteredFunction<TIn, TOut>): void;
+    /**
+     * Get a function by ID
+     */
+    get<TIn, TOut>(id: string): ((input: TIn) => TOut | Promise<TOut>) | undefined;
+    /**
+     * Get function metadata without the function itself
+     */
+    getMetadata(id: string): RegisteredFunctionMetadata | undefined;
+    /**
+     * List all registered functions, optionally filtered by category
+     */
+    list(category?: FunctionCategory): RegisteredFunctionMetadata[];
+    /**
+     * Check if a function is registered
+     */
+    has(id: string): boolean;
+    /**
+     * Clear all registered functions (useful for testing)
+     */
+    clear(): void;
+    /**
+     * Get the count of registered functions
+     */
+    get size(): number;
+}
+/**
+ * Global function registry singleton
+ */
+export declare const functionRegistry: FunctionRegistry;
+//# sourceMappingURL=function-registry.d.ts.map