valtech-components 2.0.821 → 2.0.823

package/esm2022/lib/services/auth/oauth.service.mjs

@@ -0,0 +1,322 @@
+import { Injectable, Inject } from '@angular/core';
+import { Observable, throwError } from 'rxjs';
+import { VALTECH_AUTH_CONFIG } from './config';
+import { catchError } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+/**
+ * Servicio de OAuth para login social.
+ *
+ * Implementa flujo OAuth server-side con popup:
+ * 1. Frontend abre popup hacia backend
+ * 2. Backend redirige a provider (Google, Apple, Microsoft)
+ * 3. Usuario autoriza
+ * 4. Backend intercambia code, genera JWT, redirige con tokens
+ * 5. Popup envía tokens a ventana padre via postMessage
+ *
+ * @example
+ * ```typescript
+ * import { OAuthService, AuthService } from 'valtech-components';
+ *
+ * @Component({...})
+ * export class LoginComponent {
+ *   private oauth = inject(OAuthService);
+ *   private auth = inject(AuthService);
+ *
+ *   async loginWithGoogle() {
+ *     this.oauth.startFlow('google').subscribe({
+ *       next: (result) => {
+ *         // Tokens recibidos, guardar en auth state
+ *         this.auth.handleOAuthSuccess(result);
+ *         this.router.navigate(['/']);
+ *       },
+ *       error: (error) => {
+ *         console.error('OAuth failed:', error);
+ *       }
+ *     });
+ *   }
+ * }
+ * ```
+ */
+export class OAuthService {
+    constructor(config, http, ngZone) {
+        this.config = config;
+        this.http = http;
+        this.ngZone = ngZone;
+        this.popup = null;
+        this.messageHandler = null;
+        this.checkClosedInterval = null;
+    }
+    /**
+     * Inicia flujo OAuth en popup.
+     * Retorna Observable que emite cuando el usuario completa el flujo.
+     *
+     * @param provider - Proveedor OAuth ('google', 'apple', 'microsoft')
+     * @returns Observable que emite OAuthResult o error
+     */
+    startFlow(provider) {
+        return new Observable(observer => {
+            // Construir URL de inicio
+            const redirectUri = `${window.location.origin}/auth/oauth/callback`;
+            const startUrl = `${this.config.apiUrl}/v2/auth/oauth/${provider}/start?redirect_uri=${encodeURIComponent(redirectUri)}`;
+            // Abrir popup centrado
+            const width = 500;
+            const height = 600;
+            const left = window.screenX + (window.outerWidth - width) / 2;
+            const top = window.screenY + (window.outerHeight - height) / 2;
+            const features = `width=${width},height=${height},left=${left},top=${top},popup=yes`;
+            this.popup = window.open(startUrl, 'oauth', features);
+            if (!this.popup) {
+                observer.error({
+                    code: 'POPUP_BLOCKED',
+                    message: 'El navegador bloqueó la ventana emergente. Por favor, permite popups para este sitio.',
+                });
+                return () => { };
+            }
+            // Escuchar mensajes del popup
+            this.messageHandler = (event) => {
+                // Validar origen
+                if (event.origin !== window.location.origin) {
+                    return;
+                }
+                // Validar tipo de mensaje
+                const data = event.data;
+                if (data?.type !== 'oauth-callback') {
+                    return;
+                }
+                // Limpiar
+                this.cleanup();
+                // Emitir resultado dentro de NgZone para trigger change detection
+                this.ngZone.run(() => {
+                    if (data.error) {
+                        observer.error(data.error);
+                    }
+                    else if (data.tokens) {
+                        observer.next(data.tokens);
+                        observer.complete();
+                    }
+                    else {
+                        observer.error({
+                            code: 'INVALID_RESPONSE',
+                            message: 'Respuesta inválida del servidor de autenticación',
+                        });
+                    }
+                });
+            };
+            window.addEventListener('message', this.messageHandler);
+            // Polling de localStorage (COOP workaround - no podemos detectar popup.closed)
+            // También verifica si el popup se cerró manualmente
+            this.checkClosedInterval = setInterval(() => {
+                // Primero verificar localStorage (funciona aunque COOP bloquee todo)
+                const storedData = this.checkLocalStorageFallback();
+                if (storedData) {
+                    this.cleanup();
+                    this.ngZone.run(() => {
+                        if (storedData.error) {
+                            observer.error(storedData.error);
+                        }
+                        else if (storedData.tokens) {
+                            console.log('[OAuthService] Retrieved tokens from localStorage fallback', {
+                                keys: Object.keys(storedData.tokens),
+                                hasFirebaseToken: !!storedData.tokens.firebaseToken,
+                                firebaseTokenLength: storedData.tokens.firebaseToken?.length ?? 0,
+                            });
+                            observer.next(storedData.tokens);
+                            observer.complete();
+                        }
+                        else {
+                            observer.error({
+                                code: 'INVALID_RESPONSE',
+                                message: 'Respuesta inválida del servidor de autenticación',
+                            });
+                        }
+                    });
+                    return;
+                }
+                // Intentar verificar si popup se cerró (puede fallar por COOP)
+                try {
+                    if (this.popup?.closed) {
+                        this.cleanup();
+                        this.ngZone.run(() => {
+                            observer.error({
+                                code: 'POPUP_CLOSED',
+                                message: 'Se cerró la ventana de autenticación',
+                            });
+                        });
+                    }
+                }
+                catch {
+                    // COOP bloquea acceso a popup.closed - ignorar y seguir con polling
+                }
+            }, 300);
+            // Cleanup cuando el observable se destruye
+            return () => this.cleanup();
+        });
+    }
+    /**
+     * Inicia flujo de linking para vincular un proveedor adicional.
+     * Requiere que el usuario esté autenticado.
+     *
+     * @param provider - Proveedor OAuth a vincular
+     * @returns Observable que emite cuando se completa el linking
+     */
+    startLinkFlow(provider) {
+        return new Observable(observer => {
+            const redirectUri = `${window.location.origin}/auth/oauth/callback`;
+            const startUrl = `${this.config.apiUrl}/v2/auth/oauth/link/${provider}/start?redirect_uri=${encodeURIComponent(redirectUri)}`;
+            const width = 500;
+            const height = 600;
+            const left = window.screenX + (window.outerWidth - width) / 2;
+            const top = window.screenY + (window.outerHeight - height) / 2;
+            const features = `width=${width},height=${height},left=${left},top=${top},popup=yes`;
+            this.popup = window.open(startUrl, 'oauth-link', features);
+            if (!this.popup) {
+                observer.error({
+                    code: 'POPUP_BLOCKED',
+                    message: 'El navegador bloqueó la ventana emergente',
+                });
+                return () => { }; // cleanup function
+            }
+            this.messageHandler = (event) => {
+                if (event.origin !== window.location.origin)
+                    return;
+                const data = event.data;
+                if (data?.type !== 'oauth-callback')
+                    return;
+                this.cleanup();
+                this.ngZone.run(() => {
+                    if (data.error) {
+                        observer.error(data.error);
+                    }
+                    else {
+                        observer.next(data.tokens || {});
+                        observer.complete();
+                    }
+                });
+            };
+            window.addEventListener('message', this.messageHandler);
+            this.checkClosedInterval = setInterval(() => {
+                if (this.popup?.closed) {
+                    this.cleanup();
+                    this.ngZone.run(() => {
+                        observer.error({
+                            code: 'POPUP_CLOSED',
+                            message: 'Se cerró la ventana de autenticación',
+                        });
+                    });
+                }
+            }, 500);
+            return () => this.cleanup();
+        });
+    }
+    /**
+     * Obtiene los proveedores OAuth vinculados al usuario.
+     */
+    getLinkedProviders() {
+        return this.http
+            .get(`${this.config.apiUrl}/v2/auth/oauth/providers`)
+            .pipe(catchError(error => throwError(() => ({
+            code: error.error?.code || 'FETCH_ERROR',
+            message: error.error?.message || 'Error al obtener proveedores vinculados',
+        }))));
+    }
+    /**
+     * Desvincula un proveedor OAuth.
+     */
+    unlinkProvider(provider) {
+        return this.http
+            .post(`${this.config.apiUrl}/v2/auth/oauth/unlink`, { provider })
+            .pipe(catchError(error => throwError(() => ({
+            code: error.error?.code || 'UNLINK_ERROR',
+            message: error.error?.message || 'Error al desvincular proveedor',
+        }))));
+    }
+    /**
+     * Establece contraseña para usuarios que solo tienen OAuth.
+     */
+    setPassword(password) {
+        return this.http
+            .post(`${this.config.apiUrl}/v2/auth/oauth/set-password`, { password })
+            .pipe(catchError(error => throwError(() => ({
+            code: error.error?.code || 'SET_PASSWORD_ERROR',
+            message: error.error?.message || 'Error al establecer contraseña',
+        }))));
+    }
+    /**
+     * Verifica si el usuario tiene contraseña establecida.
+     */
+    hasPassword() {
+        return this.http
+            .get(`${this.config.apiUrl}/v2/auth/oauth/has-password`)
+            .pipe(catchError(error => throwError(() => ({
+            code: error.error?.code || 'CHECK_PASSWORD_ERROR',
+            message: error.error?.message || 'Error al verificar contraseña',
+        }))));
+    }
+    /**
+     * Revisa localStorage por datos de callback OAuth (fallback para COOP).
+     * Solo acepta datos recientes (últimos 30 segundos).
+     */
+    checkLocalStorageFallback() {
+        try {
+            const timestamp = localStorage.getItem('oauth_callback_timestamp');
+            const dataStr = localStorage.getItem('oauth_callback_data');
+            if (!timestamp || !dataStr) {
+                return null;
+            }
+            // Solo aceptar datos de los últimos 30 segundos
+            const age = Date.now() - parseInt(timestamp, 10);
+            if (age > 30000) {
+                console.log('[OAuthService] localStorage data too old, ignoring');
+                this.clearLocalStorageFallback();
+                return null;
+            }
+            const data = JSON.parse(dataStr);
+            this.clearLocalStorageFallback();
+            return data;
+        }
+        catch (e) {
+            console.warn('[OAuthService] Error reading localStorage fallback:', e);
+            return null;
+        }
+    }
+    /**
+     * Limpia datos de fallback de localStorage.
+     */
+    clearLocalStorageFallback() {
+        try {
+            localStorage.removeItem('oauth_callback_data');
+            localStorage.removeItem('oauth_callback_timestamp');
+        }
+        catch {
+            // Ignorar errores de limpieza
+        }
+    }
+    /**
+     * Limpia recursos del popup.
+     */
+    cleanup() {
+        if (this.messageHandler) {
+            window.removeEventListener('message', this.messageHandler);
+            this.messageHandler = null;
+        }
+        if (this.checkClosedInterval) {
+            clearInterval(this.checkClosedInterval);
+            this.checkClosedInterval = null;
+        }
+        if (this.popup && !this.popup.closed) {
+            this.popup.close();
+        }
+        this.popup = null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: OAuthService, deps: [{ token: VALTECH_AUTH_CONFIG }, { token: i1.HttpClient }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: OAuthService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: OAuthService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [VALTECH_AUTH_CONFIG]
+                }] }, { type: i1.HttpClient }, { type: i0.NgZone }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"oauth.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/auth/oauth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Inject, NgZone } from '@angular/core';\nimport { Observable, Subject, throwError } from 'rxjs';\nimport { VALTECH_AUTH_CONFIG } from './config';\nimport {\n  ValtechAuthConfig,\n  OAuthProvider,\n  OAuthResult,\n  OAuthError,\n  OAuthCallbackData,\n  LinkedProvider,\n  HasPasswordResponse,\n} from './types';\nimport { HttpClient } from '@angular/common/http';\nimport { catchError } from 'rxjs/operators';\n\n/**\n * Servicio de OAuth para login social.\n *\n * Implementa flujo OAuth server-side con popup:\n * 1. Frontend abre popup hacia backend\n * 2. Backend redirige a provider (Google, Apple, Microsoft)\n * 3. Usuario autoriza\n * 4. Backend intercambia code, genera JWT, redirige con tokens\n * 5. Popup envía tokens a ventana padre via postMessage\n *\n * @example\n * ```typescript\n * import { OAuthService, AuthService } from 'valtech-components';\n *\n * @Component({...})\n * export class LoginComponent {\n *   private oauth = inject(OAuthService);\n *   private auth = inject(AuthService);\n *\n *   async loginWithGoogle() {\n *     this.oauth.startFlow('google').subscribe({\n *       next: (result) => {\n *         // Tokens recibidos, guardar en auth state\n *         this.auth.handleOAuthSuccess(result);\n *         this.router.navigate(['/']);\n *       },\n *       error: (error) => {\n *         console.error('OAuth failed:', error);\n *       }\n *     });\n *   }\n * }\n * ```\n */\n@Injectable({ providedIn: 'root' })\nexport class OAuthService {\n  private popup: Window | null = null;\n  private messageHandler: ((event: MessageEvent) => void) | null = null;\n  private checkClosedInterval: ReturnType<typeof setInterval> | null = null;\n\n  constructor(\n    @Inject(VALTECH_AUTH_CONFIG) private config: ValtechAuthConfig,\n    private http: HttpClient,\n    private ngZone: NgZone\n  ) {}\n\n  /**\n   * Inicia flujo OAuth en popup.\n   * Retorna Observable que emite cuando el usuario completa el flujo.\n   *\n   * @param provider - Proveedor OAuth ('google', 'apple', 'microsoft')\n   * @returns Observable que emite OAuthResult o error\n   */\n  startFlow(provider: OAuthProvider): Observable<OAuthResult> {\n    return new Observable(observer => {\n      // Construir URL de inicio\n      const redirectUri = `${window.location.origin}/auth/oauth/callback`;\n      const startUrl = `${this.config.apiUrl}/v2/auth/oauth/${provider}/start?redirect_uri=${encodeURIComponent(redirectUri)}`;\n\n      // Abrir popup centrado\n      const width = 500;\n      const height = 600;\n      const left = window.screenX + (window.outerWidth - width) / 2;\n      const top = window.screenY + (window.outerHeight - height) / 2;\n      const features = `width=${width},height=${height},left=${left},top=${top},popup=yes`;\n\n      this.popup = window.open(startUrl, 'oauth', features);\n\n      if (!this.popup) {\n        observer.error({\n          code: 'POPUP_BLOCKED',\n          message:\n            'El navegador bloqueó la ventana emergente. Por favor, permite popups para este sitio.',\n        } as OAuthError);\n        return () => {};\n      }\n\n      // Escuchar mensajes del popup\n      this.messageHandler = (event: MessageEvent) => {\n        // Validar origen\n        if (event.origin !== window.location.origin) {\n          return;\n        }\n\n        // Validar tipo de mensaje\n        const data = event.data as OAuthCallbackData;\n        if (data?.type !== 'oauth-callback') {\n          return;\n        }\n\n        // Limpiar\n        this.cleanup();\n\n        // Emitir resultado dentro de NgZone para trigger change detection\n        this.ngZone.run(() => {\n          if (data.error) {\n            observer.error(data.error);\n          } else if (data.tokens) {\n            observer.next(data.tokens);\n            observer.complete();\n          } else {\n            observer.error({\n              code: 'INVALID_RESPONSE',\n              message: 'Respuesta inválida del servidor de autenticación',\n            } as OAuthError);\n          }\n        });\n      };\n\n      window.addEventListener('message', this.messageHandler);\n\n      // Polling de localStorage (COOP workaround - no podemos detectar popup.closed)\n      // También verifica si el popup se cerró manualmente\n      this.checkClosedInterval = setInterval(() => {\n        // Primero verificar localStorage (funciona aunque COOP bloquee todo)\n        const storedData = this.checkLocalStorageFallback();\n        if (storedData) {\n          this.cleanup();\n          this.ngZone.run(() => {\n            if (storedData.error) {\n              observer.error(storedData.error);\n            } else if (storedData.tokens) {\n              console.log('[OAuthService] Retrieved tokens from localStorage fallback', {\n                keys: Object.keys(storedData.tokens),\n                hasFirebaseToken: !!storedData.tokens.firebaseToken,\n                firebaseTokenLength: storedData.tokens.firebaseToken?.length ?? 0,\n              });\n              observer.next(storedData.tokens);\n              observer.complete();\n            } else {\n              observer.error({\n                code: 'INVALID_RESPONSE',\n                message: 'Respuesta inválida del servidor de autenticación',\n              } as OAuthError);\n            }\n          });\n          return;\n        }\n\n        // Intentar verificar si popup se cerró (puede fallar por COOP)\n        try {\n          if (this.popup?.closed) {\n            this.cleanup();\n            this.ngZone.run(() => {\n              observer.error({\n                code: 'POPUP_CLOSED',\n                message: 'Se cerró la ventana de autenticación',\n              } as OAuthError);\n            });\n          }\n        } catch {\n          // COOP bloquea acceso a popup.closed - ignorar y seguir con polling\n        }\n      }, 300);\n\n      // Cleanup cuando el observable se destruye\n      return () => this.cleanup();\n    });\n  }\n\n  /**\n   * Inicia flujo de linking para vincular un proveedor adicional.\n   * Requiere que el usuario esté autenticado.\n   *\n   * @param provider - Proveedor OAuth a vincular\n   * @returns Observable que emite cuando se completa el linking\n   */\n  startLinkFlow(provider: OAuthProvider): Observable<OAuthResult> {\n    return new Observable(observer => {\n      const redirectUri = `${window.location.origin}/auth/oauth/callback`;\n      const startUrl = `${this.config.apiUrl}/v2/auth/oauth/link/${provider}/start?redirect_uri=${encodeURIComponent(redirectUri)}`;\n\n      const width = 500;\n      const height = 600;\n      const left = window.screenX + (window.outerWidth - width) / 2;\n      const top = window.screenY + (window.outerHeight - height) / 2;\n      const features = `width=${width},height=${height},left=${left},top=${top},popup=yes`;\n\n      this.popup = window.open(startUrl, 'oauth-link', features);\n\n      if (!this.popup) {\n        observer.error({\n          code: 'POPUP_BLOCKED',\n          message: 'El navegador bloqueó la ventana emergente',\n        } as OAuthError);\n        return () => {}; // cleanup function\n      }\n\n      this.messageHandler = (event: MessageEvent) => {\n        if (event.origin !== window.location.origin) return;\n\n        const data = event.data as OAuthCallbackData;\n        if (data?.type !== 'oauth-callback') return;\n\n        this.cleanup();\n\n        this.ngZone.run(() => {\n          if (data.error) {\n            observer.error(data.error);\n          } else {\n            observer.next(data.tokens || ({} as OAuthResult));\n            observer.complete();\n          }\n        });\n      };\n\n      window.addEventListener('message', this.messageHandler);\n\n      this.checkClosedInterval = setInterval(() => {\n        if (this.popup?.closed) {\n          this.cleanup();\n          this.ngZone.run(() => {\n            observer.error({\n              code: 'POPUP_CLOSED',\n              message: 'Se cerró la ventana de autenticación',\n            } as OAuthError);\n          });\n        }\n      }, 500);\n\n      return () => this.cleanup();\n    });\n  }\n\n  /**\n   * Obtiene los proveedores OAuth vinculados al usuario.\n   */\n  getLinkedProviders(): Observable<LinkedProvider[]> {\n    return this.http\n      .get<{ providers: LinkedProvider[] }>(`${this.config.apiUrl}/v2/auth/oauth/providers`)\n      .pipe(\n        catchError(error =>\n          throwError(\n            () =>\n              ({\n                code: error.error?.code || 'FETCH_ERROR',\n                message: error.error?.message || 'Error al obtener proveedores vinculados',\n              }) as OAuthError\n          )\n        )\n      ) as unknown as Observable<LinkedProvider[]>;\n  }\n\n  /**\n   * Desvincula un proveedor OAuth.\n   */\n  unlinkProvider(provider: OAuthProvider): Observable<{ success: boolean }> {\n    return this.http\n      .post<{ success: boolean }>(`${this.config.apiUrl}/v2/auth/oauth/unlink`, { provider })\n      .pipe(\n        catchError(error =>\n          throwError(\n            () =>\n              ({\n                code: error.error?.code || 'UNLINK_ERROR',\n                message: error.error?.message || 'Error al desvincular proveedor',\n              }) as OAuthError\n          )\n        )\n      );\n  }\n\n  /**\n   * Establece contraseña para usuarios que solo tienen OAuth.\n   */\n  setPassword(password: string): Observable<{ success: boolean }> {\n    return this.http\n      .post<{ success: boolean }>(`${this.config.apiUrl}/v2/auth/oauth/set-password`, { password })\n      .pipe(\n        catchError(error =>\n          throwError(\n            () =>\n              ({\n                code: error.error?.code || 'SET_PASSWORD_ERROR',\n                message: error.error?.message || 'Error al establecer contraseña',\n              }) as OAuthError\n          )\n        )\n      );\n  }\n\n  /**\n   * Verifica si el usuario tiene contraseña establecida.\n   */\n  hasPassword(): Observable<HasPasswordResponse> {\n    return this.http\n      .get<HasPasswordResponse>(`${this.config.apiUrl}/v2/auth/oauth/has-password`)\n      .pipe(\n        catchError(error =>\n          throwError(\n            () =>\n              ({\n                code: error.error?.code || 'CHECK_PASSWORD_ERROR',\n                message: error.error?.message || 'Error al verificar contraseña',\n              }) as OAuthError\n          )\n        )\n      );\n  }\n\n  /**\n   * Revisa localStorage por datos de callback OAuth (fallback para COOP).\n   * Solo acepta datos recientes (últimos 30 segundos).\n   */\n  private checkLocalStorageFallback(): OAuthCallbackData | null {\n    try {\n      const timestamp = localStorage.getItem('oauth_callback_timestamp');\n      const dataStr = localStorage.getItem('oauth_callback_data');\n\n      if (!timestamp || !dataStr) {\n        return null;\n      }\n\n      // Solo aceptar datos de los últimos 30 segundos\n      const age = Date.now() - parseInt(timestamp, 10);\n      if (age > 30000) {\n        console.log('[OAuthService] localStorage data too old, ignoring');\n        this.clearLocalStorageFallback();\n        return null;\n      }\n\n      const data = JSON.parse(dataStr) as OAuthCallbackData;\n      this.clearLocalStorageFallback();\n      return data;\n    } catch (e) {\n      console.warn('[OAuthService] Error reading localStorage fallback:', e);\n      return null;\n    }\n  }\n\n  /**\n   * Limpia datos de fallback de localStorage.\n   */\n  private clearLocalStorageFallback(): void {\n    try {\n      localStorage.removeItem('oauth_callback_data');\n      localStorage.removeItem('oauth_callback_timestamp');\n    } catch {\n      // Ignorar errores de limpieza\n    }\n  }\n\n  /**\n   * Limpia recursos del popup.\n   */\n  private cleanup(): void {\n    if (this.messageHandler) {\n      window.removeEventListener('message', this.messageHandler);\n      this.messageHandler = null;\n    }\n\n    if (this.checkClosedInterval) {\n      clearInterval(this.checkClosedInterval);\n      this.checkClosedInterval = null;\n    }\n\n    if (this.popup && !this.popup.closed) {\n      this.popup.close();\n    }\n    this.popup = null;\n  }\n}\n"]}

