@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/cjs/plugins/state/helpers.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RX_STATE_SCHEMA_TITLE = exports.RX_STATE_ID_LENGTH = exports.RX_STATE_COLLECTION_SCHEMA = void 0;
+exports.isValidWeakMapKey = isValidWeakMapKey;
+exports.nextRxStateId = nextRxStateId;
+var _overwritable = require("../../overwritable.js");
+var _rxError = require("../../rx-error.js");
+var RX_STATE_SCHEMA_TITLE = exports.RX_STATE_SCHEMA_TITLE = 'RxStateCollection';
+var RX_STATE_ID_LENGTH = exports.RX_STATE_ID_LENGTH = 14;
+var RX_STATE_COLLECTION_SCHEMA = exports.RX_STATE_COLLECTION_SCHEMA = {
+  title: RX_STATE_SCHEMA_TITLE,
+  primaryKey: 'id',
+  version: 0,
+  type: 'object',
+  properties: {
+    id: {
+      type: 'string',
+      /**
+       * We store numbers in string format like '0001'
+       * with a left-pad.
+       */
+      maxLength: RX_STATE_ID_LENGTH,
+      minLength: RX_STATE_ID_LENGTH,
+      pattern: '[0-9]+'
+    },
+    sId: {
+      type: 'string',
+      maxLength: 10,
+      minLength: 10
+    },
+    ops: {
+      type: 'array',
+      minItems: 1,
+      items: {
+        type: 'object',
+        properties: {
+          k: {
+            type: 'string'
+          },
+          v: {
+            /**
+             * Do not define a type for the value
+             * because anything is allowed.
+             */
+          }
+        },
+        required: ['k', 'v']
+      }
+    }
+  },
+  required: ['id', 'sId', 'ops']
+};
+function nextRxStateId(lastId) {
+  if (!lastId) {
+    return ''.padStart(RX_STATE_ID_LENGTH, '0');
+  }
+  var parsed = parseInt(lastId, 10);
+  var next = parsed + 1;
+  var nextString = next.toString();
+  return nextString.padStart(RX_STATE_ID_LENGTH, '0');
+}
+
+/**
+ * Only non-primitives can be used as a key in WeakMap
+ */
+function isValidWeakMapKey(key) {
+  // This method is slow and must only be used in dev-mode!
+  if (!_overwritable.overwritable.isDevMode()) {
+    throw (0, _rxError.newRxError)('SNH');
+  }
+  try {
+    new WeakMap().set(key, {});
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+//# sourceMappingURL=helpers.js.map

package/dist/cjs/plugins/state/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","names":["_overwritable","require","_rxError","RX_STATE_SCHEMA_TITLE","exports","RX_STATE_ID_LENGTH","RX_STATE_COLLECTION_SCHEMA","title","primaryKey","version","type","properties","id","maxLength","minLength","pattern","sId","ops","minItems","items","k","v","required","nextRxStateId","lastId","padStart","parsed","parseInt","next","nextString","toString","isValidWeakMapKey","key","overwritable","isDevMode","newRxError","WeakMap","set","err"],"sources":["../../../../src/plugins/state/helpers.ts"],"sourcesContent":["import { overwritable } from '../../overwritable.ts';\r\nimport { newRxError } from '../../rx-error.ts';\r\nimport type { DeepReadonly, RxJsonSchema } from '../../types';\r\nimport type { RxStateDocument } from './types';\r\n\r\nexport const RX_STATE_SCHEMA_TITLE = 'RxStateCollection';\r\nexport const RX_STATE_ID_LENGTH = 14;\r\nexport const RX_STATE_COLLECTION_SCHEMA: DeepReadonly<RxJsonSchema<RxStateDocument>> = {\r\n    title: RX_STATE_SCHEMA_TITLE,\r\n    primaryKey: 'id',\r\n    version: 0,\r\n    type: 'object',\r\n    properties: {\r\n        id: {\r\n            type: 'string',\r\n            /**\r\n             * We store numbers in string format like '0001'\r\n             * with a left-pad.\r\n             */\r\n            maxLength: RX_STATE_ID_LENGTH,\r\n            minLength: RX_STATE_ID_LENGTH,\r\n            pattern: '[0-9]+'\r\n        },\r\n        sId: {\r\n            type: 'string',\r\n            maxLength: 10,\r\n            minLength: 10\r\n        },\r\n        ops: {\r\n            type: 'array',\r\n            minItems: 1,\r\n            items: {\r\n                type: 'object',\r\n                properties: {\r\n                    k: {\r\n                        type: 'string'\r\n                    },\r\n                    v: {\r\n                        /**\r\n                         * Do not define a type for the value\r\n                         * because anything is allowed.\r\n                         */\r\n                    }\r\n                },\r\n                required: [\r\n                    'k',\r\n                    'v'\r\n                ]\r\n            }\r\n        }\r\n    },\r\n    required: [\r\n        'id',\r\n        'sId',\r\n        'ops'\r\n    ]\r\n} as const;\r\n\r\n\r\nexport function nextRxStateId(lastId?: string): string {\r\n    if (!lastId) {\r\n        return ''.padStart(RX_STATE_ID_LENGTH, '0');\r\n    }\r\n    const parsed = parseInt(lastId, 10);\r\n    const next = parsed + 1;\r\n    const nextString = next.toString();\r\n    return nextString.padStart(RX_STATE_ID_LENGTH, '0');\r\n}\r\n\r\n\r\n\r\n/**\r\n * Only non-primitives can be used as a key in WeakMap\r\n */\r\nexport function isValidWeakMapKey(key: any) {\r\n    // This method is slow and must only be used in dev-mode!\r\n    if (!overwritable.isDevMode()) {\r\n        throw newRxError('SNH');\r\n    }\r\n    try {\r\n        new WeakMap().set(key, {});\r\n        return true;\r\n    } catch (err) {\r\n        return false;\r\n    }\r\n}\r\n"],"mappings":";;;;;;;;AAAA,IAAAA,aAAA,GAAAC,OAAA;AACA,IAAAC,QAAA,GAAAD,OAAA;AAIO,IAAME,qBAAqB,GAAAC,OAAA,CAAAD,qBAAA,GAAG,mBAAmB;AACjD,IAAME,kBAAkB,GAAAD,OAAA,CAAAC,kBAAA,GAAG,EAAE;AAC7B,IAAMC,0BAAuE,GAAAF,OAAA,CAAAE,0BAAA,GAAG;EACnFC,KAAK,EAAEJ,qBAAqB;EAC5BK,UAAU,EAAE,IAAI;EAChBC,OAAO,EAAE,CAAC;EACVC,IAAI,EAAE,QAAQ;EACdC,UAAU,EAAE;IACRC,EAAE,EAAE;MACAF,IAAI,EAAE,QAAQ;MACd;AACZ;AACA;AACA;MACYG,SAAS,EAAER,kBAAkB;MAC7BS,SAAS,EAAET,kBAAkB;MAC7BU,OAAO,EAAE;IACb,CAAC;IACDC,GAAG,EAAE;MACDN,IAAI,EAAE,QAAQ;MACdG,SAAS,EAAE,EAAE;MACbC,SAAS,EAAE;IACf,CAAC;IACDG,GAAG,EAAE;MACDP,IAAI,EAAE,OAAO;MACbQ,QAAQ,EAAE,CAAC;MACXC,KAAK,EAAE;QACHT,IAAI,EAAE,QAAQ;QACdC,UAAU,EAAE;UACRS,CAAC,EAAE;YACCV,IAAI,EAAE;UACV,CAAC;UACDW,CAAC,EAAE;YACC;AACxB;AACA;AACA;UAHwB;QAKR,CAAC;QACDC,QAAQ,EAAE,CACN,GAAG,EACH,GAAG;MAEX;IACJ;EACJ,CAAC;EACDA,QAAQ,EAAE,CACN,IAAI,EACJ,KAAK,EACL,KAAK;AAEb,CAAU;AAGH,SAASC,aAAaA,CAACC,MAAe,EAAU;EACnD,IAAI,CAACA,MAAM,EAAE;IACT,OAAO,EAAE,CAACC,QAAQ,CAACpB,kBAAkB,EAAE,GAAG,CAAC;EAC/C;EACA,IAAMqB,MAAM,GAAGC,QAAQ,CAACH,MAAM,EAAE,EAAE,CAAC;EACnC,IAAMI,IAAI,GAAGF,MAAM,GAAG,CAAC;EACvB,IAAMG,UAAU,GAAGD,IAAI,CAACE,QAAQ,CAAC,CAAC;EAClC,OAAOD,UAAU,CAACJ,QAAQ,CAACpB,kBAAkB,EAAE,GAAG,CAAC;AACvD;;AAIA;AACA;AACA;AACO,SAAS0B,iBAAiBA,CAACC,GAAQ,EAAE;EACxC;EACA,IAAI,CAACC,0BAAY,CAACC,SAAS,CAAC,CAAC,EAAE;IAC3B,MAAM,IAAAC,mBAAU,EAAC,KAAK,CAAC;EAC3B;EACA,IAAI;IACA,IAAIC,OAAO,CAAC,CAAC,CAACC,GAAG,CAACL,GAAG,EAAE,CAAC,CAAC,CAAC;IAC1B,OAAO,IAAI;EACf,CAAC,CAAC,OAAOM,GAAG,EAAE;IACV,OAAO,KAAK;EAChB;AACJ","ignoreList":[]}

package/dist/cjs/plugins/state/index.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  addState: true,
+  RxDBStatePlugin: true
+};
+exports.RxDBStatePlugin = void 0;
+exports.addState = addState;
+var _utilsMap = require("../utils/utils-map.js");
+var _rxState = require("./rx-state.js");
+var _helpers = require("./helpers.js");
+Object.keys(_helpers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _helpers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _helpers[key];
+    }
+  });
+});
+var STATE_BY_DATABASE = new WeakMap();
+async function addState(namespace = '') {
+  var stateCache = (0, _utilsMap.getFromMapOrCreate)(STATE_BY_DATABASE, this, () => new Map());
+  var state = await (0, _utilsMap.getFromMapOrCreate)(stateCache, namespace, () => (0, _rxState.createRxState)(this, namespace));
+  this.states[namespace] = state;
+  return state;
+}
+var RxDBStatePlugin = exports.RxDBStatePlugin = {
+  name: 'state',
+  rxdb: true,
+  prototypes: {
+    RxDatabase(proto) {
+      proto.addState = addState;
+    }
+  }
+};
+//# sourceMappingURL=index.js.map

