@epam/uui-db 5.3.0-rc.1 → 5.3.0

package/src/Loader.ts

@@ -0,0 +1,96 @@
+import { DbRef } from './DbRef';
+import {
+    DbPatch, DbTablesSet, LoadingState, ILoadingTracker,
+} from './types';
+
+export interface LoaderOptions<TTables extends DbTablesSet<TTables>, TResult, TRequest> {
+    api: (request: TRequest) => Promise<TResult>;
+    convertToPatch?: (result: TResult) => DbPatch<TTables>;
+    postProcess?: (patch: DbPatch<TTables>) => DbPatch<TTables>;
+    clientToServerRequest?: (request: TRequest) => TRequest;
+}
+
+export interface LoaderResult<TRequest> extends LoadingState<TRequest> {
+    promise: Promise<void>;
+    reload: () => void;
+}
+
+export class Loader<TTables extends DbTablesSet<TTables>, TResult, TRequest> {
+    private currentRequests: Set<Promise<void>> = new Set();
+    public loaded: ILoadingTracker<TRequest, TResult>;
+    private loadedAndLoading: ILoadingTracker<TRequest, TResult>;
+    constructor(
+        private dbRef: DbRef<TTables, any>,
+        private getTracker: () => ILoadingTracker<TRequest, TResult>,
+        private options: LoaderOptions<TTables, TResult, TRequest>,
+    ) {
+        this.loaded = getTracker();
+        this.loadedAndLoading = getTracker();
+    }
+
+    private loadImpl(state: LoaderResult<TRequest>) {
+        this.loadedAndLoading.append(state.missing);
+        state.isLoading = true;
+        let serverRequest = state.missing;
+        if (this.options.clientToServerRequest) {
+            serverRequest = this.options.clientToServerRequest(serverRequest);
+        }
+        state.promise = this.options.api(serverRequest).then((result) => {
+            this.loaded.append(state.missing, result);
+            this.loadedAndLoading.append(state.missing, result);
+            state.missing = null;
+            state.isLoading = false;
+            state.isComplete = true;
+            state.promise = Promise.resolve();
+            const flatten = this.options.convertToPatch(result);
+            this.options.postProcess && this.options.postProcess(flatten);
+            this.dbRef.commitFetch(flatten);
+        });
+
+        this.currentRequests.add(state.promise);
+
+        state.promise.finally(() => {
+            this.currentRequests.delete(state.promise);
+        });
+
+        return state.promise;
+    }
+
+    public load = (inputRequest: TRequest) => {
+        const result: LoaderResult<TRequest> = {
+            isComplete: this.loaded.diff(inputRequest) == null,
+            isLoading: false,
+            request: inputRequest,
+            missing: this.loadedAndLoading.diff(inputRequest),
+            promise: null,
+            reload: null,
+        };
+
+        result.reload = () => {
+            result.missing = inputRequest;
+            this.loadImpl(result);
+        };
+
+        if (result.isComplete) {
+            // Everything requested is already loaded
+            result.isComplete = true;
+            result.isLoading = false;
+            result.promise = Promise.resolve();
+            return result;
+        } else {
+            if (result.missing == null) {
+                // Everything requested is either loaded already, or being loaded
+                result.isComplete = false;
+                result.isLoading = true;
+                // There's no good way to tell which of current requests is querying requested data - there actually can be 2 of them.
+                // So we track all running requests, and await all of them in such case.
+                result.promise = Promise.all(this.currentRequests.entries()).then(() => {});
+                return result;
+            } else {
+                // Something requested is not loaded, nor being loaded. Need to perform a new request.
+                this.loadImpl(result);
+                return result;
+            }
+        }
+    };
+}

package/src/Scheduler.ts

