@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/esm/plugins/storage-memory/index.js

@@ -0,0 +1,29 @@
+import { ensureRxStorageInstanceParamsAreCorrect } from "../../rx-storage-helper.js";
+import { RXDB_VERSION } from "../utils/utils-rxdb-version.js";
+import { createMemoryStorageInstance } from "./rx-storage-instance-memory.js";
+
+/**
+ * Keep the state even when the storage instance is closed.
+ * This makes it easier to use the memory storage
+ * to test filesystem-like and multiInstance behaviors.
+ */
+var COLLECTION_STATES = new Map();
+export function getRxStorageMemory(settings = {}) {
+  var storage = {
+    name: 'memory',
+    rxdbVersion: RXDB_VERSION,
+    collectionStates: COLLECTION_STATES,
+    createStorageInstance(params) {
+      ensureRxStorageInstanceParamsAreCorrect(params);
+      var useSettings = Object.assign({}, settings, params.options);
+      return createMemoryStorageInstance(this, params, useSettings);
+    }
+  };
+  return storage;
+}
+export * from "./memory-helper.js";
+export * from "./binary-search-bounds.js";
+export * from "./memory-types.js";
+export * from "./memory-indexes.js";
+export * from "./rx-storage-instance-memory.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/plugins/storage-memory/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["ensureRxStorageInstanceParamsAreCorrect","RXDB_VERSION","createMemoryStorageInstance","COLLECTION_STATES","Map","getRxStorageMemory","settings","storage","name","rxdbVersion","collectionStates","createStorageInstance","params","useSettings","Object","assign","options"],"sources":["../../../../src/plugins/storage-memory/index.ts"],"sourcesContent":["import { ensureRxStorageInstanceParamsAreCorrect } from '../../rx-storage-helper.ts';\r\nimport type { RxStorageInstanceCreationParams } from '../../types/index.d.ts';\r\nimport { RXDB_VERSION } from '../utils/utils-rxdb-version.ts';\r\nimport type {\r\n    RxStorageMemory,\r\n    RxStorageMemoryInstanceCreationOptions,\r\n    RxStorageMemorySettings\r\n} from './memory-types.ts';\r\nimport {\r\n    createMemoryStorageInstance,\r\n    RxStorageInstanceMemory\r\n} from './rx-storage-instance-memory.ts';\r\n\r\n/**\r\n * Keep the state even when the storage instance is closed.\r\n * This makes it easier to use the memory storage\r\n * to test filesystem-like and multiInstance behaviors.\r\n */\r\nconst COLLECTION_STATES = new Map();\r\n\r\nexport function getRxStorageMemory(\r\n    settings: RxStorageMemorySettings = {}\r\n): RxStorageMemory {\r\n\r\n    const storage: RxStorageMemory = {\r\n        name: 'memory',\r\n        rxdbVersion: RXDB_VERSION,\r\n        collectionStates: COLLECTION_STATES,\r\n        createStorageInstance<RxDocType>(\r\n            params: RxStorageInstanceCreationParams<RxDocType, RxStorageMemoryInstanceCreationOptions>\r\n        ): Promise<RxStorageInstanceMemory<RxDocType>> {\r\n            ensureRxStorageInstanceParamsAreCorrect(params);\r\n            const useSettings = Object.assign(\r\n                {},\r\n                settings,\r\n                params.options\r\n            );\r\n\r\n\r\n            return createMemoryStorageInstance(this, params, useSettings);\r\n        }\r\n    };\r\n\r\n    return storage;\r\n}\r\n\r\n\r\nexport * from './memory-helper.ts';\r\nexport * from './binary-search-bounds.ts';\r\nexport * from './memory-types.ts';\r\nexport * from './memory-indexes.ts';\r\nexport * from './rx-storage-instance-memory.ts';\r\n"],"mappings":"AAAA,SAASA,uCAAuC,QAAQ,4BAA4B;AAEpF,SAASC,YAAY,QAAQ,gCAAgC;AAM7D,SACIC,2BAA2B,QAExB,iCAAiC;;AAExC;AACA;AACA;AACA;AACA;AACA,IAAMC,iBAAiB,GAAG,IAAIC,GAAG,CAAC,CAAC;AAEnC,OAAO,SAASC,kBAAkBA,CAC9BC,QAAiC,GAAG,CAAC,CAAC,EACvB;EAEf,IAAMC,OAAwB,GAAG;IAC7BC,IAAI,EAAE,QAAQ;IACdC,WAAW,EAAER,YAAY;IACzBS,gBAAgB,EAAEP,iBAAiB;IACnCQ,qBAAqBA,CACjBC,MAA0F,EAC/C;MAC3CZ,uCAAuC,CAACY,MAAM,CAAC;MAC/C,IAAMC,WAAW,GAAGC,MAAM,CAACC,MAAM,CAC7B,CAAC,CAAC,EACFT,QAAQ,EACRM,MAAM,CAACI,OACX,CAAC;MAGD,OAAOd,2BAA2B,CAAC,IAAI,EAAEU,MAAM,EAAEC,WAAW,CAAC;IACjE;EACJ,CAAC;EAED,OAAON,OAAO;AAClB;AAGA,cAAc,oBAAoB;AAClC,cAAc,2BAA2B;AACzC,cAAc,mBAAmB;AACjC,cAAc,qBAAqB;AACnC,cAAc,iCAAiC","ignoreList":[]}

package/dist/esm/plugins/storage-memory/memory-helper.js

