Module Integrator Plan

Ecosistema completo para organización y gestión de contenido con interfaces espaciales

Plan de Desarrollo - Librería Module Integrator (Core)

Estado Actual

Cambios de Arquitectura

Dependencias Fundamentales

Integración de Tipos y Contratos

El Module Integrator NO redefine el ModuleManifest ni otros contratos base. En su lugar:

Fases de Implementación

Fase 1: Core Services y Estructura Base (Semana 1)

1.1 Crear estructura de directorios

src/lib/
├── core/                    # Servicios core del orquestador
├── management/              # Gestión de módulos y configuración
├── navigation/              # Gestión de navegación inter-módulo
├── communication/           # Comunicación cross-module
├── bootstrap/               # Inicialización y configuración
├── validation/              # Validación de contratos y seguridad
├── orchestration/           # Coordinación avanzada
├── monitoring/              # Monitoreo y métricas
├── models/                  # Modelos de datos
├── workers/                 # Web Workers para operaciones pesadas
└── utils/                   # Utilidades específicas

1.2 Implementar servicios core

1.3 Implementar modelos base

Fase 2: Configuración API y Gestión de Módulos (Semana 2)

2.1 Gestión de Configuración desde API

2.2 Validación y Seguridad

Fase 3: Navegación y UI Integration (Semana 3)

3.1 Gestión de Navegación

3.2 Comunicación Cross-Module

3.3 Integración UI

Fase 4: Orchestration y Performance (Semana 4)

4.1 Browser Orchestration

4.2 Performance Monitoring

4.3 Web Workers

Fase 5: Testing e Integración (Semana 5)

5.1 Testing Comprehensivo

5.2 Integración con Ecosistema

5.3 Documentación

Estructura Detallada del Paquete

src/lib/
├── core/
│   ├── integrator.service.ts           # IntegratorService - Orquestador principal
│   ├── module-registry.service.ts      # ModuleRegistryService - Registro central
│   ├── dependency-solver.service.ts    # DependencySolverService
│   ├── lifecycle-manager.service.ts    # LifecycleManagerService
│   └── module-discovery.service.ts     # ModuleDiscoveryService
├── management/
│   ├── module-activator.ts             # ModuleActivator
│   ├── config-merger.service.ts        # ConfigMergerService
│   └── settings-resolver.service.ts    # SettingsResolver
├── navigation/
│   ├── navigation-manager.service.ts   # NavigationManagerService
│   ├── embeddable-component-registry.ts # EmbeddableComponentRegistry
│   ├── toolbar-manager.service.ts      # ToolbarManagerService
│   └── breadcrumb.service.ts           # BreadcrumbService
├── communication/
│   ├── module-provider-registry.ts     # ModuleProviderRegistry
│   ├── module-consumer-resolver.ts     # ModuleConsumerResolver
│   ├── cross-module-action.service.ts  # CrossModuleActionService
│   └── asset-sharing.service.ts        # AssetSharingService
├── bootstrap/
│   ├── browser-bootstrapper.ts         # BrowserBootstrapper
│   ├── config-merger.service.ts        # ConfigMergerService
│   ├── startup-sequencer.ts            # StartupSequencer
│   └── module-activator.ts             # ModuleActivator
├── validation/
│   ├── contract-validator.ts           # ContractValidator
│   ├── dependency-validator.ts         # DependencyValidator
│   ├── browser-compatibility-checker.ts # BrowserCompatibilityChecker
│   └── security-validator.ts           # SecurityValidator
├── orchestration/
│   ├── workflow-coordinator.ts         # WorkflowCoordinator
│   ├── async-operation-coordinator.ts  # AsyncOperationCoordinator
│   ├── event-coordinator.ts            # EventCoordinator
│   └── state-coordinator.ts            # StateCoordinator
├── monitoring/
│   ├── browser-performance-monitor.ts  # BrowserPerformanceMonitor
│   ├── memory-usage-monitor.ts         # MemoryUsageMonitor
│   ├── network-monitor.ts              # NetworkMonitor
│   └── ux-metrics.service.ts           # UserExperienceMetrics
├── models/
│   ├── dependency-graph.ts             # DependencyGraph - Grafo de dependencias entre módulos
│   ├── browser-lifecycle-state.ts      # BrowserLifecycleState - Estados del ciclo de vida
│   ├── local-module-config.ts          # LocalModuleConfig - Configuración específica por módulo
│   ├── navigation-config.ts            # NavigationConfig - Configuración de navegación
│   ├── embeddable-component.ts         # EmbeddableComponent - Componentes embebibles
│   └── performance-metrics.ts          # PerformanceMetrics - Métricas de rendimiento
├── workers/
│   ├── dependency-resolver.worker.ts   # DependencyResolverWorker
│   └── performance-analyzer.worker.ts  # PerformanceAnalyzerWorker
└── utils/
    ├── browser-feature-detector.ts     # BrowserFeatureDetector
    ├── component-embedder.ts           # ComponentEmbedder
    └── module-cache-manager.ts         # ModuleCacheManager

