@common-stack/server-stack 8.0.1-alpha.2 → 8.2.1-alpha.0

package/lib/inngest/middleware/function-reference-helper.mjs

@@ -0,0 +1,363 @@
+/**
+ * Function Reference Helper for Inngest
+ *
+ * Provides automatic function reference resolution for all registered functions.
+ * Instead of manually importing functions, you can reference them by ID.
+ *
+ * This combines:
+ * 1. Inngest's native `referenceFunction()` pattern
+ * 2. Automatic registry from all Feature-registered functions
+ * 3. Type-safe helpers for common patterns
+ *
+ * Usage:
+ * ```typescript
+ * // Instead of:
+ * import { someFunction } from '../other-module';
+ * await step.invoke('call-it', { function: someFunction, data: {...} });
+ *
+ * // You can do:
+ * await step.invoke('call-it', {
+ *   function: ctx.resolveFunction('some-function-id'),
+ *   data: {...}
+ * });
+ *
+ * // Or even simpler (if middleware auto-resolve enabled):
+ * await step.invoke('some-function-id', { data: {...} });
+ * ```
+ */
+/**
+ * Global function registry
+ * Populated by setup.ts after all functions are loaded
+ */
+class FunctionRegistry {
+    functions = new Map();
+    initialized = false;
+    /**
+     * Register all functions from Feature system
+     */
+    register(functions) {
+        if (this.initialized) {
+            console.warn('[FunctionRegistry] Already initialized, skipping re-registration');
+            return;
+        }
+        console.log(`[FunctionRegistry] Registering ${functions.length} functions...`);
+        functions.forEach((fn, index) => {
+            try {
+                if (!fn) {
+                    console.warn(`[FunctionRegistry] Skipping null function at index ${index}`);
+                    return;
+                }
+                // Get function ID (might be method or property)
+                let fnId;
+                if (typeof fn.id === 'function') {
+                    fnId = fn.id();
+                }
+                else {
+                    fnId = String(fn.id);
+                }
+                if (!fnId) {
+                    console.warn(`[FunctionRegistry] Skipping function at index ${index} - empty ID`);
+                    return;
+                }
+                this.functions.set(fnId, fn);
+                // Also register lowercase version for case-insensitive lookup
+                this.functions.set(fnId.toLowerCase(), fn);
+            }
+            catch (error) {
+                console.error(`[FunctionRegistry] Error registering function at index ${index}:`, error);
+            }
+        });
+        this.initialized = true;
+        const uniqueCount = Array.from(new Set(this.functions.values())).length;
+        console.log(`[FunctionRegistry] ✅ Registered ${uniqueCount} unique functions`);
+    }
+    /**
+     * Get function by ID (case-insensitive)
+     */
+    get(functionId) {
+        // Try exact match first
+        let fn = this.functions.get(functionId);
+        if (fn)
+            return fn;
+        // Try lowercase match
+        fn = this.functions.get(functionId.toLowerCase());
+        if (fn)
+            return fn;
+        return undefined;
+    }
+    /**
+     * Check if function exists
+     */
+    has(functionId) {
+        return this.functions.has(functionId) || this.functions.has(functionId.toLowerCase());
+    }
+    /**
+     * Get all registered function IDs
+     */
+    getAllIds() {
+        const uniqueFunctions = Array.from(new Set(this.functions.values()));
+        return uniqueFunctions
+            .map((fn) => {
+            if (typeof fn.id === 'function') {
+                return fn.id();
+            }
+            return String(fn.id);
+        })
+            .filter(Boolean);
+    }
+    /**
+     * Get count of registered functions
+     */
+    get count() {
+        return Array.from(new Set(this.functions.values())).length;
+    }
+    /**
+     * Check if registry is initialized
+     */
+    get isInitialized() {
+        return this.initialized;
+    }
+    /**
+     * Clear registry (for testing)
+     */
+    clear() {
+        this.functions.clear();
+        this.initialized = false;
+    }
+}
+// Global singleton instance
+const globalFunctionRegistry = new FunctionRegistry();
+/**
+ * Reference a function by its ID
+ * Similar to Inngest's native referenceFunction, but automatically uses global registry
+ *
+ * @param functionIdOrOptions - The ID of the function or options object with functionId
+ * @returns The function reference to use in step.invoke()
+ *
+ * @example
+ * ```typescript
+ * // Simple usage
+ * const userCreateFn = referenceFunction('user-create');
+ *
+ * // Type-safe usage
+ * const computePi = referenceFunction({ functionId: 'compute-pi' });
+ *
+ * await step.invoke('create-user', {
+ *   function: userCreateFn,
+ *   data: { email: 'user@example.com' }
+ * });
+ * ```
+ */
+function referenceFunction(functionIdOrOptions) {
+    const functionId = typeof functionIdOrOptions === 'string' ? functionIdOrOptions : functionIdOrOptions.functionId;
+    if (!globalFunctionRegistry.isInitialized) {
+        throw new Error(`[referenceFunction] Function registry not initialized yet. ` +
+            `Ensure setupInngestFunctions() has completed before using referenceFunction().`);
+    }
+    const fn = globalFunctionRegistry.get(functionId);
+    if (!fn) {
+        const available = globalFunctionRegistry.getAllIds();
+        const suggestions = available.filter((id) => id.toLowerCase().includes(functionId.toLowerCase())).slice(0, 5);
+        let errorMsg = `[referenceFunction] Function "${functionId}" not found in registry.`;
+        if (suggestions.length > 0) {
+            errorMsg += `\n\nDid you mean one of these?\n  - ${suggestions.join('\n  - ')}`;
+        }
+        else {
+            errorMsg += `\n\nAvailable functions (${available.length} total):\n  - ${available.slice(0, 10).join('\n  - ')}`;
+            if (available.length > 10) {
+                errorMsg += `\n  ... and ${available.length - 10} more`;
+            }
+        }
+        throw new Error(errorMsg);
+    }
+    return fn;
+}
+/**
+ * Batch reference multiple functions at once
+ * Useful for orchestrator workflows that call many functions
+ *
+ * @example
+ * ```typescript
+ * const { userCreate, emailSend, analyticsTrack } = referenceFunctions([
+ *   'user-create',
+ *   'email-send-welcome',
+ *   'analytics-track-event'
+ * ]);
+ *
+ * await step.invoke('create-user', { function: userCreate, data: {...} });
+ * await step.invoke('send-email', { function: emailSend, data: {...} });
+ * await step.invoke('track', { function: analyticsTrack, data: {...} });
+ * ```
+ */
+function referenceFunctions(functionIds) {
+    const result = {};
+    for (const functionId of functionIds) {
+        result[functionId] = referenceFunction(functionId);
+    }
+    return result;
+}
+/**
+ * Check if a function is registered
+ * Useful for conditional logic
+ *
+ * @example
+ * ```typescript
+ * if (hasFunctionReference('email-send-welcome')) {
+ *   const emailFn = referenceFunction('email-send-welcome');
+ *   await step.invoke('send-email', { function: emailFn, data: {...} });
+ * }
+ * ```
+ */
+function hasFunctionReference(functionId) {
+    return globalFunctionRegistry.has(functionId);
+}
+/**
+ * Get all available function IDs
+ * Useful for debugging and introspection
+ *
+ * @example
+ * ```typescript
+ * console.log('Available functions:', getAvailableFunctions());
+ * ```
+ */
+function getAvailableFunctions() {
+    return globalFunctionRegistry.getAllIds();
+}
+/**
+ * Resolve a workflow-style or ID-style function reference to an Inngest function reference.
+ *
+ * Supported inputs:
+ * - Exact function id: "user-create"
+ * - Workflow-style: "WORKFLOWNAME.Function/trigger" or "WORKFLOWNAME.Function.trigger"
+ *
+ * The resolver will first try the exact ID as provided. If not found it will
+ * normalize the string by replacing separators ("/", ".") with dashes and
+ * collapsing non-alphanumerics, then lower-case the result. Example:
+ *
+ *   WORKFLOWNAME.Function/trigger -> workflowname-function-trigger
+ *
+ * If still not found, it will throw the same helpful error as `referenceFunction`.
+ */
+function resolveFunctionId(functionRef) {
+    const raw = typeof functionRef === 'string' ? functionRef : functionRef.functionId;
+    if (!raw || typeof raw !== 'string') {
+        throw new Error('[resolveFunctionId] Invalid function reference');
+    }
+    // Try direct lookup first
+    if (globalFunctionRegistry.has(raw)) {
+        return referenceFunction(raw);
+    }
+    // Normalize common workflow-style patterns into kebab-case id
+    let normalized = raw
+        // Replace separators with dashes
+        .replace(/[\/\.\s]+/g, '-')
+        // Insert dashes between camelCase / PascalCase boundaries (aB -> a-B)
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        // Remove non-alphanumeric/dash characters
+        .replace(/[^a-zA-Z0-9-]+/g, '-')
+        // Collapse multiple dashes
+        .replace(/-+/g, '-')
+        // Trim dashes
+        .replace(/(^-|-$)/g, '')
+        .toLowerCase();
+    if (globalFunctionRegistry.has(normalized)) {
+        return referenceFunction(normalized);
+    }
+    // As a last resort, try lowercasing the raw input
+    if (globalFunctionRegistry.has(raw.toLowerCase())) {
+        return referenceFunction(raw.toLowerCase());
+    }
+    // Not found - rethrow a helpful error from referenceFunction to show suggestions
+    return referenceFunction(normalized);
+}
+/**
+ * Combined middleware: Reference + Auto-Resolve
+ * Provides both manual and automatic function resolution
+ *
+ * @example
+ * ```typescript
+ * const inngest = new Inngest({
+ *   middleware: [createCombinedFunctionMiddleware()],
+ * });
+ *
+ * // Method 1: Manual reference
+ * const userFn = ctx.resolveFunction('user-create');
+ * await step.invoke('create-user', { function: userFn, data: {...} });
+ *
+ * // Method 2: Automatic (if function ID matches)
+ * await step.invoke('user-create', { data: {...} });  // Auto-resolved!
+ * ```
+ */
+function createCombinedFunctionMiddleware(options) {
+    const { autoResolve = true, caseSensitive = false, debug = false } = options || {};
+    const log = (...args) => {
+        if (debug) {
+            console.log('[CombinedFunctionMiddleware]', ...args);
+        }
+    };
+    return {
+        name: 'combined-function-middleware',
+        init() {
+            return {
+                onFunctionRun({ ctx }) {
+                    // Inject reference helpers
+                    ctx.resolveFunction = referenceFunction;
+                    ctx.resolveFunctions = referenceFunctions;
+                    ctx.hasFunction = hasFunctionReference;
+                    ctx.getAvailableFunctions = getAvailableFunctions;
+                    ctx.resolveFunctionId = resolveFunctionId;
+                    return {
+                        transformInput(inputCtx) {
+                            // Inject into context
+                            if (inputCtx.ctx) {
+                                inputCtx.ctx.resolveFunction = referenceFunction;
+                                inputCtx.ctx.resolveFunctions = referenceFunctions;
+                                inputCtx.ctx.hasFunction = hasFunctionReference;
+                                inputCtx.ctx.getAvailableFunctions = getAvailableFunctions;
+                                inputCtx.ctx.resolveFunctionId = resolveFunctionId;
+                            }
+                            // Inject helper functions into step object for inline editor support
+                            // The actual step object that gets passed to workflow functions is inputCtx.ctx.step
+                            // inputCtx.step is the step data array, inputCtx.ctx.step is the step object with methods
+                            const stepObject = inputCtx.ctx && inputCtx.ctx.step;
+                            log('Checking step object - inputCtx.step:', !!inputCtx.step, 'inputCtx.steps:', !!inputCtx.steps, 'inputCtx.ctx.step:', !!stepObject, 'found step object:', !!stepObject);
+                            if (stepObject) {
+                                // Make referenceFunction available as step.referenceFunction()
+                                stepObject.referenceFunction = referenceFunction;
+                                stepObject.hasFunction = hasFunctionReference;
+                                stepObject.getAvailableFunctions = getAvailableFunctions;
+                                stepObject.resolveFunctionId = resolveFunctionId;
+                                log('✅ Injected referenceFunction into step object');
+                            }
+                            else {
+                                log('❌ No step object found in inputCtx.ctx.step');
+                            }
+                            // Auto-resolve if enabled
+                            if (autoResolve && stepObject) {
+                                const originalInvoke = stepObject.invoke;
+                                stepObject.invoke = async (stepId, opts = {}) => {
+                                    log(`invoke() called: "${stepId}", has function:`, !!opts.function);
+                                    // Auto-resolve if no function provided
+                                    if (!opts.function) {
+                                        try {
+                                            const fn = referenceFunction(stepId);
+                                            opts = { ...opts, function: fn };
+                                            log(`✅ Auto-resolved function for step "${stepId}"`);
+                                        }
+                                        catch (error) {
+                                            log(`⚠️  Could not auto-resolve "${stepId}":`, error.message);
+                                            // Continue with original behavior
+                                        }
+                                    }
+                                    return originalInvoke.call(stepObject, stepId, opts);
+                                };
+                            }
+                            return inputCtx;
+                        },
+                    };
+                },
+                onSendEvent: () => ({}),
+            };
+        },
+    };
+}export{createCombinedFunctionMiddleware,getAvailableFunctions,globalFunctionRegistry,hasFunctionReference,referenceFunction,referenceFunctions,resolveFunctionId};//# sourceMappingURL=function-reference-helper.mjs.map

