n8n-nodes-semble/dist/core/ServiceContainer.d.ts

n8n community node for Semble practice management system - automate bookings, patients, and product/service catalog management

/**
 * @fileoverview ServiceContainer.ts
 * @description Dependency injection container for clean architecture and testability. Provides service registration, resolution, and lifecycle management.
 * @author Mike Hatcher
 * @website https://progenious.com
 * @namespace N8nNodesSemble.Core.ServiceContainer
 * @since 2.0.0
 */
/**
 * Service lifecycle types
 */
export declare enum ServiceLifetime {
    SINGLETON = "singleton",
    TRANSIENT = "transient",
    SCOPED = "scoped"
}
/**
 * Service registration configuration
 */
export interface ServiceRegistration<T = any> {
    name: string;
    factory: (...dependencies: any[]) => T;
    lifetime: ServiceLifetime;
    dependencies?: string[];
    instance?: T;
    scope?: string;
}
/**
 * Service container interface for dependency injection
 */
export interface IServiceContainer {
    register<T>(name: string, factory: (...deps: any[]) => T, lifetime?: ServiceLifetime, dependencies?: string[]): void;
    resolve<T>(name: string, scope?: string): T;
    isRegistered(name: string): boolean;
    clear(): void;
    createScope(scopeName: string): IServiceContainer;
}
/**
 * Dependency injection container implementation
 * Supports singleton, transient, and scoped service lifetimes
 */
export declare class ServiceContainer implements IServiceContainer {
    private services;
    private singletonInstances;
    private scopedInstances;
    private resolutionStack;
    /**
     * Register a service with the container
     */
    register<T>(name: string, factory: (...dependencies: any[]) => T, lifetime?: ServiceLifetime, dependencies?: string[]): void;
    /**
     * Register a singleton service
     */
    registerSingleton<T>(name: string, factory: (...dependencies: any[]) => T, dependencies?: string[]): void;
    /**
     * Register a transient service
     */
    registerTransient<T>(name: string, factory: (...dependencies: any[]) => T, dependencies?: string[]): void;
    /**
     * Register a scoped service
     */
    registerScoped<T>(name: string, factory: (...dependencies: any[]) => T, dependencies?: string[]): void;
    /**
     * Resolve a service by name
     */
    resolve<T>(name: string, scope?: string): T;
    /**
     * Resolve singleton service
     */
    private resolveSingleton;
    /**
     * Resolve scoped service
     */
    private resolveScoped;
    /**
     * Resolve transient service
     */
    private resolveTransient;
    /**
     * Resolve service dependencies
     */
    private resolveDependencies;
    /**
     * Check if a service is registered
     */
    isRegistered(name: string): boolean;
    /**
     * Get all registered service names
     */
    getRegisteredServices(): string[];
    /**
     * Clear all services and instances
     */
    clear(): void;
    /**
     * Clear scoped instances for a specific scope
     */
    clearScope(scope: string): void;
    /**
     * Create a scoped container
     */
    createScope(scopeName: string): IServiceContainer;
    /**
     * Get service registration info
     */
    getServiceInfo(name: string): ServiceRegistration | undefined;
    /**
     * Register multiple services at once
     */
    registerBatch(registrations: Array<{
        name: string;
        factory: (...deps: any[]) => any;
        lifetime?: ServiceLifetime;
        dependencies?: string[];
    }>): void;
}
/**
 * Default service container instance
 */
export declare const serviceContainer: ServiceContainer;
/**
 * Service decorator for automatic registration
 */
export declare function Service(name: string, lifetime?: ServiceLifetime): <T extends {
    new (...args: any[]): {};
}>(constructor: T) => T;
/**
 * Injectable decorator for dependency injection
 */
export declare function Injectable(dependencies?: string[]): <T extends {
    new (...args: any[]): {};
}>(constructor: T) => any;
/**
 * Utility functions for common service patterns
 */
export declare class ServiceContainerUtils {
    /**
     * Register all Semble core services
     */
    static registerCoreServices(container: ServiceContainer): void;
    /**
     * Create a service container with all Semble services registered
     */
    static createConfiguredContainer(): ServiceContainer;
}