react-native-mosquito-transport 0.0.21 → 0.0.23

package/src/products/database/counter.js

@@ -1,16 +1,18 @@
+import getLodash from "lodash/get";
+import setLodash from 'lodash/set';
 import { CacheStore } from "../../helpers/variables";
+import { serializeToBase64 } from "./bson";
 
-// TODO: fix this shit
-export const incrementDatabaseSize = (projectUrl, doc) => {
+export const incrementDatabaseSize = (builder, path, size) => incrementDatabaseSizeCore(CacheStore.DatabaseStats, builder, path, size);
 
-};
+export const incrementDatabaseSizeCore = (baseObj, builder, path, size = 0) => {
+    const { projectUrl, dbUrl, dbName } = builder;
+    baseObj._db_size += size;
 
-export const decrementDatabaseSize = (projectUrl, doc) => {
+    const node = [projectUrl, dbUrl, dbName, path];
 
-};
+    const b4 = getLodash(baseObj.database, node, 0);
+    setLodash(baseObj.database, node, b4 + size);
+}
 
-const opDatabaseSize = (projectUrl, doc) => {
-    // if (!CacheStore.DatabaseStats[projectUrl])
-    //     CacheStore.DatabaseStats[projectUrl] = 0;
-    // CacheStore.DatabaseStats[projectUrl] += size;
-};
+export const docSize = doc => doc ? serializeToBase64({ _: doc }).length : 0;

package/src/products/database/index.js

@@ -4,15 +4,14 @@ import { DatabaseRecordsListener } from "../../helpers/listeners";
 import { deserializeE2E, listenReachableServer, niceTry, serializeE2E } from "../../helpers/peripherals";
 import { awaitStore, buildFetchInterface, buildFetchResult, getReachableServer } from "../../helpers/utils";
 import { CacheStore, Scoped } from "../../helpers/variables";
-import { addPendingWrites, generateRecordID, getRecord, insertRecord, listenQueryEntry, removePendingWrite, validateWriteValue } from "./accessor";
+import { addPendingWrites, generateRecordID, getCountQuery, getRecord, insertCountQuery, insertRecord, listenQueryEntry, removePendingWrite, validateWriteValue } from "./accessor";
 import { validateCollectionName, validateFilter, validateFindConfig, validateFindObject, validateListenFindConfig } from "./validator";
 import { awaitRefreshToken, listenToken } from "../auth/accessor";
 import { DELIVERY, RETRIEVAL } from "../../helpers/values";
-import setLodash from 'lodash.set';
 import { ObjectId } from "bson";
 import { guardObject, Validator } from "guard-object";
 import { simplifyCaughtError } from "simplify-error";
-import cloneDeep from "lodash.clonedeep";
+import cloneDeep from "lodash/cloneDeep";
 import { deserializeBSON, serializeToBase64 } from "./bson";
 
 export class MTCollection {
@@ -67,19 +66,6 @@ export class MTCollection {
         get: (config) => findObject({ ...this.builder, command: { findOne } }, config)
     });
 
-    onDisconnect = () => ({
-        setOne: (value) => initOnDisconnectionTask({ ...this.builder }, value, 'setOne'),
-        setMany: (value) => initOnDisconnectionTask({ ...this.builder }, value, 'setMany'),
-        updateOne: (find = {}, value) => initOnDisconnectionTask({ ...this.builder, command: { find } }, value, 'updateOne'),
-        updateMany: (find = {}, value) => initOnDisconnectionTask({ ...this.builder, command: { find } }, value, 'updateMany'),
-        mergeOne: (find = {}, value) => initOnDisconnectionTask({ ...this.builder, command: { find } }, value, 'mergeOne'),
-        mergeMany: (find = {}, value) => initOnDisconnectionTask({ ...this.builder, command: { find } }, value, 'mergeMany'),
-        deleteOne: (find = {}) => initOnDisconnectionTask({ ...this.builder, command: { find } }, undefined, 'deleteOne'),
-        deleteMany: (find = {}) => initOnDisconnectionTask({ ...this.builder, command: { find } }, undefined, 'deleteMany'),
-        replaceOne: (find = {}, value) => initOnDisconnectionTask({ ...this.builder, command: { find } }, value, 'replaceOne'),
-        putOne: (find = {}, value) => initOnDisconnectionTask({ ...this.builder, command: { find } }, value, 'putOne')
-    });
-
     setOne = (value, config) => commitData(this.builder, value, 'setOne', config);
 
     setMany = (value, config) => commitData(this.builder, value, 'setMany', config);
