shared-lib-angular 1.0.0

package/src/lib/config/app.config.ts

@@ -0,0 +1,320 @@
+import { AppConfiguration, ConfigServerResponse } from '../models/app-config.interface';
+import { FrmkLibraryConfig, DEFAULT_LIBRARY_CONFIG } from '../models/library-config.interface';
+
+// Variable global para almacenar la configuración actual
+let currentAppConfig: AppConfiguration | null = null;
+
+// Variable global para almacenar la configuración de la librería
+let libraryConfig: FrmkLibraryConfig | null = null;
+
+/**
+ * Inicializa la configuración de la librería con los valores proporcionados por la aplicación
+ * Esta función debe ser llamada antes de usar cualquier servicio de la librería
+ * 
+ * @param config Configuración proporcionada por la aplicación consumidora
+ */
+export function initializeLibraryConfig(config: FrmkLibraryConfig): void {
+  libraryConfig = {
+    ...DEFAULT_LIBRARY_CONFIG,
+    ...config
+  } as FrmkLibraryConfig;
+  
+  // Resetear la configuración actual para que se reconstruya con los nuevos valores
+  currentAppConfig = null;
+}
+
+/**
+ * Obtiene la configuración de la librería
+ * Lanza error si no ha sido inicializada
+ */
+export function getLibraryConfig(): FrmkLibraryConfig {
+  if (!libraryConfig) {
+    throw new Error(
+      '[FRMK] La librería no ha sido configurada. ' +
+      'Debe proporcionar FRMK_LIBRARY_CONFIG en los providers de su aplicación. ' +
+      'Ejemplo: provideFrmkConfig({ configServerHost: "...", frontendId: "..." })'
+    );
+  }
+  return libraryConfig;
+}
+
+/**
+ * Verifica si la librería ha sido configurada
+ */
+export function isLibraryConfigured(): boolean {
+  return libraryConfig !== null;
+}
+
+// Función para crear la configuración por defecto usando los valores de la librería
+function createDefaultAppConfig(): AppConfiguration {
+  const libConfig = getLibraryConfig();
+  
+  return {
+    hosts: {  
+      configServer: libConfig.configServerHost,
+      authServer: '', // Leído desde Config Server
+      keycloak: '', // Leído desde Config Server
+      localApp: '' // Leído desde Config Server
+    },
+    paths: {
+      configService: libConfig.configServicePath || '/api/v1/config/service',
+      realm: libConfig.realm || 'realm-to-create'
+    },
+    configServer: {
+      url: '', // Se construirá dinámicamente
+      frontend: libConfig.frontendId
+    },
+    auth: {
+      issuer: '', // Se construirá dinámicamente
+      loginUrl: '', // Se construirá dinámicamente
+      tokenEndpoint: '', // Se construirá dinámicamente
+      userinfoEndpoint: '', // Se construirá dinámicamente
+      logoutUrl: '', // Se construirá dinámicamente
+      clientId: '',
+      redirectUri: '', // Se construirá dinámicamente
+      postLogoutRedirectUri: '', // Se construirá dinámicamente
+      silentRefreshRedirectUri: '', // Se construirá dinámicamente
+      scope: 'openid email profile'
+    },
+    authorization: {
+      baseUrl: '',
+      verifyEndpoint: '/api/v1/authz/verify-groups',
+      hierarchyEndpoint: '/api/v1/authz/hierarchy-by-component-and-groups',
+    },
+    environment: {
+      production: libConfig.production ?? false,
+      requireHttps: libConfig.requireHttps ?? true,
+      showDebugInformation: libConfig.showDebugInformation ?? false
+    }
+  };
+}
+
+// Getter para obtener la configuración por defecto (lazy initialization)
+export function getDefaultAppConfig(): AppConfiguration {
+  return createDefaultAppConfig();
+}
+
+// Función para mapear la configuración del config server a la configuración de la aplicación
+export function mapConfigServerResponse(configServerData: ConfigServerResponse): Partial<AppConfiguration> {
+  const mappedConfig: Partial<AppConfiguration> = {};
+  const defaultConfig = getDefaultAppConfig();
+  
+  // Mapear Auth URL
+  configureAuthServer();
+
+  // Mapear client ID
+  initializeClientId();
+
+  // Mapear realm
+  initializeRealmMapping();
+
+  // Mapear URL de autorización (authServer)
+  initializeAuthorizationConfig();
+
+  // Mapear scope de autorización
+  initializeAuthScope();
+
+  // Mapear keycloak URL
+  initializeKeycloakHost();
+
+  // Mapear callback URL (local app host)
+  configureLocalAppCallback(); 
+
+  // Mapear callback URL (local app host)
+  initializeHttpsSettings(); 
+
+  return mappedConfig;
+
+  function initializeHttpsSettings() {
+    if (configServerData["security.url.https"]) {
+      mappedConfig.environment = {
+        ...defaultConfig.environment,
+        ...(mappedConfig.environment || {}),
+        requireHttps: configServerData["security.url.https"]
+      };
+    }
+  }
+
+  function configureLocalAppCallback() {
+    if (configServerData["security.url.callback"]) {
+      mappedConfig.hosts = {
+        ...defaultConfig.hosts,
+        ...(mappedConfig.hosts || {}),
+        localApp: configServerData["security.url.callback"]
+      };
+    }
+  }
+
+  function initializeKeycloakHost() {
+    if (configServerData["security.url.keycloak"]) {
+      mappedConfig.hosts = {
+        ...defaultConfig.hosts,
+        ...(mappedConfig.hosts || {}),
+        keycloak: configServerData["security.url.keycloak"]
+      };
+    }
+  }
+
+  function initializeAuthScope() {
+    if (configServerData["security.scope"]) {
+      mappedConfig.auth = {
+        ...defaultConfig.auth,
+        ...(mappedConfig.auth || {}),
+        scope: configServerData["security.scope"]
+      };
+    }
+  }
+
+  function initializeAuthorizationConfig() {
+    if (configServerData["security.url.authz"]) {
+      mappedConfig.authorization = {
+        ...defaultConfig.authorization,
+        ...(mappedConfig.authorization || {}),
+        baseUrl: configServerData["security.url.authz"]
+      };
+    }
+  }
+
+  function initializeRealmMapping() {
+    if (configServerData["security.realm"]) {
+      mappedConfig.paths = {
+        ...defaultConfig.paths,
+        ...(mappedConfig.paths || {}),
+        realm: configServerData["security.realm"]
+      };
+    }
+  }
+
+  function initializeClientId() {
+    if (configServerData["quarkus.oidc.client-id"]) {
+      mappedConfig.auth = {
+        ...defaultConfig.auth,
+        ...(mappedConfig.auth || {}),
+        clientId: configServerData["quarkus.oidc.client-id"]
+      };
+    }
+  }
+
+  function configureAuthServer() {
+    if (configServerData["security.url.auth"]) {
+      mappedConfig.hosts = {
+        ...defaultConfig.hosts,
+        ...(mappedConfig.hosts || {}),
+        authServer: configServerData["security.url.auth"]
+      };
+    }
+  }
+}
+
+/**
+ * Función para establecer la configuración actual con datos del config server
+ * Esta función debe ser llamada desde el ConfigService después de cargar la configuración
+ */
+export function setCurrentAppConfig(configServerData?: ConfigServerResponse): void {
+  currentAppConfig = getAppConfigWithServerData(configServerData);
+}
+
+/**
+ * Función para obtener la configuración actual
+ * Si no se ha establecido una configuración, devuelve la configuración por defecto
+ */
+export function getCurrentAppConfig(): AppConfiguration {
+  return currentAppConfig || getAppConfig();
+}
+
+// Función para obtener la configuración con posibles sobrescrituras de variables de entorno
+export function getAppConfig(): AppConfiguration {
+  const config = { ...getDefaultAppConfig() };
+
+  // Construir URLs dinámicamente
+  const protocol = 'https';
+  const localProtocol = config.environment.requireHttps ? 'https' : 'http';
+  
+  // Config Server URL
+  config.configServer.url = `${localProtocol}://${config.hosts.configServer}${config.paths.configService}`;
+  
+  // Auth URLs
+  config.auth.issuer = `${protocol}://${config.hosts.keycloak}/realms/${config.paths.realm}`;
+  config.auth.loginUrl = `${protocol}://${config.hosts.keycloak}/realms/${config.paths.realm}/protocol/openid-connect/auth`;
+  config.auth.tokenEndpoint = `${localProtocol}://${config.hosts.authServer}/oidc/realm/${config.paths.realm}/protocol/openid-connect/token`;
+  config.auth.userinfoEndpoint = `${localProtocol}://${config.hosts.authServer}/oidc/realm/${config.paths.realm}/protocol/openid-connect/userinfo`;
+  config.auth.logoutUrl = `${localProtocol}://${config.hosts.authServer}/oidc/realm/${config.paths.realm}/protocol/openid-connect/logout`;
+   
+  // Redirect URLs (locales)
+  const currentOrigin = globalThis.window?.location?.origin ?? config.hosts.localApp;
+  config.auth.redirectUri = `${currentOrigin}/login`;
+  config.auth.postLogoutRedirectUri = `${currentOrigin}/login`;
+  
+  // Authorization URL
+  config.authorization.baseUrl = `${localProtocol}://${config.authorization.baseUrl}`;
+  
+  return config;
+}
+
+// Función para obtener la configuración aplicando primero la del config server y luego variables de entorno
+export function getAppConfigWithServerData(configServerData?: ConfigServerResponse): AppConfiguration {
+  let config = { ...getDefaultAppConfig() };
+  
+  // Aplicar configuración del config server si está disponible
+  if (configServerData) {
+    const serverMappedConfig = mapConfigServerResponse(configServerData);
+    config = mergeConfigurations(config, serverMappedConfig);
+  }
+  
+  // Construir URLs dinámicamente
+  config = buildDynamicUrls(config);
+  
+  return config;
+}
+
+// Función auxiliar para fusionar configuraciones
+function mergeConfigurations(base: AppConfiguration, override: Partial<AppConfiguration>): AppConfiguration {
+  const merged = { ...base };
+  
+  if (override.hosts) {
+    merged.hosts = { ...merged.hosts, ...override.hosts };
+  }
+  if (override.paths) {
+    merged.paths = { ...merged.paths, ...override.paths };
+  }
+  if (override.configServer) {
+    merged.configServer = { ...merged.configServer, ...override.configServer };
+  }
+  if (override.auth) {
+    merged.auth = { ...merged.auth, ...override.auth };
+  }
+  if (override.authorization) {
+    merged.authorization = { ...merged.authorization, ...override.authorization };
+  }
+  if (override.environment) {
+    merged.environment = { ...merged.environment, ...override.environment };
+  }
+  
+  return merged;
+}
+
+// Función para construir URLs dinámicamente
+function buildDynamicUrls(config: AppConfiguration): AppConfiguration {
+  const protocol = 'https';
+  const localProtocol = config.environment.requireHttps ? 'https' : 'http';
+  
+  // Config Server URL
+  config.configServer.url = `${protocol}://${config.hosts.configServer}${config.paths.configService}`;
+  
+  // Auth URLs
+  config.auth.issuer = `${protocol}://${config.hosts.keycloak}/realms/${config.paths.realm}`;
+  config.auth.loginUrl = `${protocol}://${config.hosts.keycloak}/realms/${config.paths.realm}/protocol/openid-connect/auth`;
+  config.auth.tokenEndpoint = `${localProtocol}://${config.hosts.authServer}/oidc/realm/${config.paths.realm}/protocol/openid-connect/token`;
+  config.auth.userinfoEndpoint = `${localProtocol}://${config.hosts.authServer}/oidc/realm/${config.paths.realm}/protocol/openid-connect/userinfo`;
+  config.auth.logoutUrl = `${localProtocol}://${config.hosts.authServer}/oidc/realm/${config.paths.realm}/protocol/openid-connect/logout`;
+  
+  // Redirect URLs (locales)
+  const currentOrigin = globalThis.window?.location?.origin ?? config.hosts.localApp;
+  config.auth.redirectUri = `${currentOrigin}/login`;
+  config.auth.postLogoutRedirectUri = `${currentOrigin}/login`;
+
+  // Authorization URL
+  config.authorization.baseUrl = `${localProtocol}://${config.authorization.baseUrl}`;
+  
+  return config;
+}