Dependencias Técnicas

Dependencias de Desarrollo

{
  "@libs-core/module-base": "^1.0.0",
  "@libs-core/action-registry": "^1.0.0",
  "@libs-core/data-access": "^1.0.0",
  "@libs-core/event-system": "^1.0.0",
  "@libs-core/log-system": "^1.0.0",
  "@libs-core/security": "^1.0.0",
  "@gograb-space/utilities": "^1.0.0",
  "@angular/core": "^20.0.0",
  "rxjs": "^7.8.0",
  "@ngxs/store": "^3.8.1"
}

Peer Dependencies

{
  "@angular/common": "^20.0.0",
  "@angular/core": "^20.0.0",
  "rxjs": "^7.8.0"
}

Cronograma de Implementación

Semana 1: Fundamentos y Core Services

Semana 2: Configuración API y Gestión de Módulos

Semana 3: Navegación y Comunicación

Semana 4: Orchestration y Performance

Semana 5: Testing e Integración

Implementación Clave

IntegratorService - Orquestador Principal

@Injectable({ providedIn: 'root' })
export class IntegratorService {
  private readonly modulesState = signal<Map<string, ModuleLifecycleState>>(new Map());

  constructor(private configService: ModuleConfigurationService, private registry: ModuleRegistryService, private lifecycleManager: LifecycleManagerService, private eventSystem: EventSystem, private logSystem: LogSystem) {}

  async initializeApplication(): Promise<void> {
    this.eventSystem.emit(new ApplicationInitializingEvent());

    try {
      // 1. Cargar configuración del API usando Angular HttpClient
      const moduleConfig = await this.configService.getModuleConfiguration();

      // 2. Obtener módulos auto-registrados (usando decoradores @AutoRegister)
      const registeredModules = this.registry.getModules();

      // 3. Gestionar ciclo de vida basado en configuración usando signals
      const activationPromises = registeredModules.map(async (module) => {
        const config = moduleConfig[module.manifest.id];
        await this.manageModuleLifecycle(module, config);
      });

      await Promise.all(activationPromises);

      this.eventSystem.emit(new ApplicationInitializedEvent());
      this.logSystem.info('Application initialized successfully');
    } catch (error) {
      this.logSystem.error('Failed to initialize application', { error });
      throw error;
    }
  }

  private async manageModuleLifecycle(module: BrowserModuleContract, config: ModuleConfig): Promise<void> {
    try {
      if (config?.enabled) {
        this.logSystem.debug(`Activating module: ${module.manifest.id}`);
        this.modulesState.update((state) => new Map(state.set(module.manifest.id, 'configuring')));

        // Configurar módulo con parámetros específicos
        await module.configure(config);
        this.modulesState.update((state) => new Map(state.set(module.manifest.id, 'initializing')));

        // Inicializar módulo (registra acciones, servicios, etc.)
        await module.initialize();
        this.modulesState.update((state) => new Map(state.set(module.manifest.id, 'starting')));

        // Iniciar módulo (prepara para uso)
        await module.start();
        this.modulesState.update((state) => new Map(state.set(module.manifest.id, 'running')));

        this.eventSystem.emit(new ModuleActivatedEvent(module.manifest.id));
      } else {
        this.logSystem.debug(`Module disabled: ${module.manifest.id}`);
        // Solo destruir si ya estaba cargado
        if (module.isInitialized()) {
          await module.destroy();
        }
      }
    } catch (error) {
      this.modulesState.update((state) => new Map(state.set(module.manifest.id, 'error')));
      this.logSystem.error(`Failed to manage lifecycle for module: ${module.manifest.id}`, { error });
      // Continuar con otros módulos incluso si uno falla
    }
  }

