@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/esm/custom-index.js

@@ -0,0 +1,271 @@
+/**
+ * For some RxStorage implementations,
+ * we need to use our custom crafted indexes
+ * so we can easily iterate over them. And sort plain arrays of document data.
+ *
+ * We really often have to craft an index string for a given document.
+ * Performance of everything in this file is very important
+ * which is why the code sometimes looks strange.
+ * Run performance tests before and after you touch anything here!
+ */
+
+import { getSchemaByObjectPath } from "./rx-schema-helper.js";
+import { ensureNotFalsy, objectPathMonad } from "./plugins/utils/index.js";
+import { INDEX_MAX, INDEX_MIN } from "./query-planner.js";
+
+/**
+ * Prepare all relevant information
+ * outside of the returned function
+ * from getIndexableStringMonad()
+ * to save performance when the returned
+ * function is called many times.
+ */
+
+export function getIndexMeta(schema, index) {
+  var fieldNameProperties = index.map(fieldName => {
+    var schemaPart = getSchemaByObjectPath(schema, fieldName);
+    if (!schemaPart) {
+      throw new Error('not in schema: ' + fieldName);
+    }
+    var type = schemaPart.type;
+    var parsedLengths;
+    if (type === 'number' || type === 'integer') {
+      parsedLengths = getStringLengthOfIndexNumber(schemaPart);
+    }
+    var getValue = objectPathMonad(fieldName);
+    var maxLength = schemaPart.maxLength ? schemaPart.maxLength : 0;
+    var getIndexStringPart;
+    if (type === 'string') {
+      getIndexStringPart = docData => {
+        var fieldValue = getValue(docData);
+        if (!fieldValue) {
+          fieldValue = '';
+        }
+        return fieldValue.padEnd(maxLength, ' ');
+      };
+    } else if (type === 'boolean') {
+      getIndexStringPart = docData => {
+        var fieldValue = getValue(docData);
+        return fieldValue ? '1' : '0';
+      };
+    } else {
+      // number
+      getIndexStringPart = docData => {
+        var fieldValue = getValue(docData);
+        return getNumberIndexString(parsedLengths, fieldValue);
+      };
+    }
+    var ret = {
+      fieldName,
+      schemaPart,
+      parsedLengths,
+      getValue,
+      getIndexStringPart
+    };
+    return ret;
+  });
+  return fieldNameProperties;
+}
+
+/**
+ * Crafts an indexable string that can be used
+ * to check if a document would be sorted below or above
+ * another documents, dependent on the index values.
+ * @monad for better performance
+ *
+ * IMPORTANT: Performance is really important here
+ * which is why we code so 'strange'.
+ * Always run performance tests when you want to
+ * change something in this method.
+ */
+export function getIndexableStringMonad(schema, index) {
+  var fieldNameProperties = getIndexMeta(schema, index);
+  var fieldNamePropertiesAmount = fieldNameProperties.length;
+  var indexPartsFunctions = fieldNameProperties.map(r => r.getIndexStringPart);
+
+  /**
+   * @hotPath Performance of this function is very critical!
+   */
+  var ret = function (docData) {
+    var str = '';
+    for (var i = 0; i < fieldNamePropertiesAmount; ++i) {
+      str += indexPartsFunctions[i](docData);
+    }
+    return str;
+  };
+  return ret;
+}
+export function getStringLengthOfIndexNumber(schemaPart) {
+  var minimum = Math.floor(schemaPart.minimum);
+  var maximum = Math.ceil(schemaPart.maximum);
+  var multipleOf = schemaPart.multipleOf;
+  var valueSpan = maximum - minimum;
+  var nonDecimals = valueSpan.toString().length;
+  var multipleOfParts = multipleOf.toString().split('.');
+  var decimals = 0;
+  if (multipleOfParts.length > 1) {
+    decimals = multipleOfParts[1].length;
+  }
+  return {
+    minimum,
+    maximum,
+    nonDecimals,
+    decimals,
+    roundedMinimum: minimum
+  };
+}
+export function getIndexStringLength(schema, index) {
+  var fieldNameProperties = getIndexMeta(schema, index);
+  var length = 0;
+  fieldNameProperties.forEach(props => {
+    var schemaPart = props.schemaPart;
+    var type = schemaPart.type;
+    if (type === 'string') {
+      length += schemaPart.maxLength;
+    } else if (type === 'boolean') {
+      length += 1;
+    } else {
+      var parsedLengths = props.parsedLengths;
+      length = length + parsedLengths.nonDecimals + parsedLengths.decimals;
+    }
+  });
+  return length;
+}
+export function getPrimaryKeyFromIndexableString(indexableString, primaryKeyLength) {
+  var paddedPrimaryKey = indexableString.slice(primaryKeyLength * -1);
+  // we can safely trim here because the primary key is not allowed to start or end with a space char.
+  var primaryKey = paddedPrimaryKey.trim();
+  return primaryKey;
+}
+export function getNumberIndexString(parsedLengths, fieldValue) {
+  /**
+   * Ensure that the given value is in the boundaries
+   * of the schema, otherwise it would create a broken index string.
+   * This can happen for example if you have a minimum of 0
+   * and run a query like
+   * selector {
+   *  numField: { $gt: -1000 }
+   * }
+   */
+  if (typeof fieldValue === 'undefined') {
+    fieldValue = 0;
+  }
+  if (fieldValue < parsedLengths.minimum) {
+    fieldValue = parsedLengths.minimum;
+  }
+  if (fieldValue > parsedLengths.maximum) {
+    fieldValue = parsedLengths.maximum;
+  }
+  var nonDecimalsValueAsString = (Math.floor(fieldValue) - parsedLengths.roundedMinimum).toString();
+  var str = nonDecimalsValueAsString.padStart(parsedLengths.nonDecimals, '0');
+  if (parsedLengths.decimals > 0) {
+    var splitByDecimalPoint = fieldValue.toString().split('.');
+    var decimalValueAsString = splitByDecimalPoint.length > 1 ? splitByDecimalPoint[1] : '0';
+    str += decimalValueAsString.padEnd(parsedLengths.decimals, '0');
+  }
+  return str;
+}
+export function getStartIndexStringFromLowerBound(schema, index, lowerBound) {
+  var str = '';
+  index.forEach((fieldName, idx) => {
+    var schemaPart = getSchemaByObjectPath(schema, fieldName);
+    var bound = lowerBound[idx];
+    var type = schemaPart.type;
+    switch (type) {
+      case 'string':
+        var maxLength = ensureNotFalsy(schemaPart.maxLength, 'maxLength not set');
+        if (typeof bound === 'string') {
+          str += bound.padEnd(maxLength, ' ');
+        } else {
+          // str += ''.padStart(maxLength, inclusiveStart ? ' ' : INDEX_MAX);
+          str += ''.padEnd(maxLength, ' ');
+        }
+        break;
+      case 'boolean':
+        if (bound === null) {
+          str += '0';
+        } else if (bound === INDEX_MIN) {
+          str += '0';
+        } else if (bound === INDEX_MAX) {
+          str += '1';
+        } else {
+          var boolToStr = bound ? '1' : '0';
+          str += boolToStr;
+        }
+        break;
+      case 'number':
+      case 'integer':
+        var parsedLengths = getStringLengthOfIndexNumber(schemaPart);
+        if (bound === null || bound === INDEX_MIN) {
+          var fillChar = '0';
+          str += fillChar.repeat(parsedLengths.nonDecimals + parsedLengths.decimals);
+        } else if (bound === INDEX_MAX) {
+          str += getNumberIndexString(parsedLengths, parsedLengths.maximum);
+        } else {
+          var add = getNumberIndexString(parsedLengths, bound);
+          str += add;
+        }
+        break;
+      default:
+        throw new Error('unknown index type ' + type);
+    }
+  });
+  return str;
+}
+export function getStartIndexStringFromUpperBound(schema, index, upperBound) {
+  var str = '';
+  index.forEach((fieldName, idx) => {
+    var schemaPart = getSchemaByObjectPath(schema, fieldName);
+    var bound = upperBound[idx];
+    var type = schemaPart.type;
+    switch (type) {
+      case 'string':
+        var maxLength = ensureNotFalsy(schemaPart.maxLength, 'maxLength not set');
+        if (typeof bound === 'string' && bound !== INDEX_MAX) {
+          str += bound.padEnd(maxLength, ' ');
+        } else if (bound === INDEX_MIN) {
+          str += ''.padEnd(maxLength, ' ');
+        } else {
+          str += ''.padEnd(maxLength, INDEX_MAX);
+        }
+        break;
+      case 'boolean':
+        if (bound === null) {
+          str += '1';
+        } else {
+          var boolToStr = bound ? '1' : '0';
+          str += boolToStr;
+        }
+        break;
+      case 'number':
+      case 'integer':
+        var parsedLengths = getStringLengthOfIndexNumber(schemaPart);
+        if (bound === null || bound === INDEX_MAX) {
+          var fillChar = '9';
+          str += fillChar.repeat(parsedLengths.nonDecimals + parsedLengths.decimals);
+        } else if (bound === INDEX_MIN) {
+          var _fillChar = '0';
+          str += _fillChar.repeat(parsedLengths.nonDecimals + parsedLengths.decimals);
+        } else {
+          str += getNumberIndexString(parsedLengths, bound);
+        }
+        break;
+      default:
+        throw new Error('unknown index type ' + type);
+    }
+  });
+  return str;
+}
+
+/**
+ * Used in storages where it is not possible
+ * to define inclusiveEnd/inclusiveStart
+ */
+export function changeIndexableStringByOneQuantum(str, direction) {
+  var lastChar = str.slice(-1);
+  var charCode = lastChar.charCodeAt(0);
+  charCode = charCode + direction;
+  var withoutLastChar = str.slice(0, -1);
+  return withoutLastChar + String.fromCharCode(charCode);
+}
+//# sourceMappingURL=custom-index.js.map