package/src/lib/config/authentication.config.ts

@@ -0,0 +1,59 @@
+import { AuthConfig } from 'angular-oauth2-oidc';
+import { getCurrentAppConfig } from './app.config';
+
+/**
+ * Función para obtener la configuración de autenticación actual
+ * Esta función se evalúa cada vez que se llama, por lo que siempre tendrá la configuración más reciente
+ */
+export function getAuthConfig(): AuthConfig {
+  const appConfig = getCurrentAppConfig();
+
+  return {
+    // URL base del servidor de identidad
+    issuer: appConfig.auth.issuer,
+   
+    // URLs específicas para evitar discovery document
+    loginUrl: appConfig.auth.loginUrl,
+    tokenEndpoint: appConfig.auth.tokenEndpoint,
+    userinfoEndpoint: appConfig.auth.userinfoEndpoint,
+    logoutUrl: appConfig.auth.logoutUrl,
+    
+    // IMPORTANTE: URLs de redirección completas
+    redirectUri: appConfig.auth.redirectUri,
+    postLogoutRedirectUri: appConfig.auth.postLogoutRedirectUri,
+
+    // Configuración del cliente
+    clientId: appConfig.auth.clientId,
+
+    // Configuración OAuth
+    responseType: 'code',
+    scope: appConfig.auth.scope,
+    
+    // Configuraciones para desarrollo
+    disableAtHashCheck: true,
+    requireHttps: appConfig.environment.requireHttps,
+    showDebugInformation: appConfig.environment.showDebugInformation,
+    strictDiscoveryDocumentValidation: false,
+    skipIssuerCheck: true,
+
+    // IMPORTANTE: Configuraciones para manejar state y session_state
+    requestAccessToken: true,
+    customQueryParams: {},
+
+    // Timeouts
+    silentRefreshTimeout: 5000,
+    timeoutFactor: 0.25,
+    
+    // Session checks
+    sessionChecksEnabled: false,
+    clearHashAfterLogin: false,
+
+    // Configuración OIDC
+    oidc: true
+  };
+}
+
+// Mantener la exportación original para compatibilidad
+export function getAuthConfigEnv(): AuthConfig {
+  return getAuthConfig();
+}

