react-native-mosquito-transport 0.0.33 → 0.0.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-mosquito-transport",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "description": "React native javascript sdk for mosquito-transport (https://github.com/brainbehindx/mosquito-transport)",
   "main": "src/index.js",
   "type": "module",
@@ -28,11 +28,11 @@
   "homepage": "https://github.com/brainbehindx/react-native-mosquito-transport#readme",
   "dependencies": {
     "@turf/turf": "^7.2.0",
-    "bson": "^6.8.0",
     "buffer": "^6.0.3",
     "entity-serializer": "^1.0.3",
     "guard-object": "^1.1.4",
     "lodash": "^4.17.21",
+    "poke-object": "^1.0.1",
     "simplify-error": "^1.0.1",
     "socket.io-client": "^4.8.1",
     "subscription-listener": "^1.1.2",
@@ -40,8 +40,8 @@
   },
   "peerDependencies": {
     "react-native": "*",
-    "react-native-fs": "*",
-    "react-native-sha256": "*",
-    "react-native-get-random-values": "*"
+    "react-native-file-access": "*",
+    "react-native-get-random-values": "*",
+    "react-native-sha256": "*"
   }
-}
+}

package/src/helpers/fs_manager.js

@@ -1,8 +1,8 @@
 import { Scoped } from "./variables";
 import { Platform } from "react-native";
-import { writeFile, mkdir, MainBundlePath, readFile, unlink, DocumentDirectoryPath, readdir } from "react-native-fs";
+import { Dirs, FileSystem } from "react-native-file-access";
 