@@ -0,0 +1,72 @@
+export interface SchedulerTask {
+    run: () => Promise<any>;
+    result?: any;
+    error?: any;
+    resolve?: (result: any) => void;
+    reject?: (result: any) => void;
+    isConcurrent: boolean;
+}
+
+export class Scheduler {
+    scheduled: SchedulerTask[] = [];
+    running: SchedulerTask[] = [];
+    complete: SchedulerTask[] = [];
+    public run(run: () => Promise<any>, isConcurrent = false) {
+        return new Promise((resolve, reject) => {
+            this.scheduled.push({
+                run, isConcurrent, resolve, reject,
+            });
+            this.scheduleRun();
+        });
+    }
+
+    isRunScheduled = false;
+    private scheduleRun() {
+        if (this.isRunScheduled) {
+            return;
+        }
+        setTimeout(() => {
+            this.isRunScheduled = false;
+            this.runQueues();
+        }, 0);
+        this.isRunScheduled = true;
+    }
+
+    tasksRunning = 0;
+    private runQueues() {
+        while (this.scheduled.length > 0) {
+            const pendingTask = this.scheduled[0];
+            if (this.running.length > 0 && !pendingTask.isConcurrent) {
+                break;
+            }
+
+            if (this.running.length > 0 && !this.running[0].isConcurrent) {
+                break;
+            }
+
+            const task = this.scheduled.shift();
+            this.running.push(task);
+            task.run()
+                .then((r) => {
+                    task.result = r;
+                })
+                .catch((err) => {
+                    task.error = err;
+                })
+                .finally(() => {
+                    this.complete.push(task);
+                    this.running = this.running.filter((t) => t !== task);
+                    this.scheduleRun();
+                });
+        }
+
+        while (this.complete.length > 0) {
+            const task = this.complete.shift();
+            if (task.error) {
+                task.reject(task.error);
+            } else {
+                task.resolve(task.result);
+            }
+        }
+    }
+}

package/src/SimpleLoadingTracker.ts

@@ -0,0 +1,17 @@
+import { ILoadingTracker } from './types';
+
+export class SimpleLoadingTracker<TRequest, TResult> implements ILoadingTracker<TRequest, TResult> {
+    private set: Set<string> = new Set();
+    constructor() {}
+    private getKey(request: TRequest) {
+        return JSON.stringify(request);
+    }
+
+    public diff(request: TRequest) {
+        return this.set.has(this.getKey(request)) ? null : request;
+    }
+
+    public append(request: TRequest, result: TResult) {
+        this.set.add(this.getKey(request));
+    }
+}

package/src/__benchmarks__/filter.ts

@@ -0,0 +1,50 @@
+import * as b from 'benny';
+import { Person } from './testData';
+import range from 'lodash.range';
+import { getFilterPredicate } from '@epam/uui-core';
+
+const testPersons = range(0, 1e4).map((id) => ({ id, name: `Person ${id}`, departmentId: Math.floor(Math.random() * 100) }));
+
+b.suite(
+    'Filter array',
+
+    b.add('array.filter, hard-coded', () => {
+        return () => testPersons.filter((p) => p.departmentId == 5);
+    }),
+
+    b.add('for-loop, array.push, hard-coded', () => {
+        return () => {
+            const result = [];
+            for (let n = 0; n < testPersons.length; n++) {
+                const person = testPersons[n];
+                if (person.departmentId == 5) {
+                    result.push(person);
+                }
+            }
+        };
+    }),
+
+    b.add('array.filter, getPatternPredicate', () => {
+        const predicate = getFilterPredicate<Person>({ departmentId: 5 });
+        return () => {
+            testPersons.filter(predicate);
+        };
+    }),
+
+    b.add('for-loop, array.push, getPatternPredicate', () => {
+        const predicate = getFilterPredicate<Person>({ departmentId: 5 });
+        return () => {
+            const result = [];
+            for (let n = 0; n < testPersons.length; n++) {
+                const person = testPersons[n];
+                if (predicate(person)) {
+                    result.push(person);
+                }
+            }
+        };
+    }),
+
+    b.cycle(),
+    b.complete(),
+    b.save({ file: 'filter', version: '1.0.0' }),
+);

package/src/__benchmarks__/index.ts

@@ -0,0 +1,5 @@
+// import './pkLookup';
+import './pkUpdate';
+import './query';
+// import './filter';
+// import './sorting';

package/src/__benchmarks__/pkLookup.ts

@@ -0,0 +1,33 @@
+import * as b from 'benny';
+import { test100KPersons, blankIxSet } from './testData';
+import * as I from 'immutable';
+
+b.suite(
+    'Find 1 entity by number ID in 100k dataset',
+
+    // b.add('Array.filter', () => test100KPersons.find(p => p.id == 5)),
+
+    b.add('IxSet.byId', () => {
+        const set = blankIxSet.with(test100KPersons);
+        return () => set.byId(5);
+    }),
+
+    b.add('Map.get', () => {
+        const map = new Map(test100KPersons.map((p) => [p.id, p]));
+        return () => map.get(5);
+    }),
+
+    b.add('hash[id]', () => {
+        const map = (Object as any).fromEntries(test100KPersons.map((p) => [p.id, p]));
+        return () => map[5];
+    }),
+
+    b.add('I.Map.get(id)', () => {
+        const map = I.Map(test100KPersons.map((p) => [p.id, p]));
+        return () => map.get(5);
+    }),
+
+    b.cycle(),
+    b.complete(),
+    b.save({ file: 'pkLookup', version: '1.0.0' }),
+);