package/src/lib/config/index.ts

@@ -0,0 +1,2 @@
+export * from './app.config';
+export * from './authentication.config';

package/src/lib/guards/authorization.guard.ts

@@ -0,0 +1,31 @@
+import { inject } from '@angular/core';
+import { CanActivateFn, Router } from '@angular/router';
+import { AuthService } from '../services/authentication.service';
+import { map, take } from 'rxjs/operators';
+
+export const authGuard: CanActivateFn = (route, state) => {
+  const authService = inject(AuthService);
+  const router = inject(Router);
+
+  const handleAuthenticated = (): boolean => {
+    return true;
+  };
+
+  const handleUnauthenticated = (currentUrl: string): boolean => {
+    if (currentUrl !== '/login' && !currentUrl.includes('/login')) {
+      router.navigate(['/login'], { 
+        queryParams: { returnUrl: currentUrl } 
+      });
+    }
+    return false;
+  }; 
+
+  return authService.isAuthenticated$.pipe(
+    take(1),
+    map(isAuthenticated => {
+      return isAuthenticated 
+        ? handleAuthenticated() 
+        : handleUnauthenticated(state.url);
+    })
+  );
+};

package/src/lib/guards/index.ts

@@ -0,0 +1 @@
+export * from './authorization.guard';

package/src/lib/models/app-config.interface.ts