-const PARENT_FOLDER = `${Platform.OS === 'android' ? DocumentDirectoryPath.split('/').slice(0, -1).join('/') : MainBundlePath}/mosquito_base`;
+const PARENT_FOLDER = `${Platform.OS === 'android' ? Dirs.DocumentDir.split('/').slice(0, -1).join('/') : Dirs.MainBundleDir}/mosquito_base`;
 
 /**
  * this method linearize read/write for individual access_id on the file system ensuring consistency across concurrent operations
@@ -16,7 +16,7 @@ export const useFS = (builder, access_id, node) => async (task) => {
     const { projectUrl, dbUrl, dbName } = builder;
     const nodeId = typeof builder === 'string' ? `${builder}_${access_id}` : `${projectUrl}_${dbUrl}_${dbName}_${access_id}`;
 
-    const thatProcess = Scoped.linearSqliteProcess[node][nodeId];
+    const thatProcess = Scoped.linearFsProcess[node][nodeId];
 
     const thisPromise = new Promise(async (resolve, reject) => {
         try {
@@ -28,12 +28,12 @@ export const useFS = (builder, access_id, node) => async (task) => {
             console.error('useFS err:', error, ' builder:', builder);
             reject(error);
         } finally {
-            if (Scoped.linearSqliteProcess[node][nodeId] === thisPromise)
-                delete Scoped.linearSqliteProcess[node][nodeId];
+            if (Scoped.linearFsProcess[node][nodeId] === thisPromise)
+                delete Scoped.linearFsProcess[node][nodeId];
         }
     });
 
-    Scoped.linearSqliteProcess[node][nodeId] = thisPromise;
+    Scoped.linearFsProcess[node][nodeId] = thisPromise;
     return (await thisPromise);
 };
 
@@ -46,24 +46,24 @@ export const getSystem = (builder) => {
     return {
         set: async (table, primary_key, value) => {
             const path = conjoin(table, primary_key);
-            await mkdir(path).catch(() => null);
+            await FileSystem.mkdir(path).catch(() => null);
             await Promise.all(Object.entries(value).map(([k, v]) =>
-                writeFile(joinPath(path, k), JSON.stringify(v), 'utf8')
+                FileSystem.writeFile(joinPath(path, k), JSON.stringify(v), 'utf8')
             ));
         },
-        delete: (table, primary_key) => unlink(conjoin(table, primary_key)),
+        delete: (table, primary_key) => FileSystem.unlink(conjoin(table, primary_key)),
         find: async (table, primary_key, extractions) => {
             const path = conjoin(table, primary_key);
 
             const value_map = await Promise.all(extractions.map(async node =>
-                [node, JSON.parse(await readFile(joinPath(path, node)), 'utf8')]
+                [node, JSON.parse(await FileSystem.readFile(joinPath(path, node), 'utf8'))]
             ));
             return Object.fromEntries(value_map);
         },
         list: async (table, extractions) => {
-            const names = await readdir(conjoin(table));
+            const names = await FileSystem.ls(conjoin(table));
             const list_data = await Promise.all(names.map(async primary_key => {
-                const obj = await system.find(table, primary_key, extractions)
+                const obj = await getSystem(builder).find(table, primary_key, extractions)
                     .catch(() => null);
                 if (!obj) return;
                 return [primary_key, obj];
@@ -74,7 +74,7 @@ export const getSystem = (builder) => {
     };
 };
 
-function purifyFilepath(filename) {
+export function purifyFilepath(filename) {
     if (!filename || typeof filename !== 'string')
         throw `invalid filename:${filename}`;
 

package/src/helpers/peripherals.js

@@ -1,9 +1,10 @@
 import { Buffer } from "buffer";
 import { ServerReachableListener } from "./listeners";
 import naclPkg from 'tweetnacl';
-import getLodash from "lodash/get";
 import { deserialize, serialize } from "entity-serializer";
 import { sha256 } from 'react-native-sha256';
+import { purifyFilepath } from "./fs_manager";
+import { grab } from "poke-object";
 
 const { box, randomBytes } = naclPkg;
 
@@ -58,8 +59,8 @@ export const shuffleArray = (n) => {
 
 export function sortArrayByObjectKey(arr = [], key) {
     return arr.sort(function (a, b) {
-        const left = getLodash(a, key),
-            right = getLodash(b, key);
+        const left = grab(a, key),
+            right = grab(b, key);
 
         return (left > right) ? 1 : (left < right) ? -1 : 0;
     });
@@ -67,8 +68,7 @@ export function sortArrayByObjectKey(arr = [], key) {
 
 export async function niceHash(str = '') {
     const hash = Buffer.from(await sha256(str), 'hex').toString('base64');
-    if (hash.length > str.length) return encodeBinary(str);
-    return hash;
+    return purifyFilepath(hash);
 };
 
 export const sameInstance = (var1, var2) => {

package/src/helpers/purger.js

@@ -1,8 +1,8 @@
 import { Validator } from "guard-object";
 import { incrementDatabaseSizeCore } from "../products/database/counter";
 import { incrementFetcherSizeCore } from "../products/http_callable/counter";
-import unsetLodash from 'lodash/unset';
 import { FS_PATH, getSystem } from "./fs_manager";
+import { unpoke } from "poke-object";
 
 const { LIMITER_DATA, LIMITER_RESULT, DB_COUNT_QUERY, FETCH_RESOURCES } = FS_PATH;
 
@@ -86,13 +86,13 @@ export const purgeRedundantRecords = async (data, builder) => {
             }) => {
                 const { projectUrl, dbUrl, dbName } = builder;
                 if (isCount) {
-                    unsetLodash(data.DatabaseCountResult, [projectUrl, dbUrl, dbName, path, access_id]);
+                    unpoke(data.DatabaseCountResult, [projectUrl, dbUrl, dbName, path, access_id]);
                 } else {
                     incrementDatabaseSizeCore(data.DatabaseStats, builder, path, -size);
                     if (isEpisode) {
-                        unsetLodash(data.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'episode', access_id, limit]);
+                        unpoke(data.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'episode', access_id, `${limit}`]);
                     } else {
-                        unsetLodash(data.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'instance', access_id]);
+                        unpoke(data.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'instance', access_id]);
                     }
                 }
             });
@@ -122,7 +122,7 @@ export const purgeRedundantRecords = async (data, builder) => {
             console.warn(`purging ${cuts} of ${redundantFetchRanking.length} fetcher entities`);
             redundantFetchRanking.slice(0, cuts).forEach(({ access_id, data: { size }, projectUrl }) => {
                 incrementFetcherSizeCore(data.DatabaseStats, projectUrl, -size);
-                unsetLodash(data.FetchedStore, [projectUrl, access_id]);
+                unpoke(data.FetchedStore, [projectUrl, access_id]);
             });
             console.log('fetcher purging complete');
         }

package/src/helpers/utils.js

@@ -2,7 +2,6 @@ import { ServerReachableListener, StoreReadyListener } from "./listeners";
 import { CacheStore, Scoped } from "./variables";
 import { serializeE2E } from "./peripherals";
 import { deserializeBSON, serializeToBase64 } from "../products/database/bson";
-import { trySendPendingWrite } from "../products/database";
 import { deserialize } from "entity-serializer";
 import { purgeRedundantRecords } from "./purger";
 import { FS_PATH, getSystem } from "./fs_manager";
@@ -37,7 +36,7 @@ export const updateCacheStore = async (node) => {
 
         io.output(txt, node);
     } else {
-        // use sqlite
+        // use fs
         const exclusion = ['DatabaseStore', 'DatabaseCountResult', 'FetchedStore'];
         const updationKey = (node ? Array.isArray(node) ? node : [node] : CacheKeys).filter(v => !exclusion.includes(v));
 
@@ -71,7 +70,7 @@ export const releaseCacheStore = async (builder) => {
                     )
                 );
             } catch (error) {
-                console.error('initializeCache sqlite data release err:', error);
+                console.error('initializeCache data release err:', error);
             }
         }
         await purgeRedundantRecords(data, builder);
@@ -87,10 +86,6 @@ export const releaseCacheStore = async (builder) => {
     Object.entries(CacheStore.AuthStore).forEach(([key, value]) => {
         Scoped.AuthJWTToken[key] = value?.token;
     });
-    Object.keys(CacheStore.PendingWrites).forEach(projectUrl => {
-        if (Scoped.IS_CONNECTED[projectUrl])
-            trySendPendingWrite(projectUrl);
-    });
     Scoped.IsStoreReady = true;
     StoreReadyListener.dispatch('_', 'ready');
 };

package/src/helpers/values.js

@@ -12,7 +12,7 @@ export const RETRIEVAL = {
 
 export const DELIVERY = {
     DEFAULT: 'default',
-    CACHE_AWAIT: 'cache-await',
+    CACHE_AWAIT: 'cache-await', // TODO: remove
     CACHE_NO_AWAIT: 'cache-no-await',
     NO_CACHE_NO_AWAIT: 'no-cache-no-await',
     NO_CACHE_AWAIT: 'no-cache-await'

package/src/helpers/variables.js

@@ -20,21 +20,14 @@ export const Scoped = {
     /**
      * @type {Promise<any> | undefined}
      */
