valtech-components 2.0.687 → 2.0.689

package/lib/services/firebase/firebase.service.d.ts

@@ -1,251 +0,0 @@
-import { Auth, UserCredential } from '@angular/fire/auth';
-import { Observable } from 'rxjs';
-import { FirebaseUser, MembershipInfo, OrganizationInfo, SessionState, ValtechFirebaseConfig } from './types';
-import * as i0 from "@angular/core";
-/**
- * Servicio de autenticación de Firebase.
- *
- * Este servicio NO maneja el login de usuarios directamente.
- * En su lugar, trabaja con Custom Tokens generados por tu backend.
- *
- * @example
- * ```typescript
- * // Después de autenticarte con tu backend (ej: Cognito)
- * @Component({...})
- * export class LoginComponent {
- *   private authService = inject(AuthService);     // Tu servicio de auth
- *   private firebase = inject(FirebaseService);    // Este servicio
- *
- *   async login(email: string, password: string) {
- *     // 1. Autenticar con tu backend
- *     const response = await this.authService.login(email, password);
- *
- *     // 2. El backend devuelve un Firebase Custom Token
- *     if (response.firebaseToken) {
- *       await this.firebase.signInWithCustomToken(response.firebaseToken);
- *     }
- *
- *     // Ahora el usuario puede acceder a Firestore, Storage, etc.
- *   }
- *
- *   async logout() {
- *     await this.authService.logout();
- *     await this.firebase.signOut();
- *   }
- * }
- * ```
- */
-export declare class FirebaseService {
-    private auth;
-    private config;
-    /** Estado interno de la sesión */
-    private sessionState;
-    /** Estado actual de la sesión como Observable */
-    readonly state$: Observable<SessionState>;
-    /** Usuario actual de Firebase como Observable */
-    readonly user$: Observable<FirebaseUser | null>;
-    /** Indica si el usuario está autenticado en Firebase */
-    readonly isAuthenticated$: Observable<boolean>;
-    constructor(auth: Auth, config: ValtechFirebaseConfig);
-    /**
-     * Autentica al usuario con un Custom Token generado por el backend.
-     *
-     * @param token - Firebase Custom Token generado por tu backend
-     * @returns UserCredential con la información del usuario
-     * @throws Error si el token es inválido o expiró
-     *
-     * @example
-     * ```typescript
-     * // Después de login exitoso con tu backend
-     * const { firebaseToken } = await backendAuth.login(email, password);
-     * await firebaseService.signInWithCustomToken(firebaseToken);
-     * ```
-     */
-    signInWithCustomToken(token: string): Promise<UserCredential>;
-    /**
-     * Cierra la sesión de Firebase.
-     * Llamar junto con el logout de tu sistema de autenticación principal.
-     *
-     * @example
-     * ```typescript
-     * async logout() {
-     *   await this.backendAuth.logout();    // Tu auth
-     *   await this.firebase.signOut();       // Firebase
-     * }
-     * ```
-     */
-    signOut(): Promise<void>;
-    /**
-     * Obtiene el usuario actual de Firebase (síncrono).
-     * Retorna null si no hay usuario autenticado.
-     */
-    get currentUser(): FirebaseUser | null;
-    /**
-     * Obtiene el UID del usuario actual.
-     * Retorna null si no hay usuario autenticado.
-     */
-    get uid(): string | null;
-    /**
-     * Indica si hay un usuario autenticado actualmente.
-     */
-    get isAuthenticated(): boolean;
-    /**
-     * Obtiene el ID Token de Firebase para el usuario actual.
-     * Útil para validar el usuario en tu backend.
-     *
-     * @param forceRefresh - Si true, fuerza la renovación del token
-     * @returns ID Token o null si no hay usuario
-     */
-    getIdToken(forceRefresh?: boolean): Promise<string | null>;
-    /**
-     * Obtiene los claims personalizados del token del usuario.
-     * Los claims son establecidos por tu backend al crear el Custom Token.
-     *
-     * @param forceRefresh - Si true, fuerza la renovación del token para obtener claims actualizados
-     * @returns Objeto con los claims o vacío si no hay usuario
-     */
-    getClaims(forceRefresh?: boolean): Promise<Record<string, unknown>>;
-    /**
-     * Verifica si el usuario tiene un rol específico.
-     * El rol debe estar definido en los claims del Custom Token.
-     *
-     * @param role - Nombre del rol a verificar
-     * @returns true si el usuario tiene el rol
-     */
-    hasRole(role: string): Promise<boolean>;
-    /**
-     * Obtiene las memberships (organizaciones) del usuario.
-     * Cada membership contiene el rol y permisos en esa organización.
-     *
-     * @param forceRefresh - Si true, fuerza la renovación del token
-     * @returns Mapa de orgId → MembershipInfo
-     *
-     * @example
-     * ```typescript
-     * const memberships = await firebaseService.getMemberships();
-     * // { 'org_abc': { roleId: 'admin', roleName: 'admin', permissions: ['users:*', ...] } }
-     * ```
-     */
-    getMemberships(forceRefresh?: boolean): Promise<Record<string, MembershipInfo>>;
-    /**
-     * Obtiene la organización activa del usuario.
-     * La organización activa se establece al hacer login o al cambiar de org.
-     *
-     * @param forceRefresh - Si true, fuerza la renovación del token
-     * @returns ID de la organización activa o null si no hay ninguna
-     */
-    getActiveOrg(forceRefresh?: boolean): Promise<string | null>;
-    /**
-     * Obtiene información de todas las organizaciones del usuario.
-     *
-     * @param forceRefresh - Si true, fuerza la renovación del token
-     * @returns Array con información de cada organización
-     */
-    getOrganizations(forceRefresh?: boolean): Promise<OrganizationInfo[]>;
-    /**
-     * Obtiene los IDs de todas las organizaciones del usuario.
-     *
-     * @returns Array de IDs de organizaciones
-     */
-    getOrganizationIds(): Promise<string[]>;
-    /**
-     * Verifica si el usuario pertenece a una organización.
-     *
-     * @param orgId - ID de la organización
-     * @returns true si el usuario es miembro
-     */
-    isMemberOf(orgId: string): Promise<boolean>;
-    /**
-     * Obtiene el rol del usuario en una organización.
-     *
-     * @param orgId - ID de la organización
-     * @returns ID del rol o null si no es miembro
-     */
-    getRoleInOrg(orgId: string): Promise<string | null>;
-    /**
-     * Obtiene los permisos del usuario en una organización.
-     *
-     * @param orgId - ID de la organización
-     * @returns Array de permisos en formato 'resource:action'
-     */
-    getPermissionsInOrg(orgId: string): Promise<string[]>;
-    /**
-     * Verifica si el usuario tiene un permiso específico en una organización.
-     * Soporta wildcards: 'resource:*' y '*:*' (super admin).
-     *
-     * @param orgId - ID de la organización
-     * @param resource - Recurso a verificar (ej: 'users', 'documents')
-     * @param action - Acción a verificar (ej: 'read', 'write', 'create', 'delete')
-     * @returns true si tiene el permiso
-     *
-     * @example
-     * ```typescript
-     * // Verificar permiso específico
-     * const canReadUsers = await firebaseService.hasPermission('org_abc', 'users', 'read');
-     *
-     * // Verificar en la organización activa
-     * const orgId = await firebaseService.getActiveOrg();
-     * const canEdit = await firebaseService.hasPermission(orgId!, 'documents', 'write');
-     * ```
-     */
-    hasPermission(orgId: string, resource: string, action: string): Promise<boolean>;
-    /**
-     * Verifica si el usuario puede leer un recurso en una organización.
-     * Atajo para hasPermission(orgId, resource, 'read').
-     */
-    canRead(orgId: string, resource: string): Promise<boolean>;
-    /**
-     * Verifica si el usuario puede escribir un recurso en una organización.
-     * Atajo para hasPermission(orgId, resource, 'write').
-     */
-    canWrite(orgId: string, resource: string): Promise<boolean>;
-    /**
-     * Verifica si el usuario puede crear un recurso en una organización.
-     * Atajo para hasPermission(orgId, resource, 'create').
-     */
-    canCreate(orgId: string, resource: string): Promise<boolean>;
-    /**
-     * Verifica si el usuario puede eliminar un recurso en una organización.
-     * Atajo para hasPermission(orgId, resource, 'delete').
-     */
-    canDelete(orgId: string, resource: string): Promise<boolean>;
-    /**
-     * Verifica si el usuario puede administrar un recurso en una organización.
-     * Equivale a tener 'resource:*' o '*:*'.
-     */
-    canManage(orgId: string, resource: string): Promise<boolean>;
-    /**
-     * Verifica si el usuario es super admin en una organización.
-     * Super admin tiene el permiso '*:*'.
-     */
-    isSuperAdmin(orgId: string): Promise<boolean>;
-    /**
-     * Verifica si el usuario es admin en una organización.
-     */
-    isAdminInOrg(orgId: string): Promise<boolean>;
-    /**
-     * Espera a que el estado de autenticación esté determinado.
-     * Útil en guards o al inicializar la app.
-     *
-     * @returns Usuario actual o null
-     */
-    waitForAuth(): Promise<FirebaseUser | null>;
-    /**
-     * Obtiene la configuración actual de Firebase.
-     */
-    getConfig(): ValtechFirebaseConfig;
-    /**
-     * Indica si los emuladores están habilitados.
-     */
-    isUsingEmulators(): boolean;
-    /**
-     * Mapea un User de Firebase a nuestra interface FirebaseUser
-     */
-    private mapUser;
-    /**
-     * Convierte errores de Firebase a mensajes en español
-     */
-    private getErrorMessage;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FirebaseService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<FirebaseService>;
-}