package/dist/cjs/plugins/state/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_utilsMap","require","_rxState","_helpers","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","STATE_BY_DATABASE","WeakMap","addState","namespace","stateCache","getFromMapOrCreate","Map","state","createRxState","states","RxDBStatePlugin","name","rxdb","prototypes","RxDatabase","proto"],"sources":["../../../../src/plugins/state/index.ts"],"sourcesContent":["import type {\r\n    RxDatabase,\r\n    RxPlugin,\r\n    RxState\r\n} from '../../types/index.d.ts';\r\nimport { getFromMapOrCreate } from '../utils/utils-map.ts';\r\nimport { RxStateBase, createRxState } from './rx-state.ts';\r\n\r\nexport * from './helpers.ts';\r\n\r\ntype StateByPrefix = Map<string, Promise<RxStateBase<any>>>;\r\nconst STATE_BY_DATABASE = new WeakMap<RxDatabase, StateByPrefix>();\r\n\r\nexport async function addState<T>(\r\n    this: RxDatabase,\r\n    namespace: string = ''\r\n): Promise<RxState<T>> {\r\n    const stateCache = getFromMapOrCreate<RxDatabase, StateByPrefix>(\r\n        STATE_BY_DATABASE,\r\n        this,\r\n        () => new Map()\r\n    );\r\n    const state = await getFromMapOrCreate(\r\n        stateCache,\r\n        namespace,\r\n        () => createRxState<T>(this, namespace)\r\n    );\r\n    this.states[namespace] = state;\r\n    return state as any;\r\n}\r\n\r\nexport const RxDBStatePlugin: RxPlugin = {\r\n    name: 'state',\r\n    rxdb: true,\r\n    prototypes: {\r\n        RxDatabase(proto: any) {\r\n            proto.addState = addState;\r\n        }\r\n    }\r\n};\r\n"],"mappings":";;;;;;;;;;;AAKA,IAAAA,SAAA,GAAAC,OAAA;AACA,IAAAC,QAAA,GAAAD,OAAA;AAEA,IAAAE,QAAA,GAAAF,OAAA;AAAAG,MAAA,CAAAC,IAAA,CAAAF,QAAA,EAAAG,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAJ,QAAA,CAAAI,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAZ,QAAA,CAAAI,GAAA;IAAA;EAAA;AAAA;AAGA,IAAMS,iBAAiB,GAAG,IAAIC,OAAO,CAA4B,CAAC;AAE3D,eAAeC,QAAQA,CAE1BC,SAAiB,GAAG,EAAE,EACH;EACnB,IAAMC,UAAU,GAAG,IAAAC,4BAAkB,EACjCL,iBAAiB,EACjB,IAAI,EACJ,MAAM,IAAIM,GAAG,CAAC,CAClB,CAAC;EACD,IAAMC,KAAK,GAAG,MAAM,IAAAF,4BAAkB,EAClCD,UAAU,EACVD,SAAS,EACT,MAAM,IAAAK,sBAAa,EAAI,IAAI,EAAEL,SAAS,CAC1C,CAAC;EACD,IAAI,CAACM,MAAM,CAACN,SAAS,CAAC,GAAGI,KAAK;EAC9B,OAAOA,KAAK;AAChB;AAEO,IAAMG,eAAyB,GAAAd,OAAA,CAAAc,eAAA,GAAG;EACrCC,IAAI,EAAE,OAAO;EACbC,IAAI,EAAE,IAAI;EACVC,UAAU,EAAE;IACRC,UAAUA,CAACC,KAAU,EAAE;MACnBA,KAAK,CAACb,QAAQ,GAAGA,QAAQ;IAC7B;EACJ;AACJ,CAAC","ignoreList":[]}

