@sankhyalabs/core 5.20.0-dev.4 → 5.20.0-dev.41

package/src/dataunit/DataUnit.ts

@@ -25,6 +25,8 @@ 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";
+import { getLoadingProperties, LoadingPropertiesReducer } from "./state/slice/LoadingProperties.js";
+import SortingUtils from "../utils/SortingUtils.js";
 
 /***
  * `DataUnit`: Atua como uma camada de abstração entre o back-end e a interface do usuário.
@@ -32,27 +34,30 @@ import { getInvalidFieldMessage, InvalidFieldsReducer } from "./state/slice/Inva
 export default class DataUnit {
     
     public static CHANGING_PAGE_LOADING_SOURCE = "CHANGING_PAGE_LOADING_SOURCE";
+    public static ALL_RECORDS_SELECTION_SOURCE = "ALL_RECORDS_SELECTION_SOURCE";
     public static DEFAULT_DATAUNIT_NAME = "dataunit";
 
     private _uuid: string;
     private _name: string;
-    private _observers: Array<(action: DataUnitAction) => void>;
+    private _observers: Array<(action: DataUnitAction, options?:DataUnitEventOptions) => void>;
     private _sortingProvider?: SortingProvider;
     private _filterProviders: Map<string, FilterProvider>;
     private _stateManager: StateManager;
-    private _interceptors: Array<DUActionInterceptor>;
+    private _interceptors: Map<string, DUActionInterceptor>;
     private _pageSize: number;
     private _childByName = new Map<string, DataUnit>();
     private _parentDataUnit: DataUnit | undefined;
     private _loadingLockers: Promise<void>[];
     private _savingLockers: Promise<any>[] = [];
     private _defaultSorting: Array<Sort>;
+    private _allowReleaseCallbacks: boolean;
     
     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>>;
+    public allRecordsLoader?: (dataUnit: DataUnit) => Array<Record> | undefined;
 
     constructor(name: string = DataUnit.DEFAULT_DATAUNIT_NAME, parentDataUnit?: DataUnit) {
         this._uuid = uuid()
@@ -61,6 +66,7 @@ export default class DataUnit {
         this._stateManager = new StateManager(
             [
                 HistReducer,
+                LoadingPropertiesReducer,
                 UnitMetadataReducer,
                 LoadingControlReducer,
                 RecordsReducer,
@@ -77,7 +83,8 @@ export default class DataUnit {
         this._filterProviders = new Map<string, FilterProvider>();
         this._sortingProvider = undefined;
         this._defaultSorting = [];
-        this._interceptors = [];
+        this._allowReleaseCallbacks = true;
+        this._interceptors = new Map();
         this._parentDataUnit = parentDataUnit;
         this._parentDataUnit?.subscribe(this.onDataUnitParentEvent);
         this._loadingLockers = [];
@@ -108,12 +115,35 @@ export default class DataUnit {
      * - Sorting Providers
      */
     public releaseCallbacks(){
+        if(!this._allowReleaseCallbacks) return;
+
         this._observers = [];
         this._filterProviders = new Map<string, FilterProvider>();
         this._sortingProvider = undefined;
-        this._interceptors = [];
+        this._interceptors = new Map();
     }
 
