react-native-mosquito-transport 0.0.34 → 0.0.36

package/src/products/database/accessor.js

@@ -2,17 +2,15 @@ import { niceHash, shuffleArray, sortArrayByObjectKey } from "../../helpers/peri
 import { awaitStore, updateCacheStore } from "../../helpers/utils";
 import { CacheStore, Scoped } from "../../helpers/variables";
 import { assignExtractionFind, CompareBson, confirmFilterDoc, defaultBSON, downcastBSON, validateCollectionName, validateFilter } from "./validator";
-import getLodash from 'lodash/get';
-import setLodash from 'lodash/set';
-import unsetLodash from 'lodash/unset';
 import { DatabaseRecordsListener } from "../../helpers/listeners";
 import cloneDeep from "lodash/cloneDeep";
-import { BSONRegExp, ObjectId, Timestamp } from "bson/lib/bson.rn.cjs";
+import { BSONRegExp, ObjectId, Timestamp } from "../../vendor/bson";
 import { niceGuard, Validator } from "guard-object";
 import { TIMESTAMP } from "../..";
 import { docSize, incrementDatabaseSize } from "./counter";
-import { deserializeBSON, serializeToBase64 } from "./bson";
+import { DatastoreParser, serializeToBase64 } from "./bson";
 import { FS_PATH, getSystem, useFS } from "../../helpers/fs_manager";
+import { grab, poke, unpoke } from "poke-object";
 
 const { LIMITER_DATA, LIMITER_RESULT, DB_COUNT_QUERY } = FS_PATH;
 
@@ -48,12 +46,12 @@ export const insertCountQuery = async (builder, access_id, value) => {
 
     const { io } = Scoped.ReleaseCacheData;
     if (io) {
-        setLodash(CacheStore.DatabaseCountResult, [projectUrl, dbUrl, dbName, path, access_id], { value, touched: Date.now() });
+        poke(CacheStore.DatabaseCountResult, [projectUrl, dbUrl, dbName, path, access_id], { value, touched: Date.now() });
         updateCacheStore(['DatabaseCountResult']);
     } else {
         await useFS(builder, access_id, 'dbQueryCount')(async fs => {
             await fs.set(DB_COUNT_QUERY(path), access_id, { value, touched: Date.now() });
-            setLodash(CacheStore.DatabaseStats.counters, [projectUrl, dbUrl, dbName, path], true);
+            poke(CacheStore.DatabaseStats.counters, [projectUrl, dbUrl, dbName, path], true);
         });
         updateCacheStore(['DatabaseStats']);
     }
@@ -64,7 +62,7 @@ export const getCountQuery = async (builder, access_id) => {
     const { io } = Scoped.ReleaseCacheData;
 
     if (io) {
-        const data = getLodash(CacheStore.DatabaseCountResult, [projectUrl, dbUrl, dbName, path, access_id]);
+        const data = grab(CacheStore.DatabaseCountResult, [projectUrl, dbUrl, dbName, path, access_id]);
         if (data) data.touched = Date.now();
         return data && data.value;
     } else {
@@ -102,14 +100,13 @@ export const insertRecord = async (builder, config, accessIdWithoutLimit, value,
             const editionSizeOffset = thisSize - (instanceData?.size || 0);
             const resultSizeOffset = isEpisode ? thisSize - (resultData?.size || 0) : 0;
 
-            const newData = serializeToBase64({
+            const newData = DatastoreParser.encode({
                 command,
                 config,
                 latest_limiter: limit,
-                size: thisSize,
                 data: value ? Array.isArray(value) ? value : [value] : []
             });
-            const newResultData = isEpisode && serializeToBase64({
+            const newResultData = isEpisode && DatastoreParser.encode({
                 data: value,
                 size: thisSize
             });
@@ -134,8 +131,8 @@ export const insertRecord = async (builder, config, accessIdWithoutLimit, value,
         return;
     }
 
-    const instanceData = getLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'instance', accessIdWithoutLimit]);
-    const resultData = getLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'episode', accessIdWithoutLimit, limit]);
+    const instanceData = grab(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'instance', accessIdWithoutLimit]);
+    const resultData = grab(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'episode', accessIdWithoutLimit, `${limit}`]);
     const isEpisode = episode === 1 || !!resultData;
 
     const editionSizeOffset = thisSize - (instanceData?.size || 0);
@@ -157,8 +154,8 @@ export const insertRecord = async (builder, config, accessIdWithoutLimit, value,
 
     incrementDatabaseSize(builder, path, editionSizeOffset + resultSizeOffset);
 
-    setLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'instance', accessIdWithoutLimit], newData);
-    if (isEpisode) setLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'episode', accessIdWithoutLimit, limit], cloneDeep(newResultData));
+    poke(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'instance', accessIdWithoutLimit], newData);
+    if (isEpisode) poke(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'episode', accessIdWithoutLimit, `${limit}`], cloneDeep(newResultData));
     updateCacheStore(['DatabaseStore', 'DatabaseStats']);
 };
 
