@sankhyalabs/core 5.17.3 → 5.18.0-ms.1

package/src/dataunit/loader/dataUnitInMemoryLoader.ts

@@ -0,0 +1,176 @@
+import {
+  Change,
+  ChangeOperation,
+  DataType,
+  DataUnit,
+  DateUtils,
+  FieldDescriptor,
+  LoadDataRequest,
+  LoadDataResponse,
+  Record,
+  SavedRecord,
+  StringUtils,
+  UnitMetadata,
+} from '../../index.js';
+import { DataUnitInMemoryLoaderConfig, RECORD_DATE_FORMAT } from './DataUnitInMemoryLoaderConfig.js';
+import { DataUnitLoaderUtils } from './utils/dataUnitLoaderUtils.js';
+
+export class DataUnitInMemoryLoader {
+  private _dataUnit: DataUnit;
+  private _metadata: UnitMetadata | undefined;
+  private _initialRecords: Array<Record> = [];
+  private recordDateFormat: RECORD_DATE_FORMAT;
+  public static readonly IN_MEMORY_DATA_UNIT_NAME = 'InMemoryDataUnit';
+  public static readonly DEFAULT_PAGE_SIZE = 150;
+
+  constructor(metadata?: UnitMetadata, records?: Array<Record>, config?: DataUnitInMemoryLoaderConfig) {
+
+    this.metadata = metadata as UnitMetadata;
+    this.recordDateFormat = config?.recordDateFormat ?? RECORD_DATE_FORMAT.DD_MM_YYYY;
+    this.records = records ?? [] as Array<Record>;
+
+    this._dataUnit = new DataUnit(DataUnitInMemoryLoader.IN_MEMORY_DATA_UNIT_NAME);
+    this._dataUnit.pageSize = config?.pageSize ?? DataUnitInMemoryLoader.DEFAULT_PAGE_SIZE;
+    this._dataUnit.metadataLoader = () => this.metadaLoader();
+    this._dataUnit.dataLoader = (dataUnit: DataUnit, request: LoadDataRequest) => this.inMemoryLoader(dataUnit, request, this.getRecordsToLoad());
+    this._dataUnit.saveLoader = (_dataUnit: DataUnit, changes: Array<Change>) => this.saveLoader(_dataUnit, changes);
+    this._dataUnit.removeLoader = (_dataUnit: DataUnit, recordIds: Array<string>) => this.removeLoader(_dataUnit, recordIds);
+
+    this.dataUnit.loadMetadata().then(() => {
+      if (config?.autoLoad !== false) {
+        this.dataUnit.loadData();
+      }
+    });
+  }
+
+  private getRecordsToLoad(): Array<Record> {
+    if (this._initialRecords == undefined && this.dataUnit.records.length > 0) {
+      this._initialRecords = this.dataUnit.records;
+    }
+
+    const addedRecords = this.dataUnit.getAddedRecords();
+    if (addedRecords) {
+      return [...this._initialRecords, ...addedRecords];
+    }
+    return this._initialRecords;
+  }
+
+  public get dataUnit(): DataUnit {
+    return this._dataUnit;
+  }
+
+  public get records(): Array<Record> {
+    return this.dataUnit.records;
+  }
+
+  public set records(records: Array<Record>) {
+    const columns = this.buildColumns();
+
+    this._initialRecords = this.buildInitialRecords(records, columns);
+
+    if (!this._dataUnit) return;
+
+    //Isso força o refresh internamente no datunit
+    this._dataUnit.loadData();
+  }
+
+  public static getConvertedValue(descriptor: FieldDescriptor, strValue: string, dateFormat?: RECORD_DATE_FORMAT) {
+    if (!descriptor) return strValue;
+    if (descriptor.dataType === DataType.BOOLEAN) return strValue === 'S';
+    if (descriptor.dataType === DataType.NUMBER) return Number(strValue);
+    if (descriptor.dataType === DataType.OBJECT) return JSON.parse(strValue);
+
+    if (descriptor.dataType === DataType.DATE) {
+      return dateFormat === RECORD_DATE_FORMAT.ISO
+        ? DateUtils.validateDate(new Date(strValue), true)
+        : DateUtils.strToDate(strValue, true);
+    }
+
+    return strValue;
+  }
+
+  private buildColumns() {
+    return this._metadata
+      ? new Map(this._metadata.fields.map(descriptor => [descriptor.name, descriptor]))
+      : undefined;
+  }
+
+  private buildInitialRecords(records: Array<Record>, columns: Map<string, FieldDescriptor> | undefined) {
+    const newRecords = records?.map(record => {
+
+      if (!record['__record__id__']) {
+        record['__record__id__'] = this.generateUniqueId();
+      }
+
+      if (!columns) return record;
+
+      for (const fieldName in record) {
+        const value = record[fieldName];
+        const fieldDescriptor = columns.get(fieldName);
+
+        if (typeof value === 'string' && fieldDescriptor) {
+          record[fieldName] = DataUnitInMemoryLoader.getConvertedValue(fieldDescriptor, value, this.recordDateFormat);
+        }
+      }
+
+      return record;
+    });
+
+    return newRecords;
+  }
+
+  public get metadata(): UnitMetadata {
+    return this._metadata as UnitMetadata;
+  }
+
+  public set metadata(metadata: UnitMetadata) {
+    this._metadata = metadata;
+
+    if (this._dataUnit) {
+      this._dataUnit.metadata = metadata as UnitMetadata;
+    }
+  }
+
+  private generateUniqueId(): string {
+    return StringUtils.generateUUID();
+  }
+
+  private inMemoryLoader(dataUnit: DataUnit, request: LoadDataRequest, recordsIn: Array<Record>): Promise<LoadDataResponse> {
+    return DataUnitLoaderUtils.buildLoadDataResponse(recordsIn, dataUnit, request);
+  }
+
+  private metadaLoader(): Promise<UnitMetadata> {
+    return Promise.resolve(this._metadata as UnitMetadata);
+  }
+
+  private saveLoader(_dataUnit: DataUnit, changes: Array<Change>): Promise<Array<SavedRecord>> {
+    return new Promise((resolve) => {
+      let dataUnitRecords: SavedRecord[] = [];
+
+      changes.forEach(change => {
+        let { record, updatingFields, operation } = change;
+
+        const changedRecord = { ...record, ...updatingFields };
+
+        if (operation === ChangeOperation.INSERT ||
+          operation === ChangeOperation.COPY) {
+          changedRecord['__old__id__'] = record['__record__id__'];
+          changedRecord['__record__id__'] = this.generateUniqueId();
+
+          this.records.push(changedRecord);
+        } else {
+          const recordIndex = this.records.findIndex(r => r['__record__id__'] == changedRecord['__record__id__']);
+          this.records[recordIndex] = changedRecord;
+        }
+
+        dataUnitRecords.push(changedRecord);
+      });
+
+      resolve(dataUnitRecords);
+    });
+  }
+
+  public removeLoader(_dataUnit: DataUnit, recordIds: Array<string>): Promise<Array<string>> {
+    return new Promise((resolve) => resolve(recordIds));
+  }
+}

