@sankhyalabs/core 6.1.0-dev.4 → 6.1.0-rc.1

package/src/dataunit/SelectionInfo.ts

@@ -1,55 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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/test/dataunit/AccessParentsDataUnit.spec.ts

@@ -1,69 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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();
-    });
-});

package/test/dataunit/FieldManager.spec.ts

@@ -1,286 +0,0 @@
-import DataUnit from "../../src/dataunit/DataUnit";
-import { DUActionInterceptor } from "../../src/dataunit/interfaces/dataUnit";
-import { DataType } from "../../src/dataunit/metadata/DataType";
-import { FieldDescriptor } from "../../src/dataunit/metadata/UnitMetadata";
-import { Action } from "../../src/dataunit/state/action/DataUnitAction";
-import { createDataUnitMock } from "./loader/utils/createDataUnitMock";
-
-describe('Field manager', () => {
-    let dataUnit: DataUnit;
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-        window.requestAnimationFrame = (functionCallback: Function) => functionCallback();
-        ({ dataUnit } = createDataUnitMock());
-    });
-
-    describe('setFieldValue', () => {
-        beforeEach(async () => {
-            await dataUnit.loadData();
-        });
-
-        it('should not create a new record when suppressCreateNewRecord is true', async () => {
-            await dataUnit.setFieldValue('column_name_1', 'new_value_1', undefined, { suppressCreateNewRecord: true });
-            const hasNewRecord = dataUnit.hasNewRecord();
-            expect(hasNewRecord).toBeFalsy();
-        });
-
-        it('should resolve promise with false when value is the same', async () => {
-            dataUnit.selectFirst();
-            const response = await dataUnit.setFieldValue('column_name_1', 'column_value_1');
-            expect(response).toBeFalsy();
-        });
-
-        it('should handle with promise values', async () => {
-            const dataChanged = jest.fn();
-            const interceptors: DUActionInterceptor = {
-                interceptAction: (action) => {
-                    if (action.type === Action.DATA_CHANGED) {
-                        dataChanged();
-                    }
-                    return action;
-                }
-            }
-            dataUnit.addInterceptor(interceptors);
-            dataUnit.selectFirst();
-            const promiseValue = new Promise((resolve) => resolve('promise_value'));
-            const response = await dataUnit.setFieldValue('column_name_1', promiseValue);
-
-            expect(response).toBeTruthy();
-            expect(dataChanged).toHaveBeenCalled();
-        });
-
-        it('should return false when value is the same', async () => {
-            dataUnit["areEquivalentValues"] = () => false;
-            dataUnit.selectFirst();
-            const response = await dataUnit.setFieldValue('column_name_1', 'column_value_1');
-            expect(response).toBeFalsy();
-        });
-    });
-
-    describe('disableField', () => {
-        beforeEach(async () => {
-            await dataUnit.loadMetadata();
-            await dataUnit.loadData();
-        });
-
-        it('should set readOnly to true', async () => {
-            dataUnit.disableField('column_name_1');
-            const field = dataUnit.getField('column_name_1');
-            expect(field?.readOnly).toBeTruthy();
-        });
-
-        it('should set readOnly to true when readonly is undefined', async () => {
-            dataUnit.disableField('column_name_2');
-            const field = dataUnit.getField('column_name_2');
-            expect(field?.readOnly).toBeTruthy();
-        });
-
-        it('should not set readOnly when field metadata not exist', async () => {
-            dataUnit.disableField('column_none');
-            const field = dataUnit.getField('column_none');
-            expect(field).toBeUndefined();
-        });
-    });
-
-    describe('enableField', () => {
-        beforeEach(async () => {
-            await dataUnit.loadMetadata();
-            await dataUnit.loadData();
-        });
-
-        it('should set readOnly to false', async () => {
-            dataUnit.enableField('column_name_1');
-            const field = dataUnit.getField('column_name_1');
-            expect(field?.readOnly).toBeFalsy();
-        });
-
-        it('should set readOnly to false when readonly is undefined', async () => {
-            dataUnit.enableField('column_name_2');
-            const field = dataUnit.getField('column_name_2');
-            expect(field?.readOnly).toBeFalsy();
-        });
-
-        it('should not set readOnly when field metadata not exist', async () => {
-            dataUnit.enableField('column_none');
-            const field = dataUnit.getField('column_none');
-            expect(field).toBeUndefined();
-        });
-    });
-
-    describe('hideField', () => {
-        beforeEach(async () => {
-            await dataUnit.loadMetadata();
-            await dataUnit.loadData();
-        });
-
-        it('should set visible to false', async () => {
-            dataUnit.hideField('column_name_1', { visibleOnConfig: true });
-            const field = dataUnit.getField('column_name_1');
-            expect(field?.visible).toBeFalsy();
-            expect(field?.properties?.visibleOnConfig).toBeTruthy();
-        });
-
-        it('should set visible to false when visible is undefined', async () => {
-            dataUnit.hideField('column_name_2', { visibleOnConfig: true });
-            const field = dataUnit.getField('column_name_2');
-            expect(field?.visible).toBeFalsy();
-        });
-
-        it('should handle with options undefined', async () => {
-            dataUnit.hideField('column_name_3', undefined);
-            const field = dataUnit.getField('column_name_3');
-
-            expect(field?.visible).toBeFalsy();
-            expect(field?.properties?.visibleOnConfig).toBeUndefined();
-            expect(field?.properties).toBeUndefined();
-        });
-
-        it('should not set visible when field metadata not exist', async () => {
-            dataUnit.hideField('column_none', { visibleOnConfig: true });
-            const field = dataUnit.getField('column_none');
-            expect(field).toBeUndefined();
-        });
-    });
-
-    describe('showField', () => {
-        beforeEach(async () => {
-            await dataUnit.loadMetadata();
-            await dataUnit.loadData();
-        });
-
-        it('should set visible to true', async () => {
-            dataUnit.showField('column_name_3');
-            const field = dataUnit.getField('column_name_3');
-            expect(field?.visible).toBeTruthy();
-        });
-
-        it('should set visible to true when visible is undefined', async () => {
-            dataUnit.showField('column_name_2');
-            const field = dataUnit.getField('column_name_2');
-            expect(field?.visible).toBeTruthy();
-        });
-
-        it('should not set visible when field metadata not exist', async () => {
-            dataUnit.showField('column_none');
-            const field = dataUnit.getField('column_none');
-            expect(field).toBeUndefined();
-        });
-    });
-
-    describe('addField', () => {
-        beforeEach(async () => {
-            await dataUnit.loadMetadata();
-            await dataUnit.loadData();
-        });
-
-        it('should add field standAlone to metadata', async () => {
-            const field: FieldDescriptor = {
-                name: 'new_field',
-                label: 'New field',
-                dataType: DataType.TEXT,
-            }
-            dataUnit.addField(field);
-            expect(dataUnit.metadata.fields).toStrictEqual(expect.arrayContaining([{ ...field, standAlone: true }]));
-        });
-    });
-
-    describe('valueFromString', () => {
-        beforeEach(async () => {
-            await dataUnit.loadMetadata();
-            await dataUnit.loadData();
-        });
-
-        it('should return number type', async () => {
-            const response = dataUnit.valueFromString('column_name_2', '100');
-            expect(response).toEqual(100);
-        });
-
-        it('should return boolean type', async () => {
-            const response = dataUnit.valueFromString('column_name_3', 'true');
-            expect(response).toEqual(true);
-        });
-
-        it('should return value without any format when not has a metadata to field', async () => {
-            const response = dataUnit.valueFromString('column_none', 'true');
-            expect(response).toEqual('true');
-        });
-    });
-
-    describe('valueToString', () => {
-        beforeEach(async () => {
-            await dataUnit.loadMetadata();
-            await dataUnit.loadData();
-        });
-
-        it('should return string from the number type', async () => {
-            const response = dataUnit.valueToString('column_name_2', 100);
-            expect(response).toEqual('100');
-        });
-
-        it('should return string from the boolean type', async () => {
-            const response = dataUnit.valueToString('column_name_3', true);
-            expect(response).toEqual('true');
-        });
-
-        it('should return string value when not has a metadata to field', async () => {
-            const response = dataUnit.valueToString('column_none', true);
-            expect(response).toEqual('true');
-        });
-    });
-
-    describe('getFormattedValue', () => {
-        beforeEach(async () => {
-            await dataUnit.loadMetadata();
-            await dataUnit.loadData();
-        });
-
-        it('should return string with number format from the number type', async () => {
-            const response = dataUnit.getFormattedValue('column_name_2', 100);
-            expect(response).toEqual('100,00');
-        });
-
-        it('should return string from the boolean type', async () => {
-            const response = dataUnit.getFormattedValue('column_name_3', true);
-            expect(response).toEqual('Sim');
-        });
-
-        it('should return empty string when value is undefined and not has any record selected', async () => {
-            const response = dataUnit.getFormattedValue('column_name_1');
-            expect(response).toEqual('');
-        });
-
-        it('should return value in string when value is undefined and has a record selected', async () => {
-            dataUnit.selectFirst();
-            const response = dataUnit.getFormattedValue('column_name_1');
-            expect(response).toEqual('column_value_1');
-        });
-
-        it('should return value in string formated when receive a string', async () => {
-            const response = dataUnit.getFormattedValue('column_name_2', '123');
-            expect(response).toEqual('123,00');
-        });
-
-        it('should return value in string with any formated when dont has a metadata field', async () => {
-            const response = dataUnit.getFormattedValue('column_none', '123');
-            expect(response).toEqual('123');
-        });
-
-        it('should return string value when not has a metadata to field', async () => {
-            const response = dataUnit.getFormattedValue('column_none', true);
-            expect(response).toEqual('true');
-        });
-    });
-
-    describe('addSourceFieldValue', () => {
-        beforeEach(async () => {
-            await dataUnit.loadMetadata();
-        });
-
-        it('should return string with number format from the number type', async () => {
-            dataUnit.addSourceFieldValue('column_name_1', 'column_name_2');
-            const response = dataUnit.getSourceFieldValue('column_name_1');
-            expect(response).toEqual('column_name_2');
-        });
-    });
-});