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

package/src/DbTable.ts

@@ -0,0 +1,264 @@
+import {
+    DbTablePatch, DbQuery, DbEntitySchema, DbPkFieldType, DbTablesSet,
+} from './types';
+import * as I from 'immutable';
+import {
+    SortDirection, getFilterPredicate, getOrderComparer, DataQueryFilter, SortingOption, getSearchFilter, DataQuery,
+} from '@epam/uui-core';
+import { Seq } from 'immutable';
+
+interface DbIndex<TEntity> {
+    field: keyof TEntity;
+    map: I.Map<any, I.Set<any>>;
+}
+
+interface DbTableState<TEntity, TTables extends DbTablesSet<TTables>> {
+    pk: I.Map<any, TEntity>;
+    indexes: DbIndex<TEntity>[];
+}
+
+export class DbTable<TEntity, TId extends DbPkFieldType, TTables extends DbTablesSet<TTables>> {
+    constructor(public readonly schema: DbEntitySchema<TEntity, TId, TTables>, private state?: DbTableState<TEntity, TTables>, private q?: DbQuery<TEntity>) {
+        if (!state) {
+            const indexes: DbIndex<TEntity>[] = (schema.indexes || []).map((indexDef) => {
+                return {
+                    field: indexDef,
+                    map: I.Map(),
+                };
+            });
+
+            this.state = { pk: I.Map(), indexes };
+        }
+
+        if (!q) {
+            this.q = {};
+        }
+    }
+
+    protected keyToImmutable(id: TId): any {
+        if (Array.isArray(id)) {
+            return I.List(id);
+        } else {
+            return id;
+        }
+    }
+
+    public byId(id: TId): TEntity {
+        return this.state.pk.get(this.keyToImmutable(id));
+    }
+
+    public getId(entity: Partial<TEntity>): TId {
+        if (Array.isArray(this.schema.primaryKey)) {
+            return this.schema.primaryKey.map((key: keyof TEntity) => entity[key]) as any as TId;
+        }
+        return entity[this.schema.primaryKey as keyof TEntity] as any as TId;
+    }
+
+    private update(mutate: (t: DbTable<TEntity, TId, TTables>) => void): this {
+        const clone = new (this.constructor as any)(this.schema, this.state, this.q);
+        mutate(clone);
+        return clone;
+    }
+
+    /* Mutation */
+
+    public with(patch: DbTablePatch<TEntity>) {
+        const updates = patch.map((entityPatch) => {
+            const id = this.getId(entityPatch);
+            const immId = this.keyToImmutable(id);
+            const existing = this.state.pk.get(immId);
+            let isDeleted = false;
+            let updated = entityPatch as TEntity;
+            if (existing) {
+                updated = { ...existing, ...entityPatch };
+
+                if (this.schema.deleteFlag) {
+                    isDeleted = (updated[this.schema.deleteFlag] as unknown) === true;
+                }
+            }
+
+            return {
+                id, immId, patch: entityPatch, existing, updated, isNew: !existing, isDeleted,
+            };
+        });
+
+        const idVal = Seq.Keyed<TId, TEntity>(updates.map((entity) => [entity.immId, entity.updated]));
+        let newPk = this.state.pk.merge(idVal);
+
+        // TBD: replace with deleteAll after migrating to immutable 4
+        updates
+            .filter((u) => u.isDeleted)
+            .forEach((u) => {
+                newPk = newPk.delete(u.immId);
+            });
+
+        const newIndexes = this.state.indexes.map((index) => {
+            let newMap = index.map;
+
+            for (let n = 0; n < updates.length; n++) {
+                const update = updates[n];
+
+                const newKey = update.updated[index.field];
+
+                if (update.existing) {
+                    const oldKey = update.existing[index.field];
+
+                    if (oldKey !== newKey || update.isDeleted) {
+                        newMap = newMap.update(oldKey, (set) => set.remove(update.immId));
+                    }
+                }
+
+                if (!update.isDeleted) {
+                    newMap = newMap.update(newKey, I.Set(), (set) => set.add(update.immId));
+                }
+            }
+
+            return { ...index, map: newMap };
+        });
+
+        const newState: DbTableState<TEntity, TTables> = { pk: newPk, indexes: newIndexes };
+
+        return this.update((t) => (t.state = newState));
+    }
+
+    /* Query */
+
+    public find(filter: DataQueryFilter<TEntity>): DbTable<TEntity, TId, TTables> {
+        return this.update((t) => (t.q = { ...t.q, filter: { ...(this.q.filter as any), ...(filter as any) } }));
+    }
+
+    public order(order: SortingOption[]) {
+        return this.update((t) => (t.q = { ...t.q, sorting: order }));
+    }
+
+    public orderBy(field: Extract<keyof TEntity, string>, direction: SortDirection = 'asc') {
+        return this.update((t) => (t.q = { ...t.q, sorting: [{ field, direction }] }));
+    }
+
+    public thenBy(field: Extract<keyof TEntity, string>, direction?: SortDirection) {
+        return this.update((t) => (t.q = { ...t.q, sorting: [...t.q.sorting, { field, direction }] }));
+    }
+
+    public search(text: string) {
+        if (!this.schema.searchBy) {
+            throw new Error(`Can't search in the ${this.schema.typeName} table - searchBy is not defined in the schema.`);
+        }
+        return this.update((t) => (t.q = { ...t.q, search: text }));
+    }
+
+    /* Materializing */
+
+    public range(from: number, count: number): TEntity[] {
+        return this.runQuery({ ...this.q, range: { from, count } });
+    }
+
+    public count() {
+        return this.runQuery(this.q).length;
+    }
+
+    public one(): TEntity {
+        return this.runQuery(this.q)[0] || null;
+    }
+
+    public toArray(): TEntity[] {
+        return this.runQuery(this.q);
+    }
+
+    public map<T>(fn: (item: TEntity, index?: number) => T) {
+        return this.toArray().map(fn);
+    }
+
+    /* Query implementation */
+
+    private runQuery(q: DataQuery<TEntity>) {
+        let result: TEntity[] = null;
+        let filter = q.filter;
+
+        if (filter) {
+            const indexes = this.state.indexes;
+
+            // Try to use indexes to fulfill filter conditions
+            for (let n = 0; n < indexes.length; n++) {
+                const index = indexes[n];
+
+                if (index.field in filter) {
+                    const { [index.field]: condition, ...rest } = filter as any;
+                    let conditionValues: any[] = null;
+
+                    if (condition != null && typeof condition === 'object') {
+                        // Attempt to use index for 'in' and 'isNull' criteria.
+                        // We need to be very conservative here, indexed field should work the same way as getPatternPredicate. So
+                        // - it's better to leave corner cases to getPatternPredicate
+
+                        const { in: inCriteria, isNull: nullCriteria, ...restCriteria } = condition as any;
+                        if (inCriteria && Array.isArray(inCriteria)) {
+                            conditionValues = inCriteria;
+                        } else {
+                            restCriteria.in = inCriteria;
+                        }
+
+                        // Conditions in getPatternPredicate are composed with 'and' logic,
+                        // For now, let's not attempt to handle tricky cases like { in: [1,2] isNull: true }, or { in: [1, null] isNull: false }
+                        // - just leave this to getPatternPredicate.
+                        // Let's just handle the a most common case { isNull: true } - find all null and undefined
+                        if (nullCriteria === true && !conditionValues) {
+                            conditionValues = [null, undefined];
+                        } else {
+                            restCriteria.in = inCriteria;
+                        }
+
+                        // Keep other conditions, e.g. { in: [1,2,3], isNull: true } - in works via index, isNull - via filter
+                        if (Object.keys(restCriteria).length > 0) {
+                            rest[index.field] = restCriteria;
+                        }
+                    } else {
+                        conditionValues = [condition];
+                    }
+
+                    if (conditionValues) {
+                        result = [];
+
+                        for (let i = 0; i < conditionValues.length; i++) {
+                            const idsSet = index.map.get(conditionValues[i]);
+                            if (idsSet) {
+                                const idsArray = idsSet.toArray();
+                                for (let j = 0; j < idsArray.length; j++) {
+                                    const item = this.state.pk.get(idsArray[j]);
+                                    result.push(item);
+                                }
+                            }
+                        }
+
+                        filter = Object.keys(rest).length > 0 ? (rest as any) : null;
+                        break;
+                    }
+                }
+            }
+        }
+
+        if (!result) {
+            result = this.state.pk.toArray();
+        }
+
+        if (filter) {
+            const predicate = getFilterPredicate<TEntity>(q.filter);
+            result = result.filter(predicate);
+        }
+
+        if (q.search) {
+            const searchFilter = getSearchFilter(q.search);
+            result = result.filter((item) => searchFilter(this.schema.searchBy.map((field) => (item as any)[field])));
+        }
+
+        if (q.sorting) {
+            const comparer = getOrderComparer(q.sorting);
+            result = result.sort(comparer);
+        }
+
+        if (q.range) {
+            result = result.slice(q.range.from, q.range.from + q.range.count);
+        }
+
+        return result;
+    }
+}

