@epam/uui-db 5.3.0 → 5.4.0

package/benchmark/results/query-1000.json

@@ -1,63 +0,0 @@
-{
-  "name": "Find N entities in 1000 dataset by departmentId, sorted by name",
-  "date": "2020-06-10T00:29:36.431Z",
-  "version": "1.0.0",
-  "results": [
-    {
-      "name": "Array - scan",
-      "ops": 278416,
-      "margin": 2.35,
-      "percentSlower": 87.88
-    },
-    {
-      "name": "Array - with filterPredicate/orderComparer",
-      "ops": 68167,
-      "margin": 3.37,
-      "percentSlower": 97.03
-    },
-    {
-      "name": "BTree - toArray/scan",
-      "ops": 23840,
-      "margin": 2.65,
-      "percentSlower": 98.96
-    },
-    {
-      "name": "I.Map - iterable.filter.sort, then toArray",
-      "ops": 22083,
-      "margin": 1.73,
-      "percentSlower": 99.04
-    },
-    {
-      "name": "I.Map - toArray, then filter/sort",
-      "ops": 17308,
-      "margin": 1.21,
-      "percentSlower": 99.25
-    },
-    {
-      "name": "IxSet - with indexes",
-      "ops": 184695,
-      "margin": 1.28,
-      "percentSlower": 91.96
-    },
-    {
-      "name": "IxSet - no indexes",
-      "ops": 21450,
-      "margin": 1.04,
-      "percentSlower": 99.07
-    },
-    {
-      "name": "DbTable - with index",
-      "ops": 2298027,
-      "margin": 1.28,
-      "percentSlower": 0
-    }
-  ],
-  "fastest": {
-    "name": "DbTable - with index",
-    "index": 7
-  },
-  "slowest": {
-    "name": "I.Map - toArray, then filter/sort",
-    "index": 4
-  }
-}

package/benchmark/results/query-10000.json

@@ -1,63 +0,0 @@
-{
-  "name": "Find N entities in 10000 dataset by departmentId, sorted by name",
-  "date": "2020-06-10T00:30:19.909Z",
-  "version": "1.0.0",
-  "results": [
-    {
-      "name": "Array - scan",
-      "ops": 27704,
-      "margin": 3.13,
-      "percentSlower": 98.71
-    },
-    {
-      "name": "Array - with filterPredicate/orderComparer",
-      "ops": 6806,
-      "margin": 3.02,
-      "percentSlower": 99.68
-    },
-    {
-      "name": "BTree - toArray/scan",
-      "ops": 2544,
-      "margin": 1.27,
-      "percentSlower": 99.88
-    },
-    {
-      "name": "I.Map - iterable.filter.sort, then toArray",
-      "ops": 2458,
-      "margin": 1.39,
-      "percentSlower": 99.89
-    },
-    {
-      "name": "I.Map - toArray, then filter/sort",
-      "ops": 1783,
-      "margin": 1.51,
-      "percentSlower": 99.92
-    },
-    {
-      "name": "IxSet - with indexes",
-      "ops": 118744,
-      "margin": 1.19,
-      "percentSlower": 94.49
-    },
-    {
-      "name": "IxSet - no indexes",
-      "ops": 2063,
-      "margin": 3.59,
-      "percentSlower": 99.9
-    },
-    {
-      "name": "DbTable - with index",
-      "ops": 2154284,
-      "margin": 1.22,
-      "percentSlower": 0
-    }
-  ],
-  "fastest": {
-    "name": "DbTable - with index",
-    "index": 7
-  },
-  "slowest": {
-    "name": "I.Map - toArray, then filter/sort",
-    "index": 4
-  }
-}

package/benchmark/results/query-100000.json

