react-native-mosquito-transport 0.0.35 → 0.0.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-mosquito-transport",
-  "version": "0.0.35",
+  "version": "0.0.36",
   "description": "React native javascript sdk for mosquito-transport (https://github.com/brainbehindx/mosquito-transport)",
   "main": "src/index.js",
   "type": "module",

package/src/helpers/fs_manager.js

@@ -1,6 +1,8 @@
+import { deserialize, serialize } from "entity-serializer";
 import { Scoped } from "./variables";
 import { Platform } from "react-native";
 import { Dirs, FileSystem } from "react-native-file-access";
+import { Buffer } from "buffer";
 
 const PARENT_FOLDER = `${Platform.OS === 'android' ? Dirs.DocumentDir.split('/').slice(0, -1).join('/') : Dirs.MainBundleDir}/mosquito_base`;
 
@@ -48,7 +50,7 @@ export const getSystem = (builder) => {
             const path = conjoin(table, primary_key);
             await FileSystem.mkdir(path).catch(() => null);
             await Promise.all(Object.entries(value).map(([k, v]) =>
-                FileSystem.writeFile(joinPath(path, k), JSON.stringify(v), 'utf8')
+                FileSystem.writeFile(joinPath(path, k), serialize(v).toString('base64'), 'base64')
             ));
         },
         delete: (table, primary_key) => FileSystem.unlink(conjoin(table, primary_key)),
@@ -56,7 +58,7 @@ export const getSystem = (builder) => {
             const path = conjoin(table, primary_key);
 
             const value_map = await Promise.all(extractions.map(async node =>
-                [node, JSON.parse(await FileSystem.readFile(joinPath(path, node), 'utf8'))]
+                [node, deserialize(Buffer.from(await FileSystem.readFile(joinPath(path, node), 'base64'), 'base64'))]
             ));
             return Object.fromEntries(value_map);
         },

package/src/helpers/purger.js

@@ -245,7 +245,7 @@ export const purgeRedundantRecords = async (data, builder) => {
     }
 }
 