package/dist/cjs/plugins/state/rx-state.js

@@ -0,0 +1,293 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RxStateBase = void 0;
+exports.createRxState = createRxState;
+exports.mergeOperationsIntoState = mergeOperationsIntoState;
+var _rxjs = require("rxjs");
+var _overwritable = require("../../overwritable.js");
+var _rxStorageHelper = require("../../rx-storage-helper.js");
+var _index = require("../utils/index.js");
+var _helpers = require("./helpers.js");
+var _rxError = require("../../rx-error.js");
+var _hooks = require("../../hooks.js");
+var debugId = 0;
+var deepFrozenCache = new WeakMap();
+
+/**
+ * RxDB internally used properties are
+ * prefixed with lodash _ to make them less
+ * likely to clash with actual state properties
+ * from the user.
+ */
+var RxStateBase = exports.RxStateBase = /*#__PURE__*/function () {
+  // used for debugging
+
+  function RxStateBase(prefix, collection) {
+    this._id = debugId++;
+    this._state = {};
+    this._nonPersisted = [];
+    this._writeQueue = _index.PROMISE_RESOLVE_VOID;
+    this._initDone = false;
+    this._instanceId = (0, _index.randomToken)(_helpers.RX_STATE_COLLECTION_SCHEMA.properties.sId.maxLength);
+    this._ownEmits$ = new _rxjs.Subject();
+    this.prefix = prefix;
+    this.collection = collection;
+    this.collection.onClose.push(() => this._writeQueue);
+    this._lastIdQuery = this.collection.findOne({
+      sort: [{
+        id: 'desc'
+      }]
+    });
+    // make it "hot" for better write performance
+    this._lastIdQuery.$.subscribe();
+    this.$ = (0, _rxjs.merge)(this._ownEmits$, this.collection.eventBulks$.pipe((0, _rxjs.tap)(eventBulk => {
+      if (!this._initDone) {
+        return;
+      }
+      var events = eventBulk.events;
+      for (var index = 0; index < events.length; index++) {
+        var event = events[index];
+        if (event.operation === 'INSERT' && event.documentData.sId !== this._instanceId) {
+          this.mergeOperationsIntoState(event.documentData.ops);
+        }
+      }
+    }))).pipe((0, _rxjs.shareReplay)(_index.RXJS_SHARE_REPLAY_DEFAULTS), (0, _rxjs.map)(() => this._state));
+    // directly subscribe because of the tap() side effect
+    this.$.subscribe();
+  }
+  var _proto = RxStateBase.prototype;
+  _proto.set = async function set(path, modifier) {
+    this._nonPersisted.push({
+      path,
+      modifier
+    });
+    return this._triggerWrite();
+  }
+
+  /**
+   * To have deterministic writes,
+   * and to ensure that multiple js realms do not overwrite
+   * each other, the write happens with incremental ids
+   * that would throw conflict errors and trigger a retry.
+   */;
+  _proto._triggerWrite = function _triggerWrite() {
+    this._writeQueue = this._writeQueue.then(async () => {
+      if (this._nonPersisted.length === 0) {
+        return;
+      }
+      var useWrites = [];
+      var done = false;
+      while (!done) {
+        var lastIdDoc = await this._lastIdQuery.exec();
+        useWrites = useWrites.concat(this._nonPersisted);
+        this._nonPersisted = [];
+        var nextId = (0, _helpers.nextRxStateId)(lastIdDoc ? lastIdDoc.id : undefined);
+        try {
+          /**
+           * TODO instead of a deep-clone we should
+           * only clone the parts where we know that they
+           * will be changed. This would improve performance.
+           */
+          var newState = (0, _index.clone)(this._state);
+          var ops = [];
+          for (var index = 0; index < useWrites.length; index++) {
+            var writeRow = useWrites[index];
+            var value = (0, _index.getProperty)(newState, writeRow.path);
+            var newValue = writeRow.modifier(value);
+            /**
+             * Here we have to clone the value because
+             * some storages like the memory storage
+             * make input data deep-frozen in dev-mode.
+             */
+            if (writeRow.path === '') {
+              newState = (0, _index.clone)(newValue);
+            } else {
+              (0, _index.setProperty)(newState, writeRow.path, (0, _index.clone)(newValue));
+            }
+            ops.push({
+              k: writeRow.path,
+              /**
+               * Here we have to clone the value because
+               * some storages like the memory storage
+               * make input data deep-frozen in dev-mode.
+               */
+              v: (0, _index.clone)(newValue)
+            });
+          }
+          await this.collection.insert({
+            id: nextId,
+            sId: this._instanceId,
+            ops
+          });
+          this._state = newState;
+          this._ownEmits$.next(this._state);
+          done = true;
+        } catch (err) {
+          if (err.code !== 'CONFLICT') {
+            throw err;
+          }
+        }
+      }
+    }).catch(error => {
+      throw (0, _rxError.newRxError)('SNH', {
+        name: 'RxState WRITE QUEUE ERROR',
+        error
+      });
+    });
+    return this._writeQueue;
+  };
+  _proto.mergeOperationsIntoState = function mergeOperationsIntoState(operations) {
+    var state = (0, _index.clone)(this._state);
+    for (var index = 0; index < operations.length; index++) {
+      var operation = operations[index];
+      if (operation.k === '') {
+        state = (0, _index.clone)(operation.v);
+      } else {
+        (0, _index.setProperty)(state, operation.k, (0, _index.clone)(operation.v));
+      }
+    }
+    this._state = state;
+  };
+  _proto.get = function get(path) {
+    var ret;
+    if (!path) {
+      ret = this._state;
+    } else {
+      ret = (0, _index.getProperty)(this._state, path);
+    }
+
+    /**
+     * In dev-mode we have to clone the value before deep-freezing
+     * it to not have an immutable subobject in the state value.
+     * But calling .get() with the same path multiple times,
+     * should return exactly the same object instance
+     * so it does not cause re-renders on react.
+     * So in dev-mode we have to 
+     */
+    if (_overwritable.overwritable.isDevMode() && (0, _helpers.isValidWeakMapKey)(ret)) {
+      var frozen = (0, _index.getFromMapOrCreate)(deepFrozenCache, ret, () => _overwritable.overwritable.deepFreezeWhenDevMode((0, _index.clone)(ret)));
+      return frozen;
+    }
+    return ret;
+  };
+  _proto.get$ = function get$(path) {
+    return this.$.pipe((0, _rxjs.map)(() => this.get(path)), (0, _rxjs.startWith)(this.get(path)), (0, _rxjs.distinctUntilChanged)(_index.deepEqual), (0, _rxjs.shareReplay)(_index.RXJS_SHARE_REPLAY_DEFAULTS));
+  };
+  _proto.get$$ = function get$$(path) {
+    var obs = this.get$(path);
+    var reactivity = this.collection.database.getReactivityFactory();
+    return reactivity.fromObservable(obs, this.get(path), this.collection.database);
+  }
+
+  /**
+   * Merges the state operations into a single write row
+   * to store space and make recreating the state from
+   * disc faster.
+   */;
+  _proto._cleanup = async function _cleanup() {
+    var firstWrite = await this.collection.findOne({
+      sort: [{
+        id: 'asc'
+      }]
+    }).exec();
+    var lastWrite = await this._lastIdQuery.exec();
+    if (!firstWrite || !lastWrite) {
+      return;
+    }
+    var firstNr = parseInt(firstWrite.id, 10);
+    var lastNr = parseInt(lastWrite.id, 10);
+    if (lastNr - 5 < firstNr) {
+      // only run if more than 5 write rows
+      return;
+    }
+
+    // update whole state object
+    await this._writeQueue;
+    await this.set('', () => this._state);
+
+    // delete old ones
+    await this.collection.find({
+      selector: {
+        id: {
+          $lte: lastWrite.id
+        }
+      }
+    }).remove();
+  };
+  return RxStateBase;
+}();
+async function createRxState(database, prefix) {
+  var collectionName = 'rx-state-' + prefix;
+  await database.addCollections({
+    [collectionName]: {
+      schema: _helpers.RX_STATE_COLLECTION_SCHEMA
+    }
+  });
+  var collection = database.collections[collectionName];
+  var rxState = new RxStateBase(prefix, collection);
+
+  /**
+   * Directly get the state and put it into memory.
+   * This ensures we can do non-async accesses to the
+   * correct state.
+   */
+  var done = false;
+  var checkpoint = undefined;
+  while (!done) {
+    var result = await (0, _rxStorageHelper.getChangedDocumentsSince)(collection.storageInstance, 1000, checkpoint);
+    checkpoint = result.checkpoint;
+    var documents = result.documents;
+    if (documents.length === 0) {
+      done = true;
+    } else {
+      for (var index = 0; index < documents.length; index++) {
+        var document = documents[index];
+        mergeOperationsIntoState(rxState._state, document.ops);
+      }
+    }
+  }
+  rxState._initDone = true;
+  var proxy = new Proxy(rxState, {
+    get(target, property) {
+      if (typeof property !== 'string') {
+        return target[property];
+      }
+      if (rxState[property]) {
+        var ret = rxState[property];
+        if (typeof ret === 'function') {
+          return ret.bind(rxState);
+        } else {
+          return ret;
+        }
+      }
+      var lastChar = property.charAt(property.length - 1);
+      if (property.endsWith('$$')) {
+        var key = property.slice(0, -2);
+        return rxState.get$$(key);
+      } else if (lastChar === '$') {
+        var _key = property.slice(0, -1);
+        return rxState.get$(_key);
+      } else {
+        return rxState.get(property);
+      }
+    },
+    set(target, newValue, receiver) {
+      throw new Error('Do not write to RxState');
+    }
+  });
+  (0, _hooks.runPluginHooks)('createRxState', {
+    collection,
+    state: proxy
+  });
+  return proxy;
+}
+function mergeOperationsIntoState(state, operations) {
+  for (var index = 0; index < operations.length; index++) {
+    var operation = operations[index];
+    (0, _index.setProperty)(state, operation.k, (0, _index.clone)(operation.v));
+  }
+}
+//# sourceMappingURL=rx-state.js.map

