valtech-components 2.0.452 → 2.0.453

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

@@ -0,0 +1,304 @@
+import { Firestore, FieldValue } from '@angular/fire/firestore';
+import { Observable } from 'rxjs';
+import { FirestoreDocument, PaginatedResult, QueryOptions } from './types';
+import * as i0 from "@angular/core";
+/**
+ * Servicio para operaciones CRUD en Firestore.
+ *
+ * @example
+ * ```typescript
+ * interface User extends FirestoreDocument {
+ *   name: string;
+ *   email: string;
+ *   role: 'admin' | 'user';
+ * }
+ *
+ * @Component({...})
+ * export class UsersComponent {
+ *   private firestore = inject(FirestoreService);
+ *
+ *   // Lectura one-time
+ *   async loadUser(id: string) {
+ *     const user = await this.firestore.getDoc<User>('users', id);
+ *   }
+ *
+ *   // Subscripción real-time
+ *   users$ = this.firestore.collectionChanges<User>('users', {
+ *     where: [{ field: 'role', operator: '==', value: 'admin' }],
+ *     orderBy: [{ field: 'name', direction: 'asc' }]
+ *   });
+ *
+ *   // Crear documento
+ *   async createUser(data: Omit<User, 'id'>) {
+ *     const user = await this.firestore.addDoc<User>('users', data);
+ *   }
+ * }
+ * ```
+ */
+export declare class FirestoreService {
+    private firestore;
+    constructor(firestore: Firestore);
+    /**
+     * Obtiene un documento por ID (lectura única).
+     *
+     * @param collectionPath - Ruta de la colección
+     * @param docId - ID del documento
+     * @returns Documento o null si no existe
+     *
+     * @example
+     * ```typescript
+     * const user = await firestoreService.getDoc<User>('users', 'abc123');
+     * if (user) {
+     *   console.log(user.name);
+     * }
+     * ```
+     */
+    getDoc<T extends FirestoreDocument>(collectionPath: string, docId: string): Promise<T | null>;
+    /**
+     * Obtiene múltiples documentos con opciones de query.
+     *
+     * @param collectionPath - Ruta de la colección
+     * @param options - Opciones de query (where, orderBy, limit)
+     * @returns Array de documentos
+     *
+     * @example
+     * ```typescript
+     * // Todos los usuarios activos ordenados por nombre
+     * const users = await firestoreService.getDocs<User>('users', {
+     *   where: [{ field: 'active', operator: '==', value: true }],
+     *   orderBy: [{ field: 'name', direction: 'asc' }],
+     *   limit: 50
+     * });
+     * ```
+     */
+    getDocs<T extends FirestoreDocument>(collectionPath: string, options?: QueryOptions): Promise<T[]>;
+    /**
+     * Obtiene documentos con paginación basada en cursores.
+     *
+     * @param collectionPath - Ruta de la colección
+     * @param options - Opciones de query (debe incluir limit)
+     * @returns Resultado paginado con cursor para la siguiente página
+     *
+     * @example
+     * ```typescript
+     * // Primera página
+     * const page1 = await firestoreService.getPaginated<User>('users', {
+     *   orderBy: [{ field: 'createdAt', direction: 'desc' }],
+     *   limit: 10
+     * });
+     *
+     * // Siguiente página
+     * if (page1.hasMore) {
+     *   const page2 = await firestoreService.getPaginated<User>('users', {
+     *     orderBy: [{ field: 'createdAt', direction: 'desc' }],
+     *     limit: 10,
+     *     startAfter: page1.lastDoc
+     *   });
+     * }
+     * ```
+     */
+    getPaginated<T extends FirestoreDocument>(collectionPath: string, options: QueryOptions & {
+        limit: number;
+    }): Promise<PaginatedResult<T>>;
+    /**
+     * Verifica si un documento existe.
+     *
+     * @param collectionPath - Ruta de la colección
+     * @param docId - ID del documento
+     * @returns true si el documento existe
+     */
+    exists(collectionPath: string, docId: string): Promise<boolean>;
+    /**
+     * Suscribe a cambios de un documento (real-time).
+     *
+     * @param collectionPath - Ruta de la colección
+     * @param docId - ID del documento
+     * @returns Observable que emite cuando el documento cambia
+     *
+     * @example
+     * ```typescript
+     * // En el componente
+     * user$ = this.firestoreService.docChanges<User>('users', this.userId);
+     *
+     * // En el template
+     * @if (user$ | async; as user) {
+     *   <p>{{ user.name }}</p>
+     * }
+     * ```
+     */
+    docChanges<T extends FirestoreDocument>(collectionPath: string, docId: string): Observable<T | null>;
+    /**
+     * Suscribe a cambios de una colección (real-time).
+     *
+     * @param collectionPath - Ruta de la colección
+     * @param options - Opciones de query
+     * @returns Observable que emite cuando la colección cambia
+     *
+     * @example
+     * ```typescript
+     * // Usuarios activos en tiempo real
+     * activeUsers$ = this.firestoreService.collectionChanges<User>('users', {
+     *   where: [{ field: 'status', operator: '==', value: 'online' }]
+     * });
+     * ```
+     */
+    collectionChanges<T extends FirestoreDocument>(collectionPath: string, options?: QueryOptions): Observable<T[]>;
+    /**
+     * Agrega un documento con ID auto-generado.
+     *
+     * @param collectionPath - Ruta de la colección
+     * @param data - Datos del documento (sin id, createdAt, updatedAt)
+     * @returns Documento creado con su ID
+     *
+     * @example
+     * ```typescript
+     * const newUser = await firestoreService.addDoc<User>('users', {
+     *   name: 'John Doe',
+     *   email: 'john@example.com',
+     *   role: 'user'
+     * });
+     * console.log('Created user with ID:', newUser.id);
+     * ```
+     */
+    addDoc<T extends FirestoreDocument>(collectionPath: string, data: Omit<T, 'id' | 'createdAt' | 'updatedAt'>): Promise<T>;
+    /**
+     * Crea o sobrescribe un documento con ID específico.
+     *
+     * @param collectionPath - Ruta de la colección
+     * @param docId - ID del documento
+     * @param data - Datos del documento
+     * @param options - Opciones (merge: true para merge en lugar de sobrescribir)
+     *
+     * @example
+     * ```typescript
+     * // Sobrescribir completamente
+     * await firestoreService.setDoc<User>('users', 'user123', userData);
+     *
+     * // Merge con datos existentes
+     * await firestoreService.setDoc<User>('users', 'user123', { name: 'New Name' }, { merge: true });
+     * ```
+     */
+    setDoc<T extends FirestoreDocument>(collectionPath: string, docId: string, data: Omit<T, 'id'>, options?: {
+        merge?: boolean;
+    }): Promise<void>;
+    /**
+     * Actualiza campos específicos de un documento.
+     *
+     * @param collectionPath - Ruta de la colección
+     * @param docId - ID del documento
+     * @param data - Campos a actualizar
+     *
+     * @example
+     * ```typescript
+     * await firestoreService.updateDoc<User>('users', 'user123', {
+     *   name: 'Updated Name',
+     *   lastLogin: new Date()
+     * });
+     * ```
+     */
+    updateDoc<T extends FirestoreDocument>(collectionPath: string, docId: string, data: Partial<Omit<T, 'id' | 'createdAt'>>): Promise<void>;
+    /**
+     * Elimina un documento.
+     *
+     * @param collectionPath - Ruta de la colección
+     * @param docId - ID del documento
+     *
+     * @example
+     * ```typescript
+     * await firestoreService.deleteDoc('users', 'user123');
+     * ```
+     */
+    deleteDoc(collectionPath: string, docId: string): Promise<void>;
+    /**
+     * Ejecuta múltiples operaciones de escritura de forma atómica.
+     *
+     * @param operations - Función que recibe el batch y agrega operaciones
+     *
+     * @example
+     * ```typescript
+     * await firestoreService.batch((batch) => {
+     *   batch.set('users/user1', { name: 'User 1' });
+     *   batch.update('users/user2', { status: 'inactive' });
+     *   batch.delete('users/user3');
+     * });
+     * ```
+     */
+    batch(operations: (batch: {
+        set: <T>(path: string, data: T) => void;
+        update: <T>(path: string, data: Partial<T>) => void;
+        delete: (path: string) => void;
+    }) => void): Promise<void>;
+    /**
+     * Construye una ruta a partir de un template.
+     *
+     * @param template - Template con placeholders {param}
+     * @param params - Valores para los placeholders
+     * @returns Ruta construida
+     *
+     * @example
+     * ```typescript
+     * const path = firestoreService.buildPath('users/{userId}/documents/{docId}', {
+     *   userId: 'user123',
+     *   docId: 'doc456'
+     * });
+     * // => 'users/user123/documents/doc456'
+     * ```
+     */
+    buildPath(template: string, params: Record<string, string>): string;
+    /**
+     * Genera un ID único para un documento (sin crearlo).
+     *
+     * @param collectionPath - Ruta de la colección
+     * @returns ID único generado por Firestore
+     */
+    generateId(collectionPath: string): string;
+    /**
+     * Retorna un valor de timestamp del servidor.
+     * Usar en campos de fecha para que Firestore asigne el timestamp.
+     */
+    serverTimestamp(): FieldValue;
+    /**
+     * Retorna un valor para agregar elementos a un array.
+     *
+     * @example
+     * ```typescript
+     * await firestoreService.updateDoc('users', 'user123', {
+     *   tags: firestoreService.arrayUnion('new-tag')
+     * });
+     * ```
+     */
+    arrayUnion(...elements: unknown[]): FieldValue;
+    /**
+     * Retorna un valor para remover elementos de un array.
+     */
+    arrayRemove(...elements: unknown[]): FieldValue;
+    /**
+     * Retorna un valor para incrementar un campo numérico.
+     *
+     * @example
+     * ```typescript
+     * await firestoreService.updateDoc('users', 'user123', {
+     *   loginCount: firestoreService.increment(1)
+     * });
+     * ```
+     */
+    increment(n: number): FieldValue;
+    /**
+     * Construye los QueryConstraints a partir de QueryOptions
+     */
+    private buildQueryConstraints;
+    /**
+     * Mapea un DocumentSnapshot a nuestro tipo
+     */
+    private mapDocument;
+    /**
+     * Convierte Timestamps de Firestore a Date de JavaScript
+     */
+    private convertTimestamps;
+    /**
+     * Divide una ruta de documento en colección e ID
+     */
+    private splitPath;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FirestoreService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FirestoreService>;
+}

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