package/src/IxSet.ts

@@ -0,0 +1,251 @@
+import BTree from 'sorted-btree';
+import { DbQuery } from './types';
+import {
+    DataQueryFilterCondition, DataQueryFilter, getFilterPredicate,
+} from '@epam/uui-core';
+import orderBy from 'lodash.orderby';
+
+export interface IxSetIndexDefinition<TEntity> {
+    fields: (keyof TEntity)[];
+}
+
+const ID = Symbol('ID');
+
+type IndexKey<TEntity> = TEntity & { [ID]: any };
+
+export interface IxSetIndex<TEntity> extends IxSetIndexDefinition<TEntity> {
+    tree: BTree<IndexKey<TEntity>, void>;
+    compare: (a: IndexKey<TEntity>, b: IndexKey<TEntity>) => number;
+}
+
+// Filter condition types
+enum FilterConditionType {
+    Single = 1,
+    Multi = 2
+}
+
+function defaultComparator(a: any, b: any) {
+    if (a === null) return -1;
+    if (b === null) return 1;
+    if (a === -Infinity || b === Infinity) return -1;
+    if (b === Infinity || a === -Infinity) return 1;
+
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+
+function iterator<T>(next: () => { done: boolean; value?: T } = () => ({ done: true, value: undefined })): IterableIterator<T> {
+    const result: any = { next };
+    result[Symbol.iterator] = function () {
+        return this;
+    };
+    return result;
+}
+
+export class IxSet<TEntity, TId> {
+    empty: BTree<TId, TEntity>;
+    /** Primary key - a b-tree with entity ID as a key, and entity itself as a value */
+    pk: BTree<TId, TEntity>;
+    indexes: IxSetIndex<TEntity>[];
+    constructor(private getId: (e: Partial<TEntity>) => TId, indexesDefinition: IxSetIndexDefinition<TEntity>[]) {
+        this.empty = new BTree([]);
+        this.pk = this.empty;
+        this.indexes = indexesDefinition.map((definition) => {
+            const fields = definition.fields;
+            const compare = (a: IndexKey<TEntity>, b: IndexKey<TEntity>) => {
+                if (a === b) return 0;
+                if (a == null) return -1;
+                if (b == null) return 1;
+
+                for (let i = 0; i < fields.length; i++) {
+                    const field = fields[i];
+                    const result = defaultComparator(a[field], b[field]);
+                    if (result !== 0) {
+                        return result;
+                    }
+                }
+
+                return defaultComparator(a[ID], b[ID]);
+            };
+
+            return {
+                ...definition,
+                compare,
+                tree: new BTree<IndexKey<TEntity>>([], compare),
+            };
+        });
+    }
+
+    public clone() {
+        const blank = Object.create(IxSet.prototype) as IxSet<TEntity, TId>;
+        blank.empty = this.empty;
+        blank.getId = this.getId;
+        blank.pk = this.pk;
+        blank.indexes = this.indexes;
+        return blank;
+    }
+
+    public byId(id: TId): TEntity {
+        return this.pk.get(id);
+    }
+
+    public with(items: Partial<TEntity>[]): IxSet<TEntity, TId> {
+        const newSet = this.clone();
+        newSet.pk = this.pk.clone();
+
+        const updatedFields = {} as any;
+
+        const updates = items.map((patch) => {
+            const id = this.getId(patch);
+            const existing = this.pk.get(id);
+            let updated = patch as TEntity;
+            if (existing) {
+                updated = { ...existing, ...patch };
+            }
+            const existingIndexEntry = { ...existing, [ID]: id };
+            const updatedIndexEntry = { ...updated, [ID]: id };
+            Object.keys(patch).forEach((f) => {
+                updatedFields[f] = true;
+            });
+            return {
+                id, patch, existing, updated, existingIndexEntry, updatedIndexEntry,
+            };
+        });
+
+        updates.forEach((update) => newSet.pk.set(update.id, update.updated));
+
+        newSet.indexes = this.indexes.map((existingIndex) => {
+            if (existingIndex.fields.some((f) => updatedFields[f])) {
+                const newIndex = { ...existingIndex };
+                newIndex.tree = existingIndex.tree.clone();
+
+                const keysToRemove = updates.filter((u) => !!u.existing).map((u) => u.existingIndexEntry);
+                keysToRemove.sort(existingIndex.compare);
+                newIndex.tree.deleteKeys(keysToRemove);
+
+                const keysToAdd = updates.map((u) => u.updatedIndexEntry);
+                keysToAdd.sort(existingIndex.compare);
+                keysToAdd.forEach((key) => newIndex.tree.set(key));
+
+                return newIndex;
+            } else {
+                return existingIndex;
+            }
+        });
+
+        return newSet;
+    }
+
+    public query(query: DbQuery<TEntity>) {
+        const filter: DataQueryFilter<TEntity> = query.filter || {};
+        const filterFields = Object.keys(filter) as (keyof TEntity)[];
+        const filterFieldTypes = {} as Record<keyof TEntity, FilterConditionType>;
+        filterFields.forEach((f) => {
+            const condition = filter[f] as DataQueryFilterCondition<any>;
+            if (condition != null && typeof condition === 'object') {
+                if (condition.in) {
+                    filterFieldTypes[f] = FilterConditionType.Multi;
+                }
+            } else {
+                filterFieldTypes[f] = FilterConditionType.Single;
+            }
+        });
+
+        let plans = this.indexes
+            .map((index) => {
+                if (filterFieldTypes[index.fields[0]]) {
+                    let matchCount = 0;
+                    const from: IndexKey<TEntity> = { [ID]: -Infinity } as any;
+                    const to: IndexKey<TEntity> = { [ID]: +Infinity } as any;
+                    const lookupFields = {} as Record<keyof TEntity, boolean>;
+                    let isRemainingUnused = false;
+
+                    for (let i = 0; i < index.fields.length; i++) {
+                        const field: keyof TEntity = index.fields[i];
+                        if (!isRemainingUnused && filterFieldTypes[field] === FilterConditionType.Single) {
+                            lookupFields[field] = true;
+                            from[field] = filter[field] as any;
+                            to[field] = filter[field] as any;
+                            matchCount++;
+                        } else {
+                            isRemainingUnused = true;
+                            from[field] = -Infinity as any;
+                            to[field] = Infinity as any;
+                        }
+                    }
+
+                    let remainingFilter: DataQueryFilter<TEntity> = null;
+                    filterFields
+                        .filter((f) => !lookupFields[f])
+                        .forEach((f) => {
+                            if (!remainingFilter) {
+                                remainingFilter = {};
+                            }
+                            remainingFilter[f] = filter[f];
+                        });
+
+                    const score = matchCount;
+                    if (matchCount > 0) {
+                        return {
+                            score, index, from, to, remainingFilter,
+                        };
+                    }
+                }
+
+                return null;
+            })
+            .filter((p) => p != null);
+
+        plans = orderBy(plans, 'score', 'desc');
+        const plan = plans[0];
+
+        // const indexEntities = plan.index.tree.entries();
+
+        let treeIterator: IterableIterator<TEntity>;
+
+        if (plan) {
+            const indexIterator = plan.index.tree.entries(plan.from);
+            treeIterator = iterator(() => {
+                const next = indexIterator.next() as any;
+                if (!next.value) {
+                    return next;
+                }
+                next.value = next.value[0];
+                if (plan.index.compare(next.value, plan.to) > 0) {
+                    next.done = true;
+                    next.value = null;
+                    return next;
+                }
+                next.value = this.pk.get(next.value[ID]);
+                return next;
+            });
+        } else {
+            treeIterator = this.pk.values();
+        }
+
+        const result: TEntity[] = [];
+
+        const filterPredicate = getFilterPredicate(plan ? plan.remainingFilter : filter);
+
+        let current;
+        let index = 0;
+        let count = 0;
+        const rangeFrom = (query.range && query.range.from) || 0;
+        const rangeCount = (query.range && query.range.count) || Number.MAX_SAFE_INTEGER;
+        while (!(current = treeIterator.next()).done && count < rangeCount) {
+            const entity: TEntity = current.value;
+            const passedFilter = !filterPredicate || filterPredicate(entity);
+
+            if (passedFilter && index >= rangeFrom) {
+                result.push(entity);
+                count++;
+            }
+            index++;
+        }
+
+        return result;
+    }
+
+    public queryOne(query: DbQuery<TEntity>) {
+        return this.query(query)[0];
+    }
+}

package/src/ListLoadingTracker.ts

@@ -0,0 +1,131 @@
+import { DataQuery, LazyDataSourceApiResponse } from '@epam/uui-core';
+import { ILoadingTracker } from './types';
+
+interface ListRecord<TItem> {
+    options: DataQuery<TItem>;
+    count: number;
+    maxCount: number;
+    isComplete: boolean;
+}
+
+export interface ListLoadingTrackerOptions<TItem, TResponse> {
+    extractList?: (response: TResponse) => LazyDataSourceApiResponse<TItem>;
+}
+
+export class ListLoadingTracker<TItem, TRequest extends DataQuery<TItem> = DataQuery<TItem>, TResponse = LazyDataSourceApiResponse<TItem>>
+implements ILoadingTracker<TRequest, TResponse> {
+    private cache: Map<string, ListRecord<TItem>> = new Map();
+    private extractList: (res: TResponse) => LazyDataSourceApiResponse<TItem>;
+    constructor(private options?: ListLoadingTrackerOptions<TItem, TResponse>) {
+        this.extractList = options?.extractList || ((r: any) => r);
+    }
+
+    private prepare(request: DataQuery<TItem>) {
+        const {
+            filter, sorting, search, range, ...unknownFields
+        } = request;
+        const options: DataQuery<TItem> = {};
+
+        if (filter) {
+            options.filter = filter;
+        }
+
+        if (sorting) {
+            options.sorting = sorting;
+        }
+
+        if (search) {
+            options.search = search;
+        }
+
+        const keyObject = { ...options, ...unknownFields };
+
+        const key = JSON.stringify(keyObject);
+        let entry = this.cache.get(key);
+        if (!entry) {
+            entry = {
+                options, count: 0, maxCount: null, isComplete: false,
+            };
+            this.cache.set(key, entry);
+        }
+
+        return {
+            options, range, unknownFields, entry,
+        };
+    }
+
+    public diff(request: TRequest): TRequest {
+        const {
+            options, range, unknownFields, entry,
+        } = this.prepare(request);
+
+        if (entry.isComplete) {
+            return null;
+        }
+
+        if (!request.range) {
+            return request;
+        } else {
+            const requestedMax = request.range.from + request.range.count;
+            let missingCount = requestedMax - entry.count;
+
+            if (entry.maxCount) {
+                missingCount = Math.min(missingCount, entry.maxCount);
+            }
+
+            if (missingCount > 0) {
+                return {
+                    ...options,
+                    ...unknownFields,
+                    range: { from: entry.count, count: requestedMax - entry.count },
+                } as TRequest;
+            } else {
+                return null;
+            }
+        }
+    }
+
+    public count(request: TRequest) {
+        const { entry } = this.prepare(request);
+
+        return { knownCount: Math.max(entry.count, entry.maxCount), exactCount: entry.maxCount };
+    }
+
+    public append(request: TRequest, response?: TResponse) {
+        const {
+            options, range, unknownFields, entry,
+        } = this.prepare(request);
+
+        if (response) {
+            const list = this.extractList(response);
+
+            if (list.count) {
+                entry.maxCount = list.count;
+            }
+
+            if (!range) {
+                entry.count = list.items.length;
+                entry.maxCount = list.items.length;
+                entry.isComplete = true;
+            } else {
+                const from = list.from == null ? range.from : list.from;
+
+                if (list.items.length > 0) {
+                    entry.count = Math.max(entry.count, from + list.items.length);
+                }
+
+                if (list.items.length < range.count) {
+                    entry.maxCount = from + list.items.length;
+                    entry.count = entry.maxCount;
+                    entry.isComplete = true;
+                }
+            }
+        } else {
+            if (range) {
+                entry.count = Math.max(entry.count, request.range.from + request.range.count);
+            } else {
+                entry.isComplete = true;
+            }
+        }
+    }
+}