@@ -197,7 +194,7 @@ export const getRecord = async (builder, accessIdWithoutLimit, episode = 0) => {
                 isEpisode ? fs.find(LIMITER_RESULT(path), resultAccessId, ['value']) :
                     fs.find(LIMITER_DATA(path), accessIdWithoutLimit, ['value'])
             ).catch(() => null);
-            const thisData = qData && deserializeBSON(qData.value, true);
+            const thisData = qData && DatastoreParser.decode(qData.value);
 
             if (!thisData) return null;
 
@@ -221,7 +218,7 @@ export const getRecord = async (builder, accessIdWithoutLimit, episode = 0) => {
     }
 
     if (isEpisode) {
-        const resultData = getLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'episode', accessIdWithoutLimit, limit]);
+        const resultData = grab(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'episode', accessIdWithoutLimit, `${limit}`]);
         if (resultData) {
             resultData.touched = Date.now();
             return [cloneDeep(resultData.data)];
@@ -229,7 +226,7 @@ export const getRecord = async (builder, accessIdWithoutLimit, episode = 0) => {
         return null;
     }
 
-    const instanceData = getLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'instance', accessIdWithoutLimit]);
+    const instanceData = grab(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'instance', accessIdWithoutLimit]);
     if (!instanceData) return null;
     const { latest_limiter, data } = instanceData;
 
@@ -285,7 +282,7 @@ const arrangeCommands = (c, removeLimit) => {
     if (c.sort) c.direction = [-1, 'desc', 'descending'].includes(c.direction) ? 'desc' : 'asc';
     if (c.find) c.find = sortFind(c.find);
     if (c.findOne) c.findOne = sortFind(c.findOne);
-    if (removeLimit && 'limit' in c) delete c.limit;
+    if (removeLimit && ('limit' in c)) delete c.limit;
     return sortObject(c);
 };
 