@@ -0,0 +1,61 @@
+/**
+ * Main application configuration interface
+ */
+export interface AppConfiguration {
+  hosts: {
+    configServer: string;
+    authServer: string;
+    keycloak: string;
+    localApp: string;
+  };
+  paths: {
+    configService: string;
+    realm: string;
+  };
+  configServer: {
+    url: string;
+    frontend: string;
+  };
+  auth: {
+    issuer: string;
+    loginUrl: string;
+    tokenEndpoint: string;
+    userinfoEndpoint: string;
+    logoutUrl: string;
+    clientId: string;
+    redirectUri: string;
+    postLogoutRedirectUri: string;
+    silentRefreshRedirectUri: string;
+    scope: string;
+  };
+  authorization: {
+    baseUrl: string;
+    verifyEndpoint: string;
+    hierarchyEndpoint: string;
+  };
+  environment: {
+    production: boolean;
+    requireHttps: boolean;
+    showDebugInformation: boolean;
+  };
+}
+
+/**
+ * Interface for the response from the config server
+ */
+export interface ConfigServerResponse {
+  "quarkus.oidc.enabled": string;
+  "quarkus.oidc.client-id": string;
+  "security.realm": string;
+  "security.url.callback": string;
+  "dev.language": string;
+  "security.url.authz": string;
+  "security.scope": string;
+  "query.timestamp": string;
+  "security.url.keycloak": string;
+  "security.auth": string;
+  "quarkus.oidc.credentials.secret": string;
+  "service.config": string;
+  "security.url.auth": string;
+  "security.url.https": boolean;
+}

