@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/esm/replication-protocol/index.js

@@ -0,0 +1,221 @@
+/**
+ * These files contain the replication protocol.
+ * It can be used to replicated RxStorageInstances or RxCollections
+ * or even to do a client(s)-server replication.
+ */
+
+import { BehaviorSubject, combineLatest, filter, firstValueFrom, mergeMap, Subject } from 'rxjs';
+import { getPrimaryFieldOfPrimaryKey } from "../rx-schema-helper.js";
+import { clone, ensureNotFalsy, flatClone, PROMISE_RESOLVE_VOID } from "../plugins/utils/index.js";
+import { getCheckpointKey } from "./checkpoint.js";
+import { startReplicationDownstream } from "./downstream.js";
+import { docStateToWriteDoc, getUnderlyingPersistentStorage, writeDocToDocState } from "./helper.js";
+import { startReplicationUpstream } from "./upstream.js";
+import { fillWriteDataForAttachmentsChange } from "../plugins/attachments/index.js";
+import { getChangedDocumentsSince } from "../rx-storage-helper.js";
+import { newRxError } from "../rx-error.js";
+export * from "./checkpoint.js";
+export * from "./downstream.js";
+export * from "./upstream.js";
+export * from "./meta-instance.js";
+export * from "./conflicts.js";
+export * from "./helper.js";
+export * from "./default-conflict-handler.js";
+
+/**
+ * Used in tests to ensure all states are cleaned up
+ * and we have no memory leak.
+ */
+export var OPEN_REPLICATION_STATES = new Set();
+export function replicateRxStorageInstance(input) {
+  input = flatClone(input);
+  input.forkInstance = getUnderlyingPersistentStorage(input.forkInstance);
+  input.metaInstance = getUnderlyingPersistentStorage(input.metaInstance);
+  var checkpointKeyPromise = getCheckpointKey(input);
+  var state = {
+    primaryPath: getPrimaryFieldOfPrimaryKey(input.forkInstance.schema.primaryKey),
+    hasAttachments: !!input.forkInstance.schema.attachments,
+    input,
+    skipStoringPullMeta: input.skipStoringPullMeta,
+    checkpointKey: checkpointKeyPromise,
+    downstreamBulkWriteFlag: checkpointKeyPromise.then(checkpointKey => 'replication-downstream-' + checkpointKey),
+    events: {
+      canceled: new BehaviorSubject(false),
+      paused: new BehaviorSubject(false),
+      active: {
+        down: new BehaviorSubject(true),
+        up: new BehaviorSubject(true)
+      },
+      processed: {
+        down: new Subject(),
+        up: new Subject()
+      },
+      resolvedConflicts: new Subject(),
+      error: new Subject()
+    },
+    stats: {
+      down: {
+        addNewTask: 0,
+        downstreamProcessChanges: 0,
+        downstreamResyncOnce: 0,
+        masterChangeStreamEmit: 0,
+        persistFromMaster: 0
+      },
+      up: {
+        forkChangeStreamEmit: 0,
+        persistToMaster: 0,
+        persistToMasterConflictWrites: 0,
+        persistToMasterHadConflicts: 0,
+        processTasks: 0,
+        upstreamInitialSync: 0
+      }
+    },
+    firstSyncDone: {
+      down: new BehaviorSubject(false),
+      up: new BehaviorSubject(false)
+    },
+    streamQueue: {
+      down: PROMISE_RESOLVE_VOID,
+      up: PROMISE_RESOLVE_VOID
+    },
+    checkpointQueue: PROMISE_RESOLVE_VOID,
+    lastCheckpointDoc: {}
+  };
+  OPEN_REPLICATION_STATES.add(state);
+  startReplicationDownstream(state);
+  startReplicationUpstream(state);
+  return state;
+}
+export function awaitRxStorageReplicationFirstInSync(state) {
+  return firstValueFrom(combineLatest([state.firstSyncDone.down.pipe(filter(v => !!v)), state.firstSyncDone.up.pipe(filter(v => !!v))])).then(() => {});
+}
+export function awaitRxStorageReplicationInSync(replicationState) {
+  return Promise.all([replicationState.streamQueue.up, replicationState.streamQueue.down, replicationState.checkpointQueue]);
+}
+export async function awaitRxStorageReplicationIdle(state) {
+  await awaitRxStorageReplicationFirstInSync(state);
+  while (true) {
+    var {
+      down,
+      up
+    } = state.streamQueue;
+    await Promise.all([up, down]);
+    /**
+     * If the Promises have not been reassigned
+     * after awaiting them, we know that the replication
+     * is in idle state at this point in time.
+     */
+    if (down === state.streamQueue.down && up === state.streamQueue.up) {
+      return;
+    }
+  }
+}
+export function rxStorageInstanceToReplicationHandler(instance, conflictHandler, databaseInstanceToken,
+/**
+ * If set to true,
+ * the _meta.lwt from the pushed documents is kept.
+ * (Used in the migration to ensure checkpoints are still valid)
+ */
+keepMeta = false) {
+  instance = getUnderlyingPersistentStorage(instance);
+  var hasAttachments = !!instance.schema.attachments;
+  var primaryPath = getPrimaryFieldOfPrimaryKey(instance.schema.primaryKey);
+  var replicationHandler = {
+    masterChangeStream$: instance.changeStream().pipe(mergeMap(async eventBulk => {
+      var ret = {
+        checkpoint: eventBulk.checkpoint,
+        documents: await Promise.all(eventBulk.events.map(async event => {
+          var docData = writeDocToDocState(event.documentData, hasAttachments, keepMeta);
+          if (hasAttachments) {
+            docData = await fillWriteDataForAttachmentsChange(primaryPath, instance, clone(docData),
+            /**
+             * Notice that the master never knows
+             * the client state of the document.
+             * Therefore we always send all attachments data.
+             */
+            undefined);
+          }
+          return docData;
+        }))
+      };
+      return ret;
+    })),
+    masterChangesSince(checkpoint, batchSize) {
+      return getChangedDocumentsSince(instance, batchSize, checkpoint).then(async result => {
+        return {
+          checkpoint: result.documents.length > 0 ? result.checkpoint : checkpoint,
+          documents: await Promise.all(result.documents.map(async plainDocumentData => {
+            var docData = writeDocToDocState(plainDocumentData, hasAttachments, keepMeta);
+            if (hasAttachments) {
+              docData = await fillWriteDataForAttachmentsChange(primaryPath, instance, clone(docData),
+              /**
+               * Notice that the master never knows
+               * the client state of the document.
+               * Therefore we always send all attachments data.
+               */
+              undefined);
+            }
+            return docData;
+          }))
+        };
+      });
+    },
+    async masterWrite(rows) {
+      var rowById = {};
+      rows.forEach(row => {
+        var docId = row.newDocumentState[primaryPath];
+        rowById[docId] = row;
+      });
+      var ids = Object.keys(rowById);
+      var masterDocsStateList = await instance.findDocumentsById(ids, true);
+      var masterDocsState = new Map();
+      masterDocsStateList.forEach(doc => masterDocsState.set(doc[primaryPath], doc));
+      var conflicts = [];
+      var writeRows = [];
+      await Promise.all(Object.entries(rowById).map(([id, row]) => {
+        var masterState = masterDocsState.get(id);
+        if (!masterState) {
+          writeRows.push({
+            document: docStateToWriteDoc(databaseInstanceToken, hasAttachments, keepMeta, row.newDocumentState)
+          });
+        } else if (masterState && !row.assumedMasterState) {
+          conflicts.push(writeDocToDocState(masterState, hasAttachments, keepMeta));
+        } else if (conflictHandler.isEqual(writeDocToDocState(masterState, hasAttachments, keepMeta), ensureNotFalsy(row.assumedMasterState), 'rxStorageInstanceToReplicationHandler-masterWrite') === true) {
+          writeRows.push({
+            previous: masterState,
+            document: docStateToWriteDoc(databaseInstanceToken, hasAttachments, keepMeta, row.newDocumentState, masterState)
+          });
+        } else {
+          conflicts.push(writeDocToDocState(masterState, hasAttachments, keepMeta));
+        }
+      }));
+      if (writeRows.length > 0) {
+        var result = await instance.bulkWrite(writeRows, 'replication-master-write');
+        result.error.forEach(err => {
+          if (err.status !== 409) {
+            throw newRxError('SNH', {
+              name: 'non conflict error',
+              error: err
+            });
+          } else {
+            conflicts.push(writeDocToDocState(ensureNotFalsy(err.documentInDb), hasAttachments, keepMeta));
+          }
+        });
+      }
+      return conflicts;
+    }
+  };
+  return replicationHandler;
+}
+export async function cancelRxStorageReplication(replicationState) {
+  OPEN_REPLICATION_STATES.delete(replicationState);
+  replicationState.events.canceled.next(true);
+  replicationState.events.active.up.complete();
+  replicationState.events.active.down.complete();
+  replicationState.events.processed.up.complete();
+  replicationState.events.processed.down.complete();
+  replicationState.events.resolvedConflicts.complete();
+  replicationState.events.canceled.complete();
+  await replicationState.checkpointQueue;
+}
+//# sourceMappingURL=index.js.map

