ng-firebase-table-kxp 1.0.0

package/src/lib/services/table.service.ts

@@ -0,0 +1,1235 @@
+import { Injectable, Optional } from '@angular/core';
+import {
+  AngularFirestore,
+  CollectionReference,
+  QueryDocumentSnapshot,
+} from '@angular/fire/compat/firestore';
+import firebase from 'firebase/compat/app';
+import { Arrange, Condition, Pagination } from '../types/Table';
+import { firstValueFrom } from 'rxjs';
+import { MatDialog } from '@angular/material/dialog';
+import { ToastrService } from 'ngx-toastr';
+import { AbstractControl, ValidatorFn } from '@angular/forms';
+import * as moment from 'moment';
+
+interface PaginationResult {
+  items: any[];
+  filterLength: number | null;
+  firstDoc: firebase.firestore.QueryDocumentSnapshot<unknown> | null;
+  lastDoc: firebase.firestore.QueryDocumentSnapshot<unknown> | null;
+  hasNextPage: boolean;
+  hasPreviousPage?: boolean;
+  currentClientPageIndex?: number;
+  totalPages?: number;
+}
+
+@Injectable({
+  providedIn: 'root',
+})
+export class TableService {
+  constructor(
+    @Optional() private ngFire: AngularFirestore,
+    @Optional() private dialog: MatDialog,
+    @Optional() private toastr: ToastrService
+  ) {}
+
+  async getItems(collection: CollectionReference<unknown>): Promise<any[]> {
+    try {
+      const querySnapshot = await collection.get();
+      return querySnapshot.docs.map(
+        (doc: firebase.firestore.QueryDocumentSnapshot<unknown>) => {
+          return { ...(doc.data() as any), id: doc.id };
+        }
+      );
+    } catch (error) {
+      console.warn('Collection não encontrada:', error);
+      return [];
+    }
+  }
+
+  private async executeQuery(params: Pagination): Promise<PaginationResult> {
+    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: firebase.firestore.QueryDocumentSnapshot<unknown> | null =
+          params.doc ? params.doc.lastDoc : null;
+        let pageResults: any[] = [];
+        let allFetchedDocs: firebase.firestore.QueryDocumentSnapshot<unknown>[] =
+          [];
+        let hasMoreDocsInDb = true;
+
+        while (pageResults.length < GOAL_SIZE && hasMoreDocsInDb) {
+          let query: firebase.firestore.Query<unknown> = 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: firebase.firestore.QueryDocumentSnapshot<unknown>) => ({
+              id: doc.id,
+              ...(doc.data() as any),
+            }))
+            .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: firebase.firestore.QueryDocumentSnapshot<unknown>) =>
+              doc.id === finalItems[0]?.id
+          ) || null;
+        const lastDocOfPage =
+          allFetchedDocs.find(
+            (doc: firebase.firestore.QueryDocumentSnapshot<unknown>) =>
+              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: any[] = [];
+        let allFetchedDocs: firebase.firestore.QueryDocumentSnapshot<unknown>[] =
+          [];
+        let hasMoreDocsInDb = true;
+
+        let boundaryDoc = params.doc.firstDoc;
+
+        while (pageResults.length < GOAL_SIZE && hasMoreDocsInDb) {
+          let query: firebase.firestore.Query<unknown> = 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] as any;
+
+          allFetchedDocs = [...snapshot.docs, ...allFetchedDocs];
+
+          const batchUsers = snapshot.docs
+            .map((doc: firebase.firestore.QueryDocumentSnapshot<unknown>) => ({
+              id: doc.id,
+              ...(doc.data() as any),
+            }))
+            .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: firebase.firestore.QueryDocumentSnapshot<unknown>) =>
+              doc.id === finalItems[0]?.id
+          ) || null;
+        const lastDocOfPage =
+          allFetchedDocs.find(
+            (doc: firebase.firestore.QueryDocumentSnapshot<unknown>) =>
+              doc.id === finalItems[finalItems.length - 1]?.id
+          ) || null;
+
+        return {
+          items: finalItems,
+          filterLength: null,
+          firstDoc: firstDocOfPage,
+          lastDoc: lastDocOfPage,
+          hasNextPage: true,
+          currentClientPageIndex: undefined,
+        };
+      }
+    } else {
+      let items: any[] = [];
+      let docs: firebase.firestore.QueryDocumentSnapshot<unknown>[] = [];
+      let hasNextPage = false;
+      let filterLength: null | number = null;
+
+      let query: firebase.firestore.Query<unknown> = this.ngFire.collection(
+        params.collection
+      ).ref;
+
+      if (params.conditions) {
+        params.conditions.forEach((c: Condition) => {
+          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: firebase.firestore.QueryDocumentSnapshot<unknown>) =>
+          docs.push(doc)
+      );
+      const itemPromises = docs.map(
+        async (item: firebase.firestore.QueryDocumentSnapshot<unknown>) => {
+          const itemData = item.data() as any;
+          items.push({ id: item.id, ...itemData });
+        }
+      );
+
+      let lastDoc: firebase.firestore.QueryDocumentSnapshot<unknown> | null =
+        docs[docs.length - 1] || null;
+      let firstDoc: firebase.firestore.QueryDocumentSnapshot<unknown> | null =
+        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: firebase.firestore.Query<unknown>,
+    arrange: Arrange,
+    conditions: Condition[] | undefined
+  ): firebase.firestore.Query<unknown> {
+    if (conditions) {
+      conditions.map((cond: Condition) => {
+        query = query.where(
+          cond.firestoreProperty,
+          cond.operator,
+          cond.dashProperty
+        );
+      });
+    }
+
+    let hasFilterSpecificOrderBy = false;
+    let appliedOrderByField: string | null = null;
+
+    const equalsFilters = arrange.filters.filter(
+      (f: any) => f.arrange === 'equals' && f.filter
+    );
+    const otherFilters = arrange.filters.filter(
+      (f: any) => f.arrange !== 'equals'
+    );
+
+    const equalsGroupedByProperty = equalsFilters.reduce(
+      (acc: any, current: any) => {
+        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: any) => {
+      // 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
+   */
+  private shouldUseClientSideFallback(params: Pagination): boolean {
+    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: Pagination): Promise<PaginationResult> {
+    // 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: any) {
+      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: Pagination): Promise<PaginationResult> {
+    // Otimizar usando pelo menos uma cláusula .where() quando possível
+    let query: firebase.firestore.Query<unknown> = this.ngFire.collection(
+      params.collection
+    ).ref;
+
+    let appliedCondition: Condition | null = null;
+    let hasAppliedWhereClause = false;
+
+    // Primeiro, tenta aplicar condições simples
+    if (params.conditions && params.conditions.length > 0) {
+      const simpleCondition = params.conditions.find((cond: Condition) =>
+        ['==', '>', '<', '>=', '<='].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: any = null;
+    if (!hasAppliedWhereClause && params.arrange?.filters) {
+      const equalsFilter = params.arrange.filters.find(
+        (f: any) => 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: any) =>
+            (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: firebase.firestore.QueryDocumentSnapshot<unknown>) => ({
+        id: doc.id,
+        ...(doc.data() as any),
+      })
+    );
+
+    // Aplicar condições restantes
+    if (params.conditions) {
+      const remainingConditions = params.conditions.filter(
+        (cond: Condition) => cond !== appliedCondition
+      );
+      if (remainingConditions.length > 0) {
+        const operators = this.operators;
+        items = items.filter((item: any) => {
+          return remainingConditions.every((cond: Condition) => {
+            const operatorFn =
+              operators[cond.operator as keyof typeof operators];
+            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: any) => f.arrange === 'equals' && f.filter?.filtering
+      );
+      if (equalsFilter) {
+        appliedFirestoreFilter = equalsFilter;
+      } else {
+        appliedFirestoreFilter = params.arrange.filters.find(
+          (f: any) =>
+            (f.arrange === 'filter' &&
+              f.filter?.filtering &&
+              f.filter?.property) ||
+            (f.arrange === 'filterByDate' &&
+              f.dateFilter?.initial &&
+              f.dateFilter?.final)
+        );
+      }
+    }
+
+    const equalsFilters = filters.filter((f: any) => f.arrange === 'equals');
+    const otherFilters = filters.filter((f: any) => f.arrange !== 'equals');
+
+    const remainingEqualsFilters = equalsFilters.filter(
+      (f: any) => f !== appliedFirestoreFilter
+    );
+    if (remainingEqualsFilters.length > 0) {
+      items = items.filter((item: any) => {
+        return remainingEqualsFilters.every(
+          (f: any) => item[f.filter.property] === f.filter.filtering
+        );
+      });
+    }
+
+    otherFilters.forEach((filterItem: any) => {
+      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: any) => {
+          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: any) => {
+          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: any, b: any) => {
+        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: string,
+    arrange: Arrange,
+    conditions: Condition[] | undefined = undefined
+  ): Promise<any[]> {
+    try {
+      let query: firebase.firestore.Query<unknown> =
+        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: firebase.firestore.QueryDocumentSnapshot<unknown>) => {
+            const data = doc.data() as any;
+            const id = doc.id;
+            return {
+              id,
+              ...data,
+            };
+          }
+        )
+      );
+    } catch (e) {
+      throw e;
+    }
+  }
+
+  public operators = {
+    '==': (a: any, b: any): boolean => a === b,
+    '!=': (a: any, b: any): boolean => a !== b,
+    '>': (a: any, b: any): boolean => a > b,
+    '<': (a: any, b: any): boolean => a < b,
+    '>=': (a: any, b: any): boolean => a >= b,
+    '<=': (a: any, b: any): boolean => a <= b,
+    includes: (a: any, b: any): any => a.includes(b),
+  };
+
+  async deleteIndex(
+    id: string,
+    col: string,
+    dialogComponent: any
+  ): Promise<boolean> {
+    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()
+      )) as firebase.firestore.DocumentSnapshot<unknown>;
+      const doc = docSnapshot.data() as any;
+      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 as any;
+      console.error('Erro ao deletar item:', error);
+      this.toastr.error('Erro ao deletar item.');
+      return false;
+    }
+  }
+
+  async reindex(
+    index: number,
+    col: string,
+    batch: firebase.firestore.WriteBatch
+  ): Promise<void> {
+    try {
+      const snapshot = (await firstValueFrom(
+        this.ngFire.collection(col).get()
+      )) as firebase.firestore.QuerySnapshot<unknown>;
+      const docs = snapshot.docs;
+      for (let doc of docs) {
+        const data = doc.data() as any;
+        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(): ValidatorFn {
+    return (control: AbstractControl): { [key: string]: any } | null => {
+      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: number, id: string, col: string): Promise<void> {
+    await this.ngFire.collection(col).doc(id).update({ index });
+  }
+
+  /**
+   * Extrai o link de criação de índice da mensagem de erro do Firestore
+   */
+  private extractIndexLink(error: any): string | null {
+    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
+   */
+  private async trackMissingIndexPreventive(
+    collection: string,
+    arrange: Arrange,
+    conditions: Condition[] | undefined = undefined
+  ): Promise<void> {
+    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: any = {
+        collection,
+        indexLink,
+        indexInstructions,
+        arrange: {
+          sortBy: arrange.sortBy,
+          filters:
+            arrange.filters?.map((f: any) => ({
+              arrange: f.arrange,
+              property: f.filter?.property || null,
+              dateField:
+                f.arrange === 'filterByDate' ? arrange.sortBy?.field : null,
+            })) || [],
+        },
+        conditions:
+          conditions?.map((c: Condition) => ({
+            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
+   */
+  private generateQuerySignature(
+    collection: string,
+    arrange: Arrange,
+    conditions: Condition[] | undefined = undefined
+  ): string {
+    const signature = {
+      collection,
+      sortBy: arrange.sortBy,
+      filters:
+        arrange.filters?.map((f: any) => ({
+          arrange: f.arrange,
+          property: f.filter?.property || null,
+        })) || [],
+      conditions:
+        conditions?.map((c: Condition) => ({
+          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
+   */
+  private generateIndexInstructions(
+    collection: string,
+    arrange: Arrange,
+    conditions: Condition[] | undefined = undefined
+  ): any {
+    const instructions: any = {
+      summary: '',
+      collection: collection,
+      fields: [] as any[],
+      queryExample: '',
+      stepByStep: [] as string[],
+      notes: [] as string[],
+    };
+
+    const fields: any[] = [];
+
+    if (conditions && conditions.length > 0) {
+      conditions.forEach((condition: 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: any) => {
+        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: any) => f.field).join(' + ');
+    instructions.summary = `Criar índice composto para ${collection}: ${fieldNames}`;
+
+    let queryExample = `db.collection('${collection}')`;
+
+    fields.forEach((field: any, index: number) => {
+      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: any) => 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: any, index: number) =>
+          `   ${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
+   */
+  private generateIndexLink(
+    collection: string,
+    arrange: Arrange,
+    conditions: Condition[] | undefined = undefined
+  ): string | null {
+    try {
+      const indexFields: string[] = [];
+
+      if (conditions && conditions.length > 0) {
+        conditions.forEach((condition: Condition) => {
+          if (condition.firestoreProperty) {
+            indexFields.push(condition.firestoreProperty);
+          }
+        });
+      }
+
+      if (arrange.filters && arrange.filters.length > 0) {
+        arrange.filters.forEach((filter: any) => {
+          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;
+    }
+  }
+
+  private async trackMissingIndex(
+    error: any,
+    collection: string,
+    arrange: Arrange,
+    conditions: Condition[] | undefined = undefined
+  ): Promise<void> {
+    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: any = {
+        collection,
+        indexLink,
+        indexInstructions,
+        arrange: {
+          sortBy: arrange.sortBy,
+          filters:
+            arrange.filters?.map((f: any) => ({
+              arrange: f.arrange,
+              property: f.filter?.property || null,
+              dateField:
+                f.arrange === 'filterByDate' ? arrange.sortBy?.field : null,
+            })) || [],
+        },
+        conditions:
+          conditions?.map((c: Condition) => ({
+            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);
+    }
+  }
+}