valtech-components 2.0.691 → 2.0.693

package/esm2022/lib/services/auth/interceptor.mjs

@@ -0,0 +1,122 @@
+import { inject } from '@angular/core';
+import { throwError, BehaviorSubject } from 'rxjs';
+import { catchError, filter, take, switchMap, finalize } from 'rxjs/operators';
+import { AuthService } from './auth.service';
+import { VALTECH_AUTH_CONFIG } from './config';
+// Control de estado de refresco (singleton a nivel de módulo)
+let isRefreshing = false;
+const refreshTokenSubject = new BehaviorSubject(null);
+/**
+ * Interceptor HTTP que:
+ * 1. Agrega header Authorization con Bearer token a requests API
+ * 2. Maneja errores 401 refrescando el token automáticamente
+ * 3. Encola requests durante el refresco para evitar múltiples refresh
+ *
+ * @example
+ * ```typescript
+ * // Incluido automáticamente por provideValtechAuth()
+ * // Para uso manual:
+ * import { provideHttpClient, withInterceptors } from '@angular/common/http';
+ * import { authInterceptor } from 'valtech-components';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideHttpClient(withInterceptors([authInterceptor])),
+ *   ],
+ * });
+ * ```
+ */
+export const authInterceptor = (request, next) => {
+    const authService = inject(AuthService);
+    const config = inject(VALTECH_AUTH_CONFIG);
+    // Omitir requests que no son a nuestra API
+    if (!isApiRequest(request, config.apiUrl)) {
+        return next(request);
+    }
+    // Omitir endpoints públicos que no necesitan token
+    if (isPublicEndpoint(request, config.authPrefix)) {
+        return next(request);
+    }
+    const accessToken = authService.accessToken();
+    // Agregar header de autorización si hay token
+    if (accessToken) {
+        request = addAuthHeader(request, accessToken);
+    }
+    return next(request).pipe(catchError((error) => {
+        if (error.status === 401 && !isNoRefreshEndpoint(request, config.authPrefix)) {
+            return handle401Error(request, next, authService);
+        }
+        if (error.status === 403) {
+            console.error('[ValtechAuth] Permiso denegado:', error.error?.message || 'Acceso prohibido');
+        }
+        return throwError(() => error);
+    }));
+};
+/**
+ * Agrega header de autorización a la request.
+ */
+function addAuthHeader(request, token) {
+    return request.clone({
+        setHeaders: {
+            Authorization: `Bearer ${token}`,
+        },
+    });
+}
+/**
+ * Verifica si la request es a nuestra API.
+ */
+function isApiRequest(request, apiUrl) {
+    return request.url.startsWith(apiUrl) || request.url.includes('/v2/auth');
+}
+/**
+ * Verifica si la request es a un endpoint público que NO requiere token.
+ */
+function isPublicEndpoint(request, authPrefix) {
+    const publicEndpoints = [
+        '/signin',
+        '/signup',
+        '/refresh',
+        '/logout',
+        '/mfa/verify', // Solo durante login
+    ];
+    return publicEndpoints.some((endpoint) => request.url.includes(`${authPrefix}${endpoint}`));
+}
+/**
+ * Verifica si la request es a un endpoint que NO debe reintentar refresh en 401.
+ */
+function isNoRefreshEndpoint(request, authPrefix) {
+    // Endpoints que no deben intentar refresh en 401:
+    // - Públicos: signin, signup, refresh, logout
+    // - MFA: verify (durante login), confirm (401 = código incorrecto), disable (401 = contraseña incorrecta)
+    const noRefreshEndpoints = [
+        '/signin',
+        '/signup',
+        '/refresh',
+        '/logout',
+        '/mfa/verify',
+        '/mfa/confirm',
+        '/mfa/disable',
+    ];
+    return noRefreshEndpoints.some((endpoint) => request.url.includes(`${authPrefix}${endpoint}`));
+}
+/**
+ * Maneja errores 401 refrescando el token.
+ */
+function handle401Error(request, next, authService) {
+    if (!isRefreshing) {
+        isRefreshing = true;
+        refreshTokenSubject.next(null);
+        return authService.refreshAccessToken().pipe(switchMap((response) => {
+            refreshTokenSubject.next(response.accessToken);
+            return next(addAuthHeader(request, response.accessToken));
+        }), catchError((error) => {
+            authService.logout();
+            return throwError(() => error);
+        }), finalize(() => {
+            isRefreshing = false;
+        }));
+    }
+    // Esperar a que termine el refresco en curso
+    return refreshTokenSubject.pipe(filter((token) => token !== null), take(1), switchMap((token) => next(addAuthHeader(request, token))));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interceptor.js","sourceRoot":"","sources":["../../../../../../src/lib/services/auth/interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject } from '@angular/core';\nimport {\n  HttpInterceptorFn,\n  HttpRequest,\n  HttpHandlerFn,\n  HttpEvent,\n  HttpErrorResponse,\n} from '@angular/common/http';\nimport { Observable, throwError, BehaviorSubject } from 'rxjs';\nimport { catchError, filter, take, switchMap, finalize } from 'rxjs/operators';\nimport { AuthService } from './auth.service';\nimport { VALTECH_AUTH_CONFIG } from './config';\n\n// Control de estado de refresco (singleton a nivel de módulo)\nlet isRefreshing = false;\nconst refreshTokenSubject = new BehaviorSubject<string | null>(null);\n\n/**\n * Interceptor HTTP que:\n * 1. Agrega header Authorization con Bearer token a requests API\n * 2. Maneja errores 401 refrescando el token automáticamente\n * 3. Encola requests durante el refresco para evitar múltiples refresh\n *\n * @example\n * ```typescript\n * // Incluido automáticamente por provideValtechAuth()\n * // Para uso manual:\n * import { provideHttpClient, withInterceptors } from '@angular/common/http';\n * import { authInterceptor } from 'valtech-components';\n *\n * bootstrapApplication(AppComponent, {\n *   providers: [\n *     provideHttpClient(withInterceptors([authInterceptor])),\n *   ],\n * });\n * ```\n */\nexport const authInterceptor: HttpInterceptorFn = (\n  request: HttpRequest<unknown>,\n  next: HttpHandlerFn\n): Observable<HttpEvent<unknown>> => {\n  const authService = inject(AuthService);\n  const config = inject(VALTECH_AUTH_CONFIG);\n\n  // Omitir requests que no son a nuestra API\n  if (!isApiRequest(request, config.apiUrl)) {\n    return next(request);\n  }\n\n  // Omitir endpoints públicos que no necesitan token\n  if (isPublicEndpoint(request, config.authPrefix!)) {\n    return next(request);\n  }\n\n  const accessToken = authService.accessToken();\n\n  // Agregar header de autorización si hay token\n  if (accessToken) {\n    request = addAuthHeader(request, accessToken);\n  }\n\n  return next(request).pipe(\n    catchError((error: HttpErrorResponse) => {\n      if (error.status === 401 && !isNoRefreshEndpoint(request, config.authPrefix!)) {\n        return handle401Error(request, next, authService);\n      }\n\n      if (error.status === 403) {\n        console.error(\n          '[ValtechAuth] Permiso denegado:',\n          error.error?.message || 'Acceso prohibido'\n        );\n      }\n\n      return throwError(() => error);\n    })\n  );\n};\n\n/**\n * Agrega header de autorización a la request.\n */\nfunction addAuthHeader(\n  request: HttpRequest<unknown>,\n  token: string\n): HttpRequest<unknown> {\n  return request.clone({\n    setHeaders: {\n      Authorization: `Bearer ${token}`,\n    },\n  });\n}\n\n/**\n * Verifica si la request es a nuestra API.\n */\nfunction isApiRequest(request: HttpRequest<unknown>, apiUrl: string): boolean {\n  return request.url.startsWith(apiUrl) || request.url.includes('/v2/auth');\n}\n\n/**\n * Verifica si la request es a un endpoint público que NO requiere token.\n */\nfunction isPublicEndpoint(\n  request: HttpRequest<unknown>,\n  authPrefix: string\n): boolean {\n  const publicEndpoints = [\n    '/signin',\n    '/signup',\n    '/refresh',\n    '/logout',\n    '/mfa/verify', // Solo durante login\n  ];\n  return publicEndpoints.some((endpoint) =>\n    request.url.includes(`${authPrefix}${endpoint}`)\n  );\n}\n\n/**\n * Verifica si la request es a un endpoint que NO debe reintentar refresh en 401.\n */\nfunction isNoRefreshEndpoint(\n  request: HttpRequest<unknown>,\n  authPrefix: string\n): boolean {\n  // Endpoints que no deben intentar refresh en 401:\n  // - Públicos: signin, signup, refresh, logout\n  // - MFA: verify (durante login), confirm (401 = código incorrecto), disable (401 = contraseña incorrecta)\n  const noRefreshEndpoints = [\n    '/signin',\n    '/signup',\n    '/refresh',\n    '/logout',\n    '/mfa/verify',\n    '/mfa/confirm',\n    '/mfa/disable',\n  ];\n  return noRefreshEndpoints.some((endpoint) =>\n    request.url.includes(`${authPrefix}${endpoint}`)\n  );\n}\n\n/**\n * Maneja errores 401 refrescando el token.\n */\nfunction handle401Error(\n  request: HttpRequest<unknown>,\n  next: HttpHandlerFn,\n  authService: AuthService\n): Observable<HttpEvent<unknown>> {\n  if (!isRefreshing) {\n    isRefreshing = true;\n    refreshTokenSubject.next(null);\n\n    return authService.refreshAccessToken().pipe(\n      switchMap((response) => {\n        refreshTokenSubject.next(response.accessToken);\n        return next(addAuthHeader(request, response.accessToken));\n      }),\n      catchError((error) => {\n        authService.logout();\n        return throwError(() => error);\n      }),\n      finalize(() => {\n        isRefreshing = false;\n      })\n    );\n  }\n\n  // Esperar a que termine el refresco en curso\n  return refreshTokenSubject.pipe(\n    filter((token): token is string => token !== null),\n    take(1),\n    switchMap((token) => next(addAuthHeader(request, token)))\n  );\n}\n"]}

