ng-firebase-table-kxp 1.0.1 → 1.0.2

package/esm2020/lib/services/table.service.mjs

@@ -0,0 +1,908 @@
+import { Injectable, Optional } from '@angular/core';
+import firebase from 'firebase/compat/app';
+import { firstValueFrom } from 'rxjs';
+import * as moment from 'moment';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/fire/compat/firestore";
+import * as i2 from "@angular/material/dialog";
+import * as i3 from "ngx-toastr";
+export class TableService {
+    constructor(ngFire, dialog, toastr) {
+        this.ngFire = ngFire;
+        this.dialog = dialog;
+        this.toastr = toastr;
+        this.operators = {
+            '==': (a, b) => a === b,
+            '!=': (a, b) => a !== b,
+            '>': (a, b) => a > b,
+            '<': (a, b) => a < b,
+            '>=': (a, b) => a >= b,
+            '<=': (a, b) => a <= b,
+            includes: (a, b) => a.includes(b),
+        };
+    }
+    async getItems(collection) {
+        try {
+            const querySnapshot = await collection.get();
+            return querySnapshot.docs.map((doc) => {
+                return { ...doc.data(), id: doc.id };
+            });
+        }
+        catch (error) {
+            console.warn('Collection não encontrada:', error);
+            return [];
+        }
+    }
+    async executeQuery(params) {
+        if (params.filterFn) {
+            // Lógica com filtro no cliente (filterFn)
+            const BATCH_FETCH_SIZE = params.batchSize;
+            const GOAL_SIZE = params.batchSize + 1;
+            if (params.navigation === 'forward' || params.navigation === 'reload') {
+                if (params.navigation === 'reload' && params.doc) {
+                    params.doc.lastDoc = null;
+                }
+                let lastDocCursor = params.doc ? params.doc.lastDoc : null;
+                let pageResults = [];
+                let allFetchedDocs = [];
+                let hasMoreDocsInDb = true;
+                while (pageResults.length < GOAL_SIZE && hasMoreDocsInDb) {
+                    let query = this.ngFire.collection(params.collection).ref;
+                    query = this.applyFilters(query, params.arrange, params.conditions);
+                    if (lastDocCursor) {
+                        query = query.startAfter(lastDocCursor);
+                    }
+                    query = query.limit(BATCH_FETCH_SIZE);
+                    const snapshot = await query.get();
+                    if (snapshot.empty) {
+                        hasMoreDocsInDb = false;
+                        break;
+                    }
+                    lastDocCursor = snapshot.docs[snapshot.docs.length - 1];
+                    allFetchedDocs.push(...snapshot.docs);
+                    const batchUsers = snapshot.docs
+                        .map((doc) => ({
+                        id: doc.id,
+                        ...doc.data(),
+                    }))
+                        .filter(params.filterFn);
+                    pageResults.push(...batchUsers);
+                    if (snapshot.size < BATCH_FETCH_SIZE) {
+                        hasMoreDocsInDb = false;
+                    }
+                }
+                const hasNextPage = pageResults.length > params.batchSize;
+                const finalItems = pageResults.slice(0, params.batchSize);
+                const firstDocOfPage = allFetchedDocs.find((doc) => doc.id === finalItems[0]?.id) || null;
+                const lastDocOfPage = allFetchedDocs.find((doc) => doc.id === finalItems[finalItems.length - 1]?.id) || null;
+                return {
+                    items: finalItems,
+                    filterLength: null,
+                    firstDoc: firstDocOfPage,
+                    lastDoc: lastDocOfPage,
+                    hasNextPage: hasNextPage,
+                    hasPreviousPage: !!(params.doc && params.doc.lastDoc) &&
+                        params.navigation !== 'reload',
+                    currentClientPageIndex: undefined,
+                };
+            }
+            // Lógica para trás (backward)
+            else if (params.navigation === 'backward') {
+                if (!params.doc || !params.doc.firstDoc) {
+                    return {
+                        items: [],
+                        filterLength: null,
+                        firstDoc: null,
+                        lastDoc: null,
+                        hasNextPage: true,
+                        hasPreviousPage: false,
+                        currentClientPageIndex: undefined,
+                    };
+                }
+                let pageResults = [];
+                let allFetchedDocs = [];
+                let hasMoreDocsInDb = true;
+                let boundaryDoc = params.doc.firstDoc;
+                while (pageResults.length < GOAL_SIZE && hasMoreDocsInDb) {
+                    let query = this.ngFire.collection(params.collection).ref;
+                    query = this.applyFilters(query, params.arrange, params.conditions);
+                    query = query.endBefore(boundaryDoc);
+                    query = query.limitToLast(BATCH_FETCH_SIZE);
+                    const snapshot = await query.get();
+                    if (snapshot.empty) {
+                        hasMoreDocsInDb = false;
+                        break;
+                    }
+                    boundaryDoc = snapshot.docs[0];
+                    allFetchedDocs = [...snapshot.docs, ...allFetchedDocs];
+                    const batchUsers = snapshot.docs
+                        .map((doc) => ({
+                        id: doc.id,
+                        ...doc.data(),
+                    }))
+                        .filter(params.filterFn);
+                    pageResults = [...batchUsers, ...pageResults];
+                    if (snapshot.size < BATCH_FETCH_SIZE) {
+                        hasMoreDocsInDb = false;
+                    }
+                }
+                const finalItems = pageResults.slice(0, params.batchSize);
+                const firstDocOfPage = allFetchedDocs.find((doc) => doc.id === finalItems[0]?.id) || null;
+                const lastDocOfPage = allFetchedDocs.find((doc) => doc.id === finalItems[finalItems.length - 1]?.id) || null;
+                return {
+                    items: finalItems,
+                    filterLength: null,
+                    firstDoc: firstDocOfPage,
+                    lastDoc: lastDocOfPage,
+                    hasNextPage: true,
+                    currentClientPageIndex: undefined,
+                };
+            }
+        }
+        else {
+            let items = [];
+            let docs = [];
+            let hasNextPage = false;
+            let filterLength = null;
+            let query = this.ngFire.collection(params.collection).ref;
+            if (params.conditions) {
+                params.conditions.forEach((c) => {
+                    if (c.operator === '!=') {
+                        query = query.orderBy(c.firestoreProperty);
+                    }
+                });
+            }
+            query = this.applyFilters(query, params.arrange, params.conditions);
+            if (params.navigation === 'reload') {
+                query = query.limit(params.batchSize + 1);
+                if (params.doc && params.doc.firstDoc) {
+                    query = query.startAt(params.doc.firstDoc);
+                }
+            }
+            else if (params.navigation === 'forward') {
+                query = query.limit(params.batchSize + 1);
+                if (params.doc && params.doc.lastDoc) {
+                    query = query.startAfter(params.doc.lastDoc);
+                }
+            }
+            else {
+                // backward
+                query = query.limitToLast(params.batchSize + 1);
+                if (params.doc && params.doc.firstDoc) {
+                    query = query.endBefore(params.doc.firstDoc);
+                }
+            }
+            const itemCol = await query.get();
+            itemCol.docs.forEach((doc) => docs.push(doc));
+            const itemPromises = docs.map(async (item) => {
+                const itemData = item.data();
+                items.push({ id: item.id, ...itemData });
+            });
+            let lastDoc = docs[docs.length - 1] || null;
+            let firstDoc = docs[0];
+            if ((items.length > params.batchSize && params.navigation === 'forward') ||
+                (params.navigation === 'reload' && items.length > params.batchSize)) {
+                lastDoc = docs[docs.length - 2] || null;
+                items.pop();
+                hasNextPage = true;
+            }
+            if (items.length > params.batchSize && params.navigation === 'backward') {
+                firstDoc = docs[1];
+                items.shift();
+                hasNextPage = true;
+            }
+            await Promise.all(itemPromises);
+            return {
+                items,
+                filterLength,
+                lastDoc,
+                firstDoc,
+                hasNextPage,
+                currentClientPageIndex: undefined,
+            };
+        }
+        // Fallback para garantir que sempre retornamos algo
+        return {
+            items: [],
+            filterLength: null,
+            firstDoc: null,
+            lastDoc: null,
+            hasNextPage: false,
+            currentClientPageIndex: undefined,
+        };
+    }
+    applyFilters(query, arrange, conditions) {
+        if (conditions) {
+            conditions.map((cond) => {
+                query = query.where(cond.firestoreProperty, cond.operator, cond.dashProperty);
+            });
+        }
+        let hasFilterSpecificOrderBy = false;
+        let appliedOrderByField = null;
+        const equalsFilters = arrange.filters.filter((f) => f.arrange === 'equals' && f.filter);
+        const otherFilters = arrange.filters.filter((f) => f.arrange !== 'equals');
+        const equalsGroupedByProperty = equalsFilters.reduce((acc, current) => {
+            const prop = current.filter.property;
+            if (!acc[prop]) {
+                acc[prop] = [];
+            }
+            acc[prop].push(current.filter.filtering);
+            return acc;
+        }, {});
+        for (const prop in equalsGroupedByProperty) {
+            const values = equalsGroupedByProperty[prop];
+            if (values.length > 0) {
+                query = query.where(prop, 'in', values);
+            }
+        }
+        otherFilters.forEach((filterItem) => {
+            // Aplicar filtragem por busca
+            if (filterItem.filter?.filtering &&
+                filterItem.filter?.property !== '' &&
+                filterItem.arrange === 'filter') {
+                query = query
+                    .where(filterItem.filter.property, '>=', filterItem.filter.filtering.trim().toUpperCase())
+                    .where(filterItem.filter.property, '<=', filterItem.filter.filtering.trim().toUpperCase() + '\uf8ff');
+                if (!hasFilterSpecificOrderBy) {
+                    query = query.orderBy(filterItem.filter.property);
+                    hasFilterSpecificOrderBy = true;
+                    appliedOrderByField = filterItem.filter.property;
+                }
+            }
+            // Aplicar filtro do tipo "filterByDate"
+            if (filterItem.dateFilter && filterItem.arrange === 'filterByDate') {
+                query = query
+                    .where(arrange.sortBy.field, '>=', filterItem.dateFilter.initial)
+                    .where(arrange.sortBy.field, '<=', filterItem.dateFilter.final);
+                if (!hasFilterSpecificOrderBy) {
+                    query = query.orderBy(arrange.sortBy.field);
+                    hasFilterSpecificOrderBy = true;
+                    appliedOrderByField = arrange.sortBy.field;
+                }
+            }
+        });
+        // Aplicar sortBy
+        if (arrange.sortBy && arrange.sortBy.field && arrange.sortBy.order) {
+            if (appliedOrderByField !== arrange.sortBy.field) {
+                query = query.orderBy(arrange.sortBy.field, arrange.sortBy.order);
+            }
+        }
+        return query;
+    }
+    /**
+     * Detecta se a query vai precisar de index composto e deve usar fallback client-side
+     */
+    shouldUseClientSideFallback(params) {
+        const hasConditions = params.conditions && params.conditions.length > 0;
+        const hasArrangeFilters = params.arrange?.filters && params.arrange.filters.length > 0;
+        const hasSortBy = params.arrange?.sortBy?.field;
+        if (params.filterFn) {
+            return false;
+        }
+        if (hasConditions && hasArrangeFilters && hasSortBy) {
+            return true;
+        }
+        if (hasConditions && hasArrangeFilters) {
+            return true;
+        }
+        if (hasArrangeFilters && params.arrange.filters.length > 1 && hasSortBy) {
+            return true;
+        }
+        return false;
+    }
+    async getPaginated(params) {
+        // Detectar preventivamente se deve usar fallback
+        if (this.shouldUseClientSideFallback(params)) {
+            await this.trackMissingIndexPreventive(params.collection, params.arrange, params.conditions);
+            const result = await this.executeClientSideQuery(params);
+            console.log('📊 [TABLE] Resultados paginados via fallback client-side:', {
+                totalItems: result.filterLength,
+                returnedItems: result.items.length,
+                hasNextPage: result.hasNextPage,
+                currentPage: (result.currentClientPageIndex || 0) + 1,
+            });
+            return result;
+        }
+        try {
+            const result = await this.executeQuery(params);
+            console.log('📊 [TABLE] Resultados paginados via Firestore:', {
+                totalItems: result.filterLength || 'N/A',
+                returnedItems: result.items.length,
+                hasNextPage: result.hasNextPage,
+            });
+            return result;
+        }
+        catch (error) {
+            if (error && error.code === 'failed-precondition') {
+                await this.trackMissingIndex(error, params.collection, params.arrange, params.conditions);
+                const result = await this.executeClientSideQuery(params);
+                console.log('📊 [TABLE] Resultados paginados via fallback (erro de index):', {
+                    totalItems: result.filterLength,
+                    returnedItems: result.items.length,
+                    hasNextPage: result.hasNextPage,
+                    currentPage: (result.currentClientPageIndex || 0) + 1,
+                });
+                return result;
+            }
+            else if (error && error.code === 'invalid-argument') {
+                await this.trackMissingIndex(error, params.collection, params.arrange, params.conditions);
+                const result = await this.executeClientSideQuery(params);
+                console.log('📊 [TABLE] Resultados paginados via fallback (argumento inválido):', {
+                    totalItems: result.filterLength,
+                    returnedItems: result.items.length,
+                    hasNextPage: result.hasNextPage,
+                    currentPage: (result.currentClientPageIndex || 0) + 1,
+                });
+                return result;
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    async executeClientSideQuery(params) {
+        // Otimizar usando pelo menos uma cláusula .where() quando possível
+        let query = this.ngFire.collection(params.collection).ref;
+        let appliedCondition = null;
+        let hasAppliedWhereClause = false;
+        // Primeiro, tenta aplicar condições simples
+        if (params.conditions && params.conditions.length > 0) {
+            const simpleCondition = params.conditions.find((cond) => ['==', '>', '<', '>=', '<='].includes(cond.operator));
+            if (simpleCondition) {
+                query = query.where(simpleCondition.firestoreProperty, simpleCondition.operator, simpleCondition.dashProperty);
+                appliedCondition = simpleCondition;
+                hasAppliedWhereClause = true;
+            }
+        }
+        // Se não há condições disponíveis, tenta aplicar filtros do arrange
+        let appliedFirestoreFilter = null;
+        if (!hasAppliedWhereClause && params.arrange?.filters) {
+            const equalsFilter = params.arrange.filters.find((f) => f.arrange === 'equals' && f.filter?.filtering);
+            if (equalsFilter && equalsFilter.filter) {
+                query = query.where(equalsFilter.filter.property, '==', equalsFilter.filter.filtering);
+                hasAppliedWhereClause = true;
+                appliedFirestoreFilter = equalsFilter;
+            }
+            else {
+                const otherFilter = params.arrange.filters.find((f) => (f.arrange === 'filter' &&
+                    f.filter?.filtering &&
+                    f.filter?.property) ||
+                    (f.arrange === 'filterByDate' &&
+                        f.dateFilter?.initial &&
+                        f.dateFilter?.final));
+                if (otherFilter) {
+                    if (otherFilter.arrange === 'filter' && otherFilter.filter) {
+                        const filterValue = otherFilter.filter.filtering
+                            .trim()
+                            .toUpperCase();
+                        query = query
+                            .where(otherFilter.filter.property, '>=', filterValue)
+                            .where(otherFilter.filter.property, '<=', filterValue + '\uf8ff');
+                        hasAppliedWhereClause = true;
+                        appliedFirestoreFilter = otherFilter;
+                    }
+                    else if (otherFilter.arrange === 'filterByDate' &&
+                        otherFilter.dateFilter &&
+                        params.arrange.sortBy?.field) {
+                        query = query
+                            .where(params.arrange.sortBy.field, '>=', otherFilter.dateFilter.initial)
+                            .where(params.arrange.sortBy.field, '<=', otherFilter.dateFilter.final);
+                        hasAppliedWhereClause = true;
+                        appliedFirestoreFilter = otherFilter;
+                    }
+                }
+            }
+        }
+        const allDocsSnapshot = await query.get();
+        let items = allDocsSnapshot.docs.map((doc) => ({
+            id: doc.id,
+            ...doc.data(),
+        }));
+        // Aplicar condições restantes
+        if (params.conditions) {
+            const remainingConditions = params.conditions.filter((cond) => cond !== appliedCondition);
+            if (remainingConditions.length > 0) {
+                const operators = this.operators;
+                items = items.filter((item) => {
+                    return remainingConditions.every((cond) => {
+                        const operatorFn = operators[cond.operator];
+                        return operatorFn
+                            ? operatorFn(item[cond.firestoreProperty], cond.dashProperty)
+                            : false;
+                    });
+                });
+            }
+        }
+        const { filters, sortBy } = params.arrange;
+        // Track which filter was already applied in Firestore to avoid double filtering
+        if (hasAppliedWhereClause && !appliedCondition && params.arrange?.filters) {
+            const equalsFilter = params.arrange.filters.find((f) => f.arrange === 'equals' && f.filter?.filtering);
+            if (equalsFilter) {
+                appliedFirestoreFilter = equalsFilter;
+            }
+            else {
+                appliedFirestoreFilter = params.arrange.filters.find((f) => (f.arrange === 'filter' &&
+                    f.filter?.filtering &&
+                    f.filter?.property) ||
+                    (f.arrange === 'filterByDate' &&
+                        f.dateFilter?.initial &&
+                        f.dateFilter?.final));
+            }
+        }
+        const equalsFilters = filters.filter((f) => f.arrange === 'equals');
+        const otherFilters = filters.filter((f) => f.arrange !== 'equals');
+        const remainingEqualsFilters = equalsFilters.filter((f) => f !== appliedFirestoreFilter);
+        if (remainingEqualsFilters.length > 0) {
+            items = items.filter((item) => {
+                return remainingEqualsFilters.every((f) => item[f.filter.property] === f.filter.filtering);
+            });
+        }
+        otherFilters.forEach((filterItem) => {
+            if (appliedFirestoreFilter === filterItem) {
+                return;
+            }
+            if (filterItem.arrange === 'filter' &&
+                filterItem.filter?.filtering &&
+                filterItem.filter?.property) {
+                const filterValue = String(filterItem.filter.filtering)
+                    .trim()
+                    .toLowerCase();
+                items = items.filter((item) => {
+                    const itemValue = String(item[filterItem.filter.property]).toLowerCase();
+                    return itemValue.includes(filterValue);
+                });
+            }
+            if (filterItem.arrange === 'filterByDate' &&
+                filterItem.dateFilter?.initial &&
+                filterItem.dateFilter?.final &&
+                sortBy.field) {
+                items = items.filter((item) => {
+                    try {
+                        const fieldValue = item[sortBy.field];
+                        if (!fieldValue) {
+                            return false;
+                        }
+                        let itemDate;
+                        if (typeof fieldValue.toDate === 'function') {
+                            itemDate = fieldValue.toDate();
+                        }
+                        else if (fieldValue instanceof Date) {
+                            itemDate = fieldValue;
+                        }
+                        else if (typeof fieldValue === 'string') {
+                            itemDate = new Date(fieldValue);
+                            if (isNaN(itemDate.getTime())) {
+                                return false;
+                            }
+                        }
+                        else if (typeof fieldValue === 'number') {
+                            itemDate = new Date(fieldValue);
+                        }
+                        else {
+                            return false;
+                        }
+                        return (itemDate >= filterItem.dateFilter.initial &&
+                            itemDate <= filterItem.dateFilter.final);
+                    }
+                    catch (error) {
+                        console.warn('Erro ao processar filtro de data para o item:', item.id, error);
+                        return false;
+                    }
+                });
+            }
+        });
+        // Aplicar filterFn se existir
+        if (params.filterFn) {
+            items = items.filter(params.filterFn);
+        }
+        if (sortBy && sortBy.field && sortBy.order) {
+            items.sort((a, b) => {
+                const valA = a[sortBy.field];
+                const valB = b[sortBy.field];
+                if (valA < valB) {
+                    return sortBy.order === 'asc' ? -1 : 1;
+                }
+                if (valA > valB) {
+                    return sortBy.order === 'asc' ? 1 : -1;
+                }
+                return 0;
+            });
+        }
+        // Paginação
+        let currentClientPageIndex = 0;
+        if (params.navigation === 'reload') {
+            currentClientPageIndex = params.clientPageIndex || 0;
+        }
+        else if (params.navigation === 'forward') {
+            currentClientPageIndex = (params.clientPageIndex || 0) + 1;
+        }
+        else if (params.navigation === 'backward') {
+            currentClientPageIndex = Math.max(0, (params.clientPageIndex || 0) - 1);
+        }
+        const pageSize = params.batchSize;
+        const startIndex = currentClientPageIndex * pageSize;
+        const endIndex = startIndex + pageSize;
+        const paginatedItems = items.slice(startIndex, endIndex);
+        const totalPages = Math.ceil(items.length / pageSize);
+        const hasNextPage = currentClientPageIndex < totalPages - 1;
+        const hasPreviousPage = currentClientPageIndex > 0;
+        return {
+            items: paginatedItems,
+            filterLength: items.length,
+            lastDoc: null,
+            firstDoc: null,
+            hasNextPage: hasNextPage,
+            hasPreviousPage: hasPreviousPage,
+            currentClientPageIndex: currentClientPageIndex,
+            totalPages: totalPages,
+        };
+    }
+    async getItemsData(collection, arrange, conditions = undefined) {
+        try {
+            let query = this.ngFire.collection(collection).ref;
+            query = this.applyFilters(query, arrange, conditions);
+            const snapshot = await query.get();
+            return await Promise.all(snapshot.docs.map(async (doc) => {
+                const data = doc.data();
+                const id = doc.id;
+                return {
+                    id,
+                    ...data,
+                };
+            }));
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async deleteIndex(id, col, dialogComponent) {
+        const dialogRef = this.dialog.open(dialogComponent, {
+            data: {
+                title: 'Você realmente deseja deletar esse item?',
+                description: 'Essa ação é irreversível.',
+            },
+        });
+        const result = await firstValueFrom(dialogRef.afterClosed());
+        if (!result === true) {
+            return false;
+        }
+        try {
+            const batch = this.ngFire.firestore.batch();
+            const docRef = this.ngFire.collection(col).doc(id);
+            const docSnapshot = (await firstValueFrom(docRef.get()));
+            const doc = docSnapshot.data();
+            batch.delete(docRef.ref);
+            if (doc && typeof doc.index === 'number') {
+                await this.reindex(doc.index, col, batch);
+            }
+            await batch.commit();
+            this.toastr.success('Item excluído com sucesso!');
+            return true;
+        }
+        catch (e) {
+            const error = e;
+            console.error('Erro ao deletar item:', error);
+            this.toastr.error('Erro ao deletar item.');
+            return false;
+        }
+    }
+    async reindex(index, col, batch) {
+        try {
+            const snapshot = (await firstValueFrom(this.ngFire.collection(col).get()));
+            const docs = snapshot.docs;
+            for (let doc of docs) {
+                const data = doc.data();
+                if (data && typeof data.index === 'number' && data.index > index) {
+                    data.index--;
+                    const docRef = this.ngFire.collection(col).doc(doc.id).ref;
+                    batch.update(docRef, data);
+                }
+            }
+        }
+        catch (error) {
+            console.error('Erro ao reindexar:', error);
+        }
+        return;
+    }
+    dateFormatValidator() {
+        return (control) => {
+            if (!control.value) {
+                return null;
+            }
+            const dateStr = control.value.trim();
+            const datePattern = /^(\d{1,2})\/(\d{1,2})\/(\d{4})$/;
+            if (!datePattern.test(dateStr)) {
+                return { invalidFormat: true };
+            }
+            const parts = dateStr.split('/');
+            const day = parts[0].padStart(2, '0');
+            const month = parts[1].padStart(2, '0');
+            const year = parts[2];
+            const normalizedDate = `${day}/${month}/${year}`;
+            const date = moment(normalizedDate, 'DD/MM/YYYY', true);
+            if (!date.isValid()) {
+                return { invalidDate: true };
+            }
+            return null;
+        };
+    }
+    async updateIndex(index, id, col) {
+        await this.ngFire.collection(col).doc(id).update({ index });
+    }
+    /**
+     * Extrai o link de criação de índice da mensagem de erro do Firestore
+     */
+    extractIndexLink(error) {
+        if (!error || !error.message)
+            return null;
+        const linkMatch = error.message.match(/(https:\/\/console\.firebase\.google\.com\/[^\s]+)/);
+        return linkMatch ? linkMatch[1] : null;
+    }
+    /**
+     * Rastreia índices ausentes ao usar fallback preventivo
+     */
+    async trackMissingIndexPreventive(collection, arrange, conditions = undefined) {
+        try {
+            const querySignature = this.generateQuerySignature(collection, arrange, conditions);
+            const docId = `${collection}_${querySignature}`;
+            const indexLink = this.generateIndexLink(collection, arrange, conditions);
+            const indexInstructions = this.generateIndexInstructions(collection, arrange, conditions);
+            const trackingData = {
+                collection,
+                indexLink,
+                indexInstructions,
+                arrange: {
+                    sortBy: arrange.sortBy,
+                    filters: arrange.filters?.map((f) => ({
+                        arrange: f.arrange,
+                        property: f.filter?.property || null,
+                        dateField: f.arrange === 'filterByDate' ? arrange.sortBy?.field : null,
+                    })) || [],
+                },
+                conditions: conditions?.map((c) => ({
+                    property: c.firestoreProperty,
+                    operator: c.operator,
+                })) || [],
+                errorMessage: `Fallback preventivo usado para a collection ${collection}. A query exigiria índice composto.`,
+                updatedAt: firebase.firestore.FieldValue.serverTimestamp(),
+            };
+            console.log('📄 [INDEX LINK] Dados que serão salvos no documento:', {
+                docId,
+                collection: trackingData.collection,
+                indexLink: trackingData.indexLink,
+                arrange: trackingData.arrange,
+                conditions: trackingData.conditions,
+                errorMessage: trackingData.errorMessage,
+            });
+            const docRef = this.ngFire.collection('missingIndexes').doc(docId);
+            const doc = await docRef.get().toPromise();
+            if (doc && doc.exists) {
+                await docRef.update({
+                    count: firebase.firestore.FieldValue.increment(1),
+                    updatedAt: firebase.firestore.FieldValue.serverTimestamp(),
+                    lastError: trackingData.errorMessage,
+                });
+            }
+            else {
+                await docRef.set({
+                    ...trackingData,
+                    count: 1,
+                    createdAt: firebase.firestore.FieldValue.serverTimestamp(),
+                });
+            }
+        }
+        catch (trackingError) {
+            console.warn('Falha ao rastrear fallback preventivo:', trackingError);
+        }
+    }
+    /**
+     * Gera uma assinatura única para uma query
+     */
+    generateQuerySignature(collection, arrange, conditions = undefined) {
+        const signature = {
+            collection,
+            sortBy: arrange.sortBy,
+            filters: arrange.filters?.map((f) => ({
+                arrange: f.arrange,
+                property: f.filter?.property || null,
+            })) || [],
+            conditions: conditions?.map((c) => ({
+                property: c.firestoreProperty,
+                operator: c.operator,
+            })) || [],
+        };
+        return btoa(JSON.stringify(signature))
+            .replace(/[^a-zA-Z0-9]/g, '')
+            .substring(0, 20);
+    }
+    /**
+     * Gera instruções claras para criar o índice manualmente
+     */
+    generateIndexInstructions(collection, arrange, conditions = undefined) {
+        const instructions = {
+            summary: '',
+            collection: collection,
+            fields: [],
+            queryExample: '',
+            stepByStep: [],
+            notes: [],
+        };
+        const fields = [];
+        if (conditions && conditions.length > 0) {
+            conditions.forEach((condition) => {
+                if (condition.firestoreProperty) {
+                    fields.push({
+                        field: condition.firestoreProperty,
+                        order: 'Ascending',
+                        type: 'WHERE clause',
+                        operator: condition.operator,
+                        description: `Filtrar por ${condition.firestoreProperty} usando operador ${condition.operator}`,
+                    });
+                }
+            });
+        }
+        if (arrange.filters && arrange.filters.length > 0) {
+            arrange.filters.forEach((filter) => {
+                if (filter.filter?.property) {
+                    fields.push({
+                        field: filter.filter.property,
+                        order: 'Ascending',
+                        type: 'WHERE clause (filter)',
+                        operator: filter.arrange === 'filter' ? 'CONTAINS' : 'RANGE',
+                        description: `Filtrar por ${filter.filter.property} usando filtro ${filter.arrange}`,
+                    });
+                }
+            });
+        }
+        if (arrange.sortBy?.field) {
+            fields.push({
+                field: arrange.sortBy.field,
+                order: arrange.sortBy.order === 'desc' ? 'Descending' : 'Ascending',
+                type: 'ORDER BY clause',
+                operator: 'N/A',
+                description: `Ordenar resultados por ${arrange.sortBy.field} em ordem ${arrange.sortBy.order}`,
+            });
+        }
+        instructions.fields = fields;
+        const fieldNames = fields.map((f) => f.field).join(' + ');
+        instructions.summary = `Criar índice composto para ${collection}: ${fieldNames}`;
+        let queryExample = `db.collection('${collection}')`;
+        fields.forEach((field, index) => {
+            if (field.type.includes('WHERE')) {
+                if (field.operator === '==') {
+                    queryExample += `\n  .where('${field.field}', '==', 'value')`;
+                }
+                else if (field.operator === 'CONTAINS') {
+                    queryExample += `\n  .where('${field.field}', '>=', 'searchText')`;
+                }
+                else {
+                    queryExample += `\n  .where('${field.field}', '${field.operator}', 'value')`;
+                }
+            }
+        });
+        const orderByField = fields.find((f) => f.type.includes('ORDER BY'));
+        if (orderByField) {
+            queryExample += `\n  .orderBy('${orderByField.field}', '${orderByField.order.toLowerCase()}')`;
+        }
+        instructions.queryExample = queryExample;
+        instructions.stepByStep = [
+            '1. Ir para Firebase Console → Firestore → Indexes',
+            '2. Clicar em "Create Index"',
+            `3. Definir Collection ID: ${collection}`,
+            '4. Configurar campos nesta ORDEM EXATA:',
+            ...fields.map((field, index) => `   ${index + 1}. Campo: ${field.field}, Order: ${field.order}, Array: No`),
+            '5. Definir Query scopes: Collection',
+            '6. Clicar em "Create" e aguardar conclusão',
+        ];
+        instructions.notes = [
+            '⚠️ A ordem dos campos é CRÍTICA - deve corresponder exatamente à ordem da query',
+            '⚠️ As cláusulas WHERE devem vir ANTES do campo ORDER BY',
+            '⚠️ Este índice só funcionará para queries com esta combinação EXATA de campos',
+            '⚠️ A criação do índice pode levar vários minutos',
+        ];
+        return instructions;
+    }
+    /**
+     * Gera um link de índice baseado na estrutura da query
+     */
+    generateIndexLink(collection, arrange, conditions = undefined) {
+        try {
+            const indexFields = [];
+            if (conditions && conditions.length > 0) {
+                conditions.forEach((condition) => {
+                    if (condition.firestoreProperty) {
+                        indexFields.push(condition.firestoreProperty);
+                    }
+                });
+            }
+            if (arrange.filters && arrange.filters.length > 0) {
+                arrange.filters.forEach((filter) => {
+                    if (filter.filter?.property) {
+                        indexFields.push(filter.filter.property);
+                    }
+                });
+            }
+            if (arrange.sortBy?.field) {
+                indexFields.push(arrange.sortBy.field);
+            }
+            if (indexFields.length > 1) {
+                const baseUrl = 'https://console.firebase.google.com/project/toppayy-dev/firestore/indexes';
+                const queryParams = new URLSearchParams({
+                    create_composite: `collection=${collection}&fields=${indexFields.join(',')}`,
+                });
+                const finalLink = `${baseUrl}?${queryParams.toString()}`;
+                return finalLink;
+            }
+            return null;
+        }
+        catch (error) {
+            console.warn('Falha ao gerar link de índice:', error);
+            return null;
+        }
+    }
+    async trackMissingIndex(error, collection, arrange, conditions = undefined) {
+        try {
+            const indexLink = this.extractIndexLink(error);
+            if (!indexLink)
+                return;
+            const linkHash = btoa(indexLink)
+                .replace(/[^a-zA-Z0-9]/g, '')
+                .substring(0, 20);
+            const docId = `${collection}_${linkHash}`;
+            const indexInstructions = this.generateIndexInstructions(collection, arrange, conditions);
+            const trackingData = {
+                collection,
+                indexLink,
+                indexInstructions,
+                arrange: {
+                    sortBy: arrange.sortBy,
+                    filters: arrange.filters?.map((f) => ({
+                        arrange: f.arrange,
+                        property: f.filter?.property || null,
+                        dateField: f.arrange === 'filterByDate' ? arrange.sortBy?.field : null,
+                    })) || [],
+                },
+                conditions: conditions?.map((c) => ({
+                    property: c.firestoreProperty,
+                    operator: c.operator,
+                })) || [],
+                errorMessage: error.message,
+                updatedAt: firebase.firestore.FieldValue.serverTimestamp(),
+            };
+            const docRef = this.ngFire.collection('missingIndexes').doc(docId);
+            const doc = await docRef.get().toPromise();
+            if (doc && doc.exists) {
+                await docRef.update({
+                    count: firebase.firestore.FieldValue.increment(1),
+                    updatedAt: firebase.firestore.FieldValue.serverTimestamp(),
+                    lastError: error.message,
+                });
+            }
+            else {
+                await docRef.set({
+                    ...trackingData,
+                    count: 1,
+                    createdAt: firebase.firestore.FieldValue.serverTimestamp(),
+                });
+            }
+        }
+        catch (trackingError) {
+            console.warn('Falha ao rastrear índice ausente:', trackingError);
+        }
+    }
+}
+TableService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TableService, deps: [{ token: i1.AngularFirestore, optional: true }, { token: i2.MatDialog, optional: true }, { token: i3.ToastrService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+TableService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TableService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TableService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AngularFirestore, decorators: [{
+                    type: Optional
+                }] }, { type: i2.MatDialog, decorators: [{
+                    type: Optional
+                }] }, { type: i3.ToastrService, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.service.js","sourceRoot":"","sources":["../../../../../projects/ng-firebase-table-kxp/src/lib/services/table.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Optional } from '@angular/core';\nimport {\n  AngularFirestore,\n  CollectionReference,\n  QueryDocumentSnapshot,\n} from '@angular/fire/compat/firestore';\nimport firebase from 'firebase/compat/app';\nimport { Arrange, Condition, Pagination } from '../types/Table';\nimport { firstValueFrom } from 'rxjs';\nimport { MatDialog } from '@angular/material/dialog';\nimport { ToastrService } from 'ngx-toastr';\nimport { AbstractControl, ValidatorFn } from '@angular/forms';\nimport * as moment from 'moment';\n\ninterface PaginationResult {\n  items: any[];\n  filterLength: number | null;\n  firstDoc: firebase.firestore.QueryDocumentSnapshot<unknown> | null;\n  lastDoc: firebase.firestore.QueryDocumentSnapshot<unknown> | null;\n  hasNextPage: boolean;\n  hasPreviousPage?: boolean;\n  currentClientPageIndex?: number;\n  totalPages?: number;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class TableService {\n  constructor(\n    @Optional() private ngFire: AngularFirestore,\n    @Optional() private dialog: MatDialog,\n    @Optional() private toastr: ToastrService\n  ) {}\n\n  async getItems(collection: CollectionReference<unknown>): Promise<any[]> {\n    try {\n      const querySnapshot = await collection.get();\n      return querySnapshot.docs.map(\n        (doc: firebase.firestore.QueryDocumentSnapshot<unknown>) => {\n          return { ...(doc.data() as any), id: doc.id };\n        }\n      );\n    } catch (error) {\n      console.warn('Collection não encontrada:', error);\n      return [];\n    }\n  }\n\n  private async executeQuery(params: Pagination): Promise<PaginationResult> {\n    if (params.filterFn) {\n      // Lógica com filtro no cliente (filterFn)\n      const BATCH_FETCH_SIZE = params.batchSize;\n      const GOAL_SIZE = params.batchSize + 1;\n\n      if (params.navigation === 'forward' || params.navigation === 'reload') {\n        if (params.navigation === 'reload' && params.doc) {\n          params.doc.lastDoc = null;\n        }\n\n        let lastDocCursor: firebase.firestore.QueryDocumentSnapshot<unknown> | null =\n          params.doc ? params.doc.lastDoc : null;\n        let pageResults: any[] = [];\n        let allFetchedDocs: firebase.firestore.QueryDocumentSnapshot<unknown>[] =\n          [];\n        let hasMoreDocsInDb = true;\n\n        while (pageResults.length < GOAL_SIZE && hasMoreDocsInDb) {\n          let query: firebase.firestore.Query<unknown> = this.ngFire.collection(\n            params.collection\n          ).ref;\n          query = this.applyFilters(query, params.arrange, params.conditions);\n\n          if (lastDocCursor) {\n            query = query.startAfter(lastDocCursor);\n          }\n          query = query.limit(BATCH_FETCH_SIZE);\n\n          const snapshot = await query.get();\n\n          if (snapshot.empty) {\n            hasMoreDocsInDb = false;\n            break;\n          }\n\n          lastDocCursor = snapshot.docs[snapshot.docs.length - 1];\n          allFetchedDocs.push(...snapshot.docs);\n\n          const batchUsers = snapshot.docs\n            .map((doc: firebase.firestore.QueryDocumentSnapshot<unknown>) => ({\n              id: doc.id,\n              ...(doc.data() as any),\n            }))\n            .filter(params.filterFn);\n\n          pageResults.push(...batchUsers);\n\n          if (snapshot.size < BATCH_FETCH_SIZE) {\n            hasMoreDocsInDb = false;\n          }\n        }\n\n        const hasNextPage = pageResults.length > params.batchSize;\n        const finalItems = pageResults.slice(0, params.batchSize);\n\n        const firstDocOfPage =\n          allFetchedDocs.find(\n            (doc: firebase.firestore.QueryDocumentSnapshot<unknown>) =>\n              doc.id === finalItems[0]?.id\n          ) || null;\n        const lastDocOfPage =\n          allFetchedDocs.find(\n            (doc: firebase.firestore.QueryDocumentSnapshot<unknown>) =>\n              doc.id === finalItems[finalItems.length - 1]?.id\n          ) || null;\n\n        return {\n          items: finalItems,\n          filterLength: null,\n          firstDoc: firstDocOfPage,\n          lastDoc: lastDocOfPage,\n          hasNextPage: hasNextPage,\n          hasPreviousPage:\n            !!(params.doc && params.doc.lastDoc) &&\n            params.navigation !== 'reload',\n          currentClientPageIndex: undefined,\n        };\n      }\n      // Lógica para trás (backward)\n      else if (params.navigation === 'backward') {\n        if (!params.doc || !params.doc.firstDoc) {\n          return {\n            items: [],\n            filterLength: null,\n            firstDoc: null,\n            lastDoc: null,\n            hasNextPage: true,\n            hasPreviousPage: false,\n            currentClientPageIndex: undefined,\n          };\n        }\n\n        let pageResults: any[] = [];\n        let allFetchedDocs: firebase.firestore.QueryDocumentSnapshot<unknown>[] =\n          [];\n        let hasMoreDocsInDb = true;\n\n        let boundaryDoc = params.doc.firstDoc;\n\n        while (pageResults.length < GOAL_SIZE && hasMoreDocsInDb) {\n          let query: firebase.firestore.Query<unknown> = this.ngFire.collection(\n            params.collection\n          ).ref;\n\n          query = this.applyFilters(query, params.arrange, params.conditions);\n\n          query = query.endBefore(boundaryDoc);\n          query = query.limitToLast(BATCH_FETCH_SIZE);\n\n          const snapshot = await query.get();\n\n          if (snapshot.empty) {\n            hasMoreDocsInDb = false;\n            break;\n          }\n\n          boundaryDoc = snapshot.docs[0] as any;\n\n          allFetchedDocs = [...snapshot.docs, ...allFetchedDocs];\n\n          const batchUsers = snapshot.docs\n            .map((doc: firebase.firestore.QueryDocumentSnapshot<unknown>) => ({\n              id: doc.id,\n              ...(doc.data() as any),\n            }))\n            .filter(params.filterFn);\n\n          pageResults = [...batchUsers, ...pageResults];\n\n          if (snapshot.size < BATCH_FETCH_SIZE) {\n            hasMoreDocsInDb = false;\n          }\n        }\n\n        const finalItems = pageResults.slice(0, params.batchSize);\n\n        const firstDocOfPage =\n          allFetchedDocs.find(\n            (doc: firebase.firestore.QueryDocumentSnapshot<unknown>) =>\n              doc.id === finalItems[0]?.id\n          ) || null;\n        const lastDocOfPage =\n          allFetchedDocs.find(\n            (doc: firebase.firestore.QueryDocumentSnapshot<unknown>) =>\n              doc.id === finalItems[finalItems.length - 1]?.id\n          ) || null;\n\n        return {\n          items: finalItems,\n          filterLength: null,\n          firstDoc: firstDocOfPage,\n          lastDoc: lastDocOfPage,\n          hasNextPage: true,\n          currentClientPageIndex: undefined,\n        };\n      }\n    } else {\n      let items: any[] = [];\n      let docs: firebase.firestore.QueryDocumentSnapshot<unknown>[] = [];\n      let hasNextPage = false;\n      let filterLength: null | number = null;\n\n      let query: firebase.firestore.Query<unknown> = this.ngFire.collection(\n        params.collection\n      ).ref;\n\n      if (params.conditions) {\n        params.conditions.forEach((c: Condition) => {\n          if (c.operator === '!=') {\n            query = query.orderBy(c.firestoreProperty);\n          }\n        });\n      }\n\n      query = this.applyFilters(query, params.arrange, params.conditions);\n\n      if (params.navigation === 'reload') {\n        query = query.limit(params.batchSize + 1);\n        if (params.doc && params.doc.firstDoc) {\n          query = query.startAt(params.doc.firstDoc);\n        }\n      } else if (params.navigation === 'forward') {\n        query = query.limit(params.batchSize + 1);\n\n        if (params.doc && params.doc.lastDoc) {\n          query = query.startAfter(params.doc.lastDoc);\n        }\n      } else {\n        // backward\n        query = query.limitToLast(params.batchSize + 1);\n        if (params.doc && params.doc.firstDoc) {\n          query = query.endBefore(params.doc.firstDoc);\n        }\n      }\n\n      const itemCol = await query.get();\n      itemCol.docs.forEach(\n        (doc: firebase.firestore.QueryDocumentSnapshot<unknown>) =>\n          docs.push(doc)\n      );\n      const itemPromises = docs.map(\n        async (item: firebase.firestore.QueryDocumentSnapshot<unknown>) => {\n          const itemData = item.data() as any;\n          items.push({ id: item.id, ...itemData });\n        }\n      );\n\n      let lastDoc: firebase.firestore.QueryDocumentSnapshot<unknown> | null =\n        docs[docs.length - 1] || null;\n      let firstDoc: firebase.firestore.QueryDocumentSnapshot<unknown> | null =\n        docs[0];\n\n      if (\n        (items.length > params.batchSize && params.navigation === 'forward') ||\n        (params.navigation === 'reload' && items.length > params.batchSize)\n      ) {\n        lastDoc = docs[docs.length - 2] || null;\n        items.pop();\n        hasNextPage = true;\n      }\n      if (items.length > params.batchSize && params.navigation === 'backward') {\n        firstDoc = docs[1];\n        items.shift();\n        hasNextPage = true;\n      }\n\n      await Promise.all(itemPromises);\n      return {\n        items,\n        filterLength,\n        lastDoc,\n        firstDoc,\n        hasNextPage,\n        currentClientPageIndex: undefined,\n      };\n    }\n\n    // Fallback para garantir que sempre retornamos algo\n    return {\n      items: [],\n      filterLength: null,\n      firstDoc: null,\n      lastDoc: null,\n      hasNextPage: false,\n      currentClientPageIndex: undefined,\n    };\n  }\n\n  applyFilters(\n    query: firebase.firestore.Query<unknown>,\n    arrange: Arrange,\n    conditions: Condition[] | undefined\n  ): firebase.firestore.Query<unknown> {\n    if (conditions) {\n      conditions.map((cond: Condition) => {\n        query = query.where(\n          cond.firestoreProperty,\n          cond.operator,\n          cond.dashProperty\n        );\n      });\n    }\n\n    let hasFilterSpecificOrderBy = false;\n    let appliedOrderByField: string | null = null;\n\n    const equalsFilters = arrange.filters.filter(\n      (f: any) => f.arrange === 'equals' && f.filter\n    );\n    const otherFilters = arrange.filters.filter(\n      (f: any) => f.arrange !== 'equals'\n    );\n\n    const equalsGroupedByProperty = equalsFilters.reduce(\n      (acc: any, current: any) => {\n        const prop = current.filter.property;\n        if (!acc[prop]) {\n          acc[prop] = [];\n        }\n        acc[prop].push(current.filter.filtering);\n        return acc;\n      },\n      {}\n    );\n\n    for (const prop in equalsGroupedByProperty) {\n      const values = equalsGroupedByProperty[prop];\n      if (values.length > 0) {\n        query = query.where(prop, 'in', values);\n      }\n    }\n\n    otherFilters.forEach((filterItem: any) => {\n      // Aplicar filtragem por busca\n      if (\n        filterItem.filter?.filtering &&\n        filterItem.filter?.property !== '' &&\n        filterItem.arrange === 'filter'\n      ) {\n        query = query\n          .where(\n            filterItem.filter.property,\n            '>=',\n            filterItem.filter.filtering.trim().toUpperCase()\n          )\n          .where(\n            filterItem.filter.property,\n            '<=',\n            filterItem.filter.filtering.trim().toUpperCase() + '\\uf8ff'\n          );\n        if (!hasFilterSpecificOrderBy) {\n          query = query.orderBy(filterItem.filter.property);\n          hasFilterSpecificOrderBy = true;\n          appliedOrderByField = filterItem.filter.property;\n        }\n      }\n\n      // Aplicar filtro do tipo \"filterByDate\"\n      if (filterItem.dateFilter && filterItem.arrange === 'filterByDate') {\n        query = query\n          .where(arrange.sortBy.field, '>=', filterItem.dateFilter.initial)\n          .where(arrange.sortBy.field, '<=', filterItem.dateFilter.final);\n        if (!hasFilterSpecificOrderBy) {\n          query = query.orderBy(arrange.sortBy.field);\n          hasFilterSpecificOrderBy = true;\n          appliedOrderByField = arrange.sortBy.field;\n        }\n      }\n    });\n\n    // Aplicar sortBy\n    if (arrange.sortBy && arrange.sortBy.field && arrange.sortBy.order) {\n      if (appliedOrderByField !== arrange.sortBy.field) {\n        query = query.orderBy(arrange.sortBy.field, arrange.sortBy.order);\n      }\n    }\n    return query;\n  }\n\n  /**\n   * Detecta se a query vai precisar de index composto e deve usar fallback client-side\n   */\n  private shouldUseClientSideFallback(params: Pagination): boolean {\n    const hasConditions = params.conditions && params.conditions.length > 0;\n    const hasArrangeFilters =\n      params.arrange?.filters && params.arrange.filters.length > 0;\n    const hasSortBy = params.arrange?.sortBy?.field;\n\n    if (params.filterFn) {\n      return false;\n    }\n\n    if (hasConditions && hasArrangeFilters && hasSortBy) {\n      return true;\n    }\n\n    if (hasConditions && hasArrangeFilters) {\n      return true;\n    }\n\n    if (hasArrangeFilters && params.arrange.filters.length > 1 && hasSortBy) {\n      return true;\n    }\n\n    return false;\n  }\n\n  async getPaginated(params: Pagination): Promise<PaginationResult> {\n    // Detectar preventivamente se deve usar fallback\n    if (this.shouldUseClientSideFallback(params)) {\n      await this.trackMissingIndexPreventive(\n        params.collection,\n        params.arrange,\n        params.conditions\n      );\n\n      const result = await this.executeClientSideQuery(params);\n      console.log('📊 [TABLE] Resultados paginados via fallback client-side:', {\n        totalItems: result.filterLength,\n        returnedItems: result.items.length,\n        hasNextPage: result.hasNextPage,\n        currentPage: (result.currentClientPageIndex || 0) + 1,\n      });\n      return result;\n    }\n\n    try {\n      const result = await this.executeQuery(params);\n      console.log('📊 [TABLE] Resultados paginados via Firestore:', {\n        totalItems: result.filterLength || 'N/A',\n        returnedItems: result.items.length,\n        hasNextPage: result.hasNextPage,\n      });\n      return result;\n    } catch (error: any) {\n      if (error && error.code === 'failed-precondition') {\n        await this.trackMissingIndex(\n          error,\n          params.collection,\n          params.arrange,\n          params.conditions\n        );\n\n        const result = await this.executeClientSideQuery(params);\n        console.log(\n          '📊 [TABLE] Resultados paginados via fallback (erro de index):',\n          {\n            totalItems: result.filterLength,\n            returnedItems: result.items.length,\n            hasNextPage: result.hasNextPage,\n            currentPage: (result.currentClientPageIndex || 0) + 1,\n          }\n        );\n        return result;\n      } else if (error && error.code === 'invalid-argument') {\n        await this.trackMissingIndex(\n          error,\n          params.collection,\n          params.arrange,\n          params.conditions\n        );\n\n        const result = await this.executeClientSideQuery(params);\n        console.log(\n          '📊 [TABLE] Resultados paginados via fallback (argumento inválido):',\n          {\n            totalItems: result.filterLength,\n            returnedItems: result.items.length,\n            hasNextPage: result.hasNextPage,\n            currentPage: (result.currentClientPageIndex || 0) + 1,\n          }\n        );\n        return result;\n      } else {\n        throw error;\n      }\n    }\n  }\n\n  async executeClientSideQuery(params: Pagination): Promise<PaginationResult> {\n    // Otimizar usando pelo menos uma cláusula .where() quando possível\n    let query: firebase.firestore.Query<unknown> = this.ngFire.collection(\n      params.collection\n    ).ref;\n\n    let appliedCondition: Condition | null = null;\n    let hasAppliedWhereClause = false;\n\n    // Primeiro, tenta aplicar condições simples\n    if (params.conditions && params.conditions.length > 0) {\n      const simpleCondition = params.conditions.find((cond: Condition) =>\n        ['==', '>', '<', '>=', '<='].includes(cond.operator)\n      );\n\n      if (simpleCondition) {\n        query = query.where(\n          simpleCondition.firestoreProperty,\n          simpleCondition.operator,\n          simpleCondition.dashProperty\n        );\n        appliedCondition = simpleCondition;\n        hasAppliedWhereClause = true;\n      }\n    }\n\n    // Se não há condições disponíveis, tenta aplicar filtros do arrange\n    let appliedFirestoreFilter: any = null;\n    if (!hasAppliedWhereClause && params.arrange?.filters) {\n      const equalsFilter = params.arrange.filters.find(\n        (f: any) => f.arrange === 'equals' && f.filter?.filtering\n      );\n\n      if (equalsFilter && equalsFilter.filter) {\n        query = query.where(\n          equalsFilter.filter.property,\n          '==',\n          equalsFilter.filter.filtering\n        );\n        hasAppliedWhereClause = true;\n        appliedFirestoreFilter = equalsFilter;\n      } else {\n        const otherFilter = params.arrange.filters.find(\n          (f: any) =>\n            (f.arrange === 'filter' &&\n              f.filter?.filtering &&\n              f.filter?.property) ||\n            (f.arrange === 'filterByDate' &&\n              f.dateFilter?.initial &&\n              f.dateFilter?.final)\n        );\n\n        if (otherFilter) {\n          if (otherFilter.arrange === 'filter' && otherFilter.filter) {\n            const filterValue = otherFilter.filter.filtering\n              .trim()\n              .toUpperCase();\n            query = query\n              .where(otherFilter.filter.property, '>=', filterValue)\n              .where(otherFilter.filter.property, '<=', filterValue + '\\uf8ff');\n            hasAppliedWhereClause = true;\n            appliedFirestoreFilter = otherFilter;\n          } else if (\n            otherFilter.arrange === 'filterByDate' &&\n            otherFilter.dateFilter &&\n            params.arrange.sortBy?.field\n          ) {\n            query = query\n              .where(\n                params.arrange.sortBy.field,\n                '>=',\n                otherFilter.dateFilter.initial\n              )\n              .where(\n                params.arrange.sortBy.field,\n                '<=',\n                otherFilter.dateFilter.final\n              );\n            hasAppliedWhereClause = true;\n            appliedFirestoreFilter = otherFilter;\n          }\n        }\n      }\n    }\n\n    const allDocsSnapshot = await query.get();\n    let items = allDocsSnapshot.docs.map(\n      (doc: firebase.firestore.QueryDocumentSnapshot<unknown>) => ({\n        id: doc.id,\n        ...(doc.data() as any),\n      })\n    );\n\n    // Aplicar condições restantes\n    if (params.conditions) {\n      const remainingConditions = params.conditions.filter(\n        (cond: Condition) => cond !== appliedCondition\n      );\n      if (remainingConditions.length > 0) {\n        const operators = this.operators;\n        items = items.filter((item: any) => {\n          return remainingConditions.every((cond: Condition) => {\n            const operatorFn =\n              operators[cond.operator as keyof typeof operators];\n            return operatorFn\n              ? operatorFn(item[cond.firestoreProperty], cond.dashProperty)\n              : false;\n          });\n        });\n      }\n    }\n\n    const { filters, sortBy } = params.arrange;\n\n    // Track which filter was already applied in Firestore to avoid double filtering\n    if (hasAppliedWhereClause && !appliedCondition && params.arrange?.filters) {\n      const equalsFilter = params.arrange.filters.find(\n        (f: any) => f.arrange === 'equals' && f.filter?.filtering\n      );\n      if (equalsFilter) {\n        appliedFirestoreFilter = equalsFilter;\n      } else {\n        appliedFirestoreFilter = params.arrange.filters.find(\n          (f: any) =>\n            (f.arrange === 'filter' &&\n              f.filter?.filtering &&\n              f.filter?.property) ||\n            (f.arrange === 'filterByDate' &&\n              f.dateFilter?.initial &&\n              f.dateFilter?.final)\n        );\n      }\n    }\n\n    const equalsFilters = filters.filter((f: any) => f.arrange === 'equals');\n    const otherFilters = filters.filter((f: any) => f.arrange !== 'equals');\n\n    const remainingEqualsFilters = equalsFilters.filter(\n      (f: any) => f !== appliedFirestoreFilter\n    );\n    if (remainingEqualsFilters.length > 0) {\n      items = items.filter((item: any) => {\n        return remainingEqualsFilters.every(\n          (f: any) => item[f.filter.property] === f.filter.filtering\n        );\n      });\n    }\n\n    otherFilters.forEach((filterItem: any) => {\n      if (appliedFirestoreFilter === filterItem) {\n        return;\n      }\n\n      if (\n        filterItem.arrange === 'filter' &&\n        filterItem.filter?.filtering &&\n        filterItem.filter?.property\n      ) {\n        const filterValue = String(filterItem.filter.filtering)\n          .trim()\n          .toLowerCase();\n        items = items.filter((item: any) => {\n          const itemValue = String(\n            item[filterItem.filter.property]\n          ).toLowerCase();\n          return itemValue.includes(filterValue);\n        });\n      }\n\n      if (\n        filterItem.arrange === 'filterByDate' &&\n        filterItem.dateFilter?.initial &&\n        filterItem.dateFilter?.final &&\n        sortBy.field\n      ) {\n        items = items.filter((item: any) => {\n          try {\n            const fieldValue = item[sortBy.field];\n\n            if (!fieldValue) {\n              return false;\n            }\n\n            let itemDate;\n            if (typeof fieldValue.toDate === 'function') {\n              itemDate = fieldValue.toDate();\n            } else if (fieldValue instanceof Date) {\n              itemDate = fieldValue;\n            } else if (typeof fieldValue === 'string') {\n              itemDate = new Date(fieldValue);\n              if (isNaN(itemDate.getTime())) {\n                return false;\n              }\n            } else if (typeof fieldValue === 'number') {\n              itemDate = new Date(fieldValue);\n            } else {\n              return false;\n            }\n\n            return (\n              itemDate >= filterItem.dateFilter.initial &&\n              itemDate <= filterItem.dateFilter.final\n            );\n          } catch (error) {\n            console.warn(\n              'Erro ao processar filtro de data para o item:',\n              item.id,\n              error\n            );\n            return false;\n          }\n        });\n      }\n    });\n\n    // Aplicar filterFn se existir\n    if (params.filterFn) {\n      items = items.filter(params.filterFn);\n    }\n\n    if (sortBy && sortBy.field && sortBy.order) {\n      items.sort((a: any, b: any) => {\n        const valA = a[sortBy.field];\n        const valB = b[sortBy.field];\n\n        if (valA < valB) {\n          return sortBy.order === 'asc' ? -1 : 1;\n        }\n        if (valA > valB) {\n          return sortBy.order === 'asc' ? 1 : -1;\n        }\n        return 0;\n      });\n    }\n\n    // Paginação\n    let currentClientPageIndex = 0;\n\n    if (params.navigation === 'reload') {\n      currentClientPageIndex = params.clientPageIndex || 0;\n    } else if (params.navigation === 'forward') {\n      currentClientPageIndex = (params.clientPageIndex || 0) + 1;\n    } else if (params.navigation === 'backward') {\n      currentClientPageIndex = Math.max(0, (params.clientPageIndex || 0) - 1);\n    }\n\n    const pageSize = params.batchSize;\n    const startIndex = currentClientPageIndex * pageSize;\n    const endIndex = startIndex + pageSize;\n    const paginatedItems = items.slice(startIndex, endIndex);\n\n    const totalPages = Math.ceil(items.length / pageSize);\n    const hasNextPage = currentClientPageIndex < totalPages - 1;\n    const hasPreviousPage = currentClientPageIndex > 0;\n\n    return {\n      items: paginatedItems,\n      filterLength: items.length,\n      lastDoc: null,\n      firstDoc: null,\n      hasNextPage: hasNextPage,\n      hasPreviousPage: hasPreviousPage,\n      currentClientPageIndex: currentClientPageIndex,\n      totalPages: totalPages,\n    };\n  }\n\n  async getItemsData(\n    collection: string,\n    arrange: Arrange,\n    conditions: Condition[] | undefined = undefined\n  ): Promise<any[]> {\n    try {\n      let query: firebase.firestore.Query<unknown> =\n        this.ngFire.collection(collection).ref;\n\n      query = this.applyFilters(query, arrange, conditions);\n      const snapshot = await query.get();\n      return await Promise.all(\n        snapshot.docs.map(\n          async (doc: firebase.firestore.QueryDocumentSnapshot<unknown>) => {\n            const data = doc.data() as any;\n            const id = doc.id;\n            return {\n              id,\n              ...data,\n            };\n          }\n        )\n      );\n    } catch (e) {\n      throw e;\n    }\n  }\n\n  public operators = {\n    '==': (a: any, b: any): boolean => a === b,\n    '!=': (a: any, b: any): boolean => a !== b,\n    '>': (a: any, b: any): boolean => a > b,\n    '<': (a: any, b: any): boolean => a < b,\n    '>=': (a: any, b: any): boolean => a >= b,\n    '<=': (a: any, b: any): boolean => a <= b,\n    includes: (a: any, b: any): any => a.includes(b),\n  };\n\n  async deleteIndex(\n    id: string,\n    col: string,\n    dialogComponent: any\n  ): Promise<boolean> {\n    const dialogRef = this.dialog.open(dialogComponent, {\n      data: {\n        title: 'Você realmente deseja deletar esse item?',\n        description: 'Essa ação é irreversível.',\n      },\n    });\n\n    const result = await firstValueFrom(dialogRef.afterClosed());\n    if (!result === true) {\n      return false;\n    }\n\n    try {\n      const batch = this.ngFire.firestore.batch();\n\n      const docRef = this.ngFire.collection(col).doc(id);\n      const docSnapshot = (await firstValueFrom(\n        docRef.get()\n      )) as firebase.firestore.DocumentSnapshot<unknown>;\n      const doc = docSnapshot.data() as any;\n      batch.delete(docRef.ref);\n      if (doc && typeof doc.index === 'number') {\n        await this.reindex(doc.index, col, batch);\n      }\n      await batch.commit();\n\n      this.toastr.success('Item excluído com sucesso!');\n      return true;\n    } catch (e) {\n      const error = e as any;\n      console.error('Erro ao deletar item:', error);\n      this.toastr.error('Erro ao deletar item.');\n      return false;\n    }\n  }\n\n  async reindex(\n    index: number,\n    col: string,\n    batch: firebase.firestore.WriteBatch\n  ): Promise<void> {\n    try {\n      const snapshot = (await firstValueFrom(\n        this.ngFire.collection(col).get()\n      )) as firebase.firestore.QuerySnapshot<unknown>;\n      const docs = snapshot.docs;\n      for (let doc of docs) {\n        const data = doc.data() as any;\n        if (data && typeof data.index === 'number' && data.index > index) {\n          data.index--;\n          const docRef = this.ngFire.collection(col).doc(doc.id).ref;\n          batch.update(docRef, data);\n        }\n      }\n    } catch (error) {\n      console.error('Erro ao reindexar:', error);\n    }\n    return;\n  }\n\n  dateFormatValidator(): ValidatorFn {\n    return (control: AbstractControl): { [key: string]: any } | null => {\n      if (!control.value) {\n        return null;\n      }\n\n      const dateStr = control.value.trim();\n      const datePattern = /^(\\d{1,2})\\/(\\d{1,2})\\/(\\d{4})$/;\n\n      if (!datePattern.test(dateStr)) {\n        return { invalidFormat: true };\n      }\n\n      const parts = dateStr.split('/');\n      const day = parts[0].padStart(2, '0');\n      const month = parts[1].padStart(2, '0');\n      const year = parts[2];\n      const normalizedDate = `${day}/${month}/${year}`;\n\n      const date = moment(normalizedDate, 'DD/MM/YYYY', true);\n\n      if (!date.isValid()) {\n        return { invalidDate: true };\n      }\n\n      return null;\n    };\n  }\n\n  async updateIndex(index: number, id: string, col: string): Promise<void> {\n    await this.ngFire.collection(col).doc(id).update({ index });\n  }\n\n  /**\n   * Extrai o link de criação de índice da mensagem de erro do Firestore\n   */\n  private extractIndexLink(error: any): string | null {\n    if (!error || !error.message) return null;\n\n    const linkMatch = error.message.match(\n      /(https:\\/\\/console\\.firebase\\.google\\.com\\/[^\\s]+)/\n    );\n    return linkMatch ? linkMatch[1] : null;\n  }\n\n  /**\n   * Rastreia índices ausentes ao usar fallback preventivo\n   */\n  private async trackMissingIndexPreventive(\n    collection: string,\n    arrange: Arrange,\n    conditions: Condition[] | undefined = undefined\n  ): Promise<void> {\n    try {\n      const querySignature = this.generateQuerySignature(\n        collection,\n        arrange,\n        conditions\n      );\n      const docId = `${collection}_${querySignature}`;\n\n      const indexLink = this.generateIndexLink(collection, arrange, conditions);\n\n      const indexInstructions = this.generateIndexInstructions(\n        collection,\n        arrange,\n        conditions\n      );\n\n      const trackingData: any = {\n        collection,\n        indexLink,\n        indexInstructions,\n        arrange: {\n          sortBy: arrange.sortBy,\n          filters:\n            arrange.filters?.map((f: any) => ({\n              arrange: f.arrange,\n              property: f.filter?.property || null,\n              dateField:\n                f.arrange === 'filterByDate' ? arrange.sortBy?.field : null,\n            })) || [],\n        },\n        conditions:\n          conditions?.map((c: Condition) => ({\n            property: c.firestoreProperty,\n            operator: c.operator,\n          })) || [],\n        errorMessage: `Fallback preventivo usado para a collection ${collection}. A query exigiria índice composto.`,\n        updatedAt: firebase.firestore.FieldValue.serverTimestamp(),\n      };\n\n      console.log('📄 [INDEX LINK] Dados que serão salvos no documento:', {\n        docId,\n        collection: trackingData.collection,\n        indexLink: trackingData.indexLink,\n        arrange: trackingData.arrange,\n        conditions: trackingData.conditions,\n        errorMessage: trackingData.errorMessage,\n      });\n\n      const docRef = this.ngFire.collection('missingIndexes').doc(docId);\n      const doc = await docRef.get().toPromise();\n\n      if (doc && doc.exists) {\n        await docRef.update({\n          count: firebase.firestore.FieldValue.increment(1),\n          updatedAt: firebase.firestore.FieldValue.serverTimestamp(),\n          lastError: trackingData.errorMessage,\n        });\n      } else {\n        await docRef.set({\n          ...trackingData,\n          count: 1,\n          createdAt: firebase.firestore.FieldValue.serverTimestamp(),\n        });\n      }\n    } catch (trackingError) {\n      console.warn('Falha ao rastrear fallback preventivo:', trackingError);\n    }\n  }\n\n  /**\n   * Gera uma assinatura única para uma query\n   */\n  private generateQuerySignature(\n    collection: string,\n    arrange: Arrange,\n    conditions: Condition[] | undefined = undefined\n  ): string {\n    const signature = {\n      collection,\n      sortBy: arrange.sortBy,\n      filters:\n        arrange.filters?.map((f: any) => ({\n          arrange: f.arrange,\n          property: f.filter?.property || null,\n        })) || [],\n      conditions:\n        conditions?.map((c: Condition) => ({\n          property: c.firestoreProperty,\n          operator: c.operator,\n        })) || [],\n    };\n\n    return btoa(JSON.stringify(signature))\n      .replace(/[^a-zA-Z0-9]/g, '')\n      .substring(0, 20);\n  }\n\n  /**\n   * Gera instruções claras para criar o índice manualmente\n   */\n  private generateIndexInstructions(\n    collection: string,\n    arrange: Arrange,\n    conditions: Condition[] | undefined = undefined\n  ): any {\n    const instructions: any = {\n      summary: '',\n      collection: collection,\n      fields: [] as any[],\n      queryExample: '',\n      stepByStep: [] as string[],\n      notes: [] as string[],\n    };\n\n    const fields: any[] = [];\n\n    if (conditions && conditions.length > 0) {\n      conditions.forEach((condition: Condition) => {\n        if (condition.firestoreProperty) {\n          fields.push({\n            field: condition.firestoreProperty,\n            order: 'Ascending',\n            type: 'WHERE clause',\n            operator: condition.operator,\n            description: `Filtrar por ${condition.firestoreProperty} usando operador ${condition.operator}`,\n          });\n        }\n      });\n    }\n\n    if (arrange.filters && arrange.filters.length > 0) {\n      arrange.filters.forEach((filter: any) => {\n        if (filter.filter?.property) {\n          fields.push({\n            field: filter.filter.property,\n            order: 'Ascending',\n            type: 'WHERE clause (filter)',\n            operator: filter.arrange === 'filter' ? 'CONTAINS' : 'RANGE',\n            description: `Filtrar por ${filter.filter.property} usando filtro ${filter.arrange}`,\n          });\n        }\n      });\n    }\n\n    if (arrange.sortBy?.field) {\n      fields.push({\n        field: arrange.sortBy.field,\n        order: arrange.sortBy.order === 'desc' ? 'Descending' : 'Ascending',\n        type: 'ORDER BY clause',\n        operator: 'N/A',\n        description: `Ordenar resultados por ${arrange.sortBy.field} em ordem ${arrange.sortBy.order}`,\n      });\n    }\n\n    instructions.fields = fields;\n\n    const fieldNames = fields.map((f: any) => f.field).join(' + ');\n    instructions.summary = `Criar índice composto para ${collection}: ${fieldNames}`;\n\n    let queryExample = `db.collection('${collection}')`;\n\n    fields.forEach((field: any, index: number) => {\n      if (field.type.includes('WHERE')) {\n        if (field.operator === '==') {\n          queryExample += `\\n  .where('${field.field}', '==', 'value')`;\n        } else if (field.operator === 'CONTAINS') {\n          queryExample += `\\n  .where('${field.field}', '>=', 'searchText')`;\n        } else {\n          queryExample += `\\n  .where('${field.field}', '${field.operator}', 'value')`;\n        }\n      }\n    });\n\n    const orderByField = fields.find((f: any) => f.type.includes('ORDER BY'));\n    if (orderByField) {\n      queryExample += `\\n  .orderBy('${\n        orderByField.field\n      }', '${orderByField.order.toLowerCase()}')`;\n    }\n\n    instructions.queryExample = queryExample;\n\n    instructions.stepByStep = [\n      '1. Ir para Firebase Console → Firestore → Indexes',\n      '2. Clicar em \"Create Index\"',\n      `3. Definir Collection ID: ${collection}`,\n      '4. Configurar campos nesta ORDEM EXATA:',\n      ...fields.map(\n        (field: any, index: number) =>\n          `   ${index + 1}. Campo: ${field.field}, Order: ${\n            field.order\n          }, Array: No`\n      ),\n      '5. Definir Query scopes: Collection',\n      '6. Clicar em \"Create\" e aguardar conclusão',\n    ];\n\n    instructions.notes = [\n      '⚠️ A ordem dos campos é CRÍTICA - deve corresponder exatamente à ordem da query',\n      '⚠️ As cláusulas WHERE devem vir ANTES do campo ORDER BY',\n      '⚠️ Este índice só funcionará para queries com esta combinação EXATA de campos',\n      '⚠️ A criação do índice pode levar vários minutos',\n    ];\n\n    return instructions;\n  }\n\n  /**\n   * Gera um link de índice baseado na estrutura da query\n   */\n  private generateIndexLink(\n    collection: string,\n    arrange: Arrange,\n    conditions: Condition[] | undefined = undefined\n  ): string | null {\n    try {\n      const indexFields: string[] = [];\n\n      if (conditions && conditions.length > 0) {\n        conditions.forEach((condition: Condition) => {\n          if (condition.firestoreProperty) {\n            indexFields.push(condition.firestoreProperty);\n          }\n        });\n      }\n\n      if (arrange.filters && arrange.filters.length > 0) {\n        arrange.filters.forEach((filter: any) => {\n          if (filter.filter?.property) {\n            indexFields.push(filter.filter.property);\n          }\n        });\n      }\n\n      if (arrange.sortBy?.field) {\n        indexFields.push(arrange.sortBy.field);\n      }\n\n      if (indexFields.length > 1) {\n        const baseUrl =\n          'https://console.firebase.google.com/project/toppayy-dev/firestore/indexes';\n        const queryParams = new URLSearchParams({\n          create_composite: `collection=${collection}&fields=${indexFields.join(\n            ','\n          )}`,\n        });\n\n        const finalLink = `${baseUrl}?${queryParams.toString()}`;\n        return finalLink;\n      }\n\n      return null;\n    } catch (error) {\n      console.warn('Falha ao gerar link de índice:', error);\n      return null;\n    }\n  }\n\n  private async trackMissingIndex(\n    error: any,\n    collection: string,\n    arrange: Arrange,\n    conditions: Condition[] | undefined = undefined\n  ): Promise<void> {\n    try {\n      const indexLink = this.extractIndexLink(error);\n      if (!indexLink) return;\n\n      const linkHash = btoa(indexLink)\n        .replace(/[^a-zA-Z0-9]/g, '')\n        .substring(0, 20);\n      const docId = `${collection}_${linkHash}`;\n\n      const indexInstructions = this.generateIndexInstructions(\n        collection,\n        arrange,\n        conditions\n      );\n\n      const trackingData: any = {\n        collection,\n        indexLink,\n        indexInstructions,\n        arrange: {\n          sortBy: arrange.sortBy,\n          filters:\n            arrange.filters?.map((f: any) => ({\n              arrange: f.arrange,\n              property: f.filter?.property || null,\n              dateField:\n                f.arrange === 'filterByDate' ? arrange.sortBy?.field : null,\n            })) || [],\n        },\n        conditions:\n          conditions?.map((c: Condition) => ({\n            property: c.firestoreProperty,\n            operator: c.operator,\n          })) || [],\n        errorMessage: error.message,\n        updatedAt: firebase.firestore.FieldValue.serverTimestamp(),\n      };\n\n      const docRef = this.ngFire.collection('missingIndexes').doc(docId);\n      const doc = await docRef.get().toPromise();\n\n      if (doc && doc.exists) {\n        await docRef.update({\n          count: firebase.firestore.FieldValue.increment(1),\n          updatedAt: firebase.firestore.FieldValue.serverTimestamp(),\n          lastError: error.message,\n        });\n      } else {\n        await docRef.set({\n          ...trackingData,\n          count: 1,\n          createdAt: firebase.firestore.FieldValue.serverTimestamp(),\n        });\n      }\n    } catch (trackingError) {\n      console.warn('Falha ao rastrear índice ausente:', trackingError);\n    }\n  }\n}\n"]}