@@ -0,0 +1,165 @@
+import { pushAtSortPosition } from 'array-push-at-sort-position';
+import { newRxError } from "../../rx-error.js";
+import { boundEQ } from "./binary-search-bounds.js";
+export function getMemoryCollectionKey(databaseName, collectionName, schemaVersion) {
+  return [databaseName, collectionName, schemaVersion].join('--memory--');
+}
+export function ensureNotRemoved(instance) {
+  if (instance.internals.removed) {
+    throw new Error('removed already ' + instance.databaseName + ' - ' + instance.collectionName + ' - ' + instance.schema.version);
+  }
+}
+export function attachmentMapKey(documentId, attachmentId) {
+  return documentId + '||' + attachmentId;
+}
+function sortByIndexStringComparator(a, b) {
+  if (a[0] < b[0]) {
+    return -1;
+  } else {
+    return 1;
+  }
+}
+
+/**
+ * @hotPath
+ */
+export function putWriteRowToState(docId, state, stateByIndex, document, docInState) {
+  state.documents.set(docId, document);
+  for (var i = 0; i < stateByIndex.length; ++i) {
+    var byIndex = stateByIndex[i];
+    var docsWithIndex = byIndex.docsWithIndex;
+    var getIndexableString = byIndex.getIndexableString;
+    var newIndexString = getIndexableString(document);
+    var insertPosition = pushAtSortPosition(docsWithIndex, [newIndexString, document, docId], sortByIndexStringComparator, 0);
+
+    /**
+     * Remove previous if it was in the state
+     */
+    if (docInState) {
+      var previousIndexString = getIndexableString(docInState);
+      if (previousIndexString === newIndexString) {
+        /**
+         * Performance shortcut.
+         * If index was not changed -> The old doc must be before or after the new one.
+         */
+        var prev = docsWithIndex[insertPosition - 1];
+        if (prev && prev[2] === docId) {
+          docsWithIndex.splice(insertPosition - 1, 1);
+        } else {
+          var next = docsWithIndex[insertPosition + 1];
+          if (next[2] === docId) {
+            docsWithIndex.splice(insertPosition + 1, 1);
+          } else {
+            throw newRxError('SNH', {
+              document,
+              args: {
+                byIndex
+              }
+            });
+          }
+        }
+      } else {
+        /**
+         * Index changed, we must search for the old one and remove it.
+         */
+        var indexBefore = boundEQ(docsWithIndex, [previousIndexString], compareDocsWithIndex);
+        docsWithIndex.splice(indexBefore, 1);
+      }
+    }
+  }
+}
+
+/**
+ * @hotPath
+ * Efficiently inserts multiple documents into the state at once.
+ * Instead of inserting one-by-one with Array.splice() (O(n) per insert),
+ * this pre-computes all index entries, sorts them, and merges them into
+ * the existing sorted arrays in a single pass (O(n log n + n + m)).
+ */
+export function bulkInsertToState(primaryPath, state, stateByIndex, docs) {
+  var docsLength = docs.length;
+
+  // Extract documents and docIds once, store in Map
+  var documents = new Array(docsLength);
+  var docIds = new Array(docsLength);
+  for (var i = 0; i < docsLength; ++i) {
+    var doc = docs[i].document;
+    var docId = doc[primaryPath];
+    documents[i] = doc;
+    docIds[i] = docId;
+    state.documents.set(docId, doc);
+  }
+
+  // For each index, batch-compute entries, sort, and merge
+  for (var indexI = 0; indexI < stateByIndex.length; ++indexI) {
+    var byIndex = stateByIndex[indexI];
+    var docsWithIndex = byIndex.docsWithIndex;
+    var getIndexableString = byIndex.getIndexableString;
+
+    // Build new entries
+    var newEntries = new Array(docsLength);
+    for (var _i = 0; _i < docsLength; ++_i) {
+      var _doc = documents[_i];
+      newEntries[_i] = [getIndexableString(_doc), _doc, docIds[_i]];
+    }
+
+    // Sort by index string
+    newEntries.sort(sortByIndexStringComparator);
+    if (docsWithIndex.length === 0) {
+      // Index is empty, just assign sorted entries
+      byIndex.docsWithIndex = newEntries;
+    } else {
+      // Merge sorted arrays
+      byIndex.docsWithIndex = mergeSortedArrays(docsWithIndex, newEntries, sortByIndexStringComparator);
+    }
+  }
+}
+
+/**
+ * Merges two sorted arrays into a single sorted array.
+ * Runs in O(n + m) where n and m are the lengths of the input arrays.
+ */
+function mergeSortedArrays(a, b, comparator) {
+  var aLen = a.length;
+  var bLen = b.length;
+  var result = new Array(aLen + bLen);
+  var ai = 0;
+  var bi = 0;
+  var ri = 0;
+  while (ai < aLen && bi < bLen) {
+    if (comparator(a[ai], b[bi]) <= 0) {
+      result[ri++] = a[ai++];
+    } else {
+      result[ri++] = b[bi++];
+    }
+  }
+  while (ai < aLen) {
+    result[ri++] = a[ai++];
+  }
+  while (bi < bLen) {
+    result[ri++] = b[bi++];
+  }
+  return result;
+}
+export function removeDocFromState(primaryPath, schema, state, doc) {
+  var docId = doc[primaryPath];
+  state.documents.delete(docId);
+  Object.values(state.byIndex).forEach(byIndex => {
+    var docsWithIndex = byIndex.docsWithIndex;
+    var indexString = byIndex.getIndexableString(doc);
+    var positionInIndex = boundEQ(docsWithIndex, [indexString], compareDocsWithIndex);
+    docsWithIndex.splice(positionInIndex, 1);
+  });
+}
+export function compareDocsWithIndex(a, b) {
+  var indexStringA = a[0];
+  var indexStringB = b[0];
+  if (indexStringA < indexStringB) {
+    return -1;
+  } else if (indexStringA === indexStringB) {
+    return 0;
+  } else {
+    return 1;
+  }
+}
+//# sourceMappingURL=memory-helper.js.map