package/dist/cjs/plugins/state/rx-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rx-state.js","names":["_rxjs","require","_overwritable","_rxStorageHelper","_index","_helpers","_rxError","_hooks","debugId","deepFrozenCache","WeakMap","RxStateBase","exports","prefix","collection","_id","_state","_nonPersisted","_writeQueue","PROMISE_RESOLVE_VOID","_initDone","_instanceId","randomToken","RX_STATE_COLLECTION_SCHEMA","properties","sId","maxLength","_ownEmits$","Subject","onClose","push","_lastIdQuery","findOne","sort","id","$","subscribe","merge","eventBulks$","pipe","tap","eventBulk","events","index","length","event","operation","documentData","mergeOperationsIntoState","ops","shareReplay","RXJS_SHARE_REPLAY_DEFAULTS","map","_proto","prototype","set","path","modifier","_triggerWrite","then","useWrites","done","lastIdDoc","exec","concat","nextId","nextRxStateId","undefined","newState","clone","writeRow","value","getProperty","newValue","setProperty","k","v","insert","next","err","code","catch","error","newRxError","name","operations","state","get","ret","overwritable","isDevMode","isValidWeakMapKey","frozen","getFromMapOrCreate","deepFreezeWhenDevMode","get$","startWith","distinctUntilChanged","deepEqual","get$$","obs","reactivity","database","getReactivityFactory","fromObservable","_cleanup","firstWrite","lastWrite","firstNr","parseInt","lastNr","find","selector","$lte","remove","createRxState","collectionName","addCollections","schema","collections","rxState","checkpoint","result","getChangedDocumentsSince","storageInstance","documents","document","proxy","Proxy","target","property","bind","lastChar","charAt","endsWith","key","slice","receiver","Error","runPluginHooks"],"sources":["../../../../src/plugins/state/rx-state.ts"],"sourcesContent":["import {\r\n    Observable,\r\n    Subject,\r\n    distinctUntilChanged,\r\n    map,\r\n    merge,\r\n    shareReplay,\r\n    startWith,\r\n    tap\r\n} from 'rxjs';\r\nimport { overwritable } from '../../overwritable.ts';\r\nimport { getChangedDocumentsSince } from '../../rx-storage-helper.ts';\r\nimport type {\r\n    RxChangeEventBulk,\r\n    RxCollection,\r\n    RxDatabase,\r\n    RxQuery,\r\n    RxDocument,\r\n    RxError,\r\n    Paths\r\n} from '../../types';\r\nimport {\r\n    RXJS_SHARE_REPLAY_DEFAULTS,\r\n    getProperty,\r\n    setProperty,\r\n    PROMISE_RESOLVE_VOID,\r\n    clone,\r\n    randomToken,\r\n    deepEqual,\r\n    getFromMapOrCreate\r\n} from '../utils/index.ts';\r\nimport {\r\n    RX_STATE_COLLECTION_SCHEMA,\r\n    isValidWeakMapKey,\r\n    nextRxStateId\r\n} from './helpers.ts';\r\nimport {\r\n    RxStateDocument,\r\n    RxStateOperation,\r\n    RxStateModifier\r\n} from './types.ts';\r\nimport { newRxError } from '../../rx-error.ts';\r\nimport { runPluginHooks } from '../../hooks.ts';\r\n\r\n\r\nlet debugId = 0;\r\n\r\n\r\nconst deepFrozenCache = new WeakMap<any, any>();\r\n\r\n/**\r\n * RxDB internally used properties are\r\n * prefixed with lodash _ to make them less\r\n * likely to clash with actual state properties\r\n * from the user.\r\n */\r\nexport class RxStateBase<T, Reactivity = unknown> {\r\n    // used for debugging\r\n    public _id: number = debugId++;\r\n    public _state: T | any = {};\r\n    public $: Observable<T>;\r\n    public _lastIdQuery: RxQuery<RxStateDocument, RxDocument<RxStateDocument, {}> | null>;\r\n    public _nonPersisted: {\r\n        path: string;\r\n        modifier: RxStateModifier;\r\n    }[] = [];\r\n    public _writeQueue = PROMISE_RESOLVE_VOID;\r\n    public _initDone = false;\r\n    public _instanceId = randomToken(RX_STATE_COLLECTION_SCHEMA.properties.sId.maxLength);\r\n    public _ownEmits$ = new Subject<T>();\r\n\r\n    constructor(\r\n        public readonly prefix: string,\r\n        public readonly collection: RxCollection<RxStateDocument>\r\n    ) {\r\n        this.collection.onClose.push(() => this._writeQueue);\r\n        this._lastIdQuery = this.collection.findOne({\r\n            sort: [\r\n                { id: 'desc' }\r\n            ]\r\n        });\r\n        // make it \"hot\" for better write performance\r\n        this._lastIdQuery.$.subscribe();\r\n\r\n        this.$ = merge(\r\n            this._ownEmits$,\r\n            this.collection.eventBulks$.pipe(\r\n                tap((eventBulk: RxChangeEventBulk<RxStateDocument>) => {\r\n                    if (!this._initDone) {\r\n                        return;\r\n                    }\r\n                    const events = eventBulk.events;\r\n                    for (let index = 0; index < events.length; index++) {\r\n                        const event = events[index];\r\n                        if (\r\n                            event.operation === 'INSERT' &&\r\n                            event.documentData.sId !== this._instanceId\r\n                        ) {\r\n                            this.mergeOperationsIntoState(event.documentData.ops);\r\n                        }\r\n                    }\r\n                })\r\n            )\r\n        ).pipe(\r\n            shareReplay(RXJS_SHARE_REPLAY_DEFAULTS),\r\n            map(() => this._state)\r\n        );\r\n        // directly subscribe because of the tap() side effect\r\n        this.$.subscribe();\r\n    }\r\n\r\n    async set(\r\n        path: Paths<T> | '',\r\n        modifier: RxStateModifier\r\n    ) {\r\n        this._nonPersisted.push({\r\n            path,\r\n            modifier\r\n        });\r\n        return this._triggerWrite();\r\n    }\r\n\r\n    /**\r\n     * To have deterministic writes,\r\n     * and to ensure that multiple js realms do not overwrite\r\n     * each other, the write happens with incremental ids\r\n     * that would throw conflict errors and trigger a retry.\r\n     */\r\n    _triggerWrite() {\r\n        this._writeQueue = this._writeQueue.then(async () => {\r\n            if (this._nonPersisted.length === 0) {\r\n                return;\r\n            }\r\n            let useWrites: typeof this._nonPersisted = [];\r\n            let done = false;\r\n            while (!done) {\r\n                const lastIdDoc = await this._lastIdQuery.exec();\r\n                useWrites = useWrites.concat(this._nonPersisted);\r\n                this._nonPersisted = [];\r\n                const nextId = nextRxStateId(lastIdDoc ? lastIdDoc.id : undefined);\r\n                try {\r\n                    /**\r\n                     * TODO instead of a deep-clone we should\r\n                     * only clone the parts where we know that they\r\n                     * will be changed. This would improve performance.\r\n                     */\r\n                    let newState = clone(this._state);\r\n                    const ops: RxStateOperation[] = [];\r\n                    for (let index = 0; index < useWrites.length; index++) {\r\n                        const writeRow = useWrites[index];\r\n                        const value = getProperty(newState, writeRow.path);\r\n                        const newValue = writeRow.modifier(value);\r\n                        /**\r\n                         * Here we have to clone the value because\r\n                         * some storages like the memory storage\r\n                         * make input data deep-frozen in dev-mode.\r\n                         */\r\n                        if (writeRow.path === '') {\r\n                            newState = clone(newValue);\r\n                        } else {\r\n                            setProperty(newState, writeRow.path, clone(newValue));\r\n                        }\r\n                        ops.push({\r\n                            k: writeRow.path,\r\n                            /**\r\n                             * Here we have to clone the value because\r\n                             * some storages like the memory storage\r\n                             * make input data deep-frozen in dev-mode.\r\n                             */\r\n                            v: clone(newValue)\r\n                        });\r\n                    }\r\n                    await this.collection.insert({\r\n                        id: nextId,\r\n                        sId: this._instanceId,\r\n                        ops\r\n                    });\r\n                    this._state = newState;\r\n                    this._ownEmits$.next(this._state);\r\n                    done = true;\r\n                } catch (err) {\r\n                    if ((err as RxError).code !== 'CONFLICT') {\r\n                        throw err;\r\n                    }\r\n                }\r\n            }\r\n        }).catch(error => {\r\n            throw newRxError('SNH', {\r\n                name: 'RxState WRITE QUEUE ERROR',\r\n                error\r\n            });\r\n        });\r\n        return this._writeQueue;\r\n    }\r\n\r\n    mergeOperationsIntoState(\r\n        operations: RxStateOperation[]\r\n    ) {\r\n        let state = clone(this._state);\r\n        for (let index = 0; index < operations.length; index++) {\r\n            const operation = operations[index];\r\n            if (operation.k === '') {\r\n                state = clone(operation.v);\r\n            } else {\r\n                setProperty(state, operation.k, clone(operation.v));\r\n            }\r\n        }\r\n        this._state = state;\r\n    }\r\n    get(path?: Paths<T>) {\r\n        let ret;\r\n        if (!path) {\r\n            ret = this._state;\r\n        } else {\r\n            ret = getProperty(this._state, path);\r\n        }\r\n\r\n        /**\r\n         * In dev-mode we have to clone the value before deep-freezing\r\n         * it to not have an immutable subobject in the state value.\r\n         * But calling .get() with the same path multiple times,\r\n         * should return exactly the same object instance\r\n         * so it does not cause re-renders on react.\r\n         * So in dev-mode we have to \r\n         */\r\n        if (overwritable.isDevMode() && isValidWeakMapKey(ret)) {\r\n            const frozen = getFromMapOrCreate(\r\n                deepFrozenCache,\r\n                ret,\r\n                () => overwritable.deepFreezeWhenDevMode(clone(ret))\r\n            );\r\n            return frozen;\r\n        }\r\n\r\n        return ret;\r\n    }\r\n    get$(path?: Paths<T>): Observable<any> {\r\n        return this.$.pipe(\r\n            map(() => this.get(path)),\r\n            startWith(this.get(path)),\r\n            distinctUntilChanged(deepEqual),\r\n            shareReplay(RXJS_SHARE_REPLAY_DEFAULTS),\r\n        );\r\n    }\r\n    get$$(path?: Paths<T>): Reactivity {\r\n        const obs = this.get$(path);\r\n        const reactivity = this.collection.database.getReactivityFactory();\r\n        return reactivity.fromObservable(\r\n            obs,\r\n            this.get(path),\r\n            this.collection.database\r\n        ) as any;\r\n    }\r\n\r\n    /**\r\n     * Merges the state operations into a single write row\r\n     * to store space and make recreating the state from\r\n     * disc faster.\r\n     */\r\n    async _cleanup() {\r\n        const firstWrite = await this.collection.findOne({\r\n            sort: [{ id: 'asc' }]\r\n        }).exec();\r\n        const lastWrite = await this._lastIdQuery.exec();\r\n\r\n        if (!firstWrite || !lastWrite) {\r\n            return;\r\n        }\r\n\r\n        const firstNr = parseInt(firstWrite.id, 10);\r\n        const lastNr = parseInt(lastWrite.id, 10);\r\n        if ((lastNr - 5) < firstNr) {\r\n            // only run if more than 5 write rows\r\n            return;\r\n        }\r\n\r\n        // update whole state object\r\n        await this._writeQueue;\r\n        await this.set('', () => this._state);\r\n\r\n        // delete old ones\r\n        await this.collection.find({\r\n            selector: {\r\n                id: {\r\n                    $lte: lastWrite.id\r\n                }\r\n            }\r\n        }).remove();\r\n    }\r\n}\r\n\r\n\r\nexport async function createRxState<T>(\r\n    database: RxDatabase,\r\n    prefix: string\r\n): Promise<RxStateBase<T>> {\r\n    const collectionName = 'rx-state-' + prefix;\r\n    await database.addCollections({\r\n        [collectionName]: {\r\n            schema: RX_STATE_COLLECTION_SCHEMA as any\r\n        }\r\n    });\r\n    const collection: RxCollection<RxStateDocument> = database.collections[collectionName];\r\n\r\n    const rxState = new RxStateBase<T>(\r\n        prefix,\r\n        collection\r\n    );\r\n\r\n\r\n    /**\r\n     * Directly get the state and put it into memory.\r\n     * This ensures we can do non-async accesses to the\r\n     * correct state.\r\n     */\r\n    let done = false;\r\n    let checkpoint: any = undefined;\r\n    while (!done) {\r\n        const result = await getChangedDocumentsSince<RxStateDocument, any>(\r\n            collection.storageInstance,\r\n            1000,\r\n            checkpoint\r\n        );\r\n        checkpoint = result.checkpoint;\r\n        const documents = result.documents;\r\n        if (documents.length === 0) {\r\n            done = true;\r\n        } else {\r\n            for (let index = 0; index < documents.length; index++) {\r\n                const document = documents[index];\r\n                mergeOperationsIntoState(rxState._state, document.ops);\r\n            }\r\n        }\r\n    }\r\n    rxState._initDone = true;\r\n\r\n    const proxy = new Proxy(\r\n        rxState as any,\r\n        {\r\n            get(target, property: any) {\r\n                if (typeof property !== 'string') {\r\n                    return target[property];\r\n                }\r\n                if ((rxState as any)[property]) {\r\n                    const ret = (rxState as any)[property];\r\n                    if (typeof ret === 'function') {\r\n                        return ret.bind(rxState);\r\n                    } else {\r\n                        return ret;\r\n                    }\r\n                }\r\n                const lastChar = property.charAt(property.length - 1);\r\n                if (property.endsWith('$$')) {\r\n                    const key = property.slice(0, -2);\r\n                    return rxState.get$$(key as any);\r\n                } else if (lastChar === '$') {\r\n                    const key = property.slice(0, -1);\r\n                    return rxState.get$(key as any);\r\n                } else {\r\n                    return rxState.get(property as any);\r\n                }\r\n            },\r\n            set(target, newValue, receiver) {\r\n                throw new Error('Do not write to RxState');\r\n            }\r\n        }\r\n    );\r\n\r\n    runPluginHooks('createRxState', {\r\n        collection,\r\n        state: proxy\r\n    });\r\n\r\n    return proxy;\r\n}\r\n\r\n\r\nexport function mergeOperationsIntoState<T>(\r\n    state: T,\r\n    operations: RxStateOperation[]\r\n) {\r\n    for (let index = 0; index < operations.length; index++) {\r\n        const operation = operations[index];\r\n        setProperty(state, operation.k, clone(operation.v));\r\n    }\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/cjs/plugins/state/types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=types.js.map

package/dist/cjs/plugins/state/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../../src/plugins/state/types.ts"],"sourcesContent":["import { DeepReadonly } from '../../types';\r\n\r\n/**\r\n * \r\n */\r\nexport type RxStateDocument = {\r\n    /**\r\n     * Ensures that when multiple\r\n     * javascript realms write at the same time,\r\n     * we do not overwrite each other but instead\r\n     * one write must conflict-error and retry.\r\n     * The clock value is also the primary key.\r\n     * The clock value contains incremental numbers\r\n     * in a string format like '0001', '0123'...\r\n     */\r\n    id: string;\r\n    /**\r\n     * Id of the JavaScript Instance of RxState\r\n     * that did the write. Used to optimise performance\r\n     * by not running these modifiers twice.\r\n     */\r\n    sId: string;\r\n    ops: RxStateOperation[]\r\n};\r\n\r\n\r\nexport type RxStateOperation = {\r\n    k: string;\r\n    v: any;\r\n};\r\n\r\nexport type RxStateModifier = (preValue: DeepReadonly<any>) => any;\r\n"],"mappings":"","ignoreList":[]}

package/dist/cjs/plugins/storage-denokv/denokv-helper.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RX_STORAGE_NAME_DENOKV = exports.DENOKV_DOCUMENT_ROOT_PATH = exports.CLEANUP_INDEX = void 0;
+exports.commitWithRetry = commitWithRetry;
+exports.getDenoGlobal = getDenoGlobal;
+exports.getDenoKVIndexName = getDenoKVIndexName;
+var _utilsPromise = require("../utils/utils-promise.js");
+var RX_STORAGE_NAME_DENOKV = exports.RX_STORAGE_NAME_DENOKV = 'denokv';
+function getDenoKVIndexName(index) {
+  return index.join('|');
+}
+
+/**
+ * Used for non-index rows that contain the document data,
+ * not just a documentId
+ */
+var DENOKV_DOCUMENT_ROOT_PATH = exports.DENOKV_DOCUMENT_ROOT_PATH = '||';
+var CLEANUP_INDEX = exports.CLEANUP_INDEX = ['_deleted', '_meta.lwt'];
+
+/**
+ * Get the global Deno variable from globalThis.Deno
+ * so that compiling with plain typescript does not fail.
+ * Deno has no way to just "download" the deno typings,
+ * so we have to use the "any" type here.
+ */
+function getDenoGlobal() {
+  return globalThis.Deno;
+}
+async function commitWithRetry(buildTx) {
+  var attempt = 0;
+  while (true) {
+    var tx = buildTx();
+    try {
+      return await tx.commit();
+    } catch (err) {
+      var locked = err && String(err.message).includes('database is locked');
+      if (locked && attempt < 10) {
+        attempt++;
+        await (0, _utilsPromise.promiseWait)(10 * attempt);
+        continue;
+      }
+      throw err;
+    }
+  }
+}
+//# sourceMappingURL=denokv-helper.js.map

package/dist/cjs/plugins/storage-denokv/denokv-helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"denokv-helper.js","names":["_utilsPromise","require","RX_STORAGE_NAME_DENOKV","exports","getDenoKVIndexName","index","join","DENOKV_DOCUMENT_ROOT_PATH","CLEANUP_INDEX","getDenoGlobal","globalThis","Deno","commitWithRetry","buildTx","attempt","tx","commit","err","locked","String","message","includes","promiseWait"],"sources":["../../../../src/plugins/storage-denokv/denokv-helper.ts"],"sourcesContent":["import { promiseWait } from '../utils/utils-promise.ts';\r\n\r\nexport const RX_STORAGE_NAME_DENOKV = 'denokv';\r\n\r\nexport function getDenoKVIndexName(index: string[]): string {\r\n    return index.join('|');\r\n}\r\n\r\n/**\r\n * Used for non-index rows that contain the document data,\r\n * not just a documentId\r\n */\r\nexport const DENOKV_DOCUMENT_ROOT_PATH = '||';\r\n\r\nexport const CLEANUP_INDEX: string[] = ['_deleted', '_meta.lwt'];\r\n\r\n\r\n/**\r\n * Get the global Deno variable from globalThis.Deno\r\n * so that compiling with plain typescript does not fail.\r\n * Deno has no way to just \"download\" the deno typings,\r\n * so we have to use the \"any\" type here.\r\n */\r\nexport function getDenoGlobal(): any {\r\n    return (globalThis as any).Deno;\r\n}\r\n\r\n\r\nexport async function commitWithRetry(buildTx: () => any) {\r\n    let attempt = 0;\r\n\r\n    while (true) {\r\n        const tx = buildTx();\r\n        try {\r\n            return await tx.commit();\r\n        } catch (err) {\r\n            const locked = err && String((err as any).message).includes('database is locked');\r\n            if (locked && attempt < 10) {\r\n                attempt++;\r\n                await promiseWait(10 * attempt);\r\n                continue;\r\n            }\r\n            throw err;\r\n        }\r\n    }\r\n}\r\n"],"mappings":";;;;;;;;;AAAA,IAAAA,aAAA,GAAAC,OAAA;AAEO,IAAMC,sBAAsB,GAAAC,OAAA,CAAAD,sBAAA,GAAG,QAAQ;AAEvC,SAASE,kBAAkBA,CAACC,KAAe,EAAU;EACxD,OAAOA,KAAK,CAACC,IAAI,CAAC,GAAG,CAAC;AAC1B;;AAEA;AACA;AACA;AACA;AACO,IAAMC,yBAAyB,GAAAJ,OAAA,CAAAI,yBAAA,GAAG,IAAI;AAEtC,IAAMC,aAAuB,GAAAL,OAAA,CAAAK,aAAA,GAAG,CAAC,UAAU,EAAE,WAAW,CAAC;;AAGhE;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,aAAaA,CAAA,EAAQ;EACjC,OAAQC,UAAU,CAASC,IAAI;AACnC;AAGO,eAAeC,eAAeA,CAACC,OAAkB,EAAE;EACtD,IAAIC,OAAO,GAAG,CAAC;EAEf,OAAO,IAAI,EAAE;IACT,IAAMC,EAAE,GAAGF,OAAO,CAAC,CAAC;IACpB,IAAI;MACA,OAAO,MAAME,EAAE,CAACC,MAAM,CAAC,CAAC;IAC5B,CAAC,CAAC,OAAOC,GAAG,EAAE;MACV,IAAMC,MAAM,GAAGD,GAAG,IAAIE,MAAM,CAAEF,GAAG,CAASG,OAAO,CAAC,CAACC,QAAQ,CAAC,oBAAoB,CAAC;MACjF,IAAIH,MAAM,IAAIJ,OAAO,GAAG,EAAE,EAAE;QACxBA,OAAO,EAAE;QACT,MAAM,IAAAQ,yBAAW,EAAC,EAAE,GAAGR,OAAO,CAAC;QAC/B;MACJ;MACA,MAAMG,GAAG;IACb;EACJ;AACJ","ignoreList":[]}

