@epam/uui-db 4.11.0-alpha.1 → 5.0.0-alpha.0

package/index.esm.js

@@ -0,0 +1,1061 @@
+import shallowEqual from 'shallowequal';
+import zip from 'lodash.zip';
+import transform from 'lodash.transform';
+import isEqual from 'lodash.isequal';
+import * as I from 'immutable';
+import { Seq } from 'immutable';
+import { getFilterPredicate, getSearchFilter, getOrderComparer, batch } from '@epam/uui-core';
+import groupBy from 'lodash.groupby';
+import map from 'lodash.map';
+import merge from 'lodash.merge';
+import countBy from 'lodash.countby';
+import filter from 'lodash.filter';
+import forEach from 'lodash.foreach';
+import pick from 'lodash.pick';
+import isEmpty from 'lodash.isempty';
+import { createContext, useContext, useState, useMemo, useEffect } from 'react';
+
+var DbRelationType;
+(function (DbRelationType) {
+    DbRelationType[DbRelationType["Aggregation"] = 0] = "Aggregation";
+    DbRelationType[DbRelationType["Association"] = 1] = "Association";
+})(DbRelationType || (DbRelationType = {}));
+
+// TBD: New typescript would contain better typing for this. Remove this hack after update.
+let objectKeys = Object.keys;
+function defaultCompareViewDependencies(prev, next) {
+    if (Array.isArray(prev) && Array.isArray(next)) {
+        if (prev.length === next.length) {
+            return zip(prev, next).every(([p, n]) => shallowEqual(p, n));
+        }
+        return false;
+    }
+    return shallowEqual(prev, next);
+}
+/**
+ * Deep diff between two object, using lodash
+ * @param  {Object} object Object compared
+ * @param  {Object} base   Object to compare with
+ * @return {Object}        Return a new object who represent the diff
+ */
+function difference(object, base) {
+    function changes(object, base) {
+        return transform(object, function (result, value, key) {
+            if (!isEqual(value, base[key])) {
+                result[key] = (typeof value === "object" && typeof base[key] === "object") ? changes(value, base[key]) : value;
+            }
+        });
+    }
+    return changes(object, base);
+}
+
+class Db {
+    constructor(tables, reusedCache) {
+        this.tables = tables;
+        this.viewCache = new Map();
+        /* Views (cached db projections) */
+        this.valueAbsent = Symbol("ValueAbsent");
+        if (reusedCache) {
+            this.viewCache = new Map(reusedCache);
+        }
+        else {
+            this.viewCache = new Map();
+        }
+    }
+    update(mutate) {
+        const clone = new this.constructor(this.tables, this.viewCache);
+        clone.tables = Object.assign({}, this.tables);
+        mutate(clone);
+        return clone;
+    }
+    with(patch) {
+        return this.update(db => {
+            objectKeys(db.tables).forEach(entityName => {
+                if (patch[entityName]) {
+                    db.tables[entityName] = db.tables[entityName].with(patch[entityName]);
+                }
+            });
+        });
+    }
+    runView(view, params) {
+        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 = 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 = this.valueAbsent;
+        if (view.getDependencies) {
+            const compare = view.compareDependencies || defaultCompareViewDependencies;
+            dependencies = view.getDependencies(this, params);
+            shouldUpdate = !compare(cacheItem.dependencies, dependencies);
+        }
+        let previousValue = cacheItem.currentValue;
+        if (shouldUpdate) {
+            cacheItem.dependencies = dependencies;
+            let newValue = view.compute(this, params, dependencies);
+            cacheItem.computedOnDb = this;
+            let compareResults = view.compareResults || isEqual;
+            if (!compareResults(previousValue, newValue)) {
+                if (view.traceDiff) {
+                    console.debug(difference(previousValue, newValue));
+                }
+                cacheItem.currentValue = newValue;
+            }
+        }
+        return cacheItem.currentValue;
+    }
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+class DbTable {
+    constructor(schema, state, q) {
+        this.schema = schema;
+        this.state = state;
+        this.q = q;
+        if (!state) {
+            const indexes = (schema.indexes || []).map(indexDef => {
+                return {
+                    field: indexDef,
+                    map: I.Map(),
+                };
+            });
+            this.state = { pk: I.Map(), indexes };
+        }
+        if (!q) {
+            this.q = {};
+        }
+    }
+    keyToImmutable(id) {
+        if (Array.isArray(id)) {
+            return I.List(id);
+        }
+        else {
+            return id;
+        }
+    }
+    byId(id) {
+        return this.state.pk.get(this.keyToImmutable(id));
+    }
+    getId(entity) {
+        if (Array.isArray(this.schema.primaryKey)) {
+            return this.schema.primaryKey.map((key) => entity[key]);
+        }
+        return entity[this.schema.primaryKey];
+    }
+    update(mutate) {
+        const clone = new this.constructor(this.schema, this.state, this.q);
+        mutate(clone);
+        return clone;
+    }
+    /* Mutation */
+    with(patch) {
+        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;
+            if (existing) {
+                updated = Object.assign(Object.assign({}, existing), entityPatch);
+                if (this.schema.deleteFlag) {
+                    isDeleted = updated[this.schema.deleteFlag] === true;
+                }
+            }
+            return { id, immId, patch: entityPatch, existing, updated, isNew: !existing, isDeleted };
+        });
+        const idVal = Seq.Keyed(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++) {
+                let 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 Object.assign(Object.assign({}, index), { map: newMap });
+        });
+        const newState = { pk: newPk, indexes: newIndexes };
+        return this.update(t => t.state = newState);
+    }
+    /* Query */
+    find(filter) {
+        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { filter: Object.assign(Object.assign({}, this.q.filter), filter) }));
+    }
+    order(order) {
+        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { sorting: order }));
+    }
+    orderBy(field, direction = 'asc') {
+        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { sorting: [{ field, direction }] }));
+    }
+    thenBy(field, direction) {
+        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { sorting: [...t.q.sorting, { field, direction }] }));
+    }
+    search(text) {
+        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 = Object.assign(Object.assign({}, t.q), { search: text }));
+    }
+    /* Materializing */
+    range(from, count) {
+        return this.runQuery(Object.assign(Object.assign({}, this.q), { range: { from, count } }));
+    }
+    count() {
+        return this.runQuery(this.q).length;
+    }
+    one() {
+        return this.runQuery(this.q)[0] || null;
+    }
+    toArray() {
+        return this.runQuery(this.q);
+    }
+    map(fn) {
+        return this.toArray().map(fn);
+    }
+    /* Query implementation */
+    runQuery(q) {
+        let result = null;
+        let filter = q.filter;
+        if (filter) {
+            let 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 _a = filter, _b = index.field, condition = _a[_b], rest = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+                    let conditionValues = 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 _c = condition, { in: inCriteria, isNull: nullCriteria } = _c, restCriteria = __rest(_c, ["in", "isNull"]);
+                        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 : null;
+                        break;
+                    }
+                }
+            }
+        }
+        if (!result) {
+            result = this.state.pk.toArray();
+        }
+        if (filter) {
+            let predicate = getFilterPredicate(q.filter);
+            result = result.filter(predicate);
+        }
+        if (q.search) {
+            let searchFilter = getSearchFilter(q.search);
+            result = result.filter(item => searchFilter(this.schema.searchBy.map(field => item[field])));
+        }
+        if (q.sorting) {
+            let 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;
+    }
+}
+
+function unionPatches(patches) {
+    const result = {};
+    patches.forEach(patch => {
+        objectKeys(patch).forEach(tableName => {
+            result[tableName] = result[tableName] ? [...result[tableName], ...patch[tableName]] : patch[tableName];
+        });
+    });
+    return result;
+}
+function mergeEntityPatches(tables, patch) {
+    const result = {};
+    objectKeys(patch).forEach(key => {
+        const table = tables[key];
+        const groupedEntities = groupBy(patch[key], item => table.getId(item));
+        const tablePatch = map(groupedEntities, entities => {
+            const result = merge({}, ...entities);
+            if (process.env.NODE_ENV !== 'production') {
+                const props = objectKeys(result).filter(prop => Object.keys(countBy(entities.filter(entity => entity[prop] !== undefined), entity => entity[prop])).length > 1);
+                if (props.length) {
+                    console.warn('mergeEntityPatches: Different property values found for the same entity.\nProperty names:\n', props, '\nEntities:\n', ...entities);
+                }
+            }
+            return result;
+        });
+        result[key] = tablePatch;
+    });
+    return result;
+}
+function flattenResponseHelper(result, object, tablesByTypeName) {
+    if (Array.isArray(object)) {
+        object.forEach(item => flattenResponseHelper(result, item, tablesByTypeName));
+    }
+    else if (typeof object === 'object') {
+        const clone = {};
+        let tableKey;
+        let fields = {};
+        if ('__typename' in object) {
+            const table = tablesByTypeName[object.__typename];
+            if (table) {
+                tableKey = table.schema.tableName;
+                fields = table.schema.fields;
+            }
+        }
+        for (let key in object) {
+            const value = object[key];
+            const field = fields[key];
+            if ((field && !!field.disableFlatten)
+                || typeof value !== 'object'
+                || value === null
+                || (Array.isArray(value) && value.every(item => typeof item !== 'object'))) {
+                clone[key] = value;
+            }
+            else {
+                flattenResponseHelper(result, value, tablesByTypeName);
+            }
+        }
+        if (tableKey) {
+            result[tableKey].push(clone);
+        }
+    }
+}
+function flattenResponse(response, tables) {
+    const result = {};
+    let tablesByTypeName = {};
+    Object.values(tables).forEach(table => tablesByTypeName[table.schema.typeName] = table);
+    objectKeys(tables).forEach(tableName => tablesByTypeName);
+    objectKeys(tables).forEach(key => result[key] = []);
+    flattenResponseHelper(result, response, tablesByTypeName);
+    return result;
+}
+function isPatchBlank(patch) {
+    return !objectKeys(patch).some(key => patch[key].length > 0);
+}
+/**
+ * Given several patches, creates a new single patch with all fields from all entities in all patches.
+ */
+function makeCumulativePatch(updatedDb, patches, clientIdsMap) {
+    const result = {};
+    objectKeys(updatedDb.tables).forEach(entityName => {
+        const table = updatedDb.tables[entityName];
+        const schema = table.schema;
+        let ids = I.Set();
+        patches.forEach(patch => {
+            let filteredPatch = (patch[entityName] || []).filter(entity => hasServerFields(entity, schema, clientIdsMap, updatedDb.tables));
+            ids = ids.union(filteredPatch.map(e => table.getId(e)));
+        });
+        const entities = ids
+            .map(id => table.byId(id))
+            .filter(e => !isClientOnly(e, schema))
+            .toArray();
+        if (entities.length > 0) {
+            result[entityName] = entities;
+        }
+    });
+    return result;
+}
+function isClientOnly(entity, schema) {
+    if (typeof schema.isClientOnly === 'function') {
+        return schema.isClientOnly(entity);
+    }
+    return !!schema.isClientOnly;
+}
+function getId(entity, schema) {
+    if (typeof schema.primaryKey == 'string') {
+        return entity[schema.primaryKey];
+    }
+    const result = [];
+    forEach(pick(entity, schema.primaryKey), (value) => {
+        result.push(value);
+    });
+    return result;
+}
+function isNew(entity, schema, clientIdsMap) {
+    const id = getId(entity, schema);
+    return !clientIdsMap.clientToServer(id);
+}
+function hasServerFields(entity, schema, clientIdsMap, tables) {
+    const fullEntity = Object.assign(Object.assign({}, tables[schema.tableName].byId(entity.id) || {}), entity);
+    if (isClientOnly(fullEntity, schema)) {
+        return false;
+    }
+    return objectKeys(entity).some(fieldName => {
+        const fieldSchema = schema.fields[fieldName];
+        return !fieldSchema || !(fieldSchema.isClientOnly || fieldSchema.isReadOnly || (fieldSchema.isGenerated && !isNew(entity, schema, clientIdsMap)));
+    });
+}
+function getParentEntities(patch, tables) {
+    const dependenciesPatch = {};
+    objectKeys(patch).forEach(key => {
+        const table = tables[key];
+        const tableSchema = table.schema;
+        const fields = filter(map(tableSchema.fields, (field, name) => (Object.assign(Object.assign({}, field), { name }))), field => field.fk && field.fk.relationType == DbRelationType.Aggregation);
+        const tablePatch = patch[key];
+        fields.forEach(field => {
+            const { fk: { tableName }, name } = field;
+            tablePatch.forEach(entity => {
+                const actualTableName = (typeof tableName == 'function' ? tableName(entity) : tableName);
+                const dbEntity = table.byId(table.getId(entity));
+                const parentEntity = tables[actualTableName].byId(dbEntity[name]);
+                const idFields = pick(parentEntity, tables[actualTableName].schema.primaryKey);
+                if (parentEntity) {
+                    dependenciesPatch[actualTableName] = dependenciesPatch[actualTableName] || [];
+                    dependenciesPatch[actualTableName].push(idFields);
+                }
+            });
+        });
+    });
+    return dependenciesPatch;
+}
+function getEntityParentDependencies(entity, entityName, tables) {
+    let patch = { [entityName]: [entity] };
+    const resultPatches = [];
+    while (true) {
+        let parents = getParentEntities(patch, tables);
+        if (isPatchBlank(parents)) {
+            break;
+        }
+        resultPatches.push(parents);
+        patch = parents;
+    }
+    let result = unionPatches([patch, ...resultPatches]);
+    result = mergeEntityPatches(tables, result);
+    return result;
+}
+
+let lastTempId = -1;
+function getTempId() {
+    return --lastTempId;
+}
+function isTempId(val) {
+    return typeof val === 'number' && val < 0;
+}
+class TempIdMap {
+    constructor(db) {
+        this.db = db;
+        this.serverToClientIds = new Map();
+        this.clientToServerIds = new Map();
+        this.clientToServer = (id) => this.clientToServerIds.get(id);
+        this.serverToClient = (tableName, id) => this.getServerToClientMap(tableName).get(id);
+        this.clientToServerRequest = (request) => {
+            request = Object.assign({}, request);
+            if (request.filter) {
+                request.filter = this.clientToServerDataFilter(request.filter);
+            }
+            return request;
+        };
+        this.clientToServerDataFilter = (filter) => {
+            filter = Object.assign({}, filter);
+            const keys = Object.keys(filter);
+            // I hope that we can rely that there won't be any negative numbers, which are not IDs, in queries.
+            // We need to invent better heuristics or a schema otherwise.
+            const clientToServer = (id) => {
+                const found = this.clientToServer(id);
+                if (found) {
+                    return found;
+                }
+                else {
+                    return id;
+                }
+            };
+            for (let n = 0; n < keys.length; n++) {
+                const key = keys[n];
+                let condition = filter[key];
+                if (condition != null && typeof condition === "object") {
+                    condition = Object.assign({}, condition);
+                    if ('in' in condition && Array.isArray(condition.in) && condition.in.length) {
+                        condition.in = condition.in.map(clientToServer);
+                    }
+                }
+                else {
+                    condition = clientToServer(condition);
+                }
+                filter[key] = condition;
+            }
+            return filter;
+        };
+    }
+    copyPatch(patch) {
+        const newPatch = Object.assign({}, patch);
+        objectKeys(patch).forEach(tableName => {
+            let tablePatch = patch[tableName].map(entityPatch => (Object.assign({}, entityPatch)));
+            newPatch[tableName] = tablePatch;
+        });
+        return newPatch;
+    }
+    // Iterate thru every field in every patch for every table, matching certain field criteria. The patch is mutated!
+    mapFields(patch, filter, callback) {
+        objectKeys(patch).forEach(tableName => {
+            const schema = this.db.tables[tableName].schema;
+            const fields = objectKeys(schema.fields || [])
+                .map(fieldName => {
+                const fieldSchema = schema.fields[fieldName];
+                if (filter(fieldSchema, fieldName)) {
+                    return { name: fieldName, schema: fieldSchema };
+                }
+            })
+                .filter(f => !!f);
+            if (!fields.length) {
+                return;
+            }
+            patch[tableName].forEach(entityPatch => {
+                for (let n = 0; n < fields.length; n++) {
+                    const field = fields[n];
+                    const fieldValue = entityPatch[field.name];
+                    callback(field.name, field.schema, fieldValue, entityPatch, tableName);
+                }
+            });
+        });
+    }
+    getServerToClientMap(tableName) {
+        const existing = this.serverToClientIds.get(tableName);
+        if (existing) {
+            return existing;
+        }
+        else {
+            const newMap = new Map();
+            this.serverToClientIds.set(tableName, newMap);
+            return newMap;
+        }
+    }
+    serverToClientPatch(patch) {
+        patch = this.copyPatch(patch);
+        // We map PK in a separate pass, as we need to remap all PKs before re-mapping FKs
+        this.mapFields(patch, f => f.isGenerated, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
+            let clientId = this.getServerToClientMap(tableName).get(fieldValue);
+            if (!clientId) {
+                clientId = getTempId();
+                this.clientToServerIds.set(clientId, fieldValue);
+                this.getServerToClientMap(tableName).set(fieldValue, clientId);
+            }
+            entityPatch[fieldName] = clientId;
+        });
+        this.mapFields(patch, f => !!(f.fk || (f.default != null) || f.toClient), (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
+            let isUndefined = typeof (fieldValue) === 'undefined';
+            if (fieldSchema.default != null && fieldValue == null) {
+                fieldValue = fieldSchema.default;
+                isUndefined = false;
+            }
+            if (fieldSchema.fk && fieldValue != null) {
+                const fkTableName = typeof fieldSchema.fk.tableName === 'function' ? fieldSchema.fk.tableName(entityPatch) : fieldSchema.fk.tableName;
+                let clientId = this.getServerToClientMap(fkTableName).get(fieldValue);
+                if (!clientId) {
+                    clientId = getTempId();
+                    this.clientToServerIds.set(clientId, fieldValue);
+                    this.getServerToClientMap(fkTableName).set(fieldValue, clientId);
+                }
+                fieldValue = clientId;
+            }
+            if (!isUndefined && fieldSchema.toClient) {
+                fieldValue = fieldSchema.toClient(fieldValue);
+            }
+            if (!isUndefined) {
+                entityPatch[fieldName] = fieldValue;
+            }
+        });
+        return patch;
+    }
+    clientToServerPatch(patch) {
+        patch = this.copyPatch(patch);
+        this.mapFields(patch, f => f.isGenerated || !!f.fk, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
+            if (fieldValue != null) {
+                const existingId = this.clientToServerIds.get(fieldValue);
+                if (existingId) {
+                    entityPatch[fieldName] = existingId;
+                }
+            }
+        });
+        this.mapFields(patch, f => !(f.isClientOnly || f.isReadOnly) && !!f.toServer, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
+            entityPatch[fieldName] = fieldSchema.toServer(entityPatch[fieldName]);
+        });
+        this.mapFields(patch, meta => meta.isClientOnly || meta.isReadOnly, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
+            delete entityPatch[fieldName];
+        });
+        return patch;
+    }
+    appendServerMapping(response) {
+        objectKeys(response.submit).forEach(tableName => {
+            if (this.db.tables[tableName]) {
+                const tablePatch = response.submit[tableName];
+                if (tablePatch) {
+                    const serverToClientIds = this.getServerToClientMap(tableName);
+                    const table = this.db.tables[tableName];
+                    tablePatch.forEach(patch => {
+                        if (isTempId(patch.id)) {
+                            const clientId = patch.id;
+                            const serverId = table.getId(patch.payload);
+                            serverToClientIds.set(serverId, clientId);
+                            this.clientToServerIds.set(clientId, serverId);
+                        }
+                    });
+                }
+            }
+        });
+    }
+}
+
+class Loader {
+    constructor(dbRef, getTracker, options) {
+        this.dbRef = dbRef;
+        this.getTracker = getTracker;
+        this.options = options;
+        this.currentRequests = new Set();
+        this.load = (inputRequest) => {
+            const result = {
+                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;
+                }
+            }
+        };
+        this.loaded = getTracker();
+        this.loadedAndLoading = getTracker();
+    }
+    loadImpl(state) {
+        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;
+    }
+}
+
+class SimpleLoadingTracker {
+    constructor() {
+        this.set = new Set();
+    }
+    getKey(request) {
+        return JSON.stringify(request);
+    }
+    diff(request) {
+        return this.set.has(this.getKey(request)) ? null : request;
+    }
+    append(request, result) {
+        this.set.add(this.getKey(request));
+    }
+}
+
+class ListLoadingTracker {
+    constructor(options) {
+        this.options = options;
+        this.cache = new Map();
+        this.extractList = (options === null || options === void 0 ? void 0 : options.extractList) || ((r) => r);
+    }
+    prepare(request) {
+        const { filter, sorting, search, range } = request, unknownFields = __rest(request, ["filter", "sorting", "search", "range"]);
+        const options = {};
+        if (filter) {
+            options.filter = filter;
+        }
+        if (sorting) {
+            options.sorting = sorting;
+        }
+        if (search) {
+            options.search = search;
+        }
+        let keyObject = Object.assign(Object.assign({}, 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 };
+    }
+    diff(request) {
+        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 Object.assign(Object.assign(Object.assign({}, options), unknownFields), { range: { from: entry.count, count: requestedMax - entry.count } });
+            }
+            else {
+                return null;
+            }
+        }
+    }
+    count(request) {
+        const { entry } = this.prepare(request);
+        return { knownCount: Math.max(entry.count, entry.maxCount), exactCount: entry.maxCount };
+    }
+    append(request, response) {
+        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;
+            }
+        }
+    }
+}
+
+class DbRef {
+    constructor(blank) {
+        this.blank = blank;
+        this.log = [];
+        this.autoSave = true;
+        this.savedPoint = 0;
+        this.throttleSaveMs = 1000;
+        /* Update subscriptions (aka live views) */
+        this.lastSubscriptionId = 1;
+        this.subscriptions = new Map();
+        this.updateHandlers = [];
+        /* Error Subscriptions */
+        this.saveErrorHandlers = [];
+        /* Save scheduling */
+        this.enqueueSave = batch(() => __awaiter(this, void 0, void 0, function* () {
+            const cumulativePatch = this.makeCumulativePatch();
+            const lastLogEntry = this.log.length;
+            if (isEmpty(cumulativePatch)) {
+                return;
+            }
+            try {
+                const response = yield this.savePatch(cumulativePatch);
+                this.applyResponse(response, lastLogEntry);
+                this.update();
+            }
+            catch (error) {
+                this.saveError(cumulativePatch, error);
+                this.update();
+                throw error;
+            }
+        }));
+        this.handleBeforeUnload = (e) => {
+            if (this.enqueueSave.isBusy) {
+                e.returnValue = false;
+                return false;
+            }
+        };
+        this.loaders = [];
+        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. */
+    save() {
+        return this.enqueueSave();
+    }
+    getAutoSave() {
+        return this.autoSave;
+    }
+    setAutoSave(val) {
+        if (this.autoSave != val) {
+            this.autoSave = val;
+            this.autoSave && this.enqueueSave();
+            this.update();
+        }
+    }
+    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 */
+    savePatch(patch) {
+        return Promise.resolve({ submit: {} });
+    }
+    /* Db Update logic */
+    commit(patch) {
+        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();
+    }
+    beforeUpdate(patch, tables, prevTables) {
+        let patchAndDependencies = {};
+        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;
+            let context = {
+                clientIdsMap: this.tempIdMap,
+                schema,
+                tables,
+                prevTables,
+            };
+            const results = patch[entityName].map(e => beforeUpdate(e, context));
+            const updatedPatch = { [entityName]: results.map(result => result.entity) };
+            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;
+    }
+    commitFetch(patch) {
+        patch = this.tempIdMap.serverToClientPatch(patch);
+        this.rebase(this.base.with(patch));
+        this.update();
+    }
+    rebase(newBase) {
+        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);
+        }
+    }
+    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;
+    }
+    applyResponse(response, newSavedPoint) {
+        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);
+    }
+    subscribe(view, params, onUpdate) {
+        const id = this.lastSubscriptionId++;
+        const subscription = {
+            update: (params) => {
+                subscription.currentParams = params;
+                subscription.currentValue = this.db.runView(view, params);
+                return subscription.currentValue;
+            },
+            currentParams: null,
+            currentValue: null,
+            onUpdate,
+            unsubscribe: () => { this.subscriptions.delete(id); },
+        };
+        subscription.update(params);
+        this.subscriptions.set(id, subscription);
+        return subscription;
+    }
+    onUpdate(handler) {
+        this.subscribe({
+            compute: db => db,
+            compareResults: (a, b) => a === b,
+        }, null, handler);
+    }
+    update() {
+        this.subscriptions.forEach(subscription => {
+            const previousValue = subscription.currentValue;
+            subscription.update(subscription.currentParams);
+            if (subscription.currentValue !== previousValue && subscription.onUpdate) {
+                subscription.onUpdate(subscription.currentValue);
+            }
+        });
+    }
+    onSaveError(handler) {
+        this.saveErrorHandlers.push(handler);
+    }
+    saveError(request, error) {
+        this.saveErrorHandlers.forEach(handler => handler(request, error));
+    }
+    makeLoader(options) {
+        const loader = new Loader(this, () => new SimpleLoadingTracker(), options);
+        this.loaders.push(loader);
+        return loader;
+    }
+    makeListLoader(options) {
+        const loader = new Loader(this, () => new ListLoadingTracker(), options);
+        this.loaders.push(loader);
+        return loader;
+    }
+    reload() {
+        this.loaders = [];
+    }
+}
+
+const DbContext = createContext(null);
+function useDbRef() {
+    return useContext(DbContext);
+}
+function useDbView(fn, params, options) {
+    const dbRef = useDbRef();
+    const [state, setState] = useState();
+    const subscription = useMemo(() => dbRef.subscribe(Object.assign({ compute: fn }, options), params, setState), []);
+    subscription.update(params);
+    useEffect(() => {
+        return () => subscription.unsubscribe();
+    }, []);
+    return subscription.currentValue;
+}
+
+export { Db, DbContext, DbRef, DbRelationType, DbTable, TempIdMap, defaultCompareViewDependencies, difference, flattenResponse, getEntityParentDependencies, getId, getParentEntities, getTempId, hasServerFields, isClientOnly, isNew, isPatchBlank, isTempId, makeCumulativePatch, mergeEntityPatches, objectKeys, unionPatches, useDbRef, useDbView };
+//# sourceMappingURL=index.esm.js.map