@sankhyalabs/core 5.20.0-dev.69 → 5.20.0-dev.70

package/src/dataunit/sorting/FieldComparator.ts

@@ -1,38 +1,24 @@
-import { Record } from "../DataUnit.js";
-import { compareValues } from "../metadata/DataType.js";
-import { FieldDescriptor } from "../metadata/UnitMetadata.js";
+import { Record } from '../DataUnit.js';
+import { compareValues } from '../metadata/DataType.js';
+import { FieldDescriptor } from '../metadata/UnitMetadata.js';
 
-export class FieldComparator{
+export class FieldComparator {
 
-    public static compare(field: FieldDescriptor, recordA: Record, recordB: Record, asc: boolean = true): number{
+  public static compare(field: FieldDescriptor, recordA: Record, recordB: Record, asc: boolean = true): number {
+    const valueA = (asc ? recordA : recordB)[field.name];
+    const valueB = (asc ? recordB : recordA)[field.name];
 
-        const valueA = (asc ? recordA : recordB)[field.name];
-        const valueB = (asc ? recordB : recordA)[field.name];
+    return FieldComparator.compareValues(field, valueA, valueB);
+  }
 
-        
-        return FieldComparator.compareValues(field, valueA, valueB);
-    }
-    
-    public static compareValues(descriptor: FieldDescriptor, valueA: any, valueB: any): number{
-        const undefinedComparison = this.compareUndefined(valueA == undefined, valueB == undefined);
-    
-        if(undefinedComparison != undefined){
-            return undefinedComparison;
-        }
+  public static compareValues(descriptor: FieldDescriptor, valueA: any, valueB: any): number {
+    const undefinedComparison = this.compareUndefined(valueA == undefined, valueB == undefined);
+    return (undefinedComparison != undefined) ? undefinedComparison : compareValues(valueA, valueB, descriptor);
+  }
 
-        return compareValues(valueA, valueB, descriptor)
-    }
-
-    public static compareUndefined(isUndefinedA: boolean, isUndefinedB: boolean): number | undefined {
-
-        if(!isUndefinedA && !isUndefinedB){
-            return;
-        }
-
-        if(isUndefinedA && isUndefinedB){
-            return 0;
-        }
-
-        return isUndefinedA ? -1 : 1;
-    }
+  public static compareUndefined(isUndefinedA: boolean, isUndefinedB: boolean): number | undefined {
+    if (!isUndefinedA && !isUndefinedB) return;
+    if (isUndefinedA && isUndefinedB) return 0;
+    return isUndefinedA ? -1 : 1;
+  }
 }

package/src/index.ts

@@ -45,6 +45,10 @@ import { ServiceUtils }  from "./utils/ServiceUtils.js";
 import { StorageType } from "./utils/CacheManager/index.js";
 import OverflowWatcher, { OnOverflowCallBack, OverflowDirection, OverFlowWatcherParams, OVERFLOWED_CLASS_NAME } from "./utils/OverflowWatcher/index.js";
 import {LockManager, LockManagerOperation} from "./utils/LockManager.js";
+import { DataUnitInMemoryLoader } from "./dataunit/loader/dataUnitInMemoryLoader.js";
+import { DataUnitLoaderUtils, PaginationInfoBuilderParams } from "./dataunit/loader/utils/dataUnitLoaderUtils.js";
+import { ColumnFilterManager } from "./utils/ColumnFilterManager.js";
+import { DataUnitInMemoryLoaderConfig, RECORD_DATE_FORMAT } from "./dataunit/loader/DataUnitInMemoryLoaderConfig.js";
 
 /*Classes públicas no pacote*/
 export {
@@ -123,5 +127,11 @@ export {
     OVERFLOWED_CLASS_NAME,
     DataUnitEventOptions,
     ServiceCanceledException,
-    SilentException
+    SilentException,
+    DataUnitInMemoryLoader,
+    DataUnitLoaderUtils,
+    PaginationInfoBuilderParams,
+    ColumnFilterManager,
+    DataUnitInMemoryLoaderConfig,
+    RECORD_DATE_FORMAT
 };

package/src/utils/ColumnFilterManager.ts

@@ -0,0 +1,104 @@
+import { Filter } from '../dataunit/metadata/UnitMetadata.js';
+import DataUnit, { Record } from '../dataunit/DataUnit.js';
+import { FieldComparator } from '../dataunit/sorting/FieldComparator.js';
+import { LoadDataRequest } from '../dataunit/loading/LoadDataRequest.js';
+
+const COLUMN_FILTER_PATTERN = /FILTRO_COLUNA_(.+)/;
+
+export class ColumnFilterManager {
+
+  public static getColumnFilters(filters: Array<Filter>, fieldName: string): Map<string, IColumnFilter> {
+    const columnFilters: Map<string, IColumnFilter> = new Map();
+
+    if (!filters?.length) {
+      return columnFilters;
+    }
+
+    filters.forEach(filter => {
+      const result = COLUMN_FILTER_PATTERN.exec(filter.name);
+      if (result) {
+        if (fieldName !== result[1]) {
+          columnFilters.set(filter.name, { columnName: result[1], ...filter });
+        }
+      }
+    });
+
+    return columnFilters;
+  }
+
+  public static getFilterFunction(dataUnit: DataUnit, filters?: Array<IColumnFilter>): ((record: Record) => boolean) | undefined {
+    if (!filters?.length) return undefined;
+
+    return record => {
+      for (const filter of filters) {
+        if (!ColumnFilterManager.recordMatchesFilter(dataUnit, record, filter)) {
+          return false;
+        }
+      }
+      return true;
+    };
+  }
+
+  private static recordMatchesFilter(dataUnit: DataUnit, record: Record, columnFilter: IColumnFilter): boolean {
+    const fieldDescriptor = dataUnit.getField(columnFilter.columnName);
+
+    if (!columnFilter.params || !fieldDescriptor) return false;
+
+    const fieldValue = record[columnFilter.columnName];
+
+    for (let param of columnFilter.params) {
+      const paramValue = dataUnit.valueFromString(columnFilter.columnName, param.value);
+      if (FieldComparator.compareValues(fieldDescriptor, fieldValue, paramValue) === 0) {
+        return true;
+      }
+
+    }
+    return false;
+  }
+
+  public static compileDistinct(fieldName: string, dataUnit: DataUnit): Array<IMultiSelectionOption> {
+    const request = dataUnit.getLastLoadRequest();
+    let list = dataUnit.records;
+    return this.doCompileDistinct(request, fieldName, dataUnit, list);
+  }
+
+  public static compileDistinctFromArray(fieldName: string, dataUnit: DataUnit, records: Array<Record>): Array<IMultiSelectionOption> {
+    const request = dataUnit.getLastLoadRequest();
+    return this.doCompileDistinct(request, fieldName, dataUnit, records);
+  }
+
+  private static doCompileDistinct(request: LoadDataRequest | undefined, fieldName: string, dataUnit: DataUnit, list: Array<Record>) {
+    if (request != undefined) {
+      const columnFilters: Array<IColumnFilter> = Array.from(ColumnFilterManager.getColumnFilters(request?.filters ?? [], fieldName).values());
+      const filterFunction = ColumnFilterManager.getFilterFunction(dataUnit, columnFilters);
+      if (filterFunction != undefined) {
+        list = list.filter(filterFunction);
+      }
+    }
+
+    const distinct: Map<string, IMultiSelectionOption> = new Map(
+      list.map(record => {
+        const fieldValue = record[fieldName];
+        if (fieldValue == undefined) {
+          return [null, { label: null, value: null, check: true }];
+        }
+        const item = { label: dataUnit.getFormattedValue(fieldName, fieldValue), value: fieldValue, check: true };
+        return [item.label, item];
+      }) as any,
+    );
+
+    return Array.from(distinct.values());
+  }
+
+}
+
+
+interface IMultiSelectionOption {
+  value: string;
+  label: string;
+  check: boolean;
+}
+
+export interface IColumnFilter extends Filter {
+  columnName: string;
+}

package/test/dataunit/loader/dataUnitInMemoryLoader.spec.ts

@@ -0,0 +1,221 @@
+import { DataUnitInMemoryLoader } from '../../../src/dataunit/loader/dataUnitInMemoryLoader.js';
+import {
+  DataUnitInMemoryLoaderConfig,
+  RECORD_DATE_FORMAT,
+} from '../../../src/dataunit/loader/DataUnitInMemoryLoaderConfig.js';
+import { FieldDescriptor, UnitMetadata } from '../../../src/dataunit/metadata/UnitMetadata.js';
+import { DataType } from '../../../src/dataunit/metadata/DataType.js';
+import DateUtils from '../../../src/utils/DateUtils.js';
+import DataUnit, { Record } from '../../../src/dataunit/DataUnit.js';
+
+describe('DataUnitInMemoryLoader - loadData', () => {
+  const dataUnitMetetadata: UnitMetadata = {
+    name: 'test',
+    label: 'test',
+    fields: [],
+  };
+
+  it('should be called load data when auto load is true', async () => {
+    const config: DataUnitInMemoryLoaderConfig = {
+      autoLoad: true,
+    };
+    const inMemoryLoader = new DataUnitInMemoryLoader(dataUnitMetetadata, [], config);
+    const loadData = jest.spyOn(inMemoryLoader.dataUnit, 'loadData');
+    await inMemoryLoader.dataUnit.loadMetadata();
+    expect(loadData).toHaveBeenCalled();
+  });
+
+  it('should be called load data when auto load is undefined', async () => {
+    const config: DataUnitInMemoryLoaderConfig = {
+      autoLoad: undefined,
+    };
+    const inMemoryLoader = new DataUnitInMemoryLoader(dataUnitMetetadata, [], config);
+    const loadData = jest.spyOn(inMemoryLoader.dataUnit, 'loadData');
+    await inMemoryLoader.dataUnit.loadMetadata();
+    expect(loadData).toHaveBeenCalled();
+  });
+
+  it('should not be called load data when auto load is false', async () => {
+    const config: DataUnitInMemoryLoaderConfig = {
+      autoLoad: false,
+    };
+    const inMemoryLoader = new DataUnitInMemoryLoader(dataUnitMetetadata, [], config);
+    const loadData = jest.spyOn(inMemoryLoader.dataUnit, 'loadData');
+    await inMemoryLoader.dataUnit.loadMetadata();
+    expect(loadData).not.toHaveBeenCalled();
+  });
+
+  it('should be called load data when config is undefined', async () => {
+    const inMemoryLoader = new DataUnitInMemoryLoader(dataUnitMetetadata, []);
+    const loadData = jest.spyOn(inMemoryLoader.dataUnit, 'loadData');
+    await inMemoryLoader.dataUnit.loadMetadata();
+    expect(loadData).toHaveBeenCalled();
+  });
+});
+
+describe('DataUnitInMemoryLoader - getConvertedValue', () => {
+  let descriptor: FieldDescriptor;
+
+  beforeEach(() => {
+    descriptor = { name: 'testField', dataType: DataType.TEXT, label: 'mock' }; // Valor padrão para inicialização
+  });
+
+  it('should return the original string if descriptor is undefined', () => {
+    const result = DataUnitInMemoryLoader.getConvertedValue(undefined as any, 'testValue');
+    expect(result).toBe('testValue');
+  });
+
+  it('should return the original string if dataType is TEXT', () => {
+    descriptor.dataType = DataType.TEXT;
+    const result = DataUnitInMemoryLoader.getConvertedValue(descriptor, 'testValue');
+    expect(result).toBe('testValue');
+  });
+
+  it('should convert to boolean when dataType is BOOLEAN', () => {
+    descriptor.dataType = DataType.BOOLEAN;
+    expect(DataUnitInMemoryLoader.getConvertedValue(descriptor, 'S')).toBe(true);
+    expect(DataUnitInMemoryLoader.getConvertedValue(descriptor, 'N')).toBe(false);
+  });
+
+  it('should convert to number when dataType is NUMBER', () => {
+    descriptor.dataType = DataType.NUMBER;
+    expect(DataUnitInMemoryLoader.getConvertedValue(descriptor, '123')).toBe(123);
+    expect(DataUnitInMemoryLoader.getConvertedValue(descriptor, '45.67')).toBe(45.67);
+  });
+
+  it('should parse JSON when dataType is OBJECT', () => {
+    descriptor.dataType = DataType.OBJECT;
+    const jsonString = '{"key": "value"}';
+    const expectedObject = { key: 'value' };
+    expect(DataUnitInMemoryLoader.getConvertedValue(descriptor, jsonString)).toEqual(expectedObject);
+  });
+
+  it('should convert to date when dataType is DATE and format is ISO', () => {
+    descriptor.dataType = DataType.DATE;
+
+    const isoDate = '2023-01-01T00:00:00Z';
+    jest.spyOn(DateUtils, 'validateDate').mockImplementation((date) => date);
+
+    const result = DataUnitInMemoryLoader.getConvertedValue(descriptor, isoDate, RECORD_DATE_FORMAT.ISO);
+    expect(DateUtils.validateDate).toHaveBeenCalledWith(new Date(isoDate), true);
+    expect(result).toEqual(new Date(isoDate));
+  });
+
+  it('should convert to date when dataType is DATE and format is not ISO', () => {
+    descriptor.dataType = DataType.DATE;
+
+    const dateString = '01/01/2023';
+    jest.spyOn(DateUtils, 'strToDate').mockImplementation(() => new Date(2023, 0, 1));
+
+    const result = DataUnitInMemoryLoader.getConvertedValue(descriptor, dateString, RECORD_DATE_FORMAT.DD_MM_YYYY);
+    expect(DateUtils.strToDate).toHaveBeenCalledWith(dateString, true);
+    expect(result).toEqual(new Date(2023, 0, 1));
+  });
+
+  it('should return the original string if no dataType matches', () => {
+    descriptor.dataType = undefined as any; // Simula um caso inválido
+    const result = DataUnitInMemoryLoader.getConvertedValue(descriptor, 'testValue');
+    expect(result).toBe('testValue');
+  });
+});
+
+describe('DataUnitInMemoryLoader - removeLoader', () => {
+  let loader: DataUnitInMemoryLoader;
+  const mockedDataUnit = {} as DataUnit;
+
+  beforeEach(() => {
+    loader = new DataUnitInMemoryLoader();
+  });
+
+  it('should resolve with the provided record IDs', async () => {
+    const mockRecordIds = ['record1', 'record2', 'record3'];
+
+    const result = await loader.removeLoader(mockedDataUnit, mockRecordIds);
+
+    expect(result).toEqual(mockRecordIds);
+  });
+
+  it('should handle empty record ID array', async () => {
+    const mockRecordIds: string[] = [];
+
+    const result = await loader.removeLoader(mockedDataUnit, mockRecordIds);
+
+    expect(result).toEqual([]);
+  });
+
+  it('should resolve the promise', async () => {
+    const mockRecordIds = ['record1'];
+
+    await expect(loader.removeLoader(mockedDataUnit, mockRecordIds)).resolves.toEqual(mockRecordIds);
+  });
+});
+
+describe('DataUnitInMemoryLoader - buildInitialRecords (indiretamente via set records)', () => {
+  let loader: DataUnitInMemoryLoader;
+  let mockRecords: Array<Record> = [
+    { id: '1', amount: '100', isActive: 'S', createdAt: '01/01/2023' },
+    { id: '2', amount: '200.50', isActive: 'N', createdAt: '02/01/2023' },
+  ] as unknown as Record[];
+
+  let mockMetadata =  {
+    fields: [
+      { name: 'id', label: 'id', dataType: DataType.TEXT },
+      { name: 'amount', label: 'amount', dataType: DataType.NUMBER },
+      { name: 'isActive', label: 'isActive', dataType: DataType.BOOLEAN },
+      { name: 'createdAt', label: 'createdAt', dataType: DataType.DATE },
+    ],
+  };
+
+  beforeEach(() => {
+    loader = new DataUnitInMemoryLoader(mockMetadata as any, [], { recordDateFormat: RECORD_DATE_FORMAT.DD_MM_YYYY });
+  });
+
+  it('should build initial records and convert field values based on metadata', () => {
+    loader.records = mockRecords;
+    const initialRecords = loader['_initialRecords'];
+
+    expect(initialRecords).toHaveLength(2);
+
+    expect(initialRecords[0]).toEqual({
+      id: '1',
+      amount: 100,
+      isActive: true,
+      createdAt: expect.any(Date),
+      __record__id__: expect.any(String),
+    });
+
+    expect(initialRecords[1]).toEqual({
+      id: '2',
+      amount: 200.5,
+      isActive: false,
+      createdAt:  expect.any(Date),
+      __record__id__: expect.any(String),
+    });
+  });
+
+  it('should generate unique IDs for records without "__record__id__"', () => {
+    loader.records = [{ id: '3', amount: '300' }] as unknown as Record[];
+
+    const builtRecords = loader['_initialRecords'];
+    expect(builtRecords).toHaveLength(1);
+
+    expect(builtRecords[0]).toHaveProperty('__record__id__');
+    expect(typeof builtRecords[0]['__record__id__']).toBe('string');
+  });
+
+  it('should leave fields untouched if no matching metadata exists', () => {
+    mockRecords[0]['extraField'] = 'unchanged';
+    loader.records = mockRecords;
+
+    const builtRecords = loader['_initialRecords'];
+    expect(builtRecords[0]).toHaveProperty('extraField', 'unchanged');
+  });
+
+  it('should skip conversion for non-string field values', () => {
+    mockRecords[0].amount = 500;
+    loader.records = mockRecords;
+
+    const builtRecords = loader['_initialRecords'];
+    expect(builtRecords[0].amount).toBe(500);
+  });
+});

package/test/dataunit/loader/utils/dataUnitLoaderUtils.spec.ts

@@ -0,0 +1,158 @@
+jest.mock('../../../../src/utils/ColumnFilterManager', () => ({
+  ColumnFilterManager: {
+    getColumnFilters: jest.fn(),
+    getFilterFunction: jest.fn(),
+  },
+}));
+
+jest.mock('../../../../src/utils/SortingUtils', () => {
+  return {
+    __esModule: true, // Indica que este módulo possui uma exportação padrão
+    default: {
+      getSortingFunction: jest.fn(),
+    },
+  };
+});
+
+
+import { DataUnitLoaderUtils } from '../../../../src/dataunit/loader/utils/dataUnitLoaderUtils';
+import { IColumnFilter } from '../../../../src/utils/ColumnFilterManager';
+import { Record } from '../../../../src/dataunit/DataUnit';
+import { Filter, Sort, SortMode } from '../../../../src/dataunit/metadata/UnitMetadata';
+import { DataType } from '../../../../src/dataunit/metadata/DataType';
+import { ColumnFilterManager } from '../../../../src/utils/ColumnFilterManager';
+import SortingUtils from '../../../../src/utils/SortingUtils';
+
+
+describe('Utility Functions', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('applyFilter', () => {
+    it('should return the original records if no filters are provided', () => {
+      const records: Record[] = [{ __record__id__: '1' }, { __record__id__: '2' }];
+      const filters: Filter[] = [];
+      const columnFilterMock = new Map<string, IColumnFilter>();
+
+      (ColumnFilterManager.getColumnFilters as jest.Mock).mockReturnValue(columnFilterMock);
+      (ColumnFilterManager.getFilterFunction as jest.Mock).mockReturnValue(undefined);
+
+      const result = DataUnitLoaderUtils.applyFilter(records, {} as any, filters);
+
+      expect(result).toEqual(records);
+      expect(ColumnFilterManager.getColumnFilters).toHaveBeenCalledWith(filters, '');
+    });
+
+    it('should filter records based on provided filters', () => {
+      const records: Record[] = [{ __record__id__: '1' }, { __record__id__: '2' }];
+      const filters: Filter[] = [{ name: 'test', expression: '1' }];
+      const columnFilterMock = new Map<string, IColumnFilter>();
+      columnFilterMock.set('test', { columnName: 'name', ...filters[0] } as IColumnFilter);
+
+      (ColumnFilterManager.getColumnFilters as jest.Mock).mockReturnValue(columnFilterMock);
+      (ColumnFilterManager.getFilterFunction as jest.Mock).mockReturnValue((record: Record) => record.__record__id__ === '1');
+
+      const result = DataUnitLoaderUtils.applyFilter(records, {} as any, filters);
+
+      expect(result).toEqual([{ __record__id__: '1' }]);
+      expect(ColumnFilterManager.getFilterFunction).toHaveBeenCalledWith({}, Array.from(columnFilterMock.values()));
+    });
+  });
+
+  describe('buildPaginationInfo function', () => {
+    it('should return correct pagination info with default values', () => {
+
+      const result = DataUnitLoaderUtils.buildPaginationInfo({
+        recordsLength: 0,
+        offset: 0,
+        recordsPerPage: 5,
+      });
+
+      expect(result).toEqual({
+        currentPage: 0,
+        firstRecord: 0,
+        lastRecord: 0,
+        total: 0,
+        hasMore: false,
+      });
+    });
+
+    it('should redosLenth as same size as recordsPerPage', () => {
+      const result = DataUnitLoaderUtils.buildPaginationInfo({
+        recordsLength: 10,
+        offset: 0,
+        recordsPerPage: 10,
+      });
+
+      expect(result).toEqual({
+        currentPage: 0,
+        firstRecord: 1,
+        lastRecord: 10,
+        total: 10,
+        hasMore: false,
+      });
+    });
+
+
+    it('should handle case when totalRecordsLength and offset 0', () => {
+      const result = DataUnitLoaderUtils.buildPaginationInfo({
+        recordsLength: 10,
+        offset: 0,
+        recordsPerPage: 5,
+      });
+
+      expect(result).toEqual({
+        currentPage: 0,
+        firstRecord: 1,
+        lastRecord: 5,
+        total: 10,
+        hasMore: true,
+      });
+    });
+
+    it('should handle case when currentPageLength is less than totalRecordsLength and lastPage', () => {
+      const result = DataUnitLoaderUtils.buildPaginationInfo({
+        recordsLength: 10,
+        offset: 5,
+        recordsPerPage: 5,
+      });
+
+      expect(result).toEqual({
+        currentPage: 1,
+        firstRecord: 6,
+        lastRecord: 10,
+        total: 10,
+        hasMore: false,
+      });
+    });
+  });
+
+  describe('applySorting function', () => {
+
+    it('should return the original records if no sorting is provided', () => {
+      const records: Record[] = [{ __record__id__: '1' }, { __record__id__: '2' }];
+      const sorting: Sort[] = [];
+
+      const result = DataUnitLoaderUtils.applySorting(records, {} as any, sorting);
+
+      expect(result).toEqual(records);
+      expect(SortingUtils.getSortingFunction).not.toHaveBeenCalled();
+    });
+
+    it('should sort records based on provided sorting criteria', () => {
+      const records: Record[] = [{ __record__id__: '2' }, { __record__id__: '1' }];
+      const sorting: Sort[] = [{ field: '__record__id__', mode: SortMode.ASC, dataType: DataType.TEXT }];
+
+      const sortingFunction = (a: Record, b: Record) => (a.__record__id__ > b.__record__id__ ? 1 : -1);
+      (SortingUtils.getSortingFunction as jest.Mock).mockReturnValue(sortingFunction);
+
+      const result = DataUnitLoaderUtils.applySorting(records, {} as any, sorting);
+
+      expect(result).toEqual([{ __record__id__: '1' }, { __record__id__: '2' }]);
+      expect(SortingUtils.getSortingFunction).toHaveBeenCalledWith({}, sorting);
+    });
+  });
+
+
+});