package/src/dataunit/loader/utils/dataUnitLoaderUtils.ts

@@ -0,0 +1,86 @@
+import DataUnit, { Record } from '../../DataUnit.js';
+import { Filter, Sort } from '../../metadata/UnitMetadata.js';
+import { LoadDataRequest } from '../../loading/LoadDataRequest.js';
+import { PaginationInfo } from '../../loading/PaginationInfo.js';
+import { IColumnFilter, ColumnFilterManager } from '../../../utils/ColumnFilterManager.js';
+import SortingUtils from '../../../utils/SortingUtils.js';
+
+export class DataUnitLoaderUtils {
+
+
+  public static applyFilter(records: Array<Record>, dataUnit: DataUnit, filters: Array<Filter>): Array<Record> {
+    const columnFilters: Map<string, IColumnFilter> = ColumnFilterManager.getColumnFilters(filters, "");
+    if (!columnFilters?.size) return records;
+
+    const filterFunction: ((record: Record) => boolean) | undefined = ColumnFilterManager.getFilterFunction(dataUnit, Array.from(columnFilters.values()));
+    return (filterFunction) ? records.filter(filterFunction) : records;
+  }
+
+
+  public static buildLoadDataResponse(recordsIn: Array<Record>, dataUnit: DataUnit, request: LoadDataRequest) {
+    let records = recordsIn ? [...recordsIn] : [];
+    records = DataUnitLoaderUtils.applyFilter(records, dataUnit, request?.filters ?? []);
+    records = DataUnitLoaderUtils.applySorting(records, dataUnit, request?.sort ?? []);
+
+    const { offset, limit } = request;
+
+    const paginationInfoBuilderParams = {
+      recordsLength: records.length,
+      offset,
+      recordsPerPage: limit,
+    } as PaginationInfoBuilderParams;
+
+    return Promise.resolve({
+      records: DataUnitLoaderUtils.getPagesByRecords(records, offset, limit),
+      paginationInfo: dataUnit.pageSize ? DataUnitLoaderUtils.buildPaginationInfo(paginationInfoBuilderParams) : undefined,
+    });
+  }
+
+
+  public static applySorting(records: Array<Record>, dataUnit: DataUnit, sorting: Array<Sort>): Array<Record> {
+    if (sorting == undefined || sorting.length == 0) {
+      return records;
+    }
+    const sortingFunction = SortingUtils.getSortingFunction(dataUnit, sorting);
+    if (sortingFunction == undefined) {
+      return records;
+    }
+    return records.sort(sortingFunction);
+  }
+
+  public static getPagesByRecords(records: Record[], offset = 0, limit = 0){
+    if(!records || !records.length || !this.hasValidLimitAndOffset(offset, limit)) return [];
+    if(limit === 0 && offset === 0) return records;
+    return records.slice(offset, offset + limit);
+  }
+
+  private static hasValidLimitAndOffset(offset: number, limit: number) {
+    return offset >= 0 && limit >= 0;
+  }
+
+  public static buildPaginationInfo({recordsLength = 0, offset = 0, recordsPerPage = 0}: PaginationInfoBuilderParams): PaginationInfo | undefined {
+
+    if (!recordsLength) {
+      return { currentPage: 0, firstRecord: 0, lastRecord: 0, total: 0, hasMore: false };
+    }
+
+    const lastRecordIndex = offset + recordsPerPage;
+    const lastRecord = lastRecordIndex ? Math.min(lastRecordIndex, recordsLength) : recordsLength;
+
+    return {
+      currentPage: recordsPerPage === 0 ? 0 : Math.ceil(offset / recordsPerPage),
+      firstRecord: offset + 1,
+      lastRecord: lastRecord,
+      total: recordsLength,
+      hasMore: lastRecord < recordsLength,
+    };
+  }
+
+}
+
+
+export interface PaginationInfoBuilderParams {
+  recordsLength: number,
+  offset: number,
+  recordsPerPage: number
+}

