valtech-components 2.0.795 → 2.0.797

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

@@ -0,0 +1,98 @@
+/**
+ * Valtech Auth Service
+ *
+ * Servicio de autenticación reutilizable para aplicaciones Angular.
+ * Proporciona autenticación con AuthV2, MFA, sincronización entre pestañas,
+ * refresh proactivo de tokens, y registro automático de dispositivos para
+ * push notifications.
+ *
+ * @example
+ * ```typescript
+ * // En main.ts
+ * import { bootstrapApplication } from '@angular/platform-browser';
+ * import { provideValtechAuth, provideValtechFirebase } from 'valtech-components';
+ * import { environment } from './environments/environment';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideValtechFirebase(environment.firebase),
+ *     provideValtechAuth({
+ *       apiUrl: environment.apiUrl,
+ *       enableFirebaseIntegration: true,
+ *       enableDeviceRegistration: true, // Auto-registra dispositivos para push
+ *     }),
+ *   ],
+ * });
+ *
+ * // En app.routes.ts
+ * import { authGuard, guestGuard, permissionGuard } from 'valtech-components';
+ *
+ * const routes: Routes = [
+ *   { path: 'login', canActivate: [guestGuard], loadComponent: () => import('./login.page') },
+ *   { path: 'dashboard', canActivate: [authGuard], loadComponent: () => import('./dashboard.page') },
+ *   { path: 'admin', canActivate: [authGuard, permissionGuard('admin:*')], loadComponent: () => import('./admin.page') },
+ * ];
+ *
+ * // En componentes
+ * import { AuthService } from 'valtech-components';
+ *
+ * @Component({...})
+ * export class LoginComponent {
+ *   private auth = inject(AuthService);
+ *
+ *   async login() {
+ *     await firstValueFrom(this.auth.signin({ email, password }));
+ *     if (this.auth.mfaPending().required) {
+ *       // Mostrar UI de MFA
+ *     } else {
+ *       this.router.navigate(['/dashboard']);
+ *     }
+ *   }
+ *
+ *   // Habilitar notificaciones push (solicita permisos + registra dispositivo)
+ *   async enableNotifications() {
+ *     const result = await this.auth.enableNotifications();
+ *     if (result.granted) {
+ *       console.log('Notificaciones habilitadas');
+ *     }
+ *   }
+ *
+ *   // Verificar estado de permisos
+ *   get canReceiveNotifications(): boolean {
+ *     return this.auth.getNotificationPermissionState() === 'granted';
+ *   }
+ *
+ *   // En template: usar signals directamente
+ *   // {{ auth.user()?.email }}
+ *   // @if (auth.hasPermission('templates:edit')) { ... }
+ * }
+ * ```
+ */
+// Tipos
+export * from './types';
+// Configuración
+export { VALTECH_AUTH_CONFIG, provideValtechAuth, provideValtechAuthInterceptor, DEFAULT_AUTH_CONFIG, } from './config';
+// Servicio principal
+export { AuthService } from './auth.service';
+// Guards
+export { authGuard, guestGuard, permissionGuard, permissionGuardFromRoute, superAdminGuard, roleGuard, } from './guards';
+// Interceptor (para uso avanzado)
+export { authInterceptor } from './interceptor';
+// Servicios internos (para testing o extensión)
+export { AuthStateService } from './auth-state.service';
+export { TokenService } from './token.service';
+export { AuthStorageService } from './storage.service';
+export { AuthSyncService } from './sync.service';
+// Servicios de gestión de dispositivos y sesiones
+export { DeviceService } from './device.service';
+export { SessionService } from './session.service';
+// OAuth (Login social)
+export { OAuthService } from './oauth.service';
+export { OAuthCallbackComponent } from './oauth-callback.component';
+// Cross-app session handoff (OAuth Authorization Code pattern internal)
+export { HandoffService, HANDOFF_TOKEN_PARAM, HANDOFF_ROUTE_PARAM } from './handoff.service';
+// Active organization switch orchestration
+export { OrgSwitchService } from './org-switch.service';
+// Cross-app cross-org notification click handler
+export { NotificationActionService } from './notification-action.service';
+//# sourceMappingURL=data:application/json;base64,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

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/notification-action.service.mjs

