@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/cjs/query-planner.js

@@ -0,0 +1,307 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UPPER_BOUND_LOGICAL_OPERATORS = exports.LOWER_BOUND_LOGICAL_OPERATORS = exports.LOGICAL_OPERATORS = exports.INDEX_MIN = exports.INDEX_MAX = void 0;
+exports.getMatcherQueryOpts = getMatcherQueryOpts;
+exports.getQueryPlan = getQueryPlan;
+exports.isSelectorSatisfiedByIndex = isSelectorSatisfiedByIndex;
+exports.rateQueryPlan = rateQueryPlan;
+var _index = require("./plugins/utils/index.js");
+var _rxError = require("./rx-error.js");
+var _rxSchemaHelper = require("./rx-schema-helper.js");
+var INDEX_MAX = exports.INDEX_MAX = String.fromCharCode(65535);
+
+/**
+ * Do not use -Infinity here because it would be
+ * transformed to null on JSON.stringify() which can break things
+ * when the query plan is sent to the storage as json.
+ * @link https://stackoverflow.com/a/16644751
+ * Notice that for IndexedDB IDBKeyRange we have
+ * to transform the value back to -Infinity
+ * before we can use it in IDBKeyRange.bound.
+ */
+var INDEX_MIN = exports.INDEX_MIN = Number.MIN_SAFE_INTEGER;
+
+/**
+ * Returns the query plan which contains
+ * information about how to run the query
+ * and which indexes to use.
+ *
+ * This is used in some storage like Memory, dexie.js and IndexedDB.
+ */
+function getQueryPlan(schema, query) {
+  var selector = query.selector;
+  var indexes = schema.indexes ? schema.indexes.slice(0) : [];
+  if (query.index) {
+    indexes = [query.index];
+  }
+
+  /**
+   * Most storages do not support descending indexes
+   * so having a 'desc' in the sorting, means we always have to re-sort the results.
+   */
+  var hasDescSorting = !!query.sort.find(sortField => Object.values(sortField)[0] === 'desc');
+
+  /**
+   * Some fields can be part of the selector while not being relevant for sorting
+   * because their selector operators specify that in all cases all matching docs
+   * would have the same value.
+   * For example the boolean field _deleted or enum fields.
+   */
+  var sortIrrelevevantFields = new Set();
+  Object.keys(selector).forEach(fieldName => {
+    var schemaPart = (0, _rxSchemaHelper.getSchemaByObjectPath)(schema, fieldName);
+    if (schemaPart && (schemaPart.type === 'boolean' || schemaPart.enum) && Object.prototype.hasOwnProperty.call(selector[fieldName], '$eq')) {
+      sortIrrelevevantFields.add(fieldName);
+    }
+  });
+  var optimalSortIndex = query.sort.map(sortField => Object.keys(sortField)[0]);
+  var optimalSortIndexCompareString = optimalSortIndex.filter(f => !sortIrrelevevantFields.has(f)).join(',');
+  var currentBestQuality = -1;
+  var currentBestQueryPlan;
+
+  /**
+   * Calculate one query plan for each index
+   * and then test which of the plans is best.
+   */
+  indexes.forEach(index => {
+    var inclusiveEnd = true;
+    var inclusiveStart = true;
+    var opts = index.map(indexField => {
+      var matcher = selector[indexField];
+      var operators = matcher ? Object.keys(matcher) : [];
+      var matcherOpts = {};
+      if (!matcher || !operators.length) {
+        var startKey = inclusiveStart ? INDEX_MIN : INDEX_MAX;
+        matcherOpts = {
+          startKey,
+          endKey: inclusiveEnd ? INDEX_MAX : INDEX_MIN,
+          inclusiveStart: true,
+          inclusiveEnd: true
+        };
+      } else {
+        operators.forEach(operator => {
+          if (LOGICAL_OPERATORS.has(operator)) {
+            var operatorValue = matcher[operator];
+            var partialOpts = getMatcherQueryOpts(operator, operatorValue);
+            matcherOpts = Object.assign(matcherOpts, partialOpts);
+          }
+        });
+      }
+
+      // fill missing attributes
+      if (typeof matcherOpts.startKey === 'undefined') {
+        matcherOpts.startKey = INDEX_MIN;
+      }
+      if (typeof matcherOpts.endKey === 'undefined') {
+        matcherOpts.endKey = INDEX_MAX;
+      }
+      if (typeof matcherOpts.inclusiveStart === 'undefined') {
+        matcherOpts.inclusiveStart = true;
+      }
+      if (typeof matcherOpts.inclusiveEnd === 'undefined') {
+        matcherOpts.inclusiveEnd = true;
+      }
+      if (inclusiveStart && !matcherOpts.inclusiveStart) {
+        inclusiveStart = false;
+      }
+      if (inclusiveEnd && !matcherOpts.inclusiveEnd) {
+        inclusiveEnd = false;
+      }
+      return matcherOpts;
+    });
+    var startKeys = opts.map(opt => opt.startKey);
+    var endKeys = opts.map(opt => opt.endKey);
+
+    /**
+     * Compute the index compare string once per index,
+     * not inside the queryPlan object literal, to avoid
+     * creating a filtered array and joining on every iteration.
+     */
+    var indexCompareString;
+    if (sortIrrelevevantFields.size === 0) {
+      indexCompareString = index.join(',');
+    } else {
+      indexCompareString = index.filter(f => !sortIrrelevevantFields.has(f)).join(',');
+    }
+    var queryPlan = {
+      index,
+      startKeys,
+      endKeys,
+      inclusiveEnd,
+      inclusiveStart,
+      sortSatisfiedByIndex: !hasDescSorting && optimalSortIndexCompareString === indexCompareString,
+      selectorSatisfiedByIndex: isSelectorSatisfiedByIndex(index, query.selector, startKeys, endKeys)
+    };
+    var quality = rateQueryPlan(schema, query, queryPlan);
+    if (quality >= currentBestQuality || query.index) {
+      currentBestQuality = quality;
+      currentBestQueryPlan = queryPlan;
+    }
+  });
+
+  /**
+   * In all cases and index must be found
+   */
+  if (!currentBestQueryPlan) {
+    throw (0, _rxError.newRxError)('SNH', {
+      query
+    });
+  }
+  return currentBestQueryPlan;
+}
+var LOGICAL_OPERATORS = exports.LOGICAL_OPERATORS = new Set(['$eq', '$gt', '$gte', '$lt', '$lte']);
+var LOWER_BOUND_LOGICAL_OPERATORS = exports.LOWER_BOUND_LOGICAL_OPERATORS = new Set(['$eq', '$gt', '$gte']);
+var UPPER_BOUND_LOGICAL_OPERATORS = exports.UPPER_BOUND_LOGICAL_OPERATORS = new Set(['$eq', '$lt', '$lte']);
+function isSelectorSatisfiedByIndex(index, selector, startKeys, endKeys) {
+  /**
+   * Not satisfied if contains $and or $or operations.
+   */
+  if (selector.$and || selector.$or) {
+    return false;
+  }
+
+  /**
+   * Check all selector entries in a single pass:
+   * - Ensure all fields are in the index
+   * - Ensure all operators are logical
+   * - Track lower/upper bound operators
+   */
+  var selectorEntries = Object.entries(selector);
+  var lowerOperatorFieldNames = new Set();
+  var upperOperatorFieldNames = new Set();
+  var hasNonEqLowerBound = false;
+  var hasNonEqUpperBound = false;
+  for (var [fieldName, operation] of selectorEntries) {
+    if (!index.includes(fieldName)) {
+      return false;
+    }
+    var operationKeys = Object.keys(operation);
+    var lowerLogicOpCount = 0;
+    var lastLowerLogicOp = void 0;
+    var upperLogicOpCount = 0;
+    var lastUpperLogicOp = void 0;
+    for (var op of operationKeys) {
+      if (!LOGICAL_OPERATORS.has(op)) {
+        return false;
+      }
+      if (LOWER_BOUND_LOGICAL_OPERATORS.has(op)) {
+        lowerLogicOpCount++;
+        lastLowerLogicOp = op;
+      }
+      if (UPPER_BOUND_LOGICAL_OPERATORS.has(op)) {
+        upperLogicOpCount++;
+        lastUpperLogicOp = op;
+      }
+    }
+
+    // If more than one logic op on the same field per bound direction, we have to selector-match.
+    if (lowerLogicOpCount > 1 || upperLogicOpCount > 1) {
+      return false;
+    }
+    if (lastLowerLogicOp) {
+      lowerOperatorFieldNames.add(fieldName);
+    }
+    if (lastLowerLogicOp !== '$eq') {
+      if (hasNonEqLowerBound) {
+        return false;
+      }
+      hasNonEqLowerBound = true;
+    }
+    if (lastUpperLogicOp) {
+      upperOperatorFieldNames.add(fieldName);
+    }
+    if (lastUpperLogicOp !== '$eq') {
+      if (hasNonEqUpperBound) {
+        return false;
+      }
+      hasNonEqUpperBound = true;
+    }
+  }
+
+  /**
+   * If the index contains a non-relevant field between
+   * the relevant fields, then the index is not satisfying.
+   */
+  var i = 0;
+  for (var _fieldName of index) {
+    for (var set of [lowerOperatorFieldNames, upperOperatorFieldNames]) {
+      if (!set.has(_fieldName) && set.size > 0) {
+        return false;
+      }
+      set.delete(_fieldName);
+    }
+    var startKey = startKeys[i];
+    var endKey = endKeys[i];
+    if (startKey !== endKey && lowerOperatorFieldNames.size > 0 && upperOperatorFieldNames.size > 0) {
+      return false;
+    }
+    i++;
+  }
+  return true;
+}
+function getMatcherQueryOpts(operator, operatorValue) {
+  switch (operator) {
+    case '$eq':
+      return {
+        startKey: operatorValue,
+        endKey: operatorValue,
+        inclusiveEnd: true,
+        inclusiveStart: true
+      };
+    case '$lte':
+      return {
+        endKey: operatorValue,
+        inclusiveEnd: true
+      };
+    case '$gte':
+      return {
+        startKey: operatorValue,
+        inclusiveStart: true
+      };
+    case '$lt':
+      return {
+        endKey: operatorValue,
+        inclusiveEnd: false
+      };
+    case '$gt':
+      return {
+        startKey: operatorValue,
+        inclusiveStart: false
+      };
+    default:
+      throw new Error('SNH');
+  }
+}
+
+/**
+ * Returns a number that determines the quality of the query plan.
+ * Higher number means better query plan.
+ */
+function rateQueryPlan(schema, query, queryPlan) {
+  var quality = 0;
+  var addQuality = value => {
+    if (value > 0) {
+      quality = quality + value;
+    }
+  };
+  var pointsPerMatchingKey = 10;
+  var nonMinKeyCount = (0, _index.countUntilNotMatching)(queryPlan.startKeys, keyValue => keyValue !== INDEX_MIN && keyValue !== INDEX_MAX);
+  addQuality(nonMinKeyCount * pointsPerMatchingKey);
+  var nonMaxKeyCount = (0, _index.countUntilNotMatching)(queryPlan.startKeys, keyValue => keyValue !== INDEX_MAX && keyValue !== INDEX_MIN);
+  addQuality(nonMaxKeyCount * pointsPerMatchingKey);
+  var equalKeyCount = (0, _index.countUntilNotMatching)(queryPlan.startKeys, (keyValue, idx) => {
+    if (keyValue === queryPlan.endKeys[idx]) {
+      return true;
+    } else {
+      return false;
+    }
+  });
+  addQuality(equalKeyCount * pointsPerMatchingKey * 1.5);
+  var pointsIfNoReSortMustBeDone = queryPlan.sortSatisfiedByIndex ? 5 : 0;
+  addQuality(pointsIfNoReSortMustBeDone);
+  return quality;
+}
+//# sourceMappingURL=query-planner.js.map