package/src/dataunit/loading/LoadDataRequest.ts

@@ -4,7 +4,7 @@ import { Filter, Sort } from "../metadata/UnitMetadata.js";
 /** Atributos enviados na requisição de carregamento dos registros */
 export interface LoadDataRequest {
     /** De onde partiu o refresh. Por padrão a fonte não é identificada */
-    source?: String;
+    source?: string;
 
     /** Indice inicial dos registros que será retornado */
     offset?: number;

package/src/dataunit/loading/PaginationInfo.ts

@@ -18,4 +18,14 @@ export interface PaginationInfo {
 
     /** Se ainda existem mais registros */
     hasMore: boolean;
+    
+    /** Informa se o carregamento de dados em background está sendo executado
+     *  Caso o dataunit não tenha carga paralela o valor será indefinido
+     */
+    loadingInProgress?: boolean;
+
+    /**
+     * Informa se deve exibir diálogo para cancelar carregamento de registros
+     */
+    askRowsLimit?: number;
 }

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/dataunit/state/action/DataUnitAction.ts

@@ -36,6 +36,7 @@ export enum Action{
     SAVING_DATA = "savingData",
     DATA_SAVED = "dataSaved",
     SAVING_ERROR = "savingError",
+    SAVING_CANCELED = "savingCanceled",
 
     REMOVING_RECORDS = "removingRecords",
     RECORDS_REMOVED = "recordsRemoved",

package/src/dataunit/state/slice/LoadingControlSlice.ts

@@ -1,4 +1,5 @@
 
+import { ChangeOperation } from "../../DataUnit.js";
 import { LoadDataRequest } from "../../loading/LoadDataRequest.js";
 import { PaginationInfo } from "../../loading/PaginationInfo.js";
 import { Action } from "../action/DataUnitAction.js";
@@ -16,6 +17,9 @@ class LoadingControlReducerImpl implements ActionReducer {
                 return {...currentState, paginationInfo: action.payload?.paginationInfo};
             case Action.PAGINATION_UPDATED:
                 return {...currentState, paginationInfo: action.payload};
+            case Action.DATA_SAVED:
+                return {...currentState, paginationInfo: updatePaginationInfo(stateManager, action.payload)};
+
         }
         return currentState;
     }
@@ -56,7 +60,45 @@ export const hasPreviousPages = (stateManager: StateManager): boolean => {
     return paginationInfo ? paginationInfo.currentPage > 0 : false;
 }
 
+const updatePaginationInfo = (stateManager: StateManager, payload: Payload): PaginationInfo =>{
+    const paginationInfo = getPaginationInfo(stateManager);
+    let { records, changes } = payload;
+
+    if(!records || !changes || !paginationInfo || !validateNewRecordOperation(changes)) return paginationInfo as PaginationInfo;
+    
+    const { count, firstRecord, lastRecord, total } = paginationInfo;
+
+    return {
+        ...paginationInfo,
+        count: (count ?? 0) + records.length,
+        firstRecord: firstRecord === 0 && records.length > 0 ? 1 : firstRecord,
+        lastRecord: lastRecord + records.length,
+        total: (total ?? 0) + records.length
+    }
+    
+}
+
+const validateNewRecordOperation = (changes: Array<Change>): boolean => {
+    return changes.every(change => isNewRecordOperation(change._operation));
+};
+
+const isNewRecordOperation = (operation: string): operation is ChangeOperation => {
+    return ["INSERT", "COPY"].includes(operation);
+};
+
 interface LoadingControlState{
     lastRequest: LoadDataRequest;
     paginationInfo: PaginationInfo;
+}
+
+interface Change {
+    dataUnit: string;
+    record: Record<string, any>;
+    updatingFields: Record<string, any>;
+    _operation: string;
+}
+
+interface Payload {
+    changes: Change[];
+    records: Record<string, any>[];
 }

package/src/dataunit/state/slice/RecordsSlice.ts

@@ -47,7 +47,7 @@ class RecordsReducerImpl implements ActionReducer {
                         newRecords.push(newRecord);
                     }
                 });