package/dist/esm/replication-protocol/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["BehaviorSubject","combineLatest","filter","firstValueFrom","mergeMap","Subject","getPrimaryFieldOfPrimaryKey","clone","ensureNotFalsy","flatClone","PROMISE_RESOLVE_VOID","getCheckpointKey","startReplicationDownstream","docStateToWriteDoc","getUnderlyingPersistentStorage","writeDocToDocState","startReplicationUpstream","fillWriteDataForAttachmentsChange","getChangedDocumentsSince","newRxError","OPEN_REPLICATION_STATES","Set","replicateRxStorageInstance","input","forkInstance","metaInstance","checkpointKeyPromise","state","primaryPath","schema","primaryKey","hasAttachments","attachments","skipStoringPullMeta","checkpointKey","downstreamBulkWriteFlag","then","events","canceled","paused","active","down","up","processed","resolvedConflicts","error","stats","addNewTask","downstreamProcessChanges","downstreamResyncOnce","masterChangeStreamEmit","persistFromMaster","forkChangeStreamEmit","persistToMaster","persistToMasterConflictWrites","persistToMasterHadConflicts","processTasks","upstreamInitialSync","firstSyncDone","streamQueue","checkpointQueue","lastCheckpointDoc","add","awaitRxStorageReplicationFirstInSync","pipe","v","awaitRxStorageReplicationInSync","replicationState","Promise","all","awaitRxStorageReplicationIdle","rxStorageInstanceToReplicationHandler","instance","conflictHandler","databaseInstanceToken","keepMeta","replicationHandler","masterChangeStream$","changeStream","eventBulk","ret","checkpoint","documents","map","event","docData","documentData","undefined","masterChangesSince","batchSize","result","length","plainDocumentData","masterWrite","rows","rowById","forEach","row","docId","newDocumentState","ids","Object","keys","masterDocsStateList","findDocumentsById","masterDocsState","Map","doc","set","conflicts","writeRows","entries","id","masterState","get","push","document","assumedMasterState","isEqual","previous","bulkWrite","err","status","name","documentInDb","cancelRxStorageReplication","delete","next","complete"],"sources":["../../../src/replication-protocol/index.ts"],"sourcesContent":["/**\r\n * These files contain the replication protocol.\r\n * It can be used to replicated RxStorageInstances or RxCollections\r\n * or even to do a client(s)-server replication.\r\n */\r\n\r\n\r\nimport {\r\n    BehaviorSubject,\r\n    combineLatest,\r\n    filter,\r\n    firstValueFrom,\r\n    mergeMap,\r\n    Subject\r\n} from 'rxjs';\r\nimport {\r\n    getPrimaryFieldOfPrimaryKey\r\n} from '../rx-schema-helper.ts';\r\nimport type {\r\n    BulkWriteRow,\r\n    ById,\r\n    DocumentsWithCheckpoint,\r\n    EventBulk,\r\n    RxConflictHandler,\r\n    RxDocumentData,\r\n    RxReplicationHandler,\r\n    RxReplicationWriteToMasterRow,\r\n    RxStorageChangeEvent,\r\n    RxStorageInstance,\r\n    RxStorageInstanceReplicationInput,\r\n    RxStorageInstanceReplicationState,\r\n    WithDeleted\r\n} from '../types/index.d.ts';\r\nimport {\r\n    clone,\r\n    ensureNotFalsy,\r\n    flatClone,\r\n    PROMISE_RESOLVE_VOID\r\n} from '../plugins/utils/index.ts';\r\nimport {\r\n    getCheckpointKey\r\n} from './checkpoint.ts';\r\nimport { startReplicationDownstream } from './downstream.ts';\r\nimport {\r\n    docStateToWriteDoc,\r\n    getUnderlyingPersistentStorage,\r\n    writeDocToDocState\r\n} from './helper.ts';\r\nimport { startReplicationUpstream } from './upstream.ts';\r\nimport { fillWriteDataForAttachmentsChange } from '../plugins/attachments/index.ts';\r\nimport { getChangedDocumentsSince } from '../rx-storage-helper.ts';\r\nimport { newRxError } from '../rx-error.ts';\r\n\r\n\r\nexport * from './checkpoint.ts';\r\nexport * from './downstream.ts';\r\nexport * from './upstream.ts';\r\nexport * from './meta-instance.ts';\r\nexport * from './conflicts.ts';\r\nexport * from './helper.ts';\r\nexport * from './default-conflict-handler.ts';\r\n\r\n\r\n/**\r\n * Used in tests to ensure all states are cleaned up\r\n * and we have no memory leak.\r\n */\r\nexport const OPEN_REPLICATION_STATES = new Set<RxStorageInstanceReplicationState<any>>();\r\n\r\nexport function replicateRxStorageInstance<RxDocType>(\r\n    input: RxStorageInstanceReplicationInput<RxDocType>\r\n): RxStorageInstanceReplicationState<RxDocType> {\r\n    input = flatClone(input);\r\n    input.forkInstance = getUnderlyingPersistentStorage(input.forkInstance);\r\n    input.metaInstance = getUnderlyingPersistentStorage(input.metaInstance);\r\n    const checkpointKeyPromise = getCheckpointKey(input);\r\n    const state: RxStorageInstanceReplicationState<RxDocType> = {\r\n        primaryPath: getPrimaryFieldOfPrimaryKey(input.forkInstance.schema.primaryKey),\r\n        hasAttachments: !!input.forkInstance.schema.attachments,\r\n        input,\r\n        skipStoringPullMeta: input.skipStoringPullMeta,\r\n        checkpointKey: checkpointKeyPromise,\r\n        downstreamBulkWriteFlag: checkpointKeyPromise.then(checkpointKey => 'replication-downstream-' + checkpointKey),\r\n        events: {\r\n            canceled: new BehaviorSubject<boolean>(false),\r\n            paused: new BehaviorSubject<boolean>(false),\r\n            active: {\r\n                down: new BehaviorSubject<boolean>(true),\r\n                up: new BehaviorSubject<boolean>(true)\r\n            },\r\n            processed: {\r\n                down: new Subject(),\r\n                up: new Subject()\r\n            },\r\n            resolvedConflicts: new Subject(),\r\n            error: new Subject()\r\n        },\r\n        stats: {\r\n            down: {\r\n                addNewTask: 0,\r\n                downstreamProcessChanges: 0,\r\n                downstreamResyncOnce: 0,\r\n                masterChangeStreamEmit: 0,\r\n                persistFromMaster: 0\r\n            },\r\n            up: {\r\n                forkChangeStreamEmit: 0,\r\n                persistToMaster: 0,\r\n                persistToMasterConflictWrites: 0,\r\n                persistToMasterHadConflicts: 0,\r\n                processTasks: 0,\r\n                upstreamInitialSync: 0\r\n            }\r\n        },\r\n        firstSyncDone: {\r\n            down: new BehaviorSubject<boolean>(false),\r\n            up: new BehaviorSubject<boolean>(false)\r\n        },\r\n        streamQueue: {\r\n            down: PROMISE_RESOLVE_VOID,\r\n            up: PROMISE_RESOLVE_VOID\r\n        },\r\n        checkpointQueue: PROMISE_RESOLVE_VOID,\r\n        lastCheckpointDoc: {}\r\n    };\r\n    OPEN_REPLICATION_STATES.add(state);\r\n\r\n    startReplicationDownstream(state);\r\n    startReplicationUpstream(state);\r\n    return state;\r\n}\r\n\r\nexport function awaitRxStorageReplicationFirstInSync(\r\n    state: RxStorageInstanceReplicationState<any>\r\n): Promise<void> {\r\n    return firstValueFrom(\r\n        combineLatest([\r\n            state.firstSyncDone.down.pipe(\r\n                filter((v: boolean) => !!v)\r\n            ),\r\n            state.firstSyncDone.up.pipe(\r\n                filter((v: boolean) => !!v)\r\n            )\r\n        ])\r\n    ).then(() => { });\r\n}\r\n\r\nexport function awaitRxStorageReplicationInSync(\r\n    replicationState: RxStorageInstanceReplicationState<any>\r\n) {\r\n    return Promise.all([\r\n        replicationState.streamQueue.up,\r\n        replicationState.streamQueue.down,\r\n        replicationState.checkpointQueue\r\n    ]);\r\n}\r\n\r\n\r\nexport async function awaitRxStorageReplicationIdle(\r\n    state: RxStorageInstanceReplicationState<any>\r\n) {\r\n    await awaitRxStorageReplicationFirstInSync(state);\r\n    while (true) {\r\n        const { down, up } = state.streamQueue;\r\n        await Promise.all([\r\n            up,\r\n            down\r\n        ]);\r\n        /**\r\n         * If the Promises have not been reassigned\r\n         * after awaiting them, we know that the replication\r\n         * is in idle state at this point in time.\r\n         */\r\n        if (\r\n            down === state.streamQueue.down &&\r\n            up === state.streamQueue.up\r\n        ) {\r\n            return;\r\n        }\r\n    }\r\n}\r\n\r\n\r\nexport function rxStorageInstanceToReplicationHandler<RxDocType, MasterCheckpointType>(\r\n    instance: RxStorageInstance<RxDocType, any, any, MasterCheckpointType>,\r\n    conflictHandler: RxConflictHandler<RxDocType>,\r\n    databaseInstanceToken: string,\r\n    /**\r\n     * If set to true,\r\n     * the _meta.lwt from the pushed documents is kept.\r\n     * (Used in the migration to ensure checkpoints are still valid)\r\n     */\r\n    keepMeta: boolean = false\r\n): RxReplicationHandler<RxDocType, MasterCheckpointType> {\r\n    instance = getUnderlyingPersistentStorage(instance);\r\n\r\n    const hasAttachments = !!instance.schema.attachments;\r\n    const primaryPath = getPrimaryFieldOfPrimaryKey(instance.schema.primaryKey);\r\n    const replicationHandler: RxReplicationHandler<RxDocType, MasterCheckpointType> = {\r\n        masterChangeStream$: instance.changeStream().pipe(\r\n            mergeMap(async (eventBulk: EventBulk<RxStorageChangeEvent<RxDocType>, MasterCheckpointType>) => {\r\n                const ret: DocumentsWithCheckpoint<RxDocType, MasterCheckpointType> = {\r\n                    checkpoint: eventBulk.checkpoint,\r\n                    documents: await Promise.all(\r\n                        eventBulk.events.map(async (event: RxStorageChangeEvent<RxDocType>) => {\r\n                            let docData = writeDocToDocState(event.documentData, hasAttachments, keepMeta);\r\n                            if (hasAttachments) {\r\n                                docData = await fillWriteDataForAttachmentsChange(\r\n                                    primaryPath,\r\n                                    instance,\r\n                                    clone(docData),\r\n                                    /**\r\n                                     * Notice that the master never knows\r\n                                     * the client state of the document.\r\n                                     * Therefore we always send all attachments data.\r\n                                     */\r\n                                    undefined\r\n                                );\r\n                            }\r\n                            return docData;\r\n                        })\r\n                    )\r\n                };\r\n                return ret;\r\n            })\r\n        ),\r\n        masterChangesSince(\r\n            checkpoint,\r\n            batchSize\r\n        ) {\r\n            return getChangedDocumentsSince(\r\n                instance,\r\n                batchSize,\r\n                checkpoint\r\n            ).then(async (result) => {\r\n                return {\r\n                    checkpoint: result.documents.length > 0 ? result.checkpoint : checkpoint,\r\n                    documents: await Promise.all(\r\n                        result.documents.map(async (plainDocumentData) => {\r\n                            let docData = writeDocToDocState(plainDocumentData, hasAttachments, keepMeta);\r\n                            if (hasAttachments) {\r\n                                docData = await fillWriteDataForAttachmentsChange(\r\n                                    primaryPath,\r\n                                    instance,\r\n                                    clone(docData),\r\n                                    /**\r\n                                     * Notice that the master never knows\r\n                                     * the client state of the document.\r\n                                     * Therefore we always send all attachments data.\r\n                                     */\r\n                                    undefined\r\n                                );\r\n                            }\r\n                            return docData;\r\n                        })\r\n                    )\r\n                };\r\n            });\r\n        },\r\n        async masterWrite(\r\n            rows\r\n        ) {\r\n            const rowById: ById<RxReplicationWriteToMasterRow<RxDocType>> = {};\r\n            rows.forEach(row => {\r\n                const docId: string = (row.newDocumentState as any)[primaryPath];\r\n                rowById[docId] = row;\r\n            });\r\n            const ids = Object.keys(rowById);\r\n\r\n            const masterDocsStateList = await instance.findDocumentsById(\r\n                ids,\r\n                true\r\n            );\r\n            const masterDocsState = new Map<string, RxDocumentData<RxDocType>>();\r\n            masterDocsStateList.forEach(doc => masterDocsState.set((doc as any)[primaryPath], doc));\r\n            const conflicts: WithDeleted<RxDocType>[] = [];\r\n            const writeRows: BulkWriteRow<RxDocType>[] = [];\r\n            await Promise.all(\r\n                Object.entries(rowById)\r\n                    .map(([id, row]) => {\r\n                        const masterState = masterDocsState.get(id);\r\n                        if (!masterState) {\r\n                            writeRows.push({\r\n                                document: docStateToWriteDoc(databaseInstanceToken, hasAttachments, keepMeta, row.newDocumentState)\r\n                            });\r\n                        } else if (\r\n                            masterState &&\r\n                            !row.assumedMasterState\r\n                        ) {\r\n                            conflicts.push(writeDocToDocState(masterState, hasAttachments, keepMeta));\r\n                        } else if (\r\n                            conflictHandler.isEqual(\r\n                                writeDocToDocState(masterState, hasAttachments, keepMeta),\r\n                                ensureNotFalsy(row.assumedMasterState),\r\n                                'rxStorageInstanceToReplicationHandler-masterWrite'\r\n                            ) === true\r\n                        ) {\r\n                            writeRows.push({\r\n                                previous: masterState,\r\n                                document: docStateToWriteDoc(databaseInstanceToken, hasAttachments, keepMeta, row.newDocumentState, masterState)\r\n                            });\r\n                        } else {\r\n                            conflicts.push(writeDocToDocState(masterState, hasAttachments, keepMeta));\r\n                        }\r\n                    })\r\n            );\r\n\r\n            if (writeRows.length > 0) {\r\n                const result = await instance.bulkWrite(\r\n                    writeRows,\r\n                    'replication-master-write'\r\n                );\r\n\r\n                result.error.forEach(err => {\r\n                    if (err.status !== 409) {\r\n                        throw newRxError('SNH', {\r\n                            name: 'non conflict error',\r\n                            error: err as any\r\n                        });\r\n                    } else {\r\n                        conflicts.push(\r\n                            writeDocToDocState(ensureNotFalsy(err.documentInDb), hasAttachments, keepMeta)\r\n                        );\r\n                    }\r\n                });\r\n            }\r\n            return conflicts;\r\n        }\r\n    };\r\n\r\n    return replicationHandler;\r\n}\r\n\r\n\r\nexport async function cancelRxStorageReplication(\r\n    replicationState: RxStorageInstanceReplicationState<any>\r\n) {\r\n    OPEN_REPLICATION_STATES.delete(replicationState);\r\n\r\n    replicationState.events.canceled.next(true);\r\n    replicationState.events.active.up.complete();\r\n    replicationState.events.active.down.complete();\r\n    replicationState.events.processed.up.complete();\r\n    replicationState.events.processed.down.complete();\r\n    replicationState.events.resolvedConflicts.complete();\r\n    replicationState.events.canceled.complete();\r\n    await replicationState.checkpointQueue;\r\n}\r\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;;AAGA,SACIA,eAAe,EACfC,aAAa,EACbC,MAAM,EACNC,cAAc,EACdC,QAAQ,EACRC,OAAO,QACJ,MAAM;AACb,SACIC,2BAA2B,QACxB,wBAAwB;AAgB/B,SACIC,KAAK,EACLC,cAAc,EACdC,SAAS,EACTC,oBAAoB,QACjB,2BAA2B;AAClC,SACIC,gBAAgB,QACb,iBAAiB;AACxB,SAASC,0BAA0B,QAAQ,iBAAiB;AAC5D,SACIC,kBAAkB,EAClBC,8BAA8B,EAC9BC,kBAAkB,QACf,aAAa;AACpB,SAASC,wBAAwB,QAAQ,eAAe;AACxD,SAASC,iCAAiC,QAAQ,iCAAiC;AACnF,SAASC,wBAAwB,QAAQ,yBAAyB;AAClE,SAASC,UAAU,QAAQ,gBAAgB;AAG3C,cAAc,iBAAiB;AAC/B,cAAc,iBAAiB;AAC/B,cAAc,eAAe;AAC7B,cAAc,oBAAoB;AAClC,cAAc,gBAAgB;AAC9B,cAAc,aAAa;AAC3B,cAAc,+BAA+B;;AAG7C;AACA;AACA;AACA;AACA,OAAO,IAAMC,uBAAuB,GAAG,IAAIC,GAAG,CAAyC,CAAC;AAExF,OAAO,SAASC,0BAA0BA,CACtCC,KAAmD,EACP;EAC5CA,KAAK,GAAGd,SAAS,CAACc,KAAK,CAAC;EACxBA,KAAK,CAACC,YAAY,GAAGV,8BAA8B,CAACS,KAAK,CAACC,YAAY,CAAC;EACvED,KAAK,CAACE,YAAY,GAAGX,8BAA8B,CAACS,KAAK,CAACE,YAAY,CAAC;EACvE,IAAMC,oBAAoB,GAAGf,gBAAgB,CAACY,KAAK,CAAC;EACpD,IAAMI,KAAmD,GAAG;IACxDC,WAAW,EAAEtB,2BAA2B,CAACiB,KAAK,CAACC,YAAY,CAACK,MAAM,CAACC,UAAU,CAAC;IAC9EC,cAAc,EAAE,CAAC,CAACR,KAAK,CAACC,YAAY,CAACK,MAAM,CAACG,WAAW;IACvDT,KAAK;IACLU,mBAAmB,EAAEV,KAAK,CAACU,mBAAmB;IAC9CC,aAAa,EAAER,oBAAoB;IACnCS,uBAAuB,EAAET,oBAAoB,CAACU,IAAI,CAACF,aAAa,IAAI,yBAAyB,GAAGA,aAAa,CAAC;IAC9GG,MAAM,EAAE;MACJC,QAAQ,EAAE,IAAItC,eAAe,CAAU,KAAK,CAAC;MAC7CuC,MAAM,EAAE,IAAIvC,eAAe,CAAU,KAAK,CAAC;MAC3CwC,MAAM,EAAE;QACJC,IAAI,EAAE,IAAIzC,eAAe,CAAU,IAAI,CAAC;QACxC0C,EAAE,EAAE,IAAI1C,eAAe,CAAU,IAAI;MACzC,CAAC;MACD2C,SAAS,EAAE;QACPF,IAAI,EAAE,IAAIpC,OAAO,CAAC,CAAC;QACnBqC,EAAE,EAAE,IAAIrC,OAAO,CAAC;MACpB,CAAC;MACDuC,iBAAiB,EAAE,IAAIvC,OAAO,CAAC,CAAC;MAChCwC,KAAK,EAAE,IAAIxC,OAAO,CAAC;IACvB,CAAC;IACDyC,KAAK,EAAE;MACHL,IAAI,EAAE;QACFM,UAAU,EAAE,CAAC;QACbC,wBAAwB,EAAE,CAAC;QAC3BC,oBAAoB,EAAE,CAAC;QACvBC,sBAAsB,EAAE,CAAC;QACzBC,iBAAiB,EAAE;MACvB,CAAC;MACDT,EAAE,EAAE;QACAU,oBAAoB,EAAE,CAAC;QACvBC,eAAe,EAAE,CAAC;QAClBC,6BAA6B,EAAE,CAAC;QAChCC,2BAA2B,EAAE,CAAC;QAC9BC,YAAY,EAAE,CAAC;QACfC,mBAAmB,EAAE;MACzB;IACJ,CAAC;IACDC,aAAa,EAAE;MACXjB,IAAI,EAAE,IAAIzC,eAAe,CAAU,KAAK,CAAC;MACzC0C,EAAE,EAAE,IAAI1C,eAAe,CAAU,KAAK;IAC1C,CAAC;IACD2D,WAAW,EAAE;MACTlB,IAAI,EAAE/B,oBAAoB;MAC1BgC,EAAE,EAAEhC;IACR,CAAC;IACDkD,eAAe,EAAElD,oBAAoB;IACrCmD,iBAAiB,EAAE,CAAC;EACxB,CAAC;EACDzC,uBAAuB,CAAC0C,GAAG,CAACnC,KAAK,CAAC;EAElCf,0BAA0B,CAACe,KAAK,CAAC;EACjCX,wBAAwB,CAACW,KAAK,CAAC;EAC/B,OAAOA,KAAK;AAChB;AAEA,OAAO,SAASoC,oCAAoCA,CAChDpC,KAA6C,EAChC;EACb,OAAOxB,cAAc,CACjBF,aAAa,CAAC,CACV0B,KAAK,CAAC+B,aAAa,CAACjB,IAAI,CAACuB,IAAI,CACzB9D,MAAM,CAAE+D,CAAU,IAAK,CAAC,CAACA,CAAC,CAC9B,CAAC,EACDtC,KAAK,CAAC+B,aAAa,CAAChB,EAAE,CAACsB,IAAI,CACvB9D,MAAM,CAAE+D,CAAU,IAAK,CAAC,CAACA,CAAC,CAC9B,CAAC,CACJ,CACL,CAAC,CAAC7B,IAAI,CAAC,MAAM,CAAE,CAAC,CAAC;AACrB;AAEA,OAAO,SAAS8B,+BAA+BA,CAC3CC,gBAAwD,EAC1D;EACE,OAAOC,OAAO,CAACC,GAAG,CAAC,CACfF,gBAAgB,CAACR,WAAW,CAACjB,EAAE,EAC/ByB,gBAAgB,CAACR,WAAW,CAAClB,IAAI,EACjC0B,gBAAgB,CAACP,eAAe,CACnC,CAAC;AACN;AAGA,OAAO,eAAeU,6BAA6BA,CAC/C3C,KAA6C,EAC/C;EACE,MAAMoC,oCAAoC,CAACpC,KAAK,CAAC;EACjD,OAAO,IAAI,EAAE;IACT,IAAM;MAAEc,IAAI;MAAEC;IAAG,CAAC,GAAGf,KAAK,CAACgC,WAAW;IACtC,MAAMS,OAAO,CAACC,GAAG,CAAC,CACd3B,EAAE,EACFD,IAAI,CACP,CAAC;IACF;AACR;AACA;AACA;AACA;IACQ,IACIA,IAAI,KAAKd,KAAK,CAACgC,WAAW,CAAClB,IAAI,IAC/BC,EAAE,KAAKf,KAAK,CAACgC,WAAW,CAACjB,EAAE,EAC7B;MACE;IACJ;EACJ;AACJ;AAGA,OAAO,SAAS6B,qCAAqCA,CACjDC,QAAsE,EACtEC,eAA6C,EAC7CC,qBAA6B;AAC7B;AACJ;AACA;AACA;AACA;AACIC,QAAiB,GAAG,KAAK,EAC4B;EACrDH,QAAQ,GAAG1D,8BAA8B,CAAC0D,QAAQ,CAAC;EAEnD,IAAMzC,cAAc,GAAG,CAAC,CAACyC,QAAQ,CAAC3C,MAAM,CAACG,WAAW;EACpD,IAAMJ,WAAW,GAAGtB,2BAA2B,CAACkE,QAAQ,CAAC3C,MAAM,CAACC,UAAU,CAAC;EAC3E,IAAM8C,kBAAyE,GAAG;IAC9EC,mBAAmB,EAAEL,QAAQ,CAACM,YAAY,CAAC,CAAC,CAACd,IAAI,CAC7C5D,QAAQ,CAAC,MAAO2E,SAA2E,IAAK;MAC5F,IAAMC,GAA6D,GAAG;QAClEC,UAAU,EAAEF,SAAS,CAACE,UAAU;QAChCC,SAAS,EAAE,MAAMd,OAAO,CAACC,GAAG,CACxBU,SAAS,CAAC1C,MAAM,CAAC8C,GAAG,CAAC,MAAOC,KAAsC,IAAK;UACnE,IAAIC,OAAO,GAAGtE,kBAAkB,CAACqE,KAAK,CAACE,YAAY,EAAEvD,cAAc,EAAE4C,QAAQ,CAAC;UAC9E,IAAI5C,cAAc,EAAE;YAChBsD,OAAO,GAAG,MAAMpE,iCAAiC,CAC7CW,WAAW,EACX4C,QAAQ,EACRjE,KAAK,CAAC8E,OAAO,CAAC;YACd;AACpC;AACA;AACA;AACA;YACoCE,SACJ,CAAC;UACL;UACA,OAAOF,OAAO;QAClB,CAAC,CACL;MACJ,CAAC;MACD,OAAOL,GAAG;IACd,CAAC,CACL,CAAC;IACDQ,kBAAkBA,CACdP,UAAU,EACVQ,SAAS,EACX;MACE,OAAOvE,wBAAwB,CAC3BsD,QAAQ,EACRiB,SAAS,EACTR,UACJ,CAAC,CAAC7C,IAAI,CAAC,MAAOsD,MAAM,IAAK;QACrB,OAAO;UACHT,UAAU,EAAES,MAAM,CAACR,SAAS,CAACS,MAAM,GAAG,CAAC,GAAGD,MAAM,CAACT,UAAU,GAAGA,UAAU;UACxEC,SAAS,EAAE,MAAMd,OAAO,CAACC,GAAG,CACxBqB,MAAM,CAACR,SAAS,CAACC,GAAG,CAAC,MAAOS,iBAAiB,IAAK;YAC9C,IAAIP,OAAO,GAAGtE,kBAAkB,CAAC6E,iBAAiB,EAAE7D,cAAc,EAAE4C,QAAQ,CAAC;YAC7E,IAAI5C,cAAc,EAAE;cAChBsD,OAAO,GAAG,MAAMpE,iCAAiC,CAC7CW,WAAW,EACX4C,QAAQ,EACRjE,KAAK,CAAC8E,OAAO,CAAC;cACd;AACpC;AACA;AACA;AACA;cACoCE,SACJ,CAAC;YACL;YACA,OAAOF,OAAO;UAClB,CAAC,CACL;QACJ,CAAC;MACL,CAAC,CAAC;IACN,CAAC;IACD,MAAMQ,WAAWA,CACbC,IAAI,EACN;MACE,IAAMC,OAAuD,GAAG,CAAC,CAAC;MAClED,IAAI,CAACE,OAAO,CAACC,GAAG,IAAI;QAChB,IAAMC,KAAa,GAAID,GAAG,CAACE,gBAAgB,CAASvE,WAAW,CAAC;QAChEmE,OAAO,CAACG,KAAK,CAAC,GAAGD,GAAG;MACxB,CAAC,CAAC;MACF,IAAMG,GAAG,GAAGC,MAAM,CAACC,IAAI,CAACP,OAAO,CAAC;MAEhC,IAAMQ,mBAAmB,GAAG,MAAM/B,QAAQ,CAACgC,iBAAiB,CACxDJ,GAAG,EACH,IACJ,CAAC;MACD,IAAMK,eAAe,GAAG,IAAIC,GAAG,CAAoC,CAAC;MACpEH,mBAAmB,CAACP,OAAO,CAACW,GAAG,IAAIF,eAAe,CAACG,GAAG,CAAED,GAAG,CAAS/E,WAAW,CAAC,EAAE+E,GAAG,CAAC,CAAC;MACvF,IAAME,SAAmC,GAAG,EAAE;MAC9C,IAAMC,SAAoC,GAAG,EAAE;MAC/C,MAAM1C,OAAO,CAACC,GAAG,CACbgC,MAAM,CAACU,OAAO,CAAChB,OAAO,CAAC,CAClBZ,GAAG,CAAC,CAAC,CAAC6B,EAAE,EAAEf,GAAG,CAAC,KAAK;QAChB,IAAMgB,WAAW,GAAGR,eAAe,CAACS,GAAG,CAACF,EAAE,CAAC;QAC3C,IAAI,CAACC,WAAW,EAAE;UACdH,SAAS,CAACK,IAAI,CAAC;YACXC,QAAQ,EAAEvG,kBAAkB,CAAC6D,qBAAqB,EAAE3C,cAAc,EAAE4C,QAAQ,EAAEsB,GAAG,CAACE,gBAAgB;UACtG,CAAC,CAAC;QACN,CAAC,MAAM,IACHc,WAAW,IACX,CAAChB,GAAG,CAACoB,kBAAkB,EACzB;UACER,SAAS,CAACM,IAAI,CAACpG,kBAAkB,CAACkG,WAAW,EAAElF,cAAc,EAAE4C,QAAQ,CAAC,CAAC;QAC7E,CAAC,MAAM,IACHF,eAAe,CAAC6C,OAAO,CACnBvG,kBAAkB,CAACkG,WAAW,EAAElF,cAAc,EAAE4C,QAAQ,CAAC,EACzDnE,cAAc,CAACyF,GAAG,CAACoB,kBAAkB,CAAC,EACtC,mDACJ,CAAC,KAAK,IAAI,EACZ;UACEP,SAAS,CAACK,IAAI,CAAC;YACXI,QAAQ,EAAEN,WAAW;YACrBG,QAAQ,EAAEvG,kBAAkB,CAAC6D,qBAAqB,EAAE3C,cAAc,EAAE4C,QAAQ,EAAEsB,GAAG,CAACE,gBAAgB,EAAEc,WAAW;UACnH,CAAC,CAAC;QACN,CAAC,MAAM;UACHJ,SAAS,CAACM,IAAI,CAACpG,kBAAkB,CAACkG,WAAW,EAAElF,cAAc,EAAE4C,QAAQ,CAAC,CAAC;QAC7E;MACJ,CAAC,CACT,CAAC;MAED,IAAImC,SAAS,CAACnB,MAAM,GAAG,CAAC,EAAE;QACtB,IAAMD,MAAM,GAAG,MAAMlB,QAAQ,CAACgD,SAAS,CACnCV,SAAS,EACT,0BACJ,CAAC;QAEDpB,MAAM,CAAC7C,KAAK,CAACmD,OAAO,CAACyB,GAAG,IAAI;UACxB,IAAIA,GAAG,CAACC,MAAM,KAAK,GAAG,EAAE;YACpB,MAAMvG,UAAU,CAAC,KAAK,EAAE;cACpBwG,IAAI,EAAE,oBAAoB;cAC1B9E,KAAK,EAAE4E;YACX,CAAC,CAAC;UACN,CAAC,MAAM;YACHZ,SAAS,CAACM,IAAI,CACVpG,kBAAkB,CAACP,cAAc,CAACiH,GAAG,CAACG,YAAY,CAAC,EAAE7F,cAAc,EAAE4C,QAAQ,CACjF,CAAC;UACL;QACJ,CAAC,CAAC;MACN;MACA,OAAOkC,SAAS;IACpB;EACJ,CAAC;EAED,OAAOjC,kBAAkB;AAC7B;AAGA,OAAO,eAAeiD,0BAA0BA,CAC5C1D,gBAAwD,EAC1D;EACE/C,uBAAuB,CAAC0G,MAAM,CAAC3D,gBAAgB,CAAC;EAEhDA,gBAAgB,CAAC9B,MAAM,CAACC,QAAQ,CAACyF,IAAI,CAAC,IAAI,CAAC;EAC3C5D,gBAAgB,CAAC9B,MAAM,CAACG,MAAM,CAACE,EAAE,CAACsF,QAAQ,CAAC,CAAC;EAC5C7D,gBAAgB,CAAC9B,MAAM,CAACG,MAAM,CAACC,IAAI,CAACuF,QAAQ,CAAC,CAAC;EAC9C7D,gBAAgB,CAAC9B,MAAM,CAACM,SAAS,CAACD,EAAE,CAACsF,QAAQ,CAAC,CAAC;EAC/C7D,gBAAgB,CAAC9B,MAAM,CAACM,SAAS,CAACF,IAAI,CAACuF,QAAQ,CAAC,CAAC;EACjD7D,gBAAgB,CAAC9B,MAAM,CAACO,iBAAiB,CAACoF,QAAQ,CAAC,CAAC;EACpD7D,gBAAgB,CAAC9B,MAAM,CAACC,QAAQ,CAAC0F,QAAQ,CAAC,CAAC;EAC3C,MAAM7D,gBAAgB,CAACP,eAAe;AAC1C","ignoreList":[]}