  // Computed signal para estado general de la aplicación
  readonly applicationStatus = computed(() => {
    const states = Array.from(this.modulesState().values());
    if (states.some((state) => state === 'error')) return 'error';
    if (states.every((state) => state === 'running' || state === 'disabled')) return 'ready';
    return 'initializing';
  });
}

ModuleConfigurationService - Gestión de Configuración API

@Injectable({ providedIn: 'root' })
export class ModuleConfigurationService {
  constructor(private configService: AppConfigService) {}

  async getModuleConfiguration(): Promise<Record<string, ModuleConfig>> {
    return await this.configService.getModuleConfiguration();
  }

  async getModuleConfig(moduleId: string): Promise<ModuleConfig | undefined> {
    const config = await this.getModuleConfiguration();
    return config[moduleId];
  }

  validateModuleConfig(moduleId: string, config: ModuleConfig): ValidationResult {
    const errors: string[] = [];

    if (config.enabled && !config.requiredDependencies?.every((dep) => this.isDependencyAvailable(dep))) {
      errors.push(`Missing required dependencies for module: ${moduleId}`);
    }

    return { isValid: errors.length === 0, errors };
  }
}

CrossModuleActionService - Comunicación entre Módulos

@Injectable({ providedIn: 'root' })
export class CrossModuleActionService {
  constructor(private actionRegistry: ActionRegistryService, private moduleRegistry: ModuleRegistryService, private assetSharing: AssetSharingService) {}

  async executeCrossModuleAction(fromModuleId: string, targetModuleId: string, actionId: string, parameters: any): Promise<any> {
    const targetModule = this.moduleRegistry.getModule(targetModuleId);
    if (!targetModule) {
      throw new Error(`Target module ${targetModuleId} not loaded`);
    }

    await this.validateCrossModulePermissions(fromModuleId, targetModuleId, actionId);

    const fullActionId = `${targetModuleId}.${actionId}`;
    return this.actionRegistry.execute(fullActionId, parameters);
  }
}

Integración con el Ecosistema

Integración con Action Registry

// Registro automático de acciones de módulos
async initializeModule(module: ModuleInstance): Promise<void> {
  const actions = await this.actionDiscovery.discover(module);
  await this.actionRegistry.registerBatch(actions);
  await this.setupActionSecurity(actions, module.permissions);
}

Integración con Data Access

// Configuración de contexto de datos por módulo
async setupDataContext(module: ModuleInstance): Promise<void> {
  const tenantConfig = module.manifest.tenantConfig;
  await this.tenantContext.configure(module.id, tenantConfig);
  await this.dataAccess.registerModuleRepositories(module);
  await this.stateManager.registerModuleStates(module);
}

Integración con Security

// Validación de permisos cross-module
async validateCrossModulePermissions(fromModuleId: string, targetModuleId: string, actionId: string): Promise<void> {
  const requiredPermission = `cross-module:${targetModuleId}.${actionId}`;

  if (!this.permissionService.hasPermission(requiredPermission)) {
    throw new PermissionError(`Insufficient permissions for cross-module action`);
  }
}

Consideraciones Técnicas

Angular 20 Features

Performance en Navegador

Security

Métricas de Éxito

Cobertura de Código

Performance

Calidad de Código

Comandos de Desarrollo

# Ejecutar tests
nx test module-integrator

# Linting
nx lint module-integrator

# Build
nx build module-integrator

# Visualizar dependencias
nx graph

Este plan proporciona una hoja de ruta completa para la implementación del Module Integrator, asegurando una integración perfecta con el ecosistema existente y una arquitectura robusta para la gestión del ciclo de vida completo de módulos en GoGrab Space.