shared-lib-angular 1.0.0 → 1.0.1

package/src/lib/services/authorization.service.spec.ts

@@ -1,239 +0,0 @@
-/**
- * AuthorizationService Unit Tests
- * ================================
- * Pruebas unitarias para el servicio de autorización
- */
-
-import { TestBed } from '@angular/core/testing';
-import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
-import { AuthorizationService } from './authorization.service';
-import { AuthorizationRequest, AuthorizationResponse, MenuHierarchyItem } from '../models';
-
-describe('AuthorizationService', () => {
-  let service: AuthorizationService;
-  let httpMock: HttpTestingController;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      imports: [HttpClientTestingModule],
-      providers: [AuthorizationService]
-    });
-
-    service = TestBed.inject(AuthorizationService);
-    httpMock = TestBed.inject(HttpTestingController);
-  });
-
-  afterEach(() => {
-    httpMock.verify();
-  });
-
-  describe('Inicialización', () => {
-    it('debería crear el servicio', () => {
-      expect(service).toBeTruthy();
-    });
-  });
-
-  describe('verifyPermission', () => {
-    it('debería verificar permisos y retornar respuesta autorizada', (done) => {
-      const request: AuthorizationRequest = {
-        groups: ['admin-group'],
-        component: 'dashboard',
-        action: 'view'
-      };
-
-      const mockResponse: AuthorizationResponse = {
-        authorized: true,
-        message: 'Access granted'
-      };
-
-      service.verifyPermission(request).subscribe((response) => {
-        expect(response.authorized).toBe(true);
-        expect(response.message).toBe('Access granted');
-        done();
-      });
-
-      const req = httpMock.expectOne((r) => r.url.includes('/authz/verify-groups'));
-      expect(req.request.method).toBe('POST');
-      req.flush(mockResponse);
-    });
-
-    it('debería manejar respuesta no autorizada', (done) => {
-      const request: AuthorizationRequest = {
-        groups: ['guest-group'],
-        component: 'admin-panel',
-        action: 'edit'
-      };
-
-      const mockResponse: AuthorizationResponse = {
-        authorized: false,
-        message: 'Access denied'
-      };
-
-      service.verifyPermission(request).subscribe((response) => {
-        expect(response.authorized).toBe(false);
-        done();
-      });
-
-      const req = httpMock.expectOne((r) => r.url.includes('/authz/verify-groups'));
-      req.flush(mockResponse);
-    });
-
-    it('debería manejar errores HTTP', (done) => {
-      const request: AuthorizationRequest = {
-        groups: ['admin-group'],
-        component: 'dashboard',
-        action: 'view'
-      };
-
-      service.verifyPermission(request).subscribe({
-        error: (error) => {
-          expect(error).toBeTruthy();
-          done();
-        }
-      });
-
-      const req = httpMock.expectOne((r) => r.url.includes('/authz/verify-groups'));
-      req.flush('Server Error', { status: 500, statusText: 'Internal Server Error' });
-    });
-  });
-
-  describe('getMenuHierarchy', () => {
-    it('debería obtener la jerarquía de menú', (done) => {
-      const groups = ['admin-group'];
-      const component = 'main-menu';
-
-      const mockHierarchy: MenuHierarchyItem[] = [
-        {
-          id: '1',
-          label: 'Dashboard',
-          icon: 'dashboard',
-          route: '/dashboard',
-          order: 1,
-          children: []
-        },
-        {
-          id: '2',
-          label: 'Settings',
-          icon: 'settings',
-          route: '/settings',
-          order: 2,
-          children: [
-            {
-              id: '2.1',
-              label: 'Profile',
-              icon: 'person',
-              route: '/settings/profile',
-              order: 1,
-              children: []
-            }
-          ]
-        }
-      ];
-
-      service.getMenuHierarchy(groups, component).subscribe((hierarchy) => {
-        expect(hierarchy.length).toBe(2);
-        expect(hierarchy[0].label).toBe('Dashboard');
-        expect(hierarchy[1].children?.length).toBe(1);
-        done();
-      });
-
-      const req = httpMock.expectOne((r) => r.url.includes('/authz/hierarchy-by-component-and-groups'));
-      expect(req.request.method).toBe('POST');
-      req.flush(mockHierarchy);
-    });
-
-    it('debería retornar array vacío cuando no hay menús', (done) => {
-      const groups = ['guest-group'];
-      const component = 'admin-menu';
-
-      service.getMenuHierarchy(groups, component).subscribe((hierarchy) => {
-        expect(hierarchy).toEqual([]);
-        done();
-      });
-
-      const req = httpMock.expectOne((r) => r.url.includes('/authz/hierarchy-by-component-and-groups'));
-      req.flush([]);
-    });
-  });
-
-  describe('getRootMenuItems', () => {
-    it('debería filtrar solo items de nivel raíz', () => {
-      const items: MenuHierarchyItem[] = [
-        { id: '1', label: 'Root 1', icon: '', route: '/r1', order: 1, children: [] },
-        { id: '2', label: 'Root 2', icon: '', route: '/r2', order: 2, children: [] }
-      ];
-
-      const rootItems = service.getRootMenuItems(items);
-      expect(rootItems.length).toBe(2);
-    });
-  });
-
-  describe('hasChildren', () => {
-    it('debería retornar true si el item tiene hijos', () => {
-      const item: MenuHierarchyItem = {
-        id: '1',
-        label: 'Parent',
-        icon: '',
-        route: '/parent',
-        order: 1,
-        children: [
-          { id: '1.1', label: 'Child', icon: '', route: '/child', order: 1, children: [] }
-        ]
-      };
-
-      expect(service.hasChildren(item)).toBe(true);
-    });
-
-    it('debería retornar false si el item no tiene hijos', () => {
-      const item: MenuHierarchyItem = {
-        id: '1',
-        label: 'Leaf',
-        icon: '',
-        route: '/leaf',
-        order: 1,
-        children: []
-      };
-
-      expect(service.hasChildren(item)).toBe(false);
-    });
-
-    it('debería retornar false si children es undefined', () => {
-      const item: MenuHierarchyItem = {
-        id: '1',
-        label: 'Leaf',
-        icon: '',
-        route: '/leaf',
-        order: 1
-      } as MenuHierarchyItem;
-
-      expect(service.hasChildren(item)).toBe(false);
-    });
-  });
-
-  describe('verifyMultiplePermissions', () => {
-    it('debería verificar múltiples permisos', (done) => {
-      const requests: AuthorizationRequest[] = [
-        { groups: ['admin'], component: 'comp1', action: 'view' },
-        { groups: ['admin'], component: 'comp2', action: 'edit' }
-      ];
-
-      const mockResponses: AuthorizationResponse[] = [
-        { authorized: true, message: 'OK' },
-        { authorized: false, message: 'Denied' }
-      ];
-
-      service.verifyMultiplePermissions(requests).subscribe((responses) => {
-        expect(responses.length).toBe(2);
-        expect(responses[0].authorized).toBe(true);
-        expect(responses[1].authorized).toBe(false);
-        done();
-      });
-
-      // Responder a ambas peticiones
-      const reqs = httpMock.match((r) => r.url.includes('/authz/verify-groups'));
-      expect(reqs.length).toBe(2);
-      reqs[0].flush(mockResponses[0]);
-      reqs[1].flush(mockResponses[1]);
-    });
-  });
-});