@@ -1,63 +0,0 @@
-{
-  "name": "Find N entities in 100000 dataset by departmentId, sorted by name",
-  "date": "2020-06-10T00:31:03.956Z",
-  "version": "1.0.0",
-  "results": [
-    {
-      "name": "Array - scan",
-      "ops": 1830,
-      "margin": 4.74,
-      "percentSlower": 99.91
-    },
-    {
-      "name": "Array - with filterPredicate/orderComparer",
-      "ops": 668,
-      "margin": 3.19,
-      "percentSlower": 99.97
-    },
-    {
-      "name": "BTree - toArray/scan",
-      "ops": 183,
-      "margin": 5.36,
-      "percentSlower": 99.99
-    },
-    {
-      "name": "I.Map - iterable.filter.sort, then toArray",
-      "ops": 50,
-      "margin": 2.33,
-      "percentSlower": 100
-    },
-    {
-      "name": "I.Map - toArray, then filter/sort",
-      "ops": 36,
-      "margin": 14.94,
-      "percentSlower": 100
-    },
-    {
-      "name": "IxSet - with indexes",
-      "ops": 76943,
-      "margin": 7.77,
-      "percentSlower": 96.16
-    },
-    {
-      "name": "IxSet - no indexes",
-      "ops": 135,
-      "margin": 8.63,
-      "percentSlower": 99.99
-    },
-    {
-      "name": "DbTable - with index",
-      "ops": 2003311,
-      "margin": 4.35,
-      "percentSlower": 0
-    }
-  ],
-  "fastest": {
-    "name": "DbTable - with index",
-    "index": 7
-  },
-  "slowest": {
-    "name": "I.Map - toArray, then filter/sort",
-    "index": 4
-  }
-}

package/benchmark/results/sorting.json

@@ -1,33 +0,0 @@
-{
-  "name": "Sort array",
-  "date": "2020-04-27T23:07:24.758Z",
-  "version": "1.0.0",
-  "results": [
-    {
-      "name": "array.sort, hard-coded",
-      "ops": 2645,
-      "margin": 2.18,
-      "percentSlower": 0
-    },
-    {
-      "name": "_.sort, hard-coded",
-      "ops": 464,
-      "margin": 1.96,
-      "percentSlower": 82.46
-    },
-    {
-      "name": "array.sort, getOrderComparer",
-      "ops": 1939,
-      "margin": 0.47,
-      "percentSlower": 26.69
-    }
-  ],
-  "fastest": {
-    "name": "array.sort, hard-coded",
-    "index": 0
-  },
-  "slowest": {
-    "name": "_.sort, hard-coded",
-    "index": 1
-  }
-}

package/build/package.json

@@ -1,69 +0,0 @@
-{
-  "name": "@epam/uui-db",
-  "version": "5.3.0",
-  "description": "UUI - client-side relational state cache",
-  "author": "EPAM",
-  "license": "MIT",
-  "module": "index.esm.js",
-  "main": "index.js",
-  "typings": "index.d.ts",
-  "scripts": {
-    "build": "node ../uui-build/scripts/buildModule",
-    "perf": "npx ts-node -T ./src/__benchmarks__/index.ts",
-    "perf-prof": "node -r ts-node/register/transpile-only --prof ./src/__benchmarks__/index.ts",
-    "prepublish": "yarn build"
-  },
-  "dependencies": {
-    "@epam/uui-core": "5.3.0",
-    "@types/lodash.countby": "4.6.6",
-    "@types/lodash.filter": "4.6.6",
-    "@types/lodash.foreach": "4.5.6",
-    "@types/lodash.groupby": "4.6.6",
-    "@types/lodash.isempty": "4.4.6",
-    "@types/lodash.isequal": "4.5.5",
-    "@types/lodash.map": "4.6.13",
-    "@types/lodash.merge": "4.6.6",
-    "@types/lodash.orderby": "4.6.6",
-    "@types/lodash.pick": "4.4.6",
-    "@types/lodash.range": "3.2.6",
-    "@types/lodash.sortby": "4.7.6",
-    "@types/lodash.transform": "4.6.6",
-    "@types/lodash.zip": "4.2.6",
-    "@types/shallowequal": "^1.1.1",
-    "immutable": "3.8.2",
-    "lodash.countby": "4.6.0",
-    "lodash.filter": "4.6.0",
-    "lodash.foreach": "4.5.0",
-    "lodash.groupby": "4.6.0",
-    "lodash.isempty": "4.4.0",
-    "lodash.isequal": "4.5.0",
-    "lodash.map": "4.6.0",
-    "lodash.merge": "4.6.2",
-    "lodash.orderby": "4.6.0",
-    "lodash.pick": "4.4.0",
-    "lodash.range": "3.2.0",
-    "lodash.sortby": "4.7.0",
-    "lodash.transform": "4.6.0",
-    "lodash.zip": "4.2.0",
-    "shallowequal": "^1.1.0",
-    "sorted-btree": "^1.2.1"
-  },
-  "devDependencies": {
-    "@types/benchmark": "^1.0.31",
-    "benny": "^3.6.14",
-    "ts-node": "10.9.1"
-  },
-  "peerDependencies": {
-    "prop-types": "*",
-    "react": ">=16.0.0",
-    "react-dom": ">=16.0.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/epam/UUI"
-  },
-  "gitHead": "e5bbda766f5bdfd7c42a3c62c34afd9c03fffedd",
-  "publishConfig": {
-    "directory": "build"
-  }
-}