package/src/__benchmarks__/pkUpdate.ts

@@ -0,0 +1,75 @@
+import * as b from 'benny';
+import * as I from 'immutable';
+import BTree from 'sorted-btree';
+import { Person, blankIxSet, blankIxSetNoIndex } from './testData';
+import range from 'lodash.range';
+import { DbTable } from '..';
+
+[
+    1e1, 1e2, 1e3, 1e4, 1e5, 1e6,
+].forEach((size) => {
+    const testPersons = range(0, size).map((id) => ({ id, name: `Person ${id}`, departmentId: Math.floor(Math.random() * 10) }));
+    const pairs = testPersons.map((p) => [p.id, p] as [number, Person]);
+    const person = testPersons[0];
+
+    const personTableNoIndex = new DbTable<any, any, any>({
+        primaryKey: ['id'],
+        tableName: 'persons',
+        typeName: 'person',
+    });
+
+    const personTableWithIndex = new DbTable<any, any, any>({
+        primaryKey: ['id'],
+        tableName: 'persons',
+        typeName: 'person',
+        indexes: ['departmentId'],
+    });
+
+    b.suite(
+        `Update 1 entity in ${size} dataset`,
+
+        b.add('BTree - with()', () => {
+            const set = new BTree(pairs);
+            return () => set.with(5, person);
+        }),
+
+        b.add('Map - clone with Map(previous)', () => {
+            const map = new Map(pairs);
+            return () => {
+                const m = new Map(map);
+                m.set(5, person);
+            };
+        }),
+
+        b.add('hash - spread clone', () => {
+            const map = (Object as any).fromEntries(pairs);
+            return () => {
+                const newMap = { ...map, 5: person };
+            };
+        }),
+
+        b.add('I.Map.set(id)', () => {
+            const map = I.Map(pairs);
+            return () => map.set(5, person);
+        }),
+
+        b.add('DbTable - no index', () => {
+            const table = personTableNoIndex.with(testPersons);
+            return () => table.with([person]);
+        }),
+
+        b.add('DbTable - single index', () => {
+            const table = personTableWithIndex.with(testPersons);
+            return () => table.with([person]);
+        }),
+
+        b.add('IxSet (with two indexes)', () => {
+            const set = blankIxSet.with(testPersons);
+            return () => set.with([person]);
+        }),
+
+        b.cycle(),
+        b.complete(),
+        b.save({ file: `pkUpdate-${size}`, version: '1.0.0' }),
+    );
+});

package/src/__benchmarks__/query.ts