package/lib/services/firebase/firestore-collection.d.ts

@@ -1,175 +0,0 @@
-import { Observable } from 'rxjs';
-import { FirestoreService } from './firestore.service';
-import { FirestoreDocument, PaginatedResult, QueryOptions } from './types';
-import * as i0 from "@angular/core";
-/**
- * Opciones de configuración para una colección.
- */
-export interface CollectionOptions {
-    /**
-     * Si true, usa soft delete (marca deletedAt en lugar de eliminar).
-     * Default: false
-     */
-    softDelete?: boolean;
-    /**
-     * Si true, maneja automáticamente createdAt/updatedAt.
-     * Default: true
-     */
-    timestamps?: boolean;
-}
-/**
- * Referencia a una sub-colección tipada.
- */
-export interface SubCollectionRef<T extends FirestoreDocument> {
-    getById(id: string): Promise<T | null>;
-    getAll(options?: QueryOptions): Promise<T[]>;
-    watch(id: string): Observable<T | null>;
-    watchAll(options?: QueryOptions): Observable<T[]>;
-    create(data: Omit<T, 'id' | 'createdAt' | 'updatedAt'>): Promise<T>;
-    update(id: string, data: Partial<T>): Promise<void>;
-    delete(id: string): Promise<void>;
-}
-/**
- * Factory para crear instancias de colección tipadas.
- *
- * @example
- * ```typescript
- * @Injectable({ providedIn: 'root' })
- * export class UsersService {
- *   private users = inject(FirestoreCollectionFactory).create<User>('users');
- *
- *   getAll = () => this.users.getAll();
- *   getById = (id: string) => this.users.getById(id);
- *   create = (data: Omit<User, 'id'>) => this.users.create(data);
- *
- *   // Métodos personalizados
- *   async getActiveUsers(): Promise<User[]> {
- *     return this.users.query({
- *       where: [{ field: 'active', operator: '==', value: true }]
- *     });
- *   }
- * }
- * ```
- */
-export declare class FirestoreCollectionFactory {
-    private firestore;
-    constructor(firestore: FirestoreService);
-    /**
-     * Crea una instancia de colección tipada.
-     *
-     * @param collectionPath - Ruta de la colección en Firestore
-     * @param options - Opciones de configuración
-     * @returns Instancia de TypedCollection
-     */
-    create<T extends FirestoreDocument>(collectionPath: string, options?: CollectionOptions): TypedCollection<T>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FirestoreCollectionFactory, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<FirestoreCollectionFactory>;
-}
-/**
- * Colección tipada con métodos CRUD.
- *
- * NO usa inject() - recibe FirestoreService por constructor.
- * Esto evita el error NG0203.
- */
-export declare class TypedCollection<T extends FirestoreDocument> {
-    private firestore;
-    private collectionPath;
-    private readonly options;
-    constructor(firestore: FirestoreService, collectionPath: string, options?: CollectionOptions);
-    /**
-     * Obtiene un documento por ID.
-     */
-    getById(id: string): Promise<T | null>;
-    /**
-     * Obtiene todos los documentos de la colección.
-     */
-    getAll(options?: QueryOptions): Promise<T[]>;
-    /**
-     * Ejecuta una query personalizada.
-     */
-    query(options: QueryOptions): Promise<T[]>;
-    /**
-     * Obtiene documentos con paginación.
-     */
-    paginate(options: QueryOptions & {
-        limit: number;
-    }): Promise<PaginatedResult<T>>;
-    /**
-     * Obtiene el primer documento que coincida con la query.
-     */
-    getFirst(options?: QueryOptions): Promise<T | null>;
-    /**
-     * Cuenta los documentos que coinciden con la query.
-     * Nota: Esto carga todos los documentos, usar con cuidado en colecciones grandes.
-     */
-    count(options?: QueryOptions): Promise<number>;
-    /**
-     * Verifica si un documento existe.
-     */
-    exists(id: string): Promise<boolean>;
-    /**
-     * Suscribe a cambios de un documento.
-     */
-    watch(id: string): Observable<T | null>;
-    /**
-     * Suscribe a cambios de la colección.
-     */
-    watchAll(options?: QueryOptions): Observable<T[]>;
-    /**
-     * Suscribe a una query personalizada.
-     */
-    watchQuery(options: QueryOptions): Observable<T[]>;
-    /**
-     * Crea un nuevo documento con ID auto-generado.
-     */
-    create(data: Omit<T, 'id' | 'createdAt' | 'updatedAt'>): Promise<T>;
-    /**
-     * Crea un documento con ID específico.
-     */
-    createWithId(id: string, data: Omit<T, 'id'>): Promise<void>;
-    /**
-     * Actualiza campos de un documento.
-     */
-    update(id: string, data: Partial<Omit<T, 'id' | 'createdAt'>>): Promise<void>;
-    /**
-     * Elimina un documento.
-     * Si softDelete está habilitado, marca como eliminado en lugar de borrar.
-     */
-    delete(id: string): Promise<void>;
-    /**
-     * Restaura un documento soft-deleted.
-     */
-    restore(id: string): Promise<void>;
-    /**
-     * Obtiene una referencia a una sub-colección.
-     *
-     * @example
-     * ```typescript
-     * // En UsersService
-     * getUserDocuments(userId: string) {
-     *   return this.users.subcollection<Document>(userId, 'documents');
-     * }
-     *
-     * // Uso
-     * const docs = await users.getUserDocuments('user123').getAll();
-     * ```
-     */
-    subcollection<S extends FirestoreDocument>(parentId: string, subcollectionName: string): SubCollectionRef<S>;
-    /**
-     * Aplica filtros por defecto a las queries.
-     */
-    private applyDefaultFilters;
-    /**
-     * Genera un nuevo ID sin crear el documento.
-     */
-    generateId(): string;
-    /**
-     * Obtiene la ruta de la colección.
-     */
-    getPath(): string;
-}
-/**
- * @deprecated Use FirestoreCollectionFactory.create() instead.
- * Type alias for backwards compatibility.
- */
-export type FirestoreCollection<T extends FirestoreDocument> = TypedCollection<T>;