package/dist/esm/replication-protocol/meta-instance.js

@@ -0,0 +1,121 @@
+import { fillWithDefaultSettings, getComposedPrimaryKeyOfDocumentData, getLengthOfPrimaryKey } from "../rx-schema-helper.js";
+import { flatCloneDocWithMeta } from "../rx-storage-helper.js";
+import { getDefaultRevision, createRevision, now } from "../plugins/utils/index.js";
+export var META_INSTANCE_SCHEMA_TITLE = 'RxReplicationProtocolMetaData';
+export function getRxReplicationMetaInstanceSchema(replicatedDocumentsSchema, encrypted) {
+  var parentPrimaryKeyLength = getLengthOfPrimaryKey(replicatedDocumentsSchema);
+  var minItemIdLength = 4; // 'DOWN' must fit into this
+  var minIdLength = minItemIdLength + 2; // 'DOWN|1' must fit into this
+  // add +1 for the '|' and +1 for the 'isCheckpoint' flag
+  var idLength = parentPrimaryKeyLength + 2;
+  if (idLength < minIdLength) {
+    idLength = minIdLength;
+  }
+  var baseSchema = {
+    title: META_INSTANCE_SCHEMA_TITLE,
+    primaryKey: {
+      key: 'id',
+      fields: ['itemId', 'isCheckpoint'],
+      separator: '|'
+    },
+    type: 'object',
+    version: replicatedDocumentsSchema.version,
+    additionalProperties: false,
+    properties: {
+      id: {
+        type: 'string',
+        minLength: 1,
+        maxLength: idLength
+      },
+      isCheckpoint: {
+        type: 'string',
+        enum: ['0', '1'],
+        minLength: 1,
+        maxLength: 1
+      },
+      itemId: {
+        type: 'string',
+        /**
+         * ensure that all values of RxStorageReplicationDirection ('DOWN' has 4 chars) fit into it
+         * because checkpoints use the itemId field for that.
+         */
+        maxLength: parentPrimaryKeyLength > minItemIdLength ? parentPrimaryKeyLength : minItemIdLength
+      },
+      checkpointData: {
+        type: 'object',
+        additionalProperties: true
+      },
+      docData: {
+        type: 'object',
+        properties: replicatedDocumentsSchema.properties
+      },
+      isResolvedConflict: {
+        type: 'string'
+      }
+    },
+    keyCompression: replicatedDocumentsSchema.keyCompression,
+    required: ['id', 'isCheckpoint', 'itemId']
+  };
+  if (encrypted) {
+    baseSchema.encrypted = ['docData'];
+  }
+  var metaInstanceSchema = fillWithDefaultSettings(baseSchema);
+  return metaInstanceSchema;
+}
+
+/**
+ * Returns the document states of what the fork instance
+ * assumes to be the latest state on the master instance.
+ */
+export function getAssumedMasterState(state, docIds) {
+  return state.input.metaInstance.findDocumentsById(docIds.map(docId => {
+    var useId = getComposedPrimaryKeyOfDocumentData(state.input.metaInstance.schema, {
+      itemId: docId,
+      isCheckpoint: '0'
+    });
+    return useId;
+  }), true).then(metaDocs => {
+    var ret = {};
+    Object.values(metaDocs).forEach(metaDoc => {
+      ret[metaDoc.itemId] = {
+        docData: metaDoc.docData,
+        metaDocument: metaDoc
+      };
+    });
+    return ret;
+  });
+}
+export async function getMetaWriteRow(state, newMasterDocState, previous, isResolvedConflict) {
+  var docId = newMasterDocState[state.primaryPath];
+  var newMeta = previous ? flatCloneDocWithMeta(previous) : {
+    id: '',
+    isCheckpoint: '0',
+    itemId: docId,
+    docData: newMasterDocState,
+    _attachments: {},
+    _deleted: false,
+    _rev: getDefaultRevision(),
+    _meta: {
+      lwt: 0
+    }
+  };
+  newMeta.docData = newMasterDocState;
+
+  /**
+   * Sending isResolvedConflict with the value undefined
+   * will throw a schema validation error because it must be either
+   * not set or have a string.
+   */
+  if (isResolvedConflict) {
+    newMeta.isResolvedConflict = isResolvedConflict;
+  }
+  newMeta._meta.lwt = now();
+  newMeta.id = getComposedPrimaryKeyOfDocumentData(state.input.metaInstance.schema, newMeta);
+  newMeta._rev = createRevision(await state.checkpointKey, previous);
+  var ret = {
+    previous,
+    document: newMeta
+  };
+  return ret;
+}
+//# sourceMappingURL=meta-instance.js.map