@@ -389,19 +386,20 @@ export const addPendingWrites = async (builder, writeId, result) => {
     const pathChanges = new Set([]);
     const pendingSnapshot = cloneDeep(result);
 
-    await Promise.all((
+    const linearWrite =
         result.type === 'batchWrite' ?
             result.value.map(({ scope, value, find, path }) =>
                 ({ type: scope, value, find, path })
             )
-            : [{ ...result, path: builder.path }]
-    ).map(async ({ value: writeObj, find, type, path }) => {
+            : [{ ...result, find: builder.find, path: builder.path }];
+
+    await Promise.all(linearWrite.map(async ({ value: writeObj, find, type, path }) => {
         WriteValidator[type]({ find, value: writeObj });
         validateCollectionName(path);
         pathChanges.add(path);
 
         if (io) {
-            const colObj = getLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'instance']);
+            const colObj = grab(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'instance']);
 
             if (colObj)
                 await Promise.all(
@@ -410,7 +408,7 @@ export const addPendingWrites = async (builder, writeId, result) => {
                             e,
                             path =>
                                 Object.values(
-                                    getLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'instance'], {})
+                                    grab(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'instance'], {})
                                 ).map(({ data }) => data).flat()
                         )
                     )
@@ -422,18 +420,18 @@ export const addPendingWrites = async (builder, writeId, result) => {
             await Promise.all(colListing.map(async ([access_id]) =>
                 useFS(builder, access_id, 'database')(async fs => {
                     const data = await fs.find(LIMITER_DATA(path), access_id, ['value'])
-                        .then(r => deserializeBSON(r.value, true));
+                        .then(r => DatastoreParser.decode(r.value));
 
                     await MutateDataInstance([access_id, data], path =>
                         pathFinder[path] || (
                             pathFinder[path] = fs.list(LIMITER_DATA(path), ['value'])
-                                .then(v => v.map(d => deserializeBSON(d[1].value, true).data).flat())
+                                .then(v => v.map(d => DatastoreParser.decode(d[1].value).data).flat())
                                 .catch(() => [])
                         )
                     );
                     await fs.set(LIMITER_DATA(path), access_id, {
                         touched: Date.now(),
-                        value: serializeToBase64(data),
+                        value: DatastoreParser.encode(data),
                         size: data.size
                     });
                 })
@@ -640,12 +638,57 @@ export const addPendingWrites = async (builder, writeId, result) => {
         };
     }));
 
-    setLodash(CacheStore.PendingWrites, [projectUrl, writeId], cloneDeep({
-        builder,
-        snapshot: pendingSnapshot,
-        editions,
-        addedOn: Date.now()
-    }));
+    const isStaticWrite = !linearWrite.some(({ value, type }) => {
+        if (
+            [
+                'updateOne',
+                'updateMany',
+                'mergeOne',
+                'mergeMany'
+            ].includes(type)
+        ) {
+            const operators = Object.keys(value);
+            return ['$inc', '$min', '$max', '$mul', '$pop', '$pull', '$push', '$rename'].includes(operators);
+        }
+    });
+    const pureBuilder = {};
+
+    ['path', 'dbUrl', 'dbName', 'find', 'extraHeaders', 'maxRetries'].forEach(v => {
+        if (builder[v] !== undefined) pureBuilder[v] = builder[v];
+    });
+    pureBuilder.find = serializeToBase64({ _: pureBuilder.find });
+    pendingSnapshot.value = serializeToBase64({ _: pendingSnapshot.value });
+
+    let wasShifted;
+
+    if (isStaticWrite) {
+        // find previously matching pending write
+        const entries = Object.entries(CacheStore.PendingWrites[projectUrl] || {});
+
+        for (const [writeId, obj] of entries) {
+            if (!Scoped.OutgoingWrites[writeId]) {
+                if (
+                    niceGuard(
+                        { builder: obj.builder, snapshot: obj.snapshot },
+                        { builder: pureBuilder, snapshot: pendingSnapshot }
+                    )
+                ) {
+                    // shift it to the front
+                    obj.addedOn = Date.now();
+                    wasShifted = true;
+                    break;
+                }
+            }
+        }
+    }
+
+    if (!wasShifted)
+        poke(CacheStore.PendingWrites, [projectUrl, writeId], cloneDeep({
+            builder: pureBuilder,
+            snapshot: pendingSnapshot,
+            editions,
+            addedOn: Date.now()
+        }));
 
     updateCacheStore(['DatabaseStore', 'PendingWrites', 'DatabaseStats']);
     notifyDatabaseNodeChanges(builder, [...pathChanges]);
@@ -654,7 +697,7 @@ export const addPendingWrites = async (builder, writeId, result) => {
 export const removePendingWrite = async (builder, writeId, revert) => {
     await awaitStore();
     const { projectUrl, dbUrl, dbName } = builder;
-    const pendingData = getLodash(CacheStore.PendingWrites, [projectUrl, writeId]);
+    const pendingData = grab(CacheStore.PendingWrites, [projectUrl, writeId]);
     const { io } = Scoped.ReleaseCacheData;
 
     if (!pendingData) return;
@@ -663,16 +706,16 @@ export const removePendingWrite = async (builder, writeId, revert) => {
     if (revert) {
         await Promise.all(pendingData.editions.map(async ([access_id, [b4Doc, afDoc], path]) => {
             if (io) {
-                RevertMutation(getLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'instance', access_id]));
+                RevertMutation(grab(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'instance', access_id]));
             } else {
                 await useFS(builder, access_id, 'database')(async fs => {
                     const colObj = await fs.find(LIMITER_DATA(path), access_id, ['value'])
-                        .then(v => deserializeBSON(v.value))
+                        .then(v => DatastoreParser.decode(v.value))
                         .catch(() => null);
                     if (!colObj) return;
                     RevertMutation(colObj);
                     await fs.set(LIMITER_DATA(path), access_id, {
-                        value: serializeToBase64(colObj),
+                        value: DatastoreParser.encode(colObj),
                         touched: Date.now(),
                         size: colObj.size
                     });
@@ -717,7 +760,7 @@ export const removePendingWrite = async (builder, writeId, revert) => {
         }));
     }
 
-    unsetLodash(CacheStore.PendingWrites, [projectUrl, writeId]);
+    unpoke(CacheStore.PendingWrites, [projectUrl, writeId]);
     updateCacheStore(['PendingWrites', 'DatabaseStore', 'DatabaseStats']);
     notifyDatabaseNodeChanges(builder, [...pathChanges]);
 };
@@ -768,19 +811,19 @@ const snipDocument = (data, find, config) => {
     if (returnOnly) {
         output = {};
         (Array.isArray(returnOnly) ? returnOnly : [returnOnly]).filter(v => v).forEach(e => {
-            const thisData = getLodash(data, e);
-            if (thisData) setLodash(output, e, thisData);
+            const thisData = grab(data, e);
+            if (thisData) poke(output, e, thisData);
         });
     } else if (excludeFields) {
         (Array.isArray(excludeFields) ? excludeFields : [excludeFields]).filter(v => v).forEach(e => {
-            if (getLodash(data, e) && e !== '_id') unsetLodash(output, e);
+            if (grab(data, e) && e !== '_id') unpoke(output, e);
         });
     }
 
     getFindFields(find).forEach(field => {
-        if (!getLodash(output, field)) {
-            const mainData = getLodash(data, field);
-            if (mainData !== undefined) setLodash(output, field, mainData);
+        if (!grab(output, field)) {
+            const mainData = grab(data, field);
+            if (mainData !== undefined) poke(output, field, mainData);
         }
     });
 
@@ -850,10 +893,10 @@ const AtomicWriter = {
             !isDate &&
             !isTimestamp
         ) throw `invalid value at $currentDate.${field}, expected any of boolean (true), { $type: "timestamp" } or { $type: "date" } but got ${value}`;
-        setLodash(object, field, isDate ? new Date() : new Timestamp({ t: Math.floor(Date.now() / 1000), i: 0 }));
+        poke(object, field, isDate ? new Date() : new Timestamp({ t: Math.floor(Date.now() / 1000), i: 0 }));
     },
     $inc: (field, value, object) => {
-        const current = getLodash(object, field);
+        const current = grab(object, field);
         if (current === null) {
             console.warn(`cannot use $inc operator on a null value at ${field}`);
             return;
@@ -863,29 +906,29 @@ const AtomicWriter = {
 
         if (!Validator.NUMBER(castedValue)) throw `expected a number at $inc.${field} but got ${value}`;
 
-        setLodash(object, field, Validator.NUMBER(castedCurrent) ? defaultBSON(castedCurrent + castedValue, current) : value);
+        poke(object, field, Validator.NUMBER(castedCurrent) ? defaultBSON(castedCurrent + castedValue, current) : value);
     },
     $min: (field, value, object) => {
-        const current = getLodash(object, field);
+        const current = grab(object, field);
         if (CompareBson.lesser(value, current)) {
-            setLodash(object, field, value);
+            poke(object, field, value);
         }
     },
     $max: (field, value, object) => {
-        const current = getLodash(object, field);
+        const current = grab(object, field);
         if (CompareBson.greater(value, current)) {
-            setLodash(object, field, value);
+            poke(object, field, value);
         }
     },
     $mul: (field, value, object) => {
-        const current = getLodash(object, field);
+        const current = grab(object, field);
         const castedValue = downcastBSON(value);
         const castedCurrent = downcastBSON(current);
 
         if (!Validator.NUMBER(castedValue))
             throw `expected a number at $mul.${field} but got ${value}`;
 
-        setLodash(object, field, Validator.NUMBER(castedCurrent) ? defaultBSON(castedCurrent * castedValue, value) : 0);
+        poke(object, field, Validator.NUMBER(castedCurrent) ? defaultBSON(castedCurrent * castedValue, value) : 0);
     },
     $rename: (field, value, object) => {
         if (!Validator.EMPTY_STRING(value))
@@ -903,7 +946,7 @@ const AtomicWriter = {
             if (!e) throw `empty node for ${field}`;
         });
         const [tipObj, tipSource, tipDest] = destStage.length === 1 ? [object, field, value]
-            : [getLodash(object, destStage.slice(0, -1).join('.')), sourceStage.slice(-1)[0], destStage.slice(-1)[0]];
+            : [grab(object, destStage.slice(0, -1).join('.')), sourceStage.slice(-1)[0], destStage.slice(-1)[0]];
 
         if (tipObj && tipSource in tipObj) {
             tipObj[tipDest] = cloneDeep(tipObj[tipSource]);
@@ -911,16 +954,16 @@ const AtomicWriter = {
         }
     },
     $set: (field, value, object) => {
-        setLodash(object, field, value === undefined ? null : value);
+        poke(object, field, value === undefined ? null : value);
     },
     $setOnInsert: (field, value, object, isNew) => {
         if (isNew) AtomicWriter.$set(field, value, object);
     },
     $unset: (field, _, object) => {
-        unsetLodash(object, field);
+        unpoke(object, field);
     },
     $addToSet: (field, value, object) => {
-        const current = getLodash(object, field);
+        const current = grab(object, field);
         if (Array.isArray(current)) {
             if (
                 Validator.OBJECT(value) &&
@@ -942,7 +985,7 @@ const AtomicWriter = {
     },
     $pop: (field, value, object) => {
         if (![1, -1].includes(value)) throw `expected 1 or -1 at "$pop.${field}" but got ${value}`;
-        const current = getLodash(object, field);
+        const current = grab(object, field);
         if (
             Array.isArray(current) &&
             current.length
@@ -950,7 +993,7 @@ const AtomicWriter = {
     },
     $pull: (field, value, object) => {
         // TODO: issues
-        const current = getLodash(object, field);
+        const current = grab(object, field);
         const isQueryObject = Validator.OBJECT(value);
 
         if (
@@ -972,11 +1015,11 @@ const AtomicWriter = {
                 } catch (_) { }
                 return true;
             });
-            setLodash(object, field, remainingCurrent);
+            poke(object, field, remainingCurrent);
         }
     },
     $push: (field, value, object) => {
-        const current = getLodash(object, field);
+        const current = grab(object, field);
 
         if (Array.isArray(current)) {
             if (Validator.OBJECT(value)) {
@@ -1023,13 +1066,13 @@ const AtomicWriter = {
         if (!Array.isArray(value))
             throw `expected an array at $pullAll.${field}`;
 
-        const current = getLodash(object, field);
+        const current = grab(object, field);
 
         if (Array.isArray(current)) {
             const remainingCurrent = current.filter(v =>
                 !value.some(k => CompareBson.equal(v, k))
             );
-            setLodash(object, field, remainingCurrent);
+            poke(object, field, remainingCurrent);
         }
     }
 };

package/src/products/database/bson.js

@@ -1,4 +1,5 @@
-import { deserialize, serialize } from "bson/lib/bson.rn.cjs";
+import { cloneDeep } from "lodash";
+import { deserialize, serialize } from "../../vendor/bson";
 import { Buffer } from "buffer";
 
 export const deserializeBSON = (data, cast) => {
@@ -13,4 +14,45 @@ export const deserializeBSON = (data, cast) => {
     });
 };
 
-export const serializeToBase64 = doc => Buffer.from(serialize(doc)).toString('base64');
+export const serializeToBase64 = doc => Buffer.from(serialize(doc)).toString('base64');
+
+export const DatastoreParser = {
+    encode: (obj) => {
+        obj = cloneDeep(obj);
+        const { command, config } = obj;
+
+        const serializeQuery = (e) =>
+            ['find', 'findOne'].forEach(n => {
+                if (e?.[n]) e[n] = serializeToBase64({ _: e[n] });
+            });
+
+        if (command) serializeQuery(command);
+        if (config) {
+            if (config.extraction)
+                (Array.isArray(config.extraction) ? config.extraction : [config.extraction]).forEach(e => {
+                    serializeQuery(e);
+                });
+        }
+        if (obj.data) obj.data = serializeToBase64({ _: obj.data });
+        return obj;
+    },
+    decode: (obj, cast = true) => {
+        obj = cloneDeep(obj);
+        const { command, config } = obj;
+
+        const serializeQuery = (e) =>
+            ['find', 'findOne'].forEach(n => {
+                if (e?.[n]) e[n] = deserializeBSON(e[n], cast)._;
+            });
+
+        if (command) serializeQuery(command);
+        if (config) {
+            if (config.extraction)
+                (Array.isArray(config.extraction) ? config.extraction : [config.extraction]).forEach(e => {
+                    serializeQuery(e);
+                });
+        }
+        if (obj.data) obj.data = deserializeBSON(obj.data, cast)._;
+        return obj;
+    }
+};

package/src/products/database/counter.js

@@ -1,7 +1,6 @@
-import getLodash from "lodash/get";
-import setLodash from 'lodash/set';
 import { CacheStore } from "../../helpers/variables";
-import { serializeToBase64 } from "./bson";
+import { grab, poke } from "poke-object";
+import { calculateObjectSize } from '../../vendor/bson';
 
 export const incrementDatabaseSize = (builder, path, size) => incrementDatabaseSizeCore(CacheStore.DatabaseStats, builder, path, size);
 
@@ -11,8 +10,8 @@ export const incrementDatabaseSizeCore = (baseObj, builder, path, size = 0) => {
 
     const node = [projectUrl, dbUrl, dbName, path];
 
-    const b4 = getLodash(baseObj.database, node, 0);
-    setLodash(baseObj.database, node, b4 + size);
+    const b4 = grab(baseObj.database, node, 0);
+    poke(baseObj.database, node, b4 + size);
 }
 
-export const docSize = doc => doc ? serializeToBase64({ _: doc }).length : 0;
+export const docSize = doc => doc ? calculateObjectSize({ _: doc }) : 0;

package/src/products/database/index.js

@@ -2,13 +2,13 @@ import { io } from "socket.io-client";
 import EngineApi from "../../helpers/engine_api";
 import { DatabaseRecordsListener } from "../../helpers/listeners";
 import { deserializeE2E, listenReachableServer, niceTry, serializeE2E } from "../../helpers/peripherals";
-import { awaitStore, buildFetchInterface, buildFetchResult, getReachableServer } from "../../helpers/utils";
+import { awaitStore, buildFetchInterface, buildFetchResult, getReachableServer, updateCacheStore } from "../../helpers/utils";
 import { CacheStore, Scoped } from "../../helpers/variables";
 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 { ObjectId } from "bson/lib/bson.rn.cjs";
+import { ObjectId } from "../../vendor/bson";
 import { guardObject, Validator } from "guard-object";
 import { simplifyCaughtError } from "simplify-error";
 import cloneDeep from "lodash/cloneDeep";
@@ -395,6 +395,7 @@ const countCollection = async (builder, config) => {
             const b4Data = await getCountQuery(builder, accessId).catch(() => null);
 
             if (e?.simpleError) {
+                e.simpleError.ack = true;
                 finalize(undefined, e.simpleError);
             } else if (!disableCache && Validator.NUMBER(b4Data)) {
                 finalize(b4Data);
@@ -552,6 +553,7 @@ const findObject = async (builder, config) => {
                 (thisRecord = [await getRecordData()])[0];
 
             if (e?.simpleError) {
+                e.simpleError.ack = true;
                 finalize(undefined, e?.simpleError);
             } else if (
                 (retrieval === RETRIEVAL.CACHE_NO_AWAIT && !(await getThisRecord())) ||
@@ -622,13 +624,14 @@ const commitData = async (builder, value, type, config) => {
     const writeId = `${Date.now() + ++Scoped.PendingIte}`;
     const isBatchWrite = type === 'batchWrite';
     const shouldCache = (delivery !== DELIVERY.DEFAULT || !disableCache) &&
-        ![DELIVERY.NO_CACHE_AWAIT, DELIVERY.NO_CACHE_NO_AWAIT].includes();
+        ![DELIVERY.NO_CACHE_AWAIT, DELIVERY.NO_CACHE_NO_AWAIT].includes(delivery);
 
     await awaitStore();
     if (shouldCache) {
-        await addPendingWrites(builder, writeId, { value, type, find, config });
+        await addPendingWrites(builder, writeId, { value, type, config: stripUndefined({ disableAuth, stepping }) });
         Scoped.OutgoingWrites[writeId] = true;
-        await Scoped.dispatchingWritesPromise;
+        if (Scoped.dispatchingWritesPromise[projectUrl])
+            await Scoped.dispatchingWritesPromise[projectUrl];
     }
 
     let retries = 0, hasFinalize;
@@ -649,10 +652,11 @@ const commitData = async (builder, value, type, config) => {
             } else reject(b);
             if (hasFinalize || !instantProcess) return;
             hasFinalize = true;
+            if (Scoped.OutgoingWrites[writeId])
+                delete Scoped.OutgoingWrites[writeId];
+
             if (shouldCache) {
                 if (removeCache) removePendingWrite(builder, writeId, revertCache);
-                if (Scoped.OutgoingWrites[writeId])
-                    delete Scoped.OutgoingWrites[writeId];
             }
         };
 
@@ -687,7 +691,8 @@ const commitData = async (builder, value, type, config) => {
         } catch (e) {
             if (e?.simpleError) {
                 console.error(`${type} error (${path}), ${e.simpleError?.message}`);
-                finalize(undefined, e?.simpleError, { removeCache: true, revertCache: true });
+                e.simpleError.ack = true;
+                finalize(undefined, e.simpleError, { removeCache: true, revertCache: true });
             } else if (delivery === DELIVERY.NO_CACHE_NO_AWAIT) {
                 finalize(undefined, simplifyCaughtError(e).simpleError);
             } else if (retries > maxRetries) {
@@ -717,9 +722,9 @@ const commitData = async (builder, value, type, config) => {
 };
 
 export const trySendPendingWrite = (projectUrl) => {
-    if (Scoped.dispatchingWritesPromise) return;
+    if (Scoped.dispatchingWritesPromise[projectUrl]) return;
 
-    Scoped.dispatchingWritesPromise = new Promise(async resolve => {
+    Scoped.dispatchingWritesPromise[projectUrl] = new Promise(async resolve => {
         const sortedWrite = Object.entries(CacheStore.PendingWrites[projectUrl] || {})
             .filter(([k]) => !Scoped.OutgoingWrites[k])
             .sort((a, b) => a[1].addedOn - b[1].addedOn);
@@ -727,12 +732,18 @@ export const trySendPendingWrite = (projectUrl) => {
 
         for (const [writeId, { snapshot, builder, attempts = 1 }] of sortedWrite) {
             try {
-                await commitData(builder, snapshot.value, snapshot.type, { ...snapshot.config, delivery: DELIVERY.NO_CACHE_NO_AWAIT });
+                await commitData(
+                    { ...Scoped.InitializedProject[projectUrl], ...builder, find: deserializeBSON(builder.find, true)._ },
+                    deserializeBSON(snapshot.value, true)._,
+                    snapshot.type,
+                    { ...snapshot.config, delivery: DELIVERY.NO_CACHE_NO_AWAIT }
+                );
+
                 delete CacheStore.PendingWrites[projectUrl][writeId];
                 ++resolveCounts;
-            } catch (_) {
+            } catch (err) {
                 const { maxRetries } = builder;
-                if (!maxRetries || attempts >= maxRetries) {
+                if (err?.ack || !maxRetries || attempts >= maxRetries) {
                     delete CacheStore.PendingWrites[projectUrl][writeId];
                     ++resolveCounts;
                 } else if (CacheStore.PendingWrites[projectUrl]?.[writeId]) {
@@ -741,7 +752,10 @@ export const trySendPendingWrite = (projectUrl) => {
             }
         }
         resolve();
-        Scoped.dispatchingWritesPromise = undefined;
+        if (projectUrl in Scoped.dispatchingWritesPromise)
+            delete Scoped.dispatchingWritesPromise[projectUrl];
+        updateCacheStore(['PendingWrites']);
+
         if (
             (sortedWrite.length - resolveCounts) &&
             await getReachableServer(projectUrl)

package/src/products/database/types.js

@@ -1,8 +1,9 @@
+import { guardObject, GuardSignal, niceGuard } from "guard-object";
 
 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;
+export const IS_TIMESTAMP = (t) => niceGuard({ $timestamp: t => t === 'now' || typeof t.$timestamp === 'number' }, t);
 
 export const DOCUMENT_EXTRACTION = (path) => ({ $dynamicValue: path });
 
@@ -11,13 +12,17 @@ export const GEO_JSON = (lat, lng) => ({
     coordinates: [lng, lat],
 });
 
-export const FIND_GEO_JSON = (location, offSetMeters, centerMeters) => ({
-    $nearSphere: {
-        $geometry: {
-            type: "Point",
-            coordinates: location.reverse()
-        },
-        $minDistance: centerMeters || 0,
-        $maxDistance: offSetMeters
-    }
-});
+export const FIND_GEO_JSON = (location, offSetMeters, centerMeters) => {
+    guardObject(GuardSignal.COORDINATE.LAT_LNG_INT).validate(location);
+
+    return {
+        $nearSphere: {
+            $geometry: {
+                type: "Point",
+                coordinates: location.slice(0).reverse()
+            },
+            $minDistance: centerMeters || 0,
+            $maxDistance: offSetMeters
+        }
+    };
+};