-    dispatchingWritesPromise: undefined,
-    linearSqliteProcess: {
+    dispatchingWritesPromise: {},
+    linearFsProcess: {
         database: {},
         dbQueryCount: {},
         httpFetch: {}
     }
 };
 
-export const SqliteCollective = {
-    openedDb: {},
-    openedDbProcess: {},
-    closeDbPromises: {},
-    openedDbReducerTimer: {}
-};
-
 export const CacheStore = {
     DatabaseStore: {},
     DatabaseCountResult: {},

package/src/index.js

@@ -82,7 +82,7 @@ class RNMT {
                 if (queuedToken) updateMountedToken(queuedToken.token);
                 ServerReachableListener.dispatch(projectUrl, true);
                 awaitStore().then(() => {
-                    trySendPendingWrite(projectUrl);
+                    if (isConnected) trySendPendingWrite(projectUrl);
                 });
             };
             const onDisconnect = () => {

package/src/products/auth/index.js

@@ -237,7 +237,7 @@ const purgeCache = (url, isMain) => {
         'AuthStore',
         'PendingWrites'
     ].forEach(e => {
-        if (e && CacheStore[e][url]) delete CacheStore[e][url];
+        if (e && CacheStore[e]?.[url]) delete CacheStore[e][url];
     });
     TokenRefreshListener.dispatch(url);
     triggerAuthToken(url);

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 { 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,15 +62,17 @@ 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 {
         return useFS(builder, access_id, 'dbQueryCount')(async fs => {
-            const { value } = await fs.find(DB_COUNT_QUERY(path), access_id, ['value']);
-            await fs.set(DB_COUNT_QUERY(path), access_id, { touched: Date.now() });
-            return value;
-        }).catch(() => undefined);
+            const data = await fs.find(DB_COUNT_QUERY(path), access_id, ['value']).catch(() => null);
+            if (data) {
+                await fs.set(DB_COUNT_QUERY(path), access_id, { touched: Date.now() });
+                return data.value;
+            }
+        });
     }
 }
 
@@ -132,8 +132,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);
@@ -155,8 +155,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']);
 };
 
@@ -219,7 +219,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)];
@@ -227,7 +227,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;
 
@@ -387,19 +387,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(
@@ -408,7 +409,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()
                         )
                     )
@@ -638,12 +639,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'].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]);
@@ -652,7 +698,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;
@@ -661,11 +707,11 @@ 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 => deserializeBSON(v.value, true))
                         .catch(() => null);
                     if (!colObj) return;
                     RevertMutation(colObj);
@@ -715,7 +761,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]);
 };
@@ -766,19 +812,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);
         }
     });
 
@@ -848,10 +894,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;
@@ -861,29 +907,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))
@@ -901,7 +947,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]);
@@ -909,16 +955,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) &&
@@ -940,7 +986,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
@@ -948,7 +994,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 (
@@ -970,11 +1016,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)) {
@@ -1021,13 +1067,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,4 @@
-import { deserialize, serialize } from "bson/lib/bson.rn.cjs";
+import { deserialize, serialize } from "../../vendor/bson";
 import { Buffer } from "buffer";
 
 export const deserializeBSON = (data, cast) => {