@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/cjs/plugins/replication-microsoft-onedrive/transaction.js

@@ -0,0 +1,138 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TRANSACTION_FILE_NAME = exports.TRANSACTION_BLOCKED_FLAG = void 0;
+exports.commitTransaction = commitTransaction;
+exports.isTransactionTimedOut = isTransactionTimedOut;
+exports.runInTransaction = runInTransaction;
+exports.startTransaction = startTransaction;
+exports.startTransactionTryOnce = startTransactionTryOnce;
+var _microsoftOnedriveHelper = require("./microsoft-onedrive-helper.js");
+var _rxError = require("../../rx-error.js");
+var _index = require("../utils/index.js");
+var _upstream = require("./upstream.js");
+var TRANSACTION_FILE_NAME = exports.TRANSACTION_FILE_NAME = 'transaction.json';
+var TRANSACTION_BLOCKED_FLAG = exports.TRANSACTION_BLOCKED_FLAG = {
+  retry: true
+};
+async function startTransactionTryOnce(oneDriveState, init) {
+  var txFileContent = await (0, _microsoftOnedriveHelper.readJsonFileContent)(oneDriveState, init.transactionFile.fileId);
+  var content = txFileContent.content;
+  if (!isEmpty(content)) {
+    // tx already existed -> retry
+    return TRANSACTION_BLOCKED_FLAG;
+  }
+  var newTxContent = {
+    createdAtClientTime: (0, _index.now)()
+  };
+  var writeResult = await (0, _microsoftOnedriveHelper.fillFileIfEtagMatches)(oneDriveState, init.transactionFile.fileId, txFileContent.etag, newTxContent);
+  if (writeResult.status !== 200 && writeResult.status !== 201) {
+    return TRANSACTION_BLOCKED_FLAG;
+  }
+  return {
+    etag: writeResult.etag
+  };
+}
+async function startTransaction(oneDriveState, init) {
+  var current = await startTransactionTryOnce(oneDriveState, init);
+  var attempts = 0;
+  while (current.retry) {
+    /**
+     * Wait a bit.
+     * Exponential backoff: 100, 200, 400, 800, ...
+     */
+
+    var waitTime = Math.min(100 * 1000, 100 * Math.pow(1.5, attempts));
+    await (0, _index.promiseWait)(waitTime);
+
+    /**
+     * Check for timeout
+     */
+    var timeoutState = await isTransactionTimedOut(oneDriveState, init);
+    if (timeoutState.expired) {
+      await (0, _microsoftOnedriveHelper.fillFileIfEtagMatches)(oneDriveState, init.transactionFile.fileId, timeoutState.etag, undefined);
+    }
+
+    /**
+     * Try to get the transaction again
+     */
+    current = await startTransactionTryOnce(oneDriveState, init);
+    attempts = attempts + 1;
+  }
+  return current;
+}
+async function isTransactionTimedOut(oneDriveState, init) {
+  var baseUrl = (0, _microsoftOnedriveHelper.getDriveBaseUrl)(oneDriveState);
+  var request = await fetch(baseUrl + "/items/" + init.transactionFile.fileId + "?$select=lastModifiedDateTime,eTag", {
+    headers: {
+      Authorization: 'Bearer ' + oneDriveState.authToken
+    }
+  });
+  var data = await request.json();
+  var dateHeader = request.headers.get('date');
+  var serverTime = Date.parse((0, _index.ensureNotFalsy)(dateHeader, 'header time'));
+  var transactionCreation = Date.parse((0, _index.ensureNotFalsy)(data.lastModifiedDateTime, 'tx time'));
+
+  /**
+   * By definition the HTTP Date header
+   * only has seconds precision so if
+   * the serverTime is "impossible", set it
+   * to the transaction creation time.
+   */
+  if (serverTime < transactionCreation) {
+    serverTime = transactionCreation;
+  }
+  var transactionAge = serverTime - transactionCreation;
+  var timeLeft = (oneDriveState.transactionTimeout || 10000) - transactionAge;
+  return {
+    timeLeft,
+    transactionAge,
+    expired: timeLeft <= 0,
+    etag: (0, _index.ensureNotFalsy)(data.eTag, 'etag')
+  };
+}
+async function commitTransaction(oneDriveState, init, transactionInput) {
+  if (transactionInput.retry) {
+    throw (0, _rxError.newRxError)('ODR11', {
+      args: {
+        transaction: transactionInput
+      }
+    });
+  }
+  var transaction = transactionInput;
+  var writeResult = await (0, _microsoftOnedriveHelper.fillFileIfEtagMatches)(oneDriveState, init.transactionFile.fileId, transaction.etag, undefined);
+  if (writeResult.status !== 200 && writeResult.status !== 201) {
+    throw (0, _rxError.newRxError)('ODR11', {
+      args: {
+        status: writeResult.status,
+        etag: writeResult.etag
+      }
+    });
+  }
+}
+function isEmpty(value) {
+  if (value === undefined || value === null) return true;
+  if (typeof value === "string") {
+    return value.length === 0;
+  }
+  if (typeof value === "object" && !Array.isArray(value)) {
+    if (value.type === 'Buffer' && Array.isArray(value.data) && value.data.length === 0) {
+      return true;
+    }
+    return Object.keys(value).length === 0;
+  }
+  return false;
+}
+async function runInTransaction(oneDriveState, init, primaryPath, fn, runAfter) {
+  var transaction = await startTransaction(oneDriveState, init);
+  await (0, _upstream.processWalFile)(oneDriveState, init, primaryPath);
+  var result = await fn();
+  await commitTransaction(oneDriveState, init, transaction);
+  if (runAfter) {
+    await runAfter();
+  }
+  return result;
+}
+//# sourceMappingURL=transaction.js.map

