@sankhyalabs/core 0.0.0-bugfix-dev-KB-6165.0

package/src/dataunit/DataUnit.ts

@@ -0,0 +1,1835 @@
+import { convertType, DataType, toString } from "./metadata/DataType.js";
+import { ChildDescriptor, FieldDescriptor, Filter, FilterProvider, Sort, SortingProvider, UnitMetadata } from "./metadata/UnitMetadata.js";
+
+import { Action, DataUnitAction, ExecutionContext } from "./state/action/DataUnitAction.js";
+import StateManager from "./state/StateManager.js";
+
+import ErrorException from "../exceptions/ErrorException.js";
+import WaitingChangeException from "../exceptions/WaitingChangeException.js";
+import { StringUtils } from "../utils/StringUtils.js";
+import ObjectUtils from "../utils/ObjectUtils.js";
+import { LoadDataRequest } from "./loading/LoadDataRequest.js";
+import { LoadDataResponse } from "./loading/LoadDataResponse.js";
+import { PaginationInfo } from "./loading/PaginationInfo.js";
+import { AddedRecordsReducer, getAddedRecords, prepareAddedRecordId, prepareCopiedRecord } from "./state/slice/AddedRecordsSlice.js";
+import { ChangesReducer, getChangesToSave, isDirty, hasDirtyRecords } from "./state/slice/ChangesSlice.js";
+import {
+    SnapshotReducer,
+    getCurrentRecords,
+    getFieldValue,
+    getModifiedRecords,
+    getSelectionRecords,
+} from './state/slice/SnapshotSlice.js';
+import { getCurrentPage, getLastPage, getPaginationInfo, getCurrentRequest, LoadingControlReducer, hasMorePages, hasPreviousPages } from "./state/slice/LoadingControlSlice.js";
+import { getRecords, RecordsReducer } from "./state/slice/RecordsSlice.js";
+import { RemovedRecordsReducer } from "./state/slice/RemovedRecordsSlice.js";
+import { getSelection, getSelectionInfo, hasNext, hasPrevious, SelectionReducer } from "./state/slice/SelectionSlice.js";
+import { getField, getMetadata, UnitMetadataReducer } from "./state/slice/UnitMetadataSlice.js";
+import { getBlockingWaitingChanges, getWaitingChangePromisses, getWaitingChanges, isWaiting, WaitingChangesReducer } from "./state/slice/WaitingChangesSlice.js";
+import { canRedo, canUndo, HistReducer } from "./state/HistReducer.js";
+import { getFormattedValue } from "./formatting/PrettyFormatter.js";
+import { v4 as uuid } from "uuid";
+import { DataUnitStorage } from "./DataUnitStorage.js";
+import { getInvalidFieldMessage, InvalidFieldsReducer } from "./state/slice/InvalidFieldsSlice.js";
+
+const DEFAULT_DATAUNIT_NAME = "dataunit";
+
+/***
+ * `DataUnit`: Atua como uma camada de abstração entre o back-end e a interface do usuário.
+ */
+export default class DataUnit {
+    private _uuid: string;
+    private _name: string;
+    private _observers: Array<(action: DataUnitAction) => void>;
+    private _sortingProvider?: SortingProvider;
+    private _filterProviders: Map<string, FilterProvider>;
+    private _stateManager: StateManager;
+    private _interceptors: Array<DUActionInterceptor>;
+    private _pageSize: number;
+    private _childByName = new Map<string, DataUnit>();
+    private _parentDataUnit: DataUnit | undefined;
+    private _loadingLockers: Promise<void>[];
+    private _savingLockers: Promise<any>[] = [];
+    
+    public metadataLoader?: (dataUnit: DataUnit) => Promise<UnitMetadata>;
+    public dataLoader?: (dataUnit: DataUnit, request: LoadDataRequest) => Promise<LoadDataResponse>;
+    public saveLoader?: (dataUnit: DataUnit, changes: Array<Change>) => Promise<Array<SavedRecord>>;
+    public removeLoader?: (dataUnit: DataUnit, recordIds: Array<string>) => Promise<Array<string>>;
+    public recordLoader?: (dataUnit: DataUnit, recordIds: Array<string>) => Promise<Array<Record>>;
+
+    constructor(name: string = DEFAULT_DATAUNIT_NAME, parentDataUnit?: DataUnit) {
+        this._uuid = uuid()
+        this._name = `${name}?uuid=${this._uuid}`;
+        this._pageSize = 0;
+        this._stateManager = new StateManager(
+            [
+                HistReducer,
+                UnitMetadataReducer,
+                LoadingControlReducer,
+                RecordsReducer,
+                RemovedRecordsReducer,
+                AddedRecordsReducer,
+                SelectionReducer,
+                ChangesReducer,
+                WaitingChangesReducer,
+                InvalidFieldsReducer,
+                SnapshotReducer
+            ]
+        );
+        this._observers = [];
+        this._filterProviders = new Map<string, FilterProvider>();
+        this._sortingProvider = undefined;
+        this._interceptors = [];
+        this._parentDataUnit = parentDataUnit;
+        this._parentDataUnit?.subscribe(this.onDataUnitParentEvent);
+        this._loadingLockers = [];
+        DataUnitStorage.put(this);
+    }
+
+    /**
+     * Desfaz vinculos do DataUnit. Chamado quando o DU não é mais necessário.
+     */
+    public release(){
+        DataUnitStorage.remove(this._name);
+        if(this._parentDataUnit){
+            this._parentDataUnit.unsubscribe(this.onDataUnitParentEvent);
+            this._parentDataUnit.removeChildDataunit(this._name);
+        }
+    }
+
+    public get dataUnitId(): string{
+        return this._uuid;
+    }
+
+    /**
+     * 
+     * Obtém o nome de identificação do DataUnit (geralmente em formato de URI - Uniform Resource Identifier).
+     * 
+     * @returns - Nome de identificação do DataUnit.
+     * 
+    */
+    public get name(): string {
+        return this._name;
+    }
+
+    /**
+     * 
+     * Obtém o valor convertido de acordo com o tipo do campo.
+     * 
+     * @param fieldName - Identificador do campo.
+     * @param newValue - Novo valor que será atribuído ao campo pós validação.
+     * 
+     * @returns - Novo valor convertido em um tipo valido.
+     * 
+    */
+    private validateAndTypeValue(fieldName: string, newValue: any): any {
+        const descriptor: FieldDescriptor | undefined = this.getField(fieldName);
+        return descriptor ? convertType(descriptor.dataType, newValue) : newValue;
+    }
+
+    /**
+     * 
+     * Trata as Actions do DataUnit Parent
+     * 
+     * 
+    */
+    private onDataUnitParentEvent = (action: DataUnitAction) => {
+        switch(action.type){
+            case Action.SELECTION_CHANGED:
+            case Action.NEXT_SELECTED:
+            case Action.PREVIOUS_SELECTED:
+            case Action.DATA_LOADED:
+                this.clearDataUnit();
+                const selectedRecord = this._parentDataUnit?.getSelectedRecord();
+                if(selectedRecord != undefined && !this.isNewRecord(selectedRecord.__record__id__)){
+                    this.loadData();
+                }
+                break;
+        }
+    }
+
+    /**
+     * 
+     * Obtém chave única para identificação do FilterProvider.
+     * 
+     * @param provider - Interface FilterProvider na qual será retornada uma chave correspondente.
+     * 
+     * @returns - A chave do provider.
+     * 
+    */
+    private getFielterProviderKey(provider: FilterProvider): string {
+        if (provider.getKey) {
+            return provider.getKey();
+        }
+        return StringUtils.hashCode(provider.getFilter.toString());
+    }
+
+    /**
+     * 
+     * Executa o carregamento dos registros.
+     * 
+     * @param request - Dados da requisição para carregamento dos registros.
+     * @param executionCtx - Contexto de execução do carregamento dos registros do DataUnit.
+     * @param checkLastFilter - Habilita a verificação da última requisição, evitando carga desnecessária.
+     * 
+     * @returns - Registros do DataUnit.
+     * 
+    */
+    private executeLoadData(request: LoadDataRequest, executionCtx?: ExecutionContext, checkLastFilter?: boolean): Promise<LoadDataResponse> {
+
+        if(checkLastFilter && this.isSameRequest(request)){
+            const paginationInfo = getPaginationInfo(this._stateManager);
+            if(paginationInfo){
+                const response: LoadDataResponse = {
+                    records: getRecords(this._stateManager),
+                    paginationInfo 
+                };
+                return Promise.resolve(response);
+            }
+        }
+
+        return new Promise(async (resolve, fail) => {
+            if (await this.dispatchAction(Action.LOADING_DATA, request, executionCtx)) {
+                if (this.dataLoader) {
+                    this.dataLoader(this, request).then(
+                        response => {
+                            this.dispatchAction(Action.DATA_LOADED, {...response, keepSelection: request.keepSelection}, executionCtx);
+                            resolve(response);
+                        }
+                    ).catch(error => {
+                        const {errorCode} = error;
+                        fail(new ErrorException("Erro ao carregar registros", error, errorCode))
+                    });
+                }
+            }
+        });
+    }
+
+    private isSameRequest(request: LoadDataRequest): boolean{
+        const lastRequest = getCurrentRequest(this._stateManager);
+        return ObjectUtils.objectToString(request) === ObjectUtils.objectToString(lastRequest || {});
+    }
+
+    // Loaders
+    /**
+     * 
+     * Carrega os metadados do DataUnit.
+     * 
+     * @param executionCtx - Contexto de execução do carregamento dos metadados do DataUnit.
+     * 
+     * @returns - Metadados carregados.
+     * 
+    */
+    public async loadMetadata(executionCtx?: ExecutionContext): Promise<UnitMetadata | void> {
+        if (await this.dispatchAction(Action.LOADING_METADATA, undefined, executionCtx)) {
+            return new Promise((resolve, fail) => {
+                if (this.metadataLoader) {
+                    this.metadataLoader(this).then(
+                        metadata => {
+                            this.metadata = metadata
+                            resolve(this.metadata);
+                        }
+                    ).catch(error => {
+                        const {errorCode} = error;
+                        fail(new ErrorException("Erro ao carregar metadados", error, errorCode))
+                    });
+                }
+            });
+        }
+    }
+
+    /**
+     * 
+     * Carrega os registros do DataUnit.
+     * 
+     * @param quickFilter - Filtros a serem aplicados.
+     * @param executionCtx - Contexto de execução do carregamento dos registros.
+     * @param checkLastFilter - Habilita a verificação da última requisição, evitando carga desnecessária.
+     * 
+     * @returns - Registros requisitados.
+     * 
+    */
+    public async loadData(quickFilter?: QuickFilter, executionCtx?: ExecutionContext, checkLastFilter?: boolean): Promise<LoadDataResponse> {
+        
+        await this.processLoadingLockers();
+
+        if (this._parentDataUnit && !this._parentDataUnit.getSelectedRecord()) {
+                if(this.records){
+                    this.clearDataUnit();
+                }
+                return Promise.resolve({
+                    records: []
+                });
+        }
+
+        const loadDataRequest = this.getLoadDataRequest(quickFilter);
+        return this.executeLoadData(loadDataRequest, executionCtx, checkLastFilter);
+    }
+
+    /**
+     * 
+     * Alterna entre os registros por número de página.
+     * 
+     * @param page - Número da página desejada.
+     * @param executionCtx - Contexto de execução do carregamento dos registros do DataUnit.
+     * 
+     * @returns - Registros da página desejada.
+     * 
+    */
+    public async gotoPage(page: number, executionCtx?: ExecutionContext): Promise<LoadDataResponse | void> {
+
+        let request = getCurrentRequest(this._stateManager);
+
+        if (!request) {
+            request = {
+                filters: this.getFilters(),
+                sort: this.getSort()
+            }
+        }
+
+        if (page >= 0 && page <= getLastPage(this._stateManager, this._pageSize)) {
+            return this.executeLoadData({
+                ...request,
+                limit: this._pageSize,
+                offset: page * this._pageSize,
+                keepSelection: true
+            }, executionCtx);
+        }
+    }
+
+    /**
+     * 
+     * Vai para os registros da página seguinte.
+     * 
+     * @param executionCtx - Contexto de execução do carregamento dos registros do DataUnit.
+     * 
+     * @returns - Registros da página seguinte.
+     * 
+    */
+    public async nextPage(executionCtx?: ExecutionContext): Promise<LoadDataResponse | void> {
+        return this.gotoPage(getCurrentPage(this._stateManager) + 1, executionCtx);
+    }
+
+    /**
+     * 
+     * Vai para os registros da página anterior.
+     * 
+     * @param executionCtx - Contexto de execução do carregamento dos registros do DataUnit.
+     * 
+     * @returns - Registros da página anterior.
+     * 
+    */
+    public async previousPage(executionCtx?: ExecutionContext): Promise<LoadDataResponse | void> {
+        return this.gotoPage(getCurrentPage(this._stateManager) - 1, executionCtx);
+    }
+
+    private getLoadDataRequest(quickFilter?: QuickFilter): LoadDataRequest {
+        const request: LoadDataRequest = {
+            filters: quickFilter?.filter ? [quickFilter.filter] : this.getFilters(),
+            sort: this.getSort(),
+            parentRecordId: this.getParentRecordId()
+        };
+
+        if (quickFilter) {
+            request.quickFilter = quickFilter;
+        }
+
+        if (this._pageSize > 0) {
+            request.limit = this._pageSize
+            request.offset = 0;
+        }
+
+        return request;
+    }
+
+    private async notifySavingData(executionCtx?: ExecutionContext): Promise<boolean>{
+        const notifyPromises: Array<Promise<boolean>> = [];
+        Array.from(this._childByName.values()).forEach(
+            child => notifyPromises.push(child.notifySavingData(executionCtx))
+        );
+        
+        if(isDirty(this._stateManager)){
+            notifyPromises.push(this.dispatchAction(Action.SAVING_DATA, undefined, executionCtx));
+        }
+
+        return new Promise(accept => Promise.all(notifyPromises).then(responses => {
+            accept(responses.reduce((previous, current) => previous && current, true));
+        }));
+    }
+
+    private getBeforeSavePromisses(): Array<Promise<any>|undefined>{
+        let promises = getWaitingChangePromisses(this._stateManager)||[];
+        promises = promises.concat(this._savingLockers);
+        return promises;
+    }
+
+    /**
+     * 
+     * Salva o estado do registro do DataUnit.
+     * 
+     * @param executionCtx - Contexto de execução da persistencia do registro do DataUnit.
+     * 
+     * @returns - Resposta da solicitação.
+     * 
+    */
+    public async saveData(executionCtx?: ExecutionContext): Promise<void> {
+        const blockingWaitingChanges = getBlockingWaitingChanges(this._stateManager);
+
+        if (blockingWaitingChanges && blockingWaitingChanges.size > 0) {
+            const [_, waitingChange] = blockingWaitingChanges.entries().next().value;
+            return Promise.reject(new WaitingChangeException("Aguardando alteração de campo", (waitingChange as WaitingChange).waitmessage));
+        } else {
+            if (this.isDirty()) {
+
+                if (await this.notifySavingData(executionCtx)) {
+                    const promisses = this.getBeforeSavePromisses();
+                    return new Promise((resolve, fail) => {
+                        Promise.all(promisses || []).then(() => {
+                            this._savingLockers = [];
+                            if (this.saveLoader) {
+                                const changes: Array<Change> = this.getAllChangesToSave();
+
+                                this.saveLoader(this, changes).then((records) => {
+                                    const recordsByDataUnit = this.getRecordsByDataUnit(records);
+
+                                    const dispatchPromisses = [];
+                                    for (const [ownerDataUnitName, splittedRecords] of recordsByDataUnit) {
+                                        const ownerDataUnit = DataUnitStorage.get(ownerDataUnitName);
+                                        const changesByDataUnit = changes.filter(change => change.dataUnit === ownerDataUnitName);
+                                        
+                                        if(ownerDataUnit){
+                                            dispatchPromisses.push(ownerDataUnit.dispatchAction(Action.DATA_SAVED, { changes: changesByDataUnit, records: splittedRecords }, executionCtx));
+                                        }
+                                    }
+                                    Promise.all(dispatchPromisses).then(() => resolve());
+                                }).catch(cause => {
+                                    const {errorCode} = cause;
+                                    fail(new ErrorException("Erro ao salvar alterações", cause, errorCode));
+                                });
+                            } else {
+                                resolve();
+                            }
+                        });
+                    });
+                }
+            }
+        }
+
+        return Promise.resolve();
+    }
+
+    /**
+     * 
+     * Retorna as alterações a serem salvas no DataUnit atual.
+     * 
+     * 
+     * 
+     * @returns - Mudanças realizadas no DataUnit atual
+     * 
+    */
+    public buildChangesToSave(): Array<Change>{
+        return getChangesToSave(this._name, this._stateManager);
+    }
+
+    public buildChangesToSaveFromChild(allChanges: Array<Change>, dataUnit: DataUnit): void {
+        dataUnit._childByName?.forEach((dataUnitChild: DataUnit) => {
+            if (dataUnitChild.isDirty()) {
+              allChanges.push(...getChangesToSave(dataUnitChild.name, dataUnitChild._stateManager));
+              this.buildChangesToSaveFromChild(allChanges, dataUnitChild);
+            }
+          });
+    }
+
+    /**
+     * 
+     * Retorna todas as alterações do DataUnit a serem salvas, incluindo no nível Master e Detail.
+     * 
+     * 
+     * 
+     * @returns - Todas as mudanças realizadas no DataUnit, tanto Master quanto Detail;
+     * 
+    */
+    public getAllChangesToSave(): Array<Change> {
+        const allChanges: Array<Change> = [];
+        allChanges.push(...this.buildChangesToSave());
+        this.buildChangesToSaveFromChild(allChanges, this);
+        return allChanges;
+    }
+
+    /**
+     * 
+     * Remove o registro selecionado.
+     * 
+     * @param buffered - Se será utilizado buffer na solicitação.
+     * @param silent - Define se haverá mensagem de confirmação da remoção
+     * 
+     * @returns - ID's dos registros removidos.
+     * 
+    */
+    public async removeSelectedRecords(buffered: boolean = false, silent: boolean = false): Promise<Array<string>> {
+        const selection = this.getSelectionInfo();
+        if (selection) {
+            if(selection.isAllRecords()){
+                throw new Error("Exclusão remota não implementada.");
+            }
+            const records = selection?.records || [];
+            const recordIds = selection?.recordIds || [];
+            return this.removeRecords(recordIds, records, buffered, undefined, silent);
+        }
+        return Promise.resolve([]);
+    }
+
+    /**
+     * 
+     * Efetua requisição para remoção dos registros.
+     * 
+     * @param recordIds - Lista de IDs dos registros que serão removidos.
+     * @param cachedRecords - Dados dos registros que serão removidos.
+     * @param buffered - Se será utilizado buffer na solicitação.
+     * @param executionCtx - Contexto de execução da remoção do registro do DataUnit.
+     * @param silent - Define se haverá mensagem de confirmação da remoção
+     * 
+     * @returns - ID's dos registros removidos.
+     * 
+    */
+    public async removeRecords(recordIds: Array<string>, cachedRecords: Array<Record>, buffered: boolean = false, executionCtx?: ExecutionContext, silent: boolean = false): Promise<Array<string>> {
+        if (recordIds) {
+            if (buffered || !this.removeLoader) {
+                this.dispatchAction(Action.RECORDS_REMOVED, { records: recordIds, cachedRecords, buffered: true }, executionCtx);
+            } else {
+                if (await this.dispatchAction(Action.REMOVING_RECORDS, {silent}, executionCtx)) {
+
+                    return new Promise((resolve, fail) => {
+                        if (this.removeLoader) {
+                            this.removeLoader(this, recordIds).then(
+                                removedIds => {
+                                    let currentIndex = 0;
+                                    const removedIndex: Array<number> = [];
+                                    const currentRecords = getCurrentRecords(this._stateManager);
+
+                                    currentRecords.forEach((value, key) => {
+                                        if (removedIds.includes(key)) {
+                                            removedIndex.push(currentIndex);
+                                        }
+
+                                        currentIndex++
+                                    });
+
+                                    this.dispatchAction(Action.RECORDS_REMOVED, { records: removedIds, cachedRecords, removedIndex, buffered: false }, executionCtx);
+                                    resolve(removedIds);
+                                }
+                            ).catch(error => {
+                                const {errorCode} = error;
+                                fail(new ErrorException("Erro ao remover registros", error, errorCode))
+                            });
+                        }
+                    });
+                }
+            }
+        }
+        return Promise.resolve(recordIds);
+    }
+
+    // API
+    /**
+     * 
+     * Obtém o valor do campo em seu formato/tipo correto a partir de uma string.
+     * 
+     * @param fieldName - Nome do campo que terá o tipo identificado para conversão.
+     * @param value - Texto que será convertido de acordo com o tipo identificado no campo.
+     * 
+     * @returns - Valor convertido ou ele mesmo.
+     * 
+    */
+    public valueFromString(fieldName: string, value: string): any {
+        const descriptor = this.getField(fieldName);
+        return descriptor ? convertType(descriptor.dataType, value) : value;
+    }
+
+    /**
+     * 
+     * Converte o valor informado para texto de acordo com o tipo do campo informado.
+     * 
+     * @param fieldName - Nome do campo utilizado para buscar o tipo de dado com o padrão de conversão para string.
+     * @param value - Valor a ser convertido.
+     * 
+     * @returns - Valor informado convertido.
+     * 
+    */
+    public valueToString(fieldName: string, value: any): string {
+        const descriptor = this.getField(fieldName);
+        return toString(descriptor?.dataType, value);
+    }
+
+    /**
+     * 
+     * Formata o valor do campo considerando as informações do descriptor.
+     * Diferente do método "valueToString" que retorna o dado em valor textual,
+     * getFormattedValue retorna uma informação amigável ao usuário, geralmente
+     * usada na interface.
+     * 
+     * @param fieldName - Nome do campo utilizado do qual se quer obter valor.
+     * @param value (opcional) - O valor a ser convertido. Caso omitido pega do registro selecionado.
+     * 
+     * @returns - Valor formatado.
+     * 
+    */
+    public getFormattedValue(fieldName: string, value?: any): string {
+        
+        const descriptor = this.getField(fieldName);
+        if (value == undefined) {
+            value = this.getFieldValue(fieldName);
+        } else if (typeof value === "string" && descriptor?.dataType != DataType.TEXT){
+            value = this.valueFromString(fieldName, value);
+        }
+
+        if(value == undefined){
+            return "";
+        }
+
+        return getFormattedValue(value, descriptor);
+    }
+
+    /**
+     * 
+     * Adiciona um interceptor correspondente a uma ação do DataUnit para fazer um processamento customizado.
+     * 
+     * @param interceptor - Interceptor a ser adicionado.
+     * 
+    */
+    public addInterceptor(interceptor: DUActionInterceptor): void {
+        this._interceptors.push(interceptor);
+    }
+
+    /**
+     * 
+     * Remove um interceptor da lista de interceptors.
+     * 
+     * @param interceptor - Interceptor a ser removido.
+     * 
+    */
+    public removeInterceptor(interceptor: DUActionInterceptor) {
+        this._interceptors = this._interceptors.filter(i => i !== interceptor);
+    }
+
+    /**
+     * 
+     * Adiciona um FilterProvider.
+     * 
+     * @param provider - FilterProvider que será adicionado.
+     * 
+    */
+    public addFilterProvider(provider: FilterProvider): void {
+        this._filterProviders.set(this.getFielterProviderKey(provider), provider);
+    }
+
+    /**
+     * 
+     * Obtém informações de paginação dos registros.
+     * 
+     * @returns - Informações da paginação de registros. 
+    */
+    public getPaginationInfo(): PaginationInfo | void {
+        return getPaginationInfo(this._stateManager);
+    }
+
+    /**
+     * 
+     * Define a lógica de ordenação dos registros.
+     * 
+     * @param provider - Objeto usado para definir a propriedade sortingProvider da instância da classe.
+     * 
+     */
+    public set sortingProvider(provider: SortingProvider) {
+        this._sortingProvider = provider;
+    }
+
+    /**
+     * 
+     * Define a propriedade metadata da instância da classe com um novo valor e chama o método dispatchAction para notificar os observers da aplicação sobre a mudança.
+     * 
+     */
+    public set metadata(md: UnitMetadata) {
+        this.dispatchAction(Action.METADATA_LOADED, md, undefined);
+    }
+
+    /**
+     * 
+     * Obtém os metadados do DataUnit.
+     * 
+     */
+    public get metadata(): UnitMetadata {
+        return getMetadata(this._stateManager);
+    }
+
+     /**
+     * 
+     * Obtém informações da ligação para um DataUnit filho.
+     * 
+     * @param name - Nome do DataUnit que se deseja.
+     * 
+     * @returns - As informações sobre a ligação solicitada. Pode retornar undefined.
+     * 
+     */
+    public getChildInfo(name: string): ChildDescriptor|undefined {
+        const children = this.metadata?.children;
+        if(children == undefined){
+            return;
+        }
+
+        return children.find(child => child.name === name);
+    }
+
+    /**
+     * 
+     * Define a propriedade records da instância da classe com um novo valor e chama o método dispatchAction para notificar os observers da aplicação sobre a mudança.
+     * 
+     */
+    public set records(records: Array<Record>) {
+        this.dispatchAction(Action.DATA_LOADED, { records }, undefined);
+    }
+
+    /**
+     * 
+     * Obtém todos os registros atuais.
+     * 
+     * @returns - Todos os registros atuais.
+     * 
+     */
+    public get records(): Array<Record> {
+        const records = getCurrentRecords(this._stateManager);
+        return records ? Array.from(records.values()) : [];
+    }
+
+    /**
+     * 
+     * Define a quantidade de registros que será exibido por página.
+     * 
+     * @param size - Quantidade de registros que será exibido por página.
+     * 
+     */
+    public set pageSize(size: number) {
+        this._pageSize = size;
+    }
+
+    /**
+     * 
+     * Obtém a quantidade de registros que está sendo exibido por página.
+     * 
+     * @returns - Quantidade de registros exibidos por página.
+     * 
+     */
+    public get pageSize(): number {
+        return this._pageSize;
+    }
+
+    /**
+     * 
+     * Obtém os registros modificados e ainda não salvos no DataUnit.
+     * 
+     * @returns - Lista dos registros em edição.
+     * 
+     */
+    public getModifiedRecords(): Array<Record> {
+        const modified = getModifiedRecords(this._stateManager);
+        return modified || [];
+    }
+
+    /**
+     * 
+     * Obtém os registros adicionados no DataUnit.
+     * 
+     * @returns - Lista dos registros adicionados.
+     * 
+     */
+    public getAddedRecords(): Array<Record> {
+        return getAddedRecords(this._stateManager);
+    }
+
+    /**
+     * 
+     * Obtém metadados de um campo específico.
+     * 
+     * @param fieldName - Identificador do campo.
+     * 
+     * @returns - Metadados do campo informado.
+     */
+    public getField(fieldName: string): FieldDescriptor | undefined {
+        return getField(this._stateManager, fieldName);
+    }
+
+    /**
+     * 
+     * Adiciona um novo registro.
+     * 
+     * @param executionCtx - Contexto de execução da inserção do dado no DataUnit.
+     * 
+    */
+    public async addRecord(executionCtx?: ExecutionContext): Promise<boolean> {
+        return this.dispatchAction(Action.RECORDS_ADDED, prepareAddedRecordId(this._stateManager, [{}], this.getParentRecordId()), executionCtx);
+    }
+
+    /**
+     * 
+     * Efetua a cópia do registro selecionado.
+     * 
+     * @param executionCtx - Contexto de execução da cópia do dado do DataUnit.
+     * 
+    */
+    public copySelected(executionCtx?: ExecutionContext): void {
+        const selectionInfo = this.getSelectionInfo();
+        if (selectionInfo) {
+            const selectedRecords = selectionInfo.records;
+            if(selectedRecords){
+                this.dispatchAction(Action.RECORDS_COPIED, prepareCopiedRecord(this._stateManager, selectedRecords, this.getParentRecordId()), executionCtx);
+            }
+        }
+    }
+    
+    private getRecordsByDataUnit(records: Array<Record>): Map<string, Array<Record>> {
+        const recordsMap = new Map<string, Array<Record>>();
+        
+        records.forEach(record => {
+            let { __owner__dataunit__name__: ownerDataUnitName } = record;
+            
+            if(!ownerDataUnitName){
+                ownerDataUnitName = this.name;
+            }
+            let changes = recordsMap.get(ownerDataUnitName);
+            
+            if(!changes){
+                changes = [];
+                recordsMap.set(ownerDataUnitName, changes);
+            }
+
+            changes.push(record);
+        });
+        
+        return recordsMap;
+    }
+
+    private getParentRecordId(){
+        const parentRecord = this._parentDataUnit?.getSelectedRecord();
+        return parentRecord?.__record__id__;
+    }
+
+    /**
+     * 
+     * Retorna se a alteração no campo já foi concluída ou se ainda está incompleta.
+     * 
+     * @param fieldName - Identificador do campo a ser verificado.
+     * 
+     * @returns - Verdadeiro se ainda está pendente.
+     * 
+    */
+    public waitingForChange(fieldName: string): boolean {
+        return isWaiting(this._stateManager, fieldName);
+    }
+
+    /**
+     * 
+     * Obtém valor do campo desejado.
+     * 
+     * @param fieldName - Identificador do campo a ser buscado.
+     * 
+     * @returns - Valor do campo.
+     * 
+    */
+    public getFieldValue(fieldName: string): any {
+        return getFieldValue(this._stateManager, fieldName);
+    }
+
+    /**
+     * 
+     *  Insere valor no campo desejado.
+     * 
+     * @param fieldName -Identificador do campo a ser modificado.
+     * @param newValue - Valor a ser inserido no campo.
+     * @param records - Indica quais registros foram afetados pela alteração no valor do campo.
+     * @returns - Promise que será resolvida quando o novo valor for persistido no state.
+     * 
+    */
+    public async setFieldValue(fieldName: string, newValue: any, records?: Array<string>): Promise<boolean> {
+
+        if(!this.hasNewRecord() && !this.getSelectedRecord())  await this.addRecord();
+        
+        const typedValue = this.validateAndTypeValue(fieldName, newValue);
+        const currentValue = this.getFieldValue(fieldName);
+        
+        if(newValue instanceof Promise){
+            const promise:Promise<boolean> = new Promise(accept => {
+                newValue.then(resolvedValue => {
+                    this.dispatchAction(Action.DATA_RESOLVED, { [fieldName]: resolvedValue, records }, undefined);
+                    accept(this.setFieldValue(fieldName, resolvedValue, records));
+                });
+            });
+            this._savingLockers.push(promise);
+            return promise;
+        }
+
+        if (currentValue !== typedValue) {
+            const promise = this.dispatchAction(Action.DATA_CHANGED, { [fieldName]: typedValue, records }, undefined);
+            this._savingLockers.push(promise);
+            return promise;
+        }
+
+        return Promise.resolve(false);
+    }
+
+    /**
+     * 
+     *  Marca campos como inválidos.
+     * 
+     * @param fieldName - Nome do campo inválido.
+     * @param message - Mensagem descrevendo o motivo da invalidade.
+     * @param recordId - Indica qual registro está com o campo inválido.
+     * 
+    */
+    public setInvalidField(fieldName: string, message: string, recordId: string): void {
+        this.dispatchAction(Action.FIELD_INVALIDATED, { fieldName, message, recordId }, undefined);
+    }
+
+    /**
+     * 
+     *  Limpa campos inválidos.
+     * 
+     * @param recordId - Indica em qual registro o campo não está mais inválido.
+     * @param fieldName - Nome do campo. Caso omitido, todos os campos serão limpos.
+     * 
+    */
+    public clearInvalid(recordId: string, fieldName?: string): void {
+        this.dispatchAction(Action.INVALIDATE_CLEAN, { fieldName, recordId }, undefined);
+    }
+
+    /**
+     * 
+     *  Obtém a mensagem de campo inválido para determinado registro.
+     * 
+     * @param recordId - Identificador do registro.
+     * @param fieldName - Nome do campo.
+     * 
+    */
+    public getInvalidMessage(recordId: string, fieldName: string): string|undefined {
+        return getInvalidFieldMessage(this._stateManager, fieldName, recordId);
+    }
+
+    /**
+     * 
+     *  Inicia alteração no campo.
+     * 
+     * @param fieldName - Identificador do campo a ser modificado.
+     * @param waitingChange - Informa que uma mudança irá iniciar.
+     * 
+    */
+    public startChange(fieldName: string, waitingChange: WaitingChange): void {
+        this.dispatchAction(Action.CHANGING_DATA, { [fieldName]: waitingChange }, undefined);
+    }
+
+    /**
+     * 
+     *  Cancela o início de uma alteração no campo.
+     * 
+     * @param fieldName - Identificador do campo.
+     * 
+    */
+    public cancelWaitingChange(fieldName: string): void {
+        this.dispatchAction(Action.WAITING_CHANGE_CANCELED, { fieldName }, undefined);
+    }
+
+    /**
+     * Retorna se existe alterações pendentes.
+     * @returns Verdadeiro se existir pendências de modificações.
+    */
+    public hasWaitingChanges(): boolean {
+        const waitingChanges = getWaitingChanges(this._stateManager);
+        return waitingChanges ? !!waitingChanges.size : false;
+        
+    }
+
+    /**
+     * 
+     * Seleciona o primeiro registro.
+     * 
+     * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
+     * 
+    */
+    public selectFirst(executionCtx?: ExecutionContext): void {
+        if (this.records.length > 0) {
+            this.setSelectionByIndex([0], executionCtx);
+        }
+    }
+
+    /**
+     * 
+     * Seleciona o último registro.
+     * 
+     * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
+     * 
+    */
+    public selectLast(executionCtx?: ExecutionContext): void {
+        if (this.records.length > 0) {
+            this.setSelectionByIndex([this.records.length - 1], executionCtx);
+        }
+    }
+
+    /**
+     * 
+     * Seleciona múltiplos registros por índice.
+     * 
+     * @param selection - Índices desejados para a seleção.
+     * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
+     * 
+    */
+    public setSelectionByIndex(selection: Array<number>, executionCtx?: ExecutionContext): void {
+        this.dispatchAction(Action.SELECTION_CHANGED, { type: "index", selection }, executionCtx);
+    }
+
+    /**
+     * 
+     * Seleciona múltiplos registros por ID ou todos os registros (multipágina) .
+     * 
+     * @param selection - IDs para selecionar ou o modo de seleção completo.
+     * @param executionCtx - Contexto de execução da seleção dos registros do DataUnit.
+     * 
+     * 
+    */
+    public setSelection(selection: Array<string> | SelectionMode.ALL_RECORDS, executionCtx?: ExecutionContext): Promise<SelectionInfo> {
+        return new Promise(resolve => {
+            this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection }, executionCtx)
+                .then(()=>resolve(getSelectionInfo(this._stateManager)));
+        });
+    }
+
+    /**
+     * 
+     * Limpa a seleção.
+     * 
+     * @param executionCtx - Contexto de execução da seleção dos registros do DataUnit.
+     * 
+    */
+    public clearSelection(executionCtx?: ExecutionContext){
+        this.setSelection([], executionCtx);
+    }
+
+    /**
+     * 
+     * Atualiza a seleção dos registros atuais.
+     * 
+     * @param selection - IDs dos registros selecionados no snapshot atual
+     * @param executionCtx - Contexto de execução da seleção dos registros do DataUnit.
+     * 
+     * @returns - Informações sobre a seleção.
+    */
+    public updatePageSelection(selection: Array<string>, executionCtx?: ExecutionContext): Promise<SelectionInfo|undefined>{
+
+        if(!selection){
+            return Promise.resolve(this.getSelectionInfo());
+        }
+
+        return new Promise(resolve => {
+            const newSelection: Set<string> = new Set(getSelection(this._stateManager));
+            const currentRecords = getCurrentRecords(this._stateManager) || new Map();
+            Array.from(currentRecords.keys()).forEach(
+                recordId => {
+                    if(selection.includes(recordId)){
+                        newSelection.add(recordId);
+                    } else {
+                        newSelection.delete(recordId);
+                    }
+                }
+            );
+
+            this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection: Array.from(newSelection) }, executionCtx)
+                .then(()=>{
+                    resolve(this.getSelectionInfo())
+                });
+        });
+    }
+
+    /**
+     * 
+     * Obtém informações sobre a seleção atual.
+     * 
+     * @returns - Objeto com informações como registros selecionados e seleção por critério.
+     * 
+     **/ 
+    public getSelectionInfo(): SelectionInfo | undefined {
+        return getSelectionInfo(this._stateManager)
+    }
+
+    /**
+     * 
+     * Retorna apenas um registro selecionado no Dataunit
+     * 
+     * @returns - Registro selecionado.
+     * 
+    */
+    public getSelectedRecord(): Record | undefined {
+        const selection = getSelectionRecords(this._stateManager);
+        if (!selection || selection.length == 0) return;
+        return selection[0];
+    }
+
+    /**
+     * 
+     * Limpa todos os registros do DataUnit
+     *
+     * 
+    */
+    public clearDataUnit(): void {
+        this.records = [];
+    }
+
+    /**
+     * 
+     * Seleciona o próximo registro.
+     * 
+     * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
+     * 
+     * 
+    */
+    public nextRecord(executionCtx?: ExecutionContext): void {
+        if(!hasNext(this._stateManager)){
+            if(hasMorePages(this._stateManager)){
+                this.nextPage({
+                    before: act =>{
+                        if(executionCtx && executionCtx.before){
+                            act = executionCtx.before(act);
+                        }
+                        return act;
+                    },
+                    after: act => {
+                        this.selectFirst(executionCtx);
+                    }
+                });
+            }
+        } else {
+            this.dispatchAction(Action.NEXT_SELECTED, undefined, executionCtx);
+        }
+    }
+
+    /**
+     * 
+     * Seleciona o registro anterior.
+     * 
+     * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
+     * 
+    */
+    public previousRecord(executionCtx?: ExecutionContext): void {
+        if(!hasPrevious(this._stateManager)){
+            if(hasPreviousPages(this._stateManager)){
+                this.previousPage({
+                    before: act =>{
+                        if(executionCtx && executionCtx.before){
+                            act = executionCtx.before(act);
+                        }
+                        return act;
+                    },
+                    after: act => {
+                        this.selectLast(executionCtx);
+                    }
+                });
+            }
+        } else {
+            this.dispatchAction(Action.PREVIOUS_SELECTED, undefined, executionCtx);
+        }
+    }
+
+    /**
+     * 
+     * Cancela edição do registro atual.
+     * 
+     * @param executionCtx - Contexto de execução do cancelamento da seleção dos registros.
+     * @param silent: Define se haverá mensagem de confirmação do cancelamento
+     * 
+    */
+    public async cancelEdition(executionCtx?: ExecutionContext, fromParent?: boolean, silent: boolean = false): Promise<boolean> {
+            const cancelledAction = await this.dispatchAction(Action.EDITION_CANCELED, {fromParent, silent}, executionCtx);
+            for (const [, dataUnit] of this._childByName) {
+                if(dataUnit.isDirty()){
+                    dataUnit.cancelEdition(undefined, true, silent);
+                }
+            }
+            return Promise.resolve(cancelledAction);
+        
+    }
+
+    /**
+     * 
+     * Retorna se existe algum tipo de alteração pendente.
+     * 
+     * @returns Verdadeiro se existir alterações pendentes.
+     * 
+    */ 
+    public isDirty(): boolean {
+        return isDirty(this._stateManager) || this.childrenIsDirty();
+    }
+
+    /**
+     * 
+     * Retorna se existe algum DataUnit detail com alterações pendentes.
+     * 
+     * @returns Verdadeiro se existir alterações pendentes em algum DataUnit detail.
+     * 
+    */ 
+    private childrenIsDirty():boolean {
+        for (let [key, dataUnitChild] of this._childByName) {
+            if(dataUnitChild.isDirty()) return true;
+        }
+        return false;
+    }
+
+    /**
+     * 
+     * Retorna se existe algum registro em modo de edição.
+     * 
+     * @returns Verdadeiro se existir alterações de registros pendentes.
+     * 
+    */
+    public hasDirtyRecords(): boolean {
+        return hasDirtyRecords(this._stateManager);
+    }
+
+    /**
+     * 
+     * Retorna se existir uma pagina seguinte a atual na paginação.
+     * 
+     * @returns Verdadeiro se existir uma próxima página.
+     * 
+    */
+    public hasNext(): boolean {
+        let result = hasNext(this._stateManager);
+        if(!result){
+            result = hasMorePages(this._stateManager);
+        }
+        return result;
+    }
+
+    /**
+     * 
+     * Retorna se existe uma página anterior a atual na paginação.
+     * 
+     * @returns Verdadeiro se existir uma página anterior.
+     * 
+    */
+    public hasPrevious(): boolean {
+        let result = hasPrevious(this._stateManager);
+        if(!result){
+            result = hasPreviousPages(this._stateManager);
+        }
+        return result;
+    }
+
+    /**
+     *
+     * Verifica se um registro é proveniente de inclusão.
+     *
+     * @param recordId - O id do registro a ser verificado.
+     * @returns Verdadeiro se o id solicitado é de um registro novo.
+     *
+    */
+    public isNewRecord(recordId: string): boolean {
+        const newRecords = getAddedRecords(this._stateManager);
+        if(newRecords && newRecords.length > 0){
+            const record = newRecords.find(newRecord => newRecord.__record__id__ === recordId);
+            return record != undefined;
+        }
+        return false;
+    }
+
+    /**
+     * 
+     * Retorna se existe pelo menos um registro novo.
+     * 
+     * @returns Verdadeiro se algum registro foi adicionado.
+     * 
+    */
+    public hasNewRecord(): boolean {
+        const newRecords = getAddedRecords(this._stateManager);
+        return newRecords && newRecords.length > 0;
+    }
+
+    /**
+     * 
+     * Retorna se existe pelo menos um registro novo.
+     * 
+     * @returns Verdadeiro se algum registro foi adicionado.
+     * 
+    */
+    public hasCopiedRecord(): boolean {
+        const newRecords = getAddedRecords(this._stateManager);
+        if(newRecords == undefined){
+            return false;
+        }
+        for(let record of newRecords){
+            if (record['__record__source__id__'] != undefined) {
+                return true
+            }
+        }
+        return false;
+    }
+
+    /**
+     * 
+     * Retorna se a informação do estado anterior está salva, permitindo desfazer a ação.
+     * 
+     * @returns Verdadeiro se for possível desfazer a ação.
+     * 
+    */
+    public canUndo(): boolean {
+        return canUndo(this._stateManager);
+    }
+
+    /**
+     * 
+     * Retorna se a informação do estado futuro está salva, permitindo refazer a ação.
+     * 
+     * @returns Verdadeiro se for possível refazer a ação.
+     * 
+    */
+    public canRedo(): boolean {
+        return canRedo(this._stateManager);
+    }
+
+    /**
+     * 
+     * Desfaz a última ação.
+     * 
+     * @param executionCtx - Contexto de execução de desfazer a última ação.
+     * 
+     * 
+    */
+    public undo(executionCtx?: ExecutionContext) {
+        this.dispatchAction(Action.CHANGE_UNDONE, undefined, executionCtx);
+    }
+
+    /**
+     * 
+     * Refaz a última ação.
+     * 
+     * @param executionCtx - Contexto de execução de refazer a última ação.
+     * 
+    */
+    public redo(executionCtx?: ExecutionContext) {
+        this.dispatchAction(Action.CHANGE_REDONE, undefined, executionCtx);
+    }
+
+    /**
+     * 
+     * Obtém a representação textual do DataUnit, nesse caso, o nome do DataUnit.
+     * 
+     * @returns - Valor contido na propriedade name. 
+     * 
+    */
+    public toString() {
+        return this.name;
+    }
+
+    // Actions / State manager
+    /**
+     *  
+     * Lança ação do DataUnit para que sejam processadas.
+     * 
+     * @param actionType - Tipo de ação que será executada.
+     * @param payload - Dados que serão processados na ação.
+     * @param executionCtx - Contexto de execução de lançar a ação que será executada.
+     * 
+     * @returns - Verdadeiro se ação iniciada.
+     * 
+    */
+    private async dispatchAction(actionType: Action, payload?: any, executionCtx?: ExecutionContext): Promise<boolean> {
+        return new Promise(async resolve => {
+            let action = new DataUnitAction(actionType, payload);
+            if (executionCtx && executionCtx.before) {
+                action = executionCtx.before(action);
+            }
+            if (action && this._interceptors && this._interceptors.length > 0) {
+                action = await this.intercept(action, this._interceptors.values());
+            }
+            if (action) {
+                this.doDispatchAction(action);
+                if (executionCtx && executionCtx.after) {
+                    executionCtx.after(action)
+                }
+                resolve(true);
+            } else {
+                resolve(false);
+            }
+        });
+    }
+
+    /**
+     *  
+     * Notifica os interceptors de que uma ação foi executada, para que cada interceptor possa fazer sua respectiva tratativa dos dados.
+     * 
+     * @param action - Ação que foi executada.
+     * @param interceptors - Interceptors que serão notificados.
+     * 
+     * @returns - Ação executada no DataUnit.
+     * 
+    */
+    private async intercept(action: DataUnitAction, interceptors: IterableIterator<DUActionInterceptor>): Promise<DataUnitAction> {
+        return new Promise(async resolve => {
+            let ite;
+            while (action && !(ite = interceptors.next()).done) {
+                action = await ite.value.interceptAction(action);
+            }
+            resolve(action);
+        });
+    }
+
+    /**
+     *  
+     * Processa as ações no DataUnit e notifica os observers.
+     * 
+     * @param action - Ações em execução no DataUnit.
+     * 
+    */
+    private doDispatchAction(action: DataUnitAction): void {
+        this._stateManager.process(action);
+        this?._parentDataUnit?.dispatchAction(Action.CHILD_CHANGED, { srcAction: action, srcDataUnit: this });
+        this._observers.forEach(f => {
+            /* 
+            if some observer throws exceptions,
+            should be continued
+            */
+            try {
+                f(action);
+            } catch (e) {
+                console.warn("[DataUnit] error while call observer", e);
+            }
+        });
+    }
+
+    /**
+     *  
+     * Cria um dataunit filho.
+     * 
+     * @param name - Nome do dataunit filho.
+     * 
+    */
+    public getChildDataunit(name:string){
+        const detail: DataUnit = new DataUnit(name, this);
+        this._childByName.set(name, detail);
+        return detail;
+    }
+
+    /**
+     *  
+     * Remove um dataunit filho.
+     * 
+     * @param name - Nome do dataunit filho.
+     * 
+    */
+    public removeChildDataunit(name:string){
+        this._childByName.delete(name);
+    }
+    
+    /**
+     *  
+     * Adiciona um novo observer no DataUnit.
+     * Ela vai ser chamada sempre que uma ação for despachada (dispatchAction()).
+     * 
+     * @param observer - Função que recebe como parâmetro as ações que serão monitoradas.
+     * 
+    */
+    public subscribe(observer: (action: DataUnitAction) => void) {
+        this._observers.push(observer);
+    }
+
+    /**
+     *  
+     * Remove um observer existente.
+     * 
+     * @param observer - Observer que se deseja remover.
+     * 
+    */
+    public unsubscribe(observer: Function) {
+        this._observers = this._observers.filter(f => f !== observer);
+    }
+
+    /**
+     * 
+     * Recarrega registro selecionado com dados atualizados do servidor.
+     * 
+     * @returns - Dados atualizados do registro selecionado.
+     *      
+    */
+    public reloadCurrentRecord(): Promise<Array<Record>>{        
+        return new Promise(async (resolve, fail) => {
+            const selection = getSelection(this._stateManager);
+            this.dispatchAction(Action.LOADING_RECORD, selection);
+            
+            if(!this.dataLoader) return;
+            if(!this.recordLoader) return;
+            
+            this.recordLoader(this, selection).then(response => {
+                this.dispatchAction(Action.RECORD_LOADED, response)
+            }).catch(cause => {
+                const {errorCode} = cause;
+                fail(new ErrorException("Erro ao recarregar registro", cause, errorCode));
+            });
+        });
+    }
+
+    /**
+     * 
+     * Obtém a estrutura de ordenação das colunas dos dados.
+     * 
+     * @returns - Lista dos ordenáveis por prioridade.
+     * 
+    */
+    public getSort(): Array<Sort> | undefined {
+        return this._sortingProvider ? this._sortingProvider.getSort(this._name) : undefined;
+    }
+
+    /**
+     * 
+     * Obtém todos os filtros de dados.
+     * 
+     * @returns - Lista de filtros.
+     * 
+    */
+    public getFilters(): Array<Filter> | undefined {        
+        let filters: Array<Filter> | undefined = undefined;
+        this._filterProviders.forEach(p => {
+            const f = p.getFilter(this.name);
+            if (f) {
+                filters = (filters || []).concat(f);
+            }
+        });
+        return filters;
+    }
+
+    /**
+     * 
+     * Obtém as informações da última carga de dados.
+     * 
+     * @returns - As informações de filtro e paginação.
+     * 
+    */    
+    public getLastLoadRequest(): LoadDataRequest | undefined {
+        return getCurrentRequest(this._stateManager);
+    }
+    
+    /**
+     * 
+     * Obtém os filtros aplicados.
+     * 
+     * @returns - Lista de filtros.
+     * 
+    */    
+    public getAppliedFilters(): Array<Filter> | undefined {
+        const { filters }: LoadDataRequest = getCurrentRequest(this._stateManager) || {};
+        return filters
+    }
+
+    /**
+     * 
+     * Habilita um campo do DataUnit
+     * @param fieldName - nome do campo para ser habilitado.
+     * 
+    */
+    public enableField(fieldName:string) {
+        const fieldDescriptor = this.getField(fieldName);
+
+        if(fieldDescriptor?.readOnly === true){
+            fieldDescriptor.readOnly = false;
+            this.metadata = {...this.metadata};
+        }
+    }
+
+    /**
+     * 
+     * Desabilita um campo do DataUnit
+     * @param fieldName - nome do campo para ficar desabilitado.
+     * 
+    */
+    public disableField(fieldName:string) {
+        const fieldDescriptor = this.getField(fieldName);
+
+        if(fieldDescriptor?.readOnly === false){
+            fieldDescriptor.readOnly = true;
+            this.metadata = {...this.metadata};
+        }
+    }
+
+    /**
+     * 
+     * Deixa um campo do DataUnit invisível 
+     * @param fieldName - nome do campo para ficar invisível.
+     * 
+    */
+    public hideField(fieldName:string) {
+        const fieldDescriptor = this.getField(fieldName);
+
+        if(fieldDescriptor?.visible === true){
+            fieldDescriptor.visible = false;
+            this.metadata = {...this.metadata};
+        }
+    }
+
+    /**
+     * 
+     * Deixa um campo do DataUnit visível 
+     * @param fieldName - nome do campo para ficar visível.
+     * 
+    */
+    public showField(fieldName:string) {
+        const fieldDescriptor = this.getField(fieldName);
+
+        if(fieldDescriptor?.visible === false){
+            fieldDescriptor.visible = true;
+            this.metadata = {...this.metadata};
+        }
+    }
+       
+    /**
+     * 
+     * Obtém todos os registros selecionados.
+     * 
+     * @returns - Lista de registros selecionados.
+     * 
+     * @deprecated - Utilize o método `getSelectionInfo()` para obter os registros selecionados.
+     * Devido a seleção virtual baseada em critérios e ordenação (ALL_RECORDS), esse
+     * método foi descontinuado e pode retornar erros no caso da seleção virtual.
+     * 
+    */
+    public getSelectedRecords(): Array<Record> | undefined {
+        console.warn("DataUnit: O método `getSelectedRecords` foi descontinuado. Use o método `getSelectionInfo`.");
+        const selection = this.getSelectionInfo();
+
+        if(selection != undefined && selection.isAllRecords()){
+            throw new Error("Erro interno: Impossível retornar os registros selecionados. A seleção atual é virtual. Use o método `getSelectionInfo`.");
+        }
+
+        if (selection) {
+            return selection.records;
+        }
+    }
+
+    /**
+     * 
+     * Obtém ids dos registros selecionados.
+     * 
+     * @returns - Lista com id de todos os registros selecionados.
+     * 
+     * @deprecated - Utilize o método `getSelectionInfo()` para obter os registros selecionados.
+     * Devido a seleção virtual baseada em critérios e ordenação (ALL_RECORDS), esse
+     * método foi descontinuado e pode retornar erros no caso da seleção virtual.
+     * 
+    */
+    public getSelection(): Array<string> {
+        console.warn("DataUnit: O método `getSelection` foi descontinuado. Use o método `getSelectionInfo`.");
+        const selection = this.getSelectionInfo();
+
+        if(selection != undefined && selection.isAllRecords()){
+            throw new Error("Erro interno: Impossível retornar os registros selecionados. A seleção atual é virtual. Use o método `getSelectionInfo`.");
+        }
+
+        return selection?.recordIds || [];
+    }
+
+    /**
+     * Adiciona um locker para impedir o carregamento dos registros do dataUnit.
+     * @returns Retorna uma função responsável por liberar o lock adicionado.
+     */
+    public addLoadingLocker(): Function {
+        let loadingLockerResolver;
+
+        this._loadingLockers.push(new Promise((resolve) => {
+            loadingLockerResolver = resolve;
+        }));
+        
+        return loadingLockerResolver || Promise.resolve;
+    }
+
+    private async processLoadingLockers(){
+        if(this._loadingLockers.length) {
+            await Promise.all(this._loadingLockers);
+            this._loadingLockers = [];
+        }
+    }
+
+}
+
+export interface DUActionInterceptor {
+    interceptAction(action: DataUnitAction): DataUnitAction | Promise<DataUnitAction>;
+}
+
+export interface Record {
+    __record__id__: string;
+    __record__label__?: string;
+    __parent__record__id__?: string;
+    __owner__dataunit__name__?: string;
+    [key: string]: any;
+}
+
+export interface SavedRecord extends Record {
+    __old__id__?: string;
+}
+
+export enum ChangeOperation {
+    INSERT = "INSERT",
+    COPY = "COPY",
+    UPDATE = "UPDATE",
+    DELETE = "DELETE",
+}
+
+/***
+ * `Change`: Dados que representam uma alteração.
+ */
+export class Change {
+
+    public dataUnit: string;
+    public record: Record;
+    public sourceId: string | undefined;
+    public updatingFields: any;
+
+    private _operation: ChangeOperation;
+
+    constructor(dataUnit: string, record: Record, updates: any, operation: ChangeOperation, sourceId?: string) {
+        this.dataUnit = dataUnit;
+        this.record = record;
+        this.sourceId = sourceId;
+        this.updatingFields = updates;
+        this._operation = operation;
+    }
+
+    /**
+     * 
+     * Obtém o tipo de operação que está sendo realizada.
+     * 
+     * @returns - Ação que está sendo executada.
+     * 
+     */
+    public get operation(): string {
+        return this._operation.toString();
+    }
+
+    /**
+     * 
+     * Retorna se o DataUnit está em uma operação de inserção.
+     * 
+     * @returns - Verdadeiro se a operação for de inserção.
+     * 
+     */
+    public isInsert(): boolean {
+        return this._operation === ChangeOperation.INSERT;
+    }
+
+    /**
+     * 
+     * Retorna se o DataUnit está em uma operação de cópia.
+     * 
+     * @returns - Verdadeiro se a operação for de cópia.
+     * 
+     */
+    public isCopy(): boolean {
+        return this._operation === ChangeOperation.COPY;
+    }
+
+    /**
+     * 
+     * Retorna se o DataUnit está em uma operação de deleção.
+     * 
+     * @returns - Verdadeiro se a operação for de deleção.
+     * 
+     */
+    public isDelete(): boolean {
+        return this._operation === ChangeOperation.DELETE;
+    }
+
+    /**
+     * 
+     * Retorna se o DataUnit está em uma operação de atualização.
+     * 
+     * @returns - Verdadeiro se a operação for de atualização.
+     * 
+     */
+    public isUpdate(): boolean {
+        return this._operation === ChangeOperation.UPDATE;
+    }
+    
+
+}
+
+export interface WaitingChange {
+    waitmessage: string;
+    blocking: boolean;
+    promise?: Promise<any>;
+}
+
+export interface PageRequest {
+    limit: number;
+    offset: number;
+    quickFilter?: QuickFilter;
+}
+
+export interface QuickFilter {
+    term: string;
+    fields?: Array<string>;
+    filter?: Filter;
+}
+
+export interface PageResponse {
+    limit: number;
+    offset: number;
+    total: number;
+    hasMore: boolean;
+    records: Array<Record>;
+}
+
+export enum SelectionMode{
+    ALL_RECORDS = "ALL_RECORDS",
+    SOME_RECORDS = "SOME_RECORDS"
+}
+
+export class SelectionInfo{
+
+    private _records: Array<Record>;
+    public mode: SelectionMode;
+    private _total?: number;
+    public filters?: Array<Filter>;
+    public sort?: Array<Sort>;
+
+    constructor(records: Array<Record>, mode: SelectionMode = SelectionMode.SOME_RECORDS, total?:number, filters?: Array<Filter>, sort?: Array<Sort>){
+        this._records = records;
+        this._total = total;
+        this.mode = mode;
+        this.filters = filters;
+        this.sort = sort;
+    }
+
+    public get records(): Array<Record> | undefined{
+        if(this.isAllRecords()){
+            throw new Error("Erro interno: [ALL_RECORDS] - Impossível retornar os registros selecionados numa seleção virtual.")
+        }
+        return this._records;
+    }
+
+    public get recordIds(): Array<string> | undefined{
+
+        const records = this.records;
+
+        if(records == undefined){
+            return undefined;
+        }
+        return records.map(record => record.__record__id__);
+    }
+
+    public get length(): number{
+        if(this.isAllRecords()){
+            return this._total || 0;
+        }
+        return this.records == undefined ? 0: this.records.length;
+    }
+
+    public isAllRecords(): boolean{
+        return this.mode === SelectionMode.ALL_RECORDS;
+    }
+
+    public isEmpty(): boolean{
+        return this.length === 0;
+    }
+}