@sankhyalabs/core 6.1.0-dev.2 → 6.1.0-dev.3

package/src/dataunit/DataUnitHelper.ts

@@ -1,4 +1,5 @@
-import DataUnit, { Record } from './DataUnit.js';
+import DataUnit from './DataUnit.js';
+import { Record } from './interfaces/dataUnit.js';
 import { DataType } from './metadata/DataType.js';
 import { LoadDataRequest, LoadDataResponse, PaginationInfo, Sort, SortMode, StringUtils } from '../index.js';
 

package/src/dataunit/SelectionInfo.ts

@@ -0,0 +1,55 @@
+import { Record, SelectionMode } from "./interfaces/dataUnit.js";
+import { Filter, Sort } from "./metadata/UnitMetadata.js";
+
+export class SelectionInfo {
+
+    public mode: SelectionMode;
+    public filters?: Array<Filter>;
+    public sort?: Array<Sort>;
+    public getAllRecords?: () => Array<Record>;
+    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;
+        this.mode = mode;
+        this.filters = filters;
+        this.sort = sort;
+    }
+
+    public get records(): Array<Record> {
+        if (this.isAllRecords()) {
+            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;
+    }
+
+    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 as Array<Record>).length;
+    }
+
+    public isAllRecords(): boolean {
+        return this.mode === SelectionMode.ALL_RECORDS;
+    }
+
+    public isEmpty(): boolean {
+        return this.length === 0;
+    }
+}

package/src/dataunit/interfaces/dataUnit.ts

@@ -0,0 +1,71 @@
+import { Filter } from "../metadata/UnitMetadata.js";
+import { DataUnitAction, ExecutionContext } from "../state/action/DataUnitAction.js";
+
+export interface LoadDataParams {
+    quickFilter?: QuickFilter;
+    executionCtx?: ExecutionContext;
+    checkLastFilter?: boolean;
+    source?: string;
+    selectFirstRecord?: boolean;
+    keepSelection?: boolean
+}
+
+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",
+}
+
+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 type DataUnitEventOptions = { [key: string]: any };
+
+export type HideFieldOptions = {
+    visibleOnConfig: boolean
+};

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

@@ -1,4 +1,5 @@
-import DataUnit, { Record } from '../../DataUnit.js';
+import DataUnit from '../../DataUnit.js';
+import { Record } from '../../interfaces/dataUnit.js';
 import { Filter, Sort } from '../../metadata/UnitMetadata.js';
 import { LoadDataRequest } from '../../loading/LoadDataRequest.js';
 import { PaginationInfo } from '../../loading/PaginationInfo.js';

package/src/dataunit/loading/LoadDataRequest.ts

@@ -1,4 +1,4 @@
-import { QuickFilter } from "../DataUnit.js";
+import { QuickFilter } from '../interfaces/dataUnit.js';
 import { Filter, Sort } from "../metadata/UnitMetadata.js";
 
 /** Atributos enviados na requisição de carregamento dos registros */

package/src/dataunit/loading/LoadDataResponse.ts

@@ -1,4 +1,4 @@
-import { Record } from "../DataUnit.js";
+import { Record } from "../interfaces/dataUnit.js";
 import { PaginationInfo } from "./PaginationInfo.js";
 
 /** Retorno dos registros da requisição de carregamento de dados */

package/src/dataunit/sorting/FieldComparator.ts

@@ -1,4 +1,4 @@
-import { Record } from '../DataUnit.js';
+import { Record } from "../interfaces/dataUnit.js";
 import { compareValues } from '../metadata/DataType.js';
 import { FieldDescriptor } from '../metadata/UnitMetadata.js';
 

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

@@ -2,7 +2,7 @@
 import { ActionReducer, StateAction } from "../StateManager.js";
 import { Action } from "../action/DataUnitAction.js";
 import StateManager from "../StateManager.js";