@@ -0,0 +1,39 @@
+/**
+ * Firebase Services
+ *
+ * Servicios reutilizables para integración con Firebase.
+ *
+ * @example
+ * ```typescript
+ * // En main.ts
+ * import { provideValtechFirebase } from 'valtech-components';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideValtechFirebase({
+ *       firebase: environment.firebase,
+ *       persistence: true,
+ *     }),
+ *   ],
+ * });
+ *
+ * // En componentes
+ * import { FirebaseService, FirestoreService } from 'valtech-components';
+ *
+ * @Component({...})
+ * export class MyComponent {
+ *   private firebase = inject(FirebaseService);
+ *   private firestore = inject(FirestoreService);
+ * }
+ * ```
+ */
+export * from './types';
+export { VALTECH_FIREBASE_CONFIG, hasEmulators, provideValtechFirebase } from './config';
+export { APP_IDS, FIREBASE_PROJECTS, SHARED_EMULATOR_CONFIG, collections, createFirebaseConfig, isEmulatorMode, storagePaths, type AppId, type CreateFirebaseConfigOptions, } from './shared-config';
+export { FirebaseService } from './firebase.service';
+export { FirestoreService } from './firestore.service';
+export { CollectionOptions, FirestoreCollection, FirestoreCollectionFactory, SubCollectionRef, TypedCollection, } from './firestore-collection';
+export { QueryBuilder, query } from './utils/query-builder';
+export { buildPath, extractPathParams, getCollectionPath, getDocumentId, isCollectionPath, isDocumentPath, isValidPath, joinPath, } from './utils/path-builder';
+export { StorageService } from './storage.service';
+export { MessagingService } from './messaging.service';

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