package/dist/esm/plugins/storage-memory/memory-helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-helper.js","names":["pushAtSortPosition","newRxError","boundEQ","getMemoryCollectionKey","databaseName","collectionName","schemaVersion","join","ensureNotRemoved","instance","internals","removed","Error","schema","version","attachmentMapKey","documentId","attachmentId","sortByIndexStringComparator","a","b","putWriteRowToState","docId","state","stateByIndex","document","docInState","documents","set","i","length","byIndex","docsWithIndex","getIndexableString","newIndexString","insertPosition","previousIndexString","prev","splice","next","args","indexBefore","compareDocsWithIndex","bulkInsertToState","primaryPath","docs","docsLength","Array","docIds","doc","indexI","newEntries","sort","mergeSortedArrays","comparator","aLen","bLen","result","ai","bi","ri","removeDocFromState","delete","Object","values","forEach","indexString","positionInIndex","indexStringA","indexStringB"],"sources":["../../../../src/plugins/storage-memory/memory-helper.ts"],"sourcesContent":["import type {\r\n    BulkWriteRow,\r\n    RxDocumentData,\r\n    RxJsonSchema\r\n} from '../../types/index.d.ts';\r\nimport type {\r\n    DocWithIndexString,\r\n    MemoryStorageInternals,\r\n    MemoryStorageInternalsByIndex\r\n} from './memory-types.ts';\r\nimport type { RxStorageInstanceMemory } from './rx-storage-instance-memory.ts';\r\nimport {\r\n    pushAtSortPosition\r\n} from 'array-push-at-sort-position';\r\nimport { newRxError } from '../../rx-error.ts';\r\nimport { boundEQ } from './binary-search-bounds.ts';\r\n\r\n\r\nexport function getMemoryCollectionKey(\r\n    databaseName: string,\r\n    collectionName: string,\r\n    schemaVersion: number\r\n): string {\r\n    return [\r\n        databaseName,\r\n        collectionName,\r\n        schemaVersion\r\n    ].join('--memory--');\r\n}\r\n\r\n\r\nexport function ensureNotRemoved(\r\n    instance: RxStorageInstanceMemory<any>\r\n) {\r\n    if (instance.internals.removed) {\r\n        throw new Error(\r\n            'removed already ' +\r\n            instance.databaseName + ' - ' + instance.collectionName +\r\n            ' - ' + instance.schema.version\r\n        );\r\n    }\r\n}\r\n\r\nexport function attachmentMapKey(documentId: string, attachmentId: string): string {\r\n    return documentId + '||' + attachmentId;\r\n}\r\n\r\n\r\nfunction sortByIndexStringComparator<RxDocType>(a: DocWithIndexString<RxDocType>, b: DocWithIndexString<RxDocType>) {\r\n    if (a[0] < b[0]) {\r\n        return -1;\r\n    } else {\r\n        return 1;\r\n    }\r\n}\r\n\r\n\r\n\r\n/**\r\n * @hotPath\r\n */\r\nexport function putWriteRowToState<RxDocType>(\r\n    docId: string,\r\n    state: MemoryStorageInternals<RxDocType>,\r\n    stateByIndex: MemoryStorageInternalsByIndex<RxDocType>[],\r\n    document: RxDocumentData<RxDocType>,\r\n    docInState?: RxDocumentData<RxDocType>\r\n) {\r\n    state.documents.set(docId, document as any);\r\n    for (let i = 0; i < stateByIndex.length; ++i) {\r\n        const byIndex = stateByIndex[i];\r\n        const docsWithIndex = byIndex.docsWithIndex;\r\n        const getIndexableString = byIndex.getIndexableString;\r\n        const newIndexString = getIndexableString(document as any);\r\n        const insertPosition = pushAtSortPosition(\r\n            docsWithIndex,\r\n            [\r\n                newIndexString,\r\n                document,\r\n                docId,\r\n            ],\r\n            sortByIndexStringComparator,\r\n            0\r\n        );\r\n\r\n        /**\r\n         * Remove previous if it was in the state\r\n         */\r\n        if (docInState) {\r\n            const previousIndexString = getIndexableString(docInState);\r\n            if (previousIndexString === newIndexString) {\r\n                /**\r\n                 * Performance shortcut.\r\n                 * If index was not changed -> The old doc must be before or after the new one.\r\n                 */\r\n                const prev = docsWithIndex[insertPosition - 1];\r\n                if (prev && prev[2] === docId) {\r\n                    docsWithIndex.splice(insertPosition - 1, 1);\r\n                } else {\r\n                    const next = docsWithIndex[insertPosition + 1];\r\n                    if (next[2] === docId) {\r\n                        docsWithIndex.splice(insertPosition + 1, 1);\r\n                    } else {\r\n                        throw newRxError('SNH', {\r\n                            document,\r\n                            args: {\r\n                                byIndex\r\n                            }\r\n                        });\r\n                    }\r\n                }\r\n            } else {\r\n                /**\r\n                 * Index changed, we must search for the old one and remove it.\r\n                 */\r\n                const indexBefore = boundEQ(\r\n                    docsWithIndex,\r\n                    [\r\n                        previousIndexString\r\n                    ] as any,\r\n                    compareDocsWithIndex\r\n                );\r\n                docsWithIndex.splice(indexBefore, 1);\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\n\r\n/**\r\n * @hotPath\r\n * Efficiently inserts multiple documents into the state at once.\r\n * Instead of inserting one-by-one with Array.splice() (O(n) per insert),\r\n * this pre-computes all index entries, sorts them, and merges them into\r\n * the existing sorted arrays in a single pass (O(n log n + n + m)).\r\n */\r\nexport function bulkInsertToState<RxDocType>(\r\n    primaryPath: string,\r\n    state: MemoryStorageInternals<RxDocType>,\r\n    stateByIndex: MemoryStorageInternalsByIndex<RxDocType>[],\r\n    docs: { document: RxDocumentData<RxDocType> }[]\r\n) {\r\n    const docsLength = docs.length;\r\n\r\n    // Extract documents and docIds once, store in Map\r\n    const documents: RxDocumentData<RxDocType>[] = new Array(docsLength);\r\n    const docIds: string[] = new Array(docsLength);\r\n    for (let i = 0; i < docsLength; ++i) {\r\n        const doc = docs[i].document;\r\n        const docId: string = (doc as any)[primaryPath];\r\n        documents[i] = doc;\r\n        docIds[i] = docId;\r\n        state.documents.set(docId, doc as any);\r\n    }\r\n\r\n    // For each index, batch-compute entries, sort, and merge\r\n    for (let indexI = 0; indexI < stateByIndex.length; ++indexI) {\r\n        const byIndex = stateByIndex[indexI];\r\n        const docsWithIndex = byIndex.docsWithIndex;\r\n        const getIndexableString = byIndex.getIndexableString;\r\n\r\n        // Build new entries\r\n        const newEntries: DocWithIndexString<RxDocType>[] = new Array(docsLength);\r\n        for (let i = 0; i < docsLength; ++i) {\r\n            const doc = documents[i];\r\n            newEntries[i] = [\r\n                getIndexableString(doc as any),\r\n                doc,\r\n                docIds[i]\r\n            ];\r\n        }\r\n\r\n        // Sort by index string\r\n        newEntries.sort(sortByIndexStringComparator);\r\n\r\n        if (docsWithIndex.length === 0) {\r\n            // Index is empty, just assign sorted entries\r\n            byIndex.docsWithIndex = newEntries;\r\n        } else {\r\n            // Merge sorted arrays\r\n            byIndex.docsWithIndex = mergeSortedArrays(docsWithIndex, newEntries, sortByIndexStringComparator);\r\n        }\r\n    }\r\n}\r\n\r\n\r\n/**\r\n * Merges two sorted arrays into a single sorted array.\r\n * Runs in O(n + m) where n and m are the lengths of the input arrays.\r\n */\r\nfunction mergeSortedArrays<T>(\r\n    a: T[],\r\n    b: T[],\r\n    comparator: (x: T, y: T) => number\r\n): T[] {\r\n    const aLen = a.length;\r\n    const bLen = b.length;\r\n    const result: T[] = new Array(aLen + bLen);\r\n    let ai = 0;\r\n    let bi = 0;\r\n    let ri = 0;\r\n\r\n    while (ai < aLen && bi < bLen) {\r\n        if (comparator(a[ai], b[bi]) <= 0) {\r\n            result[ri++] = a[ai++];\r\n        } else {\r\n            result[ri++] = b[bi++];\r\n        }\r\n    }\r\n\r\n    while (ai < aLen) {\r\n        result[ri++] = a[ai++];\r\n    }\r\n    while (bi < bLen) {\r\n        result[ri++] = b[bi++];\r\n    }\r\n\r\n    return result;\r\n}\r\n\r\nexport function removeDocFromState<RxDocType>(\r\n    primaryPath: string,\r\n    schema: RxJsonSchema<RxDocumentData<RxDocType>>,\r\n    state: MemoryStorageInternals<RxDocType>,\r\n    doc: RxDocumentData<RxDocType>\r\n) {\r\n    const docId: string = (doc as any)[primaryPath];\r\n    state.documents.delete(docId);\r\n\r\n    Object.values(state.byIndex).forEach(byIndex => {\r\n        const docsWithIndex = byIndex.docsWithIndex;\r\n        const indexString = byIndex.getIndexableString(doc);\r\n\r\n        const positionInIndex = boundEQ(\r\n            docsWithIndex,\r\n            [\r\n                indexString\r\n            ] as any,\r\n            compareDocsWithIndex\r\n        );\r\n        docsWithIndex.splice(positionInIndex, 1);\r\n    });\r\n}\r\n\r\n\r\nexport function compareDocsWithIndex<RxDocType>(\r\n    a: DocWithIndexString<RxDocType>,\r\n    b: DocWithIndexString<RxDocType>\r\n): 1 | 0 | -1 {\r\n    const indexStringA = a[0];\r\n    const indexStringB = b[0];\r\n    if (indexStringA < indexStringB) {\r\n        return -1;\r\n    } else if (indexStringA === indexStringB) {\r\n        return 0;\r\n    } else {\r\n        return 1;\r\n    }\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/plugins/storage-memory/memory-indexes.js

@@ -0,0 +1,21 @@
+import { getIndexableStringMonad } from "../../custom-index.js";
+import { getPrimaryFieldOfPrimaryKey } from "../../rx-schema-helper.js";
+import { toArray } from "../../plugins/utils/index.js";
+export function addIndexesToInternalsState(state, schema) {
+  var primaryPath = getPrimaryFieldOfPrimaryKey(schema.primaryKey);
+  var useIndexes = !schema.indexes ? [] : schema.indexes.map(row => toArray(row));
+
+  // we need this index for running cleanup()
+  useIndexes.push(['_deleted', '_meta.lwt', primaryPath]);
+  useIndexes.forEach(indexAr => {
+    state.byIndex[getMemoryIndexName(indexAr)] = {
+      index: indexAr,
+      docsWithIndex: [],
+      getIndexableString: getIndexableStringMonad(schema, indexAr)
+    };
+  });
+}
+export function getMemoryIndexName(index) {
+  return index.join(',');
+}
+//# sourceMappingURL=memory-indexes.js.map

package/dist/esm/plugins/storage-memory/memory-indexes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-indexes.js","names":["getIndexableStringMonad","getPrimaryFieldOfPrimaryKey","toArray","addIndexesToInternalsState","state","schema","primaryPath","primaryKey","useIndexes","indexes","map","row","push","forEach","indexAr","byIndex","getMemoryIndexName","index","docsWithIndex","getIndexableString","join"],"sources":["../../../../src/plugins/storage-memory/memory-indexes.ts"],"sourcesContent":["import { getIndexableStringMonad } from '../../custom-index.ts';\r\nimport { getPrimaryFieldOfPrimaryKey } from '../../rx-schema-helper.ts';\r\nimport type { RxDocumentData, RxJsonSchema } from '../../types/index.d.ts';\r\nimport { toArray } from '../../plugins/utils/index.ts';\r\nimport type { MemoryStorageInternals } from './memory-types.ts';\r\n\r\nexport function addIndexesToInternalsState<RxDocType>(\r\n    state: MemoryStorageInternals<RxDocType>,\r\n    schema: RxJsonSchema<RxDocumentData<RxDocType>>\r\n) {\r\n    const primaryPath = getPrimaryFieldOfPrimaryKey(schema.primaryKey);\r\n    const useIndexes: string[][] = !schema.indexes ? [] : schema.indexes.map(row => toArray(row)) as any;\r\n\r\n    // we need this index for running cleanup()\r\n    useIndexes.push([\r\n        '_deleted',\r\n        '_meta.lwt',\r\n        primaryPath\r\n    ]);\r\n\r\n\r\n    useIndexes.forEach(indexAr => {\r\n        state.byIndex[getMemoryIndexName(indexAr)] = {\r\n            index: indexAr,\r\n            docsWithIndex: [],\r\n            getIndexableString: getIndexableStringMonad(schema, indexAr)\r\n        };\r\n    });\r\n}\r\n\r\n\r\nexport function getMemoryIndexName(index: string[]): string {\r\n    return index.join(',');\r\n}\r\n"],"mappings":"AAAA,SAASA,uBAAuB,QAAQ,uBAAuB;AAC/D,SAASC,2BAA2B,QAAQ,2BAA2B;AAEvE,SAASC,OAAO,QAAQ,8BAA8B;AAGtD,OAAO,SAASC,0BAA0BA,CACtCC,KAAwC,EACxCC,MAA+C,EACjD;EACE,IAAMC,WAAW,GAAGL,2BAA2B,CAACI,MAAM,CAACE,UAAU,CAAC;EAClE,IAAMC,UAAsB,GAAG,CAACH,MAAM,CAACI,OAAO,GAAG,EAAE,GAAGJ,MAAM,CAACI,OAAO,CAACC,GAAG,CAACC,GAAG,IAAIT,OAAO,CAACS,GAAG,CAAC,CAAQ;;EAEpG;EACAH,UAAU,CAACI,IAAI,CAAC,CACZ,UAAU,EACV,WAAW,EACXN,WAAW,CACd,CAAC;EAGFE,UAAU,CAACK,OAAO,CAACC,OAAO,IAAI;IAC1BV,KAAK,CAACW,OAAO,CAACC,kBAAkB,CAACF,OAAO,CAAC,CAAC,GAAG;MACzCG,KAAK,EAAEH,OAAO;MACdI,aAAa,EAAE,EAAE;MACjBC,kBAAkB,EAAEnB,uBAAuB,CAACK,MAAM,EAAES,OAAO;IAC/D,CAAC;EACL,CAAC,CAAC;AACN;AAGA,OAAO,SAASE,kBAAkBA,CAACC,KAAe,EAAU;EACxD,OAAOA,KAAK,CAACG,IAAI,CAAC,GAAG,CAAC;AAC1B","ignoreList":[]}

package/dist/esm/plugins/storage-memory/memory-types.js

@@ -0,0 +1,3 @@
+export {};
+export {};
+//# sourceMappingURL=memory-types.js.map

package/dist/esm/plugins/storage-memory/memory-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-types.js","names":[],"sources":["../../../../src/plugins/storage-memory/memory-types.ts"],"sourcesContent":["import { Subject } from 'rxjs';\r\nimport type {\r\n    CategorizeBulkWriteRowsOutput,\r\n    EventBulk,\r\n    RxAttachmentWriteData,\r\n    RxDocumentData,\r\n    RxJsonSchema,\r\n    RxStorage,\r\n    RxStorageChangeEvent,\r\n    RxStorageDefaultCheckpoint\r\n} from '../../types/index.d.ts';\r\n\r\nexport type RxStorageMemorySettings = {};\r\nexport type RxStorageMemoryInstanceCreationOptions = {};\r\nexport type RxStorageMemory = RxStorage<MemoryStorageInternals<any>, RxStorageMemoryInstanceCreationOptions> & {\r\n    /**\r\n     * State by collectionKey\r\n     */\r\n    collectionStates: Map<string, MemoryStorageInternals<any>>;\r\n};\r\n\r\nexport type MemoryStorageInternalsByIndex<RxDocType> = {\r\n    index: string[];\r\n    docsWithIndex: DocWithIndexString<RxDocType>[];\r\n    getIndexableString: (docData: RxDocumentData<RxDocType>) => string;\r\n};\r\n\r\n/**\r\n * The internals are shared between multiple storage instances\r\n * that have been created with the same [databaseName+collectionName] combination.\r\n */\r\nexport type MemoryStorageInternals<RxDocType> = {\r\n    // used to debug stuff and identify instances\r\n    id: string;\r\n\r\n    /**\r\n     * Schema of the first instance created with the given settings.\r\n     * Used to ensure that the same storage is not re-created with\r\n     * a different schema.\r\n     */\r\n    schema: RxJsonSchema<RxDocumentData<RxDocType>>;\r\n\r\n    /**\r\n     * We reuse the memory state when multiple instances\r\n     * are created with the same params.\r\n     * If refCount becomes 0, we can delete the state.\r\n     */\r\n    refCount: number;\r\n    /**\r\n     * If this becomes true,\r\n     * it means that an instance has called remove()\r\n     * so all other instances should also not work anymore.\r\n     */\r\n    removed: boolean;\r\n    documents: Map<string, RxDocumentData<RxDocType>>;\r\n    /**\r\n     * Attachments data, indexed by a combined string\r\n     * consisting of [documentId + '||' + attachmentId]\r\n     */\r\n    attachments: Map<string, {\r\n        writeData: RxAttachmentWriteData;\r\n        digest: string;\r\n    }>;\r\n    byIndex: {\r\n        /**\r\n         * Because RxDB requires a deterministic sorting\r\n         * on all indexes, we can be sure that the composed index key\r\n         * of each document is unique, because it contains the primaryKey\r\n         * as last index part.\r\n         * So we do not have to store the index-position when we want to do fast\r\n         * writes. Instead we can do a binary search over the existing array\r\n         * because RxDB also knows the previous state of the document when we do a bulkWrite().\r\n         */\r\n        [indexName: string]: MemoryStorageInternalsByIndex<RxDocType>;\r\n    };\r\n\r\n    /**\r\n     * We need these to do lazy writes.\r\n     */\r\n    ensurePersistenceTask?: CategorizeBulkWriteRowsOutput<RxDocType>;\r\n    ensurePersistenceIdlePromise?: Promise<void>;\r\n\r\n    changes$: Subject<EventBulk<RxStorageChangeEvent<RxDocumentData<RxDocType>>, RxStorageDefaultCheckpoint>>;\r\n};\r\n\r\nexport type DocWithIndexString<RxDocType> = [\r\n    string, // indexString, must be first because often we only need that one.\r\n    RxDocumentData<RxDocType>, // document\r\n    string, // id\r\n];\r\n"],"mappings":"","ignoreList":[]}

package/dist/esm/plugins/storage-memory/rx-storage-instance-memory.js

@@ -0,0 +1,364 @@
+import _readOnlyError from "@babel/runtime/helpers/readOnlyError";
+import { Subject } from 'rxjs';
+import { getStartIndexStringFromLowerBound, getStartIndexStringFromUpperBound } from "../../custom-index.js";
+import { getPrimaryFieldOfPrimaryKey } from "../../rx-schema-helper.js";
+import { categorizeBulkWriteRows } from "../../rx-storage-helper.js";
+import { deepEqual, ensureNotFalsy, now, PROMISE_RESOLVE_TRUE, PROMISE_RESOLVE_VOID, randomToken, requestIdlePromiseNoQueue } from "../../plugins/utils/index.js";
+import { boundGE, boundGT, boundLE, boundLT } from "./binary-search-bounds.js";
+import { attachmentMapKey, bulkInsertToState, compareDocsWithIndex, ensureNotRemoved, getMemoryCollectionKey, putWriteRowToState, removeDocFromState } from "./memory-helper.js";
+import { addIndexesToInternalsState, getMemoryIndexName } from "./memory-indexes.js";
+import { getQueryMatcher, getSortComparator } from "../../rx-query-helper.js";
+import { newRxError } from "../../rx-error.js";
+
+/**
+ * Used in tests to ensure everything
+ * is closed correctly
+ */
+export var OPEN_MEMORY_INSTANCES = new Set();
+export var RxStorageInstanceMemory = /*#__PURE__*/function () {
+  /**
+   * Used by some plugins and storage wrappers
+   * to find out details about the internals of a write operation.
+   * For example if you want to know which documents really have been replaced
+   * or newly inserted.
+   */
+
+  function RxStorageInstanceMemory(storage, databaseName, collectionName, schema, internals, options, settings, devMode) {
+    this.closed = false;
+    this.categorizedByWriteInput = new WeakMap();
+    this.storage = storage;
+    this.databaseName = databaseName;
+    this.collectionName = collectionName;
+    this.schema = schema;
+    this.internals = internals;
+    this.options = options;
+    this.settings = settings;
+    this.devMode = devMode;
+    OPEN_MEMORY_INSTANCES.add(this);
+    this.primaryPath = getPrimaryFieldOfPrimaryKey(this.schema.primaryKey);
+  }
+  var _proto = RxStorageInstanceMemory.prototype;
+  _proto.bulkWrite = function bulkWrite(documentWrites, context) {
+    this.ensurePersistence();
+    ensureNotRemoved(this);
+    var internals = this.internals;
+    var documentsById = this.internals.documents;
+    var primaryPath = this.primaryPath;
+    var categorized = categorizeBulkWriteRows(this, primaryPath, documentsById, documentWrites, context);
+    var error = categorized.errors;
+    /**
+     * @performance
+     * We have to return a Promise but we do not want to wait
+     * one tick, so we directly create the promise
+     * which makes it likely to be already resolved later.
+     */
+    var awaitMe = Promise.resolve({
+      error
+    });
+    this.categorizedByWriteInput.set(documentWrites, categorized);
+    this.internals.ensurePersistenceTask = categorized;
+    if (!this.internals.ensurePersistenceIdlePromise) {
+      this.internals.ensurePersistenceIdlePromise = requestIdlePromiseNoQueue().then(() => {
+        this.internals.ensurePersistenceIdlePromise = undefined;
+        this.ensurePersistence();
+      });
+    }
+
+    /**
+     * Important: The events must be emitted AFTER the persistence
+     * task has been added.
+     */
+    if (categorized.eventBulk.events.length > 0) {
+      var lastState = ensureNotFalsy(categorized.newestRow).document;
+      categorized.eventBulk.checkpoint = {
+        id: lastState[primaryPath],
+        lwt: lastState._meta.lwt
+      };
+      internals.changes$.next(categorized.eventBulk);
+    }
+    return awaitMe;
+  }
+
+  /**
+   * Instead of directly inserting the documents into all indexes,
+   * we do it lazy in the background. This gives the application time
+   * to directly work with the write-result and to do stuff like rendering DOM
+   * notes and processing RxDB queries.
+   * Then in some later time, or just before the next read/write,
+   * it is ensured that the indexes have been written.
+   */;
+  _proto.ensurePersistence = function ensurePersistence() {
+    if (!this.internals.ensurePersistenceTask) {
+      return;
+    }
+    var internals = this.internals;
+    var documentsById = this.internals.documents;
+    var primaryPath = this.primaryPath;
+    var categorized = this.internals.ensurePersistenceTask;
+    this.internals.ensurePersistenceTask = undefined;
+
+    /**
+     * Do inserts/updates
+     */
+    var stateByIndex = Object.values(this.internals.byIndex);
+
+    /**
+     * @performance Use batch insert for bulk inserts to avoid
+     * repeated Array.splice() calls which are O(n) each.
+     * Instead, batch-compute index entries, sort them,
+     * and merge into existing sorted arrays.
+     */
+    var bulkInsertDocs = categorized.bulkInsertDocs;
+    if (bulkInsertDocs.length > 0) {
+      bulkInsertToState(primaryPath, internals, stateByIndex, bulkInsertDocs);
+    }
+    var bulkUpdateDocs = categorized.bulkUpdateDocs;
+    for (var i = 0; i < bulkUpdateDocs.length; ++i) {
+      var writeRow = bulkUpdateDocs[i];
+      var doc = writeRow.document;
+      var docId = doc[primaryPath];
+      putWriteRowToState(docId, internals, stateByIndex, doc, documentsById.get(docId));
+    }
+
+    /**
+     * Handle attachments
+     */
+    if (this.schema.attachments) {
+      var attachmentsMap = internals.attachments;
+      categorized.attachmentsAdd.forEach(attachment => {
+        attachmentsMap.set(attachmentMapKey(attachment.documentId, attachment.attachmentId), {
+          writeData: attachment.attachmentData,
+          digest: attachment.digest
+        });
+      });
+      if (this.schema.attachments) {
+        categorized.attachmentsUpdate.forEach(attachment => {
+          attachmentsMap.set(attachmentMapKey(attachment.documentId, attachment.attachmentId), {
+            writeData: attachment.attachmentData,
+            digest: attachment.digest
+          });
+        });
+        categorized.attachmentsRemove.forEach(attachment => {
+          attachmentsMap.delete(attachmentMapKey(attachment.documentId, attachment.attachmentId));
+        });
+      }
+    }
+  };
+  _proto.findDocumentsById = function findDocumentsById(docIds, withDeleted) {
+    this.ensurePersistence();
+    var documentsById = this.internals.documents;
+    var ret = [];
+    if (documentsById.size === 0) {
+      return Promise.resolve(ret);
+    }
+    for (var i = 0; i < docIds.length; ++i) {
+      var docId = docIds[i];
+      var docInDb = documentsById.get(docId);
+      if (docInDb && (!docInDb._deleted || withDeleted)) {
+        ret.push(docInDb);
+      }
+    }
+    return Promise.resolve(ret);
+  };
+  _proto.query = function query(preparedQuery) {
+    this.ensurePersistence();
+    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 queryMatcher = false;
+    if (!queryPlan.selectorSatisfiedByIndex) {
+      queryMatcher = getQueryMatcher(this.schema, preparedQuery.query);
+    }
+    var queryPlanFields = queryPlan.index;
+    var mustManuallyResort = !queryPlan.sortSatisfiedByIndex;
+    var index = queryPlanFields;
+    var lowerBound = queryPlan.startKeys;
+    var lowerBoundString = getStartIndexStringFromLowerBound(this.schema, index, lowerBound);
+    var upperBound = queryPlan.endKeys;
+    var upperBoundString = getStartIndexStringFromUpperBound(this.schema, index, upperBound);
+    var indexName = getMemoryIndexName(index);
+    if (!this.internals.byIndex[indexName]) {
+      throw new Error('index does not exist ' + indexName);
+    }
+    var docsWithIndex = this.internals.byIndex[indexName].docsWithIndex;
+    var indexOfLower = (queryPlan.inclusiveStart ? boundGE : boundGT)(docsWithIndex, [lowerBoundString], compareDocsWithIndex);
+    var indexOfUpper = (queryPlan.inclusiveEnd ? boundLE : boundLT)(docsWithIndex, [upperBoundString], compareDocsWithIndex);
+    var rows = [];
+
+    /**
+     * @performance
+     * If the selector is satisfied by the index,
+     * we can extract all documents in the range without
+     * running a per-document queryMatcher check.
+     * This is a common case for queries like find-by-query
+     * where the selector is empty or fully covered by the index.
+     */
+    if (!queryMatcher) {
+      var rangeLength = indexOfUpper - indexOfLower + 1;
+      if (rangeLength > 0) {
+        var extractLength = mustManuallyResort ? rangeLength : Math.min(rangeLength, skipPlusLimit);
+        rows = new Array(extractLength);
+        for (var i = 0; i < extractLength; i++) {
+          rows[i] = docsWithIndex[indexOfLower + i][1];
+        }
+      }
+    } else {
+      var done = false;
+      while (!done) {
+        var currentRow = docsWithIndex[indexOfLower];
+        if (!currentRow || indexOfLower > indexOfUpper) {
+          break;
+        }
+        var currentDoc = currentRow[1];
+        if (queryMatcher(currentDoc)) {
+          rows.push(currentDoc);
+        }
+        if (rows.length >= skipPlusLimit && !mustManuallyResort) {
+          done = true;
+        }
+        indexOfLower++;
+      }
+    }
+    if (mustManuallyResort) {
+      var sortComparator = getSortComparator(this.schema, preparedQuery.query);
+      rows = rows.sort(sortComparator);
+    }
+
+    // apply skip and limit boundaries.
+    if (skip !== 0 || rows.length > skipPlusLimit) {
+      rows = rows.slice(skip, skipPlusLimit);
+    }
+    return Promise.resolve({
+      documents: rows
+    });
+  };
+  _proto.count = function count(preparedQuery) {
+    this.ensurePersistence();
+    var queryPlan = preparedQuery.queryPlan;
+
+    /**
+     * @performance
+     * If the selector is satisfied by the index,
+     * we can compute the count directly from the index range
+     * without extracting document data into an array.
+     */
+    if (queryPlan.selectorSatisfiedByIndex) {
+      var queryPlanFields = queryPlan.index;
+      var index = queryPlanFields;
+      var lowerBound = queryPlan.startKeys;
+      var lowerBoundString = getStartIndexStringFromLowerBound(this.schema, index, lowerBound);
+      var upperBound = queryPlan.endKeys;
+      var upperBoundString = getStartIndexStringFromUpperBound(this.schema, index, upperBound);
+      var indexName = getMemoryIndexName(index);
+      if (!this.internals.byIndex[indexName]) {
+        throw newRxError('SNH', {
+          args: {
+            indexName
+          }
+        });
+      }
+      var docsWithIndex = this.internals.byIndex[indexName].docsWithIndex;
+      var indexOfLower = (queryPlan.inclusiveStart ? boundGE : boundGT)(docsWithIndex, [lowerBoundString], compareDocsWithIndex);
+      var indexOfUpper = (queryPlan.inclusiveEnd ? boundLE : boundLT)(docsWithIndex, [upperBoundString], compareDocsWithIndex);
+      var _count = Math.max(0, indexOfUpper - indexOfLower + 1);
+      return Promise.resolve({
+        count: _count,
+        mode: 'fast'
+      });
+    }
+    return this.query(preparedQuery).then(result => ({
+      count: result.documents.length,
+      mode: 'fast'
+    }));
+  };
+  _proto.cleanup = function cleanup(minimumDeletedTime) {
+    this.ensurePersistence();
+    var maxDeletionTime = now() - minimumDeletedTime;
+    var index = ['_deleted', '_meta.lwt', this.primaryPath];
+    var indexName = getMemoryIndexName(index);
+    var docsWithIndex = this.internals.byIndex[indexName].docsWithIndex;
+    var lowerBoundString = getStartIndexStringFromLowerBound(this.schema, index, [true, 0, '']);
+    var indexOfLower = boundGT(docsWithIndex, [lowerBoundString], compareDocsWithIndex);
+    var done = false;
+    while (!done) {
+      var currentDoc = docsWithIndex[indexOfLower];
+      if (!currentDoc || currentDoc[1]._meta.lwt > maxDeletionTime) {
+        done = true;
+      } else {
+        removeDocFromState(this.primaryPath, this.schema, this.internals, currentDoc[1]);
+        indexOfLower++;
+      }
+    }
+    return PROMISE_RESOLVE_TRUE;
+  };
+  _proto.getAttachmentData = function getAttachmentData(documentId, attachmentId, digest) {
+    this.ensurePersistence();
+    ensureNotRemoved(this);
+    var key = attachmentMapKey(documentId, attachmentId);
+    var data = this.internals.attachments.get(key);
+    if (!digest || !data || data.digest !== digest) {
+      throw new Error('attachment does not exist: ' + key);
+    }
+    return Promise.resolve(data.writeData.data);
+  };
+  _proto.changeStream = function changeStream() {
+    ensureNotRemoved(this);
+    return this.internals.changes$.asObservable();
+  };
+  _proto.remove = async function remove() {
+    if (this.closed) {
+      throw new Error('closed');
+    }
+    this.ensurePersistence();
+    ensureNotRemoved(this);
+    this.internals.removed = true;
+    this.storage.collectionStates.delete(getMemoryCollectionKey(this.databaseName, this.collectionName, this.schema.version));
+    await this.close();
+  };
+  _proto.close = function close() {
+    OPEN_MEMORY_INSTANCES.delete(this);
+    this.ensurePersistence();
+    if (this.closed) {
+      return PROMISE_RESOLVE_VOID;
+    }
+    this.closed = true;
+    this.internals.refCount = this.internals.refCount - 1;
+    return PROMISE_RESOLVE_VOID;
+  };
+  return RxStorageInstanceMemory;
+}();
+export function createMemoryStorageInstance(storage, params, settings) {
+  var collectionKey = getMemoryCollectionKey(params.databaseName, params.collectionName, params.schema.version);
+  var internals = storage.collectionStates.get(collectionKey);
+  if (!internals) {
+    internals = {
+      id: randomToken(5),
+      schema: params.schema,
+      removed: false,
+      refCount: 1,
+      documents: new Map(),
+      attachments: params.schema.attachments ? new Map() : undefined,
+      byIndex: {},
+      changes$: new Subject()
+    };
+    addIndexesToInternalsState(internals, params.schema);
+    storage.collectionStates.set(collectionKey, internals);
+  } else {
+    /**
+     * Ensure that the storage was not already
+     * created with a different schema.
+     * This is very important because if this check
+     * does not exist here, we have hard-to-debug problems
+     * downstream.
+     */
+    if (params.devMode && !deepEqual(internals.schema, params.schema)) {
+      throw new Error('storage was already created with a different schema');
+    }
+    internals.refCount = internals.refCount + 1;
+  }
+  var instance = new RxStorageInstanceMemory(storage, params.databaseName, params.collectionName, params.schema, internals, params.options, settings, params.devMode);
+  return Promise.resolve(instance);
+}
+//# sourceMappingURL=rx-storage-instance-memory.js.map