@common-stack/server-stack 8.2.5-alpha.8 → 8.3.1-alpha.0

package/lib/infrastructure/usage-examples.d.ts

@@ -1,9 +0,0 @@
-import { MainStackServer } from '../MainStackServer';
-import { StackServer } from '../StackServer';
-/**
- * Example usage of the new modular infrastructure system
- */
-export declare function startMainServer(): Promise<MainStackServer>;
-export declare function startMicroservice(): Promise<StackServer>;
-export declare function startServerWithCustomWorkflows(): Promise<MainStackServer>;
-export declare function getEnvironmentConfig(environment: string): import("./types").ConnectorConfig;

package/lib/infrastructure/workflow-orchestrator.d.ts

@@ -1,10 +0,0 @@
-import { InfrastructureConfig, WorkflowStep, ConnectorConfig } from './types';
-export declare class WorkflowOrchestrator {
-    private config;
-    private steps;
-    constructor(config: InfrastructureConfig);
-    addStep(step: WorkflowStep): void;
-    executeWorkflow(context: any): Promise<void>;
-    getEnabledSteps(): WorkflowStep[];
-}
-export declare const CONNECTOR_CONFIGS: Record<string, ConnectorConfig>;

package/lib/inngest/client-id-generator.d.ts

@@ -1,29 +0,0 @@
-export interface InngestClientIdConfig {
-    APP_NAME: string;
-    NODE_ENV: string;
-    INNGEST_CLIENT_ID?: string;
-}
-/**
- * Generates a unique Inngest client ID for multi-developer environments
- * Combines app name, environment, username, and hostname for uniqueness
- */
-export declare function generateInngestClientId(config: InngestClientIdConfig, logger?: any): string;
-/**
- * Examples of generated IDs:
- *
- * Production:
- * - APP_NAME=OrderAPI, NODE_ENV=production → "orderapi"
- *
- * Staging:
- * - APP_NAME=OrderAPI, NODE_ENV=staging → "orderapi-staging"
- *
- * Development:
- * - APP_NAME=OrderAPI, NODE_ENV=development, USER=john, HOSTNAME=macbook-pro
- *   → "orderapi-development-john-macbookp"
- *
- * - APP_NAME=OrderAPI, NODE_ENV=development, USER=mary, HOSTNAME=mary-laptop
- *   → "orderapi-development-mary-marylap"
- *
- * Explicit Override:
- * - INNGEST_CLIENT_ID=custom-client-id → "custom-client-id"
- */

package/lib/inngest/handler-factory.d.ts

@@ -1,24 +0,0 @@
-import { Container } from 'inversify';
-import { Feature } from '@common-stack/server-core';
-export type InngestFunctionFactory = (params: {
-    container: Container;
-    inngest: any;
-    settings?: any;
-}) => Record<string, any>;
-/**
- * Creates an Inngest handler that combines functions from multiple modules
- * Similar to how Moleculer services are loaded
- *
- * The improved loadInngestFunctions method now:
- * - Handles both array and object returns from factories
- * - Automatically extracts function instances from objects
- * - Flattens nested arrays
- * - Validates function instances
- */
-export declare const createInngestHandler: (features: Feature[], container: Container, inngestClient: any, settings?: any) => Promise<any[]>;
-/**
- * Legacy factory for backward compatibility
- * @param container - The inversify container
- * @deprecated Use createInngestHandler with Feature system instead
- */
-export declare const inngestHandlerFactory: (container: Container, inngestClient?: any) => Promise<any[]>;

package/lib/inngest/middleware/auto-resolve-invoke.middleware.d.ts