@@ -0,0 +1,263 @@
+/**
+ * Messaging Service (FCM)
+ *
+ * Servicio para Firebase Cloud Messaging (Push Notifications).
+ * Permite solicitar permisos, obtener tokens, escuchar mensajes y manejar
+ * navegación (deep linking) cuando el usuario toca una notificación.
+ */
+import { NgZone } from '@angular/core';
+import { Messaging } from '@angular/fire/messaging';
+import { Observable } from 'rxjs';
+import { NotificationAction, NotificationClickEvent, NotificationPayload, NotificationPermission, ValtechFirebaseConfig } from './types';
+import * as i0 from "@angular/core";
+/**
+ * Estado interno del servicio de messaging
+ */
+interface MessagingState {
+    token: string | null;
+    permission: NotificationPermission;
+    isSupported: boolean;
+}
+/**
+ * Servicio para Firebase Cloud Messaging (FCM).
+ *
+ * Permite recibir notificaciones push en la aplicación web.
+ * Requiere VAPID key configurada en ValtechFirebaseConfig.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class NotificationComponent {
+ *   private messaging = inject(MessagingService);
+ *
+ *   token = signal<string | null>(null);
+ *
+ *   async enableNotifications() {
+ *     // Solicitar permiso y obtener token
+ *     const token = await this.messaging.requestPermission();
+ *
+ *     if (token) {
+ *       this.token.set(token);
+ *       // Enviar token a tu backend para almacenarlo
+ *       await this.backend.registerDeviceToken(token);
+ *     }
+ *   }
+ *
+ *   // Escuchar mensajes en foreground
+ *   messages$ = this.messaging.onMessage();
+ * }
+ * ```
+ */
+export declare class MessagingService {
+    private messaging;
+    private config;
+    private platformId;
+    private ngZone;
+    private messageSubject;
+    private notificationClickSubject;
+    private stateSubject;
+    private unsubscribeOnMessage?;
+    constructor(messaging: Messaging | null, config: ValtechFirebaseConfig, platformId: Object, ngZone: NgZone);
+    /**
+     * Inicializa el servicio de messaging
+     */
+    private initializeMessaging;
+    /**
+     * Configura listener para mensajes del Service Worker.
+     * Recibe eventos cuando el usuario hace click en una notificación background.
+     */
+    private setupServiceWorkerListener;
+    /**
+     * Verifica si FCM está soportado en el navegador actual
+     */
+    private checkSupport;
+    /**
+     * Solicita permiso de notificaciones y obtiene el token FCM.
+     *
+     * @returns Token FCM si se otorgó permiso, null si se denegó
+     *
+     * @example
+     * ```typescript
+     * const token = await messaging.requestPermission();
+     * if (token) {
+     *   console.log('Token FCM:', token);
+     *   // Enviar a backend
+     * } else {
+     *   console.log('Permiso denegado o no soportado');
+     * }
+     * ```
+     */
+    requestPermission(): Promise<string | null>;
+    /**
+     * Obtiene el token FCM actual (sin solicitar permiso).
+     *
+     * @returns Token FCM si está disponible, null si no
+     *
+     * @example
+     * ```typescript
+     * const token = await messaging.getToken();
+     * ```
+     */
+    getToken(): Promise<string | null>;
+    /**
+     * Elimina el token FCM actual (unsubscribe de notificaciones).
+     *
+     * @example
+     * ```typescript
+     * await messaging.deleteToken();
+     * console.log('Token eliminado, no recibirá más notificaciones');
+     * ```
+     */
+    deleteToken(): Promise<void>;
+    /**
+     * Observable de mensajes recibidos en foreground.
+     *
+     * IMPORTANTE: Los mensajes en background son manejados por el Service Worker.
+     *
+     * @returns Observable que emite cuando llega un mensaje en foreground
+     *
+     * @example
+     * ```typescript
+     * messaging.onMessage().subscribe(payload => {
+     *   console.log('Mensaje recibido:', payload);
+     *   // Mostrar notificación custom o actualizar UI
+     * });
+     * ```
+     */
+    onMessage(): Observable<NotificationPayload>;
+    /**
+     * Configura el listener de mensajes en foreground
+     */
+    private setupMessageListener;
+    /**
+     * Obtiene el estado actual del permiso de notificaciones.
+     *
+     * @returns 'granted' | 'denied' | 'default'
+     *
+     * @example
+     * ```typescript
+     * const permission = messaging.getPermissionState();
+     * if (permission === 'granted') {
+     *   // Ya tiene permiso
+     * } else if (permission === 'default') {
+     *   // Puede solicitar permiso
+     * } else {
+     *   // Denegado, debe habilitar manualmente
+     * }
+     * ```
+     */
+    getPermissionState(): NotificationPermission;
+    /**
+     * Verifica si FCM está soportado en el navegador actual.
+     *
+     * @returns true si FCM está soportado
+     *
+     * @example
+     * ```typescript
+     * if (await messaging.isSupported()) {
+     *   // Puede usar notificaciones push
+     * } else {
+     *   // Navegador no soporta o no tiene Service Worker
+     * }
+     * ```
+     */
+    isSupported(): Promise<boolean>;
+    /**
+     * Obtiene el token actual sin hacer request.
+     *
+     * @returns Token almacenado o null
+     */
+    get currentToken(): string | null;
+    /**
+     * Observable del estado completo del servicio de messaging.
+     */
+    get state$(): Observable<MessagingState>;
+    /**
+     * Verifica si el usuario ya otorgó permiso de notificaciones.
+     */
+    get hasPermission(): boolean;
+    /**
+     * Observable de clicks en notificaciones.
+     *
+     * Emite cuando el usuario hace click en una notificación (foreground o background).
+     * Usa este observable para navegar a la página correspondiente.
+     *
+     * @returns Observable que emite NotificationClickEvent
+     *
+     * @example
+     * ```typescript
+     * @Component({...})
+     * export class AppComponent {
+     *   private messaging = inject(MessagingService);
+     *   private router = inject(Router);
+     *
+     *   constructor() {
+     *     this.messaging.onNotificationClick().subscribe(event => {
+     *       if (event.action.route) {
+     *         this.router.navigate([event.action.route], {
+     *           queryParams: event.action.queryParams
+     *         });
+     *       }
+     *     });
+     *   }
+     * }
+     * ```
+     */
+    onNotificationClick(): Observable<NotificationClickEvent>;
+    /**
+     * Extrae la acción de navegación de los datos de una notificación.
+     *
+     * Busca campos específicos en el payload de datos:
+     * - `route`: Ruta interna de la app (ej: '/orders/123')
+     * - `url`: URL externa (ej: 'https://example.com')
+     * - `action_type`: Tipo de acción personalizada
+     * - Campos con prefijo `action_`: Datos adicionales
+     *
+     * @param data - Datos del payload de la notificación
+     * @returns Acción de navegación extraída
+     *
+     * @example
+     * ```typescript
+     * // Payload desde el backend:
+     * // { route: '/orders/123', action_type: 'view_order', action_orderId: '123' }
+     *
+     * const action = messaging.extractActionFromData(notification.data);
+     * // { route: '/orders/123', actionType: 'view_order', actionData: { orderId: '123' } }
+     * ```
+     */
+    extractActionFromData(data?: Record<string, string>): NotificationAction;
+    /**
+     * Emite manualmente un evento de click en notificación.
+     *
+     * Útil para manejar clicks en notificaciones foreground donde
+     * la app decide mostrar un banner custom.
+     *
+     * @param notification - Payload de la notificación
+     *
+     * @example
+     * ```typescript
+     * messaging.onMessage().subscribe(notification => {
+     *   // Mostrar banner custom
+     *   this.showBanner(notification, () => {
+     *     // Usuario hizo click en el banner
+     *     messaging.handleNotificationClick(notification);
+     *   });
+     * });
+     * ```
+     */
+    handleNotificationClick(notification: NotificationPayload): void;
+    /**
+     * Verifica si una notificación tiene acción de navegación.
+     *
+     * @param data - Datos del payload
+     * @returns true si tiene route o url
+     */
+    hasNavigationAction(data?: Record<string, string>): boolean;
+    /**
+     * Parsea un query string en un objeto.
+     */
+    private parseQueryString;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessagingService, [{ optional: true; }, null, null, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MessagingService>;
+}
+export {};