package/esm2022/lib/services/auth/org-switch.service.mjs

@@ -0,0 +1,137 @@
+import { Injectable, signal } from '@angular/core';
+import { firstValueFrom, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./auth.service";
+/**
+ * OrgSwitchService — orchestrates active organization changes across the app.
+ *
+ * Built on top of `AuthService.switchOrg`, which already:
+ * - Hits `POST /v2/auth/switch-org` and receives a new Firebase custom token.
+ * - Re-authenticates Firebase Auth with the new token (RBAC claims update).
+ * - Broadcasts `ORG_SWITCH` to other tabs via `AuthSyncService` (multi-tab sync).
+ *
+ * What this service adds on top:
+ * - A `switching` signal so the UI can show a loading indicator (1-2s switch).
+ * - An `orgChanged$` Observable that components subscribe to in order to
+ *   invalidate their org-scoped caches (e.g. drop old query results, reset
+ *   page state) without a full page reload.
+ * - Optional `reload: true` for apps where invalidating in-memory state piece
+ *   by piece is impractical.
+ *
+ * **What this service does NOT do automatically:**
+ *
+ * 1. **Teardown Firestore listeners.** Listeners are owned by their subscribing
+ *    components (typically via `takeUntilDestroyed` or async pipe). When the
+ *    component re-renders or unsubscribes, the listener disposes. If a
+ *    component does NOT unsubscribe on org change, its listener will keep
+ *    pointing at the previous org's path and may start failing rules. The fix
+ *    is component-level: subscribe to `orgChanged$` and reset state, or use
+ *    the `reload: true` option.
+ *
+ * 2. **Re-instantiate routed components.** Angular keeps mounted components
+ *    alive across navigations. If you need fresh state, either subscribe to
+ *    `orgChanged$` in the component, or use `reload: true`.
+ *
+ * @example Basic switch with loading state
+ * ```typescript
+ * private orgSwitch = inject(OrgSwitchService);
+ *
+ * async onSwitchOrg(orgId: string) {
+ *   await this.orgSwitch.switchTo(orgId);
+ *   // Components subscribed to orgChanged$ have already reset their state.
+ * }
+ *
+ * // In template:
+ * @if (orgSwitch.switching()) { <val-loading /> }
+ * ```
+ *
+ * @example Component reacting to org change
+ * ```typescript
+ * private orgSwitch = inject(OrgSwitchService);
+ *
+ * constructor() {
+ *   this.orgSwitch.orgChanged$
+ *     .pipe(takeUntilDestroyed())
+ *     .subscribe(() => this.resetState());
+ * }
+ * ```
+ *
+ * @example Brutal reload mode
+ * ```typescript
+ * await this.orgSwitch.switchTo(orgId, { reload: true });
+ * // window.location.reload() — clean slate, loses scroll position
+ * ```
+ */
+export class OrgSwitchService {
+    constructor(auth) {
+        this.auth = auth;
+        this._switching = signal(false);
+        this._orgChanged = new Subject();
+        /**
+         * `true` while a switch is in flight. UI should disable interactions
+         * with org-scoped data and show a loading indicator.
+         */
+        this.switching = this._switching.asReadonly();
+        /**
+         * Fires after a successful switch, with the previous and new org ids.
+         * Components subscribe to invalidate caches / reset state.
+         *
+         * Fires AFTER the Firebase re-auth completes — listeners attached here
+         * see the updated Firebase user / activeOrg claim.
+         */
+        this.orgChanged$ = this._orgChanged.asObservable();
+    }
+    /**
+     * Switch the user's active organization.
+     *
+     * Re-entrant safe: while a switch is in flight, additional calls are
+     * rejected silently (returns immediately). Inspect `switching()` to gate UI.
+     *
+     * @param orgId Target organization id. Must be one the user has a role in
+     *              — backend rejects otherwise with `PERMISSION_DENIED`.
+     * @param options See `SwitchOrgOptions`.
+     *
+     * @throws The error from `auth.switchOrg` if the backend call fails.
+     *         `switching` returns to `false` before the error propagates.
+     */
+    async switchTo(orgId, options = {}) {
+        if (this._switching()) {
+            return;
+        }
+        const previousOrg = this.currentActiveOrg();
+        if (previousOrg === orgId) {
+            // No-op — already on this org.
+            return;
+        }
+        this._switching.set(true);
+        try {
+            await firstValueFrom(this.auth.switchOrg(orgId));
+            this._orgChanged.next({ previousOrg, newOrg: orgId });
+            if (options.reload && typeof window !== 'undefined') {
+                window.location.reload();
+            }
+        }
+        finally {
+            this._switching.set(false);
+        }
+    }
+    /**
+     * Read the current `activeOrg` from the auth user signal.
+     * Falls back to empty string if the user isn't loaded yet.
+     */
+    currentActiveOrg() {
+        const user = this.auth.user();
+        // AuthUser may expose activeOrgId under different names depending on
+        // backend version — keep tolerant.
+        return (user?.activeOrgId ??
+            user?.activeOrg ??
+            '');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: OrgSwitchService, deps: [{ token: i1.AuthService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: OrgSwitchService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: OrgSwitchService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.AuthService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"org-switch.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/auth/org-switch.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,cAAc,EAAc,OAAO,EAAE,MAAM,MAAM,CAAC;;;AA8B3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AAEH,MAAM,OAAO,gBAAgB;IAmB3B,YAAoB,IAAiB;QAAjB,SAAI,GAAJ,IAAI,CAAa;QAlBpB,eAAU,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC3B,gBAAW,GAAG,IAAI,OAAO,EAAmB,CAAC;QAE9D;;;WAGG;QACM,cAAS,GAAG,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,CAAC;QAElD;;;;;;WAMG;QACM,gBAAW,GAAgC,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,CAAC;IAE5C,CAAC;IAEzC;;;;;;;;;;;;OAYG;IACH,KAAK,CAAC,QAAQ,CAAC,KAAa,EAAE,UAA4B,EAAE;QAC1D,IAAI,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;YACtB,OAAO;QACT,CAAC;QAED,MAAM,WAAW,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC5C,IAAI,WAAW,KAAK,KAAK,EAAE,CAAC;YAC1B,+BAA+B;YAC/B,OAAO;QACT,CAAC;QAED,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC1B,IAAI,CAAC;YACH,MAAM,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;YACjD,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;YAEtD,IAAI,OAAO,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE,CAAC;gBACpD,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;YAC3B,CAAC;QACH,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAC7B,CAAC;IACH,CAAC;IAED;;;OAGG;IACK,gBAAgB;QACtB,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;QAC9B,qEAAqE;QACrE,mCAAmC;QACnC,OAAO,CACJ,IAA4D,EAAE,WAAW;YACzE,IAA4D,EAAE,SAAS;YACxE,EAAE,CACH,CAAC;IACJ,CAAC;+GAvEU,gBAAgB;mHAAhB,gBAAgB,cADH,MAAM;;4FACnB,gBAAgB;kBAD5B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE","sourcesContent":["import { Injectable, signal } from '@angular/core';\nimport { firstValueFrom, Observable, Subject } from 'rxjs';\n\nimport { AuthService } from './auth.service';\n\n/**\n * Event emitted when the active organization changes.\n */\nexport interface OrgChangedEvent {\n  /** Org the user was on before the switch. May be empty on first sign-in. */\n  previousOrg: string;\n  /** Org the user just switched to. */\n  newOrg: string;\n}\n\n/**\n * Options for `OrgSwitchService.switchTo`.\n */\nexport interface SwitchOrgOptions {\n  /**\n   * If `true`, after the switch succeeds the page is fully reloaded via\n   * `window.location.reload()`. Useful for apps with significant in-memory\n   * state tied to the previous org that's hard to invalidate piece by piece.\n   *\n   * Trade-off: reload loses all in-memory state (forms, scroll position).\n   * Default: `false` — relies on `orgChanged$` and `auth.user()` signal\n   * propagation for components to react.\n   */\n  reload?: boolean;\n}\n\n/**\n * OrgSwitchService — orchestrates active organization changes across the app.\n *\n * Built on top of `AuthService.switchOrg`, which already:\n * - Hits `POST /v2/auth/switch-org` and receives a new Firebase custom token.\n * - Re-authenticates Firebase Auth with the new token (RBAC claims update).\n * - Broadcasts `ORG_SWITCH` to other tabs via `AuthSyncService` (multi-tab sync).\n *\n * What this service adds on top:\n * - A `switching` signal so the UI can show a loading indicator (1-2s switch).\n * - An `orgChanged$` Observable that components subscribe to in order to\n *   invalidate their org-scoped caches (e.g. drop old query results, reset\n *   page state) without a full page reload.\n * - Optional `reload: true` for apps where invalidating in-memory state piece\n *   by piece is impractical.\n *\n * **What this service does NOT do automatically:**\n *\n * 1. **Teardown Firestore listeners.** Listeners are owned by their subscribing\n *    components (typically via `takeUntilDestroyed` or async pipe). When the\n *    component re-renders or unsubscribes, the listener disposes. If a\n *    component does NOT unsubscribe on org change, its listener will keep\n *    pointing at the previous org's path and may start failing rules. The fix\n *    is component-level: subscribe to `orgChanged$` and reset state, or use\n *    the `reload: true` option.\n *\n * 2. **Re-instantiate routed components.** Angular keeps mounted components\n *    alive across navigations. If you need fresh state, either subscribe to\n *    `orgChanged$` in the component, or use `reload: true`.\n *\n * @example Basic switch with loading state\n * ```typescript\n * private orgSwitch = inject(OrgSwitchService);\n *\n * async onSwitchOrg(orgId: string) {\n *   await this.orgSwitch.switchTo(orgId);\n *   // Components subscribed to orgChanged$ have already reset their state.\n * }\n *\n * // In template:\n * @if (orgSwitch.switching()) { <val-loading /> }\n * ```\n *\n * @example Component reacting to org change\n * ```typescript\n * private orgSwitch = inject(OrgSwitchService);\n *\n * constructor() {\n *   this.orgSwitch.orgChanged$\n *     .pipe(takeUntilDestroyed())\n *     .subscribe(() => this.resetState());\n * }\n * ```\n *\n * @example Brutal reload mode\n * ```typescript\n * await this.orgSwitch.switchTo(orgId, { reload: true });\n * // window.location.reload() — clean slate, loses scroll position\n * ```\n */\n@Injectable({ providedIn: 'root' })\nexport class OrgSwitchService {\n  private readonly _switching = signal(false);\n  private readonly _orgChanged = new Subject<OrgChangedEvent>();\n\n  /**\n   * `true` while a switch is in flight. UI should disable interactions\n   * with org-scoped data and show a loading indicator.\n   */\n  readonly switching = this._switching.asReadonly();\n\n  /**\n   * Fires after a successful switch, with the previous and new org ids.\n   * Components subscribe to invalidate caches / reset state.\n   *\n   * Fires AFTER the Firebase re-auth completes — listeners attached here\n   * see the updated Firebase user / activeOrg claim.\n   */\n  readonly orgChanged$: Observable<OrgChangedEvent> = this._orgChanged.asObservable();\n\n  constructor(private auth: AuthService) {}\n\n  /**\n   * Switch the user's active organization.\n   *\n   * Re-entrant safe: while a switch is in flight, additional calls are\n   * rejected silently (returns immediately). Inspect `switching()` to gate UI.\n   *\n   * @param orgId Target organization id. Must be one the user has a role in\n   *              — backend rejects otherwise with `PERMISSION_DENIED`.\n   * @param options See `SwitchOrgOptions`.\n   *\n   * @throws The error from `auth.switchOrg` if the backend call fails.\n   *         `switching` returns to `false` before the error propagates.\n   */\n  async switchTo(orgId: string, options: SwitchOrgOptions = {}): Promise<void> {\n    if (this._switching()) {\n      return;\n    }\n\n    const previousOrg = this.currentActiveOrg();\n    if (previousOrg === orgId) {\n      // No-op — already on this org.\n      return;\n    }\n\n    this._switching.set(true);\n    try {\n      await firstValueFrom(this.auth.switchOrg(orgId));\n      this._orgChanged.next({ previousOrg, newOrg: orgId });\n\n      if (options.reload && typeof window !== 'undefined') {\n        window.location.reload();\n      }\n    } finally {\n      this._switching.set(false);\n    }\n  }\n\n  /**\n   * Read the current `activeOrg` from the auth user signal.\n   * Falls back to empty string if the user isn't loaded yet.\n   */\n  private currentActiveOrg(): string {\n    const user = this.auth.user();\n    // AuthUser may expose activeOrgId under different names depending on\n    // backend version — keep tolerant.\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"]}

package/esm2022/lib/services/auth/session.service.mjs

@@ -0,0 +1,78 @@
+import { Injectable, Inject } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { VALTECH_AUTH_CONFIG } from './config';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+/**
+ * Servicio para gestión de sesiones activas del usuario.
+ * Permite listar y revocar sesiones.
+ *
+ * @example
+ * ```typescript
+ * import { SessionService } from 'valtech-components';
+ *
+ * @Component({...})
+ * export class SessionsPage {
+ *   private sessionService = inject(SessionService);
+ *
+ *   sessions = signal<SessionInfo[]>([]);
+ *
+ *   async ngOnInit() {
+ *     const sessions = await firstValueFrom(this.sessionService.listSessions());
+ *     this.sessions.set(sessions);
+ *   }
+ *
+ *   async revokeSession(sessionId: string) {
+ *     await firstValueFrom(this.sessionService.revokeSession(sessionId));
+ *     // Recargar lista
+ *   }
+ *
+ *   async revokeAllOthers() {
+ *     const result = await firstValueFrom(this.sessionService.revokeAllSessions());
+ *     console.log(`${result.sessionsRevoked} sesiones cerradas`);
+ *   }
+ * }
+ * ```
+ */
+export class SessionService {
+    constructor(config, http) {
+        this.config = config;
+        this.http = http;
+    }
+    get baseUrl() {
+        return `${this.config.apiUrl}/v2/users/me/sessions`;
+    }
+    /**
+     * Lista todas las sesiones activas del usuario.
+     * La sesión actual está marcada con isCurrent=true.
+     */
+    listSessions() {
+        return this.http.get(this.baseUrl).pipe(map(response => response.sessions));
+    }
+    /**
+     * Revoca una sesión específica.
+     * Fuerza el cierre de sesión en ese dispositivo/navegador.
+     */
+    revokeSession(sessionId) {
+        return this.http.delete(`${this.baseUrl}/${sessionId}`);
+    }
+    /**
+     * Revoca todas las sesiones excepto la actual.
+     * Útil para "cerrar sesión en todos los dispositivos".
+     *
+     * @returns Número de sesiones revocadas
+     */
+    revokeAllSessions() {
+        return this.http.delete(this.baseUrl);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SessionService, deps: [{ token: VALTECH_AUTH_CONFIG }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SessionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SessionService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [VALTECH_AUTH_CONFIG]
+                }] }, { type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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