package/src/lib/models/authorization.interface.ts

@@ -0,0 +1,40 @@
+/**
+ * Request interface for authorization verification
+ */
+export interface AuthorizationRequest {
+  groupIds: string[];
+  componentId: string;
+  resourcePath: string;
+  operationName: string;
+}
+
+/**
+ * Response interface from authorization service
+ */
+export interface AuthorizationResponse {
+  hasPermission: boolean;
+  conditions?: any;
+  attributes?: any;
+  resourceCode: string;
+}
+
+/**
+ * Interface for menu hierarchy items
+ */
+export interface MenuHierarchyItem {
+  name: string;
+  code: string;
+  path: string;
+  attributes: string;
+  level: number;
+  hasParent: boolean;
+  children?: MenuHierarchyItem[];
+}
+
+/**
+ * Request interface for menu hierarchy
+ */
+export interface MenuHierarchyRequest {
+  componentId: string;
+  groupIds: string;
+}

package/src/lib/models/index.ts

@@ -0,0 +1,4 @@
+export * from './login-config.interface';
+export * from './app-config.interface';
+export * from './authorization.interface';
+export * from './library-config.interface';

package/src/lib/models/library-config.interface.ts

@@ -0,0 +1,104 @@
+import { InjectionToken } from '@angular/core';
+
+/**
+ * Configuración de la librería que debe ser proporcionada por la aplicación consumidora
+ * Estos valores son críticos y deben ser configurados al inicializar la librería
+ */
+export interface FrmkLibraryConfig {
+  /**
+   * URL del servidor de configuración (Config Server)
+   * Ejemplo: 'config-server.example.com' o 'localhost:8080'
+   */
+  configServerHost: string;
+
+  /**
+   * Identificador del frontend en el Config Server
+   * Este valor identifica la aplicación para obtener su configuración específica
+   * Ejemplo: 'mi-aplicacion-frontend'
+   */
+  frontendId: string;
+
+  /**
+   * Ruta del servicio de configuración (opcional)
+   * Por defecto: '/api/v1/config/service'
+   */
+  configServicePath?: string;
+
+  /**
+   * Realm de autenticación (opcional)
+   * Por defecto se obtiene del Config Server
+   */
+  realm?: string;
+
+  /**
+   * Si es ambiente de producción (opcional)
+   * Por defecto: false
+   */
+  production?: boolean;
+
+  /**
+   * Si requiere HTTPS (opcional)
+   * Por defecto: true
+   */
+  requireHttps?: boolean;
+
+  /**
+   * Mostrar información de debug (opcional)
+   * Por defecto: false
+   */
+  showDebugInformation?: boolean;
+}
+
+/**
+ * Configuración por defecto de la librería
+ */
+export const DEFAULT_LIBRARY_CONFIG: Partial<FrmkLibraryConfig> = {
+  configServicePath: '/api/v1/config/service',
+  production: false,
+  requireHttps: true,
+  showDebugInformation: false
+};
+
+/**
+ * Token de inyección para la configuración de la librería
+ * 
+ * @example
+ * // En el app.config.ts o app.module.ts de la aplicación consumidora:
+ * providers: [
+ *   {
+ *     provide: FRMK_LIBRARY_CONFIG,
+ *     useValue: {
+ *       configServerHost: 'config-server.miempresa.com',
+ *       frontendId: 'mi-aplicacion-frontend',
+ *       production: environment.production
+ *     }
+ *   }
+ * ]
+ */
+export const FRMK_LIBRARY_CONFIG = new InjectionToken<FrmkLibraryConfig>('FrmkLibraryConfig');
+
+/**
+ * Función helper para crear la configuración de la librería
+ * 
+ * @example
+ * // En el app.config.ts:
+ * import { provideFrmkConfig } from '@mh-dinafi-frmk/shared-lib-angular';
+ * 
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideFrmkConfig({
+ *       configServerHost: environment.configServerHost,
+ *       frontendId: 'mi-aplicacion'
+ *     })
+ *   ]
+ * };
+ */
+export function provideFrmkConfig(config: FrmkLibraryConfig) {
+  return {
+    provide: FRMK_LIBRARY_CONFIG,
+    useValue: {
+      ...DEFAULT_LIBRARY_CONFIG,
+      ...config
+    }
+  };
+}