-import { Record } from "../../DataUnit.js";
+import { Record } from "../../interfaces/dataUnit.js";
 
 class AddedRecordsReducerImpl implements ActionReducer{
     

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

@@ -6,7 +6,8 @@ import { getSelection } from "./SelectionSlice.js";
 import { getRecords } from "./RecordsSlice.js";
 import { getRemovedRecords } from "./RemovedRecordsSlice.js";
 import { getAddedRecords, isAddedRecord } from "./AddedRecordsSlice.js";
-import { Change, ChangeOperation, Record } from "../../DataUnit.js";
+import { ChangeOperation, Record } from "../../interfaces/dataUnit.js";
+import { Change } from "../../Changes.js";
 import { getWaitingChanges } from "./WaitingChangesSlice.js";
 import { getSelectionRecords } from "./SnapshotSlice.js";
 

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

@@ -1,5 +1,4 @@
-
-import { ChangeOperation } from "../../DataUnit.js";
+import { ChangeOperation } from "../../interfaces/dataUnit.js";
 import { LoadDataRequest } from "../../loading/LoadDataRequest.js";
 import { PaginationInfo } from "../../loading/PaginationInfo.js";
 import { Action } from "../action/DataUnitAction.js";

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

@@ -2,7 +2,8 @@ import { ActionReducer, StateAction } from "../StateManager.js";
 import StateManager from "../StateManager.js";
 import { getRemovedRecords } from "./RemovedRecordsSlice.js";
 import { Action } from "../action/DataUnitAction.js";
-import { Record, SavedRecord } from "../../DataUnit.js";
+import { Record, SavedRecord } from "../../interfaces/dataUnit.js";
+
 
 class RecordsReducerImpl implements ActionReducer {
 
@@ -12,7 +13,7 @@ class RecordsReducerImpl implements ActionReducer {
         switch (action.type) {
 
             case Action.DATA_LOADED:
-                return action.payload ? action.payload.records : undefined;
+                return action.payload ? action.payload.records : [];
             case Action.RECORDS_REMOVED:
                 
                 const {records, buffered} = action.payload;

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

@@ -2,7 +2,8 @@ import { ActionReducer, StateAction } from "../StateManager.js";
 import { Action } from "../action/DataUnitAction.js";
 import StateManager from "../StateManager.js";
 import { getCurrentRecords, getSelectionRecords } from "./SnapshotSlice.js";
-import { Record, SavedRecord, SelectionInfo, SelectionMode } from "../../DataUnit.js";
+import { Record, SavedRecord, SelectionMode } from "../../interfaces/dataUnit.js";
+import { SelectionInfo } from "../../SelectionInfo.js";
 import { getCurrentRequest, getPaginationInfo } from "./LoadingControlSlice.js";
 import { PaginationInfo } from "../../loading/PaginationInfo.js";
 

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

@@ -1,7 +1,7 @@
 
 import { ActionReducer } from "../StateManager.js";
 import StateManager from "../StateManager.js";
-import { Record } from "../../DataUnit.js";
+import { Record } from "../../interfaces/dataUnit.js";
 import { getRecords } from "./RecordsSlice.js";
 import { getSelection } from "./SelectionSlice.js";
 import { getChangedFieldValue, getChanges } from "./ChangesSlice.js";

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

@@ -1,5 +1,5 @@
 
-import { WaitingChange } from "../../DataUnit.js";
+import { WaitingChange } from "../../interfaces/dataUnit.js";
 import { Action } from "../action/DataUnitAction.js";
 import StateManager, { ActionReducer, StateAction } from "../StateManager.js";
 

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

@@ -1,7 +1,7 @@
 
 import * as RecordsReducerModule from '../RecordsSlice';
 import StateManager from '../../StateManager';
-import { Record } from '../../../DataUnit';
+import { Record } from '../../../interfaces/dataUnit';
 import { Action } from '../../action/DataUnitAction';
 
 jest.spyOn(RecordsReducerModule, "getRecords").mockImplementation(() => [

package/src/index.ts

@@ -9,7 +9,10 @@ import { HttpProvider } from "./http/HttpProvider.js";
 import { SkwHttpProvider } from "./http/SkwHttpProvider.js";
 import { RequestMetadata } from "./http/RequestMetadata.js";
 import { AuthorizedServiceCaller } from "./http/AuthorizedServiceCaller.js";
-import DataUnit, {SavedRecord, Record, Change, ChangeOperation, DUActionInterceptor, WaitingChange, PageRequest, QuickFilter, SelectionMode, SelectionInfo, DataUnitEventOptions} from "./dataunit/DataUnit.js";
+import DataUnit from "./dataunit/DataUnit.js";
+import {SavedRecord, Record, ChangeOperation, DUActionInterceptor, WaitingChange, PageRequest, QuickFilter, SelectionMode, DataUnitEventOptions} from "./dataunit/interfaces/dataUnit.js";
+import { Change } from "./dataunit/Changes.js";
+import { SelectionInfo } from "./dataunit/SelectionInfo.js";
 import { DataType } from "./dataunit/metadata/DataType.js";
 import { UnitMetadata, FieldDescriptor, UserInterface, Sort, SortMode, SortingProvider, Filter, DependencyType, ChildDescriptor, ChildLink } from "./dataunit/metadata/UnitMetadata.js";
 import { DataUnitAction, Action, ExecutionContext } from "./dataunit/state/action/DataUnitAction.js";

package/src/utils/ColumnFilterManager.ts

@@ -1,5 +1,6 @@
 import { Filter } from '../dataunit/metadata/UnitMetadata.js';
-import DataUnit, { Record } from '../dataunit/DataUnit.js';
+import DataUnit from '../dataunit/DataUnit.js';
+import { Record } from '../dataunit/interfaces/dataUnit.js';
 import { FieldComparator } from '../dataunit/sorting/FieldComparator.js';
 import { LoadDataRequest } from '../dataunit/loading/LoadDataRequest.js';
 

package/src/utils/SortingUtils.ts

@@ -1,7 +1,7 @@
 import DataUnit from "../dataunit/DataUnit.js";
 import { FieldDescriptor, Sort, SortMode } from "../dataunit/metadata/UnitMetadata.js";
 import { FieldComparator } from "../dataunit/sorting/FieldComparator.js";
-import { Record } from '../dataunit/DataUnit.js';
+import { Record } from '../dataunit/interfaces/dataUnit.js';
 
 /**
  * `SortingUtils`: Utilizado para auxiliar na ordenacao de registros.

package/test/dataunit/AccessParentsDataUnit.spec.ts

@@ -0,0 +1,69 @@
+import DataUnit from "../../src/dataunit/DataUnit";
+import { createDataUnitMock } from "./loader/utils/createDataUnitMock";
+import { metadata } from "./resources/metadata";
+
+describe('Access parent dataUnits', () => {
+    let dataUnit: DataUnit;
+    let metadataLoaderMock = jest.fn();
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        window.requestAnimationFrame = (functionCallback: Function) => functionCallback();
+        ({ dataUnit, metadataLoaderMock } = createDataUnitMock());
+    });
+
+    describe('getChildInfo', () => {
+        beforeEach(async () => {
+            await dataUnit.loadMetadata();
+            await dataUnit.loadData();
+        });
+
+        it('should return metadata children data', () => {
+            const name = dataUnit.getChildInfo('child');
+            expect(name).toStrictEqual(metadata.children![0]);
+        });
+
+        it('should return undefined when dont has metadata', async () => {
+            metadataLoaderMock.mockResolvedValue(undefined);
+            await dataUnit.loadMetadata();
+            const name = dataUnit.getChildInfo('child');
+            expect(name).toBeUndefined();
+        });
+
+        it('should return undefined when dont has metadata children data', async () => {
+            metadataLoaderMock.mockResolvedValue({ ...metadata, children: undefined });
+            await dataUnit.loadMetadata();
+            const name = dataUnit.getChildInfo('child');
+            expect(name).toBeUndefined();
+        });
+    });
+
+    describe('getParentDataUnit', () => {
+        it('should return parent dataUnit', () => {
+            const childDataUnit = new DataUnit('child', dataUnit);
+            const parentDataUnit = childDataUnit.getParentDataUnit();
+            expect(parentDataUnit).toStrictEqual(dataUnit);
+        });
+    });
+
+    describe('isParentDirty', () => {
+        it('should return true when parent is dirty', async () => {
+            dataUnit.selectFirst();
+            await dataUnit.setFieldValue('column_name_1', 'new_value');
+            const childDataUnit = new DataUnit('child', dataUnit);
+            const parentIsDirty = childDataUnit.isParentDirty();
+            expect(parentIsDirty).toBeTruthy();
+        });
+
+        it('should return false when parent is not dirty', () => {
+            const childDataUnit = new DataUnit('child', dataUnit);
+            const parentIsDirty = childDataUnit.isParentDirty();
+            expect(parentIsDirty).toBeFalsy();
+        });
+
+        it('should return false when dont has parent', () => {
+            const parentIsDirty = dataUnit.isParentDirty();
+            expect(parentIsDirty).toBeFalsy();
+        });
+    });
+});

package/test/dataunit/Actions.spec.ts

@@ -0,0 +1,74 @@
+import DataUnit from "../../src/dataunit/DataUnit";
+import { Action, DataUnitAction } from "../../src/dataunit/state/action/DataUnitAction";
+import { createDataUnitMock } from "./loader/utils/createDataUnitMock";
+import { recordsTest } from "./resources/records";
+
+describe('Actions', () => {
+    let dataUnit: DataUnit;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        window.requestAnimationFrame = (functionCallback: Function) => functionCallback();
+        ({ dataUnit } = createDataUnitMock());
+    });
+
+    describe('savingCanceled', () => {
+        it('should emit event savingCanceled', async () => {
+            const savingCanceled = jest.fn();
+            const observer = async (action: DataUnitAction) => {
+                if (action.type === Action.SAVING_CANCELED) {
+                    savingCanceled();
+                }
+                return;
+            }
+            dataUnit.subscribe(observer);
+            dataUnit.selectFirst();
+            await dataUnit.setFieldValue('column_name_1', 'new_value');
+            dataUnit.savingCanceled([{ name: 'column_name_1', message: 'cancel_saving' }], 'test_1');
+            expect(savingCanceled).toHaveBeenCalled();
+        });
+    });
+
+    describe('clearInvalid', () => {
+        beforeEach(async () => {
+            await dataUnit.loadMetadata();
+            await dataUnit.loadData();
+        });
+
+        it('should emit event savingCanceled', async () => {
+            const invalidateClean = jest.fn();
+            const observer = async (action: DataUnitAction) => {
+                if (action.type === Action.INVALIDATE_CLEAN) {
+                    invalidateClean();
+                }
+                return;
+            }
+            dataUnit.subscribe(observer);
+            dataUnit.selectFirst();
+            await dataUnit.setFieldValue('column_name_1', 'new_value');
+            dataUnit.clearInvalid('test_1', 'column_name_1');
+            expect(invalidateClean).toHaveBeenCalled();
+        });
+    });
+
+    describe('redo', () => {
+        beforeEach(async () => {
+            await dataUnit.loadMetadata();
+            await dataUnit.loadData();
+            const saveLoaderMock = jest.fn().mockResolvedValue(recordsTest);
+            dataUnit.saveLoader = saveLoaderMock;
+        });
+
+
+        it('should return true when field value changes can redo', async () => {
+            dataUnit.selectFirst();
+            await dataUnit.setFieldValue('column_name_1', 'new_value');
+            dataUnit.undo();
+            let fieldValue = dataUnit.getFieldValue('column_name_1');
+            expect(fieldValue).toBe('column_value_1');
+            dataUnit.redo();
+            fieldValue = dataUnit.getFieldValue('column_name_1');
+            expect(fieldValue).toBe('new_value');
+        });
+    });
+});

package/test/dataunit/Change.spec.ts

@@ -0,0 +1,66 @@
+import { Change } from "../../src/dataunit/Changes";
+import { ChangeOperation } from "../../src/dataunit/interfaces/dataUnit";
+
+describe('Change', () => {
+    let change: Change;
+    beforeEach(() => {
+        change = new Change(
+            'test',
+            { __record__id__: 'test_1' },
+            undefined,
+            ChangeOperation.COPY,
+            'source_id',
+        );
+    });
+
+    it('should return operation', () => {
+        const response = change.operation;
+        expect(response).toBe('COPY');
+    });
+
+    it('should return false when operation is not insert', () => {
+        const response = change.isInsert();
+        expect(response).toBeFalsy();
+    });
+
+    it('should return true when operation is insert', () => {
+        change = new Change(
+            'test',
+            { __record__id__: 'test_1' },
+            undefined,
+            ChangeOperation.INSERT,
+            'source_id',
+        );
+        const response = change.isInsert();
+        expect(response).toBeTruthy();
+    });
+
+    it('should return true when operation is copy', () => {
+        const response = change.isCopy();
+        expect(response).toBeTruthy();
+    });
+
+    it('should return true when operation is delete', () => {
+        change = new Change(
+            'test',
+            { __record__id__: 'test_1' },
+            undefined,
+            ChangeOperation.DELETE,
+            'source_id',
+        );
+        const response = change.isDelete();
+        expect(response).toBeTruthy();
+    });
+
+    it('should return true when operation is update', () => {
+        change = new Change(
+            'test',
+            { __record__id__: 'test_1' },
+            undefined,
+            ChangeOperation.UPDATE,
+            'source_id',
+        );
+        const response = change.isUpdate();
+        expect(response).toBeTruthy();
+    });
+});