package/build/readme.md

@@ -1,17 +0,0 @@
-# UUI DB package
-
-This package is a part of [EPAM UUI](https://github.com/epam/UUI) library.
-
-@epam/uui-db is an experimental state-management solution. It maintains immutable relational database on client, provides means to load data from server, update it both from client, and save it to server asynchronously with UI operations.
-
-## Features
-
-- relation data model for state, providing a normalized storage for UI state
-- data loading from server, with automatic GraphQL response normalization into tables
-- synchronous and transactional updates of state from UI
-- asynchronous bi-directional state synchronization between UI and server. UI changes in terms of 'patches' are batched and sent to server. Server can also push updates to UI state
-- GIT-like branch-rebase approach to handle state concurrency
-- tables can be indexed to speed-up queries
-- Views to build arbitrary state projections
-- subscriptions to subscribe parts of UI to changes in Views
-

package/globals.d.ts

@@ -1,9 +0,0 @@
-/// <reference path="../uui_globals.d.ts" />
-
-declare module 'jsurl';
-declare module 'query-string';
-declare module 'draft-js-plugins-editor';
-declare module 'draft-js-clear-formatting';
-declare module 'draft-convert';
-declare module 'draft-js-plugins-utils';
-declare module 'draft-js/lib/*';

package/index.tsx

@@ -1 +0,0 @@
-export * from './src';

package/src/Db.ts

@@ -1,89 +0,0 @@
-import {
-    DbPatch, DbTablesSet, DbTableEntityByTable, DbView, DbRelationType, ViewCacheItem,
-} from './types';
-import { objectKeys, defaultCompareViewDependencies, difference } from './utils';
-import isEqual from 'lodash.isequal';
-
-type ViewCache = Map<DbView<any, any, any, any>, Map<string, ViewCacheItem>>;
-
-export abstract class Db<TTables extends DbTablesSet<TTables>> {
-    private viewCache: ViewCache = new Map();
-    constructor(public tables: TTables, reusedCache?: ViewCache) {
-        if (reusedCache) {
-            this.viewCache = new Map(reusedCache);
-        } else {
-            this.viewCache = new Map();
-        }
-    }
-
-    private update(mutate: (db: this) => void): this {
-        const clone = new (this.constructor as any)(this.tables, this.viewCache);
-        clone.tables = { ...this.tables };
-        mutate(clone);
-        return clone;
-    }
-
-    public with(patch: DbPatch<TTables>): this {
-        return this.update((db) => {
-            objectKeys(db.tables).forEach((entityName) => {
-                if (patch[entityName]) {
-                    db.tables[entityName] = db.tables[entityName].with(patch[entityName]);
-                }
-            });
-        });
-    }
-
-    /* Views (cached db projections) */
-
-    valueAbsent = Symbol('ValueAbsent');
-    public runView<TResult, TParams = void, TDependencies = void>(view: DbView<this, TResult, TParams, TDependencies>, params?: TParams) {
-        let cache = this.viewCache.get(view);
-
-        if (!cache) {
-            cache = new Map();
-            this.viewCache.set(view, cache);
-        }
-
-        const key = view.getKey ? view.getKey(params) : JSON.stringify(params);
-
-        let cacheItem: ViewCacheItem = cache.get(key);
-
-        if (!cacheItem) {
-            cacheItem = {
-                dependencies: this.valueAbsent,
-                currentValue: this.valueAbsent,
-                computedOnDb: this.valueAbsent,
-            };
-            cache.set(key, cacheItem);
-        }
-
-        let shouldUpdate = this !== cacheItem.computedOnDb;
-        let dependencies: any = this.valueAbsent;
-
-        if (view.getDependencies) {
-            const compare = view.compareDependencies || defaultCompareViewDependencies;
-            dependencies = view.getDependencies(this, params);
-            shouldUpdate = !compare(cacheItem.dependencies, dependencies);
-        }
-
-        const previousValue = cacheItem.currentValue;
-
-        if (shouldUpdate) {
-            cacheItem.dependencies = dependencies;
-            const newValue = view.compute(this, params, dependencies);
-            cacheItem.computedOnDb = this;
-
-            const compareResults = view.compareResults || isEqual;
-
-            if (!compareResults(previousValue, newValue)) {
-                if (view.traceDiff) {
-                    console.debug(difference(previousValue, newValue));
-                }
-
-                cacheItem.currentValue = newValue;
-            }
-        }
-
-        return cacheItem.currentValue as TResult;
-    }
-}

package/src/DbRef.ts

@@ -1,254 +0,0 @@
-import { Db } from './Db';
-import {
-    DbPatch, DbTablesSet, ServerError, DbSaveResponse, DbView, ViewCacheItem, DbSubscription, DbPkFieldType,
-} from './types';
-import {
-    makeCumulativePatch, unionPatches, mergeEntityPatches, flattenResponse,
-} from './patchHelpers';
-import { TempIdMap, IClientIdsMap } from './tempIds';
-import { objectKeys, defaultCompareViewDependencies, difference } from './utils';
-import isEmpty from 'lodash.isempty';
-import { Loader, LoaderOptions } from './Loader';
-import { DataQuery, LazyDataSourceApiResponse, batch } from '@epam/uui-core';
-import { SimpleLoadingTracker } from './SimpleLoadingTracker';
-import { ListLoadingTracker, ListLoadingTrackerOptions } from './ListLoadingTracker';
-
-export class DbRef<TTables extends DbTablesSet<TTables>, TDb extends Db<TTables>> {
-    private base: TDb;
-    private log: { patch: DbPatch<TTables> }[] = [];
-    private autoSave = true;
-    private savedPoint = 0;
-    private tempIdMap: TempIdMap<TTables>;
-    public db: TDb;
-    protected throttleSaveMs = 1000;
-    public readonly idMap: IClientIdsMap;
-    constructor(public blank: TDb) {
-        this.db = blank;
-        this.base = blank;
-        this.tempIdMap = new TempIdMap(blank);
-        this.idMap = this.tempIdMap;
-
-        window.addEventListener('beforeunload', this.handleBeforeUnload);
-    }
-
-    /** Saves all committed patches. Useful only if autoSave is off. */
-    public save() {
-        return this.enqueueSave();
-    }
-
-    public getAutoSave() {
-        return this.autoSave;
-    }
-
-    public setAutoSave(val: boolean) {
-        if (this.autoSave != val) {
-            this.autoSave = val;
-            this.autoSave && this.enqueueSave();
-            this.update();
-        }
-    }
-
-    public revert() {
-        this.db = this.base;
-        this.log = this.log.slice(0, this.savedPoint);
-        this.update();
-    }
-
-    /** Concrete DbRef instances should override and implement their save logic in this method */
-    protected savePatch(patch: DbPatch<TTables>): Promise<DbSaveResponse<TTables>> {
-        return Promise.resolve({ submit: {} });
-    }
-
-    /* Db Update logic */
-
-    public commit(patch: DbPatch<TTables>): void {
-        const dbBeforeUpdate = this.db.with(patch);
-        patch = this.beforeUpdate(patch, dbBeforeUpdate.tables, this.db.tables);
-        patch = mergeEntityPatches(this.db.tables, patch);
-        this.log.push({ patch });
-        this.db = this.db.with(patch);
-
-        this.autoSave && this.enqueueSave(null, { throttleMs: this.throttleSaveMs });
-        this.update();
-    }
-
-    private beforeUpdate(patch: DbPatch<TTables>, tables: TTables, prevTables: TTables): DbPatch<TTables> {
-        let patchAndDependencies: DbPatch<TTables> = {};
-
-        objectKeys(tables)
-            .filter((entityName) => patch[entityName] && !tables[entityName].schema.beforeUpdate)
-            .forEach((entityName) => {
-                patchAndDependencies[entityName] = patch[entityName];
-            });
-
-        objectKeys(tables)
-            .filter((entityName) => patch[entityName] && tables[entityName].schema.beforeUpdate)
-            .forEach((entityName) => {
-                const schema = tables[entityName].schema;
-                const { beforeUpdate } = schema;
-                const context = {
-                    clientIdsMap: this.tempIdMap,
-                    schema,
-                    tables,
-                    prevTables,
-                };
-
-                const results = patch[entityName].map((e) => beforeUpdate(e, context));
-                const updatedPatch = { [entityName]: results.map((result) => result.entity) } as DbPatch<TTables>;
-                const dependentEntityPatchesForUpdate = unionPatches(results.filter((result) => result.dependentEntities).map((result) => result.dependentEntities));
-                const dependentEntityPatches = this.beforeUpdate(dependentEntityPatchesForUpdate, tables, prevTables);
-
-                patchAndDependencies = mergeEntityPatches(tables, unionPatches([
-                    patchAndDependencies, updatedPatch, dependentEntityPatches,
-                ]));
-            });
-        return patchAndDependencies;
-    }
-
-    public commitFetch(patch: DbPatch<TTables>): void {
-        patch = this.tempIdMap.serverToClientPatch(patch);
-        this.rebase(this.base.with(patch));
-        this.update();
-    }
-
-    private rebase(newBase: TDb) {
-        this.base = newBase;
-        this.db = newBase;
-        for (let n = this.savedPoint; n < this.log.length; n++) {
-            this.db = this.db.with(this.log[n].patch);
-        }
-    }
-
-    private makeCumulativePatch() {
-        const lastLogEntry = this.log.length;
-        const logEntriesToSave = this.log.slice(this.savedPoint, lastLogEntry);
-        let cumulativePatch = makeCumulativePatch(
-            this.db,
-            logEntriesToSave.map((t) => t.patch),
-            this.tempIdMap,
-        );
-        cumulativePatch = this.tempIdMap.clientToServerPatch(cumulativePatch);
-
-        return cumulativePatch;
-    }
-
-    private applyResponse(response: DbSaveResponse<TTables>, newSavedPoint: number) {
-        this.tempIdMap.appendServerMapping(response);
-
-        let serverPatch = flattenResponse(response.submit, this.db.tables);
-        serverPatch = mergeEntityPatches(this.db.tables, serverPatch);
-        this.savedPoint = newSavedPoint;
-        this.base = this.db;
-        this.commitFetch(serverPatch);
-    }
-
-    /* Update subscriptions (aka live views) */
-
-    private lastSubscriptionId = 1;
-    private subscriptions: Map<number, DbSubscription<any, any>> = new Map();
-    public subscribe<TValue, TParams, TDependencies>(
-        view: DbView<TDb, TValue, TParams, TDependencies>,
-        params: TParams,
-        onUpdate: (newValue: TValue) => any,
-    ): DbSubscription<TValue, TParams> {
-        const id = this.lastSubscriptionId++;
-
-        const subscription: DbSubscription<TValue, TParams> = {
-            update: (subscriptionParams: TParams) => {
-                subscription.currentParams = subscriptionParams;
-                subscription.currentValue = this.db.runView(view, subscriptionParams);
-                return subscription.currentValue;
-            },
-            currentParams: null,
-            currentValue: null,
-            onUpdate,
-            unsubscribe: () => {
-                this.subscriptions.delete(id);
-            },
-        };
-
-        subscription.update(params);
-
-        this.subscriptions.set(id, subscription);
-
-        return subscription;
-    }
-
-    updateHandlers: (() => any)[] = [];
-    public onUpdate(handler: () => any) {
-        this.subscribe(
-            {
-                compute: (db) => db,
-                compareResults: (a, b) => a === b,
-            },
-            null,
-            handler,
-        );
-    }
-
-    private update() {
-        this.subscriptions.forEach((subscription) => {
-            const previousValue = subscription.currentValue;
-            subscription.update(subscription.currentParams);
-            if (subscription.currentValue !== previousValue && subscription.onUpdate) {
-                subscription.onUpdate(subscription.currentValue);
-            }
-        });
-    }
-
-    /* Error Subscriptions */
-
-    public saveErrorHandlers: ((request: DbPatch<TTables>, error: any) => void)[] = [];
-    public onSaveError(handler: (request: DbPatch<TTables>, error: any) => void) {
-        this.saveErrorHandlers.push(handler);
-    }
-
-    private saveError(request: DbPatch<TTables>, error: any) {
-        this.saveErrorHandlers.forEach((handler) => handler(request, error));
-    }
-
-    /* Save scheduling */
-
-    private enqueueSave = batch(async () => {
-        const cumulativePatch = this.makeCumulativePatch();
-        const lastLogEntry = this.log.length;
-        if (isEmpty(cumulativePatch)) {
-            return;
-        }
-        try {
-            const response = await this.savePatch(cumulativePatch);
-            this.applyResponse(response, lastLogEntry);
-            this.update();
-        } catch (error) {
-            this.saveError(cumulativePatch, error);
-            this.update();
-            throw error;
-        }
-    });
-
-    private handleBeforeUnload = (e: BeforeUnloadEvent) => {
-        if (this.enqueueSave.isBusy) {
-            e.returnValue = false;
-            return false;
-        }
-    };
-
-    loaders: Loader<TTables, any, any>[] = [];
-    protected makeLoader<TResponse, TRequest>(options: LoaderOptions<TTables, TResponse, TRequest>) {
-        const loader = new Loader<TTables, TResponse, TRequest>(this as any, () => new SimpleLoadingTracker<TRequest, TResponse>(), options);
-        this.loaders.push(loader);
-        return loader;
-    }
-
-    protected makeListLoader<TItem, TResponse = DataQuery<TItem>, TRequest extends DataQuery<TItem> = DataQuery<TItem>>(
-        options: LoaderOptions<TTables, TResponse, TRequest> & ListLoadingTrackerOptions<TItem, TResponse>,
-    ) {
-        const loader = new Loader<TTables, TResponse, TRequest>(this as any, () => new ListLoadingTracker<TItem, TRequest, TResponse>(), options);
-        this.loaders.push(loader);
-        return loader;
-    }
-
-    reload() {
-        this.loaders = [];
-    }
-}