package/lib/inngest/middleware/function-reference-helper.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"function-reference-helper.mjs","sources":["../../../src/inngest/middleware/function-reference-helper.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/lib/inngest/middleware/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Inngest Middleware - Public Exports
+ *
+ * This module provides middleware to automatically resolve Inngest function references
+ * in step.invoke() calls, enabling cleaner workflow code.
+ */
+export { createAutoResolveInvokeMiddleware, createAutoResolveInvokeMiddlewareWithFunctions, createAutoResolveInvokeMiddlewareWithDefaults, createCommonStackAutoResolveMiddleware, createStrictAutoResolveInvokeMiddleware, type AutoResolveInvokeOptions, } from './auto-resolve-invoke.middleware';
+export { referenceFunction, referenceFunctions, hasFunctionReference, getAvailableFunctions, resolveFunctionId, globalFunctionRegistry, createFunctionReferenceMiddleware, createCombinedFunctionMiddleware, } from './function-reference-helper';
+export type { InngestFunction } from 'inngest';
+export type { ExtendedContext, ExtendedStep, InlineEditorHandler, FullContextHandler } from './types';
+/**
+ * Usage Example:
+ *
+ * ```typescript
+ * import { createCommonStackAutoResolveMiddleware } from '@common-stack/server-stack';
+ *
+ * const inngest = new Inngest({
+ *     id: 'my-app',
+ *     middleware: [
+ *         createCommonStackAutoResolveMiddleware({
+ *             debug: true,
+ *         })
+ *     ]
+ * });
+ *
+ * // In your workflows:
+ * await step.invoke(WorkflowNamespace.USER_CREATE, {
+ *     data: { email: 'test@example.com' }
+ * });
+ * ```
+ */

package/lib/inngest/middleware/types.d.ts

@@ -0,0 +1,162 @@
+/**
+ * TypeScript type extensions for Inngest middleware-injected helpers
+ *
+ * These types extend the Inngest Step and Context objects with our custom helpers
+ * that are injected by the function-reference middleware.
+ *
+ * Usage in your code:
+ * ```typescript
+ * import type { ExtendedStep, ExtendedContext } from '@common-stack/server-stack';
+ *
+ * const myFn = inngest.createFunction(..., async ({ event, ctx, step }: {
+ *   event: any;
+ *   ctx: ExtendedContext;
+ *   step: ExtendedStep;
+ * }) => {
+ *   // Now you get autocomplete for ctx.resolveFunctionId and step.resolveFunctionId!
+ *   const userFn = ctx.resolveFunctionId('USER.Create/trigger');
+ *   await step.invoke('create-user', { function: userFn, data: {...} });
+ * });
+ * ```
+ */
+import type { InngestFunction } from 'inngest';
+/**
+ * Extended Context with injected function reference helpers
+ */
+export interface ExtendedContext {
+    /**
+     * Reference a function by its exact ID
+     * @param functionId - The exact function ID (e.g., 'user-create')
+     */
+    resolveFunction<T extends InngestFunction.Any = InngestFunction.Any>(functionId: string | {
+        functionId: string;
+    }): T;
+    /**
+     * Resolve a function reference from a workflow-style string or plain ID
+     * Normalizes strings like "WORKFLOWNAME.Function/trigger" to "workflowname-function-trigger"
+     * @param functionRef - Workflow-style string or plain function ID
+     */
+    resolveFunctionId<T extends InngestFunction.Any = InngestFunction.Any>(functionRef: string | {
+        functionId: string;
+    }): T;
+    /**
+     * Batch reference multiple functions at once
+     * @param functionIds - Array of function IDs to reference
+     */
+    resolveFunctions<T extends readonly string[]>(functionIds: T): {
+        [K in T[number]]: InngestFunction.Any;
+    };
+    /**
+     * Check if a function is registered in the global registry
+     * @param functionId - The function ID to check
+     */
+    hasFunction(functionId: string): boolean;
+    /**
+     * Get all available function IDs from the registry
+     */
+    getAvailableFunctions(): string[];
+}
+/**
+ * Extended Step with injected function reference helpers
+ *
+ * These are available on the step object for inline editors that can't import modules.
+ */
+export interface ExtendedStep {
+    /**
+     * Reference a function by its exact ID
+     * Available on step object for inline editor support (no imports needed)
+     * @param functionId - The exact function ID (e.g., 'user-create')
+     *
+     * @example
+     * ```typescript
+     * const step_159 = async (event, step) => {
+     *   const userFn = step.referenceFunction('user-create');
+     *   await step.invoke('create-user', { function: userFn, data: {...} });
+     * };
+     * ```
+     */
+    referenceFunction<T extends InngestFunction.Any = InngestFunction.Any>(functionId: string | {
+        functionId: string;
+    }): T;
+    /**
+     * Resolve a function reference from a workflow-style string or plain ID
+     * Available on step object for inline editor support (no imports needed)
+     * Normalizes strings like "WORKFLOWNAME.Function/trigger" to "workflowname-function-trigger"
+     * @param functionRef - Workflow-style string or plain function ID
+     *
+     * @example
+     * ```typescript
+     * const step_159 = async (event, step) => {
+     *   // Workflow-style reference
+     *   const paymentFn = step.resolveFunctionId('BILLING.ProcessPayment/trigger');
+     *   await step.invoke('process-payment', { function: paymentFn, data: {...} });
+     * };
+     * ```
+     */
+    resolveFunctionId<T extends InngestFunction.Any = InngestFunction.Any>(functionRef: string | {
+        functionId: string;
+    }): T;
+    /**
+     * Check if a function is registered in the global registry
+     * Available on step object for inline editor support (no imports needed)
+     * @param functionId - The function ID to check
+     *
+     * @example
+     * ```typescript
+     * const step_159 = async (event, step) => {
+     *   if (step.hasFunction('email-send')) {
+     *     const emailFn = step.referenceFunction('email-send');
+     *     await step.invoke('send-email', { function: emailFn, data: {...} });
+     *   }
+     * };
+     * ```
+     */
+    hasFunction(functionId: string): boolean;
+    /**
+     * Get all available function IDs from the registry
+     * Available on step object for inline editor support (no imports needed)
+     *
+     * @example
+     * ```typescript
+     * const step_159 = async (event, step) => {
+     *   console.log('Available functions:', step.getAvailableFunctions());
+     * };
+     * ```
+     */
+    getAvailableFunctions(): string[];
+    invoke: any;
+    run: any;
+    sleep: any;
+    sleepUntil: any;
+    waitForEvent: any;
+    sendEvent: any;
+    [key: string]: any;
+}
+/**
+ * Helper type for inline editor function handlers
+ * Use this for your inline editor functions to get full autocomplete
+ *
+ * @example
+ * ```typescript
+ * const step_159: InlineEditorHandler = async (event, step) => {
+ *   // Full autocomplete for step.resolveFunctionId, step.referenceFunction, etc!
+ *   const userFn = step.resolveFunctionId('USER.Create/trigger');
+ *   await step.invoke('create-user', { function: userFn, data: {...} });
+ *   return { success: true };
+ * };
+ * ```
+ */
+export type InlineEditorHandler = (event: any, step: ExtendedStep) => Promise<any>;
+/**
+ * Full context handler with both ctx and step extended
+ *
+ * @example
+ * ```typescript
+ * const myHandler: FullContextHandler = async (event, ctx, step) => {
+ *   const userFn = ctx.resolveFunctionId('USER.Create/trigger');
+ *   await step.invoke('create-user', { function: userFn, data: {...} });
+ *   return { success: true };
+ * };
+ * ```
+ */
+export type FullContextHandler = (event: any, ctx: ExtendedContext, step: ExtendedStep) => Promise<any>;