@@ -0,0 +1,101 @@
+import * as b from 'benny';
+import * as I from 'immutable';
+import BTree from 'sorted-btree';
+import orderBy from 'lodash.orderby';
+import sortBy from 'lodash.sortby';
+import range from 'lodash.range';
+import { Person, blankIxSet, blankIxSetNoIndex } from './testData';
+import { getFilterPredicate, getOrderComparer } from '@epam/uui-core';
+import { DbTable } from '..';
+
+[
+    1e1, 1e2, 1e3, 1e4, 1e5,
+].forEach((size) => {
+    const testPersons = range(0, size).map((id) => ({ id, name: `Person ${id}`, departmentId: Math.floor((Math.random() * size) / 10) }));
+    const pairs = testPersons.map((p) => [p.id, p] as [number, Person]);
+    const filterPredicate = getFilterPredicate<Person>({ departmentId: 5 });
+    const orderComparer = getOrderComparer<Person>([{ field: 'name' }]);
+
+    const personTableNoIndex = new DbTable<any, any, any>({
+        primaryKey: ['id'],
+        tableName: 'persons',
+        typeName: 'person',
+    });
+
+    const personTableWithIndex = new DbTable<any, any, any>({
+        primaryKey: ['id'],
+        tableName: 'persons',
+        typeName: 'person',
+        indexes: ['departmentId'],
+    });
+
+    b.suite(
+        `Find N entities in ${size} dataset by departmentId, sorted by name`,
+
+        b.add('Array - scan', () => {
+            return () =>
+                orderBy(
+                    testPersons.filter((p) => p.departmentId == 5),
+                    'name',
+                );
+        }),
+
+        b.add('Array - with filterPredicate/orderComparer', () => {
+            return () => testPersons.filter(filterPredicate).sort(orderComparer);
+        }),
+
+        b.add('BTree - toArray/scan', () => {
+            const set = new BTree(pairs);
+            return () => set.valuesArray().filter(filterPredicate).sort(orderComparer);
+        }),
+
+        b.add('I.Map - iterable.filter.sort, then toArray', () => {
+            const set = I.Map(pairs);
+            return () => (set as I.Iterable<number, Person>).filter(filterPredicate).sort(orderComparer).toArray();
+        }),
+
+        b.add('I.Map - toArray, then filter/sort', () => {
+            const set = I.Map(pairs);
+            return () => sortBy((set as I.Iterable<number, Person>).toArray().filter(filterPredicate), 'name');
+        }),
+
+        // Super-fast by design, probably the best way to go with indexes.
+        // Skip for now to compare others.
+        //
+        // b.add('Lookup by I.Map with BTrees', () => {
+        //     const byDepId = I.Map<number, BTree<string, Person>>();
+        //     testPersons.forEach((p) => {
+        //         let bTree = byDepId.get(p.departmentId);
+        //         if (!bTree) {
+        //             bTree = new BTree<string, Person>();
+        //             byDepId.set(p.departmentId, bTree);
+        //         }
+        //         bTree.set(p.name, p);
+        //     });
+        //     const set = new BTree(pairs);
+        //     return () => byDepId.get(5);
+        // }),
+
+        b.add('IxSet - with indexes', () => {
+            const set = blankIxSet.with(testPersons);
+            return () => set.query({ filter: { departmentId: 5 }, sorting: [{ field: 'name' }] });
+        }),
+
+        b.add('IxSet - no indexes', () => {
+            const set = blankIxSetNoIndex.with(testPersons);
+            return () => set.query({ filter: { departmentId: 5 }, sorting: [{ field: 'name' }] });
+        }),
+
+        b.add('DbTable - no index', () => {
+            return () => personTableNoIndex.find({ departmentId: 5 }).orderBy('name');
+        }),
+
+        b.add('DbTable - with index', () => {
+            return () => personTableWithIndex.find({ departmentId: 5 }).orderBy('name');
+        }),
+
+        b.cycle(),
+        b.complete(),
+        b.save({ file: `query-${size}`, version: '1.0.0' }),
+    );
+});

package/src/__benchmarks__/sorting.ts

@@ -0,0 +1,33 @@
+import * as b from 'benny';
+import orderBy from 'lodash.orderby';
+import { Person } from './testData';
+import { getFilterPredicate, getOrderComparer } from '@epam/uui-core';
+import range from 'lodash.range';
+
+const testPersons = range(0, 1e4).map((id) => ({ id, name: `Person ${id}`, departmentId: Math.floor(Math.random() * 100) }));
+
+const nameComparer = (p1: Person, p2: Person) => (p1.name > p2.name ? 1 : -1);
+
+b.suite(
+    'Sort array',
+
+    b.add('array.sort, hard-coded', () => {
+        const arr = [...testPersons];
+        return () => arr.sort(nameComparer);
+    }),
+
+    b.add('_.sort, hard-coded', () => {
+        const arr = [...testPersons];
+        return () => orderBy(arr, 'name');
+    }),
+
+    b.add('array.sort, getOrderComparer', () => {
+        const arr = [...testPersons];
+        const comparer = getOrderComparer<Person>([{ field: 'name' }]);
+        return () => arr.sort(comparer);
+    }),
+
+    b.cycle(),
+    b.complete(),
+    b.save({ file: 'sorting', version: '1.0.0' }),
+);

package/src/__benchmarks__/testData.ts

