@sankhyalabs/core 7.1.1-rc.1 → 7.2.1-dev.1

package/src/utils/ColumnFilterManager.ts

@@ -3,6 +3,7 @@ import DataUnit from '../dataunit/DataUnit.js';
 import { Record } from '../dataunit/interfaces/dataUnit.js';
 import { FieldComparator } from '../dataunit/sorting/FieldComparator.js';
 import { LoadDataRequest } from '../dataunit/loading/LoadDataRequest.js';
+import { DataType } from '../dataunit/metadata/DataType.js';
 
 const COLUMN_FILTER_PATTERN = /FILTRO_COLUNA_(.+)/;
 
@@ -46,13 +47,26 @@ export class ColumnFilterManager {
     if (!columnFilter.params || !fieldDescriptor) return false;
 
     const fieldValue = record[columnFilter.columnName];
+    /**
+     * Casa datas pelo valor FORMATADO — a mesma granularidade que o funil exibe/agrupa
+     * (dia p/ data pura, minuto p/ DATETIME). Nem por dia nem por timestamp exato. KB-171175.
+     */
+    const isDate = fieldDescriptor.dataType === DataType.DATE;
 
     for (let param of columnFilter.params) {
       const paramValue = dataUnit.valueFromString(columnFilter.columnName, param.value);
-      if (FieldComparator.compareValues(fieldDescriptor, fieldValue, paramValue) === 0) {
+      let matches: boolean;
+      if (isDate) {
+        matches = (fieldValue == undefined || paramValue == undefined)
+          ? fieldValue == paramValue
+          : dataUnit.getFormattedValue(columnFilter.columnName, fieldValue)
+              === dataUnit.getFormattedValue(columnFilter.columnName, paramValue);
+      } else {
+        matches = FieldComparator.compareValues(fieldDescriptor, fieldValue, paramValue) === 0;
+      }
+      if (matches) {
         return true;
       }
-
     }
     return false;
   }

package/test/util/ColumnFilterManager.spec.ts

@@ -1,5 +1,6 @@
 import { ColumnFilterManager, IColumnFilter } from '../../src/utils/ColumnFilterManager.js';
-import { FieldDescriptor, Filter, FilterParam } from '../../src/dataunit/metadata/UnitMetadata.js';
+import { FieldDescriptor, Filter, FilterParam, UserInterface } from '../../src/dataunit/metadata/UnitMetadata.js';
+import { DataType } from '../../src/dataunit/metadata/DataType.js';
 import DataUnit from '../../src/dataunit/DataUnit';
 import { Record } from '../../src/dataunit/interfaces/dataUnit';
 
@@ -82,6 +83,63 @@ describe('ColumnFilterManager', () => {
       const record: Record = { field1: 'test' } as unknown as Record;
       expect(filterFunction!(record)).toBe(false);
     });
+
+    describe('granularidade de data (KB-171175)', () => {
+      // Formata na granularidade EXIBIDA do campo, como o funil faz via getFormattedValue:
+      // DATE -> dia; DATETIME -> minuto. Usa toISOString (sempre UTC) p/ ser estável ao fuso do runner.
+      const formatterFor = (field: FieldDescriptor) => (_col: string, value: any) => {
+        if (value == undefined) return null;
+        const iso = new Date(value).toISOString();
+        return field.userInterface === UserInterface.DATE ? iso.slice(0, 10) : iso.slice(0, 16);
+      };
+
+      const buildDataUnit = (field: FieldDescriptor): DataUnit => ({
+        getField: jest.fn().mockReturnValue(field),
+        // O funil envia a data selecionada; devolvemos como Date, como faz o DataUnit real.
+        valueFromString: jest.fn().mockImplementation((_col: string, value: any) => new Date(value)),
+        getFormattedValue: jest.fn().mockImplementation(formatterFor(field)),
+      } as unknown as DataUnit);
+
+      const buildFilter = (...values: string[]): IColumnFilter[] => ([{
+        columnName: 'dt',
+        name: 'FILTRO_COLUNA_dt',
+        expression: '',
+        params: values.map(value => ({ value } as FilterParam)),
+      }]);
+
+      it('data PURA (DATE): casa por dia (granularidade exibida) — alinhado ao onlydate da exportação', () => {
+        const dataUnit = buildDataUnit({ name: 'dt', dataType: DataType.DATE, userInterface: UserInterface.DATE } as FieldDescriptor);
+        // Seleção do funil no nível de dia (03/08).
+        const filterFunction = ColumnFilterManager.getFilterFunction(dataUnit, buildFilter('2025-08-03T00:00:00Z'));
+
+        // Registros do mesmo dia, com horas diferentes, devem casar.
+        expect(filterFunction!({ dt: new Date('2025-08-03T09:18:00Z') } as unknown as Record)).toBe(true);
+        expect(filterFunction!({ dt: new Date('2025-08-03T09:22:00Z') } as unknown as Record)).toBe(true);
+        // Dia diferente não casa.
+        expect(filterFunction!({ dt: new Date('2025-08-04T09:18:00Z') } as unknown as Record)).toBe(false);
+      });
+
+      it('data+hora (DATETIME): casa pelo minuto exibido — distingue 09:18 de 09:22', () => {
+        const dataUnit = buildDataUnit({ name: 'dt', dataType: DataType.DATE, userInterface: UserInterface.DATETIME } as FieldDescriptor);
+        // Funil com apenas 09:22 marcado; o param carrega o timestamp representativo (09:22:39).
+        const filterFunction = ColumnFilterManager.getFilterFunction(dataUnit, buildFilter('2025-08-03T09:22:39Z'));
+
+        expect(filterFunction!({ dt: new Date('2025-08-03T09:22:00Z') } as unknown as Record)).toBe(true);
+        // O título das 09:18 deve sair da grade.
+        expect(filterFunction!({ dt: new Date('2025-08-03T09:18:49Z') } as unknown as Record)).toBe(false);
+      });
+
+      it('data+hora (DATETIME): mantém registros IRMÃOS do mesmo minuto com segundos diferentes (regressão KB-171175)', () => {
+        const dataUnit = buildDataUnit({ name: 'dt', dataType: DataType.DATE, userInterface: UserInterface.DATETIME } as FieldDescriptor);
+        // A opção "09:22" no funil = 1 param representativo (09:22:39), mas há irmãos :51/:55.
+        const filterFunction = ColumnFilterManager.getFilterFunction(dataUnit, buildFilter('2025-08-03T09:22:39Z'));
+
+        expect(filterFunction!({ dt: new Date('2025-08-03T09:22:39Z') } as unknown as Record)).toBe(true);
+        // Casamento exato descartaria estes; por minuto exibido eles PERMANECEM.
+        expect(filterFunction!({ dt: new Date('2025-08-03T09:22:51Z') } as unknown as Record)).toBe(true);
+        expect(filterFunction!({ dt: new Date('2025-08-03T09:22:55Z') } as unknown as Record)).toBe(true);
+      });
+    });
   });