package/dist/cjs/plugins/replication-microsoft-onedrive/transaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.js","names":["_microsoftOnedriveHelper","require","_rxError","_index","_upstream","TRANSACTION_FILE_NAME","exports","TRANSACTION_BLOCKED_FLAG","retry","startTransactionTryOnce","oneDriveState","init","txFileContent","readJsonFileContent","transactionFile","fileId","content","isEmpty","newTxContent","createdAtClientTime","now","writeResult","fillFileIfEtagMatches","etag","status","startTransaction","current","attempts","waitTime","Math","min","pow","promiseWait","timeoutState","isTransactionTimedOut","expired","undefined","baseUrl","getDriveBaseUrl","request","fetch","headers","Authorization","authToken","data","json","dateHeader","get","serverTime","Date","parse","ensureNotFalsy","transactionCreation","lastModifiedDateTime","transactionAge","timeLeft","transactionTimeout","eTag","commitTransaction","transactionInput","newRxError","args","transaction","value","length","Array","isArray","type","Object","keys","runInTransaction","primaryPath","fn","runAfter","processWalFile","result"],"sources":["../../../../src/plugins/replication-microsoft-onedrive/transaction.ts"],"sourcesContent":["import type { OneDriveState } from './microsoft-onedrive-types.ts';\r\nimport {\r\n    fillFileIfEtagMatches,\r\n    readJsonFileContent,\r\n    getDriveBaseUrl\r\n} from './microsoft-onedrive-helper.ts';\r\nimport { newRxError } from '../../rx-error.ts';\r\nimport { DriveStructure } from './init.ts';\r\nimport { ensureNotFalsy, now, promiseWait } from '../utils/index.ts';\r\nimport { processWalFile } from './upstream.ts';\r\n\r\nexport type DriveTransaction = {\r\n    etag: string;\r\n};\r\nexport type TransactionFileContent = {\r\n    createdAtClientTime: number;\r\n};\r\n\r\nexport const TRANSACTION_FILE_NAME = 'transaction.json';\r\nexport const TRANSACTION_BLOCKED_FLAG = {\r\n    retry: true\r\n} as const;\r\n\r\nexport async function startTransactionTryOnce(\r\n    oneDriveState: OneDriveState,\r\n    init: DriveStructure,\r\n): Promise<typeof TRANSACTION_BLOCKED_FLAG | DriveTransaction> {\r\n    const txFileContent = await readJsonFileContent(\r\n        oneDriveState,\r\n        init.transactionFile.fileId\r\n    );\r\n\r\n    const content = txFileContent.content;\r\n\r\n    if (!isEmpty(content)) {\r\n        // tx already existed -> retry\r\n        return TRANSACTION_BLOCKED_FLAG;\r\n    }\r\n\r\n\r\n    const newTxContent: TransactionFileContent = {\r\n        createdAtClientTime: now()\r\n    };\r\n\r\n    const writeResult = await fillFileIfEtagMatches<TransactionFileContent>(\r\n        oneDriveState,\r\n        init.transactionFile.fileId,\r\n        txFileContent.etag,\r\n        newTxContent\r\n    );\r\n\r\n    if (writeResult.status !== 200 && writeResult.status !== 201) {\r\n        return TRANSACTION_BLOCKED_FLAG;\r\n    }\r\n\r\n    return {\r\n        etag: writeResult.etag\r\n    };\r\n}\r\n\r\nexport async function startTransaction(\r\n    oneDriveState: OneDriveState,\r\n    init: DriveStructure,\r\n): Promise<DriveTransaction> {\r\n    let current = await startTransactionTryOnce(\r\n        oneDriveState,\r\n        init\r\n    );\r\n\r\n    let attempts = 0;\r\n    while ((current as any).retry) {\r\n        /**\r\n         * Wait a bit.\r\n         * Exponential backoff: 100, 200, 400, 800, ...\r\n         */\r\n\r\n        const waitTime = Math.min(\r\n            100 * 1000,\r\n            100 * Math.pow(1.5, attempts)\r\n        );\r\n        await promiseWait(waitTime);\r\n\r\n        /**\r\n         * Check for timeout\r\n         */\r\n        const timeoutState = await isTransactionTimedOut(\r\n            oneDriveState,\r\n            init\r\n        );\r\n        if (timeoutState.expired) {\r\n            await fillFileIfEtagMatches<TransactionFileContent>(\r\n                oneDriveState,\r\n                init.transactionFile.fileId,\r\n                timeoutState.etag,\r\n                undefined\r\n            );\r\n        }\r\n\r\n        /**\r\n         * Try to get the transaction again\r\n         */\r\n        current = await startTransactionTryOnce(\r\n            oneDriveState,\r\n            init\r\n        );\r\n\r\n        attempts = attempts + 1;\r\n    }\r\n\r\n    return current as DriveTransaction;\r\n}\r\n\r\nexport async function isTransactionTimedOut(\r\n    oneDriveState: OneDriveState,\r\n    init: DriveStructure,\r\n) {\r\n    const baseUrl = getDriveBaseUrl(oneDriveState);\r\n    const request = await fetch(\r\n        `${baseUrl}/items/${init.transactionFile.fileId}?$select=lastModifiedDateTime,eTag`,\r\n        {\r\n            headers: {\r\n                Authorization: 'Bearer ' + oneDriveState.authToken\r\n            }\r\n        }\r\n    );\r\n    const data = await request.json();\r\n\r\n    const dateHeader = request.headers.get('date');\r\n    let serverTime = Date.parse(ensureNotFalsy(dateHeader, 'header time'));\r\n\r\n    const transactionCreation = Date.parse(ensureNotFalsy(data.lastModifiedDateTime, 'tx time'));\r\n\r\n    /**\r\n     * By definition the HTTP Date header\r\n     * only has seconds precision so if\r\n     * the serverTime is \"impossible\", set it\r\n     * to the transaction creation time.\r\n     */\r\n    if (serverTime < transactionCreation) {\r\n        serverTime = transactionCreation;\r\n    }\r\n\r\n    const transactionAge = serverTime - transactionCreation;\r\n    const timeLeft = (oneDriveState.transactionTimeout || 10000) - transactionAge;\r\n\r\n    return {\r\n        timeLeft,\r\n        transactionAge,\r\n        expired: timeLeft <= 0,\r\n        etag: ensureNotFalsy(data.eTag, 'etag')\r\n    }\r\n}\r\n\r\nexport async function commitTransaction(\r\n    oneDriveState: OneDriveState,\r\n    init: DriveStructure,\r\n    transactionInput: DriveTransaction | typeof TRANSACTION_BLOCKED_FLAG\r\n) {\r\n    if ((transactionInput as typeof TRANSACTION_BLOCKED_FLAG).retry) {\r\n        throw newRxError('ODR11', {\r\n            args: {\r\n                transaction: transactionInput\r\n            }\r\n        });\r\n    }\r\n\r\n    const transaction: DriveTransaction = transactionInput as any;\r\n    const writeResult = await fillFileIfEtagMatches<TransactionFileContent>(\r\n        oneDriveState,\r\n        init.transactionFile.fileId,\r\n        transaction.etag,\r\n        undefined\r\n    );\r\n    if (writeResult.status !== 200 && writeResult.status !== 201) {\r\n        throw newRxError('ODR11', {\r\n            args: {\r\n                status: writeResult.status,\r\n                etag: writeResult.etag\r\n            }\r\n        });\r\n    }\r\n}\r\n\r\nfunction isEmpty(value: any) {\r\n    if (value === undefined || value === null) return true;\r\n\r\n    if (typeof value === \"string\") {\r\n        return value.length === 0;\r\n    }\r\n\r\n    if (typeof value === \"object\" && !Array.isArray(value)) {\r\n        if (value.type === 'Buffer' && Array.isArray(value.data) && value.data.length === 0) {\r\n            return true;\r\n        }\r\n        return Object.keys(value).length === 0;\r\n    }\r\n    return false;\r\n}\r\n\r\n\r\nexport async function runInTransaction<T>(\r\n    oneDriveState: OneDriveState,\r\n    init: DriveStructure,\r\n    primaryPath: string,\r\n    fn: () => Promise<T>,\r\n    runAfter?: () => any\r\n): Promise<T> {\r\n    const transaction = await startTransaction(oneDriveState, init);\r\n    await processWalFile(\r\n        oneDriveState,\r\n        init,\r\n        primaryPath\r\n    );\r\n    const result = await fn();\r\n    await commitTransaction(oneDriveState, init, transaction);\r\n    if (runAfter) {\r\n        await runAfter();\r\n    }\r\n    return result;\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/cjs/plugins/replication-microsoft-onedrive/upstream.js

@@ -0,0 +1,190 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WAL_FILE_NAME = exports.DRIVE_MAX_BULK_SIZE = void 0;
+exports.fetchConflicts = fetchConflicts;
+exports.handleUpstreamBatch = handleUpstreamBatch;
+exports.processWalFile = processWalFile;
+exports.readWalContent = readWalContent;
+exports.writeToWal = writeToWal;
+var _rxError = require("../../rx-error.js");
+var _index = require("../utils/index.js");
+var _documentHandling = require("./document-handling.js");
+var _microsoftOnedriveHelper = require("./microsoft-onedrive-helper.js");
+var WAL_FILE_NAME = exports.WAL_FILE_NAME = 'rxdb-wal.json';
+
+// Batch insert limit in Graph api is often not fully restricted for files unless using batch endpoints, 
+// a reasonable size is 100-250 to avoid timeout.
+var DRIVE_MAX_BULK_SIZE = exports.DRIVE_MAX_BULK_SIZE = 250;
+async function fetchConflicts(oneDriveState, init, primaryPath, writeRows) {
+  if (writeRows.length > DRIVE_MAX_BULK_SIZE) {
+    throw (0, _rxError.newRxError)('ODR18', {
+      args: {
+        DRIVE_MAX_BULK_SIZE
+      }
+    });
+  }
+  var ids = writeRows.map(row => row.newDocumentState[primaryPath]);
+  var filesMeta = await (0, _documentHandling.getDocumentFiles)(oneDriveState, init, ids);
+  var fileIdByDocId = new Map();
+  var fileIds = filesMeta.files.map(f => {
+    var fileId = (0, _index.ensureNotFalsy)(f.id);
+    var docId = f.name.split('.')[0];
+    fileIdByDocId.set(docId, fileId);
+    return fileId;
+  });
+  var contentsByFileId = await (0, _documentHandling.fetchDocumentContents)(oneDriveState, fileIds);
+  var conflicts = [];
+  var nonConflicts = [];
+  writeRows.forEach(row => {
+    var docId = row.newDocumentState[primaryPath];
+    var fileContent;
+    var fileId = fileIdByDocId.get(docId);
+    if (fileId) {
+      fileContent = contentsByFileId.byId[fileId];
+    }
+    if (row.assumedMasterState) {
+      if (!(0, _index.deepEqual)(row.assumedMasterState, fileContent)) {
+        conflicts.push((0, _index.ensureNotFalsy)(fileContent));
+      } else {
+        nonConflicts.push(row);
+      }
+    } else if (fileContent) {
+      conflicts.push(fileContent);
+    } else {
+      nonConflicts.push(row);
+    }
+  });
+  if (nonConflicts.length + conflicts.length !== writeRows.length) {
+    throw (0, _rxError.newRxError)('SNH', {
+      pushRows: writeRows,
+      args: {
+        nonConflicts,
+        conflicts,
+        contentsByFileId: contentsByFileId.byId
+      }
+    });
+  }
+  return {
+    conflicts,
+    nonConflicts
+  };
+}
+async function writeToWal(oneDriveState, init, writeRows) {
+  var walFileId = init.walFile.fileId;
+  var baseUrl = (0, _microsoftOnedriveHelper.getDriveBaseUrl)(oneDriveState);
+  var metaUrl = baseUrl + "/items/" + encodeURIComponent(walFileId) + "?$select=id,size,eTag";
+  var metaRes = await fetch(metaUrl, {
+    method: "GET",
+    headers: {
+      Authorization: "Bearer " + oneDriveState.authToken
+    }
+  });
+  if (!metaRes.ok) {
+    throw await (0, _rxError.newRxFetchError)(metaRes);
+  }
+  var meta = await metaRes.json();
+  var sizeNum = meta.size || 0;
+  if (writeRows && sizeNum > 0) {
+    throw (0, _rxError.newRxError)("ODR19", {
+      args: {
+        sizeNum,
+        walFileId,
+        meta,
+        writeRows: writeRows?.length
+      }
+    });
+  }
+  var etag = (0, _index.ensureNotFalsy)(meta.eTag, 'etag missing');
+  var writeResult = await (0, _microsoftOnedriveHelper.fillFileIfEtagMatches)(oneDriveState, walFileId, etag, writeRows);
+  if (writeResult.status !== 200 && writeResult.status !== 201) {
+    throw (0, _rxError.newRxError)("ODR19", {
+      args: {
+        walFileId,
+        meta,
+        writeRows: writeRows?.length
+      }
+    });
+  }
+}
+async function readWalContent(oneDriveState, init) {
+  var walFileId = init.walFile.fileId;
+  var baseUrl = (0, _microsoftOnedriveHelper.getDriveBaseUrl)(oneDriveState);
+  var contentUrl = baseUrl + "/items/" + encodeURIComponent(walFileId) + "/content";
+  var res = await fetch(contentUrl, {
+    method: "GET",
+    headers: {
+      Authorization: "Bearer " + oneDriveState.authToken
+    }
+  });
+  if (!res.ok) {
+    throw await (0, _rxError.newRxFetchError)(res);
+  }
+  var etag = res.headers.get("etag") || res.headers.get("ETag");
+  if (!etag) {
+    var metaRes = await fetch(baseUrl + "/items/" + encodeURIComponent(walFileId) + "?$select=eTag", {
+      headers: {
+        Authorization: "Bearer " + oneDriveState.authToken
+      }
+    });
+    var meta = await metaRes.json();
+    etag = meta.eTag;
+  }
+  var text = await res.text();
+  if (!text || !text.trim()) {
+    return {
+      etag: (0, _index.ensureNotFalsy)(etag),
+      rows: undefined
+    };
+  }
+  return {
+    etag: (0, _index.ensureNotFalsy)(etag),
+    rows: JSON.parse(text)
+  };
+}
+
+/**
+ * Here we read the WAL file content
+ * and sort the content into the actual
+ * document files.
+ * Notice that when the JavaScript process
+ * exists at any point here, we need to have
+ * a recoverable state on the next run. So this
+ * must be idempotent.
+ */
+async function processWalFile(oneDriveState, init, primaryPath) {
+  var content = await readWalContent(oneDriveState, init);
+  if (!content.rows) {
+    return;
+  }
+  var docIds = content.rows.map(row => row.newDocumentState[primaryPath]);
+  var docFiles = await (0, _documentHandling.getDocumentFiles)(oneDriveState, init, docIds);
+  var fileIdByDocId = {};
+  docFiles.files.forEach(file => {
+    var docId = file.name.split('.')[0];
+    fileIdByDocId[docId] = file.id;
+  });
+  var toInsert = [];
+  var toUpdate = [];
+  content.rows.filter(row => {
+    var docId = row.newDocumentState[primaryPath];
+    var fileExists = fileIdByDocId[docId];
+    if (!fileExists) {
+      toInsert.push(row.newDocumentState);
+    } else {
+      toUpdate.push(row.newDocumentState);
+    }
+  });
+  await Promise.all([(0, _documentHandling.insertDocumentFiles)(oneDriveState, init, primaryPath, toInsert), (0, _documentHandling.updateDocumentFiles)(oneDriveState, primaryPath, toUpdate, fileIdByDocId)]);
+
+  // overwrite wal with emptyness
+  await writeToWal(oneDriveState, init, undefined);
+}
+async function handleUpstreamBatch(oneDriveState, init, primaryPath, writeRows) {
+  var conflictResult = await fetchConflicts(oneDriveState, init, primaryPath, writeRows);
+  await writeToWal(oneDriveState, init, conflictResult.nonConflicts);
+  return conflictResult.conflicts;
+}
+//# sourceMappingURL=upstream.js.map

package/dist/cjs/plugins/replication-microsoft-onedrive/upstream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"upstream.js","names":["_rxError","require","_index","_documentHandling","_microsoftOnedriveHelper","WAL_FILE_NAME","exports","DRIVE_MAX_BULK_SIZE","fetchConflicts","oneDriveState","init","primaryPath","writeRows","length","newRxError","args","ids","map","row","newDocumentState","filesMeta","getDocumentFiles","fileIdByDocId","Map","fileIds","files","f","fileId","ensureNotFalsy","id","docId","name","split","set","contentsByFileId","fetchDocumentContents","conflicts","nonConflicts","forEach","fileContent","get","byId","assumedMasterState","deepEqual","push","pushRows","writeToWal","walFileId","walFile","baseUrl","getDriveBaseUrl","metaUrl","encodeURIComponent","metaRes","fetch","method","headers","Authorization","authToken","ok","newRxFetchError","meta","json","sizeNum","size","etag","eTag","writeResult","fillFileIfEtagMatches","status","readWalContent","contentUrl","res","text","trim","rows","undefined","JSON","parse","processWalFile","content","docIds","docFiles","file","toInsert","toUpdate","filter","fileExists","Promise","all","insertDocumentFiles","updateDocumentFiles","handleUpstreamBatch","conflictResult"],"sources":["../../../../src/plugins/replication-microsoft-onedrive/upstream.ts"],"sourcesContent":["import { RxReplicationWriteToMasterRow, WithDeletedAndAttachments } from '../../index.ts';\r\nimport { newRxError, newRxFetchError } from '../../rx-error.ts';\r\nimport { deepEqual, ensureNotFalsy } from '../utils/index.ts';\r\nimport { fetchDocumentContents, getDocumentFiles, insertDocumentFiles, updateDocumentFiles } from './document-handling.ts';\r\nimport { fillFileIfEtagMatches, getDriveBaseUrl } from './microsoft-onedrive-helper.ts';\r\nimport type {\r\n    OneDriveState,\r\n    OneDriveItem\r\n} from './microsoft-onedrive-types.ts';\r\nimport { DriveStructure } from './init.ts';\r\n\r\nexport const WAL_FILE_NAME = 'rxdb-wal.json';\r\n\r\n// Batch insert limit in Graph api is often not fully restricted for files unless using batch endpoints, \r\n// a reasonable size is 100-250 to avoid timeout.\r\nexport const DRIVE_MAX_BULK_SIZE = 250;\r\n\r\nexport async function fetchConflicts<RxDocType>(\r\n    oneDriveState: OneDriveState,\r\n    init: DriveStructure,\r\n    primaryPath: keyof WithDeletedAndAttachments<RxDocType>,\r\n    writeRows: RxReplicationWriteToMasterRow<RxDocType>[]\r\n) {\r\n    if (writeRows.length > DRIVE_MAX_BULK_SIZE) {\r\n        throw newRxError('ODR18', {\r\n            args: {\r\n                DRIVE_MAX_BULK_SIZE\r\n            }\r\n        });\r\n    }\r\n\r\n    const ids = writeRows.map(row => (row.newDocumentState as any)[primaryPath]);\r\n    const filesMeta = await getDocumentFiles(\r\n        oneDriveState,\r\n        init,\r\n        ids as string[]\r\n    );\r\n    const fileIdByDocId = new Map<string, string>();\r\n    const fileIds: string[] = filesMeta.files.map((f) => {\r\n        const fileId = ensureNotFalsy(f.id);\r\n        const docId = f.name.split('.')[0];\r\n        fileIdByDocId.set(docId, fileId);\r\n        return fileId;\r\n    });\r\n    const contentsByFileId = await fetchDocumentContents<WithDeletedAndAttachments<RxDocType>>(\r\n        oneDriveState,\r\n        fileIds\r\n    );\r\n\r\n    const conflicts: WithDeletedAndAttachments<RxDocType>[] = [];\r\n    const nonConflicts: RxReplicationWriteToMasterRow<RxDocType>[] = [];\r\n    writeRows.forEach(row => {\r\n        const docId = (row.newDocumentState as any)[primaryPath];\r\n        let fileContent: undefined | WithDeletedAndAttachments<RxDocType>;\r\n        const fileId = fileIdByDocId.get(docId);\r\n        if (fileId) {\r\n            fileContent = contentsByFileId.byId[fileId];\r\n        }\r\n        if (row.assumedMasterState) {\r\n            if (!deepEqual(row.assumedMasterState, fileContent)) {\r\n                conflicts.push(ensureNotFalsy(fileContent));\r\n            } else {\r\n                nonConflicts.push(row);\r\n            }\r\n        } else if (fileContent) {\r\n            conflicts.push(fileContent);\r\n        } else {\r\n            nonConflicts.push(row);\r\n        }\r\n    });\r\n\r\n    if ((nonConflicts.length + conflicts.length) !== writeRows.length) {\r\n        throw newRxError('SNH', {\r\n            pushRows: writeRows,\r\n            args: {\r\n                nonConflicts,\r\n                conflicts,\r\n                contentsByFileId: contentsByFileId.byId\r\n            }\r\n        });\r\n    }\r\n\r\n    return {\r\n        conflicts,\r\n        nonConflicts\r\n    };\r\n}\r\n\r\nexport async function writeToWal<RxDocType>(\r\n    oneDriveState: OneDriveState,\r\n    init: DriveStructure,\r\n    writeRows?: RxReplicationWriteToMasterRow<RxDocType>[]\r\n) {\r\n    const walFileId = init.walFile.fileId;\r\n    const baseUrl = getDriveBaseUrl(oneDriveState);\r\n\r\n    const metaUrl = `${baseUrl}/items/${encodeURIComponent(walFileId)}?$select=id,size,eTag`;\r\n    const metaRes = await fetch(metaUrl, {\r\n        method: \"GET\",\r\n        headers: {\r\n            Authorization: `Bearer ${oneDriveState.authToken}`,\r\n        },\r\n    });\r\n    if (!metaRes.ok) {\r\n        throw await newRxFetchError(metaRes);\r\n    }\r\n    const meta: OneDriveItem = await metaRes.json();\r\n    const sizeNum = meta.size || 0;\r\n\r\n    if (writeRows && sizeNum > 0) {\r\n        throw newRxError(\"ODR19\", {\r\n            args: {\r\n                sizeNum,\r\n                walFileId,\r\n                meta,\r\n                writeRows: writeRows?.length\r\n            }\r\n        });\r\n    }\r\n\r\n    const etag = ensureNotFalsy(meta.eTag, 'etag missing');\r\n    const writeResult = await fillFileIfEtagMatches(\r\n        oneDriveState,\r\n        walFileId,\r\n        etag,\r\n        writeRows\r\n    );\r\n    if (writeResult.status !== 200 && writeResult.status !== 201) {\r\n        throw newRxError(\"ODR19\", {\r\n            args: {\r\n                walFileId,\r\n                meta,\r\n                writeRows: writeRows?.length\r\n            }\r\n        });\r\n    }\r\n}\r\n\r\n\r\nexport async function readWalContent<RxDocType>(\r\n    oneDriveState: OneDriveState,\r\n    init: DriveStructure,\r\n): Promise<{\r\n    etag: string;\r\n    rows: RxReplicationWriteToMasterRow<RxDocType>[] | undefined;\r\n}> {\r\n    const walFileId = init.walFile.fileId;\r\n    const baseUrl = getDriveBaseUrl(oneDriveState);\r\n    const contentUrl = `${baseUrl}/items/${encodeURIComponent(walFileId)}/content`;\r\n\r\n    const res = await fetch(contentUrl, {\r\n        method: \"GET\",\r\n        headers: {\r\n            Authorization: `Bearer ${oneDriveState.authToken}`,\r\n        },\r\n    });\r\n\r\n    if (!res.ok) {\r\n        throw await newRxFetchError(res);\r\n    }\r\n\r\n    let etag = res.headers.get(\"etag\") || res.headers.get(\"ETag\");\r\n\r\n    if (!etag) {\r\n        const metaRes = await fetch(`${baseUrl}/items/${encodeURIComponent(walFileId)}?$select=eTag`, {\r\n            headers: {\r\n                Authorization: `Bearer ${oneDriveState.authToken}`,\r\n            }\r\n        });\r\n        const meta: OneDriveItem = await metaRes.json();\r\n        etag = meta.eTag;\r\n    }\r\n\r\n    const text = await res.text();\r\n\r\n    if (!text || !text.trim()) {\r\n        return {\r\n            etag: ensureNotFalsy(etag),\r\n            rows: undefined\r\n        };\r\n    }\r\n\r\n    return {\r\n        etag: ensureNotFalsy(etag),\r\n        rows: JSON.parse(text) as RxReplicationWriteToMasterRow<RxDocType>[]\r\n    };\r\n}\r\n\r\n\r\n/**\r\n * Here we read the WAL file content\r\n * and sort the content into the actual\r\n * document files.\r\n * Notice that when the JavaScript process\r\n * exists at any point here, we need to have\r\n * a recoverable state on the next run. So this\r\n * must be idempotent.\r\n */\r\nexport async function processWalFile<RxDocType>(\r\n    oneDriveState: OneDriveState,\r\n    init: DriveStructure,\r\n    primaryPath: keyof RxDocType\r\n) {\r\n    const content = await readWalContent<RxDocType>(\r\n        oneDriveState,\r\n        init\r\n    );\r\n    if (!content.rows) {\r\n        return;\r\n    }\r\n\r\n\r\n    const docIds = content.rows.map(row => row.newDocumentState[primaryPath]);\r\n    const docFiles = await getDocumentFiles(\r\n        oneDriveState,\r\n        init,\r\n        docIds as string[]\r\n    );\r\n    const fileIdByDocId: Record<string, string> = {};\r\n\r\n    docFiles.files.forEach(file => {\r\n        const docId = file.name.split('.')[0] as any;\r\n        fileIdByDocId[docId] = file.id;\r\n    });\r\n\r\n    const toInsert: WithDeletedAndAttachments<RxDocType>[] = [];\r\n    const toUpdate: WithDeletedAndAttachments<RxDocType>[] = [];\r\n    content.rows.filter(row => {\r\n        const docId = row.newDocumentState[primaryPath];\r\n        const fileExists = fileIdByDocId[docId as any];\r\n        if (!fileExists) {\r\n            toInsert.push(row.newDocumentState);\r\n        } else {\r\n            toUpdate.push(row.newDocumentState);\r\n        }\r\n    });\r\n\r\n    await Promise.all([\r\n        insertDocumentFiles(\r\n            oneDriveState,\r\n            init,\r\n            primaryPath,\r\n            toInsert\r\n        ),\r\n        updateDocumentFiles(\r\n            oneDriveState,\r\n            primaryPath,\r\n            toUpdate,\r\n            fileIdByDocId,\r\n        )\r\n    ]);\r\n\r\n\r\n    // overwrite wal with emptyness\r\n    await writeToWal(\r\n        oneDriveState,\r\n        init,\r\n        undefined\r\n    );\r\n\r\n}\r\n\r\nexport async function handleUpstreamBatch<RxDocType>(\r\n    oneDriveState: OneDriveState,\r\n    init: DriveStructure,\r\n    primaryPath: keyof WithDeletedAndAttachments<RxDocType>,\r\n    writeRows: RxReplicationWriteToMasterRow<RxDocType>[]\r\n): Promise<WithDeletedAndAttachments<RxDocType>[]> {\r\n    const conflictResult = await fetchConflicts(\r\n        oneDriveState,\r\n        init,\r\n        primaryPath,\r\n        writeRows\r\n    );\r\n    await writeToWal(\r\n        oneDriveState,\r\n        init,\r\n        conflictResult.nonConflicts\r\n    );\r\n\r\n    return conflictResult.conflicts;\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/cjs/plugins/replication-mongodb/index.js

@@ -0,0 +1,229 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  RxMongoDBReplicationState: true,
+  replicateMongoDB: true
+};
+exports.RxMongoDBReplicationState = void 0;
+exports.replicateMongoDB = replicateMongoDB;
+var _inheritsLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/inheritsLoose"));
+var _index = require("../../plugins/utils/index.js");
+var _index2 = require("../leader-election/index.js");
+var _index3 = require("../replication/index.js");
+var _index4 = require("../../index.js");
+var _rxjs = require("rxjs");
+var _mongodb = require("mongodb");
+var _mongodbHelper = require("../storage-mongodb/mongodb-helper.js");
+var _mongodbCheckpoint = require("./mongodb-checkpoint.js");
+Object.keys(_mongodbCheckpoint).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _mongodbCheckpoint[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _mongodbCheckpoint[key];
+    }
+  });
+});
+var _mongodbHelper2 = require("./mongodb-helper.js");
+Object.keys(_mongodbHelper2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _mongodbHelper2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _mongodbHelper2[key];
+    }
+  });
+});
+var RxMongoDBReplicationState = exports.RxMongoDBReplicationState = /*#__PURE__*/function (_RxReplicationState) {
+  function RxMongoDBReplicationState(mongoClient, mongoDatabase, mongoCollection, options, replicationIdentifier, collection, pull, push, live = true, retryTime = 1000 * 5, autoStart = true) {
+    var _this;
+    _this = _RxReplicationState.call(this, replicationIdentifier, collection, '_deleted', pull, push, live, retryTime, autoStart) || this;
+    _this.mongoClient = mongoClient;
+    _this.mongoDatabase = mongoDatabase;
+    _this.mongoCollection = mongoCollection;
+    _this.options = options;
+    _this.replicationIdentifier = replicationIdentifier;
+    _this.collection = collection;
+    _this.pull = pull;
+    _this.push = push;
+    _this.live = live;
+    _this.retryTime = retryTime;
+    _this.autoStart = autoStart;
+    return _this;
+  }
+  (0, _inheritsLoose2.default)(RxMongoDBReplicationState, _RxReplicationState);
+  return RxMongoDBReplicationState;
+}(_index3.RxReplicationState);
+function replicateMongoDB(options) {
+  (0, _index4.addRxPlugin)(_index2.RxDBLeaderElectionPlugin);
+  var primaryPath = options.collection.schema.primaryPath;
+  options.live = typeof options.live === 'undefined' ? true : options.live;
+  options.waitForLeadership = typeof options.waitForLeadership === 'undefined' ? true : options.waitForLeadership;
+  var pullStream$ = new _rxjs.Subject();
+  var mongoClient = new _mongodb.MongoClient(options.mongodb.connection, _mongodbHelper.MONGO_OPTIONS_DRIVER_INFO);
+  var mongoDatabase = mongoClient.db(options.mongodb.databaseName);
+  var mongoCollection = mongoDatabase.collection(options.mongodb.collectionName);
+  var replicationPrimitivesPull;
+  if (options.pull) {
+    replicationPrimitivesPull = {
+      async handler(lastPulledCheckpoint, batchSize) {
+        var result = await (0, _mongodbCheckpoint.iterateCheckpoint)(primaryPath, mongoCollection, batchSize, lastPulledCheckpoint);
+        return {
+          documents: result.docs,
+          checkpoint: result.checkpoint
+        };
+      },
+      batchSize: (0, _index.ensureNotFalsy)(options.pull).batchSize,
+      modifier: (0, _index.ensureNotFalsy)(options.pull).modifier,
+      stream$: pullStream$.asObservable()
+    };
+  }
+  var replicationPrimitivesPush;
+  if (options.push) {
+    replicationPrimitivesPush = {
+      async handler(rows) {
+        var conflicts = [];
+        var session = mongoClient.startSession();
+        session.startTransaction(options.mongodb.pushTransactionOptions);
+        var ids = rows.map(row => row.newDocumentState[primaryPath]);
+        var currentDocsArray = await mongoCollection.find({
+          [primaryPath]: {
+            $in: ids
+          }
+        }, {
+          session
+        }).toArray();
+        var currentDocsMap = new Map();
+        currentDocsArray.forEach(doc => {
+          currentDocsMap.set(doc[primaryPath], doc);
+        });
+        var promises = [];
+        rows.forEach(row => {
+          var toMongoDoc = (0, _mongodbHelper2.rxdbDocToMongo)(row.newDocumentState);
+          var docId = row.newDocumentState[primaryPath];
+          var current = currentDocsMap.get(docId);
+          var remoteDocState = current ? (0, _mongodbHelper2.mongodbDocToRxDB)(primaryPath, current) : undefined;
+
+          /**
+           * We do not want to require a deleted-flag or any RxDB specific stuff on the RxDB side.
+           * So for deletes we have to hack around this.
+           */
+          var assumedMaster = row.assumedMasterState;
+          if (row.newDocumentState._deleted) {
+            if (remoteDocState) {
+              if (!assumedMaster) {
+                // remote exists but not assumed -> conflict
+                conflicts.push(remoteDocState);
+              } else if (assumedMaster._deleted) {
+                // remote exists but assumed as deleted -> conflict
+                conflicts.push(remoteDocState);
+              } else {
+                // remote exists and assumed to exist -> check for normal conflict or do the deletion-write
+                if (options.collection.conflictHandler.isEqual(remoteDocState, assumedMaster, 'mongodb-pull-equal-check-deleted') === false) {
+                  // conflict
+                  conflicts.push(remoteDocState);
+                } else {
+                  promises.push(mongoCollection.deleteOne({
+                    [primaryPath]: docId
+                  }, {
+                    session
+                  }));
+                }
+              }
+            } else {
+              if (!assumedMaster) {
+                // no remote and no assumed master -> insertion of deleted -> do nothing
+              } else if (assumedMaster._deleted) {
+                // no remote and assumed master also deleted -> insertion of deleted -> do nothing
+              }
+            }
+          } else {
+            /**
+             * Non-deleted are handled normally like in every other
+             * of the replication plugins.
+             */
+            if (remoteDocState && (!row.assumedMasterState || options.collection.conflictHandler.isEqual(remoteDocState, row.assumedMasterState, 'mongodb-pull-equal-check') === false)) {
+              // conflict
+              conflicts.push(remoteDocState);
+            } else {
+              if (current) {
+                if (row.newDocumentState._deleted) {
+                  promises.push(mongoCollection.deleteOne({
+                    [primaryPath]: docId
+                  }, {
+                    session
+                  }));
+                } else {
+                  promises.push(mongoCollection.updateOne({
+                    [primaryPath]: docId
+                  }, {
+                    $set: toMongoDoc
+                  }, {
+                    upsert: true,
+                    session
+                  }));
+                }
+              } else {
+                /**
+                 * No current but has assumed.
+                 * This means the server state was deleted
+                 * and we have a conflict.
+                 */
+                if (row.assumedMasterState) {
+                  var conflicting = (0, _index.flatClone)(row.assumedMasterState);
+                  conflicting._deleted = true;
+                  conflicts.push(conflicting);
+                } else {
+                  if (row.newDocumentState._deleted) {
+                    // inserting deleted -> do nothing
+                  } else {
+                    promises.push(mongoCollection.insertOne(toMongoDoc, {
+                      session
+                    }));
+                  }
+                }
+              }
+            }
+          }
+        });
+        await Promise.all(promises);
+        await session.commitTransaction();
+        return conflicts;
+      },
+      batchSize: options.push.batchSize,
+      modifier: options.push.modifier
+    };
+  }
+  var replicationState = new RxMongoDBReplicationState(mongoClient, mongoDatabase, mongoCollection, options, options.replicationIdentifier, options.collection, replicationPrimitivesPull, replicationPrimitivesPush, options.live, options.retryTime, options.autoStart);
+
+  /**
+   * Subscribe to changes for the pull.stream$
+   */
+  if (options.live && options.pull) {
+    var startBefore = replicationState.start.bind(replicationState);
+    var cancelBefore = replicationState.cancel.bind(replicationState);
+    replicationState.start = async () => {
+      var changestream = await (0, _mongodbHelper2.startChangeStream)(mongoCollection, undefined, replicationState.subjects.error);
+      changestream.on('change', () => {
+        // TODO use the documents data of the change instead of emitting the RESYNC flag
+        pullStream$.next('RESYNC');
+      });
+      replicationState.cancel = async () => {
+        await changestream.close();
+        return cancelBefore();
+      };
+      return startBefore();
+    };
+  }
+  (0, _index3.startReplicationOnLeaderShip)(options.waitForLeadership, replicationState);
+  return replicationState;
+}
+//# sourceMappingURL=index.js.map