package/dist/cjs/plugins/storage-denokv/denokv-query.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.queryDenoKV = queryDenoKV;
+var _customIndex = require("../../custom-index.js");
+var _index = require("../../plugins/utils/index.js");
+var _rxQueryHelper = require("../../rx-query-helper.js");
+var _denokvHelper = require("./denokv-helper.js");
+async function queryDenoKV(instance, preparedQuery) {
+  var queryPlan = preparedQuery.queryPlan;
+  var query = preparedQuery.query;
+  var skip = query.skip ? query.skip : 0;
+  var limit = query.limit ? query.limit : Infinity;
+  var skipPlusLimit = skip + limit;
+  var queryPlanFields = queryPlan.index;
+  var mustManuallyResort = !queryPlan.sortSatisfiedByIndex;
+  var queryMatcher = false;
+  if (!queryPlan.selectorSatisfiedByIndex) {
+    queryMatcher = (0, _rxQueryHelper.getQueryMatcher)(instance.schema, preparedQuery.query);
+  }
+  var kv = await instance.kvPromise;
+  var indexForName = queryPlanFields.slice(0);
+  var indexName = (0, _denokvHelper.getDenoKVIndexName)(indexForName);
+  var indexMeta = (0, _index.ensureNotFalsy)(instance.internals.indexes[indexName]);
+  var lowerBound = queryPlan.startKeys;
+  var lowerBoundString = (0, _customIndex.getStartIndexStringFromLowerBound)(instance.schema, indexForName, lowerBound);
+  if (!queryPlan.inclusiveStart) {
+    lowerBoundString = (0, _customIndex.changeIndexableStringByOneQuantum)(lowerBoundString, 1);
+  }
+  var upperBound = queryPlan.endKeys;
+  var upperBoundString = (0, _customIndex.getStartIndexStringFromUpperBound)(instance.schema, indexForName, upperBound);
+  if (queryPlan.inclusiveEnd) {
+    upperBoundString = (0, _customIndex.changeIndexableStringByOneQuantum)(upperBoundString, +1);
+  }
+  if (lowerBoundString > upperBoundString) {
+    return {
+      documents: []
+    };
+  }
+  var result = [];
+
+  /**
+   * TODO for whatever reason the keySelectors like firstGreaterThan etc.
+   * do not work properly. So we have to hack here to find the correct
+   * document in case lowerBoundString===upperBoundString.
+   * This likely must be fixed in the foundationdb library.
+   * When it is fixed, we do not need this if-case and instead
+   * can rely on .getRangeBatch() in all cases.
+   */
+  if (lowerBoundString === upperBoundString) {
+    var singleDocResult = await kv.get([instance.keySpace, indexMeta.indexId, lowerBoundString], instance.kvOptions);
+    if (singleDocResult.value) {
+      var docId = singleDocResult.value;
+      var docDataResult = await kv.get([instance.keySpace, _denokvHelper.DENOKV_DOCUMENT_ROOT_PATH, docId], instance.kvOptions);
+      var docData = docDataResult.value;
+      if (docData && (!queryMatcher || queryMatcher(docData))) {
+        result.push(docData);
+      }
+    }
+    return {
+      documents: result
+    };
+  }
+  var range = kv.list({
+    start: [instance.keySpace, indexMeta.indexId, lowerBoundString],
+    end: [instance.keySpace, indexMeta.indexId, upperBoundString]
+  }, {
+    consistency: instance.settings.consistencyLevel,
+    limit: !mustManuallyResort && queryPlan.selectorSatisfiedByIndex ? skipPlusLimit : undefined,
+    batchSize: instance.settings.batchSize
+  });
+  for await (var indexDocEntry of range) {
+    var _docId = indexDocEntry.value;
+    var _docDataResult = await kv.get([instance.keySpace, _denokvHelper.DENOKV_DOCUMENT_ROOT_PATH, _docId], instance.kvOptions);
+    var _docData = _docDataResult.value;
+    if (!_docData) {
+      continue;
+    }
+    if (!queryMatcher || queryMatcher(_docData)) {
+      result.push(_docData);
+    }
+    if (!mustManuallyResort && result.length === skipPlusLimit) {
+      break;
+    }
+  }
+  if (mustManuallyResort) {
+    var sortComparator = (0, _rxQueryHelper.getSortComparator)(instance.schema, preparedQuery.query);
+    result = result.sort(sortComparator);
+  }
+
+  // apply skip and limit boundaries.
+  result = result.slice(skip, skipPlusLimit);
+  return {
+    documents: result
+  };
+}
+//# sourceMappingURL=denokv-query.js.map