react-native-mosquito-transport 0.0.34 → 0.0.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-mosquito-transport",
-  "version": "0.0.34",
+  "version": "0.0.36",
   "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",
@@ -44,4 +44,4 @@
     "react-native-get-random-values": "*",
     "react-native-sha256": "*"
   }
-}
+}

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`;
 
@@ -16,7 +18,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 +30,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);
 };
 
@@ -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,14 +58,14 @@ 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);
         },
         list: async (table, extractions) => {
             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];

package/src/helpers/peripherals.js

@@ -1,10 +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;
 
@@ -59,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;
     });

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');
         }
@@ -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,16 +1,31 @@
 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 { 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;
 
@@ -23,28 +38,38 @@ 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 : {}
         });
 
         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));
 
         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 })
                 )
@@ -62,35 +87,31 @@ 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 sqlite 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;
     });
-    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);