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

package/lib/infrastructure/example-workflows.d.ts

@@ -1,16 +0,0 @@
-import { WorkflowStep, ConnectorConfig } from './types';
-/**
- * Example custom workflow steps that can be added to the infrastructure initialization
- */
-export declare const metricsInitializationStep: WorkflowStep;
-export declare const customMigrationStep: WorkflowStep;
-export declare const healthCheckStep: WorkflowStep;
-export declare const cacheWarmingStep: WorkflowStep;
-export declare const HIGH_PERFORMANCE_CONFIG: ConnectorConfig;
-export declare const MINIMAL_CONFIG: ConnectorConfig;
-export declare function createCustomWorkflow(environment: string): WorkflowStep[];
-export declare function createCustomInfrastructureConfig(environment: string): {
-    connectors: ConnectorConfig;
-    workflows: WorkflowStep[];
-    environment: string;
-};

package/lib/infrastructure/index.d.ts

@@ -1,5 +0,0 @@
-export * from './types';
-export * from './container-module';
-export * from './workflow-orchestrator';
-export * from './infrastructure-factory';
-export * from './inngest-factory';

package/lib/infrastructure/infrastructure-factory.d.ts

@@ -1,45 +0,0 @@
-import { ServiceBroker } from 'moleculer';
-import { Container } from 'inversify';
-import { Feature as ServerFeature } from '@common-stack/server-core';
-import { CdmLogger } from '@cdm-logger/core';
-import { InfrastructureContext, ConnectorConfig, WorkflowStep } from './types';
-import { ConnectionBroker } from '../connectors/connection-broker';
-export interface BrokerInitializationOptions {
-    type: 'main' | 'microservice';
-    nodeId?: string;
-    connectorConfig: ConnectorConfig;
-    enableMetrics?: boolean;
-    workflows?: WorkflowStep[];
-    /**
-     * Optional callback invoked immediately after container creation,
-     * before services are instantiated.
-     */
-    onContainerCreated?: (params: {
-        container: Container;
-        broker: ServiceBroker;
-        context: InfrastructureContext;
-    }) => void | Promise<void>;
-}
-export declare class InfrastructureFactory {
-    private logger;
-    private connectionBroker;
-    private orchestrator;
-    constructor(logger: CdmLogger.ILogger);
-    initialize(): Promise<void>;
-    createBrokerAndContainer(options: BrokerInitializationOptions, serverFeature: ServerFeature, settings: any, existingAllModules?: ServerFeature): Promise<{
-        broker: ServiceBroker;
-        container: Container;
-        context: InfrastructureContext;
-        allModules: ServerFeature;
-    }>;
-    private loadAndComposeModules;
-    private createContainerFromModules;
-    private loadMoleculerServices;
-    private createInfrastructureContext;
-    private createServiceBroker;
-    getConnectionBroker(): ConnectionBroker;
-    cleanup(): Promise<void>;
-    static createMainServiceConfig(): BrokerInitializationOptions;
-    static createMicroserviceConfig(nodeId?: string): BrokerInitializationOptions;
-    static createDevelopmentMicroserviceConfig(): BrokerInitializationOptions;
-}

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

@@ -1,8 +0,0 @@
-import { Inngest } from 'inngest';
-import { CdmLogger } from '@cdm-logger/core';
-export declare const generateInngestClientId: (configParams: {
-    APP_NAME: string;
-    NODE_ENV: string;
-    INNGEST_CLIENT_ID?: string;
-}, logger: CdmLogger.ILogger) => string;
-export declare const createInngestClient: (logger: CdmLogger.ILogger) => Inngest;

package/lib/infrastructure/types.d.ts

@@ -1,28 +0,0 @@
-import { ServiceBroker } from 'moleculer';
-import { CdmLogger } from '@cdm-logger/core';
-import { Inngest } from 'inngest';
-export interface InfrastructureContext {
-    broker: ServiceBroker;
-    pubsub: any;
-    mongoClient: any;
-    logger: CdmLogger.ILogger;
-    redisClient: any;
-    inngestClient?: Inngest;
-}
-export interface WorkflowStep {
-    name: string;
-    order: number;
-    enabled: boolean;
-    execute: (context: InfrastructureContext) => Promise<void> | void;
-}
-export interface ConnectorConfig {
-    redis: boolean;
-    mongo: boolean;
-    pubsub: boolean;
-    inngest: boolean;
-}
-export interface InfrastructureConfig {
-    connectors: ConnectorConfig;
-    workflows: WorkflowStep[];
-    environment: string;
-}

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' }
- * });
- * ```
- */