package/dist/cjs/query-planner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-planner.js","names":["_index","require","_rxError","_rxSchemaHelper","INDEX_MAX","exports","String","fromCharCode","INDEX_MIN","Number","MIN_SAFE_INTEGER","getQueryPlan","schema","query","selector","indexes","slice","index","hasDescSorting","sort","find","sortField","Object","values","sortIrrelevevantFields","Set","keys","forEach","fieldName","schemaPart","getSchemaByObjectPath","type","enum","prototype","hasOwnProperty","call","add","optimalSortIndex","map","optimalSortIndexCompareString","filter","f","has","join","currentBestQuality","currentBestQueryPlan","inclusiveEnd","inclusiveStart","opts","indexField","matcher","operators","matcherOpts","length","startKey","endKey","operator","LOGICAL_OPERATORS","operatorValue","partialOpts","getMatcherQueryOpts","assign","startKeys","opt","endKeys","indexCompareString","size","queryPlan","sortSatisfiedByIndex","selectorSatisfiedByIndex","isSelectorSatisfiedByIndex","quality","rateQueryPlan","newRxError","LOWER_BOUND_LOGICAL_OPERATORS","UPPER_BOUND_LOGICAL_OPERATORS","$and","$or","selectorEntries","entries","lowerOperatorFieldNames","upperOperatorFieldNames","hasNonEqLowerBound","hasNonEqUpperBound","operation","includes","operationKeys","lowerLogicOpCount","lastLowerLogicOp","upperLogicOpCount","lastUpperLogicOp","op","i","set","delete","Error","addQuality","value","pointsPerMatchingKey","nonMinKeyCount","countUntilNotMatching","keyValue","nonMaxKeyCount","equalKeyCount","idx","pointsIfNoReSortMustBeDone"],"sources":["../../src/query-planner.ts"],"sourcesContent":["import { countUntilNotMatching } from './plugins/utils/index.ts';\r\nimport { newRxError } from './rx-error.ts';\r\nimport { getSchemaByObjectPath } from './rx-schema-helper.ts';\r\nimport type {\r\n    FilledMangoQuery,\r\n    MangoQuerySelector,\r\n    RxDocumentData,\r\n    RxJsonSchema,\r\n    RxQueryPlan,\r\n    RxQueryPlanKey,\r\n    RxQueryPlanerOpts\r\n} from './types/index.d.ts';\r\n\r\nexport const INDEX_MAX = String.fromCharCode(65535);\r\n\r\n/**\r\n * Do not use -Infinity here because it would be\r\n * transformed to null on JSON.stringify() which can break things\r\n * when the query plan is sent to the storage as json.\r\n * @link https://stackoverflow.com/a/16644751\r\n * Notice that for IndexedDB IDBKeyRange we have\r\n * to transform the value back to -Infinity\r\n * before we can use it in IDBKeyRange.bound.\r\n */\r\nexport const INDEX_MIN = Number.MIN_SAFE_INTEGER;\r\n\r\n/**\r\n * Returns the query plan which contains\r\n * information about how to run the query\r\n * and which indexes to use.\r\n *\r\n * This is used in some storage like Memory, dexie.js and IndexedDB.\r\n */\r\nexport function getQueryPlan<RxDocType>(\r\n    schema: RxJsonSchema<RxDocumentData<RxDocType>>,\r\n    query: FilledMangoQuery<RxDocType>\r\n): RxQueryPlan {\r\n    const selector = query.selector;\r\n    let indexes: string[][] = schema.indexes ? schema.indexes.slice(0) as any : [];\r\n    if (query.index) {\r\n        indexes = [query.index];\r\n    }\r\n\r\n    /**\r\n     * Most storages do not support descending indexes\r\n     * so having a 'desc' in the sorting, means we always have to re-sort the results.\r\n     */\r\n    const hasDescSorting = !!query.sort.find(sortField => Object.values(sortField)[0] === 'desc');\r\n\r\n    /**\r\n     * Some fields can be part of the selector while not being relevant for sorting\r\n     * because their selector operators specify that in all cases all matching docs\r\n     * would have the same value.\r\n     * For example the boolean field _deleted or enum fields.\r\n     */\r\n    const sortIrrelevevantFields = new Set();\r\n    Object.keys(selector).forEach(fieldName => {\r\n        const schemaPart = getSchemaByObjectPath(schema, fieldName);\r\n        if (\r\n            schemaPart &&\r\n            (\r\n                schemaPart.type === 'boolean' ||\r\n                schemaPart.enum\r\n            ) &&\r\n            Object.prototype.hasOwnProperty.call((selector as any)[fieldName], '$eq')\r\n        ) {\r\n            sortIrrelevevantFields.add(fieldName);\r\n        }\r\n    });\r\n\r\n\r\n    const optimalSortIndex = query.sort.map(sortField => Object.keys(sortField)[0]);\r\n    const optimalSortIndexCompareString = optimalSortIndex\r\n        .filter(f => !sortIrrelevevantFields.has(f))\r\n        .join(',');\r\n\r\n    let currentBestQuality = -1;\r\n    let currentBestQueryPlan: RxQueryPlan | undefined;\r\n\r\n    /**\r\n     * Calculate one query plan for each index\r\n     * and then test which of the plans is best.\r\n     */\r\n    indexes.forEach((index) => {\r\n        let inclusiveEnd = true;\r\n        let inclusiveStart = true;\r\n        const opts: RxQueryPlanerOpts[] = index.map(indexField => {\r\n            const matcher = (selector as any)[indexField];\r\n            const operators = matcher ? Object.keys(matcher) : [];\r\n\r\n            let matcherOpts: RxQueryPlanerOpts = {} as any;\r\n            if (\r\n                !matcher ||\r\n                !operators.length\r\n            ) {\r\n                const startKey = inclusiveStart ? INDEX_MIN : INDEX_MAX;\r\n                matcherOpts = {\r\n                    startKey,\r\n                    endKey: inclusiveEnd ? INDEX_MAX : INDEX_MIN,\r\n                    inclusiveStart: true,\r\n                    inclusiveEnd: true\r\n                };\r\n            } else {\r\n                operators.forEach(operator => {\r\n                    if (LOGICAL_OPERATORS.has(operator)) {\r\n                        const operatorValue = matcher[operator];\r\n                        const partialOpts = getMatcherQueryOpts(operator, operatorValue);\r\n                        matcherOpts = Object.assign(matcherOpts, partialOpts);\r\n                    }\r\n                });\r\n            }\r\n\r\n            // fill missing attributes\r\n            if (typeof matcherOpts.startKey === 'undefined') {\r\n                matcherOpts.startKey = INDEX_MIN;\r\n            }\r\n            if (typeof matcherOpts.endKey === 'undefined') {\r\n                matcherOpts.endKey = INDEX_MAX;\r\n            }\r\n            if (typeof matcherOpts.inclusiveStart === 'undefined') {\r\n                matcherOpts.inclusiveStart = true;\r\n            }\r\n            if (typeof matcherOpts.inclusiveEnd === 'undefined') {\r\n                matcherOpts.inclusiveEnd = true;\r\n            }\r\n\r\n            if (inclusiveStart && !matcherOpts.inclusiveStart) {\r\n                inclusiveStart = false;\r\n            }\r\n            if (inclusiveEnd && !matcherOpts.inclusiveEnd) {\r\n                inclusiveEnd = false;\r\n            }\r\n\r\n            return matcherOpts;\r\n        });\r\n\r\n\r\n        const startKeys = opts.map(opt => opt.startKey);\r\n        const endKeys = opts.map(opt => opt.endKey);\r\n\r\n        /**\r\n         * Compute the index compare string once per index,\r\n         * not inside the queryPlan object literal, to avoid\r\n         * creating a filtered array and joining on every iteration.\r\n         */\r\n        let indexCompareString: string;\r\n        if (sortIrrelevevantFields.size === 0) {\r\n            indexCompareString = index.join(',');\r\n        } else {\r\n            indexCompareString = index.filter(f => !sortIrrelevevantFields.has(f)).join(',');\r\n        }\r\n\r\n        const queryPlan: RxQueryPlan = {\r\n            index,\r\n            startKeys,\r\n            endKeys,\r\n            inclusiveEnd,\r\n            inclusiveStart,\r\n            sortSatisfiedByIndex: !hasDescSorting && optimalSortIndexCompareString === indexCompareString,\r\n            selectorSatisfiedByIndex: isSelectorSatisfiedByIndex(index, query.selector, startKeys, endKeys)\r\n        };\r\n        const quality = rateQueryPlan(\r\n            schema,\r\n            query,\r\n            queryPlan\r\n        );\r\n        if (\r\n            (\r\n                quality >= currentBestQuality\r\n            ) ||\r\n            query.index\r\n        ) {\r\n            currentBestQuality = quality;\r\n            currentBestQueryPlan = queryPlan;\r\n        }\r\n    });\r\n\r\n    /**\r\n     * In all cases and index must be found\r\n     */\r\n    if (!currentBestQueryPlan) {\r\n        throw newRxError('SNH', {\r\n            query\r\n        });\r\n    }\r\n\r\n    return currentBestQueryPlan;\r\n}\r\n\r\nexport const LOGICAL_OPERATORS = new Set(['$eq', '$gt', '$gte', '$lt', '$lte']);\r\nexport const LOWER_BOUND_LOGICAL_OPERATORS = new Set(['$eq', '$gt', '$gte']);\r\nexport const UPPER_BOUND_LOGICAL_OPERATORS = new Set(['$eq', '$lt', '$lte']);\r\n\r\n\r\nexport function isSelectorSatisfiedByIndex(\r\n    index: string[],\r\n    selector: MangoQuerySelector<any>,\r\n    startKeys: RxQueryPlanKey[],\r\n    endKeys: RxQueryPlanKey[]\r\n): boolean {\r\n\r\n    /**\r\n     * Not satisfied if contains $and or $or operations.\r\n     */\r\n    if (selector.$and || selector.$or) {\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * Check all selector entries in a single pass:\r\n     * - Ensure all fields are in the index\r\n     * - Ensure all operators are logical\r\n     * - Track lower/upper bound operators\r\n     */\r\n    const selectorEntries = Object.entries(selector);\r\n    const lowerOperatorFieldNames = new Set<string>();\r\n    const upperOperatorFieldNames = new Set<string>();\r\n    let hasNonEqLowerBound = false;\r\n    let hasNonEqUpperBound = false;\r\n\r\n    for (const [fieldName, operation] of selectorEntries) {\r\n        if (!index.includes(fieldName)) {\r\n            return false;\r\n        }\r\n\r\n        const operationKeys = Object.keys(operation as any);\r\n\r\n        let lowerLogicOpCount = 0;\r\n        let lastLowerLogicOp: string | undefined;\r\n        let upperLogicOpCount = 0;\r\n        let lastUpperLogicOp: string | undefined;\r\n\r\n        for (const op of operationKeys) {\r\n            if (!LOGICAL_OPERATORS.has(op)) {\r\n                return false;\r\n            }\r\n            if (LOWER_BOUND_LOGICAL_OPERATORS.has(op)) {\r\n                lowerLogicOpCount++;\r\n                lastLowerLogicOp = op;\r\n            }\r\n            if (UPPER_BOUND_LOGICAL_OPERATORS.has(op)) {\r\n                upperLogicOpCount++;\r\n                lastUpperLogicOp = op;\r\n            }\r\n        }\r\n\r\n        // If more than one logic op on the same field per bound direction, we have to selector-match.\r\n        if (lowerLogicOpCount > 1 || upperLogicOpCount > 1) {\r\n            return false;\r\n        }\r\n\r\n        if (lastLowerLogicOp) {\r\n            lowerOperatorFieldNames.add(fieldName);\r\n        }\r\n        if (lastLowerLogicOp !== '$eq') {\r\n            if (hasNonEqLowerBound) {\r\n                return false;\r\n            }\r\n            hasNonEqLowerBound = true;\r\n        }\r\n\r\n        if (lastUpperLogicOp) {\r\n            upperOperatorFieldNames.add(fieldName);\r\n        }\r\n        if (lastUpperLogicOp !== '$eq') {\r\n            if (hasNonEqUpperBound) {\r\n                return false;\r\n            }\r\n            hasNonEqUpperBound = true;\r\n        }\r\n    }\r\n\r\n\r\n    /**\r\n     * If the index contains a non-relevant field between\r\n     * the relevant fields, then the index is not satisfying.\r\n     */\r\n    let i = 0;\r\n    for (const fieldName of index) {\r\n        for (const set of [\r\n            lowerOperatorFieldNames,\r\n            upperOperatorFieldNames\r\n        ]) {\r\n            if (\r\n                !set.has(fieldName) &&\r\n                set.size > 0\r\n            ) {\r\n                return false;\r\n            }\r\n            set.delete(fieldName);\r\n        }\r\n\r\n        const startKey = startKeys[i];\r\n        const endKey = endKeys[i];\r\n\r\n        if (\r\n            startKey !== endKey && (\r\n                lowerOperatorFieldNames.size > 0 &&\r\n                upperOperatorFieldNames.size > 0\r\n            )\r\n        ) {\r\n            return false;\r\n        }\r\n\r\n        i++;\r\n    }\r\n\r\n    return true;\r\n}\r\n\r\nexport function getMatcherQueryOpts(\r\n    operator: string,\r\n    operatorValue: any\r\n): Partial<RxQueryPlanerOpts> {\r\n    switch (operator) {\r\n        case '$eq':\r\n            return {\r\n                startKey: operatorValue,\r\n                endKey: operatorValue,\r\n                inclusiveEnd: true,\r\n                inclusiveStart: true\r\n            };\r\n        case '$lte':\r\n            return {\r\n                endKey: operatorValue,\r\n                inclusiveEnd: true\r\n            };\r\n        case '$gte':\r\n            return {\r\n                startKey: operatorValue,\r\n                inclusiveStart: true\r\n            };\r\n        case '$lt':\r\n            return {\r\n                endKey: operatorValue,\r\n                inclusiveEnd: false\r\n            };\r\n        case '$gt':\r\n            return {\r\n                startKey: operatorValue,\r\n                inclusiveStart: false\r\n            };\r\n        default:\r\n            throw new Error('SNH');\r\n    }\r\n}\r\n\r\n\r\n/**\r\n * Returns a number that determines the quality of the query plan.\r\n * Higher number means better query plan.\r\n */\r\nexport function rateQueryPlan<RxDocType>(\r\n    schema: RxJsonSchema<RxDocumentData<RxDocType>>,\r\n    query: FilledMangoQuery<RxDocType>,\r\n    queryPlan: RxQueryPlan\r\n): number {\r\n    let quality: number = 0;\r\n    const addQuality = (value: number) => {\r\n        if (value > 0) {\r\n            quality = quality + value;\r\n        }\r\n    };\r\n\r\n    const pointsPerMatchingKey = 10;\r\n\r\n    const nonMinKeyCount = countUntilNotMatching(queryPlan.startKeys, keyValue => keyValue !== INDEX_MIN && keyValue !== INDEX_MAX);\r\n    addQuality(nonMinKeyCount * pointsPerMatchingKey);\r\n\r\n    const nonMaxKeyCount = countUntilNotMatching(queryPlan.startKeys, keyValue => keyValue !== INDEX_MAX && keyValue !== INDEX_MIN);\r\n    addQuality(nonMaxKeyCount * pointsPerMatchingKey);\r\n\r\n    const equalKeyCount = countUntilNotMatching(queryPlan.startKeys, (keyValue, idx) => {\r\n        if (keyValue === queryPlan.endKeys[idx]) {\r\n            return true;\r\n        } else {\r\n            return false;\r\n        }\r\n    });\r\n    addQuality(equalKeyCount * pointsPerMatchingKey * 1.5);\r\n\r\n    const pointsIfNoReSortMustBeDone = queryPlan.sortSatisfiedByIndex ? 5 : 0;\r\n    addQuality(pointsIfNoReSortMustBeDone);\r\n\r\n    return quality;\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/cjs/replication-protocol/checkpoint.js

@@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCheckpointKey = getCheckpointKey;
+exports.getLastCheckpointDoc = getLastCheckpointDoc;
+exports.setCheckpoint = setCheckpoint;
+var _rxSchemaHelper = require("../rx-schema-helper.js");
+var _rxStorageHelper = require("../rx-storage-helper.js");
+var _index = require("../plugins/utils/index.js");
+async function getLastCheckpointDoc(state, direction) {
+  var checkpointDocId = (0, _rxSchemaHelper.getComposedPrimaryKeyOfDocumentData)(state.input.metaInstance.schema, {
+    isCheckpoint: '1',
+    itemId: direction
+  });
+  var checkpointResult = await state.input.metaInstance.findDocumentsById([checkpointDocId], false);
+  var checkpointDoc = checkpointResult[0];
+  state.lastCheckpointDoc[direction] = checkpointDoc;
+  if (checkpointDoc) {
+    return checkpointDoc.checkpointData;
+  } else {
+    return undefined;
+  }
+}
+
+/**
+ * Sets the checkpoint,
+ * automatically resolves conflicts that appear.
+ */
+async function setCheckpoint(state, direction, checkpoint) {
+  state.checkpointQueue = state.checkpointQueue.then(async () => {
+    var previousCheckpointDoc = state.lastCheckpointDoc[direction];
+    if (checkpoint &&
+    /**
+     * If the replication is already canceled,
+     * we do not write a checkpoint
+     * because that could mean we write a checkpoint
+     * for data that has been fetched from the master
+     * but not been written to the child.
+     */
+    !state.events.canceled.getValue() && (
+    /**
+     * Only write checkpoint if it is different from before
+     * to have less writes to the storage.
+     */
+
+    !previousCheckpointDoc || JSON.stringify(previousCheckpointDoc.checkpointData) !== JSON.stringify(checkpoint))) {
+      var newDoc = {
+        id: '',
+        isCheckpoint: '1',
+        itemId: direction,
+        _deleted: false,
+        _attachments: {},
+        checkpointData: checkpoint,
+        _meta: (0, _index.getDefaultRxDocumentMeta)(),
+        _rev: (0, _index.getDefaultRevision)()
+      };
+      newDoc.id = (0, _rxSchemaHelper.getComposedPrimaryKeyOfDocumentData)(state.input.metaInstance.schema, newDoc);
+      while (!state.events.canceled.getValue()) {
+        /**
+         * Instead of just storing the new checkpoint,
+         * we have to stack up the checkpoint with the previous one.
+         * This is required for plugins like the sharding RxStorage
+         * where the changeStream events only contain a Partial of the
+         * checkpoint.
+         */
+        if (previousCheckpointDoc) {
+          newDoc.checkpointData = (0, _rxStorageHelper.stackCheckpoints)([previousCheckpointDoc.checkpointData, newDoc.checkpointData]);
+        }
+        newDoc._meta.lwt = (0, _index.now)();
+        newDoc._rev = (0, _index.createRevision)(await state.checkpointKey, previousCheckpointDoc);
+        if (state.events.canceled.getValue()) {
+          return;
+        }
+        var writeRows = [{
+          previous: previousCheckpointDoc,
+          document: newDoc
+        }];
+        var result = await state.input.metaInstance.bulkWrite(writeRows, 'replication-set-checkpoint');
+        var successDoc = (0, _rxStorageHelper.getWrittenDocumentsFromBulkWriteResponse)(state.primaryPath, writeRows, result)[0];
+        if (successDoc) {
+          state.lastCheckpointDoc[direction] = successDoc;
+          return;
+        } else {
+          var error = result.error[0];
+          if (error.status !== 409) {
+            throw error;
+          } else {
+            previousCheckpointDoc = (0, _index.ensureNotFalsy)(error.documentInDb);
+            newDoc._rev = (0, _index.createRevision)(await state.checkpointKey, previousCheckpointDoc);
+          }
+        }
+      }
+    }
+  });
+  await state.checkpointQueue;
+}
+async function getCheckpointKey(input) {
+  var hash = await input.hashFunction([input.identifier, input.forkInstance.databaseName, input.forkInstance.collectionName].join('||'));
+  return 'rx_storage_replication_' + hash;
+}
+//# sourceMappingURL=checkpoint.js.map

package/dist/cjs/replication-protocol/checkpoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint.js","names":["_rxSchemaHelper","require","_rxStorageHelper","_index","getLastCheckpointDoc","state","direction","checkpointDocId","getComposedPrimaryKeyOfDocumentData","input","metaInstance","schema","isCheckpoint","itemId","checkpointResult","findDocumentsById","checkpointDoc","lastCheckpointDoc","checkpointData","undefined","setCheckpoint","checkpoint","checkpointQueue","then","previousCheckpointDoc","events","canceled","getValue","JSON","stringify","newDoc","id","_deleted","_attachments","_meta","getDefaultRxDocumentMeta","_rev","getDefaultRevision","stackCheckpoints","lwt","now","createRevision","checkpointKey","writeRows","previous","document","result","bulkWrite","successDoc","getWrittenDocumentsFromBulkWriteResponse","primaryPath","error","status","ensureNotFalsy","documentInDb","getCheckpointKey","hash","hashFunction","identifier","forkInstance","databaseName","collectionName","join"],"sources":["../../../src/replication-protocol/checkpoint.ts"],"sourcesContent":["import { getComposedPrimaryKeyOfDocumentData } from '../rx-schema-helper.ts';\r\nimport { getWrittenDocumentsFromBulkWriteResponse, stackCheckpoints } from '../rx-storage-helper.ts';\r\nimport type {\r\n    RxDocumentData,\r\n    RxStorageInstanceReplicationInput,\r\n    RxStorageInstanceReplicationState,\r\n    RxStorageReplicationDirection,\r\n    RxStorageReplicationMeta\r\n} from '../types/index.d.ts';\r\nimport {\r\n    createRevision,\r\n    ensureNotFalsy,\r\n    getDefaultRevision,\r\n    getDefaultRxDocumentMeta,\r\n    now\r\n} from '../plugins/utils/index.ts';\r\n\r\nexport async function getLastCheckpointDoc<RxDocType, CheckpointType>(\r\n    state: RxStorageInstanceReplicationState<RxDocType>,\r\n    direction: RxStorageReplicationDirection\r\n): Promise<undefined | CheckpointType> {\r\n    const checkpointDocId = getComposedPrimaryKeyOfDocumentData(\r\n        state.input.metaInstance.schema,\r\n        {\r\n            isCheckpoint: '1',\r\n            itemId: direction\r\n        }\r\n    );\r\n    const checkpointResult = await state.input.metaInstance.findDocumentsById(\r\n        [\r\n            checkpointDocId\r\n        ],\r\n        false\r\n    );\r\n\r\n    const checkpointDoc = checkpointResult[0];\r\n    state.lastCheckpointDoc[direction] = checkpointDoc;\r\n    if (checkpointDoc) {\r\n        return checkpointDoc.checkpointData;\r\n    } else {\r\n        return undefined;\r\n    }\r\n}\r\n\r\n\r\n/**\r\n * Sets the checkpoint,\r\n * automatically resolves conflicts that appear.\r\n */\r\nexport async function setCheckpoint<RxDocType, CheckpointType>(\r\n    state: RxStorageInstanceReplicationState<RxDocType>,\r\n    direction: RxStorageReplicationDirection,\r\n    checkpoint: CheckpointType\r\n) {\r\n    state.checkpointQueue = state.checkpointQueue.then(async () => {\r\n        let previousCheckpointDoc = state.lastCheckpointDoc[direction];\r\n        if (\r\n            checkpoint &&\r\n            /**\r\n             * If the replication is already canceled,\r\n             * we do not write a checkpoint\r\n             * because that could mean we write a checkpoint\r\n             * for data that has been fetched from the master\r\n             * but not been written to the child.\r\n             */\r\n            !state.events.canceled.getValue() &&\r\n            /**\r\n             * Only write checkpoint if it is different from before\r\n             * to have less writes to the storage.\r\n             */\r\n            (\r\n                !previousCheckpointDoc ||\r\n                JSON.stringify(previousCheckpointDoc.checkpointData) !== JSON.stringify(checkpoint)\r\n            )\r\n        ) {\r\n            const newDoc: RxDocumentData<RxStorageReplicationMeta<RxDocType, CheckpointType>> = {\r\n                id: '',\r\n                isCheckpoint: '1',\r\n                itemId: direction,\r\n                _deleted: false,\r\n                _attachments: {},\r\n                checkpointData: checkpoint,\r\n                _meta: getDefaultRxDocumentMeta(),\r\n                _rev: getDefaultRevision()\r\n            };\r\n            newDoc.id = getComposedPrimaryKeyOfDocumentData(\r\n                state.input.metaInstance.schema,\r\n                newDoc\r\n            );\r\n            while (!state.events.canceled.getValue()) {\r\n                /**\r\n                 * Instead of just storing the new checkpoint,\r\n                 * we have to stack up the checkpoint with the previous one.\r\n                 * This is required for plugins like the sharding RxStorage\r\n                 * where the changeStream events only contain a Partial of the\r\n                 * checkpoint.\r\n                 */\r\n                if (previousCheckpointDoc) {\r\n                    newDoc.checkpointData = stackCheckpoints([\r\n                        previousCheckpointDoc.checkpointData,\r\n                        newDoc.checkpointData\r\n                    ]);\r\n                }\r\n                newDoc._meta.lwt = now();\r\n                newDoc._rev = createRevision(\r\n                    await state.checkpointKey,\r\n                    previousCheckpointDoc\r\n                );\r\n\r\n                if (state.events.canceled.getValue()) {\r\n                    return;\r\n                }\r\n\r\n                const writeRows = [{\r\n                    previous: previousCheckpointDoc,\r\n                    document: newDoc\r\n                }];\r\n                const result = await state.input.metaInstance.bulkWrite(writeRows, 'replication-set-checkpoint');\r\n                const successDoc = getWrittenDocumentsFromBulkWriteResponse(\r\n                    state.primaryPath,\r\n                    writeRows,\r\n                    result\r\n                )[0];\r\n                if (successDoc) {\r\n                    state.lastCheckpointDoc[direction] = successDoc;\r\n                    return;\r\n                } else {\r\n                    const error = result.error[0];\r\n                    if (error.status !== 409) {\r\n                        throw error;\r\n                    } else {\r\n                        previousCheckpointDoc = ensureNotFalsy(error.documentInDb);\r\n                        newDoc._rev = createRevision(\r\n                            await state.checkpointKey,\r\n                            previousCheckpointDoc\r\n                        );\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    });\r\n    await state.checkpointQueue;\r\n}\r\n\r\nexport async function getCheckpointKey<RxDocType>(\r\n    input: RxStorageInstanceReplicationInput<RxDocType>\r\n): Promise<string> {\r\n    const hash = await input.hashFunction([\r\n        input.identifier,\r\n        input.forkInstance.databaseName,\r\n        input.forkInstance.collectionName\r\n    ].join('||'));\r\n    return 'rx_storage_replication_' + hash;\r\n}\r\n"],"mappings":";;;;;;;;AAAA,IAAAA,eAAA,GAAAC,OAAA;AACA,IAAAC,gBAAA,GAAAD,OAAA;AAQA,IAAAE,MAAA,GAAAF,OAAA;AAQO,eAAeG,oBAAoBA,CACtCC,KAAmD,EACnDC,SAAwC,EACL;EACnC,IAAMC,eAAe,GAAG,IAAAC,mDAAmC,EACvDH,KAAK,CAACI,KAAK,CAACC,YAAY,CAACC,MAAM,EAC/B;IACIC,YAAY,EAAE,GAAG;IACjBC,MAAM,EAAEP;EACZ,CACJ,CAAC;EACD,IAAMQ,gBAAgB,GAAG,MAAMT,KAAK,CAACI,KAAK,CAACC,YAAY,CAACK,iBAAiB,CACrE,CACIR,eAAe,CAClB,EACD,KACJ,CAAC;EAED,IAAMS,aAAa,GAAGF,gBAAgB,CAAC,CAAC,CAAC;EACzCT,KAAK,CAACY,iBAAiB,CAACX,SAAS,CAAC,GAAGU,aAAa;EAClD,IAAIA,aAAa,EAAE;IACf,OAAOA,aAAa,CAACE,cAAc;EACvC,CAAC,MAAM;IACH,OAAOC,SAAS;EACpB;AACJ;;AAGA;AACA;AACA;AACA;AACO,eAAeC,aAAaA,CAC/Bf,KAAmD,EACnDC,SAAwC,EACxCe,UAA0B,EAC5B;EACEhB,KAAK,CAACiB,eAAe,GAAGjB,KAAK,CAACiB,eAAe,CAACC,IAAI,CAAC,YAAY;IAC3D,IAAIC,qBAAqB,GAAGnB,KAAK,CAACY,iBAAiB,CAACX,SAAS,CAAC;IAC9D,IACIe,UAAU;IACV;AACZ;AACA;AACA;AACA;AACA;AACA;IACY,CAAChB,KAAK,CAACoB,MAAM,CAACC,QAAQ,CAACC,QAAQ,CAAC,CAAC;IACjC;AACZ;AACA;AACA;;IAEgB,CAACH,qBAAqB,IACtBI,IAAI,CAACC,SAAS,CAACL,qBAAqB,CAACN,cAAc,CAAC,KAAKU,IAAI,CAACC,SAAS,CAACR,UAAU,CAAC,CACtF,EACH;MACE,IAAMS,MAA2E,GAAG;QAChFC,EAAE,EAAE,EAAE;QACNnB,YAAY,EAAE,GAAG;QACjBC,MAAM,EAAEP,SAAS;QACjB0B,QAAQ,EAAE,KAAK;QACfC,YAAY,EAAE,CAAC,CAAC;QAChBf,cAAc,EAAEG,UAAU;QAC1Ba,KAAK,EAAE,IAAAC,+BAAwB,EAAC,CAAC;QACjCC,IAAI,EAAE,IAAAC,yBAAkB,EAAC;MAC7B,CAAC;MACDP,MAAM,CAACC,EAAE,GAAG,IAAAvB,mDAAmC,EAC3CH,KAAK,CAACI,KAAK,CAACC,YAAY,CAACC,MAAM,EAC/BmB,MACJ,CAAC;MACD,OAAO,CAACzB,KAAK,CAACoB,MAAM,CAACC,QAAQ,CAACC,QAAQ,CAAC,CAAC,EAAE;QACtC;AAChB;AACA;AACA;AACA;AACA;AACA;QACgB,IAAIH,qBAAqB,EAAE;UACvBM,MAAM,CAACZ,cAAc,GAAG,IAAAoB,iCAAgB,EAAC,CACrCd,qBAAqB,CAACN,cAAc,EACpCY,MAAM,CAACZ,cAAc,CACxB,CAAC;QACN;QACAY,MAAM,CAACI,KAAK,CAACK,GAAG,GAAG,IAAAC,UAAG,EAAC,CAAC;QACxBV,MAAM,CAACM,IAAI,GAAG,IAAAK,qBAAc,EACxB,MAAMpC,KAAK,CAACqC,aAAa,EACzBlB,qBACJ,CAAC;QAED,IAAInB,KAAK,CAACoB,MAAM,CAACC,QAAQ,CAACC,QAAQ,CAAC,CAAC,EAAE;UAClC;QACJ;QAEA,IAAMgB,SAAS,GAAG,CAAC;UACfC,QAAQ,EAAEpB,qBAAqB;UAC/BqB,QAAQ,EAAEf;QACd,CAAC,CAAC;QACF,IAAMgB,MAAM,GAAG,MAAMzC,KAAK,CAACI,KAAK,CAACC,YAAY,CAACqC,SAAS,CAACJ,SAAS,EAAE,4BAA4B,CAAC;QAChG,IAAMK,UAAU,GAAG,IAAAC,yDAAwC,EACvD5C,KAAK,CAAC6C,WAAW,EACjBP,SAAS,EACTG,MACJ,CAAC,CAAC,CAAC,CAAC;QACJ,IAAIE,UAAU,EAAE;UACZ3C,KAAK,CAACY,iBAAiB,CAACX,SAAS,CAAC,GAAG0C,UAAU;UAC/C;QACJ,CAAC,MAAM;UACH,IAAMG,KAAK,GAAGL,MAAM,CAACK,KAAK,CAAC,CAAC,CAAC;UAC7B,IAAIA,KAAK,CAACC,MAAM,KAAK,GAAG,EAAE;YACtB,MAAMD,KAAK;UACf,CAAC,MAAM;YACH3B,qBAAqB,GAAG,IAAA6B,qBAAc,EAACF,KAAK,CAACG,YAAY,CAAC;YAC1DxB,MAAM,CAACM,IAAI,GAAG,IAAAK,qBAAc,EACxB,MAAMpC,KAAK,CAACqC,aAAa,EACzBlB,qBACJ,CAAC;UACL;QACJ;MACJ;IACJ;EACJ,CAAC,CAAC;EACF,MAAMnB,KAAK,CAACiB,eAAe;AAC/B;AAEO,eAAeiC,gBAAgBA,CAClC9C,KAAmD,EACpC;EACf,IAAM+C,IAAI,GAAG,MAAM/C,KAAK,CAACgD,YAAY,CAAC,CAClChD,KAAK,CAACiD,UAAU,EAChBjD,KAAK,CAACkD,YAAY,CAACC,YAAY,EAC/BnD,KAAK,CAACkD,YAAY,CAACE,cAAc,CACpC,CAACC,IAAI,CAAC,IAAI,CAAC,CAAC;EACb,OAAO,yBAAyB,GAAGN,IAAI;AAC3C","ignoreList":[]}

package/dist/cjs/replication-protocol/conflicts.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveConflictError = resolveConflictError;
+var _index = require("../plugins/utils/index.js");
+/**
+ * Resolves a conflict error or determines that the given document states are equal.
+ * Returns the resolved document that must be written to the fork.
+ * Then the new document state can be pushed upstream.
+ * If document is not in conflict, returns undefined.
+ * If error is non-409, it throws an error.
+ * Conflicts are only solved in the upstream, never in the downstream.
+ */
+async function resolveConflictError(state, input, forkState) {
+  var conflictHandler = state.input.conflictHandler;
+  var resolved = await conflictHandler.resolve(input, 'replication-resolve-conflict');
+  /**
+   * We have a resolved conflict,
+   * use the resolved document data.
+   */
+  var resolvedDoc = Object.assign({}, resolved, {
+    /**
+     * Because the resolved conflict is written to the fork,
+     * we have to keep/update the forks _meta data, not the masters.
+     */
+    _meta: (0, _index.flatClone)(forkState._meta),
+    _rev: (0, _index.getDefaultRevision)(),
+    _attachments: (0, _index.flatClone)(forkState._attachments)
+  });
+  resolvedDoc._meta.lwt = (0, _index.now)();
+  resolvedDoc._rev = (0, _index.createRevision)(await state.checkpointKey, forkState);
+  return resolvedDoc;
+}
+//# sourceMappingURL=conflicts.js.map

package/dist/cjs/replication-protocol/conflicts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conflicts.js","names":["_index","require","resolveConflictError","state","input","forkState","conflictHandler","resolved","resolve","resolvedDoc","Object","assign","_meta","flatClone","_rev","getDefaultRevision","_attachments","lwt","now","createRevision","checkpointKey"],"sources":["../../../src/replication-protocol/conflicts.ts"],"sourcesContent":["import type {\r\n    RxConflictHandler,\r\n    RxConflictHandlerInput,\r\n    RxDocumentData,\r\n    RxStorageInstanceReplicationState\r\n} from '../types/index.d.ts';\r\nimport {\r\n    getDefaultRevision,\r\n    createRevision,\r\n    now,\r\n    flatClone\r\n} from '../plugins/utils/index.ts';\r\n\r\n/**\r\n * Resolves a conflict error or determines that the given document states are equal.\r\n * Returns the resolved document that must be written to the fork.\r\n * Then the new document state can be pushed upstream.\r\n * If document is not in conflict, returns undefined.\r\n * If error is non-409, it throws an error.\r\n * Conflicts are only solved in the upstream, never in the downstream.\r\n */\r\nexport async function resolveConflictError<RxDocType>(\r\n    state: RxStorageInstanceReplicationState<RxDocType>,\r\n    input: RxConflictHandlerInput<RxDocType>,\r\n    forkState: RxDocumentData<RxDocType>\r\n): Promise<RxDocumentData<RxDocType> | undefined> {\r\n    const conflictHandler: RxConflictHandler<RxDocType> = state.input.conflictHandler;\r\n\r\n    const resolved = await conflictHandler.resolve(input, 'replication-resolve-conflict');\r\n    /**\r\n     * We have a resolved conflict,\r\n     * use the resolved document data.\r\n     */\r\n    const resolvedDoc: RxDocumentData<RxDocType> = Object.assign(\r\n        {},\r\n        resolved,\r\n        {\r\n            /**\r\n             * Because the resolved conflict is written to the fork,\r\n             * we have to keep/update the forks _meta data, not the masters.\r\n             */\r\n            _meta: flatClone(forkState._meta),\r\n            _rev: getDefaultRevision(),\r\n            _attachments: flatClone(forkState._attachments)\r\n        }\r\n    ) as any;\r\n    resolvedDoc._meta.lwt = now();\r\n    resolvedDoc._rev = createRevision(\r\n        await state.checkpointKey,\r\n        forkState\r\n    );\r\n    return resolvedDoc;\r\n}\r\n"],"mappings":";;;;;;AAMA,IAAAA,MAAA,GAAAC,OAAA;AAOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,eAAeC,oBAAoBA,CACtCC,KAAmD,EACnDC,KAAwC,EACxCC,SAAoC,EACU;EAC9C,IAAMC,eAA6C,GAAGH,KAAK,CAACC,KAAK,CAACE,eAAe;EAEjF,IAAMC,QAAQ,GAAG,MAAMD,eAAe,CAACE,OAAO,CAACJ,KAAK,EAAE,8BAA8B,CAAC;EACrF;AACJ;AACA;AACA;EACI,IAAMK,WAAsC,GAAGC,MAAM,CAACC,MAAM,CACxD,CAAC,CAAC,EACFJ,QAAQ,EACR;IACI;AACZ;AACA;AACA;IACYK,KAAK,EAAE,IAAAC,gBAAS,EAACR,SAAS,CAACO,KAAK,CAAC;IACjCE,IAAI,EAAE,IAAAC,yBAAkB,EAAC,CAAC;IAC1BC,YAAY,EAAE,IAAAH,gBAAS,EAACR,SAAS,CAACW,YAAY;EAClD,CACJ,CAAQ;EACRP,WAAW,CAACG,KAAK,CAACK,GAAG,GAAG,IAAAC,UAAG,EAAC,CAAC;EAC7BT,WAAW,CAACK,IAAI,GAAG,IAAAK,qBAAc,EAC7B,MAAMhB,KAAK,CAACiB,aAAa,EACzBf,SACJ,CAAC;EACD,OAAOI,WAAW;AACtB","ignoreList":[]}

package/dist/cjs/replication-protocol/default-conflict-handler.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultConflictHandler = void 0;
+var _index = require("../plugins/utils/index.js");
+var _rxStorageHelper = require("../rx-storage-helper.js");
+var defaultConflictHandler = exports.defaultConflictHandler = {
+  isEqual(a, b, _ctx) {
+    a = addAttachmentsIfNotExists(a);
+    b = addAttachmentsIfNotExists(b);
+
+    /**
+     * If the documents are deep equal,
+     * we have no conflict.
+     * On your custom conflict handler you might only
+     * check some properties, like the updatedAt time,
+     * for better performance, because deepEqual is expensive.
+    */
+    var ret = (0, _index.deepEqual)((0, _rxStorageHelper.stripAttachmentsDataFromDocument)(a), (0, _rxStorageHelper.stripAttachmentsDataFromDocument)(b));
+    return ret;
+  },
+  resolve(i) {
+    /**
+     * The default conflict handler will always
+     * drop the fork state and use the master state instead.
+     */
+    return i.realMasterState;
+  }
+};
+function addAttachmentsIfNotExists(d) {
+  if (!d._attachments) {
+    d = (0, _index.flatClone)(d);
+    d._attachments = {};
+  }
+  return d;
+}
+//# sourceMappingURL=default-conflict-handler.js.map

package/dist/cjs/replication-protocol/default-conflict-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-conflict-handler.js","names":["_index","require","_rxStorageHelper","defaultConflictHandler","exports","isEqual","a","b","_ctx","addAttachmentsIfNotExists","ret","deepEqual","stripAttachmentsDataFromDocument","resolve","i","realMasterState","d","_attachments","flatClone"],"sources":["../../../src/replication-protocol/default-conflict-handler.ts"],"sourcesContent":["import {\r\n    deepEqual,\r\n    flatClone\r\n} from '../plugins/utils/index.ts';\r\nimport { stripAttachmentsDataFromDocument } from '../rx-storage-helper.ts';\r\nimport type { RxConflictHandler, RxDocumentData } from '../types';\r\n\r\nexport const defaultConflictHandler: RxConflictHandler<any> = {\r\n    isEqual(a, b, _ctx) {\r\n        a = addAttachmentsIfNotExists(a);\r\n        b = addAttachmentsIfNotExists(b);\r\n\r\n        /**\r\n         * If the documents are deep equal,\r\n         * we have no conflict.\r\n         * On your custom conflict handler you might only\r\n         * check some properties, like the updatedAt time,\r\n         * for better performance, because deepEqual is expensive.\r\n        */\r\n        const ret = deepEqual(\r\n            stripAttachmentsDataFromDocument(a),\r\n            stripAttachmentsDataFromDocument(b)\r\n        );\r\n\r\n        return ret;\r\n    },\r\n    resolve(i) {\r\n        /**\r\n         * The default conflict handler will always\r\n         * drop the fork state and use the master state instead.\r\n         */\r\n        return i.realMasterState;\r\n    }\r\n};\r\n\r\n\r\nfunction addAttachmentsIfNotExists<T>(d: RxDocumentData<T>): RxDocumentData<T> {\r\n    if (!d._attachments) {\r\n        d = flatClone(d);\r\n        d._attachments = {};\r\n    }\r\n    return d;\r\n}\r\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAIA,IAAAC,gBAAA,GAAAD,OAAA;AAGO,IAAME,sBAA8C,GAAAC,OAAA,CAAAD,sBAAA,GAAG;EAC1DE,OAAOA,CAACC,CAAC,EAAEC,CAAC,EAAEC,IAAI,EAAE;IAChBF,CAAC,GAAGG,yBAAyB,CAACH,CAAC,CAAC;IAChCC,CAAC,GAAGE,yBAAyB,CAACF,CAAC,CAAC;;IAEhC;AACR;AACA;AACA;AACA;AACA;AACA;IACQ,IAAMG,GAAG,GAAG,IAAAC,gBAAS,EACjB,IAAAC,iDAAgC,EAACN,CAAC,CAAC,EACnC,IAAAM,iDAAgC,EAACL,CAAC,CACtC,CAAC;IAED,OAAOG,GAAG;EACd,CAAC;EACDG,OAAOA,CAACC,CAAC,EAAE;IACP;AACR;AACA;AACA;IACQ,OAAOA,CAAC,CAACC,eAAe;EAC5B;AACJ,CAAC;AAGD,SAASN,yBAAyBA,CAAIO,CAAoB,EAAqB;EAC3E,IAAI,CAACA,CAAC,CAACC,YAAY,EAAE;IACjBD,CAAC,GAAG,IAAAE,gBAAS,EAACF,CAAC,CAAC;IAChBA,CAAC,CAACC,YAAY,GAAG,CAAC,CAAC;EACvB;EACA,OAAOD,CAAC;AACZ","ignoreList":[]}