@epam/uui-db 5.0.0-alpha.0 → 5.0.0-alpha.2

package/index.esm.js

@@ -22,7 +22,7 @@ var DbRelationType;
 })(DbRelationType || (DbRelationType = {}));
 
 // TBD: New typescript would contain better typing for this. Remove this hack after update.
-let objectKeys = Object.keys;
+const objectKeys = Object.keys;
 function defaultCompareViewDependencies(prev, next) {
     if (Array.isArray(prev) && Array.isArray(next)) {
         if (prev.length === next.length) {
@@ -42,7 +42,7 @@ 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;
+                result[key] = typeof value === 'object' && typeof base[key] === 'object' ? changes(value, base[key]) : value;
             }
         });
     }
@@ -54,7 +54,7 @@ class Db {
         this.tables = tables;
         this.viewCache = new Map();
         /* Views (cached db projections) */
-        this.valueAbsent = Symbol("ValueAbsent");
+        this.valueAbsent = Symbol('ValueAbsent');
         if (reusedCache) {
             this.viewCache = new Map(reusedCache);
         }
@@ -69,8 +69,8 @@ class Db {
         return clone;
     }
     with(patch) {
-        return this.update(db => {
-            objectKeys(db.tables).forEach(entityName => {
+        return this.update((db) => {
+            objectKeys(db.tables).forEach((entityName) => {
                 if (patch[entityName]) {
                     db.tables[entityName] = db.tables[entityName].with(patch[entityName]);
                 }
@@ -100,12 +100,12 @@ class Db {
             dependencies = view.getDependencies(this, params);
             shouldUpdate = !compare(cacheItem.dependencies, dependencies);
         }
-        let previousValue = cacheItem.currentValue;
+        const previousValue = cacheItem.currentValue;
         if (shouldUpdate) {
             cacheItem.dependencies = dependencies;
-            let newValue = view.compute(this, params, dependencies);
+            const newValue = view.compute(this, params, dependencies);
             cacheItem.computedOnDb = this;
-            let compareResults = view.compareResults || isEqual;
+            const compareResults = view.compareResults || isEqual;
             if (!compareResults(previousValue, newValue)) {
                 if (view.traceDiff) {
                     console.debug(difference(previousValue, newValue));
@@ -160,7 +160,7 @@ class DbTable {
         this.state = state;
         this.q = q;
         if (!state) {
-            const indexes = (schema.indexes || []).map(indexDef => {
+            const indexes = (schema.indexes || []).map((indexDef) => {
                 return {
                     field: indexDef,
                     map: I.Map(),
@@ -196,7 +196,7 @@ class DbTable {
     }
     /* Mutation */
     with(patch) {
-        const updates = patch.map(entityPatch => {
+        const updates = patch.map((entityPatch) => {
             const id = this.getId(entityPatch);
             const immId = this.keyToImmutable(id);
             const existing = this.state.pk.get(immId);
@@ -208,52 +208,56 @@ class DbTable {
                     isDeleted = updated[this.schema.deleteFlag] === true;
                 }
             }
-            return { id, immId, patch: entityPatch, existing, updated, isNew: !existing, isDeleted };
+            return {
+                id, immId, patch: entityPatch, existing, updated, isNew: !existing, isDeleted,
+            };
         });
-        const idVal = Seq.Keyed(updates.map(entity => [entity.immId, entity.updated]));
+        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 => {
+        updates
+            .filter((u) => u.isDeleted)
+            .forEach((u) => {
             newPk = newPk.delete(u.immId);
         });
-        const newIndexes = this.state.indexes.map(index => {
+        const newIndexes = this.state.indexes.map((index) => {
             let newMap = index.map;
             for (let n = 0; n < updates.length; n++) {
-                let update = updates[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));
+                        newMap = newMap.update(oldKey, (set) => set.remove(update.immId));
                     }
                 }
                 if (!update.isDeleted) {
-                    newMap = newMap.update(newKey, I.Set(), set => set.add(update.immId));
+                    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);
+        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) }));
+        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 }));
+        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 }] }));
+        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 }] }));
+        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 }));
+        return this.update((t) => (t.q = Object.assign(Object.assign({}, t.q), { search: text })));
     }
     /* Materializing */
     range(from, count) {
@@ -276,14 +280,14 @@ class DbTable {
         let result = null;
         let filter = q.filter;
         if (filter) {
-            let indexes = this.state.indexes;
+            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 _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") {
+                    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
@@ -334,15 +338,15 @@ class DbTable {
             result = this.state.pk.toArray();
         }
         if (filter) {
-            let predicate = getFilterPredicate(q.filter);
+            const 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])));
+            const searchFilter = getSearchFilter(q.search);
+            result = result.filter((item) => searchFilter(this.schema.searchBy.map((field) => item[field])));
         }
         if (q.sorting) {
-            let comparer = getOrderComparer(q.sorting);
+            const comparer = getOrderComparer(q.sorting);
             result = result.sort(comparer);
         }
         if (q.range) {
@@ -354,8 +358,8 @@ class DbTable {
 
 function unionPatches(patches) {
     const result = {};
-    patches.forEach(patch => {
-        objectKeys(patch).forEach(tableName => {
+    patches.forEach((patch) => {
+        objectKeys(patch).forEach((tableName) => {
             result[tableName] = result[tableName] ? [...result[tableName], ...patch[tableName]] : patch[tableName];
         });
     });
@@ -363,13 +367,13 @@ function unionPatches(patches) {
 }
 function mergeEntityPatches(tables, patch) {
     const result = {};
-    objectKeys(patch).forEach(key => {
+    objectKeys(patch).forEach((key) => {
         const table = tables[key];
-        const groupedEntities = groupBy(patch[key], item => table.getId(item));
-        const tablePatch = map(groupedEntities, entities => {
+        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);
+                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);
                 }
@@ -382,7 +386,7 @@ function mergeEntityPatches(tables, patch) {
 }
 function flattenResponseHelper(result, object, tablesByTypeName) {
     if (Array.isArray(object)) {
-        object.forEach(item => flattenResponseHelper(result, item, tablesByTypeName));
+        object.forEach((item) => flattenResponseHelper(result, item, tablesByTypeName));
     }
     else if (typeof object === 'object') {
         const clone = {};
@@ -395,13 +399,13 @@ function flattenResponseHelper(result, object, tablesByTypeName) {
                 fields = table.schema.fields;
             }
         }
-        for (let key in object) {
+        for (const 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'))) {
+                || (Array.isArray(value) && value.every((item) => typeof item !== 'object'))) {
                 clone[key] = value;
             }
             else {
@@ -415,32 +419,32 @@ function flattenResponseHelper(result, object, tablesByTypeName) {
 }
 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] = []);
+    const 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);
+    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 => {
+    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)));
+        patches.forEach((patch) => {
+            const 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))
+            .map((id) => table.byId(id))
+            .filter((e) => !isClientOnly(e, schema))
             .toArray();
         if (entities.length > 0) {
             result[entityName] = entities;
@@ -469,25 +473,25 @@ function isNew(entity, schema, clientIdsMap) {
     return !clientIdsMap.clientToServer(id);
 }
 function hasServerFields(entity, schema, clientIdsMap, tables) {
-    const fullEntity = Object.assign(Object.assign({}, tables[schema.tableName].byId(entity.id) || {}), entity);
+    const fullEntity = Object.assign(Object.assign({}, (tables[schema.tableName].byId(entity.id) || {})), entity);
     if (isClientOnly(fullEntity, schema)) {
         return false;
     }
-    return objectKeys(entity).some(fieldName => {
+    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 => {
+    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 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 => {
+        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]);
@@ -505,7 +509,7 @@ function getEntityParentDependencies(entity, entityName, tables) {
     let patch = { [entityName]: [entity] };
     const resultPatches = [];
     while (true) {
-        let parents = getParentEntities(patch, tables);
+        const parents = getParentEntities(patch, tables);
         if (isPatchBlank(parents)) {
             break;
         }
@@ -555,7 +559,7 @@ class TempIdMap {
             for (let n = 0; n < keys.length; n++) {
                 const key = keys[n];
                 let condition = filter[key];
-                if (condition != null && typeof condition === "object") {
+                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);
@@ -571,28 +575,28 @@ class TempIdMap {
     }
     copyPatch(patch) {
         const newPatch = Object.assign({}, patch);
-        objectKeys(patch).forEach(tableName => {
-            let tablePatch = patch[tableName].map(entityPatch => (Object.assign({}, entityPatch)));
+        objectKeys(patch).forEach((tableName) => {
+            const 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 => {
+        objectKeys(patch).forEach((tableName) => {
             const schema = this.db.tables[tableName].schema;
             const fields = objectKeys(schema.fields || [])
-                .map(fieldName => {
+                .map((fieldName) => {
                 const fieldSchema = schema.fields[fieldName];
                 if (filter(fieldSchema, fieldName)) {
                     return { name: fieldName, schema: fieldSchema };
                 }
             })
-                .filter(f => !!f);
+                .filter((f) => !!f);
             if (!fields.length) {
                 return;
             }
-            patch[tableName].forEach(entityPatch => {
+            patch[tableName].forEach((entityPatch) => {
                 for (let n = 0; n < fields.length; n++) {
                     const field = fields[n];
                     const fieldValue = entityPatch[field.name];
@@ -615,7 +619,7 @@ class TempIdMap {
     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) => {
+        this.mapFields(patch, (f) => f.isGenerated, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
             let clientId = this.getServerToClientMap(tableName).get(fieldValue);
             if (!clientId) {
                 clientId = getTempId();
@@ -624,8 +628,8 @@ class TempIdMap {
             }
             entityPatch[fieldName] = clientId;
         });
-        this.mapFields(patch, f => !!(f.fk || (f.default != null) || f.toClient), (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
-            let isUndefined = typeof (fieldValue) === 'undefined';
+        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;
@@ -651,7 +655,7 @@ class TempIdMap {
     }
     clientToServerPatch(patch) {
         patch = this.copyPatch(patch);
-        this.mapFields(patch, f => f.isGenerated || !!f.fk, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
+        this.mapFields(patch, (f) => f.isGenerated || !!f.fk, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
             if (fieldValue != null) {
                 const existingId = this.clientToServerIds.get(fieldValue);
                 if (existingId) {
@@ -659,22 +663,22 @@ class TempIdMap {
                 }
             }
         });
-        this.mapFields(patch, f => !(f.isClientOnly || f.isReadOnly) && !!f.toServer, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
+        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) => {
+        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 => {
+        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 => {
+                    tablePatch.forEach((patch) => {
                         if (isTempId(patch.id)) {
                             const clientId = patch.id;
                             const serverId = table.getId(patch.payload);
@@ -741,7 +745,7 @@ class Loader {
         if (this.options.clientToServerRequest) {
             serverRequest = this.options.clientToServerRequest(serverRequest);
         }
-        state.promise = this.options.api(serverRequest).then(result => {
+        state.promise = this.options.api(serverRequest).then((result) => {
             this.loaded.append(state.missing, result);
             this.loadedAndLoading.append(state.missing, result);
             state.missing = null;
@@ -793,17 +797,21 @@ class ListLoadingTracker {
         if (search) {
             options.search = search;
         }
-        let keyObject = Object.assign(Object.assign({}, options), unknownFields);
+        const 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 };
+            entry = {
+                options, count: 0, maxCount: null, isComplete: false,
+            };
             this.cache.set(key, entry);
         }
-        return { options, range, unknownFields, entry };
+        return {
+            options, range, unknownFields, entry,
+        };
     }
     diff(request) {
-        const { options, range, unknownFields, entry } = this.prepare(request);
+        const { options, range, unknownFields, entry, } = this.prepare(request);
         if (entry.isComplete) {
             return null;
         }
@@ -829,7 +837,7 @@ class ListLoadingTracker {
         return { knownCount: Math.max(entry.count, entry.maxCount), exactCount: entry.maxCount };
     }
     append(request, response) {
-        const { options, range, unknownFields, entry } = this.prepare(request);
+        const { options, range, unknownFields, entry, } = this.prepare(request);
         if (response) {
             const list = this.extractList(response);
             if (list.count) {
@@ -841,7 +849,7 @@ class ListLoadingTracker {
                 entry.isComplete = true;
             }
             else {
-                const from = (list.from == null) ? range.from : list.from;
+                const from = list.from == null ? range.from : list.from;
                 if (list.items.length > 0) {
                     entry.count = Math.max(entry.count, from + list.items.length);
                 }
@@ -942,23 +950,29 @@ class DbRef {
     }
     beforeUpdate(patch, tables, prevTables) {
         let patchAndDependencies = {};
-        objectKeys(tables).filter(entityName => patch[entityName] && !tables[entityName].schema.beforeUpdate).forEach(entityName => {
+        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 => {
+        objectKeys(tables)
+            .filter((entityName) => patch[entityName] && tables[entityName].schema.beforeUpdate)
+            .forEach((entityName) => {
             const schema = tables[entityName].schema;
             const { beforeUpdate } = schema;
-            let context = {
+            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) };
-            const dependentEntityPatchesForUpdate = unionPatches(results.filter(result => result.dependentEntities).map(result => result.dependentEntities));
+            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]));
+            patchAndDependencies = mergeEntityPatches(tables, unionPatches([
+                patchAndDependencies, updatedPatch, dependentEntityPatches,
+            ]));
         });
         return patchAndDependencies;
     }
@@ -977,7 +991,7 @@ class DbRef {
     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);
+        let cumulativePatch = makeCumulativePatch(this.db, logEntriesToSave.map((t) => t.patch), this.tempIdMap);
         cumulativePatch = this.tempIdMap.clientToServerPatch(cumulativePatch);
         return cumulativePatch;
     }
@@ -1000,7 +1014,9 @@ class DbRef {
             currentParams: null,
             currentValue: null,
             onUpdate,
-            unsubscribe: () => { this.subscriptions.delete(id); },
+            unsubscribe: () => {
+                this.subscriptions.delete(id);
+            },
         };
         subscription.update(params);
         this.subscriptions.set(id, subscription);
@@ -1008,12 +1024,12 @@ class DbRef {
     }
     onUpdate(handler) {
         this.subscribe({
-            compute: db => db,
+            compute: (db) => db,
             compareResults: (a, b) => a === b,
         }, null, handler);
     }
     update() {
-        this.subscriptions.forEach(subscription => {
+        this.subscriptions.forEach((subscription) => {
             const previousValue = subscription.currentValue;
             subscription.update(subscription.currentParams);
             if (subscription.currentValue !== previousValue && subscription.onUpdate) {
@@ -1025,7 +1041,7 @@ class DbRef {
         this.saveErrorHandlers.push(handler);
     }
     saveError(request, error) {
-        this.saveErrorHandlers.forEach(handler => handler(request, error));
+        this.saveErrorHandlers.forEach((handler) => handler(request, error));
     }
     makeLoader(options) {
         const loader = new Loader(this, () => new SimpleLoadingTracker(), options);