-const breakDbMap = (obj, callback) =>
+export const breakDbMap = (obj = {}, callback) =>
     Object.entries(obj).forEach(([projectUrl, dbUrlObj]) => {
         Object.entries(dbUrlObj).forEach(([dbUrl, dbNameObj]) => {
             Object.entries(dbNameObj).forEach(([dbName, pathObj]) => {

package/src/helpers/utils.js

@@ -1,15 +1,31 @@
 import { ServerReachableListener, StoreReadyListener } from "./listeners";
 import { CacheStore, Scoped } from "./variables";
 import { serializeE2E } from "./peripherals";
-import { deserializeBSON, serializeToBase64 } from "../products/database/bson";
-import { deserialize } from "entity-serializer";
-import { purgeRedundantRecords } from "./purger";
+import { DatastoreParser } from "../products/database/bson";
+import { deserialize, serialize } from "entity-serializer";
+import { breakDbMap, purgeRedundantRecords } from "./purger";
 import { FS_PATH, getSystem } from "./fs_manager";
+import cloneDeep from "lodash/cloneDeep";
 
 const { FILE_NAME, TABLE_NAME } = FS_PATH;
 
 const CacheKeys = Object.keys(CacheStore);
 
+const prefillDatastore = (obj, caller) => {
+    obj = cloneDeep(obj);
+    breakDbMap(obj, (_projectUrl, _dbUrl, _dbName, _path, value) => {
+        Object.entries(value.instance).forEach(([access_id, obj]) => {
+            value.instance[access_id] = caller(obj);
+        });
+        Object.entries(value.episode).forEach(([_access_id, limitObj]) => {
+            Object.entries(limitObj).forEach(([limit, obj]) => {
+                limitObj[limit] = caller(obj);
+            });
+        });
+    });
+    return obj;
+};
+
 export const updateCacheStore = async (node) => {
     const { io, promoteCache } = Scoped.ReleaseCacheData;
 
@@ -22,14 +38,24 @@ export const updateCacheStore = async (node) => {
         ...restStore
     } = CacheStore;
 
+    const minimizePendingWrite = () => {
+        const obj = cloneDeep(PendingWrites);
+        Object.values(obj).forEach(e => {
+            Object.values(e).forEach(b => {
+                if ('editions' in b) delete b.editions;
+            });
+        });
+        return obj;
+    }
+
     if (io) {
         const txt = JSON.stringify({
             AuthStore,
             EmulatedAuth,
             PendingAuthPurge,
             ...promoteCache ? {
-                DatabaseStore: serializeToBase64(DatabaseStore),
-                PendingWrites: serializeToBase64(PendingWrites)
+                DatabaseStore: prefillDatastore(DatabaseStore, DatastoreParser.encode),
+                PendingWrites: minimizePendingWrite()
             } : {},
             ...promoteCache ? restStore : {}
         });
@@ -43,7 +69,7 @@ export const updateCacheStore = async (node) => {
         if (!updationKey.length) return;
         await Promise.all(
             updationKey
-                .map(v => [v, v === 'PendingWrites' ? serializeToBase64(CacheStore[v]) : CacheStore[v]])
+                .map(v => [v, v === 'PendingWrites' ? minimizePendingWrite() : CacheStore[v]])
                 .map(([ref, value]) =>
                     getSystem(FILE_NAME).set(TABLE_NAME, ref, { value })
                 )
@@ -61,27 +87,27 @@ export const releaseCacheStore = async (builder) => {
     try {
         if (io) {
             data = JSON.parse((await io.input()) || '{}');
-        } else {
-            try {
-                const query = await getSystem(FILE_NAME).list(TABLE_NAME, ['value']).catch(() => []);
-                data = Object.fromEntries(
-                    query.map(([ref, { value }]) =>
-                        [ref, value]
-                    )
+
+            if (data.DatabaseStore)
+                data.DatabaseStore = prefillDatastore(
+                    data.DatabaseStore,
+                    r => DatastoreParser.decode(r, false)
                 );
-            } catch (error) {
-                console.error('initializeCache data release err:', error);
-            }
+        } else {
+            const query = await getSystem(FILE_NAME).list(TABLE_NAME, ['value']).catch(() => []);
+            data = Object.fromEntries(
+                query.map(([ref, { value }]) =>
+                    [ref, value]
+                )
+            );
         }
         await purgeRedundantRecords(data, builder);
     } catch (e) {
-        console.error('initializeCache data err:', e);
+        console.error('releaseCacheStore data err:', e);
     }
 
     Object.entries(data).forEach(([k, v]) => {
-        if (['DatabaseStore', 'PendingWrites'].includes(k)) {
-            CacheStore[k] = deserializeBSON(v);
-        } else CacheStore[k] = v;
+        CacheStore[k] = v;
     });
     Object.entries(CacheStore.AuthStore).forEach(([key, value]) => {
         Scoped.AuthJWTToken[key] = value?.token;

package/src/products/database/accessor.js

@@ -8,7 +8,7 @@ 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";
 
@@ -100,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
             });
@@ -195,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;
 
@@ -283,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);
 };
 
@@ -421,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
                     });
                 })
@@ -654,7 +653,7 @@ export const addPendingWrites = async (builder, writeId, result) => {
     });
     const pureBuilder = {};
 
-    ['path', 'dbUrl', 'dbName', 'find', 'extraHeaders'].forEach(v => {
+    ['path', 'dbUrl', 'dbName', 'find', 'extraHeaders', 'maxRetries'].forEach(v => {
         if (builder[v] !== undefined) pureBuilder[v] = builder[v];
     });
     pureBuilder.find = serializeToBase64({ _: pureBuilder.find });
@@ -711,12 +710,12 @@ export const removePendingWrite = async (builder, writeId, revert) => {
             } 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, true))
+                        .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
                     });

package/src/products/database/bson.js

@@ -1,3 +1,4 @@
+import { cloneDeep } from "lodash";
 import { deserialize, serialize } from "../../vendor/bson";
 import { Buffer } from "buffer";
 
@@ -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/index.js

@@ -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())) ||
@@ -689,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) {
@@ -738,9 +741,9 @@ export const trySendPendingWrite = (projectUrl) => {
 
                 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]) {