@sankhyalabs/core 1.0.38 → 1.0.42

package/src/dataunit/DataUnit.ts

@@ -1,334 +1,357 @@
-import { UnitMetadata, FieldDescriptor, SortingProvider, FilterProvider, Sort, Filter } from "./metadata/UnitMetadata";
-import { convertType } from "./metadata/DataType";
-
-import { DataUnitAction, Action } from "./state/action/DataUnitAction";
-import StateManager from "./state/StateManager";
-
-import { HistReducer, canRedo, canUndo } from "./state/HistReducer";
-import { UnitMetadataReducer, getField, getMetadata } from "./state/slice/UnitMetadataSlice";
-import { RecordsReducer } from "./state/slice/RecordsSlice";
-import { SelectionReducer, getSelection, hasNext, hasPrevious } from "./state/slice/SelectionSlice";
-import { ChangesReducer, isDirty, getChangesToSave } from "./state/slice/ChangesSlice";
-import { RemovedRecordsReducer } from "./state/slice/RemovedRecordsSlice";
-import { AddedRecordsReducer, prepareAddedRecordId } from "./state/slice/AddedRecordsSlice";
-import { CurrentRecordsReducer, getCurrentRecords, getFieldValue } from "./state/slice/CurrentRecordsSlice";
-
-export default class DataUnit {
-
-    private _name: string;
-    private _observers: Array<(action: DataUnitAction) => void>;
-    private _sortingProvider?: SortingProvider;
-    private _filterProviders: Array<FilterProvider>;
-    private _stateManager: StateManager;
-    private _interceptors: Array<DUActionInterceptor>;
-
-    public metadataLoader?: (dataUnit: DataUnit) => Promise<UnitMetadata>;
-    public dataLoader?: (dataUnit: DataUnit, sort?: Array<Sort>, filters?: Array<Filter>) => Promise<Array<Record>>;
-    public saveLoader?: (dataUnit: DataUnit, changes: Array<Change>) => Promise<Array<SavedRecord>>;
-
-    constructor(name: string) {
-        this._name = name;
-        this._stateManager = new StateManager(
-            [
-                HistReducer,
-                UnitMetadataReducer,
-                RecordsReducer,
-                RemovedRecordsReducer,
-                AddedRecordsReducer,
-                SelectionReducer,
-                ChangesReducer,
-                CurrentRecordsReducer
-            ]
-        );
-        this._observers = [];
-        this._filterProviders = [];
-        this._sortingProvider = undefined;
-        this._interceptors = [];
-    }
-
-    public get name(): string {
-        return this._name;
-    }
-
-    // Métodos privados
-    private validateAndTypeValue(fieldName: string, newValue: any): any {
-        //FIXME: Validações devem ser feitas aqui
-        const descriptor: FieldDescriptor | undefined = this.getField(fieldName);
-        return descriptor ? convertType(descriptor.dataType, newValue) : newValue;
-    }
-
-    private 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;
-    }
-
-    private getSort(): Array<Sort> | undefined {
-        return this._sortingProvider ? this._sortingProvider.getSort(this._name) : undefined;
-    }
-
-    // Loaders
-    public async loadMetadata(): Promise<UnitMetadata> {
-        this.dispatchAction(Action.LOADING_METADATA);
-        return new Promise((resolve, fail) => {
-            if (this.metadataLoader) {
-                this.metadataLoader(this).then(
-                    metadata => {
-                        this.metadata = metadata
-                        resolve(this.metadata);
-                    }
-                ).catch(error => fail(error));
-            }
-        });
-    }
-
-    public async loadData(): Promise<Array<Record>> {
-        this.dispatchAction(Action.LOADING_DATA);
-        return new Promise((resolve, fail) => {
-            if (this.dataLoader) {
-                const sort = this.getSort();
-                const filters = this.getFilters();
-                this.dataLoader(this, sort, filters).then(
-                    records => {
-                        this.records = records;
-                        resolve(this.records);
-                    }
-                ).catch(error => fail(error));
-            }
-        });
-    }
-
-    public async saveData(): Promise<void> {
-
-        const changes: Array<Change> = getChangesToSave(this._name, this._stateManager);
-
-        if (changes.length > 0) {
-            this.dispatchAction(Action.SAVING_DATA);
-            return new Promise((resolve, fail) => {
-                if (this.saveLoader) {
-                    this.saveLoader(this, changes).then(
-                        records => this.dispatchAction(Action.DATA_SAVED, { changes, records })
-                    ).catch(error => fail(error));
-                }
-            });
-        }
-        return Promise.resolve();
-    }
-
-    // API
-    public valueFromString(fieldName: string, value: string): any {
-        const descriptor: FieldDescriptor | undefined = this.getField(fieldName);
-        return descriptor ? convertType(descriptor.dataType, value) : value;
-    }
-
-    public addInterceptor(interceptor: DUActionInterceptor): void {
-        this._interceptors.push(interceptor);
-    }
-
-    public addFilterProvider(provider: FilterProvider): void {
-        this._filterProviders.push(provider);
-    }
-
-    public set sortingProvider(provider: SortingProvider) {
-        this._sortingProvider = provider;
-    }
-
-    public set metadata(md: UnitMetadata) {
-        this.dispatchAction(Action.METADATA_LOADED, md);
-    }
-
-    public get metadata(): UnitMetadata {
-        return getMetadata(this._stateManager);
-    }
-
-    public set records(r: Array<Record>) {
-        this.dispatchAction(Action.DATA_LOADED, r);
-    }
-
-    public get records(): Array<Record> {
-        const records = getCurrentRecords(this._stateManager);
-        return records ? Array.from(records.values()) : [];
-    }
-
-    public getField(fieldName: string): FieldDescriptor | undefined {
-        return getField(this._stateManager, fieldName);
-    }
-
-    public addRecord(): void {
-        this.dispatchAction(Action.RECORDS_ADDED, prepareAddedRecordId(this._stateManager, [{}]));
-    }
-
-    public copySelected(): void{
-        const selectedRecords = this.getSelectedRecords();
-        if(selectedRecords){
-            this.dispatchAction(Action.RECORDS_COPIED, prepareAddedRecordId(this._stateManager, selectedRecords));
-        }
-    }
-
-    public removeSelectedRecords(): void {
-        const selection = getSelection(this._stateManager);
-        if (selection) {
-            this.dispatchAction(Action.RECORDS_REMOVED, selection);
-        }
-    }
-
-    public getFieldValue(fieldName: string): any {
-        return getFieldValue(this._stateManager, fieldName);
-    }
-
-    public setFieldValue(fieldName: string, newValue: any, records?: Array<string>): void {
-
-        const typedValue = this.validateAndTypeValue(fieldName, newValue);
-        const currentValue = this.getFieldValue(fieldName);
-
-        if (currentValue !== typedValue) {
-            this.dispatchAction(Action.DATA_CHANGED, { [fieldName]: typedValue, records });
-        }
-    }
-
-    public getSelection(): Array<string> {
-        return getSelection(this._stateManager);
-    }
-
-    public setSelection(selection: Array<string>): void {
-        this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection });
-    }
-
-    public setSelectionByIndex(selection: Array<number>): void {
-        this.dispatchAction(Action.SELECTION_CHANGED, { type: "index", selection });
-    }
-
-    public getSelectedRecords(): Array<Record>|undefined{
-        const selection: Array<string> = this.getSelection();
-        if(selection){
-            const currentRecords: Array<Record> = this.records;
-            return currentRecords?.filter(r => selection.includes(r.__record__id__));
-        }
-    }
-
-    public nextRecord(): void {
-        this.dispatchAction(Action.NEXT_SELECTED);
-    }
-
-    public previousRecord(): void {
-        this.dispatchAction(Action.PREVIOUS_SELECTED);
-    }
-
-    public cancelEdition(): void {
-        this.dispatchAction(Action.EDITION_CANCELED);
-    }
-
-    public isDirty(): boolean {
-        return isDirty(this._stateManager);
-    }
-
-    public hasNext(): boolean {
-        return hasNext(this._stateManager);
-    }
-
-    public hasPrevious(): boolean {
-        return hasPrevious(this._stateManager);
-    }
-
-    public canUndo(): boolean {
-        return canUndo(this._stateManager);
-    }
-
-    public canRedo(): boolean {
-        return canRedo(this._stateManager);
-    }
-
-    public undo() {
-        this.dispatchAction(Action.CHANGE_UNDONE);
-    }
-
-    public redo() {
-        this.dispatchAction(Action.CHANGE_REDONE);
-    }
-
-    public toString(){
-        return this.name;
-    }
-
-    // Actions / State manager
-    private dispatchAction(actionType: Action, payload?: any): void {
-        let action = new DataUnitAction(actionType, payload);
-
-        this._interceptors?.forEach(interceptor => {
-            if(action){
-                action = interceptor.interceptAction(action);
-            }
-        });
-
-        if(action){
-            this._stateManager.process(action);
-            this._observers.forEach(f => f(action));
-        }
-    }
-
-    public subscribe(observer: (action: DataUnitAction) => void) {
-        this._observers.push(observer);
-    }
-
-    public unsubscribe(observer: Function) {
-        this._observers = this._observers.filter(f => f !== observer);
-    }
-}
-
-export interface DUActionInterceptor{
-    interceptAction(action: DataUnitAction): DataUnitAction; 
-}
-
-export interface Record {
-    __record__id__: string;
-    __parent__record__id__?: string;
-    [key: string]: any;
-}
-
-export interface SavedRecord extends Record {
-    __old__id__?: string;
-}
-
-export enum ChangeOperation {
-    INSERT = "INSERT",
-    UPDATE = "UPDATE",
-    DELETE = "DELETE"
-}
-
-export class Change {
-
-    public dataUnit: string;
-    public record: Record;
-    public updatingFields: any;
-
-    private _operation: ChangeOperation;
-
-    constructor(dataUnit: string, record: Record, updates: any, operation: ChangeOperation) {
-        this.dataUnit = dataUnit;
-        this.record = record;
-        this.updatingFields = updates;
-        this._operation = operation;
-    }
-
-    public get operation(): string{
-        return this._operation.toString();
-    }
-
-    public isInsert(): boolean {
-        return this._operation === ChangeOperation.INSERT;
-    }
-
-    public isDelete(): boolean {
-        return this._operation === ChangeOperation.DELETE;
-    }
-
-    public isUpdate(): boolean {
-        return this._operation === ChangeOperation.UPDATE;
-    }
-
+import { UnitMetadata, FieldDescriptor, SortingProvider, FilterProvider, Sort, Filter } from "./metadata/UnitMetadata.js";
+import { convertType } from "./metadata/DataType.js";
+
+import { DataUnitAction, Action } from "./state/action/DataUnitAction.js";
+import StateManager from "./state/StateManager.js";
+
+import { HistReducer, canRedo, canUndo } from "./state/HistReducer.js";
+import { UnitMetadataReducer, getField, getMetadata } from "./state/slice/UnitMetadataSlice.js";
+import { RecordsReducer } from "./state/slice/RecordsSlice.js";
+import { SelectionReducer, getSelection, hasNext, hasPrevious } from "./state/slice/SelectionSlice.js";
+import { ChangesReducer, isDirty, getChangesToSave } from "./state/slice/ChangesSlice.js";
+import { RemovedRecordsReducer } from "./state/slice/RemovedRecordsSlice.js";
+import { AddedRecordsReducer, prepareAddedRecordId } from "./state/slice/AddedRecordsSlice.js";
+import { CurrentRecordsReducer, getCurrentRecords, getFieldValue } from "./state/slice/CurrentRecordsSlice.js";
+
+export default class DataUnit {
+
+    private _name: string;
+    private _observers: Array<(action: DataUnitAction) => void>;
+    private _sortingProvider?: SortingProvider;
+    private _filterProviders: Array<FilterProvider>;
+    private _stateManager: StateManager;
+    private _interceptors: Array<DUActionInterceptor>;
+
+    public metadataLoader?: (dataUnit: DataUnit) => Promise<UnitMetadata>;
+    public dataLoader?: (dataUnit: DataUnit, sort?: Array<Sort>, filters?: Array<Filter>) => Promise<Array<Record>>;
+    public saveLoader?: (dataUnit: DataUnit, changes: Array<Change>) => Promise<Array<SavedRecord>>;
+    public removeLoader?: (dataUnit: DataUnit, recordIds: Array<string>) => Promise<Array<string>>;
+
+    constructor(name: string) {
+        this._name = name;
+        this._stateManager = new StateManager(
+            [
+                HistReducer,
+                UnitMetadataReducer,
+                RecordsReducer,
+                RemovedRecordsReducer,
+                AddedRecordsReducer,
+                SelectionReducer,
+                ChangesReducer,
+                CurrentRecordsReducer
+            ]
+        );
+        this._observers = [];
+        this._filterProviders = [];
+        this._sortingProvider = undefined;
+        this._interceptors = [];
+    }
+
+    public get name(): string {
+        return this._name;
+    }
+
+    // Métodos privados
+    private validateAndTypeValue(fieldName: string, newValue: any): any {
+        //FIXME: Validações devem ser feitas aqui
+        const descriptor: FieldDescriptor | undefined = this.getField(fieldName);
+        return descriptor ? convertType(descriptor.dataType, newValue) : newValue;
+    }
+
+    private 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;
+    }
+
+    private getSort(): Array<Sort> | undefined {
+        return this._sortingProvider ? this._sortingProvider.getSort(this._name) : undefined;
+    }
+
+    // Loaders
+    public async loadMetadata(): Promise<UnitMetadata> {
+        this.dispatchAction(Action.LOADING_METADATA);
+        return new Promise((resolve, fail) => {
+            if (this.metadataLoader) {
+                this.metadataLoader(this).then(
+                    metadata => {
+                        this.metadata = metadata
+                        resolve(this.metadata);
+                    }
+                ).catch(error => fail(error));
+            }
+        });
+    }
+
+    public async loadData(): Promise<Array<Record>> {
+        this.dispatchAction(Action.LOADING_DATA);
+        return new Promise((resolve, fail) => {
+            if (this.dataLoader) {
+                const sort = this.getSort();
+                const filters = this.getFilters();
+                this.dataLoader(this, sort, filters).then(
+                    records => {
+                        this.records = records;
+                        resolve(this.records);
+                    }
+                ).catch(error => fail(error));
+            }
+        });
+    }
+
+    public async saveData(): Promise<void> {
+
+        const changes: Array<Change> = getChangesToSave(this._name, this._stateManager);
+
+        if (changes.length > 0) {
+            this.dispatchAction(Action.SAVING_DATA);
+            return new Promise((resolve, fail) => {
+                if (this.saveLoader) {
+                    this.saveLoader(this, changes).then(
+                        records => this.dispatchAction(Action.DATA_SAVED, { changes, records })
+                    ).catch(error => fail(error));
+                }
+            });
+        }
+        return Promise.resolve();
+    }
+
+    public async removeSelectedRecords(buffered: boolean = false): Promise<Array<string>> {
+        const selection = getSelection(this._stateManager);
+        if (selection) {
+            return this.removeRecords(selection, buffered);
+        }
+        return Promise.resolve(selection);
+    }
+
+    public async removeRecords(records:Array<string>, buffered: boolean = false): Promise<Array<string>> {
+        if (records) {
+            if (buffered || !this.removeLoader) {
+                this.dispatchAction(Action.RECORDS_REMOVED, { records, buffered: true });
+            } else {
+                this.dispatchAction(Action.REMOVING_RECORDS);
+                return new Promise((resolve, fail) => {
+                    if (this.removeLoader) {
+                        this.removeLoader(this, records).then(
+                            records => {
+                                this.dispatchAction(Action.RECORDS_REMOVED, { records, buffered: false });
+                                resolve(records);
+                            }
+                        ).catch(error => fail(error));
+                    }
+                });
+            }
+        }
+        return Promise.resolve(records);
+    }
+
+    // API
+    public valueFromString(fieldName: string, value: string): any {
+        const descriptor: FieldDescriptor | undefined = this.getField(fieldName);
+        return descriptor ? convertType(descriptor.dataType, value) : value;
+    }
+
+    public addInterceptor(interceptor: DUActionInterceptor): void {
+        this._interceptors.push(interceptor);
+    }
+
+    public addFilterProvider(provider: FilterProvider): void {
+        this._filterProviders.push(provider);
+    }
+
+    public set sortingProvider(provider: SortingProvider) {
+        this._sortingProvider = provider;
+    }
+
+    public set metadata(md: UnitMetadata) {
+        this.dispatchAction(Action.METADATA_LOADED, md);
+    }
+
+    public get metadata(): UnitMetadata {
+        return getMetadata(this._stateManager);
+    }
+
+    public set records(r: Array<Record>) {
+        this.dispatchAction(Action.DATA_LOADED, r);
+    }
+
+    public get records(): Array<Record> {
+        const records = getCurrentRecords(this._stateManager);
+        return records ? Array.from(records.values()) : [];
+    }
+
+    public getField(fieldName: string): FieldDescriptor | undefined {
+        return getField(this._stateManager, fieldName);
+    }
+
+    public addRecord(): void {
+        this.dispatchAction(Action.RECORDS_ADDED, prepareAddedRecordId(this._stateManager, [{}]));
+    }
+
+    public copySelected(): void {
+        const selectedRecords = this.getSelectedRecords();
+        if (selectedRecords) {
+            this.dispatchAction(Action.RECORDS_COPIED, prepareAddedRecordId(this._stateManager, selectedRecords));
+        }
+    }
+
+    public getFieldValue(fieldName: string): any {
+        return getFieldValue(this._stateManager, fieldName);
+    }
+
+    public setFieldValue(fieldName: string, newValue: any, records?: Array<string>): void {
+
+        const typedValue = this.validateAndTypeValue(fieldName, newValue);
+        const currentValue = this.getFieldValue(fieldName);
+
+        if (currentValue !== typedValue) {
+            this.dispatchAction(Action.DATA_CHANGED, { [fieldName]: typedValue, records });
+        }
+    }
+
+    public getSelection(): Array<string> {
+        return getSelection(this._stateManager);
+    }
+
+    public setSelection(selection: Array<string>): void {
+        this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection });
+    }
+
+    public setSelectionByIndex(selection: Array<number>): void {
+        this.dispatchAction(Action.SELECTION_CHANGED, { type: "index", selection });
+    }
+
+    public getSelectedRecords(): Array<Record> | undefined {
+        const selection: Array<string> = this.getSelection();
+        if (selection) {
+            const currentRecords: Array<Record> = this.records;
+            return currentRecords?.filter(r => selection.includes(r.__record__id__));
+        }
+    }
+
+    public nextRecord(): void {
+        this.dispatchAction(Action.NEXT_SELECTED);
+    }
+
+    public previousRecord(): void {
+        this.dispatchAction(Action.PREVIOUS_SELECTED);
+    }
+
+    public cancelEdition(): void {
+        this.dispatchAction(Action.EDITION_CANCELED);
+    }
+
+    public isDirty(): boolean {
+        return isDirty(this._stateManager);
+    }
+
+    public hasNext(): boolean {
+        return hasNext(this._stateManager);
+    }
+
+    public hasPrevious(): boolean {
+        return hasPrevious(this._stateManager);
+    }
+
+    public canUndo(): boolean {
+        return canUndo(this._stateManager);
+    }
+
+    public canRedo(): boolean {
+        return canRedo(this._stateManager);
+    }
+
+    public undo() {
+        this.dispatchAction(Action.CHANGE_UNDONE);
+    }
+
+    public redo() {
+        this.dispatchAction(Action.CHANGE_REDONE);
+    }
+
+    public toString() {
+        return this.name;
+    }
+
+    // Actions / State manager
+    private dispatchAction(actionType: Action, payload?: any): void {
+        let action = new DataUnitAction(actionType, payload);
+
+        this._interceptors?.forEach(interceptor => {
+            if (action) {
+                action = interceptor.interceptAction(action);
+            }
+        });
+
+        if (action) {
+            this._stateManager.process(action);
+            this._observers.forEach(f => f(action));
+        }
+    }
+
+    public subscribe(observer: (action: DataUnitAction) => void) {
+        this._observers.push(observer);
+    }
+
+    public unsubscribe(observer: Function) {
+        this._observers = this._observers.filter(f => f !== observer);
+    }
+}
+
+export interface DUActionInterceptor {
+    interceptAction(action: DataUnitAction): DataUnitAction;
+}
+
+export interface Record {
+    __record__id__: string;
+    __parent__record__id__?: string;
+    [key: string]: any;
+}
+
+export interface SavedRecord extends Record {
+    __old__id__?: string;
+}
+
+export enum ChangeOperation {
+    INSERT = "INSERT",
+    UPDATE = "UPDATE",
+    DELETE = "DELETE"
+}
+
+export class Change {
+
+    public dataUnit: string;
+    public record: Record;
+    public updatingFields: any;
+
+    private _operation: ChangeOperation;
+
+    constructor(dataUnit: string, record: Record, updates: any, operation: ChangeOperation) {
+        this.dataUnit = dataUnit;
+        this.record = record;
+        this.updatingFields = updates;
+        this._operation = operation;
+    }
+
+    public get operation(): string {
+        return this._operation.toString();
+    }
+
+    public isInsert(): boolean {
+        return this._operation === ChangeOperation.INSERT;
+    }
+
+    public isDelete(): boolean {
+        return this._operation === ChangeOperation.DELETE;
+    }
+
+    public isUpdate(): boolean {
+        return this._operation === ChangeOperation.UPDATE;
+    }
+
 }