package/src/lib/services/authorization.service.ts

@@ -1,183 +0,0 @@
-import { Injectable } from '@angular/core';
-import { HttpClient, HttpParams, HttpHeaders } from '@angular/common/http';
-import { Observable, of } from 'rxjs';
-import { catchError, map } from 'rxjs/operators';
-import { AuthService } from './authentication.service';
-import { ConfigService } from './config.service';
-import { AuthorizationRequest, AuthorizationResponse, MenuHierarchyItem } from '../models/authorization.interface';
-
-@Injectable({
-  providedIn: 'root'
-})
-export class AuthorizationService {
-
-  constructor(
-    private readonly http: HttpClient,
-    private readonly authService: AuthService,
-    private readonly configService: ConfigService
-  ) {}
-
-  /**
-   * Verifica si el usuario tiene permisos para acceder a un recurso específico
-   */
-  verifyPermission(resourcePath: string, operationName: string = 'VIEW'): Observable<boolean> {
-    const groups = this.getUserGroups();
-    const config = this.configService.getAppConfig();
-    
-    if (groups.length === 0) {
-      return of(false);
-    }
-
-    const request: AuthorizationRequest = {
-      groupIds: groups,
-      componentId: config.configServer.frontend,
-      resourcePath: resourcePath,
-      operationName: operationName
-    };
-
-    return this.checkAuthorization(request);
-  }
-
-  /**
-   * Realiza la llamada HTTP al servicio de autorización
-   */
-  private checkAuthorization(request: AuthorizationRequest): Observable<boolean> {
-    let params = new HttpParams();
-    
-    const cleanGroups = request.groupIds.map(group => group.replace(/\//g, ''));
-    const groupIdsString = cleanGroups.join(',');
-    
-    params = params.set('groupIds', groupIdsString);
-    params = params.set('componentId', request.componentId);
-    params = params.set('resourcePath', request.resourcePath);
-    params = params.set('operationName', request.operationName);
-
-    let headers = new HttpHeaders();
-
-    const url = `${this.configService.getAppConfig().authorization.baseUrl}${this.configService.getAppConfig().authorization.verifyEndpoint}`;
-
-    return this.http.get<AuthorizationResponse>(url, { 
-      params,
-      headers
-    }).pipe(
-      map(response => {
-        return response.hasPermission;
-      }),
-      catchError(() => {
-        return of(false);
-      })
-    );
-  }
-
-  /**
-   * Obtiene los grupos del usuario desde el access token
-   */
-  private getUserGroups(): string[] {
-    return this.authService.getUserGroups();
-  }
-
-  /** 
-   * Método público para obtener los grupos del usuario (útil para debugging)
-   */
-  public getUserGroupsDebug(): string[] {
-    return this.authService.getUserGroups();
-  }
-
-  /**
-   * Obtiene la jerarquía de menús basada en el componente y los grupos del usuario
-   */
-  getMenuHierarchy(): Observable<MenuHierarchyItem[]> {
-    const groups = this.getUserGroups();
-    const config = this.configService.getAppConfig();
-    
-    if (groups.length === 0) {
-      return of([]);
-    }
-
-    const cleanGroups = groups.map(group => group.replace(/\//g, ''));
-    const groupIdsString = cleanGroups.join(',');
-
-    let params = new HttpParams();
-    params = params.set('componentId',  config.configServer.frontend);
-    params = params.set('groupIds', groupIdsString);
-
-    let headers = new HttpHeaders();
-
-    const url = `${config.authorization.baseUrl}${config.authorization.hierarchyEndpoint}`;
-
-    return this.http.get<MenuHierarchyItem[]>(url, { 
-      params,
-      headers
-    }).pipe(
-      catchError(error => {
-        console.error('Error obteniendo jerarquía de menús:', error);
-        return of([]);
-      })
-    );
-  }
-
-  /**
-   * Obtiene elementos de menú de nivel raíz (level 1)
-   */
-  getRootMenuItems(menuHierarchy: MenuHierarchyItem[]): MenuHierarchyItem[] {
-    return menuHierarchy.filter(item => item.level === 1);
-  }
-
-  /**
-   * Obtiene elementos hijos de un elemento padre específico por path
-   */
-  getChildMenuItems(menuHierarchy: MenuHierarchyItem[], parentPath: string, level: number): MenuHierarchyItem[] {
-    return menuHierarchy.filter(item => 
-      item.level === level && 
-      item.hasParent && 
-      item.path.startsWith(parentPath) &&
-      item.path !== parentPath &&
-      this.isDirectChild(item.path, parentPath, level)
-    );
-  }
-
-  /**
-   * Verifica si un elemento tiene hijos
-   */
-  hasChildren(menuHierarchy: MenuHierarchyItem[], item: MenuHierarchyItem): boolean {
-    return this.getChildMenuItems(menuHierarchy, item.path, item.level + 1).length > 0;
-  }
-
-  /**
-   * Verifica si un path es hijo directo de otro path
-   */
-  private isDirectChild(childPath: string, parentPath: string, expectedLevel: number): boolean {
-    const relativePath = childPath.substring(parentPath.length);
-    const slashCount = (relativePath.match(/\//g) || []).length;
-    return slashCount === 1;
-  }
-
-  /**
-   * Verifica múltiples permisos a la vez
-   */
-  verifyMultiplePermissions(permissions: { resourcePath: string, operationName?: string }[]): Observable<{ [key: string]: boolean }> {
-    const results: { [key: string]: boolean } = {};
-    const observables = permissions.map(permission => 
-      this.verifyPermission(permission.resourcePath, permission.operationName).pipe(
-        map(authorized => ({ 
-          key: `${permission.resourcePath}_${permission.operationName || 'VIEW'}`, 
-          authorized 
-        }))
-      )
-    );
-
-    return new Observable(observer => {
-      let completed = 0;
-      observables.forEach(obs => {
-        obs.subscribe(result => {
-          results[result.key] = result.authorized;
-          completed++;
-          if (completed === observables.length) {
-            observer.next(results);
-            observer.complete();
-          }
-        });
-      });
-    });
-  }
-}

package/src/lib/services/config.service.spec.ts

@@ -1,99 +0,0 @@
-/**
- * ConfigService Unit Tests
- * =========================
- * Pruebas unitarias para el servicio de configuración
- */
-
-import { TestBed } from '@angular/core/testing';
-import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
-import { ConfigService } from './config.service';
-import { ConfigServerResponse } from '../models';
-
-describe('ConfigService', () => {
-  let service: ConfigService;
-  let httpMock: HttpTestingController;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      imports: [HttpClientTestingModule],
-      providers: [ConfigService]
-    });
-
-    service = TestBed.inject(ConfigService);
-    httpMock = TestBed.inject(HttpTestingController);
-  });
-
-  afterEach(() => {
-    httpMock.verify();
-  });
-
-  describe('Inicialización', () => {
-    it('debería crear el servicio', () => {
-      expect(service).toBeTruthy();
-    });
-
-    it('debería indicar que la configuración no está cargada inicialmente', () => {
-      expect(service.isConfigLoaded()).toBe(false);
-    });
-  });
-
-  describe('loadConfig', () => {
-    it('debería cargar la configuración desde el servidor', (done) => {
-      const mockConfigResponse: Partial<ConfigServerResponse> = {
-        'quarkus.oidc.client-id': 'test-client',
-        'security.realm': 'test-realm',
-        'security.url.keycloak': 'https://keycloak.example.com',
-        'security.url.callback': 'http://localhost:4200',
-        'security.scope': 'openid profile email',
-        'security.url.authz': 'https://authz.example.com'
-      };
-
-      service.loadConfig('http://config-server/api/config').subscribe((config) => {
-        expect(config).toBeTruthy();
-        expect(service.isConfigLoaded()).toBe(true);
-        done();
-      });
-
-      const req = httpMock.expectOne('http://config-server/api/config');
-      expect(req.request.method).toBe('GET');
-      req.flush(mockConfigResponse);
-    });
-
-    it('debería manejar errores de carga de configuración', (done) => {
-      service.loadConfig('http://config-server/api/config').subscribe({
-        error: (error) => {
-          expect(error).toBeTruthy();
-          expect(service.isConfigLoaded()).toBe(false);
-          done();
-        }
-      });
-
-      const req = httpMock.expectOne('http://config-server/api/config');
-      req.flush('Config Server Error', { status: 503, statusText: 'Service Unavailable' });
-    });
-  });
-
-  describe('get', () => {
-    it('debería retornar undefined si la configuración no está cargada', () => {
-      const value = service.get('some.key');
-      expect(value).toBeUndefined();
-    });
-  });
-
-  describe('getAll', () => {
-    it('debería retornar objeto vacío si la configuración no está cargada', () => {
-      const config = service.getAll();
-      expect(config).toEqual({});
-    });
-  });
-
-  describe('getAppConfig', () => {
-    it('debería retornar la configuración de la aplicación', () => {
-      const appConfig = service.getAppConfig();
-      expect(appConfig).toBeTruthy();
-      expect(appConfig.hosts).toBeDefined();
-      expect(appConfig.auth).toBeDefined();
-      expect(appConfig.authorization).toBeDefined();
-    });
-  });
-});

package/src/lib/services/config.service.ts

@@ -1,77 +0,0 @@
-import { Injectable } from '@angular/core';
-import { HttpClient } from '@angular/common/http';
-import { firstValueFrom } from 'rxjs';
-import { AppConfiguration, ConfigServerResponse } from '../models/app-config.interface';
-import { getAppConfig, getAppConfigWithServerData, setCurrentAppConfig } from '../config/app.config';
-
-@Injectable({ 
-  providedIn: 'root' 
-})
-export class ConfigService {
-  private configServerData: ConfigServerResponse | null = null;
-  private finalAppConfig: AppConfiguration | null = null;
-  private isLoaded = false;
-  private readonly initialAppConfig = getAppConfig();
-
-  constructor(private readonly http: HttpClient) {}
-
-  /**
-   * Carga la configuración desde el config-server
-   */
-  async loadConfig(): Promise<void> {
-    try {
-      const url = `${this.initialAppConfig.configServer.url}/${this.initialAppConfig.configServer.frontend}`;
-      
-      this.configServerData = await firstValueFrom(
-        this.http.get<ConfigServerResponse>(url)
-      );
-      
-      this.finalAppConfig = getAppConfigWithServerData(this.configServerData);
-      
-      // IMPORTANTE: Establecer la configuración actual para que esté disponible globalmente
-      setCurrentAppConfig(this.configServerData);
-      
-      this.isLoaded = true;
-    } catch (error) {
-      console.log(`Exception while loading config: ${error}`);
-      this.finalAppConfig = this.initialAppConfig;
-      setCurrentAppConfig();
-      this.isLoaded = true;
-    }
-  }
-
-  /**
-   * Obtiene un valor de configuración por clave del config server
-   */
-  get(key: string): string | boolean | undefined {
-    return this.configServerData?.[key as keyof ConfigServerResponse];
-  }
-
-  /**
-   * Obtiene toda la configuración del config server
-   */
-  getAll(): ConfigServerResponse | null {
-    return this.configServerData ? { ...this.configServerData } : null;
-  }
-
-  /**
-   * Verifica si la configuración ha sido cargada
-   */
-  isConfigLoaded(): boolean {
-    return this.isLoaded;
-  }
-
-  /**
-   * Obtiene la configuración final de la aplicación (con valores del config server aplicados)
-   */
-  getAppConfig(): AppConfiguration {
-    return this.finalAppConfig || this.initialAppConfig;
-  }
-
-  /**
-   * Obtiene los datos raw del config server
-   */
-  getConfigServerData(): ConfigServerResponse | null {
-    return this.configServerData;
-  }
-}

package/src/lib/services/index.ts

@@ -1,3 +0,0 @@
-export * from './authentication.service';
-export * from './authorization.service';
-export * from './config.service';

package/src/lib/version.ts

@@ -1,21 +0,0 @@
-// ========================================
-// VERSION - Auto-generado por sync-version.js
-// ========================================
-// Ejecutar 'npm run sync-version' para actualizar manualmente
-// Se sincroniza automáticamente en prebuild
-
-/**
- * Versión actual de la librería @dinafi/frmk
- * Sincronizada con package.json
- */
-export const VERSION = '1.0.0';
-
-/**
- * Información completa de la versión
- */
-export const VERSION_INFO = {
-  version: '1.0.0',
-  name: 'shared-lib-angular',
-  buildDate: '2026-02-03T22:10:56.622Z',
-  angular: '^20.0.0'
-} as const;

package/src/public-api.ts

@@ -1,75 +0,0 @@
-// ========================================
-// @dinafi/frmk - Public API
-// Angular Shared Library - Ministerio de Hacienda
-// ========================================
-
-// === VERSION ===
-export { VERSION, VERSION_INFO } from './lib/version';
-
-// === MODELS / INTERFACES ===
-export {
-  // Login Configuration
-  LoginConfig,
-  DEFAULT_LOGIN_CONFIG,
-  
-  // Application Configuration
-  AppConfiguration,
-  ConfigServerResponse,
-  
-  // Authorization
-  AuthorizationRequest,
-  AuthorizationResponse,
-  MenuHierarchyItem,
-  MenuHierarchyRequest,
-  
-  // Library Configuration (Injectable)
-  FrmkLibraryConfig,
-  DEFAULT_LIBRARY_CONFIG,
-  FRMK_LIBRARY_CONFIG,
-  provideFrmkConfig
-} from './lib/models';
-
-// === CONFIGURATION UTILITIES ===
-export {
-  // Library Configuration Initialization
-  initializeLibraryConfig,
-  getLibraryConfig,
-  isLibraryConfigured,
-  
-  // App Config Management
-  getDefaultAppConfig,
-  mapConfigServerResponse,
-  setCurrentAppConfig,
-  getCurrentAppConfig,
-  getAppConfig,
-  getAppConfigWithServerData,
-  
-  // OAuth2 Config
-  getAuthConfig,
-  getAuthConfigEnv
-} from './lib/config';
-
-// === SERVICES ===
-export {
-  // Authentication Service
-  AuthService,
-  
-  // Authorization Service
-  AuthorizationService,
-  
-  // Configuration Service
-  ConfigService
-} from './lib/services';
-
-// === GUARDS ===
-export { authGuard } from './lib/guards';
-
-// === COMPONENTS ===
-export { 
-  LoginComponent 
-} from './lib/components/login/login.component';
-
-export { 
-  DashboardComponent,
-  DashboardConfig 
-} from './lib/components/dashboard/dashboard.component';