package/dist/esm/replication-protocol/meta-instance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta-instance.js","names":["fillWithDefaultSettings","getComposedPrimaryKeyOfDocumentData","getLengthOfPrimaryKey","flatCloneDocWithMeta","getDefaultRevision","createRevision","now","META_INSTANCE_SCHEMA_TITLE","getRxReplicationMetaInstanceSchema","replicatedDocumentsSchema","encrypted","parentPrimaryKeyLength","minItemIdLength","minIdLength","idLength","baseSchema","title","primaryKey","key","fields","separator","type","version","additionalProperties","properties","id","minLength","maxLength","isCheckpoint","enum","itemId","checkpointData","docData","isResolvedConflict","keyCompression","required","metaInstanceSchema","getAssumedMasterState","state","docIds","input","metaInstance","findDocumentsById","map","docId","useId","schema","then","metaDocs","ret","Object","values","forEach","metaDoc","metaDocument","getMetaWriteRow","newMasterDocState","previous","primaryPath","newMeta","_attachments","_deleted","_rev","_meta","lwt","checkpointKey","document"],"sources":["../../../src/replication-protocol/meta-instance.ts"],"sourcesContent":["import {\r\n    fillWithDefaultSettings,\r\n    getComposedPrimaryKeyOfDocumentData,\r\n    getLengthOfPrimaryKey\r\n} from '../rx-schema-helper.ts';\r\nimport { flatCloneDocWithMeta } from '../rx-storage-helper.ts';\r\nimport type {\r\n    BulkWriteRow,\r\n    ById,\r\n    RxDocumentData,\r\n    RxJsonSchema,\r\n    RxStorageInstanceReplicationState,\r\n    RxStorageReplicationMeta,\r\n    WithDeleted\r\n} from '../types/index.d.ts';\r\nimport {\r\n    getDefaultRevision,\r\n    createRevision,\r\n    now\r\n} from '../plugins/utils/index.ts';\r\n\r\n\r\nexport const META_INSTANCE_SCHEMA_TITLE = 'RxReplicationProtocolMetaData';\r\n\r\nexport function getRxReplicationMetaInstanceSchema<RxDocType, CheckpointType>(\r\n    replicatedDocumentsSchema: RxJsonSchema<RxDocumentData<RxDocType>>,\r\n    encrypted: boolean\r\n): RxJsonSchema<RxDocumentData<RxStorageReplicationMeta<RxDocType, CheckpointType>>> {\r\n    const parentPrimaryKeyLength = getLengthOfPrimaryKey(replicatedDocumentsSchema);\r\n\r\n    const minItemIdLength = 4; // 'DOWN' must fit into this\r\n    const minIdLength = minItemIdLength + 2; // 'DOWN|1' must fit into this\r\n    // add +1 for the '|' and +1 for the 'isCheckpoint' flag\r\n    let idLength = parentPrimaryKeyLength + 2;\r\n    if (idLength < minIdLength) {\r\n        idLength = minIdLength;\r\n    }\r\n\r\n    const baseSchema: RxJsonSchema<RxStorageReplicationMeta<RxDocType, CheckpointType>> = {\r\n        title: META_INSTANCE_SCHEMA_TITLE,\r\n        primaryKey: {\r\n            key: 'id',\r\n            fields: [\r\n                'itemId',\r\n                'isCheckpoint'\r\n            ],\r\n            separator: '|'\r\n        },\r\n        type: 'object',\r\n        version: replicatedDocumentsSchema.version,\r\n        additionalProperties: false,\r\n        properties: {\r\n            id: {\r\n                type: 'string',\r\n                minLength: 1,\r\n                maxLength: idLength\r\n            },\r\n            isCheckpoint: {\r\n                type: 'string',\r\n                enum: [\r\n                    '0',\r\n                    '1'\r\n                ],\r\n                minLength: 1,\r\n                maxLength: 1\r\n            },\r\n            itemId: {\r\n                type: 'string',\r\n                /**\r\n                 * ensure that all values of RxStorageReplicationDirection ('DOWN' has 4 chars) fit into it\r\n                 * because checkpoints use the itemId field for that.\r\n                 */\r\n                maxLength: parentPrimaryKeyLength > minItemIdLength ? parentPrimaryKeyLength : minItemIdLength\r\n            },\r\n            checkpointData: {\r\n                type: 'object',\r\n                additionalProperties: true\r\n            },\r\n            docData: {\r\n                type: 'object',\r\n                properties: replicatedDocumentsSchema.properties\r\n            },\r\n            isResolvedConflict: {\r\n                type: 'string'\r\n            }\r\n        },\r\n        keyCompression: replicatedDocumentsSchema.keyCompression,\r\n        required: [\r\n            'id',\r\n            'isCheckpoint',\r\n            'itemId'\r\n        ]\r\n    };\r\n    if (encrypted) {\r\n        baseSchema.encrypted = ['docData'];\r\n    }\r\n    const metaInstanceSchema: RxJsonSchema<RxDocumentData<RxStorageReplicationMeta<RxDocType, CheckpointType>>> = fillWithDefaultSettings(baseSchema);\r\n    return metaInstanceSchema;\r\n}\r\n\r\n\r\n\r\n/**\r\n * Returns the document states of what the fork instance\r\n * assumes to be the latest state on the master instance.\r\n */\r\nexport function getAssumedMasterState<RxDocType>(\r\n    state: RxStorageInstanceReplicationState<RxDocType>,\r\n    docIds: string[]\r\n): Promise<ById<{\r\n    docData: WithDeleted<RxDocType>;\r\n    metaDocument: RxDocumentData<RxStorageReplicationMeta<RxDocType, any>>;\r\n}>> {\r\n    return state.input.metaInstance.findDocumentsById(\r\n        docIds.map(docId => {\r\n            const useId = getComposedPrimaryKeyOfDocumentData(\r\n                state.input.metaInstance.schema,\r\n                {\r\n                    itemId: docId,\r\n                    isCheckpoint: '0'\r\n                }\r\n            );\r\n            return useId;\r\n        }),\r\n        true\r\n    ).then(metaDocs => {\r\n        const ret: {\r\n            [docId: string]: {\r\n                docData: RxDocumentData<RxDocType>;\r\n                metaDocument: RxDocumentData<RxStorageReplicationMeta<RxDocType, any>>;\r\n            };\r\n        } = {};\r\n        Object\r\n            .values(metaDocs)\r\n            .forEach((metaDoc) => {\r\n                ret[metaDoc.itemId] = {\r\n                    docData: metaDoc.docData,\r\n                    metaDocument: metaDoc\r\n                };\r\n            });\r\n\r\n        return ret;\r\n    });\r\n}\r\n\r\n\r\nexport async function getMetaWriteRow<RxDocType>(\r\n    state: RxStorageInstanceReplicationState<RxDocType>,\r\n    newMasterDocState: WithDeleted<RxDocType>,\r\n    previous?: RxDocumentData<RxStorageReplicationMeta<RxDocType, any>>,\r\n    isResolvedConflict?: string\r\n): Promise<BulkWriteRow<RxStorageReplicationMeta<RxDocType, any>>> {\r\n    const docId: string = (newMasterDocState as any)[state.primaryPath];\r\n    const newMeta: RxDocumentData<RxStorageReplicationMeta<RxDocType, any>> = previous ? flatCloneDocWithMeta(\r\n        previous\r\n    ) : {\r\n        id: '',\r\n        isCheckpoint: '0',\r\n        itemId: docId,\r\n        docData: newMasterDocState,\r\n        _attachments: {},\r\n        _deleted: false,\r\n        _rev: getDefaultRevision(),\r\n        _meta: {\r\n            lwt: 0\r\n        }\r\n    };\r\n    newMeta.docData = newMasterDocState;\r\n\r\n    /**\r\n     * Sending isResolvedConflict with the value undefined\r\n     * will throw a schema validation error because it must be either\r\n     * not set or have a string.\r\n     */\r\n    if (isResolvedConflict) {\r\n        newMeta.isResolvedConflict = isResolvedConflict;\r\n    }\r\n\r\n    newMeta._meta.lwt = now();\r\n    newMeta.id = getComposedPrimaryKeyOfDocumentData(\r\n        state.input.metaInstance.schema,\r\n        newMeta\r\n    );\r\n    newMeta._rev = createRevision(\r\n        await state.checkpointKey,\r\n        previous\r\n    );\r\n\r\n    const ret = {\r\n        previous,\r\n        document: newMeta\r\n    };\r\n\r\n    return ret;\r\n}\r\n"],"mappings":"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","ignoreList":[]}