@@ -1,111 +0,0 @@
-/**
- * Auto-Resolve Invoke Middleware for Inngest
- *
- * Makes the `function` parameter optional in step.invoke() by automatically
- * resolving functions from the registry based on step names.
- *
- * Usage:
- * ```typescript
- * const inngest = new Inngest({
- *     middleware: [
- *         createFunctionMapperMiddleware(),      // Required first
- *         createAutoResolveInvokeMiddleware(),   // Then this
- *     ]
- * });
- *
- * // In your functions
- * async ({ step }) => {
- *     // Function auto-resolved from step name!
- *     await step.invoke('user-create', {
- *         data: { email: 'test@example.com' }
- *     });
- * }
- * ```
- */
-export interface AutoResolveInvokeOptions {
-    /**
-     * Custom mappings from step name to function ID
-     * Example: { 'create-user': 'user-create' }
-     */
-    mappings?: Record<string, string>;
-    /**
-     * Prefixes to strip from step names when resolving
-     * Default: ['invoke-', 'call-']
-     * Example: 'invoke-user-create' → 'user-create'
-     */
-    stripPrefixes?: string[];
-    /**
-     * Whether function ID matching is case-sensitive
-     * Default: false
-     */
-    caseSensitive?: boolean;
-    /**
-     * Whether to throw an error if function cannot be resolved
-     * Default: true
-     */
-    throwOnNotFound?: boolean;
-    /**
-     * Enable debug logging
-     * Default: false
-     */
-    debug?: boolean;
-}
-/**
- * Creates middleware that auto-resolves functions for step.invoke()
- *
- * IMPORTANT: This middleware requires functions to be provided explicitly.
- * Use `createAutoResolveInvokeMiddlewareWithFunctions()` helper instead,
- * or pass functions manually after calling serve().
- *
- * Resolution strategy (in order):
- * 1. If function explicitly provided → use it
- * 2. Try custom mappings
- * 3. Try exact match with function ID
- * 4. Try stripping configured prefixes
- * 5. Throw error or return null (based on throwOnNotFound)
- */
-export declare function createAutoResolveInvokeMiddleware(options?: AutoResolveInvokeOptions): any;
-/**
- * Helper: Create middleware with functions pre-populated
- * Use this version to ensure functions are available before middleware runs
- */
-export declare function createAutoResolveInvokeMiddlewareWithFunctions(functions: any[], options?: AutoResolveInvokeOptions): any;
-/**
- * Helper: Create middleware with common defaults for common-stack
- * Handles common-stack naming patterns like:
- * - aicode-code-agent
- * - project-mgmt-main-workflow
- * - key-mgmt-openbao-create-secret
- */
-export declare function createAutoResolveInvokeMiddlewareWithDefaults(): any;
-/**
- * Helper: Create middleware configured for common-stack WorkflowNamespace patterns
- *
- * Handles your naming convention where:
- * - Function IDs: 'aicode-code-agent', 'project-mgmt-main-workflow'
- * - Event Names: 'aicode/code-agent-trigger', 'project-mgmt-main-workflow/trigger'
- *
- * Example usage:
- * ```typescript
- * // In your workflow
- * await step.invoke('aicode-code-agent', { data: {...} });
- * // Resolves to function with ID 'aicode-code-agent'
- *
- * await step.invoke('project-mgmt-create-from-template', { data: {...} });
- * // Resolves to function with ID 'project-mgmt-create-from-template'
- * ```
- */
-export declare function createCommonStackAutoResolveMiddleware(options?: {
-    /** Additional custom mappings for special cases */
-    customMappings?: Record<string, string>;
-    /** Enable debug logging */
-    debug?: boolean;
-}): any;
-/**
- * Strict mode - only exact matches, case-sensitive
- */
-export declare const createStrictAutoResolveInvokeMiddleware: () => any;
-/**
- * Lenient mode - tries everything, doesn't throw
- */
-export declare const createLenientAutoResolveInvokeMiddleware: () => any;

package/lib/inngest/middleware/function-reference-helper.d.ts

@@ -1,211 +0,0 @@
-/**
- * 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: {...} });
- * ```
- */
-import { InngestFunction } from 'inngest';
-/**
- * Global function registry
- * Populated by setup.ts after all functions are loaded
- */
-declare class FunctionRegistry {
-    private functions;
-    private initialized;
-    /**
-     * Register all functions from Feature system
-     */
-    register(functions: InngestFunction.Any[]): void;
-    /**
-     * Get function by ID (case-insensitive)
-     */
-    get(functionId: string): InngestFunction.Any | undefined;
-    /**
-     * Check if function exists
-     */
-    has(functionId: string): boolean;
-    /**
-     * Get all registered function IDs
-     */
-    getAllIds(): string[];
-    /**
-     * Get count of registered functions
-     */
-    get count(): number;
-    /**
-     * Check if registry is initialized
-     */
-    get isInitialized(): boolean;
-    /**
-     * Clear registry (for testing)
-     */
-    clear(): void;
-}
-export declare const globalFunctionRegistry: 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' }
- * });
- * ```
- */
-export declare function referenceFunction<T extends InngestFunction.Any = InngestFunction.Any>(functionIdOrOptions: string | {
-    functionId: string;
-}): T;
-/**
- * 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: {...} });
- * ```
- */
-export declare function referenceFunctions<T extends readonly string[]>(functionIds: T): {
-    [K in T[number]]: InngestFunction.Any;
-};
-/**
- * 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: {...} });
- * }
- * ```
- */
-export declare function hasFunctionReference(functionId: string): boolean;
-/**
- * Get all available function IDs
- * Useful for debugging and introspection
- *
- * @example
- * ```typescript
- * console.log('Available functions:', getAvailableFunctions());
- * ```
- */
-export declare function getAvailableFunctions(): string[];
-/**
- * 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`.
- */
-export declare function resolveFunctionId(functionRef: string | {
-    functionId: string;
-}): InngestFunction.Any;
-/**
- * Middleware that injects referenceFunction into context
- * Makes it available in all function handlers
- *
- * @example
- * ```typescript
- * const inngest = new Inngest({
- *   middleware: [createFunctionReferenceMiddleware()],
- * });
- *
- * const myFn = inngest.createFunction(..., async ({ step, ctx }) => {
- *   // Access via context!
- *   const userFn = ctx.resolveFunction('user-create');
- *   await step.invoke('create-user', { function: userFn, data: {...} });
- * });
- * ```
- */
-export declare function createFunctionReferenceMiddleware(): {
-    name: string;
-    init(): {
-        onFunctionRun({ ctx }: any): {
-            transformInput(inputCtx: any): any;
-        };
-        onSendEvent: () => {};
-    };
-};
-/**
- * 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!
- * ```
- */
-export declare function createCombinedFunctionMiddleware(options?: {
-    /** Enable auto-resolve (default: true) */
-    autoResolve?: boolean;
-    /** Case-sensitive matching (default: false) */
-    caseSensitive?: boolean;
-    /** Enable debug logging (default: false) */
-    debug?: boolean;
-}): {
-    name: string;
-    init(): {
-        onFunctionRun({ ctx }: any): {
-            transformInput(inputCtx: any): any;
-        };
-        onSendEvent: () => {};
-    };
-};
-export {};

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

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

@@ -1,162 +0,0 @@
-/**
- * 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>;