react-native-mosquito-transport 0.0.22 → 0.0.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-mosquito-transport",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "description": "React native javascript sdk for mosquito-transport (https://github.com/brainbehindx/mosquito-transport)",
   "main": "src/index.js",
   "type": "module",
@@ -33,8 +33,9 @@
     "entity-serializer": "^1.0.2",
     "guard-object": "^1.1.4",
     "lodash": "^4.17.21",
+    "react-native-file-access": "^3.1.1",
     "react-native-get-random-values": "^1.9.0",
-    "react-native-hash": "^3.0.3",
+    "react-native-sha256": "^1.4.10",
     "simplify-error": "^1.0.1",
     "socket.io-client": "^4.6.2",
     "subscription-listener": "^1.1.2",

package/src/helpers/fs_manager.js

@@ -0,0 +1,46 @@
+import { Platform } from "react-native";
+import { Buffer } from 'buffer';
+import { deserialize, serialize } from 'entity-serializer';
+import { Dirs, FileSystem } from 'react-native-file-access';
+
+const MAX_INLINE_BLOB = 1024;
+
+const DIR_PATH = `${Platform.OS === 'android' ? Dirs.DatabaseDir : Dirs.MainBundleDir}/MOSQUITO`;
+const resolvePath = (path = '') => `${DIR_PATH}/${path.startsWith('/') ? path : '/' + path}`;
+
+const DIR_CREATION_PROMISE = FileSystem.mkdir(DIR_PATH);
+
+const fsWrite = async (path, data) => {
+    await DIR_CREATION_PROMISE;
+    return FileSystem.writeFile(resolvePath(path), data instanceof Buffer ? data.toString('base64') : data, 'base64');
+}
+
+const fsRead = async (path) => {
+    await DIR_CREATION_PROMISE;
+    return Buffer.from(await FileSystem.readFile(resolvePath(path), 'base64'), 'base64');
+}
+
+export const getStoreID = (db_filename, table, primary_key) => `${table}_${primary_key}_${db_filename}.blob`;
+
+export const deleteBigData = (store_id) => FileSystem.unlink(resolvePath(store_id));
+
+export const handleBigData = async (store_id, data) => {
+    const bufData = serialize(data);
+    if (bufData.byteLength <= MAX_INLINE_BLOB) {
+        return serialize([bufData]).toString('base64');
+    }
+    await fsWrite(store_id, bufData);
+    return serialize([undefined, store_id]).toString('base64');
+};
+
+export const parseBigData = async (result) => {
+    const [inline, store_id] = deserialize(Buffer.from(result, 'base64'));
+    if (store_id) {
+        try {
+            return deserialize(await fsRead(store_id));
+        } catch (error) {
+            throw `Referenced local file is either corrupted or deleted, Error: ${error}`;
+        }
+    }
+    return deserialize(inline);
+};

package/src/helpers/peripherals.js

@@ -3,7 +3,7 @@ import { ServerReachableListener } from "./listeners";
 import naclPkg from 'tweetnacl';
 import getLodash from "lodash/get";
 import { deserialize, serialize } from "entity-serializer";
-import { CONSTANTS, JSHash } from 'react-native-hash';
+import { sha256 } from 'react-native-sha256';
 
 const { box, randomBytes } = naclPkg;
 
@@ -65,7 +65,7 @@ export function sortArrayByObjectKey(arr = [], key) {
 };
 
 export async function niceHash(str = '') {
-    const hash = await JSHash(str, CONSTANTS.HashAlgorithms.md5);
+    const hash = await sha256(str);
     if (hash.length > str.length) return encodeBinary(str);
     return hash;
 };

package/src/helpers/purger.js

@@ -3,6 +3,7 @@ import { Validator } from "guard-object";
 import { incrementDatabaseSizeCore } from "../products/database/counter";
 import { incrementFetcherSizeCore } from "../products/http_callable/counter";
 import unsetLodash from 'lodash/unset';
+import { deleteBigData, getStoreID } from "./fs_manager";
 
 const { LIMITER_DATA, LIMITER_RESULT, DB_COUNT_QUERY, FETCH_RESOURCES } = SQLITE_PATH;
 
@@ -156,7 +157,7 @@ export const purgeRedundantRecords = async (data, builder) => {
 
                                 const [instanceData, resultData] = await Promise.all([
                                     sqlite.executeSql(`SELECT access_id, touched, size FROM ${LIMITER_DATA(path)}`),
-                                    sqlite.executeSql(`SELECT access_id-limit, touched, size FROM ${LIMITER_RESULT(path)}`)
+                                    sqlite.executeSql(`SELECT access_id_limiter, touched, size FROM ${LIMITER_RESULT(path)}`)
                                 ]).then(r =>
                                     r.map(v => v[0].rows.raw())
                                 );
@@ -178,19 +179,24 @@ export const purgeRedundantRecords = async (data, builder) => {
                     let cuts = 0;
 
                     for (let i = 0; i < redundantDbRanking.length; i++) {
-                        sizer -= redundantDbRanking[i][0].size || 0;
+                        sizer -= (redundantDbRanking[i][0].size || 0);
                         ++cuts;
                         if (sizer < newSize) break;
                     }
 
                     console.warn(`purging ${cuts} of ${redundantDbRanking.length} db entities`);
                     await Promise.all(redundantDbRanking.slice(0, cuts).map(async ([v, { builder, isCounter, path }]) => {
-                        const sqlite = await openDB(builder);
+                        let db_filename;
+                        const sqlite = await openDB(builder, n => db_filename = n);
                         try {
-                            const table = (isCounter ? DB_COUNT_QUERY : 'access_id-limit' in v ? LIMITER_RESULT : LIMITER_DATA)(path);
-                            const id_field = 'access_id-limit' in v ? 'access_id-limit' : 'access_id';
+                            const table = (isCounter ? DB_COUNT_QUERY : 'access_id_limiter' in v ? LIMITER_RESULT : LIMITER_DATA)(path);
+                            const id_field = 'access_id_limiter' in v ? 'access_id_limiter' : 'access_id';
+                            const primary_key = v[id_field];
 
-                            await sqlite.executeSql(SQLITE_COMMANDS.DELETE_ROW(table, `${id_field} = ?`), [v[id_field]]);
+                            await Promise.all([
+                                sqlite.executeSql(SQLITE_COMMANDS.DELETE_ROW(table, `${id_field} = ?`), [primary_key]),
+                                deleteBigData(getStoreID(db_filename, table, primary_key)).catch(() => null)
+                            ]);
                             if (!isCounter) incrementDatabaseSizeCore(data.DatabaseStats, builder, path, -v.size);
                         } catch (error) {
                             console.log('db redundantClearing err:', error);
@@ -223,16 +229,21 @@ export const purgeRedundantRecords = async (data, builder) => {
                     let cuts = 0;
 
                     for (let i = 0; i < redundantFetchRanking.length; i++) {
-                        sizer -= redundantFetchRanking[i][0].size || 0;
+                        sizer -= (redundantFetchRanking[i][0].size || 0);
                         ++cuts;
                         if (sizer < newSize) break;
                     }
 
                     console.warn(`purging ${cuts} of ${redundantFetchRanking.length} fetcher entities`);
                     await Promise.all(redundantFetchRanking.slice(0, cuts).map(async ([v, projectUrl]) => {
-                        const sqlite = await openDB(FETCH_RESOURCES(projectUrl));
+                        let db_filename;
+                        const sqlite = await openDB(FETCH_RESOURCES(projectUrl), n => db_filename = n);
+
                         try {
-                            await sqlite.executeSql(SQLITE_COMMANDS.DELETE_ROW('main', 'access_id = ?'), [v.access_id]);
+                            await Promise.all([
+                                sqlite.executeSql(SQLITE_COMMANDS.DELETE_ROW('main', 'access_id = ?'), [v.access_id]),
+                                deleteBigData(getStoreID(db_filename, 'main', v.access_id)).catch(() => null)
+                            ]);
                             incrementFetcherSizeCore(data.DatabaseStats, projectUrl, -v.size);
                         } catch (error) {
                             console.log('fetcher redundantClearing err:', error);

package/src/helpers/sqlite_manager.js

@@ -3,6 +3,7 @@ import { Scoped, SqliteCollective } from './variables';
 import { niceHash } from './peripherals';
 
 enablePromise(true);
+let sqliteKeyHash;
 
 /**
  * this method implement a centralize approach for opening and closing of sqlite database to ensure consistency across multiple task opening and closing the database in diferent order
@@ -10,7 +11,7 @@ enablePromise(true);
  * @param {string} name 
  * @returns {Promise<import('react-native-sqlite-storage').SQLiteDatabase>}
  */
-export const openDB = async (name) => {
+export const openDB = async (name, onName) => {
 
     if (name?.projectUrl) {
         const { projectUrl, dbUrl, dbName } = name;
@@ -19,11 +20,15 @@ export const openDB = async (name) => {
 
     const { sqliteKey } = Scoped.ReleaseCacheData;
 
-    if (sqliteKey) name = `${niceHash(sqliteKey)}__${name}`;
+    if (sqliteKey) {
+        const thisHash = await (sqliteKeyHash || (sqliteKeyHash = niceHash(sqliteKey)));
+        name = `${thisHash}__${name}`;
+    }
+    onName?.(name);
 
     if (!SqliteCollective.openedDb[name]) {
         SqliteCollective.openedDbProcess[name] = 0;
-        SqliteCollective.openedDb[name] = (SqliteCollective.closeDbPromises[name] || Promise.resolve()).finally(() =>
+        SqliteCollective.openedDb[name] = Promise.allSettled([SqliteCollective.closeDbPromises[name] || Promise.resolve()]).then(() =>
             openDatabase({
                 location: 'default',
                 name,
@@ -91,13 +96,14 @@ export const openDB = async (name) => {
  * @param {any} builder 
  * @param {string} access_id 
  * @param {'database' | 'dbQueryCount' | 'httpFetch'} node
- * @returns {(task: (sqlite: import("react-native-sqlite-storage").SQLiteDatabase) => Promise<{any}> )=> Promise<{any}>}
+ * @returns {(task: (sqlite: import("react-native-sqlite-storage").SQLiteDatabase, db_filename: string) => Promise<{any}> )=> Promise<{any}>}
  */
 export const useSqliteLinearAccessId = (builder, access_id, node) => async (task) => {
     const { projectUrl, dbUrl, dbName } = builder;
     const nodeId = typeof builder === 'string' ? `${builder}_${access_id}` : `${projectUrl}_${dbUrl}_${dbName}_${access_id}`;
+    let db_filename;
 
-    const sqlite = await openDB(builder);
+    const sqlite = await openDB(builder, n => db_filename = n);
 
     const thatProcess = Scoped.linearSqliteProcess[node][nodeId];
 
@@ -106,7 +112,7 @@ export const useSqliteLinearAccessId = (builder, access_id, node) => async (task
             if (thatProcess !== undefined) await thatProcess;
         } catch (_) { }
         try {
-            resolve(await task(sqlite));
+            resolve(await task(sqlite, db_filename));
         } catch (error) {
             console.error('useSqliteLinearAccessId err:', error);
             reject(error);
@@ -124,10 +130,10 @@ export const useSqliteLinearAccessId = (builder, access_id, node) => async (task
 export const SQLITE_PATH = {
     FILE_NAME: 'MOSQUITO_TRANSPORT.db',
     TABLE_NAME: 'MT_MAIN',
-    LIMITER_RESULT: path => `"${encodeURIComponent(path)}-LIMITER_RESULT"`,
-    LIMITER_DATA: path => `"${encodeURIComponent(path)}-LIMITER_DATA"`,
-    DB_COUNT_QUERY: path => `"${encodeURIComponent(path)}-DB_COUNT_QUERY"`,
-    FETCH_RESOURCES: projectUrl => `FETCH_RESOURCES-${encodeURIComponent(projectUrl)}.db`
+    LIMITER_RESULT: path => `"${encodeURIComponent(path)}_LIMITER_RESULT"`,
+    LIMITER_DATA: path => `"${encodeURIComponent(path)}_LIMITER_DATA"`,
+    DB_COUNT_QUERY: path => `"${encodeURIComponent(path)}_DB_COUNT_QUERY"`,
+    FETCH_RESOURCES: projectUrl => `FETCH_RESOURCES_${encodeURIComponent(projectUrl)}.db`
 };
 
 export const SQLITE_COMMANDS = {

package/src/helpers/utils.js

@@ -6,6 +6,7 @@ import { trySendPendingWrite } from "../products/database";
 import { deserialize } from "entity-serializer";
 import { openDB, SQLITE_COMMANDS, SQLITE_PATH } from "./sqlite_manager";
 import { purgeRedundantRecords } from "./purger";
+import { getStoreID, handleBigData, parseBigData } from "./fs_manager";
 
 const { FILE_NAME, TABLE_NAME } = SQLITE_PATH;
 
@@ -44,14 +45,18 @@ export const updateCacheStore = (timer = 300, node) => {
 
             if (!updationKey.length) return;
             const sqlite = await openDB(FILE_NAME);
-            await Promise.allSettled(
+            await Promise.all(
                 updationKey
                     .map(v => [v, v === 'PendingWrites' ? serializeToBase64(CacheStore[v]) : CacheStore[v]])
-                    .map(([ref, value]) =>
-                        sqlite.executeSql(SQLITE_COMMANDS.MERGE(TABLE_NAME, ['ref', 'value']), [ref, JSON.stringify(value)])
-                    )
-            );
-            sqlite.close();
+                    .map(async ([ref, value]) => {
+                        const blobData = await handleBigData(getStoreID(FILE_NAME, TABLE_NAME, ref), value);
+                        return sqlite.executeSql(SQLITE_COMMANDS.MERGE(TABLE_NAME, ['ref', 'value']), [ref, blobData]);
+                    })
+            ).catch(err => {
+                console.error('updateCacheStore err:', err);
+            }).finally(() => {
+                sqlite.close();
+            });
         }
     };
 
@@ -71,14 +76,23 @@ export const releaseCacheStore = async (builder) => {
             data = JSON.parse((await io.input()) || '{}');
         } else {
             const sqlite = await openDB(FILE_NAME);
-            await sqlite.executeSql(`CREATE TABLE IF NOT EXISTS ${TABLE_NAME} ( ref TEXT PRIMARY KEY, value TEXT )`).catch(() => null);
-            const [query] = await sqlite.executeSql(`SELECT * FROM ${TABLE_NAME}`);
-            data = Object.fromEntries(query.rows.raw().map(v => [v.ref, JSON.parse(v.value)]));
-            sqlite.close();
+            await sqlite.executeSql(`CREATE TABLE IF NOT EXISTS ${TABLE_NAME} ( ref TEXT PRIMARY KEY, value BLOB )`).catch(() => null);
+            try {
+                const [query] = await sqlite.executeSql(`SELECT * FROM ${TABLE_NAME}`);
+                data = Object.fromEntries(
+                    await Promise.all(query.rows.raw().map(async v =>
+                        [v.ref, await parseBigData(v.value)]
+                    ))
+                );
+            } catch (error) {
+                console.error('initializeCache sqlite data release err:', error);
+            } finally {
+                sqlite.close();
+            }
         }
         await purgeRedundantRecords(data, builder);
     } catch (e) {
-        console.error('releaseCacheStore data err:', e);
+        console.error('initializeCache data err:', e);
     }
 
     Object.entries(data).forEach(([k, v]) => {

package/src/helpers/variables.js

@@ -28,7 +28,7 @@ export const Scoped = {
         httpFetch: {}
     },
     initedSqliteInstances: {
-        httpFetch: undefined,
+        httpFetch: {},
         dbQueryCount: {},
         database: {}
     }

package/src/products/database/accessor.js

@@ -13,6 +13,7 @@ import { TIMESTAMP } from "../..";
 import { docSize, incrementDatabaseSize } from "./counter";
 import { deserializeBSON, serializeToBase64 } from "./bson";
 import { openDB, SQLITE_COMMANDS, SQLITE_PATH, useSqliteLinearAccessId } from "../../helpers/sqlite_manager";
+import { getStoreID, handleBigData, parseBigData } from "../../helpers/fs_manager";
 
 const { LIMITER_DATA, LIMITER_RESULT, DB_COUNT_QUERY } = SQLITE_PATH;
 
@@ -105,20 +106,20 @@ export const insertRecord = async (builder, config, accessIdWithoutLimit, value,
     const thisSize = docSize(value);
 
     if (!io) {
-        await useSqliteLinearAccessId(builder, accessIdWithoutLimit, 'database')(async (sqlite) => {
+        await useSqliteLinearAccessId(builder, accessIdWithoutLimit, 'database')(async (sqlite, db_filename) => {
             const initNode = `${projectUrl}_${dbUrl}_${dbName}_${path}`;
 
             if (!Scoped.initedSqliteInstances.database[initNode]) {
                 Scoped.initedSqliteInstances.database[initNode] = (async () => {
                     await Promise.allSettled([
-                        sqlite.executeSql(`CREATE TABLE IF NOT EXISTS ${LIMITER_DATA(path)} ( access_id TEXT PRIMARY KEY, value TEXT, touched INTEGER, size INTEGER )`),
-                        sqlite.executeSql(`CREATE TABLE IF NOT EXISTS ${LIMITER_RESULT(path)} ( access_id-limit TEXT PRIMARY KEY, access_id TEXT, value TEXT, touched INTEGER, size INTEGER )`)
+                        sqlite.executeSql(`CREATE TABLE IF NOT EXISTS ${LIMITER_DATA(path)} ( access_id TEXT PRIMARY KEY, value BLOB, touched INTEGER, size INTEGER )`),
+                        sqlite.executeSql(`CREATE TABLE IF NOT EXISTS ${LIMITER_RESULT(path)} ( access_id_limiter TEXT PRIMARY KEY, access_id TEXT, value BLOB, touched INTEGER, size INTEGER )`)
                     ]);
 
                     await Promise.allSettled([
                         sqlite.executeSql(SQLITE_COMMANDS.CREATE_INDEX(LIMITER_DATA(path), ['access_id'])),
                         // sqlite.executeSql(SQLITE_COMMANDS.CREATE_INDEX(LIMITER_DATA(path), ['touched'])),
-                        sqlite.executeSql(SQLITE_COMMANDS.CREATE_INDEX(LIMITER_RESULT(path), ['access_id-limit'])),
+                        sqlite.executeSql(SQLITE_COMMANDS.CREATE_INDEX(LIMITER_RESULT(path), ['access_id_limiter'])),
                         // sqlite.executeSql(SQLITE_COMMANDS.CREATE_INDEX(LIMITER_RESULT(path), ['touched']))
                     ]);
                 })();
@@ -130,7 +131,7 @@ export const insertRecord = async (builder, config, accessIdWithoutLimit, value,
 
             const [instanceData, resultData] = await Promise.all([
                 sqlite.executeSql(`SELECT access_id, size FROM ${LIMITER_DATA(path)} WHERE access_id = ?`, [accessIdWithoutLimit]),
-                sqlite.executeSql(`SELECT access_id-limit, size FROM ${LIMITER_RESULT(path)} WHERE access_id-limit = ?`, [resultAccessId])
+                sqlite.executeSql(`SELECT access_id_limiter, size FROM ${LIMITER_RESULT(path)} WHERE access_id_limiter = ?`, [resultAccessId])
             ]).then(r =>
                 r.map(v => v[0].rows.item(0))
             );
@@ -150,16 +151,22 @@ export const insertRecord = async (builder, config, accessIdWithoutLimit, value,
                 data: value,
                 size: thisSize
             });
+            const [blobData, episodeBlobData] = await Promise.all([
+                handleBigData(getStoreID(db_filename, LIMITER_DATA(path), accessIdWithoutLimit), newData),
+                isEpisode ?
+                    handleBigData(getStoreID(db_filename, LIMITER_RESULT(path), resultAccessId), newResultData)
+                    : Promise.resolve()
+            ]);
 
             await Promise.all([
                 sqlite.executeSql(
                     SQLITE_COMMANDS.MERGE(LIMITER_DATA(path), ['access_id', 'value', 'touched', 'size']),
-                    [accessIdWithoutLimit, newData, Date.now(), thisSize]
+                    [accessIdWithoutLimit, blobData, Date.now(), thisSize]
                 ),
                 isEpisode ?
                     sqlite.executeSql(
-                        SQLITE_COMMANDS.MERGE(LIMITER_RESULT(path), ['access_id-limit', 'access_id', 'value', 'touched', 'size']),
-                        [resultAccessId, accessIdWithoutLimit, newResultData, Date.now(), thisSize]
+                        SQLITE_COMMANDS.MERGE(LIMITER_RESULT(path), ['access_id_limiter', 'access_id', 'value', 'touched', 'size']),
+                        [resultAccessId, accessIdWithoutLimit, episodeBlobData, Date.now(), thisSize]
                     ) : Promise.resolve()
             ]);
             incrementDatabaseSize(builder, path, editionSizeOffset + resultSizeOffset);
@@ -227,18 +234,16 @@ export const getRecord = async (builder, accessIdWithoutLimit, episode = 0) => {
         const record = await useSqliteLinearAccessId(builder, accessIdWithoutLimit, 'database')(async sqlite => {
             const resultAccessId = `${accessIdWithoutLimit}-${limit}`;
 
-            const thisData = await (
-                isEpisode ? sqlite.executeSql(`SELECT * FROM ${LIMITER_RESULT(path)} WHERE access_id-limit = ?`, [resultAccessId]) :
+            const qData = await (
+                isEpisode ? sqlite.executeSql(`SELECT * FROM ${LIMITER_RESULT(path)} WHERE access_id_limiter = ?`, [resultAccessId]) :
                     sqlite.executeSql(`SELECT * FROM ${LIMITER_DATA(path)} WHERE access_id = ?`, [accessIdWithoutLimit])
-            ).then(v => {
-                const d = v[0].rows.item(0);
-                if (d) return deserializeBSON(d.value, true);
-            }).catch(() => null);
+            ).then(v => v[0].rows.item(0)).catch(() => null);
+            const thisData = qData && deserializeBSON(await parseBigData(qData.value), true);
 
             if (!thisData) return null;
 
             if (isEpisode) {
-                await sqlite.executeSql(SQLITE_COMMANDS.UPDATE_COLUMNS(LIMITER_RESULT(path), ['touched'], 'access_id-limit = ?'), [Date.now(), resultAccessId]);
+                await sqlite.executeSql(SQLITE_COMMANDS.UPDATE_COLUMNS(LIMITER_RESULT(path), ['touched'], 'access_id_limiter = ?'), [Date.now(), resultAccessId]);
                 return [thisData.data];
             }
 
@@ -460,20 +465,30 @@ export const addPendingWrites = async (builder, writeId, result) => {
                 const pathFinder = {};
 
                 await Promise.all(colListing.map(async access_id =>
-                    useSqliteLinearAccessId(builder, access_id, 'database')(async sqlite => {
-                        const data = await sqlite.executeSql(`SELECT * FROM ${LIMITER_DATA(path)} WHERE access_id = ?`, [access_id]).then(v =>
-                            v[0].rows.raw().map(d => [d.access_id, deserializeBSON(d.value, true)])[0]
-                        );
+                    useSqliteLinearAccessId(builder, access_id, 'database')(async (sqlite, db_filename) => {
+                        const data = await sqlite.executeSql(`SELECT * FROM ${LIMITER_DATA(path)} WHERE access_id = ?`, [access_id]).then(async v => {
+                            const d = v[0].rows.item(0);
+                            return [d.access_id, deserializeBSON(await parseBigData(d.value), true)];
+                        });
                         await MutateDataInstance(data, path =>
                             pathFinder[path] || (
                                 pathFinder[path] = sqlite.executeSql(`SELECT value FROM ${LIMITER_DATA(path)}`).then(v =>
-                                    v[0].rows.raw().map(d => deserializeBSON(d.value, true).data).flat()
+                                    Promise.all(
+                                        v[0].rows.raw().map(async d =>
+                                            deserializeBSON(await parseBigData(d.value), true).data
+                                        )
+                                    ).then(r => r.flat())
                                 ).catch(() => [])
                             )
                         );
+                        const editedBlobData = await handleBigData(
+                            getStoreID(db_filename, LIMITER_DATA(path), access_id),
+                            serializeToBase64(data[1])
+                        );
+
                         await sqlite.executeSql(
                             SQLITE_COMMANDS.MERGE(LIMITER_DATA(path), ['access_id', 'value', 'touched', 'size']),
-                            [access_id, serializeToBase64(data[1]), Date.now(), data[1].size]
+                            [access_id, editedBlobData, Date.now(), data[1].size]
                         );
                     })
                 ));
@@ -709,15 +724,21 @@ export const removePendingWrite = async (builder, writeId, revert) => {
             if (io) {
                 RevertMutation(getLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'instance', access_id]));
             } else {
-                await useSqliteLinearAccessId(builder, access_id, 'database')(async sqlite => {
-                    const colObj = await sqlite.executeSql(`SELECT * FROM ${LIMITER_DATA(path)} WHERE access_id = ?`, [access_id]).then(v =>
-                        v[0].rows.raw().map(d => deserializeBSON(d.value))[0]
-                    ).catch(() => null);
+                await useSqliteLinearAccessId(builder, access_id, 'database')(async (sqlite, db_filename) => {
+                    const colObj = await sqlite.executeSql(`SELECT * FROM ${LIMITER_DATA(path)} WHERE access_id = ?`, [access_id]).then(async v => {
+                        const d = v[0].rows.item(0);
+                        return deserializeBSON(await parseBigData(d.value));
+                    }).catch(() => null);
                     if (!colObj) return;
                     RevertMutation(colObj);
+                    const revertedBlobData = await handleBigData(
+                        getStoreID(db_filename, LIMITER_DATA(path), access_id),
+                        serializeToBase64(colObj)
+                    );
+
                     await sqlite.executeSql(
                         SQLITE_COMMANDS.MERGE(LIMITER_DATA(path), ['access_id', 'value', 'touched', 'size']),
-                        [access_id, serializeToBase64(colObj), Date.now(), colObj.size]
+                        [access_id, revertedBlobData, Date.now(), colObj.size]
                     );
                 });
             }

package/src/products/database/index.js

@@ -505,8 +505,11 @@ const findObject = async (builder, config) => {
                     Scoped.PendingDbReadCollective[processAccessId] = [];
                 }
 
-                const staleData = await getRecordData();
-                if (retrieval.startsWith('sticky') && staleData) {
+                let staleData;
+                if (
+                    retrieval.startsWith('sticky') &&
+                    (staleData = await getRecordData())
+                ) {
                     finalize(staleData);
                     if (retrieval !== RETRIEVAL.STICKY_RELOAD) return;
                 }

package/src/products/http_callable/accessor.js

@@ -1,35 +1,35 @@
-import { Buffer } from "buffer";
 import { updateCacheStore } from "../../helpers/utils";
 import { CacheStore, Scoped } from "../../helpers/variables";
 import cloneDeep from "lodash/cloneDeep";
-import { deserialize, serialize } from "entity-serializer";
+import { serialize } from "entity-serializer";
 import { SQLITE_COMMANDS, SQLITE_PATH, useSqliteLinearAccessId } from "../../helpers/sqlite_manager";
 import { incrementFetcherSize } from "./counter";
+import { getStoreID, handleBigData, parseBigData } from "../../helpers/fs_manager";
 
 const { FETCH_RESOURCES } = SQLITE_PATH;
 
 export const insertFetchResources = async (projectUrl, access_id, value) => {
     value = cloneDeep(value);
-    const data = serialize(value).toString('base64');
+    const dataSize = serialize(value).byteLength;
 
     const { io } = Scoped.ReleaseCacheData;
     if (io) {
         if (!CacheStore.FetchedStore[projectUrl])
             CacheStore.FetchedStore[projectUrl] = {};
         const b4 = CacheStore.FetchedStore[projectUrl][access_id];
-        incrementFetcherSize(projectUrl, data.length - (b4?.size || 0));
+        incrementFetcherSize(projectUrl, dataSize - (b4?.size || 0));
         CacheStore.FetchedStore[projectUrl][access_id] = {
             touched: Date.now(),
             data: value,
-            size: data.length
+            size: dataSize
         };
     } else {
         const initNode = projectUrl;
 
-        await useSqliteLinearAccessId(FETCH_RESOURCES(projectUrl), access_id, 'httpFetch')(async sqlite => {
+        await useSqliteLinearAccessId(FETCH_RESOURCES(projectUrl), access_id, 'httpFetch')(async (sqlite, db_filename) => {
             if (!Scoped.initedSqliteInstances.httpFetch[initNode]) {
                 Scoped.initedSqliteInstances.httpFetch[initNode] = (async () => {
-                    await sqlite.executeSql(`CREATE TABLE IF NOT EXISTS main ( access_id TEXT PRIMARY KEY, value TEXT, touched INTEGER, size INTEGER )`).catch(() => null);
+                    await sqlite.executeSql(`CREATE TABLE IF NOT EXISTS main ( access_id TEXT PRIMARY KEY, value BLOB, touched INTEGER, size INTEGER )`).catch(() => null);
                     await Promise.allSettled([
                         sqlite.executeSql(SQLITE_COMMANDS.CREATE_INDEX('main', ['access_id'])),
                         sqlite.executeSql(SQLITE_COMMANDS.CREATE_INDEX('main', ['touched']))
@@ -41,11 +41,13 @@ export const insertFetchResources = async (projectUrl, access_id, value) => {
             const b4Data = await sqlite.executeSql(`SELECT access_id, size FROM main WHERE access_id = ?`, [access_id]).then(r =>
                 r[0].rows.item(0)
             );
+            const blobData = await handleBigData(getStoreID(db_filename, 'main', access_id), value);
+
             await sqlite.executeSql(
                 SQLITE_COMMANDS.MERGE('main', ['access_id', 'value', 'touched', 'size']),
-                [access_id, data, Date.now(), data.length]
+                [access_id, blobData, Date.now(), dataSize]
             );
-            incrementFetcherSize(projectUrl, data.length - (b4Data?.size || 0));
+            incrementFetcherSize(projectUrl, dataSize - (b4Data?.size || 0));
         });
     }
 
@@ -61,12 +63,15 @@ export const getFetchResources = async (projectUrl, access_id) => {
         return record && cloneDeep(record?.data);
     }
 
-    const res = await useSqliteLinearAccessId(FETCH_RESOURCES(projectUrl), access_id, 'httpFetch')(sqlite =>
-        sqlite.executeSql('SELECT * FROM main WHERE access_id = ?', [access_id]).then(async r => {
-            const data = deserialize(Buffer.from(r[0].rows.item(0).value, 'base64'));
-            await sqlite.executeSql(SQLITE_COMMANDS.UPDATE_COLUMNS('main', ['touched'], 'access_id = ?'), [Date.now(), access_id]);
-            return data;
-        }).catch(() => null)
-    );
+    const res = await useSqliteLinearAccessId(FETCH_RESOURCES(projectUrl), access_id, 'httpFetch')(async sqlite => {
+        const query = await sqlite.executeSql('SELECT * FROM main WHERE access_id = ?', [access_id]).catch(() => null);
+
+        const rawData = query && query[0].rows.item(0).value;
+        if (!rawData) return null;
+
+        const data = await parseBigData(rawData);
+        await sqlite.executeSql(SQLITE_COMMANDS.UPDATE_COLUMNS('main', ['touched'], 'access_id = ?'), [Date.now(), access_id]);
+        return data;
+    });
     return res;
 }

package/src/products/http_callable/index.js

@@ -122,8 +122,11 @@ export const mfetch = async (input = '', init, config) => {
                     Scoped.PendingFetchCollective[processReqId] = [];
                 }
 
-                const reqData = await getFetchResources(projectUrl, reqId);
-                if (retrieval.startsWith('sticky') && reqData) {
+                let reqData;
+                if (
+                    retrieval.startsWith('sticky') &&
+                    (reqData = await getFetchResources(projectUrl, reqId))
+                ) {
                     resolveCache(reqData);
                     if (retrieval !== RETRIEVAL.STICKY_RELOAD) return;
                 }