@@ -0,0 +1,117 @@
+/**
+ * NotificationActionService — orquesta el "click en notificación" cross-app cross-org.
+ *
+ * Flujo:
+ *   1. markAsRead (best-effort, no bloquea)
+ *   2. Si appId destino !== appId actual → handoff token + redirect a app destino
+ *   3. Si orgId destino !== activeOrg → switchTo(orgId) (sin reload, navega después)
+ *   4. router.navigateByUrl(actionRoute)
+ *
+ * Requiere:
+ *   - ValtechAuthConfig.appId  (identifica la app actual)
+ *   - ValtechAuthConfig.appUrls (mapa baseUrl para handoff cross-app)
+ */
+import { HttpErrorResponse } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import { firstValueFrom } from 'rxjs';
+import { VALTECH_AUTH_CONFIG } from './config';
+import * as i0 from "@angular/core";
+import * as i1 from "./auth.service";
+import * as i2 from "./org-switch.service";
+import * as i3 from "./handoff.service";
+import * as i4 from "../firebase/notifications.service";
+import * as i5 from "@angular/router";
+export class NotificationActionService {
+    constructor(config, auth, orgSwitch, handoff, notifications, router) {
+        this.config = config;
+        this.auth = auth;
+        this.orgSwitch = orgSwitch;
+        this.handoff = handoff;
+        this.notifications = notifications;
+        this.router = router;
+    }
+    /**
+     * Abre la notificación: marca como leída, switch-org si toca, navegación local o
+     * redirect cross-app vía handoff.
+     *
+     * No lanza errores hacia la UI — devuelve un resultado descriptivo. Errores
+     * técnicos quedan en console.warn.
+     */
+    async open(notif) {
+        // 1) Mark as read (best-effort, no bloquea el flujo principal)
+        if (notif.id && !notif.isRead) {
+            this.notifications.markAsRead(notif.id).catch(err => {
+                console.warn('[NotificationAction] markAsRead failed', err);
+            });
+        }
+        const route = notif.actionRoute;
+        if (!route) {
+            return 'no-action-route';
+        }
+        const currentApp = this.config.appId;
+        const targetApp = notif.appId;
+        // 2) Cross-app: handoff + full redirect
+        //
+        // baseUrl resolution priority:
+        //   (1) response.targetBaseUrl  — backend lookup en app-config (preferred, single source of truth)
+        //   (2) config.appUrls[targetApp] — fallback frontend mientras backend agrega el campo
+        if (targetApp && currentApp && targetApp !== currentApp) {
+            try {
+                const resp = await firstValueFrom(this.handoff.createHandoff({ targetAppId: targetApp, route }));
+                const baseUrl = resp.targetBaseUrl ?? this.config.appUrls?.[targetApp];
+                if (!baseUrl) {
+                    console.warn(`[NotificationAction] No baseUrl for app '${targetApp}' — backend did not return targetBaseUrl and no appUrls fallback configured`);
+                    return 'cross-app-unconfigured';
+                }
+                const url = this.buildHandoffUrl(baseUrl, resp.token, route);
+                if (typeof window !== 'undefined') {
+                    window.location.href = url;
+                }
+                return 'redirected-cross-app';
+            }
+            catch (err) {
+                const msg = err instanceof HttpErrorResponse ? err.message : String(err);
+                console.warn('[NotificationAction] createHandoff failed:', msg);
+                return 'handoff-failed';
+            }
+        }
+        // 3) Same app — switch-org si toca (sin reload — la navegación posterior monta page fresh)
+        let switched = false;
+        if (notif.orgId) {
+            const active = this.activeOrg();
+            if (active && active !== notif.orgId) {
+                await this.orgSwitch.switchTo(notif.orgId);
+                switched = true;
+            }
+        }
+        // 4) Navigate local
+        await this.router.navigateByUrl(route);
+        return switched ? 'navigated-after-switch-org' : 'navigated';
+    }
+    activeOrg() {
+        const user = this.auth.user();
+        return (user?.activeOrgId ??
+            user?.activeOrg ??
+            '');
+    }
+    /**
+     * Construye URL absoluta para handoff cross-app preservando pathname y otros
+     * params existentes de la baseUrl.
+     */
+    buildHandoffUrl(baseUrl, token, route) {
+        const url = new URL(baseUrl);
+        url.searchParams.set('handoff', token);
+        url.searchParams.set('route', route);
+        return url.toString();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NotificationActionService, deps: [{ token: VALTECH_AUTH_CONFIG }, { token: i1.AuthService }, { token: i2.OrgSwitchService }, { token: i3.HandoffService }, { token: i4.NotificationsService }, { token: i5.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NotificationActionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NotificationActionService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [VALTECH_AUTH_CONFIG]
+                }] }, { type: i1.AuthService }, { type: i2.OrgSwitchService }, { type: i3.HandoffService }, { type: i4.NotificationsService }, { type: i5.Router }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notification-action.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/auth/notification-action.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAGtC,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;;;;;;;AAgB/C,MAAM,OAAO,yBAAyB;IACpC,YACuC,MAAyB,EACtD,IAAiB,EACjB,SAA2B,EAC3B,OAAuB,EACvB,aAAmC,EACnC,MAAc;QALe,WAAM,GAAN,MAAM,CAAmB;QACtD,SAAI,GAAJ,IAAI,CAAa;QACjB,cAAS,GAAT,SAAS,CAAkB;QAC3B,YAAO,GAAP,OAAO,CAAgB;QACvB,kBAAa,GAAb,aAAa,CAAsB;QACnC,WAAM,GAAN,MAAM,CAAQ;IACrB,CAAC;IAEJ;;;;;;OAMG;IACH,KAAK,CAAC,IAAI,CAAC,KAA2B;QACpC,+DAA+D;QAC/D,IAAI,KAAK,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;YAC9B,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE;gBAClD,OAAO,CAAC,IAAI,CAAC,wCAAwC,EAAE,GAAG,CAAC,CAAC;YAC9D,CAAC,CAAC,CAAC;QACL,CAAC;QAED,MAAM,KAAK,GAAG,KAAK,CAAC,WAAW,CAAC;QAChC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,iBAAiB,CAAC;QAC3B,CAAC;QAED,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;QACrC,MAAM,SAAS,GAAG,KAAK,CAAC,KAAK,CAAC;QAE9B,wCAAwC;QACxC,EAAE;QACF,+BAA+B;QAC/B,mGAAmG;QACnG,uFAAuF;QACvF,IAAI,SAAS,IAAI,UAAU,IAAI,SAAS,KAAK,UAAU,EAAE,CAAC;YACxD,IAAI,CAAC;gBACH,MAAM,IAAI,GAAG,MAAM,cAAc,CAC/B,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE,WAAW,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAC9D,CAAC;gBACF,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,SAAS,CAAC,CAAC;gBACvE,IAAI,CAAC,OAAO,EAAE,CAAC;oBACb,OAAO,CAAC,IAAI,CACV,4CAA4C,SAAS,6EAA6E,CACnI,CAAC;oBACF,OAAO,wBAAwB,CAAC;gBAClC,CAAC;gBACD,MAAM,GAAG,GAAG,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;gBAC7D,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE,CAAC;oBAClC,MAAM,CAAC,QAAQ,CAAC,IAAI,GAAG,GAAG,CAAC;gBAC7B,CAAC;gBACD,OAAO,sBAAsB,CAAC;YAChC,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,MAAM,GAAG,GAAG,GAAG,YAAY,iBAAiB,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;gBACzE,OAAO,CAAC,IAAI,CAAC,4CAA4C,EAAE,GAAG,CAAC,CAAC;gBAChE,OAAO,gBAAgB,CAAC;YAC1B,CAAC;QACH,CAAC;QAED,2FAA2F;QAC3F,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;YAChB,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;YAChC,IAAI,MAAM,IAAI,MAAM,KAAK,KAAK,CAAC,KAAK,EAAE,CAAC;gBACrC,MAAM,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;gBAC3C,QAAQ,GAAG,IAAI,CAAC;YAClB,CAAC;QACH,CAAC;QAED,oBAAoB;QACpB,MAAM,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QACvC,OAAO,QAAQ,CAAC,CAAC,CAAC,4BAA4B,CAAC,CAAC,CAAC,WAAW,CAAC;IAC/D,CAAC;IAEO,SAAS;QACf,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;QAC9B,OAAO,CACJ,IAA4D,EAAE,WAAW;YACzE,IAA4D,EAAE,SAAS;YACxE,EAAE,CACH,CAAC;IACJ,CAAC;IAED;;;OAGG;IACK,eAAe,CAAC,OAAe,EAAE,KAAa,EAAE,KAAa;QACnE,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC;QAC7B,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QACvC,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QACrC,OAAO,GAAG,CAAC,QAAQ,EAAE,CAAC;IACxB,CAAC;+GA/FU,yBAAyB,kBAE1B,mBAAmB;mHAFlB,yBAAyB,cADZ,MAAM;;4FACnB,yBAAyB;kBADrC,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE;;0BAG7B,MAAM;2BAAC,mBAAmB","sourcesContent":["/**\n * NotificationActionService — orquesta el \"click en notificación\" cross-app cross-org.\n *\n * Flujo:\n *   1. markAsRead (best-effort, no bloquea)\n *   2. Si appId destino !== appId actual → handoff token + redirect a app destino\n *   3. Si orgId destino !== activeOrg → switchTo(orgId) (sin reload, navega después)\n *   4. router.navigateByUrl(actionRoute)\n *\n * Requiere:\n *   - ValtechAuthConfig.appId  (identifica la app actual)\n *   - ValtechAuthConfig.appUrls (mapa baseUrl para handoff cross-app)\n */\n\nimport { HttpErrorResponse } from '@angular/common/http';\nimport { Inject, Injectable } from '@angular/core';\nimport { Router } from '@angular/router';\nimport { firstValueFrom } from 'rxjs';\n\nimport { AuthService } from './auth.service';\nimport { VALTECH_AUTH_CONFIG } from './config';\nimport { HandoffService } from './handoff.service';\nimport { OrgSwitchService } from './org-switch.service';\nimport { ValtechAuthConfig } from './types';\nimport { NotificationDocument, NotificationsService } from '../firebase/notifications.service';\n\n/** Resultado descriptivo del open() — útil para tests y telemetría. */\nexport type NotificationOpenResult =\n  | 'navigated'\n  | 'navigated-after-switch-org'\n  | 'redirected-cross-app'\n  | 'no-action-route'\n  | 'cross-app-unconfigured'\n  | 'handoff-failed';\n\n@Injectable({ providedIn: 'root' })\nexport class NotificationActionService {\n  constructor(\n    @Inject(VALTECH_AUTH_CONFIG) private config: ValtechAuthConfig,\n    private auth: AuthService,\n    private orgSwitch: OrgSwitchService,\n    private handoff: HandoffService,\n    private notifications: NotificationsService,\n    private router: Router\n  ) {}\n\n  /**\n   * Abre la notificación: marca como leída, switch-org si toca, navegación local o\n   * redirect cross-app vía handoff.\n   *\n   * No lanza errores hacia la UI — devuelve un resultado descriptivo. Errores\n   * técnicos quedan en console.warn.\n   */\n  async open(notif: NotificationDocument): Promise<NotificationOpenResult> {\n    // 1) Mark as read (best-effort, no bloquea el flujo principal)\n    if (notif.id && !notif.isRead) {\n      this.notifications.markAsRead(notif.id).catch(err => {\n        console.warn('[NotificationAction] markAsRead failed', err);\n      });\n    }\n\n    const route = notif.actionRoute;\n    if (!route) {\n      return 'no-action-route';\n    }\n\n    const currentApp = this.config.appId;\n    const targetApp = notif.appId;\n\n    // 2) Cross-app: handoff + full redirect\n    //\n    // baseUrl resolution priority:\n    //   (1) response.targetBaseUrl  — backend lookup en app-config (preferred, single source of truth)\n    //   (2) config.appUrls[targetApp] — fallback frontend mientras backend agrega el campo\n    if (targetApp && currentApp && targetApp !== currentApp) {\n      try {\n        const resp = await firstValueFrom(\n          this.handoff.createHandoff({ targetAppId: targetApp, route })\n        );\n        const baseUrl = resp.targetBaseUrl ?? this.config.appUrls?.[targetApp];\n        if (!baseUrl) {\n          console.warn(\n            `[NotificationAction] No baseUrl for app '${targetApp}' — backend did not return targetBaseUrl and no appUrls fallback configured`\n          );\n          return 'cross-app-unconfigured';\n        }\n        const url = this.buildHandoffUrl(baseUrl, resp.token, route);\n        if (typeof window !== 'undefined') {\n          window.location.href = url;\n        }\n        return 'redirected-cross-app';\n      } catch (err) {\n        const msg = err instanceof HttpErrorResponse ? err.message : String(err);\n        console.warn('[NotificationAction] createHandoff failed:', msg);\n        return 'handoff-failed';\n      }\n    }\n\n    // 3) Same app — switch-org si toca (sin reload — la navegación posterior monta page fresh)\n    let switched = false;\n    if (notif.orgId) {\n      const active = this.activeOrg();\n      if (active && active !== notif.orgId) {\n        await this.orgSwitch.switchTo(notif.orgId);\n        switched = true;\n      }\n    }\n\n    // 4) Navigate local\n    await this.router.navigateByUrl(route);\n    return switched ? 'navigated-after-switch-org' : 'navigated';\n  }\n\n  private activeOrg(): string {\n    const user = this.auth.user();\n    return (\n      (user as { activeOrgId?: string; activeOrg?: string } | null)?.activeOrgId ??\n      (user as { activeOrgId?: string; activeOrg?: string } | null)?.activeOrg ??\n      ''\n    );\n  }\n\n  /**\n   * Construye URL absoluta para handoff cross-app preservando pathname y otros\n   * params existentes de la baseUrl.\n   */\n  private buildHandoffUrl(baseUrl: string, token: string, route: string): string {\n    const url = new URL(baseUrl);\n    url.searchParams.set('handoff', token);\n    url.searchParams.set('route', route);\n    return url.toString();\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"]}