@@ -0,0 +1,15 @@
+import range from 'lodash.range';
+import { IxSet } from '../IxSet';
+
+export interface Person {
+    id: number;
+    name: string;
+    departmentId: number;
+    location?: string;
+}
+
+export const test100KPersons = range(101000, 999, -1).map((id) => ({ id, name: `Person ${id}`, departmentId: Math.floor(Math.random() * 10) }));
+
+export const blankIxSet = new IxSet<Person, number>((i) => i.id, [{ fields: ['name'] }, { fields: ['departmentId', 'name'] }]);
+
+export const blankIxSetNoIndex = new IxSet<Person, number>((i) => i.id, []);

package/src/__tests__/ListLoadingTracker.test.ts

@@ -0,0 +1,83 @@
+import { Task } from './TaskDb';
+import { ListLoadingTracker } from '../ListLoadingTracker';
+import { DataQuery, LazyDataSourceApiResponse, runDataQuery } from '@epam/uui-core';
+import range from 'lodash.range';
+
+describe('db - ListLoadingTracker', () => {
+    const testItems = range(200).map((id) => {
+        return {
+            id, name: 'Task', isDone: false, createdBy: 'JS', isDraft: false, assignedTo: 'DT',
+        } as Task;
+    });
+
+    function getMockResponse(request: DataQuery<Task>): LazyDataSourceApiResponse<Task> {
+        return runDataQuery(testItems, request);
+    }
+
+    it('Should correctly process single ranged load', () => {
+        const tracker = new ListLoadingTracker<Task>();
+
+        const request = { filter: { assignedTo: 'DT' }, range: { from: 0, count: 10 } };
+        const request1 = tracker.diff(request);
+        expect(request1).toEqual(request);
+
+        tracker.append(request);
+
+        const request2 = tracker.diff(request);
+        expect(request2).toEqual(null);
+    });
+
+    it('Should correctly process overlapping ranges', () => {
+        const tracker = new ListLoadingTracker<Task>();
+
+        const request = { range: { from: 0, count: 10 } };
+        tracker.append(request, getMockResponse(request));
+
+        const overlappingRequest = { range: { from: 5, count: 10 } };
+        const diffRequest = tracker.diff(overlappingRequest);
+        expect(diffRequest).toEqual({ range: { from: 10, count: 5 } });
+    });
+
+    it('Should correctly process non-overlapping ranges', () => {
+        const tracker = new ListLoadingTracker<Task>();
+
+        const request = { range: { from: 0, count: 10 } };
+        tracker.append(request, getMockResponse(request));
+
+        const nonOverlappingRequest = { range: { from: 20, count: 10 } };
+        const missingRequest = tracker.diff(nonOverlappingRequest);
+
+        expect(missingRequest).toEqual({ range: { from: 10, count: 20 } });
+    });
+
+    it('Handle complete list correctly (after explicit load with no range)', () => {
+        const tracker = new ListLoadingTracker<Task>();
+
+        const request = {};
+        const loadRequest = tracker.diff(request);
+        expect(loadRequest).toEqual(request);
+
+        tracker.append(request);
+
+        const loadRequest2 = tracker.diff({});
+        expect(loadRequest2).toEqual(null);
+
+        const loadRequest3 = tracker.diff({ range: { from: 20, count: 10 } });
+        expect(loadRequest3).toEqual(null);
+    });
+
+    it('Handle complete list correctly (with implicit end of list detection)', () => {
+        const tracker = new ListLoadingTracker<Task>();
+
+        const request = { range: { from: 0, count: 2000 } };
+        const loadRequest = tracker.diff(request);
+        expect(loadRequest).toEqual(request);
+        tracker.append(request, getMockResponse(request));
+
+        const loadRequest2 = tracker.diff({});
+        expect(loadRequest2).toEqual(null);
+
+        const loadRequest3 = tracker.diff({ range: { from: 20, count: 10 } });
+        expect(loadRequest2).toEqual(null);
+    });
+});

package/src/__tests__/Scheduler.test.ts

@@ -0,0 +1,24 @@
+import { Scheduler } from '../Scheduler';
+
+const delay = (t: number) =>
+    new Promise((resolve) => {
+        setTimeout(resolve, t);
+    });
+
+const testApi = async (params: any) => {
+    await delay(1);
+    return params;
+};
+
+describe('db - Scheduler', () => {
+    beforeEach(() => {
+        // testTask.mockReset();
+    });
+
+    it('runs and completes a single task', async () => {
+        const scheduler = new Scheduler();
+        const testTask = jest.fn(testApi);
+        const result = await scheduler.run(() => testTask(123));
+        expect(result).toBe(123);
+    });
+});