+    /**
+     * Adiciona uma propriedade transacional que será envida aos 
+     * loaders (dataLoader, saveLoader, removeLoader e recordLoader) na chamada.
+     * Essas propriedades serão limpas ao final da execução de cada método.
+     * 
+     * @param name - Nome da propriedade
+     * @param value - Valor da propriedade
+     * 
+     */
+    public addGlobalLoaderProp(name: string, value: string):void{
+        this.dispatchAction(Action.LOADING_PROPERTY_ADDED, {[name]: value});
+    }
+
+    /**
+     * Retorna as propriedades transacionais adicionados anteriores à chamada.
+     * 
+     * @returns - Todas as propriedades desde o final do último loader.
+     */
+    public getGlobalLoaderProps(): Map<string, string>{
+        return getLoadingProperties(this._stateManager) || new Map();
+    }
 
     public get dataUnitId(): string{
         return this._uuid;
@@ -157,6 +187,8 @@ export default class DataUnit {
             case Action.NEXT_SELECTED:
             case Action.PREVIOUS_SELECTED:
             case Action.DATA_LOADED:
+            case Action.RECORDS_ADDED:
+            case Action.EDITION_CANCELED:
                 this.clearDataUnit();
                 const selectedRecord = this._parentDataUnit?.getSelectedRecord();
                 if(selectedRecord != undefined && !this.isNewRecord(selectedRecord.__record__id__)){
@@ -215,22 +247,24 @@ export default class DataUnit {
             if (await this.dispatchAction(Action.LOADING_DATA, request, executionCtx)) {
                 if (this.dataLoader) {
                     this.dataLoader(this, request).then(
-                        response => {
-                            this.dispatchAction(
+                        async response => {
+                            await this.dispatchAction(
                                 Action.DATA_LOADED, 
-                                {...response, keepSelection: request.keepSelection, filters: request.filters},
+                                {...response, keepSelection: request.keepSelection, filters: request.filters, selectFirstRecord},
                                 executionCtx
                             );
 
+                            await this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
+
                             if(selectFirstRecord){
                                 this.requestSelectFirst(executionCtx);
                             }
-
                             resolve(response);
                         }
                     ).catch(error => {
                         console.error(error);
                         const {errorCode} = error;
+                        this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
                         fail(new ErrorException("Erro ao carregar registros", error, errorCode))
                     });
                 }
@@ -292,13 +326,16 @@ export default class DataUnit {
         
         await this.processLoadingLockers();
 
-        if (this._parentDataUnit && !this._parentDataUnit.getSelectedRecord()) {
+        if (this._parentDataUnit) {
+            const parentRecord = this._parentDataUnit.getSelectedRecord();
+            if(parentRecord == undefined || this._parentDataUnit.isNewRecord(parentRecord.__record__id__)){
                 if(this.records){
                     this.clearDataUnit();
                 }
                 return Promise.resolve({
                     records: []
                 });
+            }
         }
 
         const loadDataRequest = this.getLoadDataRequest(quickFilter, source);
@@ -311,7 +348,7 @@ export default class DataUnit {
      * 
      * @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.
      * 
     */
@@ -431,6 +468,7 @@ export default class DataUnit {
                                 const changes: Array<Change> = this.getAllChangesToSave();
 
                                 this.saveLoader(this, changes).then((records) => {
+                                    this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
                                     const recordsByDataUnit = this.getRecordsByDataUnit(records);
 
                                     const dispatchPromisses = [];
@@ -445,9 +483,12 @@ export default class DataUnit {
                                     Promise.all(dispatchPromisses).then(() => resolve());
                                 }).catch(cause => {
                                     const {errorCode} = cause;
+                                    this.dispatchAction(Action.SAVING_ERROR);
+                                    this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
                                     fail(new ErrorException("Erro ao salvar alterações", cause, errorCode));
                                 });
                             } else {
+                                this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
                                 resolve();
                             }
                         });
@@ -513,8 +554,8 @@ export default class DataUnit {
             if(selection.isAllRecords()){
                 throw new Error("Exclusão remota não implementada.");
             }
-            const records = selection?.records || [];
-            const recordIds = selection?.recordIds || [];
+            const records = selection?.records as Array<Record> || [];
+            const recordIds = selection?.recordIds as Array<string> || [];
             return this.removeRecords(recordIds, records, buffered, undefined, silent);
         }
         return Promise.resolve([]);
@@ -536,6 +577,7 @@ export default class DataUnit {
     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.LOADING_PROPERTIES_CLEANED);
                 this.dispatchAction(Action.RECORDS_REMOVED, { records: recordIds, cachedRecords, buffered: true }, executionCtx);
             } else {
                 if (await this.dispatchAction(Action.REMOVING_RECORDS, {silent}, executionCtx)) {
@@ -547,15 +589,18 @@ export default class DataUnit {
                                     const currentRecordsKeys = Array.from(getCurrentRecords(this._stateManager).keys());
                                     const removedIndex: Array<number> = recordIds
                                         .map(id => currentRecordsKeys.indexOf(id))
-                                        .filter(index => index > -1);
+                                        .filter(index => index > -1)
+                                        .sort();
 
                                     const nextIndex = Math.min(removedIndex.slice(-1)[0] + 1, currentRecordsKeys.length);
-                                    const selectionAfterRemove = [currentRecordsKeys[nextIndex]];
+                                    const selectionAfterRemove = currentRecordsKeys[nextIndex] ? [currentRecordsKeys[nextIndex]] : [];
 
                                     this.dispatchAction(Action.RECORDS_REMOVED, { records: removedIds, cachedRecords, removedIndex, buffered: false, selectionAfterRemove }, executionCtx);
+                                    this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
                                     resolve(removedIds);
                                 }
                             ).catch(error => {
+                                this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
                                 const {errorCode} = error;
                                 fail(new ErrorException("Erro ao remover registros", error, errorCode))
                             });
@@ -612,7 +657,6 @@ export default class DataUnit {
      * 
     */
     public getFormattedValue(fieldName: string, value?: any): string {
-        
         const descriptor = this.getField(fieldName);
         if (value == undefined) {
             value = this.getFieldValue(fieldName);
@@ -635,7 +679,7 @@ export default class DataUnit {
      * 
     */
     public addInterceptor(interceptor: DUActionInterceptor): void {
-        this._interceptors.push(interceptor);
+        this._interceptors.set(interceptor.interceptAction.toString(), interceptor);
     }
 
     /**
@@ -646,7 +690,7 @@ export default class DataUnit {
      * 
     */
     public removeInterceptor(interceptor: DUActionInterceptor) {
-        this._interceptors = this._interceptors.filter(i => i !== interceptor);
+        this._interceptors.delete(interceptor.interceptAction.toString())
     }
 
     /**
@@ -848,8 +892,12 @@ export default class DataUnit {
     public copySelected(executionCtx?: ExecutionContext): void {
         const selectionInfo = this.getSelectionInfo();
         if (selectionInfo) {
-            const selectedRecords = selectionInfo.records;
+            if(selectionInfo.isAllRecords()){
+                throw new Error("Erro interno: Impossível copiar os registros selecionados pois a seleção atual é virtual.");
+            }
+            const selectedRecords = selectionInfo.records as Array<Record>;
             if(selectedRecords){
+                
                 this.dispatchAction(Action.RECORDS_COPIED, prepareCopiedRecord(this._stateManager, selectedRecords, this.getParentRecordId()), executionCtx);
             }
         }
@@ -918,12 +966,16 @@ export default class DataUnit {
      * @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> {
+    public async setFieldValue(fieldName: string, newValue: any, records?: Array<string>, options?:DataUnitEventOptions): Promise<boolean> {
 
         if(!this.hasNewRecord() && !this.getSelectedRecord())  await this.addRecord();
         
         const typedValue = this.validateAndTypeValue(fieldName, newValue);
         const currentValue = this.getFieldValue(fieldName);
+
+        if(ObjectUtils.hasEquivalentProps(currentValue, typedValue)){
+            return Promise.resolve(false);
+        }
         
         if(newValue instanceof Promise){
             const promise:Promise<boolean> = new Promise(accept => {
@@ -937,7 +989,7 @@ export default class DataUnit {
         }
 
         if (currentValue !== typedValue) {
-            const promise = this.dispatchAction(Action.DATA_CHANGED, { [fieldName]: typedValue, records }, undefined);
+            const promise = this.dispatchAction(Action.DATA_CHANGED, { [fieldName]: typedValue, records }, undefined, options);
             this._savingLockers.push(promise);
             return promise;
         }
@@ -1065,7 +1117,7 @@ export default class 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)));
+                .then(()=>resolve(this.getSelectionInfo()));
         });
     }
 
@@ -1122,8 +1174,16 @@ export default class DataUnit {
      * @returns - Objeto com informações como registros selecionados e seleção por critério.
      * 
      **/ 
-    public getSelectionInfo(): SelectionInfo | undefined {
-        return getSelectionInfo(this._stateManager)
+    public getSelectionInfo(): SelectionInfo{
+        const selectionInfo: SelectionInfo = getSelectionInfo(this._stateManager);
+        selectionInfo.getAllRecords = () => this.allRecordsLoader?.(this);
+
+        if (selectionInfo.sort != undefined && selectionInfo.sort.length > 0) {
+            const sortingFunction = SortingUtils.getSortingFunction(this, selectionInfo.sort)
+            selectionInfo.records?.sort(sortingFunction)
+        }
+
+        return selectionInfo;
     }
 
     /**
@@ -1137,6 +1197,15 @@ export default class DataUnit {
        return getSelectedRecord(this._stateManager);
     }
 
+    /**
+     * Retorna o DataUnit pai
+     *
+     * @returns DataUnit pai ou undefined
+     */
+    public getParentDataUnit(): DataUnit | undefined {
+        return this._parentDataUnit;
+    }
+
     /**
      * 
      * Limpa todos os registros do DataUnit
@@ -1224,14 +1293,28 @@ export default class DataUnit {
     /**
      * 
      * Retorna se existe algum tipo de alteração pendente.
-     * 
+     *
+     * @param ignoreChildren: Define se deverá ignorar alterações pendentes no DataUnit filho.
      * @returns Verdadeiro se existir alterações pendentes.
      * 
     */ 
-    public isDirty(): boolean {
+    public isDirty(ignoreChildren?: boolean): boolean {
+        if(ignoreChildren) return isDirty(this._stateManager);
+
         return isDirty(this._stateManager) || this.childrenIsDirty();
     }
 
+    /**
+     *
+     * Retorna se existe alterações pendentes no DataUnit pai.
+     *
+     * @returns Verdadeiro se existir alterações pendentes e Falso caso não exista alterações ou não exista DataUnit pai.
+     *
+     */
+    public isParentDirty(): boolean {
+        return this._parentDataUnit ? this._parentDataUnit.isDirty(true) : false;
+    }
+
     /**
      * 
      * Retorna se existe algum DataUnit detail com alterações pendentes.
@@ -1404,17 +1487,17 @@ export default class DataUnit {
      * @returns - Verdadeiro se ação iniciada.
      * 
     */
-    private async dispatchAction(actionType: Action, payload?: any, executionCtx?: ExecutionContext): Promise<boolean> {
+    private async dispatchAction(actionType: Action, payload?: any, executionCtx?: ExecutionContext, options?:DataUnitEventOptions): 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) {
+            if (action && this._interceptors && this._interceptors.size > 0) {
                 action = await this.intercept(action, this._interceptors.values());
             }
             if (action) {
-                this.doDispatchAction(action);
+                this.doDispatchAction(action, options);
                 if (executionCtx && executionCtx.after) {
                     executionCtx.after(action)
                 }
@@ -1452,7 +1535,7 @@ export default class DataUnit {
      * @param action - Ações em execução no DataUnit.
      * 
     */
-    private doDispatchAction(action: DataUnitAction): void {
+    private doDispatchAction(action: DataUnitAction, options:DataUnitEventOptions = {}): void {
         this._stateManager.process(action);
         this?._parentDataUnit?.dispatchAction(Action.CHILD_CHANGED, { srcAction: action, srcDataUnit: this });
         this._observers.forEach(f => {
@@ -1461,7 +1544,7 @@ export default class DataUnit {
             should be continued
             */
             try {
-                f(action);
+                f(action, options);
             } catch (e) {
                 console.warn("[DataUnit] error while call observer", e);
             }
@@ -1500,7 +1583,7 @@ export default class DataUnit {
      * @param observer - Função que recebe como parâmetro as ações que serão monitoradas.
      * 
     */
-    public subscribe(observer: (action: DataUnitAction) => void) {
+    public subscribe(observer: (action: DataUnitAction, options?:DataUnitEventOptions) => void | Promise<void>) {
         this._observers.push(observer);
     }
 
@@ -1527,12 +1610,16 @@ export default class DataUnit {
             const selection = getSelection(this._stateManager);
             this.dispatchAction(Action.LOADING_RECORD, selection);
             
-            if(!this.dataLoader) return;
-            if(!this.recordLoader) return;
+            if(!this.recordLoader || !this.dataLoader) {
+                this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
+                return;
+            }
             
             this.recordLoader(this, selection).then(response => {
                 this.dispatchAction(Action.RECORD_LOADED, response)
+                this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
             }).catch(cause => {
+                this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
                 const {errorCode} = cause;
                 fail(new ErrorException("Erro ao recarregar registro", cause, errorCode));
             });
@@ -1671,7 +1758,7 @@ export default class DataUnit {
         }
 
         if (selection) {
-            return selection.records;
+            return selection.records as Array<Record>;
         }
     }
 
@@ -1689,12 +1776,15 @@ export default class DataUnit {
     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){
+            return [];
+        }
 
-        if(selection != undefined && selection.isAllRecords()){
+        if(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 || [];
+        return selection?.recordIds as Array<string>;
     }
 
     /**
@@ -1730,6 +1820,10 @@ export default class DataUnit {
         return loadingLockerResolver || Promise.resolve;
     }
 
+    public set allowReleaseCallbacks(allow: boolean){
+        this._allowReleaseCallbacks = allow;
+    }
+
     private async processLoadingLockers(){
         if(this._loadingLockers.length) {
             await Promise.all(this._loadingLockers);
@@ -1871,12 +1965,13 @@ export enum SelectionMode{
 
 export class SelectionInfo{
 
-    private _records: Array<Record>;
     public mode: SelectionMode;
-    private _total?: number;
     public filters?: Array<Filter>;
     public sort?: Array<Sort>;
-
+    public getAllRecords?: () => Array<Record> | undefined;
+    private _records: Array<Record>;
+    private _total?: number;
+    
     constructor(records: Array<Record>, mode: SelectionMode = SelectionMode.SOME_RECORDS, total?:number, filters?: Array<Filter>, sort?: Array<Sort>){
         this._records = records;
         this._total = total;
@@ -1887,7 +1982,10 @@ export class SelectionInfo{
 
     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.")
+            if(this.getAllRecords != undefined){
+                return this.getAllRecords();
+            }
+            throw new Error("Erro interno: Impossível retornar os registros selecionados numa seleção virtual.");
         }
         return this._records;
     }
@@ -1906,7 +2004,7 @@ export class SelectionInfo{
         if(this.isAllRecords()){
             return this._total || 0;
         }
-        return this.records == undefined ? 0: this.records.length;
+        return this.records == undefined ? 0 : (this.records as Array<Record>).length;
     }
 
     public isAllRecords(): boolean{
@@ -1917,3 +2015,5 @@ export class SelectionInfo{
         return this.length === 0;
     }
 }
+
+export type DataUnitEventOptions = {[key:string]: any};

package/src/dataunit/formatting/PrettyFormatter.ts

@@ -10,10 +10,10 @@ export const getFormattedValue = (value: any, descriptor?: FieldDescriptor) => {
     }
 
     if(descriptor?.dataType === DataType.OBJECT){
-        if(Object.hasOwn(value, "value")){
+        if(value && Object.hasOwn(value, "value")){
             return getSearchFormat(value, descriptor);
         }
-        return value == undefined ? "" : value.toString();
+        return !value ? "" : value.toString();
     }
 
     if(descriptor?.userInterface === UserInterface.OPTIONSELECTOR){
@@ -43,7 +43,7 @@ export const getFormattedValue = (value: any, descriptor?: FieldDescriptor) => {
     const mask = getMask(value, descriptor);
     if(mask != undefined){
         try{
-            return new MaskFormatter(mask).format(value);
+            return new MaskFormatter(mask).format(value, true);
         } catch(error){
             console.warn(`Erro ao formatar valor: ${value}. Mascara: ${mask}. Erro: ${error}`);
         }
@@ -53,6 +53,7 @@ export const getFormattedValue = (value: any, descriptor?: FieldDescriptor) => {
 }
 
 const getNumberFormat = (value: any, descriptor: FieldDescriptor) => {
+    if(value === undefined || value === null) return "";
     if(descriptor.userInterface === UserInterface.INTEGERNUMBER){
         return value;
     }
@@ -79,10 +80,12 @@ const getOptionFormat = (value: any, descriptor: FieldDescriptor) => {
         options = JSON.parse(prop);
     } else {
         options = {};
-        prop.forEach(opt => options[opt.label] = opt.value);
+        if(prop != undefined){
+            prop.forEach(opt => options[opt.label] = opt.value);
+        }
     }
 
-    if(typeof value === "object"){
+    if(value && typeof value === "object" ){
         value = value.value
     }
 
@@ -90,7 +93,7 @@ const getOptionFormat = (value: any, descriptor: FieldDescriptor) => {
         return options[value];
     }
 
-    return value;     
+    return value ?? "";
 }
 
 
@@ -101,7 +104,7 @@ const getMask = (value: string, descriptor: FieldDescriptor | undefined): string
     }
 
     const mask = descriptor.properties?.mask;
-    if(mask == undefined){
+    if(mask == undefined || !value){
         return;
     }
 

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/metadata/DataType.ts

@@ -67,7 +67,16 @@ export const getConvertedValue = (dataType: DataType, value: any): any => {
     case DataType.NUMBER:
       return value === "" || isNaN(Number(value)) ? null : Number(value);
     case DataType.OBJECT:
-      return typeof value === "string" ? JSON.parse(value) : value;
+    //Caso de uso campo DataType do tipo STRING e UserInterface do tipo TEXT, que tem relacionamento (TGFPRO.GRUPOPIS)
+    if(typeof value === "string") {
+        try{
+            return JSON.parse(value);
+        }catch(e){
+            console.warn(`Erro ao fazer parse do valor ${value} para objeto, dataType: ${dataType}`);
+        }
+      }
+
+      return value;
     case DataType.BOOLEAN:
       if (typeof value === "string") {
         return Boolean(value === 'true');
@@ -110,6 +119,9 @@ export const toString = ( dataType: DataType|undefined, value: any): string => {
         } else if (dataType === DataType.DATE) {
             if (typeof value === "string") {
                 value = DateUtils.strToDate(value);
+                if (value == undefined) {
+                    return value;
+                }
             }
             return DateUtils.formatRfc3339(value as Date);
         } else {

package/src/dataunit/state/action/DataUnitAction.ts

@@ -35,6 +35,7 @@ export enum Action{
 
     SAVING_DATA = "savingData",
     DATA_SAVED = "dataSaved",
+    SAVING_ERROR = "savingError",
 
     REMOVING_RECORDS = "removingRecords",
     RECORDS_REMOVED = "recordsRemoved",
@@ -63,6 +64,8 @@ export enum Action{
     CHILD_CHANGED = "childChanged",
 
     FIELD_INVALIDATED = "fieldInvalidated",
-    INVALIDATE_CLEAN = "invalidateClean"
+    INVALIDATE_CLEAN = "invalidateClean",
     
+    LOADING_PROPERTY_ADDED = "loadingPropertyAdded",
+    LOADING_PROPERTIES_CLEANED = "loadingPropertiesCleaned"
 }

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

@@ -94,27 +94,28 @@ export const getChangedFieldValue = (fieldName: string, record: Record, stateMan
 }
 
 export const getChangesToSave = (dataUnit: string, stateManager: StateManager): Array<Change> => {
-    const result: Array<Change> = [];
-
+    
     const changes = getChanges(stateManager);
     const selectedRecords = getSelectionRecords(stateManager) || [];
-    const records: Set<Record> = new Set(
+    const records: Map<string, Record> = new Map(
         getRecords(stateManager)
         .concat(
-            selectedRecords
-                .filter(record => !isAddedRecord(record.__record__id__, stateManager)
-            )
+            selectedRecords.filter(record => !isAddedRecord(record.__record__id__, stateManager))
         )
+        .map(r => [r.__record__id__, r])
     );
-
-    records?.forEach(r => {
-        if(changes){
-            const c = changes.get(r.__record__id__);
-            if (c) {
-                result.push(new Change(dataUnit, r, c, ChangeOperation.UPDATE,  r.__record__source__id__));
+    
+    const result: Array<Change> = [];
+    
+    if(changes != undefined){
+        Array.from(changes.entries())
+        .forEach(([recordId, change]) =>{
+            const record = records.get(recordId);
+            if(record != undefined){
+                result.push(new Change(dataUnit, record, change, ChangeOperation.UPDATE,  record.__record__source__id__));
             }
-        }
-    });
+        });
+    }
 
     const addedRecords = getAddedRecords(stateManager);
     if (addedRecords) {

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

@@ -15,6 +15,8 @@ class InvalidFieldsReducerImpl implements ActionReducer{
                 return makeInvalid(currentState, action.payload);
             case Action.INVALIDATE_CLEAN:
                 return clearRecord(currentState, action.payload);
+            case Action.EDITION_CANCELED:
+                return undefined;
         }
 
         return currentState;