package/dist/esm/custom-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-index.js","names":["getSchemaByObjectPath","ensureNotFalsy","objectPathMonad","INDEX_MAX","INDEX_MIN","getIndexMeta","schema","index","fieldNameProperties","map","fieldName","schemaPart","Error","type","parsedLengths","getStringLengthOfIndexNumber","getValue","maxLength","getIndexStringPart","docData","fieldValue","padEnd","getNumberIndexString","ret","getIndexableStringMonad","fieldNamePropertiesAmount","length","indexPartsFunctions","r","str","i","minimum","Math","floor","maximum","ceil","multipleOf","valueSpan","nonDecimals","toString","multipleOfParts","split","decimals","roundedMinimum","getIndexStringLength","forEach","props","getPrimaryKeyFromIndexableString","indexableString","primaryKeyLength","paddedPrimaryKey","slice","primaryKey","trim","nonDecimalsValueAsString","padStart","splitByDecimalPoint","decimalValueAsString","getStartIndexStringFromLowerBound","lowerBound","idx","bound","boolToStr","fillChar","repeat","add","getStartIndexStringFromUpperBound","upperBound","changeIndexableStringByOneQuantum","direction","lastChar","charCode","charCodeAt","withoutLastChar","String","fromCharCode"],"sources":["../../src/custom-index.ts"],"sourcesContent":["/**\r\n * For some RxStorage implementations,\r\n * we need to use our custom crafted indexes\r\n * so we can easily iterate over them. And sort plain arrays of document data.\r\n *\r\n * We really often have to craft an index string for a given document.\r\n * Performance of everything in this file is very important\r\n * which is why the code sometimes looks strange.\r\n * Run performance tests before and after you touch anything here!\r\n */\r\n\r\nimport {\r\n    getSchemaByObjectPath\r\n} from './rx-schema-helper.ts';\r\nimport type {\r\n    JsonSchema,\r\n    RxDocumentData,\r\n    RxJsonSchema\r\n} from './types/index.d.ts';\r\nimport {\r\n    ensureNotFalsy,\r\n    objectPathMonad,\r\n    ObjectPathMonadFunction\r\n} from './plugins/utils/index.ts';\r\nimport {\r\n    INDEX_MAX,\r\n    INDEX_MIN\r\n} from './query-planner.ts';\r\n\r\n\r\n/**\r\n * Prepare all relevant information\r\n * outside of the returned function\r\n * from getIndexableStringMonad()\r\n * to save performance when the returned\r\n * function is called many times.\r\n */\r\ntype IndexMetaField<RxDocType> = {\r\n    fieldName: string;\r\n    schemaPart: JsonSchema;\r\n    /*\r\n     * Only in number fields.\r\n     */\r\n    parsedLengths?: ParsedLengths;\r\n    getValue: ObjectPathMonadFunction<RxDocType>;\r\n    getIndexStringPart: (docData: RxDocumentData<RxDocType>) => string;\r\n};\r\n\r\nexport function getIndexMeta<RxDocType>(\r\n    schema: RxJsonSchema<RxDocumentData<RxDocType>>,\r\n    index: string[]\r\n): IndexMetaField<RxDocType>[] {\r\n    const fieldNameProperties: IndexMetaField<RxDocType>[] = index.map(fieldName => {\r\n        const schemaPart = getSchemaByObjectPath(\r\n            schema,\r\n            fieldName\r\n        );\r\n        if (!schemaPart) {\r\n            throw new Error('not in schema: ' + fieldName);\r\n        }\r\n        const type = schemaPart.type;\r\n        let parsedLengths: ParsedLengths | undefined;\r\n        if (type === 'number' || type === 'integer') {\r\n            parsedLengths = getStringLengthOfIndexNumber(\r\n                schemaPart\r\n            );\r\n        }\r\n\r\n        const getValue = objectPathMonad(fieldName);\r\n        const maxLength = schemaPart.maxLength ? schemaPart.maxLength : 0;\r\n\r\n        let getIndexStringPart: (docData: RxDocumentData<RxDocType>) => string;\r\n        if (type === 'string') {\r\n            getIndexStringPart = docData => {\r\n                let fieldValue = getValue(docData);\r\n                if (!fieldValue) {\r\n                    fieldValue = '';\r\n                }\r\n                return fieldValue.padEnd(maxLength, ' ');\r\n            };\r\n        } else if (type === 'boolean') {\r\n            getIndexStringPart = docData => {\r\n                const fieldValue = getValue(docData);\r\n                return fieldValue ? '1' : '0';\r\n            };\r\n        } else { // number\r\n            getIndexStringPart = docData => {\r\n                const fieldValue = getValue(docData);\r\n                return getNumberIndexString(\r\n                    parsedLengths as any,\r\n                    fieldValue\r\n                );\r\n            };\r\n        }\r\n\r\n        const ret: IndexMetaField<RxDocType> = {\r\n            fieldName,\r\n            schemaPart,\r\n            parsedLengths,\r\n            getValue,\r\n            getIndexStringPart\r\n        };\r\n        return ret;\r\n    });\r\n    return fieldNameProperties;\r\n}\r\n\r\n\r\n/**\r\n * Crafts an indexable string that can be used\r\n * to check if a document would be sorted below or above\r\n * another documents, dependent on the index values.\r\n * @monad for better performance\r\n *\r\n * IMPORTANT: Performance is really important here\r\n * which is why we code so 'strange'.\r\n * Always run performance tests when you want to\r\n * change something in this method.\r\n */\r\nexport function getIndexableStringMonad<RxDocType>(\r\n    schema: RxJsonSchema<RxDocumentData<RxDocType>>,\r\n    index: string[]\r\n): (docData: RxDocumentData<RxDocType>) => string {\r\n    const fieldNameProperties = getIndexMeta(schema, index);\r\n    const fieldNamePropertiesAmount = fieldNameProperties.length;\r\n    const indexPartsFunctions = fieldNameProperties.map(r => r.getIndexStringPart);\r\n\r\n\r\n    /**\r\n     * @hotPath Performance of this function is very critical!\r\n     */\r\n    const ret = function (docData: RxDocumentData<RxDocType>): string {\r\n        let str = '';\r\n        for (let i = 0; i < fieldNamePropertiesAmount; ++i) {\r\n            str += indexPartsFunctions[i](docData);\r\n        }\r\n        return str;\r\n    };\r\n    return ret;\r\n}\r\n\r\n\r\ndeclare type ParsedLengths = {\r\n    minimum: number;\r\n    maximum: number;\r\n    nonDecimals: number;\r\n    decimals: number;\r\n    roundedMinimum: number;\r\n};\r\nexport function getStringLengthOfIndexNumber(\r\n    schemaPart: JsonSchema\r\n): ParsedLengths {\r\n    const minimum = Math.floor(schemaPart.minimum as number);\r\n    const maximum = Math.ceil(schemaPart.maximum as number);\r\n    const multipleOf: number = schemaPart.multipleOf as number;\r\n\r\n    const valueSpan = maximum - minimum;\r\n    const nonDecimals = valueSpan.toString().length;\r\n\r\n    const multipleOfParts = multipleOf.toString().split('.');\r\n    let decimals = 0;\r\n    if (multipleOfParts.length > 1) {\r\n        decimals = multipleOfParts[1].length;\r\n    }\r\n    return {\r\n        minimum,\r\n        maximum,\r\n        nonDecimals,\r\n        decimals,\r\n        roundedMinimum: minimum\r\n    };\r\n}\r\n\r\nexport function getIndexStringLength<RxDocType>(\r\n    schema: RxJsonSchema<RxDocumentData<RxDocType>>,\r\n    index: string[]\r\n): number {\r\n    const fieldNameProperties = getIndexMeta(schema, index);\r\n    let length = 0;\r\n    fieldNameProperties.forEach(props => {\r\n        const schemaPart = props.schemaPart;\r\n        const type = schemaPart.type;\r\n\r\n        if (type === 'string') {\r\n            length += schemaPart.maxLength as number;\r\n        } else if (type === 'boolean') {\r\n            length += 1;\r\n        } else {\r\n            const parsedLengths = props.parsedLengths as ParsedLengths;\r\n            length = length + parsedLengths.nonDecimals + parsedLengths.decimals;\r\n        }\r\n\r\n    });\r\n    return length;\r\n}\r\n\r\n\r\nexport function getPrimaryKeyFromIndexableString(\r\n    indexableString: string,\r\n    primaryKeyLength: number\r\n): string {\r\n    const paddedPrimaryKey = indexableString.slice(primaryKeyLength * -1);\r\n    // we can safely trim here because the primary key is not allowed to start or end with a space char.\r\n    const primaryKey = paddedPrimaryKey.trim();\r\n    return primaryKey;\r\n}\r\n\r\n\r\nexport function getNumberIndexString(\r\n    parsedLengths: ParsedLengths,\r\n    fieldValue: number\r\n): string {\r\n    /**\r\n     * Ensure that the given value is in the boundaries\r\n     * of the schema, otherwise it would create a broken index string.\r\n     * This can happen for example if you have a minimum of 0\r\n     * and run a query like\r\n     * selector {\r\n     *  numField: { $gt: -1000 }\r\n     * }\r\n     */\r\n    if (typeof fieldValue === 'undefined') {\r\n        fieldValue = 0;\r\n    }\r\n    if (fieldValue < parsedLengths.minimum) {\r\n        fieldValue = parsedLengths.minimum;\r\n    }\r\n    if (fieldValue > parsedLengths.maximum) {\r\n        fieldValue = parsedLengths.maximum;\r\n    }\r\n\r\n    const nonDecimalsValueAsString = (Math.floor(fieldValue) - parsedLengths.roundedMinimum).toString();\r\n    let str = nonDecimalsValueAsString.padStart(parsedLengths.nonDecimals, '0');\r\n\r\n    if (parsedLengths.decimals > 0) {\r\n        const splitByDecimalPoint = fieldValue.toString().split('.');\r\n        const decimalValueAsString = splitByDecimalPoint.length > 1 ? splitByDecimalPoint[1] : '0';\r\n        str += decimalValueAsString.padEnd(parsedLengths.decimals, '0');\r\n    }\r\n    return str;\r\n}\r\n\r\nexport function getStartIndexStringFromLowerBound(\r\n    schema: RxJsonSchema<any>,\r\n    index: string[],\r\n    lowerBound: (string | boolean | number | null | undefined)[]\r\n): string {\r\n    let str = '';\r\n    index.forEach((fieldName, idx) => {\r\n        const schemaPart = getSchemaByObjectPath(\r\n            schema,\r\n            fieldName\r\n        );\r\n        const bound = lowerBound[idx];\r\n        const type = schemaPart.type;\r\n\r\n        switch (type) {\r\n            case 'string':\r\n                const maxLength = ensureNotFalsy(schemaPart.maxLength, 'maxLength not set');\r\n                if (typeof bound === 'string') {\r\n                    str += (bound as string).padEnd(maxLength, ' ');\r\n                } else {\r\n                    // str += ''.padStart(maxLength, inclusiveStart ? ' ' : INDEX_MAX);\r\n                    str += ''.padEnd(maxLength, ' ');\r\n                }\r\n                break;\r\n            case 'boolean':\r\n                if (bound === null) {\r\n                    str += '0';\r\n                } else if (bound === INDEX_MIN) {\r\n                    str += '0';\r\n                } else if (bound === INDEX_MAX) {\r\n                    str += '1';\r\n                } else {\r\n                    const boolToStr = bound ? '1' : '0';\r\n                    str += boolToStr;\r\n                }\r\n                break;\r\n            case 'number':\r\n            case 'integer':\r\n                const parsedLengths = getStringLengthOfIndexNumber(\r\n                    schemaPart\r\n                );\r\n                if (bound === null || bound === INDEX_MIN) {\r\n                    const fillChar = '0';\r\n                    str += fillChar.repeat(parsedLengths.nonDecimals + parsedLengths.decimals);\r\n                } else if (bound === INDEX_MAX) {\r\n                    str += getNumberIndexString(\r\n                        parsedLengths,\r\n                        parsedLengths.maximum\r\n                    );\r\n                } else {\r\n                    const add = getNumberIndexString(\r\n                        parsedLengths,\r\n                        bound as number\r\n                    );\r\n                    str += add;\r\n                }\r\n                break;\r\n            default:\r\n                throw new Error('unknown index type ' + type);\r\n        }\r\n    });\r\n    return str;\r\n}\r\n\r\n\r\nexport function getStartIndexStringFromUpperBound(\r\n    schema: RxJsonSchema<any>,\r\n    index: string[],\r\n    upperBound: (string | boolean | number | null | undefined)[]\r\n): string {\r\n    let str = '';\r\n    index.forEach((fieldName, idx) => {\r\n        const schemaPart = getSchemaByObjectPath(\r\n            schema,\r\n            fieldName\r\n        );\r\n        const bound = upperBound[idx];\r\n        const type = schemaPart.type;\r\n\r\n        switch (type) {\r\n            case 'string':\r\n                const maxLength = ensureNotFalsy(schemaPart.maxLength, 'maxLength not set');\r\n                if (typeof bound === 'string' && bound !== INDEX_MAX) {\r\n                    str += (bound as string).padEnd(maxLength, ' ');\r\n                } else if (bound === INDEX_MIN) {\r\n                    str += ''.padEnd(maxLength, ' ');\r\n                } else {\r\n                    str += ''.padEnd(maxLength, INDEX_MAX);\r\n                }\r\n                break;\r\n            case 'boolean':\r\n                if (bound === null) {\r\n                    str += '1';\r\n                } else {\r\n                    const boolToStr = bound ? '1' : '0';\r\n                    str += boolToStr;\r\n                }\r\n                break;\r\n            case 'number':\r\n            case 'integer':\r\n                const parsedLengths = getStringLengthOfIndexNumber(\r\n                    schemaPart\r\n                );\r\n                if (bound === null || bound === INDEX_MAX) {\r\n                    const fillChar = '9';\r\n                    str += fillChar.repeat(parsedLengths.nonDecimals + parsedLengths.decimals);\r\n                } else if (bound === INDEX_MIN) {\r\n                    const fillChar = '0';\r\n                    str += fillChar.repeat(parsedLengths.nonDecimals + parsedLengths.decimals);\r\n                } else {\r\n                    str += getNumberIndexString(\r\n                        parsedLengths,\r\n                        bound as number\r\n                    );\r\n                }\r\n                break;\r\n            default:\r\n                throw new Error('unknown index type ' + type);\r\n        }\r\n    });\r\n    return str;\r\n}\r\n\r\n/**\r\n * Used in storages where it is not possible\r\n * to define inclusiveEnd/inclusiveStart\r\n */\r\nexport function changeIndexableStringByOneQuantum(str: string, direction: 1 | -1): string {\r\n    const lastChar = str.slice(-1);\r\n    let charCode = lastChar.charCodeAt(0);\r\n    charCode = charCode + direction;\r\n    const withoutLastChar = str.slice(0, -1);\r\n    return withoutLastChar + String.fromCharCode(charCode);\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/doc-cache.js

@@ -0,0 +1,227 @@
+import _createClass from "@babel/runtime/helpers/createClass";
+import { getFromMapOrThrow, getHeightOfRevision, overwriteGetterForCaching, requestIdlePromiseNoQueue } from "./plugins/utils/index.js";
+import { overwritable } from "./overwritable.js";
+
+/**
+ * Because we have to create many cache items,
+ * we use an array instead of an object with properties
+ * for better performance and less memory usage.
+ * @link https://stackoverflow.com/questions/17295056/array-vs-object-efficiency-in-javascript
+ */
+
+/**
+ * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/FinalizationRegistry
+ */
+
+/**
+ * The DocumentCache stores RxDocument objects
+ * by their primary key and revision.
+ * This is useful on client side applications where
+ * it is not known how much memory can be used, so
+ * we de-duplicate RxDocument states to save memory.
+ * To not fill up the memory with old document states, the DocumentCache
+ * only contains weak references to the RxDocuments themself.
+ * @link https://caniuse.com/?search=weakref
+ */
+export var DocumentCache = /*#__PURE__*/function () {
+  /**
+   * Process stuff lazy to not block the CPU
+   * on critical paths.
+   */
+
+  /**
+   * Some JavaScript runtimes like QuickJS,
+   * so not have a FinalizationRegistry or WeakRef.
+   * Therefore we need a workaround which might waste a lot of memory,
+   * but at least works.
+   */
+
+  function DocumentCache(primaryPath, changes$,
+  /**
+   * A method that can create a RxDocument by the given document data.
+   */
+  documentCreator) {
+    this.cacheItemByDocId = new Map();
+    this.tasks = new Set();
+    this.registry = typeof FinalizationRegistry === 'function' ? new FinalizationRegistry(docMeta => {
+      var docId = docMeta.docId;
+      var cacheItem = this.cacheItemByDocId.get(docId);
+      if (cacheItem) {
+        cacheItem[0].delete(docMeta.revisionHeight + docMeta.lwt + '');
+        if (cacheItem[0].size === 0) {
+          /**
+           * No state of the document is cached anymore,
+           * so we can clean up.
+           */
+          this.cacheItemByDocId.delete(docId);
+        }
+      }
+    }) : undefined;
+    this.primaryPath = primaryPath;
+    this.changes$ = changes$;
+    this.documentCreator = documentCreator;
+    changes$.subscribe(events => {
+      this.tasks.add(() => {
+        var cacheItemByDocId = this.cacheItemByDocId;
+        for (var index = 0; index < events.length; index++) {
+          var event = events[index];
+          var cacheItem = cacheItemByDocId.get(event.documentId);
+          if (cacheItem) {
+            var documentData = event.documentData;
+            if (!documentData) {
+              documentData = event.previousDocumentData;
+            }
+            cacheItem[1] = documentData;
+          }
+        }
+      });
+      if (this.tasks.size <= 1) {
+        requestIdlePromiseNoQueue().then(() => {
+          this.processTasks();
+        });
+      }
+    });
+  }
+  var _proto = DocumentCache.prototype;
+  _proto.processTasks = function processTasks() {
+    if (this.tasks.size === 0) {
+      return;
+    }
+    var tasks = Array.from(this.tasks);
+    tasks.forEach(task => task());
+    this.tasks.clear();
+  }
+
+  /**
+   * Get the RxDocument from the cache
+   * and create a new one if not exits before.
+   * @overwrites itself with the actual function
+   * because this is @performance relevant.
+   * It is called on each document row for each write and read.
+   */;
+  /**
+   * Throws if not exists
+   */
+  _proto.getLatestDocumentData = function getLatestDocumentData(docId) {
+    this.processTasks();
+    var cacheItem = getFromMapOrThrow(this.cacheItemByDocId, docId);
+    return cacheItem[1];
+  };
+  _proto.getLatestDocumentDataIfExists = function getLatestDocumentDataIfExists(docId) {
+    this.processTasks();
+    var cacheItem = this.cacheItemByDocId.get(docId);
+    if (cacheItem) {
+      return cacheItem[1];
+    }
+  };
+  return _createClass(DocumentCache, [{
+    key: "getCachedRxDocuments",
+    get: function () {
+      var fn = getCachedRxDocumentMonad(this);
+      return overwriteGetterForCaching(this, 'getCachedRxDocuments', fn);
+    }
+  }, {
+    key: "getCachedRxDocument",
+    get: function () {
+      var fn = getCachedRxDocumentMonad(this);
+      return overwriteGetterForCaching(this, 'getCachedRxDocument', doc => fn([doc])[0]);
+    }
+  }]);
+}();
+
+/**
+ * This function is called very very often.
+ * @hotPath This is one of the most important methods for performance.
+ * It is used in many places to transform the raw document data into RxDocuments.
+ */
+function getCachedRxDocumentMonad(docCache) {
+  var primaryPath = docCache.primaryPath;
+  var cacheItemByDocId = docCache.cacheItemByDocId;
+  var registry = docCache.registry;
+  var deepFreezeWhenDevMode = overwritable.deepFreezeWhenDevMode;
+  var documentCreator = docCache.documentCreator;
+  var fn = docsData => {
+    var ret = new Array(docsData.length);
+    var registryTasks = [];
+    for (var index = 0; index < docsData.length; index++) {
+      var docData = docsData[index];
+      var docId = docData[primaryPath];
+      var revisionHeight = getHeightOfRevision(docData._rev);
+
+      /**
+       * @performance
+       * Compute the byRev cache key once and reuse it
+       * for both the Map.get() and Map.set() calls.
+       */
+      var cacheKey = revisionHeight + docData._meta.lwt + '';
+      var byRev = void 0;
+      var cachedRxDocumentWeakRef = void 0;
+      var cacheItem = cacheItemByDocId.get(docId);
+      if (!cacheItem) {
+        byRev = new Map();
+        cacheItem = [byRev, docData];
+        cacheItemByDocId.set(docId, cacheItem);
+      } else {
+        byRev = cacheItem[0];
+        cachedRxDocumentWeakRef = byRev.get(cacheKey);
+      }
+      var cachedRxDocument = cachedRxDocumentWeakRef ? cachedRxDocumentWeakRef.deref() : undefined;
+      if (!cachedRxDocument) {
+        docData = deepFreezeWhenDevMode(docData);
+        cachedRxDocument = documentCreator(docData);
+        byRev.set(cacheKey, createWeakRefWithFallback(cachedRxDocument));
+        if (registry) {
+          registryTasks.push(cachedRxDocument);
+        }
+      }
+      ret[index] = cachedRxDocument;
+    }
+    if (registryTasks.length > 0 && registry) {
+      /**
+       * Calling registry.register() has shown to have
+       * really bad performance. So we add the cached documents
+       * lazily.
+       */
+      docCache.tasks.add(() => {
+        for (var _index = 0; _index < registryTasks.length; _index++) {
+          var doc = registryTasks[_index];
+          registry.register(doc, {
+            docId: doc.primary,
+            revisionHeight: getHeightOfRevision(doc.revision),
+            lwt: doc._data._meta.lwt
+          });
+        }
+      });
+      if (docCache.tasks.size <= 1) {
+        requestIdlePromiseNoQueue().then(() => {
+          docCache.processTasks();
+        });
+      }
+    }
+    return ret;
+  };
+  return fn;
+}
+export function mapDocumentsDataToCacheDocs(docCache, docsData) {
+  var getCachedRxDocuments = docCache.getCachedRxDocuments;
+  return getCachedRxDocuments(docsData);
+}
+
+/**
+ * Fallback for JavaScript runtimes that do not support WeakRef.
+ * The fallback will keep the items in cache forever,
+ * but at least works.
+ */
+var HAS_WEAK_REF = typeof WeakRef === 'function';
+var createWeakRefWithFallback = HAS_WEAK_REF ? createWeakRef : createWeakRefFallback;
+function createWeakRef(obj) {
+  return new WeakRef(obj);
+}
+function createWeakRefFallback(obj) {
+  return {
+    deref() {
+      return obj;
+    }
+  };
+}
+//# sourceMappingURL=doc-cache.js.map

package/dist/esm/doc-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"doc-cache.js","names":["getFromMapOrThrow","getHeightOfRevision","overwriteGetterForCaching","requestIdlePromiseNoQueue","overwritable","DocumentCache","primaryPath","changes$","documentCreator","cacheItemByDocId","Map","tasks","Set","registry","FinalizationRegistry","docMeta","docId","cacheItem","get","delete","revisionHeight","lwt","size","undefined","subscribe","events","add","index","length","event","documentId","documentData","previousDocumentData","then","processTasks","_proto","prototype","Array","from","forEach","task","clear","getLatestDocumentData","getLatestDocumentDataIfExists","_createClass","key","fn","getCachedRxDocumentMonad","doc","docCache","deepFreezeWhenDevMode","docsData","ret","registryTasks","docData","_rev","cacheKey","_meta","byRev","cachedRxDocumentWeakRef","set","cachedRxDocument","deref","createWeakRefWithFallback","push","register","primary","revision","_data","mapDocumentsDataToCacheDocs","getCachedRxDocuments","HAS_WEAK_REF","WeakRef","createWeakRef","createWeakRefFallback","obj"],"sources":["../../src/doc-cache.ts"],"sourcesContent":["import type {\r\n    RxDocument,\r\n    RxDocumentData,\r\n    RxStorageChangeEvent,\r\n    WeakRef,\r\n    FinalizationRegistry\r\n} from './types/index.d.ts';\r\nimport {\r\n    getFromMapOrThrow,\r\n    getHeightOfRevision,\r\n    overwriteGetterForCaching,\r\n    requestIdlePromiseNoQueue\r\n} from './plugins/utils/index.ts';\r\nimport {\r\n    overwritable\r\n} from './overwritable.ts';\r\nimport { Observable } from 'rxjs';\r\n\r\n/**\r\n * Because we have to create many cache items,\r\n * we use an array instead of an object with properties\r\n * for better performance and less memory usage.\r\n * @link https://stackoverflow.com/questions/17295056/array-vs-object-efficiency-in-javascript\r\n */\r\ndeclare type CacheItem<RxDocType, OrmMethods> = [\r\n    /**\r\n     * Store the different document states of time\r\n     * based on their [revisionHeight+_meta.lwt] .\r\n     * We store WeakRefs so that we can later clean up\r\n     * document states that are no longer needed.\r\n     *\r\n     * Notice that we can not only rely on the revisionHeight\r\n     * because when cleanup is used, two document states can end up with\r\n     * the same revision but different _meta.lwt.\r\n     */\r\n    Map<string, WeakRef<RxDocument<RxDocType, OrmMethods>>>,\r\n\r\n    /**\r\n     * Store the latest known document state.\r\n     * As long as any state of the document is in the cache,\r\n     * we observe the changestream and update the latestDoc accordingly.\r\n     * This makes it easier to optimize performance on other parts\r\n     * because for each known document we can always get the current state\r\n     * in the storage.\r\n     * Also it makes it possible to call RxDocument.latest() in a non-async way\r\n     * to retrieve the latest document state or to observe$ some property.\r\n     *\r\n     * To not prevent the whole cacheItem from being garbage collected,\r\n     * we store only the document data here, but not the RxDocument.\r\n     */\r\n    RxDocumentData<RxDocType>\r\n];\r\n\r\n\r\n/**\r\n * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/FinalizationRegistry\r\n */\r\ndeclare type FinalizationRegistryValue = {\r\n    docId: string;\r\n    revisionHeight: number;\r\n    lwt: number;\r\n};\r\n\r\n/**\r\n * The DocumentCache stores RxDocument objects\r\n * by their primary key and revision.\r\n * This is useful on client side applications where\r\n * it is not known how much memory can be used, so\r\n * we de-duplicate RxDocument states to save memory.\r\n * To not fill up the memory with old document states, the DocumentCache\r\n * only contains weak references to the RxDocuments themself.\r\n * @link https://caniuse.com/?search=weakref\r\n */\r\nexport class DocumentCache<RxDocType, OrmMethods> {\r\n    public readonly cacheItemByDocId = new Map<string, CacheItem<RxDocType, OrmMethods>>();\r\n\r\n    /**\r\n     * Process stuff lazy to not block the CPU\r\n     * on critical paths.\r\n     */\r\n    public readonly tasks = new Set<Function>();\r\n\r\n    /**\r\n     * Some JavaScript runtimes like QuickJS,\r\n     * so not have a FinalizationRegistry or WeakRef.\r\n     * Therefore we need a workaround which might waste a lot of memory,\r\n     * but at least works.\r\n     */\r\n    public readonly registry?: FinalizationRegistry<FinalizationRegistryValue> = typeof FinalizationRegistry === 'function' ?\r\n        new FinalizationRegistry<FinalizationRegistryValue>(docMeta => {\r\n            const docId = docMeta.docId;\r\n            const cacheItem = this.cacheItemByDocId.get(docId);\r\n            if (cacheItem) {\r\n                cacheItem[0].delete(docMeta.revisionHeight + docMeta.lwt + '');\r\n                if (cacheItem[0].size === 0) {\r\n                    /**\r\n                     * No state of the document is cached anymore,\r\n                     * so we can clean up.\r\n                     */\r\n                    this.cacheItemByDocId.delete(docId);\r\n                }\r\n            }\r\n        }) as any :\r\n        undefined;\r\n\r\n    constructor(\r\n        public readonly primaryPath: string,\r\n        public readonly changes$: Observable<RxStorageChangeEvent<RxDocType>[]>,\r\n        /**\r\n         * A method that can create a RxDocument by the given document data.\r\n         */\r\n        public documentCreator: (docData: RxDocumentData<RxDocType>) => RxDocument<RxDocType, OrmMethods>\r\n    ) {\r\n        changes$.subscribe((events: RxStorageChangeEvent<RxDocType>[]) => {\r\n            this.tasks.add(() => {\r\n                const cacheItemByDocId = this.cacheItemByDocId;\r\n                for (let index = 0; index < events.length; index++) {\r\n                    const event = events[index];\r\n                    const cacheItem = cacheItemByDocId.get(event.documentId);\r\n                    if (cacheItem) {\r\n                        let documentData = event.documentData;\r\n                        if (!documentData) {\r\n                            documentData = event.previousDocumentData as any;\r\n                        }\r\n                        cacheItem[1] = documentData;\r\n                    }\r\n                }\r\n            });\r\n            if (this.tasks.size <= 1) {\r\n                requestIdlePromiseNoQueue().then(() => {\r\n                    this.processTasks();\r\n                });\r\n            }\r\n        });\r\n    }\r\n\r\n    public processTasks() {\r\n        if (this.tasks.size === 0) {\r\n            return;\r\n        }\r\n        const tasks = Array.from(this.tasks);\r\n        tasks.forEach(task => task());\r\n        this.tasks.clear();\r\n    }\r\n\r\n    /**\r\n     * Get the RxDocument from the cache\r\n     * and create a new one if not exits before.\r\n     * @overwrites itself with the actual function\r\n     * because this is @performance relevant.\r\n     * It is called on each document row for each write and read.\r\n     */\r\n    get getCachedRxDocuments(): (docsData: RxDocumentData<RxDocType>[]) => RxDocument<RxDocType, OrmMethods>[] {\r\n        const fn = getCachedRxDocumentMonad(this);\r\n        return overwriteGetterForCaching(\r\n            this,\r\n            'getCachedRxDocuments',\r\n            fn\r\n        );\r\n    }\r\n\r\n    get getCachedRxDocument(): (docData: RxDocumentData<RxDocType>) => RxDocument<RxDocType, OrmMethods> {\r\n        const fn = getCachedRxDocumentMonad(this);\r\n        return overwriteGetterForCaching(\r\n            this,\r\n            'getCachedRxDocument',\r\n            doc => fn([doc])[0]\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Throws if not exists\r\n     */\r\n    public getLatestDocumentData(docId: string): RxDocumentData<RxDocType> {\r\n        this.processTasks();\r\n        const cacheItem = getFromMapOrThrow(this.cacheItemByDocId, docId);\r\n        return cacheItem[1];\r\n    }\r\n\r\n    public getLatestDocumentDataIfExists(docId: string): RxDocumentData<RxDocType> | undefined {\r\n        this.processTasks();\r\n        const cacheItem = this.cacheItemByDocId.get(docId);\r\n        if (cacheItem) {\r\n            return cacheItem[1];\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * This function is called very very often.\r\n * @hotPath This is one of the most important methods for performance.\r\n * It is used in many places to transform the raw document data into RxDocuments.\r\n */\r\nfunction getCachedRxDocumentMonad<RxDocType, OrmMethods>(\r\n    docCache: DocumentCache<RxDocType, OrmMethods>\r\n): (docsData: RxDocumentData<RxDocType>[]) => RxDocument<RxDocType, OrmMethods>[] {\r\n    const primaryPath = docCache.primaryPath;\r\n    const cacheItemByDocId = docCache.cacheItemByDocId;\r\n    const registry = docCache.registry;\r\n    const deepFreezeWhenDevMode = overwritable.deepFreezeWhenDevMode;\r\n    const documentCreator = docCache.documentCreator;\r\n    const fn: (docsData: RxDocumentData<RxDocType>[]) => RxDocument<RxDocType, OrmMethods>[] = (docsData: RxDocumentData<RxDocType>[]) => {\r\n        const ret: RxDocument<RxDocType, OrmMethods>[] = new Array(docsData.length);\r\n        const registryTasks: RxDocument<RxDocType, OrmMethods>[] = [];\r\n        for (let index = 0; index < docsData.length; index++) {\r\n            let docData = docsData[index];\r\n            const docId: string = (docData as any)[primaryPath];\r\n\r\n            const revisionHeight = getHeightOfRevision(docData._rev);\r\n\r\n            /**\r\n             * @performance\r\n             * Compute the byRev cache key once and reuse it\r\n             * for both the Map.get() and Map.set() calls.\r\n             */\r\n            const cacheKey = revisionHeight + docData._meta.lwt + '';\r\n\r\n            let byRev: Map<string, WeakRef<RxDocument<RxDocType, OrmMethods>>>;\r\n            let cachedRxDocumentWeakRef: WeakRef<RxDocument<RxDocType, OrmMethods>> | undefined;\r\n            let cacheItem = cacheItemByDocId.get(docId);\r\n            if (!cacheItem) {\r\n                byRev = new Map();\r\n                cacheItem = [\r\n                    byRev,\r\n                    docData\r\n                ];\r\n                cacheItemByDocId.set(docId, cacheItem);\r\n            } else {\r\n                byRev = cacheItem[0];\r\n                cachedRxDocumentWeakRef = byRev.get(cacheKey);\r\n            }\r\n            let cachedRxDocument = cachedRxDocumentWeakRef ? cachedRxDocumentWeakRef.deref() : undefined;\r\n            if (!cachedRxDocument) {\r\n                docData = deepFreezeWhenDevMode(docData) as any;\r\n                cachedRxDocument = documentCreator(docData) as RxDocument<RxDocType, OrmMethods>;\r\n                byRev.set(cacheKey, createWeakRefWithFallback(cachedRxDocument));\r\n                if (registry) {\r\n                    registryTasks.push(cachedRxDocument);\r\n                }\r\n            }\r\n            ret[index] = cachedRxDocument;\r\n        }\r\n        if (registryTasks.length > 0 && registry) {\r\n            /**\r\n             * Calling registry.register() has shown to have\r\n             * really bad performance. So we add the cached documents\r\n             * lazily.\r\n             */\r\n            docCache.tasks.add(() => {\r\n                for (let index = 0; index < registryTasks.length; index++) {\r\n                    const doc = registryTasks[index];\r\n                    registry.register(doc, {\r\n                        docId: doc.primary,\r\n                        revisionHeight: getHeightOfRevision(doc.revision),\r\n                        lwt: doc._data._meta.lwt\r\n                    });\r\n                }\r\n            });\r\n            if (docCache.tasks.size <= 1) {\r\n                requestIdlePromiseNoQueue().then(() => {\r\n                    docCache.processTasks();\r\n                });\r\n            }\r\n        }\r\n        return ret;\r\n    };\r\n    return fn;\r\n}\r\n\r\nexport function mapDocumentsDataToCacheDocs<RxDocType, OrmMethods>(\r\n    docCache: DocumentCache<RxDocType, OrmMethods>,\r\n    docsData: RxDocumentData<RxDocType>[]\r\n) {\r\n    const getCachedRxDocuments = docCache.getCachedRxDocuments;\r\n    return getCachedRxDocuments(docsData);\r\n}\r\n\r\n/**\r\n * Fallback for JavaScript runtimes that do not support WeakRef.\r\n * The fallback will keep the items in cache forever,\r\n * but at least works.\r\n */\r\nconst HAS_WEAK_REF = typeof WeakRef === 'function';\r\nconst createWeakRefWithFallback = HAS_WEAK_REF ? createWeakRef : createWeakRefFallback;\r\nfunction createWeakRef<T extends object>(obj: T): WeakRef<T> {\r\n    return new WeakRef(obj) as any;\r\n}\r\nfunction createWeakRefFallback<T extends object>(obj: T): WeakRef<T> {\r\n    return {\r\n        deref() {\r\n            return obj;\r\n        }\r\n    } as any;\r\n}\r\n"],"mappings":"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","ignoreList":[]}