package/esm2022/lib/services/auth/oauth-callback.component.mjs

@@ -0,0 +1,169 @@
+import { Component } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+/**
+ * Componente de callback para OAuth.
+ *
+ * Este componente procesa la respuesta del servidor OAuth y envía
+ * los tokens a la ventana padre via postMessage.
+ *
+ * Debe agregarse a las rutas de la aplicación:
+ * ```typescript
+ * // app.routes.ts
+ * import { OAuthCallbackComponent } from 'valtech-components';
+ *
+ * export const routes: Routes = [
+ *   { path: 'auth/oauth/callback', component: OAuthCallbackComponent },
+ *   // ... otras rutas
+ * ];
+ * ```
+ *
+ * El backend redirige a esta ruta con los tokens en query params:
+ * `/auth/oauth/callback?access_token=xxx&refresh_token=xxx&expires_in=900`
+ *
+ * O con error:
+ * `/auth/oauth/callback?error=INVALID_CODE&error_description=...`
+ */
+export class OAuthCallbackComponent {
+    constructor() {
+        this.message = 'Procesando autenticación...';
+    }
+    ngOnInit() {
+        this.processCallback();
+    }
+    processCallback() {
+        const params = new URLSearchParams(window.location.search);
+        // DEBUG: Log all received params
+        console.log('[OAuthCallback] URL params received:', {
+            url: window.location.href,
+            hasAccessToken: params.has('access_token'),
+            hasRefreshToken: params.has('refresh_token'),
+            hasFirebaseToken: params.has('firebase_token'),
+            firebaseTokenLength: params.get('firebase_token')?.length || 0,
+            error: params.get('error'),
+        });
+        // Verificar si hay error
+        const error = params.get('error');
+        if (error) {
+            this.sendToParent({
+                type: 'oauth-callback',
+                error: {
+                    code: error,
+                    message: params.get('error_description') || 'Error de autenticación',
+                },
+            });
+            this.message = 'Error de autenticación';
+            this.closeAfterDelay();
+            return;
+        }
+        // Extraer tokens
+        const accessToken = params.get('access_token');
+        const refreshToken = params.get('refresh_token');
+        const expiresIn = params.get('expires_in');
+        const firebaseToken = params.get('firebase_token');
+        if (!accessToken || !refreshToken) {
+            this.sendToParent({
+                type: 'oauth-callback',
+                error: {
+                    code: 'MISSING_TOKENS',
+                    message: 'No se recibieron los tokens de autenticación',
+                },
+            });
+            this.message = 'Error: tokens no recibidos';
+            this.closeAfterDelay();
+            return;
+        }
+        // Extraer roles y permisos (pueden venir como JSON en base64)
+        let roles;
+        let permissions;
+        const rolesParam = params.get('roles');
+        const permissionsParam = params.get('permissions');
+        if (rolesParam) {
+            try {
+                roles = JSON.parse(atob(rolesParam));
+            }
+            catch {
+                roles = rolesParam.split(',');
+            }
+        }
+        if (permissionsParam) {
+            try {
+                permissions = JSON.parse(atob(permissionsParam));
+            }
+            catch {
+                permissions = permissionsParam.split(',');
+            }
+        }
+        // Enviar tokens a la ventana padre
+        const result = {
+            accessToken,
+            refreshToken,
+            expiresIn: expiresIn ? parseInt(expiresIn, 10) : 900,
+            firebaseToken: firebaseToken || undefined,
+            roles,
+            permissions,
+            isNewUser: params.get('is_new_user') === 'true',
+            linked: params.get('linked') === 'true',
+        };
+        this.sendToParent({
+            type: 'oauth-callback',
+            tokens: result,
+        });
+        this.message = 'Autenticación exitosa';
+        this.closeAfterDelay();
+    }
+    sendToParent(data) {
+        // Siempre guardar en localStorage como fallback (para COOP issues)
+        try {
+            localStorage.setItem('oauth_callback_data', JSON.stringify(data));
+            localStorage.setItem('oauth_callback_timestamp', Date.now().toString());
+            console.log('[OAuthCallback] Saved to localStorage as fallback');
+        }
+        catch (e) {
+            console.warn('[OAuthCallback] Could not save to localStorage:', e);
+        }
+        // Intentar postMessage (puede fallar por COOP)
+        try {
+            if (window.opener && !window.opener.closed) {
+                window.opener.postMessage(data, window.location.origin);
+                console.log('[OAuthCallback] postMessage sent to opener');
+            }
+            else if (window.parent !== window) {
+                window.parent.postMessage(data, window.location.origin);
+                console.log('[OAuthCallback] postMessage sent to parent');
+            }
+            else {
+                console.log('[OAuthCallback] No opener/parent available, using localStorage only');
+            }
+        }
+        catch (e) {
+            // COOP blocks postMessage - localStorage fallback already saved
+            console.warn('[OAuthCallback] postMessage blocked (COOP), using localStorage fallback:', e);
+        }
+    }
+    closeAfterDelay() {
+        // Dar tiempo para que el mensaje se envíe antes de cerrar
+        setTimeout(() => {
+            if (window.opener) {
+                window.close();
+            }
+        }, 500);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: OAuthCallbackComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: OAuthCallbackComponent, isStandalone: true, selector: "val-oauth-callback", ngImport: i0, template: `
+    <div class="oauth-callback">
+      <div class="oauth-callback__spinner"></div>
+      <p class="oauth-callback__text">{{ message }}</p>
+    </div>
+  `, isInline: true, styles: [".oauth-callback{display:flex;flex-direction:column;align-items:center;justify-content:center;height:100vh;font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,sans-serif}.oauth-callback__spinner{width:40px;height:40px;border:3px solid #f3f3f3;border-top:3px solid #3498db;border-radius:50%;animation:spin 1s linear infinite;margin-bottom:16px}@keyframes spin{0%{transform:rotate(0)}to{transform:rotate(360deg)}}.oauth-callback__text{color:#666;font-size:14px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: OAuthCallbackComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-oauth-callback', standalone: true, imports: [CommonModule], template: `
+    <div class="oauth-callback">
+      <div class="oauth-callback__spinner"></div>
+      <p class="oauth-callback__text">{{ message }}</p>
+    </div>
+  `, styles: [".oauth-callback{display:flex;flex-direction:column;align-items:center;justify-content:center;height:100vh;font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,sans-serif}.oauth-callback__spinner{width:40px;height:40px;border:3px solid #f3f3f3;border-top:3px solid #3498db;border-radius:50%;animation:spin 1s linear infinite;margin-bottom:16px}@keyframes spin{0%{transform:rotate(0)}to{transform:rotate(360deg)}}.oauth-callback__text{color:#666;font-size:14px}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"oauth-callback.component.js","sourceRoot":"","sources":["../../../../../../src/lib/services/auth/oauth-callback.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { OAuthCallbackData, OAuthResult, OAuthError } from './types';\n\n/**\n * Componente de callback para OAuth.\n *\n * Este componente procesa la respuesta del servidor OAuth y envía\n * los tokens a la ventana padre via postMessage.\n *\n * Debe agregarse a las rutas de la aplicación:\n * ```typescript\n * // app.routes.ts\n * import { OAuthCallbackComponent } from 'valtech-components';\n *\n * export const routes: Routes = [\n *   { path: 'auth/oauth/callback', component: OAuthCallbackComponent },\n *   // ... otras rutas\n * ];\n * ```\n *\n * El backend redirige a esta ruta con los tokens en query params:\n * `/auth/oauth/callback?access_token=xxx&refresh_token=xxx&expires_in=900`\n *\n * O con error:\n * `/auth/oauth/callback?error=INVALID_CODE&error_description=...`\n */\n@Component({\n  selector: 'val-oauth-callback',\n  standalone: true,\n  imports: [CommonModule],\n  template: `\n    <div class=\"oauth-callback\">\n      <div class=\"oauth-callback__spinner\"></div>\n      <p class=\"oauth-callback__text\">{{ message }}</p>\n    </div>\n  `,\n  styles: [`\n    .oauth-callback {\n      display: flex;\n      flex-direction: column;\n      align-items: center;\n      justify-content: center;\n      height: 100vh;\n      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;\n    }\n\n    .oauth-callback__spinner {\n      width: 40px;\n      height: 40px;\n      border: 3px solid #f3f3f3;\n      border-top: 3px solid #3498db;\n      border-radius: 50%;\n      animation: spin 1s linear infinite;\n      margin-bottom: 16px;\n    }\n\n    @keyframes spin {\n      0% { transform: rotate(0deg); }\n      100% { transform: rotate(360deg); }\n    }\n\n    .oauth-callback__text {\n      color: #666;\n      font-size: 14px;\n    }\n  `],\n})\nexport class OAuthCallbackComponent implements OnInit {\n  message = 'Procesando autenticación...';\n\n  ngOnInit(): void {\n    this.processCallback();\n  }\n\n  private processCallback(): void {\n    const params = new URLSearchParams(window.location.search);\n\n    // DEBUG: Log all received params\n    console.log('[OAuthCallback] URL params received:', {\n      url: window.location.href,\n      hasAccessToken: params.has('access_token'),\n      hasRefreshToken: params.has('refresh_token'),\n      hasFirebaseToken: params.has('firebase_token'),\n      firebaseTokenLength: params.get('firebase_token')?.length || 0,\n      error: params.get('error'),\n    });\n\n    // Verificar si hay error\n    const error = params.get('error');\n    if (error) {\n      this.sendToParent({\n        type: 'oauth-callback',\n        error: {\n          code: error,\n          message: params.get('error_description') || 'Error de autenticación',\n        } as OAuthError,\n      });\n      this.message = 'Error de autenticación';\n      this.closeAfterDelay();\n      return;\n    }\n\n    // Extraer tokens\n    const accessToken = params.get('access_token');\n    const refreshToken = params.get('refresh_token');\n    const expiresIn = params.get('expires_in');\n    const firebaseToken = params.get('firebase_token');\n\n    if (!accessToken || !refreshToken) {\n      this.sendToParent({\n        type: 'oauth-callback',\n        error: {\n          code: 'MISSING_TOKENS',\n          message: 'No se recibieron los tokens de autenticación',\n        } as OAuthError,\n      });\n      this.message = 'Error: tokens no recibidos';\n      this.closeAfterDelay();\n      return;\n    }\n\n    // Extraer roles y permisos (pueden venir como JSON en base64)\n    let roles: string[] | undefined;\n    let permissions: string[] | undefined;\n\n    const rolesParam = params.get('roles');\n    const permissionsParam = params.get('permissions');\n\n    if (rolesParam) {\n      try {\n        roles = JSON.parse(atob(rolesParam));\n      } catch {\n        roles = rolesParam.split(',');\n      }\n    }\n\n    if (permissionsParam) {\n      try {\n        permissions = JSON.parse(atob(permissionsParam));\n      } catch {\n        permissions = permissionsParam.split(',');\n      }\n    }\n\n    // Enviar tokens a la ventana padre\n    const result: OAuthResult = {\n      accessToken,\n      refreshToken,\n      expiresIn: expiresIn ? parseInt(expiresIn, 10) : 900,\n      firebaseToken: firebaseToken || undefined,\n      roles,\n      permissions,\n      isNewUser: params.get('is_new_user') === 'true',\n      linked: params.get('linked') === 'true',\n    };\n\n    this.sendToParent({\n      type: 'oauth-callback',\n      tokens: result,\n    });\n\n    this.message = 'Autenticación exitosa';\n    this.closeAfterDelay();\n  }\n\n  private sendToParent(data: OAuthCallbackData): void {\n    // Siempre guardar en localStorage como fallback (para COOP issues)\n    try {\n      localStorage.setItem('oauth_callback_data', JSON.stringify(data));\n      localStorage.setItem('oauth_callback_timestamp', Date.now().toString());\n      console.log('[OAuthCallback] Saved to localStorage as fallback');\n    } catch (e) {\n      console.warn('[OAuthCallback] Could not save to localStorage:', e);\n    }\n\n    // Intentar postMessage (puede fallar por COOP)\n    try {\n      if (window.opener && !window.opener.closed) {\n        window.opener.postMessage(data, window.location.origin);\n        console.log('[OAuthCallback] postMessage sent to opener');\n      } else if (window.parent !== window) {\n        window.parent.postMessage(data, window.location.origin);\n        console.log('[OAuthCallback] postMessage sent to parent');\n      } else {\n        console.log('[OAuthCallback] No opener/parent available, using localStorage only');\n      }\n    } catch (e) {\n      // COOP blocks postMessage - localStorage fallback already saved\n      console.warn('[OAuthCallback] postMessage blocked (COOP), using localStorage fallback:', e);\n    }\n  }\n\n  private closeAfterDelay(): void {\n    // Dar tiempo para que el mensaje se envíe antes de cerrar\n    setTimeout(() => {\n      if (window.opener) {\n        window.close();\n      }\n    }, 500);\n  }\n}\n"]}