rcc-configuration
Version:
RCC Configuration Module - Comprehensive configuration management for modular TypeScript applications
252 lines • 6.72 kB
TypeScript
/**
* Configuration to Pipeline Integration Module
*
* This module extends the Configuration System to provide pipeline assembly functionality
* based on virtual model mapping configurations. It serves as the bridge between
* configuration management and pipeline execution.
*/
import { BaseModule } from 'rcc-basemodule';
import { ConfigurationSystem } from '../core/ConfigurationSystem';
import { ConfigData, VirtualModelTarget } from '../core/ConfigData';
import { PipelineAssembler } from 'rcc-pipeline';
import { VirtualModelRulesModule } from 'rcc-virtual-model-rules';
import { PipelineAssemblyConfig, PipelineModuleConfig, ModuleConnection, Pipeline } from 'rcc-pipeline';
/**
* Virtual model mapping configuration
*/
export interface VirtualModelMapping {
/**
* Virtual model identifier
*/
virtualModelId: string;
/**
* Target configuration list
*/
targets: VirtualModelTarget[];
/**
* Pipeline configuration for this virtual model
*/
pipelineConfig?: VirtualModelPipelineConfig;
/**
* Priority for routing (higher = higher priority)
*/
priority?: number;
/**
* Whether this mapping is enabled
*/
enabled?: boolean;
/**
* Additional metadata
*/
metadata?: Record<string, any>;
}
/**
* Pipeline configuration for virtual models
*/
export interface VirtualModelPipelineConfig {
/**
* Custom pipeline modules to include
*/
modules?: PipelineModuleConfig[];
/**
* Custom module connections
*/
connections?: ModuleConnection[];
/**
* Module-specific configurations
*/
moduleConfigs?: Record<string, any>;
/**
* Pipeline execution settings
*/
execution?: {
timeout?: number;
retryCount?: number;
fallbackEnabled?: boolean;
};
}
/**
* Pipeline table generation configuration
*/
export interface PipelineTableConfig {
/**
* Whether to generate pipeline tables automatically
*/
enabled: boolean;
/**
* Pipeline table generation strategy
*/
strategy: 'static' | 'dynamic' | 'hybrid';
/**
* Default pipeline modules to include
*/
defaultModules?: PipelineModuleConfig[];
/**
* Default module connections
*/
defaultConnections?: ModuleConnection[];
/**
* Cache settings for generated pipelines
*/
cache?: {
enabled: boolean;
ttl: number;
maxSize: number;
};
/**
* Validation settings
*/
validation?: {
strict: boolean;
failOnError: boolean;
warnOnUnknown: boolean;
};
}
/**
* Pipeline assembly result
*/
export interface PipelineAssemblyResult {
/**
* Whether assembly was successful
*/
success: boolean;
/**
* Assembled pipeline (if successful)
*/
pipeline?: Pipeline;
/**
* Generated pipeline table
*/
pipelineTable?: Map<string, PipelineAssemblyConfig>;
/**
* Assembly errors (if any)
*/
errors?: string[];
/**
* Assembly warnings (if any)
*/
warnings?: string[];
/**
* Assembly metadata
*/
metadata?: {
assemblyTime: number;
virtualModelCount: number;
moduleCount: number;
connectionCount: number;
};
}
/**
* Configuration to Pipeline Integration Module
*/
export declare class ConfigurationToPipelineModule extends BaseModule {
private configurationSystem;
private pipelineAssembler;
private virtualModelRulesModule;
private pipelineTable;
private pipelineCache;
protected config: PipelineTableConfig;
private isInitialized;
constructor(configurationSystem: ConfigurationSystem, pipelineAssembler: PipelineAssembler, virtualModelRulesModule: VirtualModelRulesModule, config?: Partial<PipelineTableConfig>);
/**
* Initialize the configuration to pipeline integration
*/
initialize(): Promise<void>;
/**
* Parse virtual model mappings from configuration
*/
parseVirtualModelMappings(config?: ConfigData): Promise<VirtualModelMapping[]>;
/**
* Generate pipeline table from virtual model mappings
*/
generatePipelineTable(mappings: VirtualModelMapping[]): Promise<Map<string, PipelineAssemblyConfig>>;
/**
* Assemble pipelines from configuration (static one-time assembly)
*/
assemblePipelinesFromConfiguration(config?: ConfigData): Promise<PipelineAssemblyResult>;
/**
* Get pipeline configuration for a virtual model
*/
getPipelineConfig(virtualModelId: string): PipelineAssemblyConfig | undefined;
/**
* Get all pipeline configurations
*/
getAllPipelineConfigs(): Map<string, PipelineAssemblyConfig>;
/**
* Get pipeline for a virtual model
*/
getPipeline(virtualModelId: string): Pipeline | undefined;
/**
* Validate configuration before pipeline assembly
*/
validateConfigurationForPipeline(config: ConfigData): Promise<{
valid: boolean;
errors: string[];
warnings: string[];
}>;
/**
* Reload configuration and reassemble pipelines
*/
reloadAndReassemble(): Promise<PipelineAssemblyResult>;
/**
* Get module status and health information
*/
getStatus(): {
moduleId: string;
initialized: boolean;
config: PipelineTableConfig;
pipelineTableSize: number;
pipelineCacheSize: number;
activePipeline: any;
timestamp: number;
};
/**
* Handle incoming messages
*/
handleMessage(message: any): Promise<any>;
/**
* Cleanup resources
*/
destroy(): Promise<void>;
/**
* Parse pipeline configuration from mapping
*/
private parsePipelineConfig;
/**
* Generate pipeline configuration from virtual model mapping
*/
private generatePipelineConfig;
/**
* Validate virtual model mapping
*/
private validateVirtualModelMapping;
/**
* Setup message handlers
*/
private setupMessageHandlers;
/**
* Start cache cleanup
*/
private startCacheCleanup;
/**
* Cleanup expired cache entries
*/
private cleanupCache;
/**
* Handle pipeline assembly request
*/
private handlePipelineAssemblyRequest;
/**
* Handle pipeline reload request
*/
private handlePipelineReloadRequest;
/**
* Handle pipeline status request
*/
private handlePipelineStatusRequest;
/**
* Handle configuration validation request
*/
private handleConfigValidationRequest;
}
//# sourceMappingURL=ConfigurationToPipelineModule.d.ts.map