-                return newRecords.concat(Array.from(recordsMap.values()));
+                return Array.from(recordsMap.values()).concat(newRecords);
 
             case Action.RECORD_LOADED:
                 action.payload.forEach((record: any) => {

package/src/dataunit/state/slice/SelectionSlice.ts

@@ -94,8 +94,8 @@ export const getSelection = (stateManager: StateManager): Array<string> => {
 export const getSelectionInfo = (stateManager: StateManager): SelectionInfo => {
 
     const selection = getSelectionState(stateManager);
+    const currentRequest = getCurrentRequest(stateManager);
     if(selection && selection.mode === SelectionMode.ALL_RECORDS){
-        const currentRequest = getCurrentRequest(stateManager);
         const paginationInfo: PaginationInfo | undefined = getPaginationInfo(stateManager);
         return new SelectionInfo(
             [],
@@ -106,7 +106,7 @@ export const getSelectionInfo = (stateManager: StateManager): SelectionInfo => {
         );
     }
    
-    return new SelectionInfo(getSelectionRecords(stateManager) || [], SelectionMode.SOME_RECORDS, undefined);
+    return new SelectionInfo(getSelectionRecords(stateManager) || [], SelectionMode.SOME_RECORDS, undefined, undefined, currentRequest?.sort);
 }
 
 export const hasNext = (stateManager: StateManager): boolean => {

package/src/dataunit/state/slice/test/RecordsSlice.spec.ts

@@ -0,0 +1,45 @@
+
+import * as RecordsReducerModule from '../RecordsSlice';
+import StateManager from '../../StateManager';
+import { Record } from '../../../DataUnit';
+import { Action } from '../../action/DataUnitAction';
+
+jest.spyOn(RecordsReducerModule, "getRecords").mockImplementation(() => [
+    {
+        __record__id__: '0',
+    }, {
+    __record__id__: '1',
+    }]);
+
+describe('RecordsSlice', () => {
+    let stateManager: StateManager;
+    let currentState: Array<Record>;
+    
+    beforeEach(() => {
+        stateManager = new StateManager([RecordsReducerModule.RecordsReducer]);
+        currentState = [{
+            __record__id__: '0',
+        }, {
+        __record__id__: '1',
+        }]
+    });
+
+    it('should return newlines at the end', () => {
+        let records = RecordsReducerModule.RecordsReducer.reduce(stateManager, currentState, {
+            type: Action.DATA_SAVED,
+            payload: {
+                records: [
+                    {__record__id__: '0'},
+                    {__record__id__: '2'},
+                    {__record__id__: '1'},
+                ]
+            }
+        })
+        expect(records).toEqual([
+            {__record__id__: '0'},
+            {__record__id__: '1'},
+            {__record__id__: '2'}
+        ]);
+    });
+
+});

package/src/dataunit/test/DataUnit.spec.ts

@@ -0,0 +1,44 @@
+import DataUnit  from '../DataUnit';
+import { Action } from '../state/action/DataUnitAction';
+
+describe('DataUnit', () => {
+
+    let dataUnit: DataUnit;
+
+    beforeEach(() => {
+        dataUnit = new DataUnit();
+
+        dataUnit['dispatchAction'] = jest.fn();
+    });
+
+    it('should return false when not waiting to reload', () => {
+        expect(dataUnit.isWaitingToReload()).toBe(false);
+    });
+
+    it('should set waitingToReload to true', () => {
+        dataUnit.setWaitingToReload(true);
+        expect(dataUnit.isWaitingToReload()).toBe(true);
+    });
+
+    it('should set waitingToReload to false', () => {
+        dataUnit.setWaitingToReload(true);
+        dataUnit.setWaitingToReload(false);
+        expect(dataUnit.isWaitingToReload()).toBe(false);
+    });
+
+    it('should dispatch SAVING_CANCELED action with correct fields and recordId', () => {
+        const fields = [
+            { name: 'field1', message: 'error1' },
+            { name: 'field2', message: 'error2' }
+        ];
+        const recordId = '12345';
+
+        dataUnit.savingCanceled(fields, recordId);
+
+        expect(dataUnit['dispatchAction']).toHaveBeenCalledWith(
+            Action.SAVING_CANCELED,
+            { fields, recordId },
+            undefined
+        );
+    });
+});

package/src/exceptions/ServiceCanceledException.ts

@@ -0,0 +1,25 @@
+/**
+ * `ServiceCanceledException`: Exceção lançada quando ocorre o cancelamento de um serviço. 
+ */
+export default class ServiceCanceledException extends Error {
+    
+    /** Nome da exceção. */
+    public name: string;
+
+    /** Titulo do erro. */
+    public title: string;
+
+    /** Descrição do erro. */
+    public message: string;
+    
+    /** Código do erro, indica o erro disparado pelo backend. */
+    public errorCode: string;
+
+    constructor(title: string, message: string, errorCode: string = "") {
+        super(message);
+        this.name = "Service Canceled";
+        this.title = title;
+        this.message = message;
+        this.errorCode = errorCode;
+    }
+}

package/src/exceptions/SilentException.ts

@@ -0,0 +1,25 @@
+/**
+ * `SilentException`: Exceção lançada quando uma exception silenciosa é. 
+ */
+export default class SilentException extends Error {
+    
+    /** Nome da exceção. */
+    public name: string;
+
+    /** Titulo do erro. */
+    public title: string;
+
+    /** Descrição do erro. */
+    public message: string;
+    
+    /** Código do erro, indica o erro disparado pelo backend. */
+    public errorCode: string;
+
+    constructor(title: string = "", message: string = "", errorCode: string = "") {
+        super(message);
+        this.name = "SilentException";
+        this.title = title;
+        this.message = message;
+        this.errorCode = errorCode;
+    }
+}

package/src/index.ts

@@ -19,6 +19,8 @@ import ObjectUtils from "./utils/ObjectUtils.js";
 import WarningException from "./exceptions/WarningException.js";
 import WaitingChangeException from "./exceptions/WaitingChangeException.js";
 import ErrorException from "./exceptions/ErrorException.js";
+import ServiceCanceledException from "./exceptions/ServiceCanceledException.js";
+import SilentException from "./exceptions/SilentException.js";
 import { ErrorTracking } from "./traking/ErrorTraking.js";
 import { PaginationInfo } from "./dataunit/loading/PaginationInfo.js";
 import { LoadDataRequest } from "./dataunit/loading/LoadDataRequest.js";
@@ -39,10 +41,19 @@ import { IRepositoryIndex } from "./repository/indexeddb/IRepositoryIndex.js"
 import { FieldComparator } from "./dataunit/sorting/FieldComparator.js";
 import { KeyboardManager } from "./utils/KeyboardManager/index.js";
 import { SearchUtils } from "./utils/SearchUtils.js";
+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 {
+    LockManager,
+    LockManagerOperation,
     StringUtils,
     MaskFormatter,
     NumberUtils,
@@ -107,10 +118,20 @@ export {
     defaultDataLoader,
     KeyboardManager,
     SearchUtils,
+    ServiceUtils,
+    StorageType,
     OverflowWatcher,
     OnOverflowCallBack,
     OverflowDirection,
     OverFlowWatcherParams,
     OVERFLOWED_CLASS_NAME,
-    DataUnitEventOptions
+    DataUnitEventOptions,
+    ServiceCanceledException,
+    SilentException,
+    DataUnitInMemoryLoader,
+    DataUnitLoaderUtils,
+    PaginationInfoBuilderParams,
+    ColumnFilterManager,
+    DataUnitInMemoryLoaderConfig,
+    RECORD_DATE_FORMAT
 };

package/src/repository/IRepository.ts

@@ -79,4 +79,11 @@ export interface IRepository<T>{
      * @returns Promessa de quantidade
      */
     count(): Promise<number>;
+    
+    /**
+     * Retorna todos os registros que estão em cache no momento
+     *
+     * @returns Todos registros que estão em cache no momento
+     */
+    getFromCache(): Array<T> | undefined
 }

package/src/repository/indexeddb/IDBRepository.ts

@@ -320,6 +320,10 @@ export class IDBRepository<T> implements IRepository<T>{
         const tx = db.transaction(this._addedStoreName);
         return tx.objectStore(this._addedStoreName).getAll();
     }
+
+    public getFromCache(): Array<T> | undefined{
+        return undefined;
+    }
 }
 
 /**