@@ -115,6 +101,26 @@ export class MTCollection {
     deleteMany = (find = {}, config) => commitData({ ...this.builder, find }, undefined, 'deleteMany', config);
 };
 
+export const onCollectionConnect = (builder) => ({
+    ...collectionIO(data => ({
+        ...initCollectionIO({ connectData: data, builder }),
+        onDisconnect: () => collectionIO(data2 =>
+            initCollectionIO({ connectData: data, disconnectData: data2, builder })
+        )
+    })),
+    onDisconnect: () => collectionIO(data =>
+        initCollectionIO({ disconnectData: data, builder })
+    )
+});
+
+const collectionIO = (caller) => ({
+    batchWrite: (map, config) => caller({ value: map, config })
+});
+
+const initCollectionIO = (data) => ({
+    start: () => initOnDisconnectionTask(data)
+});
+
 export const batchWrite = (builder, map, config) => commitData({ ...builder }, map, 'batchWrite', config);
 
 const {
@@ -130,9 +136,9 @@ const {
 } = EngineApi;
 
 const listenDocument = (callback, onError, builder, config) => {
-    const { projectUrl, wsPrefix, serverE2E_PublicKey, baseUrl, dbUrl, dbName, accessKey, path, disableCache, command, uglify, extraHeaders, castBSON } = builder;
+    const { projectUrl, wsPrefix, serverE2E_PublicKey, baseUrl, dbUrl, dbName, path, disableCache, command, uglify, extraHeaders, castBSON } = builder;
     const { find, findOne, sort, direction, limit } = command;
-    const { disableAuth } = config || {};
+    const { disableAuth, episode } = config || {};
     const shouldCache = !disableCache;
     const processId = `${++Scoped.AnyProcessIte}`;
     let accessId;
@@ -145,7 +151,6 @@ const listenDocument = (callback, onError, builder, config) => {
         hasRespond,
         cacheListener,
         socket,
-        wasDisconnected,
         lastToken = Scoped.AuthJWTToken[projectUrl] || null,
         lastInitRef = 0,
         connectedListener,
@@ -159,7 +164,7 @@ const listenDocument = (callback, onError, builder, config) => {
     };
 
     if (shouldCache) {
-        accessId = generateRecordID(builder, config).then(hash => {
+        accessId = generateRecordID(builder, config, true).then(hash => {
             if (hasCancelled) return hash;
             cacheListener = listenQueryEntry(snapshot => {
                 if (!Scoped.IS_CONNECTED[projectUrl]) dispatchSnapshot(snapshot);
@@ -193,24 +198,25 @@ const listenDocument = (callback, onError, builder, config) => {
                 direction,
                 limit
             }),
-            dbName,
-            dbUrl
+            ...dbName ? { dbName } : undefined,
+            ...dbUrl ? { dbUrl } : undefined
         };
 
-        const [encPlate, [privateKey]] = uglify ? await serializeE2E({ accessKey, _body: authObj }, mtoken, serverE2E_PublicKey) : ['', []];
+        const [encPlate, [privateKey]] = uglify ? await serializeE2E({ _body: authObj }, mtoken, serverE2E_PublicKey) : ['', []];
 
         socket = io(`${wsPrefix}://${baseUrl}`, {
             transports: ['websocket', 'polling', 'flashsocket'],
             extraHeaders,
-            auth: uglify ? { e2e: encPlate.toString('base64'), _m_internal: true } : {
-                accessKey,
-                _body: authObj,
-                ...mtoken ? { mtoken } : {},
-                _m_internal: true
+            auth: {
+                ...uglify ? { e2e: encPlate.toString('base64') } : {
+                    _body: authObj,
+                    ...mtoken ? { mtoken } : {}
+                },
+                _m_internal: true,
+                _m_route: (findOne ? _listenDocument : _listenCollection)(uglify)
             }
         });
 
-        socket.emit((findOne ? _listenDocument : _listenCollection)(uglify));
         socket.on('mSnapshot', async ([err, snapshot]) => {
             hasRespond = true;
             if (err) {
@@ -219,20 +225,12 @@ const listenDocument = (callback, onError, builder, config) => {
                 } else console.error('unhandled listen for:', { path, find }, ' error:', err);
             } else {
                 if (uglify) snapshot = await deserializeE2E(snapshot, serverE2E_PublicKey, privateKey);
-                snapshot = deserializeBSON(snapshot)._;
+                snapshot = hydrateForeignDoc(deserializeBSON(snapshot)._);
                 dispatchSnapshot(snapshot);
 
-                if (shouldCache) insertRecord(builder, config, await accessId, snapshot);
+                if (shouldCache) insertRecord(builder, config, await accessId, snapshot, episode);
             }
         });
-
-        socket.on('connect', () => {
-            if (wasDisconnected) socket.emit((findOne ? _listenDocument : _listenCollection)(uglify));
-        });
-
-        socket.on('disconnect', () => {
-            wasDisconnected = true;
-        });
     };
 
     init();
@@ -240,10 +238,10 @@ const listenDocument = (callback, onError, builder, config) => {
     const tokenListener = listenToken(t => {
         if ((t || null) !== lastToken) {
             socket?.close?.();
-            wasDisconnected = undefined;
+            socket = undefined;
             init();
         }
-        lastToken = t;
+        lastToken = t || null;
     }, projectUrl);
 
     return () => {
@@ -256,17 +254,30 @@ const listenDocument = (callback, onError, builder, config) => {
     }
 };
 
-const initOnDisconnectionTask = (builder, value, type) => {
-    const { projectUrl, wsPrefix, baseUrl, serverE2E_PublicKey, dbUrl, dbName, accessKey, path, extraHeaders, command, uglify } = builder;
-    const { find } = command || {};
+const initOnDisconnectionTask = ({ builder, connectData, disconnectData }) => {
+    const { projectUrl, wsPrefix, baseUrl, serverE2E_PublicKey, dbUrl, dbName, extraHeaders, uglify } = builder;
     const disableAuth = false;
 
-    validateCollectionName(path);
-    validateWriteValue({ type, find, value });
+    [connectData, disconnectData].forEach((e) => {
+        if (e) {
+            if (e.config !== undefined)
+                guardObject({
+                    stepping: t => t === undefined || Validator.BOOLEAN(t)
+                }).validate(e.config);
+
+            cleanBatchWrite(e.value).forEach(e => {
+                const { scope, find, value, path } = e;
+                validateCollectionName(path);
+                validateWriteValue({ find, value, type: scope });
+            });
+        }
+    });
 
     let hasCancelled,
+        /**
+         * @type {import('socket.io-client').Socket}
+         */
         socket,
-        wasDisconnected,
         lastToken = Scoped.AuthJWTToken[projectUrl] || null,
         lastInitRef = 0;
 
@@ -276,68 +287,64 @@ const initOnDisconnectionTask = (builder, value, type) => {
         if (hasCancelled || processID !== lastInitRef) return;
 
         const mtoken = disableAuth ? undefined : Scoped.AuthJWTToken[projectUrl];
+        const makeObj = (d) => ({
+            ...d?.config,
+            value: serializeToBase64({ _: cleanBatchWrite(d.value) })
+        });
+
         const authObj = {
-            commands: stripUndefined({
-                path,
-                find: find && serializeToBase64(find),
-                value: value && serializeToBase64({ _: value }),
-                scope: type
-            }),
-            dbName,
-            dbUrl
+            commands: {
+                ...connectData ? { connectTask: makeObj(connectData) } : {},
+                ...disconnectData ? { disconnectTask: makeObj(disconnectData) } : {}
+            },
+            ...dbName ? { dbName } : undefined,
+            ...dbUrl ? { dbUrl } : undefined
         };
 
         socket = io(`${wsPrefix}://${baseUrl}`, {
             transports: ['websocket', 'polling', 'flashsocket'],
             extraHeaders,
-            auth: uglify ? {
-                e2e: (await serializeE2E({ accessKey, _body: authObj }, mtoken, serverE2E_PublicKey))[0].toString('base64'),
-                _m_internal: true
-            } : {
-                ...mtoken ? { mtoken } : {},
-                accessKey,
-                _body: authObj,
-                _m_internal: true
+            auth: {
+                ...uglify ? {
+                    e2e: (await serializeE2E({ _body: authObj }, mtoken, serverE2E_PublicKey))[0].toString('base64')
+                } : {
+                    ...mtoken ? { mtoken } : {},
+                    _body: authObj
+                },
+                _m_internal: true,
+                _m_route: _startDisconnectWriteTask(uglify)
             }
         });
-        socket.emit(_startDisconnectWriteTask(uglify));
-
-        socket.on('connect', () => {
-            if (wasDisconnected) socket.emit(_startDisconnectWriteTask(uglify));
-        });
-
-        socket.on('disconnect', () => {
-            wasDisconnected = true;
-        });
     };
 
     init();
 
-    const tokenListener = listenToken(async t => {
+    const tokenListener = disableAuth ? undefined : listenToken(async t => {
         if ((t || null) !== lastToken) {
             if (socket) {
-                await niceTry(() => socket.timeout(7000).emitWithAck(_cancelDisconnectWriteTask(uglify)));
                 socket.close();
-            }
-            wasDisconnected = undefined;
-            init();
+                socket = undefined;
+                setTimeout(init, 500);
+            } else init();
         }
         lastToken = t;
     }, projectUrl);
 
     return () => {
         if (hasCancelled) return;
-        tokenListener();
-        if (socket)
-            niceTry(() => socket.timeout(7000).emitWithAck(_cancelDisconnectWriteTask(uglify))).then(() => {
-                socket.close();
-            });
         hasCancelled = true;
+        tokenListener?.();
+        if (socket) {
+            const thisSocket = socket;
+            return niceTry(() => thisSocket.timeout(5000).emitWithAck(_cancelDisconnectWriteTask(uglify))).finally(() => {
+                thisSocket.close();
+            });
+        }
     };
 };
 
 const countCollection = async (builder, config) => {
-    const { projectUrl, serverE2E_PublicKey, dbUrl, dbName, accessKey, maxRetries = 7, uglify, extraHeaders, path, disableCache, command = {} } = builder;
+    const { projectUrl, serverE2E_PublicKey, dbUrl, dbName, maxRetries = 1, uglify, extraHeaders, path, disableCache, command = {} } = builder;
     const { find } = command;
     const { disableAuth } = config || {};
     const accessId = await generateRecordID({ ...builder, countDoc: true }, config);
@@ -368,10 +375,9 @@ const countCollection = async (builder, config) => {
             const [reqBuilder, [privateKey]] = await buildFetchInterface({
                 body: {
                     commands: { path, find: serializeToBase64(find) },
-                    dbName,
-                    dbUrl
+                    ...dbName ? { dbName } : undefined,
+                    ...dbUrl ? { dbUrl } : undefined
                 },
-                accessKey,
                 ...disableAuth ? {} : { authToken: Scoped.AuthJWTToken[projectUrl] },
                 serverE2E_PublicKey,
                 uglify,
@@ -382,12 +388,11 @@ const countCollection = async (builder, config) => {
 
             const f = uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data;
 
-            if (!disableCache)
-                setLodash(CacheStore.DatabaseCountResult, [projectUrl, dbUrl, dbName, accessId], f.result);
-
             finalize(f.result);
+
+            if (!disableCache) insertCountQuery(builder, accessId, f.result);
         } catch (e) {
-            const b4Data = setLodash(CacheStore.DatabaseCountResult, [projectUrl, dbUrl, dbName, accessId]);
+            const b4Data = await getCountQuery(builder, accessId).catch(() => null);
 
             if (e?.simpleError) {
                 finalize(undefined, e.simpleError);
@@ -424,26 +429,40 @@ const stripUndefined = o => Object.fromEntries(
     Object.entries(o).filter(v => v[1] !== undefined)
 );
 
+const hydrateForeignDoc = ({ data, doc_holder }) => {
+    const isList = Array.isArray(data);
+    const filled = (isList ? data : [data]).map(v => {
+        if (v?._foreign_doc) {
+            v._foreign_doc = Array.isArray(v._foreign_doc)
+                ? v._foreign_doc.map(k => doc_holder[k])
+                : doc_holder[v._foreign_doc];
+        }
+        return v;
+    });
+    return isList ? filled : filled[0];
+}
+
 const transformBSON = (d, castBSON) => {
     if (castBSON) return d && deserializeBSON(serializeToBase64({ _: d }), true)._;
     return cloneDeep(d);
 };
 
 const findObject = async (builder, config) => {
-    const { projectUrl, serverE2E_PublicKey, dbUrl, dbName, accessKey, maxRetries = 7, path, disableCache, uglify, extraHeaders, command, castBSON } = builder;
+    const { projectUrl, serverE2E_PublicKey, dbUrl, dbName, maxRetries = 1, path, disableCache = false, uglify, extraHeaders, command, castBSON } = builder;
+    const pureConfig = stripRequestConfig(config);
+    validateFindObject(command);
+    validateFindConfig(config);
+    validateCollectionName(path);
+
     const { find, findOne, sort, direction, limit, random } = command;
     const { retrieval = RETRIEVAL.DEFAULT, episode = 0, disableAuth, disableMinimizer } = config || {};
     const enableMinimizer = !disableMinimizer;
-    const accessId = await generateRecordID(builder, config);
-    const processAccessId = `${accessId}${projectUrl}${dbUrl}${dbName}${retrieval}`;
-    const getRecordData = () => getRecord(builder, config, accessId);
+    const accessId = await generateRecordID(builder, config, true);
+    const processAccessId = `${accessId}_${limit}_${episode}_${projectUrl}_${dbUrl}_${dbName}_${retrieval}_${disableCache}`;
+    const getRecordData = () => getRecord(builder, accessId, episode);
     const shouldCache = (retrieval !== RETRIEVAL.DEFAULT || !disableCache) &&
         ![RETRIEVAL.NO_CACHE_NO_AWAIT, RETRIEVAL.NO_CACHE_AWAIT].includes(retrieval);
 
-    const pureConfig = stripRequestConfig(config);
-    validateFindObject(command);
-    validateFindConfig(config);
-    validateCollectionName(path);
     await awaitStore();
 
     let retries = 0, hasFinalize;
@@ -453,10 +472,7 @@ const findObject = async (builder, config) => {
             instantProcess = retryProcess === 1;
 
         const finalize = (a, b) => {
-            const res = (instantProcess && a) ?
-                (a.liveResult || a.liveResult === null) ?
-                    transformBSON(a.liveResult || undefined, castBSON) :
-                    transformBSON(a.episode[episode], castBSON) : a;
+            const res = (instantProcess && a) ? transformBSON(a[0] || undefined, castBSON) : a;
 
             if (a) {
                 resolve(instantProcess ? cloneDeep(res) : a);
@@ -465,35 +481,36 @@ const findObject = async (builder, config) => {
             hasFinalize = true;
 
             if (enableMinimizer) {
-                (Scoped.PendingDbReadCollective.pendingResolution[processAccessId] || []).forEach(e => {
+                const resolutionList = (Scoped.PendingDbReadCollective[processAccessId] || []).slice(0);
+
+                if (Scoped.PendingDbReadCollective[processAccessId])
+                    delete Scoped.PendingDbReadCollective[processAccessId];
+
+                resolutionList.forEach(e => {
                     e(a ? { result: res } : undefined, b);
                 });
-                if (Scoped.PendingDbReadCollective.pendingResolution[processAccessId])
-                    delete Scoped.PendingDbReadCollective.pendingResolution[processAccessId];
-
-                if (Scoped.PendingDbReadCollective.pendingProcess[processAccessId])
-                    delete Scoped.PendingDbReadCollective.pendingProcess[processAccessId];
             }
         };
 
         try {
             if (instantProcess) {
                 if (enableMinimizer) {
-                    if (Scoped.PendingDbReadCollective.pendingProcess[processAccessId]) {
-                        if (!Scoped.PendingDbReadCollective.pendingResolution[processAccessId])
-                            Scoped.PendingDbReadCollective.pendingResolution[processAccessId] = [];
-
-                        Scoped.PendingDbReadCollective.pendingResolution[processAccessId].push((a, b) => {
+                    if (Scoped.PendingDbReadCollective[processAccessId]) {
+                        Scoped.PendingDbReadCollective[processAccessId].push((a, b) => {
                             if (a) resolve(cloneDeep(a.result));
                             else reject(cloneDeep(b));
                         });
                         return;
                     }
-                    Scoped.PendingDbReadCollective.pendingProcess[processAccessId] = true;
+                    Scoped.PendingDbReadCollective[processAccessId] = [];
                 }
 
-                if (retrieval.startsWith('sticky') && await getRecordData()) {
-                    finalize({ episode: await getRecordData() });
+                let staleData;
+                if (
+                    retrieval.startsWith('sticky') &&
+                    (staleData = await getRecordData())
+                ) {
+                    finalize(staleData);
                     if (retrieval !== RETRIEVAL.STICKY_RELOAD) return;
                 }
             }
@@ -512,10 +529,9 @@ const findObject = async (builder, config) => {
                         limit,
                         random
                     }),
-                    dbName,
-                    dbUrl
+                    ...dbName ? { dbName } : undefined,
+                    ...dbUrl ? { dbUrl } : undefined
                 },
-                accessKey,
                 authToken: disableAuth ? undefined : Scoped.AuthJWTToken[projectUrl],
                 serverE2E_PublicKey,
                 uglify,
@@ -524,14 +540,16 @@ const findObject = async (builder, config) => {
 
             const data = await buildFetchResult(await fetch((findOne ? _readDocument : _queryCollection)(projectUrl, uglify), reqBuilder), uglify);
 
-            const result = deserializeBSON((uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data).result)._;
+            const result = hydrateForeignDoc(
+                deserializeBSON((uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data).result)._
+            );
 
-            if (shouldCache) insertRecord(builder, config, accessId, result);
-            finalize({ liveResult: result || null });
+            if (shouldCache) insertRecord(builder, config, accessId, result, episode);
+            finalize([result]);
         } catch (e) {
             let thisRecord;
-            const getThisRecord = async () => thisRecord ? thisRecord.value :
-                (thisRecord = { value: await getRecordData() }).value;
+            const getThisRecord = async () => thisRecord ? thisRecord[0] :
+                (thisRecord = [await getRecordData()])[0];
 
             if (e?.simpleError) {
                 finalize(undefined, e?.simpleError);
@@ -543,10 +561,14 @@ const findObject = async (builder, config) => {
                 finalize(undefined, simplifyCaughtError(e).simpleError);
             } else if (
                 shouldCache &&
-                [RETRIEVAL.DEFAULT, RETRIEVAL.CACHE_NO_AWAIT].includes(retrieval) &&
+                [
+                    RETRIEVAL.DEFAULT,
+                    RETRIEVAL.CACHE_NO_AWAIT,
+                    RETRIEVAL.CACHE_AWAIT
+                ].includes(retrieval) &&
                 await getThisRecord()
             ) {
-                finalize({ episode: await getThisRecord() });
+                finalize(await getThisRecord());
             } else if (retries > maxRetries) {
                 finalize(undefined, { error: 'retry_limit_exceeded', message: `retry exceed limit(${maxRetries})` });
             } else {
@@ -563,7 +585,7 @@ const findObject = async (builder, config) => {
         }
     });
 
-    return await readValue();
+    return (await readValue());
 };
 
 const transformNullRecursively = obj => Object.fromEntries(
@@ -572,6 +594,17 @@ const transformNullRecursively = obj => Object.fromEntries(
     )
 );
 
+const cleanBatchWrite = (value) => cloneDeep(value).map(v => {
+    if (Validator.OBJECT(v?.value)) {
+        v.value = transformNullRecursively(v.value);
+    } else if (Array.isArray(v?.value)) {
+        v.value = v.value.map(e =>
+            Validator.OBJECT(e) ? transformNullRecursively(e) : e
+        );
+    }
+    return v;
+});
+
 const commitData = async (builder, value, type, config) => {
     // transform undefined
     if (Validator.OBJECT(value)) {
@@ -579,28 +612,17 @@ const commitData = async (builder, value, type, config) => {
     } else if (type === 'batchWrite' && Array.isArray(value)) {
         value = deserializeBSON(
             serializeToBase64({
-                _: value.map(v => {
-                    if (Validator.OBJECT(v?.value)) {
-                        v.value = transformNullRecursively(v.value);
-                    } else if (Array.isArray(v?.value)) {
-                        v.value = v.value.map(e =>
-                            Validator.OBJECT(e) ? transformNullRecursively(e) : e
-                        );
-                    }
-                    return v;
-                })
+                _: cleanBatchWrite(value)
             })
         )._;
     }
 
-    const { projectUrl, serverE2E_PublicKey, dbUrl, dbName, accessKey, maxRetries = 7, path, find, disableCache, uglify, extraHeaders } = builder;
+    const { projectUrl, serverE2E_PublicKey, dbUrl, dbName, maxRetries = 1, path, find, disableCache, uglify, extraHeaders } = builder;
     const { disableAuth, delivery = DELIVERY.DEFAULT, stepping } = config || {};
     const writeId = `${Date.now() + ++Scoped.PendingIte}`;
     const isBatchWrite = type === 'batchWrite';
     const shouldCache = (delivery !== DELIVERY.DEFAULT || !disableCache) &&
-        delivery !== DELIVERY.NO_CACHE &&
-        delivery !== DELIVERY.NO_AWAIT_NO_CACHE &&
-        delivery !== DELIVERY.AWAIT_NO_CACHE;
+        ![DELIVERY.NO_CACHE_AWAIT, DELIVERY.NO_CACHE_NO_AWAIT].includes();
 
     await awaitStore();
     if (shouldCache) {
@@ -648,10 +670,9 @@ const commitData = async (builder, value, type, config) => {
                             find: find && serializeToBase64(find)
                         }
                     }),
-                    dbName,
-                    dbUrl
+                    ...dbName ? { dbName } : undefined,
+                    ...dbUrl ? { dbUrl } : undefined
                 },
-                accessKey,
                 serverE2E_PublicKey,
                 authToken: disableAuth ? undefined : Scoped.AuthJWTToken[projectUrl],
                 uglify,
@@ -667,27 +688,16 @@ const commitData = async (builder, value, type, config) => {
             if (e?.simpleError) {
                 console.error(`${type} error (${path}), ${e.simpleError?.message}`);
                 finalize(undefined, e?.simpleError, { removeCache: true, revertCache: true });
-            } else if (
-                [
-                    DELIVERY.NO_AWAIT,
-                    DELIVERY.CACHE_NO_AWAIT,
-                    DELIVERY.NO_AWAIT_NO_CACHE,
-                    DELIVERY.NO_CACHE
-                ].includes(delivery)
-            ) {
-                finalize(
-                    undefined,
-                    simplifyCaughtError(e).simpleError,
-                    await getReachableServer(projectUrl) ? { removeCache: true } : undefined
-                );
-            } else if (retries >= maxRetries) {
+            } else if (delivery === DELIVERY.NO_CACHE_NO_AWAIT) {
+                finalize(undefined, simplifyCaughtError(e).simpleError);
+            } else if (retries > maxRetries) {
                 finalize(
                     undefined,
                     { error: 'retry_limit_exceeded', message: `retry exceed limit(${maxRetries})` },
                     { removeCache: true, revertCache: true }
                 );
             } else {
-                if (delivery === DELIVERY.AWAIT_NO_CACHE) {
+                if (delivery === DELIVERY.NO_CACHE_AWAIT) {
                     const onlineListener = listenReachableServer(connected => {
                         if (connected) {
                             onlineListener();
@@ -703,7 +713,7 @@ const commitData = async (builder, value, type, config) => {
         }
     });
 
-    return await sendValue();
+    return (await sendValue());
 };
 
 export const trySendPendingWrite = (projectUrl) => {
@@ -713,20 +723,28 @@ export const trySendPendingWrite = (projectUrl) => {
         const sortedWrite = Object.entries(CacheStore.PendingWrites[projectUrl] || {})
             .filter(([k]) => !Scoped.OutgoingWrites[k])
             .sort((a, b) => a[1].addedOn - b[1].addedOn);
+        let resolveCounts = 0;
 
         for (const [writeId, { snapshot, builder, attempts = 1 }] of sortedWrite) {
             try {
-                await commitData(builder, snapshot.value, snapshot.type, { ...snapshot.config, delivery: DELIVERY.NO_AWAIT_NO_CACHE });
+                await commitData(builder, snapshot.value, snapshot.type, { ...snapshot.config, delivery: DELIVERY.NO_CACHE_NO_AWAIT });
                 delete CacheStore.PendingWrites[projectUrl][writeId];
+                ++resolveCounts;
             } catch (_) {
                 const { maxRetries } = builder;
                 if (!maxRetries || attempts >= maxRetries) {
                     delete CacheStore.PendingWrites[projectUrl][writeId];
+                    ++resolveCounts;
+                } else if (CacheStore.PendingWrites[projectUrl]?.[writeId]) {
+                    CacheStore.PendingWrites[projectUrl][writeId].attempts = attempts + 1;
                 }
             }
         }
         resolve();
         Scoped.dispatchingWritesPromise = undefined;
-        if (sortedWrite.length && await getReachableServer(projectUrl)) trySendPendingWrite(projectUrl);
+        if (
+            (sortedWrite.length - resolveCounts) &&
+            await getReachableServer(projectUrl)
+        ) trySendPendingWrite(projectUrl);
     });
 };

package/src/products/database/types.js

@@ -1,5 +1,6 @@
 
 export const TIMESTAMP = { $timestamp: "now" };
+export const TIMESTAMP_OFFSET = (v) => ({ $timestamp_offset: v });
 
 export const IS_TIMESTAMP = (t) => t && (typeof t.$timestamp === 'number' || t.$timestamp === 'now') && Object.keys(t).length === 1;