react-native-mosquito-transport 0.0.32 → 0.0.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-mosquito-transport",
-  "version": "0.0.32",
+  "version": "0.0.34",
   "description": "React native javascript sdk for mosquito-transport (https://github.com/brainbehindx/mosquito-transport)",
   "main": "src/index.js",
   "type": "module",
@@ -40,12 +40,8 @@
   },
   "peerDependencies": {
     "react-native": "*",
-    "react-native-fs": "*",
-    "react-native-sha256": "*",
-    "react-native-sqlite-storage": "*",
-    "react-native-get-random-values": "*"
-  },
-  "devDependencies": {
-    "@types/react-native-sqlite-storage": "^6.0.5"
+    "react-native-file-access": "*",
+    "react-native-get-random-values": "*",
+    "react-native-sha256": "*"
   }
 }

package/src/helpers/fs_manager.js

@@ -1,27 +1,82 @@
+import { Scoped } from "./variables";
 import { Platform } from "react-native";
-import { Buffer } from 'buffer';
-import { deserialize, serialize } from 'entity-serializer';
-import { writeFile, mkdir, MainBundlePath, readFile, unlink, DocumentDirectoryPath } from "react-native-fs";
+import { Dirs, FileSystem } from "react-native-file-access";
 
-const MAX_INLINE_BLOB = 1024;
+const PARENT_FOLDER = `${Platform.OS === 'android' ? Dirs.DocumentDir.split('/').slice(0, -1).join('/') : Dirs.MainBundleDir}/mosquito_base`;
 
-const DIR_PATH = `${Platform.OS === 'android' ? DocumentDirectoryPath.split('/').slice(0, -1).join('/').concat('/databases') : MainBundlePath}/MOSQUITO`;
-const resolvePath = (path = '') => `${DIR_PATH}${path.startsWith('/') ? path : '/' + path}`;
+/**
+ * this method linearize read/write for individual access_id on the file system ensuring consistency across concurrent operations
+ * 
+ * @param {any} builder 
+ * @param {string} access_id 
+ * @param {string} node 
+ * @returns {(task: (system: { set: (table: string, primary_key: string, value: {}) => Promise<void>, delete: (table: string, primary_key: string) => Promise<void>, find: (table: string, primary_key: string, extractions: string[]) => Promise<{}>, list: (table: string, extractions: string[]) => Promise<[string, {}][]> }) => any) => Promise<any>}
+ */
+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 DIR_CREATION_PROMISE = mkdir(DIR_PATH).catch(() => null);
+    const thatProcess = Scoped.linearSqliteProcess[node][nodeId];
 
-const fsWrite = async (path, data) => {
-    await DIR_CREATION_PROMISE;
-    return writeFile(resolvePath(path), data instanceof Buffer ? data.toString('base64') : data, 'base64');
-}
+    const thisPromise = new Promise(async (resolve, reject) => {
+        try {
+            if (thatProcess !== undefined) await thatProcess;
+        } catch (_) { }
+        try {
+            resolve(await task(getSystem(builder)));
+        } catch (error) {
+            console.error('useFS err:', error, ' builder:', builder);
+            reject(error);
+        } finally {
+            if (Scoped.linearSqliteProcess[node][nodeId] === thisPromise)
+                delete Scoped.linearSqliteProcess[node][nodeId];
+        }
+    });
 
-const fsRead = async (path) => {
-    await DIR_CREATION_PROMISE;
-    return Buffer.from(await readFile(resolvePath(path), 'base64'), 'base64');
-}
+    Scoped.linearSqliteProcess[node][nodeId] = thisPromise;
+    return (await thisPromise);
+};
+
+export const getSystem = (builder) => {
+    const { projectUrl, dbUrl, dbName } = builder;
+
+    const DIR_PATH = joinPath(PARENT_FOLDER, purifyFilepath(typeof builder === 'string' ? builder : `${projectUrl}_${dbUrl}_${dbName}`));
+    const conjoin = (...args) => joinPath(DIR_PATH, ...args);
 
-const purifyFilename = (filename) => {
-    if (!filename || typeof filename !== 'string') return 'unnamed';
+    return {
+        set: async (table, primary_key, value) => {
+            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')
+            ));
+        },
+        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 FileSystem.readFile(joinPath(path, node)), 'utf8')]
+            ));
+            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)
+                    .catch(() => null);
+                if (!obj) return;
+                return [primary_key, obj];
+            }));
+
+            return list_data.filter(v => v);
+        }
+    };
+};
+
+export function purifyFilepath(filename) {
+    if (!filename || typeof filename !== 'string')
+        throw `invalid filename:${filename}`;
 
     // Remove invalid characters for both iOS and Android
     return filename
@@ -29,27 +84,21 @@ const purifyFilename = (filename) => {
         .trim(); // Remove leading/trailing whitespace
 }
 
-export const getStoreID = (db_filename, table, primary_key) => purifyFilename(`${table}_${primary_key}_${db_filename}.blob`);
-
-export const deleteBigData = (store_id) => 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');
-};
+function joinPath(...args) {
+    return args.map((v, i) => {
+        if (i && v.startsWith('/'))
+            v = v.slice(1);
+        if (v.endsWith('/'))
+            v = v.slice(0, -1);
+        return v;
+    }).join('/');
+}
 
-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);
+export const FS_PATH = {
+    FILE_NAME: 'MOSQUITO_TRANSPORT',
+    TABLE_NAME: 'MT_MAIN',
+    LIMITER_RESULT: path => `${purifyFilepath(encodeURIComponent(path))}_LR`,
+    LIMITER_DATA: path => `${purifyFilepath(encodeURIComponent(path))}_LD`,
+    DB_COUNT_QUERY: path => `${purifyFilepath(encodeURIComponent(path))}_QC`,
+    FETCH_RESOURCES: projectUrl => `FR_${purifyFilepath(encodeURIComponent(projectUrl))}`
 };

package/src/helpers/peripherals.js

@@ -4,6 +4,7 @@ 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";
 
 const { box, randomBytes } = naclPkg;
 
@@ -66,9 +67,8 @@ export function sortArrayByObjectKey(arr = [], key) {
 };
 
 export async function niceHash(str = '') {
-    const hash = await sha256(str);
-    if (hash.length > str.length) return encodeBinary(str);
-    return hash;
+    const hash = Buffer.from(await sha256(str), 'hex').toString('base64');
+    return purifyFilepath(hash);
 };
 
 export const sameInstance = (var1, var2) => {

package/src/helpers/purger.js

@@ -1,11 +1,16 @@
-import { openDB, SQLITE_COMMANDS, SQLITE_PATH } from "./sqlite_manager";
 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";
+import { FS_PATH, getSystem } from "./fs_manager";
 
-const { LIMITER_DATA, LIMITER_RESULT, DB_COUNT_QUERY, FETCH_RESOURCES } = SQLITE_PATH;
+const { LIMITER_DATA, LIMITER_RESULT, DB_COUNT_QUERY, FETCH_RESOURCES } = FS_PATH;
+
+const inlineFsData = (arr, access_id_node = 'access_id') =>
+    arr.map(([access_id, obj]) => {
+        obj[access_id_node] = access_id;
+        return obj;
+    });
 
 export const purgeRedundantRecords = async (data, builder) => {
     const { io, maxLocalDatabaseSize = 10485760, maxLocalFetchHttpSize = 10485760 } = builder;
@@ -145,28 +150,24 @@ export const purgeRedundantRecords = async (data, builder) => {
                         instances.map(async obj => {
                             const { builder, isCounter, path } = obj;
 
-                            const sqlite = await openDB(builder);
-
                             try {
                                 if (isCounter) {
-                                    const data = await sqlite.executeSql(`SELECT * FROM ${DB_COUNT_QUERY(path)}`).then(r =>
-                                        r[0].rows.raw()
+                                    const data = inlineFsData(
+                                        await getSystem(builder).list(DB_COUNT_QUERY(path), ['size', 'touched'])
                                     );
                                     return data.map(v => [v, obj]);
                                 }
 
                                 const [instanceData, resultData] = await Promise.all([
-                                    sqlite.executeSql(`SELECT access_id, touched, size FROM ${LIMITER_DATA(path)}`),
-                                    sqlite.executeSql(`SELECT access_id_limiter, touched, size FROM ${LIMITER_RESULT(path)}`)
+                                    getSystem(builder).list(LIMITER_DATA(path), ['touched', 'size']).catch(() => []),
+                                    getSystem(builder).list(LIMITER_RESULT(path), ['touched', 'size']).catch(() => [])
                                 ]).then(r =>
-                                    r.map(v => v[0].rows.raw())
+                                    r.map((v, i) => inlineFsData(v, i ? 'access_id_limiter' : 'access_id'))
                                 );
                                 return [...instanceData, ...resultData].map(v => [v, obj]);
                             } catch (error) {
                                 console.error('redundantDbRanking err:', error);
                                 return [];
-                            } finally {
-                                sqlite.close();
                             }
                         })
                     ).then(r =>
@@ -186,22 +187,15 @@ export const purgeRedundantRecords = async (data, builder) => {
 
                     console.warn(`purging ${cuts} of ${redundantDbRanking.length} db entities`);
                     await Promise.all(redundantDbRanking.slice(0, cuts).map(async ([v, { builder, isCounter, path }]) => {
-                        let db_filename;
-                        const sqlite = await openDB(builder, n => db_filename = n);
                         try {
                             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 Promise.all([
-                                sqlite.executeSql(SQLITE_COMMANDS.DELETE_ROW(table, `${id_field} = ?`), [primary_key]),
-                                deleteBigData(getStoreID(db_filename, table, primary_key)).catch(() => null)
-                            ]);
+                            await getSystem(builder).delete(table, primary_key);
                             if (!isCounter) incrementDatabaseSizeCore(data.DatabaseStats, builder, path, -v.size);
                         } catch (error) {
                             console.log('db redundantClearing err:', error);
                         }
-                        sqlite.close();
                     }));
                     console.log('database purging complete');
                 } catch (error) {
@@ -212,13 +206,12 @@ export const purgeRedundantRecords = async (data, builder) => {
                 try {
                     if (!Validator.POSITIVE_NUMBER(_fetcher_size) || !maxLocalFetchHttpSize || _fetcher_size < maxLocalFetchHttpSize) return;
 
-                    const redundantFetchRanking = await Promise.all(Object.entries(fetchers).map(async ([projectUrl]) => {
-                        const sqlite = await openDB(FETCH_RESOURCES(projectUrl));
-                        const data = await sqlite.executeSql('SELECT access_id, touched, size FROM main').then(r =>
-                            r[0].rows.raw()
-                        );
-                        return data.map(v => [v, projectUrl]);
-                    })).then(r =>
+                    const redundantFetchRanking = await Promise.all(
+                        Object.entries(fetchers).map(async ([projectUrl]) => {
+                            const data = inlineFsData(await getSystem(FETCH_RESOURCES(projectUrl)).list('main', ['touched', 'size']));
+                            return data.map(v => [v, projectUrl]);
+                        })
+                    ).then(r =>
                         r.flat().sort(([a], [b]) =>
                             a.touched - b.touched
                         )
@@ -236,19 +229,12 @@ export const purgeRedundantRecords = async (data, builder) => {
 
                     console.warn(`purging ${cuts} of ${redundantFetchRanking.length} fetcher entities`);
                     await Promise.all(redundantFetchRanking.slice(0, cuts).map(async ([v, projectUrl]) => {
-                        let db_filename;
-                        const sqlite = await openDB(FETCH_RESOURCES(projectUrl), n => db_filename = n);
-
                         try {
-                            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)
-                            ]);
+                            await getSystem(FETCH_RESOURCES(projectUrl)).delete('main', v.access_id);
                             incrementFetcherSizeCore(data.DatabaseStats, projectUrl, -v.size);
                         } catch (error) {
-                            console.log('fetcher redundantClearing err:', error);
+                            console.log('fetcher redundantClearing err:', error, ' obj:', v, ' projectUrl:', projectUrl);
                         }
-                        sqlite.close();
                     }));
                     console.log('fetcher purging complete');
                 } catch (error) {
@@ -268,8 +254,4 @@ const breakDbMap = (obj, callback) =>
                 });
             });
         });
-    });
-
-export const purgeInstance = (projectUrl) => {
-    // TODO: purge when signed-out
-}
+    });

package/src/helpers/utils.js

@@ -4,66 +4,54 @@ import { serializeE2E } from "./peripherals";
 import { deserializeBSON, serializeToBase64 } from "../products/database/bson";
 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";
+import { FS_PATH, getSystem } from "./fs_manager";
 
-const { FILE_NAME, TABLE_NAME } = SQLITE_PATH;
+const { FILE_NAME, TABLE_NAME } = FS_PATH;
 
 const CacheKeys = Object.keys(CacheStore);
 
-export const updateCacheStore = (timer = 300, node) => {
+export const updateCacheStore = async (node) => {
     const { io, promoteCache } = Scoped.ReleaseCacheData;
 
-    const doUpdate = async () => {
-        const {
+    const {
+        AuthStore,
+        EmulatedAuth,
+        PendingAuthPurge,
+        DatabaseStore,
+        PendingWrites,
+        ...restStore
+    } = CacheStore;
+
+    if (io) {
+        const txt = JSON.stringify({
             AuthStore,
             EmulatedAuth,
             PendingAuthPurge,
-            DatabaseStore,
-            PendingWrites,
-            ...restStore
-        } = CacheStore;
-
-        if (io) {
-            const txt = JSON.stringify({
-                AuthStore,
-                EmulatedAuth,
-                PendingAuthPurge,
-                ...promoteCache ? {
-                    DatabaseStore: serializeToBase64(DatabaseStore),
-                    PendingWrites: serializeToBase64(PendingWrites)
-                } : {},
-                ...promoteCache ? restStore : {}
-            });
-
-            io.output(txt, node);
-        } else {
-            // use sqlite
-            const exclusion = ['DatabaseStore', 'DatabaseCountResult', 'FetchedStore'];
-            const updationKey = (node ? Array.isArray(node) ? node : [node] : CacheKeys).filter(v => !exclusion.includes(v));
-
-            if (!updationKey.length) return;
-            const sqlite = await openDB(FILE_NAME);
-            await Promise.all(
-                updationKey
-                    .map(v => [v, v === 'PendingWrites' ? serializeToBase64(CacheStore[v]) : CacheStore[v]])
-                    .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();
-            });
-        }
-    };
-
-    clearTimeout(Scoped.cacheStorageReducer);
-    if (timer) {
-        Scoped.cacheStorageReducer = setTimeout(doUpdate, timer);
-    } else doUpdate();
+            ...promoteCache ? {
+                DatabaseStore: serializeToBase64(DatabaseStore),
+                PendingWrites: serializeToBase64(PendingWrites)
+            } : {},
+            ...promoteCache ? restStore : {}
+        });
+
+        io.output(txt, node);
+    } else {
+        // use sqlite
+        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(([ref, value]) =>
+                    getSystem(FILE_NAME).set(TABLE_NAME, ref, { value })
+                )
+        ).catch(err => {
+            console.error('updateCacheStore err:', err);
+        });
+    }
 };
 
 export const releaseCacheStore = async (builder) => {
@@ -75,19 +63,15 @@ export const releaseCacheStore = async (builder) => {
         if (io) {
             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 BLOB )`).catch(() => null);
             try {
-                const [query] = await sqlite.executeSql(`SELECT * FROM ${TABLE_NAME}`);
+                const query = await getSystem(FILE_NAME).list(TABLE_NAME, ['value']).catch(() => []);
                 data = Object.fromEntries(
-                    await Promise.all(query.rows.raw().map(async v =>
-                        [v.ref, await parseBigData(v.value)]
-                    ))
+                    query.map(([ref, { value }]) =>
+                        [ref, value]
+                    )
                 );
             } catch (error) {
                 console.error('initializeCache sqlite data release err:', error);
-            } finally {
-                sqlite.close();
             }
         }
         await purgeRedundantRecords(data, builder);

package/src/helpers/variables.js

@@ -8,7 +8,6 @@ export const Scoped = {
     InitializedProject: {},
     ReleaseCacheData: undefined,
     AuthJWTToken: {},
-    cacheStorageReducer: undefined,
     IsStoreReady: false,
     TokenRefreshTimer: {},
     LastTokenRefreshRef: {},
@@ -26,11 +25,6 @@ export const Scoped = {
         database: {},
         dbQueryCount: {},
         httpFetch: {}
-    },
-    initedSqliteInstances: {
-        httpFetch: {},
-        dbQueryCount: {},
-        database: {}
     }
 };
 
@@ -62,6 +56,9 @@ export const CacheStore = {
     },
     AuthStore: {},
     PendingAuthPurge: {},
+    /**
+     * [the instance url]: the url been emulated
+     */
     EmulatedAuth: {},
     PendingWrites: {},
     FetchedStore: {}

package/src/index.d.ts

@@ -96,11 +96,7 @@ interface ReleaseCacheOption_IO {
 
 interface ReleaseCacheOption {
     /**
-     * This key will be used to encrypt sqlite data stored locally
-     */
-    sqliteKey?: string;
-    /**
-     * sqlite is used as the default caching mechanism
+     * fs is used as the default caching mechanism
      * 
      * providing `io` means you want to override this behaviour and handle caching yourself in the system's memory
      */

package/src/index.js

@@ -419,10 +419,7 @@ const discloseSocketArguments = (args = []) => {
 
 const validateReleaseCacheProp = (prop) => {
     Object.entries(prop).forEach(([k, v]) => {
-        if (k === 'sqliteKey') {
-            if (typeof v !== 'string' || v.trim().length <= 0)
-                throw `Invalid value supplied to "sqliteKey", value must be a string and greater than 0 characters`;
-        } else if (k === 'io') {
+        if (k === 'io') {
             Object.entries(v).forEach(([k, v]) => {
                 if (k === 'input' || k === 'output') {
                     if (typeof v !== 'function')

package/src/products/auth/accessor.js

@@ -23,7 +23,7 @@ export const injectFreshToken = async (config, { token, refreshToken }) => {
     const isEmulated = projectUrl in CacheStore.EmulatedAuth;
     if (isEmulated) delete CacheStore.EmulatedAuth[projectUrl];
 
-    updateCacheStore(0, ['AuthStore', isEmulated ? 'EmulatedAuth' : ''].filter(v => v));
+    updateCacheStore(['AuthStore', isEmulated ? 'EmulatedAuth' : ''].filter(v => v));
 
     triggerAuthToken(projectUrl);
     initTokenRefresher(config);
@@ -47,7 +47,7 @@ export const injectEmulatedAuth = async (config, emulatedURL) => {
     Scoped.AuthJWTToken[projectUrl] = token;
     CacheStore.EmulatedAuth[projectUrl] = emulatedURL;
 
-    updateCacheStore(0, ['AuthStore', 'EmulatedAuth']);
+    updateCacheStore(['AuthStore', 'EmulatedAuth']);
     triggerAuthToken(projectUrl);
     initTokenRefresher(config);
 };
@@ -161,7 +161,7 @@ const refreshToken = (builder, processRef, remainRetries = 1, isForceRefresh) =>
                 triggerAuthToken(v, isInit);
                 if (isForceRefresh) Scoped.InitiatedForcedToken[v] = true;
             });
-            updateCacheStore(0, ['AuthStore']);
+            updateCacheStore(['AuthStore']);
             initTokenRefresher(builder);
         } else reject(lostProcess.simpleError);
     } catch (e) {

package/src/products/auth/index.js

@@ -232,13 +232,12 @@ const doCustomSignup = (builder, email, password, name, metadata) => new Promise
 
 const purgeCache = (url, isMain) => {
     if (url in Scoped.AuthJWTToken) delete Scoped.AuthJWTToken[url];
-    Object.keys(CacheStore).forEach(e => {
-        if (
-            e !== 'PendingAuthPurge' &&
-            (!['EmulatedAuth'].includes(e) || isMain)
-        ) {
-            if (CacheStore[e][url]) delete CacheStore[e][url];
-        }
+    [
+        isMain ? 'EmulatedAuth' : undefined,
+        'AuthStore',
+        'PendingWrites'
+    ].forEach(e => {
+        if (e && CacheStore[e][url]) delete CacheStore[e][url];
     });
     TokenRefreshListener.dispatch(url);
     triggerAuthToken(url);
@@ -257,7 +256,7 @@ export const doSignOut = async (builder) => {
     const emulatedURL = CacheStore.EmulatedAuth[builder.projectUrl];
 
     clearCacheForSignout(builder, !emulatedURL);
-    updateCacheStore(0, ['AuthStore', 'EmulatedAuth']);
+    updateCacheStore(['AuthStore', 'EmulatedAuth']);
     if (emulatedURL) return;
     await revokeAuthIntance(builder);
 };
@@ -304,7 +303,7 @@ export const purgePendingToken = async (nodeId) => {
         throw simplifyCaughtError(e).simpleError;
     } finally {
         delete CacheStore.PendingAuthPurge[nodeId];
-        updateCacheStore(0);
+        updateCacheStore(['PendingAuthPurge']);
     }
 };
 

package/src/products/database/accessor.js

@@ -12,10 +12,9 @@ import { niceGuard, Validator } from "guard-object";
 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";
+import { FS_PATH, getSystem, useFS } from "../../helpers/fs_manager";
 
-const { LIMITER_DATA, LIMITER_RESULT, DB_COUNT_QUERY } = SQLITE_PATH;
+const { LIMITER_DATA, LIMITER_RESULT, DB_COUNT_QUERY } = FS_PATH;
 
 export const listenQueryEntry = (callback, { accessId, builder, config, processId }) => {
     const { projectUrl, dbName, dbUrl, path } = builder;
@@ -50,28 +49,14 @@ 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() });
+        updateCacheStore(['DatabaseCountResult']);
     } else {
-        const initNode = `${projectUrl}_${dbUrl}_${dbName}_${path}`;
-        await useSqliteLinearAccessId(builder, access_id, 'dbQueryCount')(async sqlite => {
-            if (!Scoped.initedSqliteInstances.dbQueryCount[initNode]) {
-                Scoped.initedSqliteInstances.dbQueryCount[initNode] = (async () => {
-                    await sqlite.executeSql(`CREATE TABLE IF NOT EXISTS ${DB_COUNT_QUERY(path)} ( access_id TEXT PRIMARY KEY, value TEXT, touched INTEGER )`).catch(() => null);
-                    await Promise.allSettled([
-                        // sqlite.executeSql(SQLITE_COMMANDS.CREATE_INDEX(DB_COUNT_QUERY(path), ['access_id'])),
-                        // sqlite.executeSql(SQLITE_COMMANDS.CREATE_INDEX(DB_COUNT_QUERY(path), ['touched']))
-                    ]);
-                })();
-            }
-
-            await Scoped.initedSqliteInstances.dbQueryCount[initNode];
-            await sqlite.executeSql(
-                SQLITE_COMMANDS.MERGE(DB_COUNT_QUERY(path), ['access_id', 'value', 'touched']),
-                [access_id, JSON.stringify(value), Date.now()]
-            );
+        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);
         });
+        updateCacheStore(['DatabaseStats']);
     }
-    updateCacheStore(undefined, ['DatabaseCountResult'])
 }
 
 export const getCountQuery = async (builder, access_id) => {
@@ -83,14 +68,13 @@ export const getCountQuery = async (builder, access_id) => {
         if (data) data.touched = Date.now();
         return data && data.value;
     } else {
-        const result = await useSqliteLinearAccessId(builder, access_id, 'dbQueryCount')(sqlite =>
-            sqlite.executeSql(`SELECT * FROM ${DB_COUNT_QUERY(path)} WHERE access_id = ?`, [access_id]).then(async r => {
-                r = JSON.parse(r[0].rows.item(0).value);
-                await sqlite.executeSql(SQLITE_COMMANDS.UPDATE_COLUMNS(DB_COUNT_QUERY(path), ['touched'], 'access_id = ?'), [Date.now(), access_id]);
-                return r;
-            }).catch(() => undefined)
-        );
-        return result;
+        return useFS(builder, access_id, 'dbQueryCount')(async fs => {
+            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;
+            }
+        });
     }
 }
 
@@ -106,35 +90,13 @@ export const insertRecord = async (builder, config, accessIdWithoutLimit, value,
     const thisSize = docSize(value);
 
     if (!io) {
-        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 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_limiter'])),
-                        // sqlite.executeSql(SQLITE_COMMANDS.CREATE_INDEX(LIMITER_RESULT(path), ['touched']))
-                    ]);
-                })();
-            }
-
-            await Scoped.initedSqliteInstances.database[initNode];
-
+        await useFS(builder, accessIdWithoutLimit, 'database')(async fs => {
             const resultAccessId = `${accessIdWithoutLimit}-${limit}`;
 
             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_limiter, size FROM ${LIMITER_RESULT(path)} WHERE access_id_limiter = ?`, [resultAccessId])
-            ]).then(r =>
-                r.map(v => v[0].rows.item(0))
-            );
+                fs.find(LIMITER_DATA(path), accessIdWithoutLimit, ['size']).catch(() => undefined),
+                fs.find(LIMITER_RESULT(path), resultAccessId, ['size']).catch(() => undefined)
+            ]);
             const isEpisode = episode === 1 || !!resultData;
 
             const editionSizeOffset = thisSize - (instanceData?.size || 0);
@@ -151,27 +113,24 @@ 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, blobData, Date.now(), thisSize]
-                ),
+                fs.set(LIMITER_DATA(path), accessIdWithoutLimit, {
+                    value: newData,
+                    touched: Date.now(),
+                    size: thisSize
+                }),
                 isEpisode ?
-                    sqlite.executeSql(
-                        SQLITE_COMMANDS.MERGE(LIMITER_RESULT(path), ['access_id_limiter', 'access_id', 'value', 'touched', 'size']),
-                        [resultAccessId, accessIdWithoutLimit, episodeBlobData, Date.now(), thisSize]
-                    ) : Promise.resolve()
+                    fs.set(LIMITER_RESULT(path), resultAccessId, {
+                        access_id: accessIdWithoutLimit,
+                        value: newResultData,
+                        touched: Date.now(),
+                        size: thisSize
+                    }) : Promise.resolve()
             ]);
             incrementDatabaseSize(builder, path, editionSizeOffset + resultSizeOffset);
         });
-        updateCacheStore(undefined, ['DatabaseStore', 'DatabaseStats']);
+        updateCacheStore(['DatabaseStats']);
         return;
     }
 
@@ -200,7 +159,7 @@ export const insertRecord = async (builder, config, accessIdWithoutLimit, value,
 
     setLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'instance', accessIdWithoutLimit], newData);
     if (isEpisode) setLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'episode', accessIdWithoutLimit, limit], cloneDeep(newResultData));
-    updateCacheStore(undefined, ['DatabaseStore', 'DatabaseStats']);
+    updateCacheStore(['DatabaseStore', 'DatabaseStats']);
 };
 
 export const getRecord = async (builder, accessIdWithoutLimit, episode = 0) => {
@@ -231,19 +190,19 @@ export const getRecord = async (builder, accessIdWithoutLimit, episode = 0) => {
     }
 
     if (!io) {
-        const record = await useSqliteLinearAccessId(builder, accessIdWithoutLimit, 'database')(async sqlite => {
+        const record = await useFS(builder, accessIdWithoutLimit, 'database')(async fs => {
             const resultAccessId = `${accessIdWithoutLimit}-${limit}`;
 
             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 => v[0].rows.item(0)).catch(() => null);
-            const thisData = qData && deserializeBSON(await parseBigData(qData.value), true);
+                isEpisode ? fs.find(LIMITER_RESULT(path), resultAccessId, ['value']) :
+                    fs.find(LIMITER_DATA(path), accessIdWithoutLimit, ['value'])
+            ).catch(() => null);
+            const thisData = qData && deserializeBSON(qData.value, true);
 
             if (!thisData) return null;
 
             if (isEpisode) {
-                await sqlite.executeSql(SQLITE_COMMANDS.UPDATE_COLUMNS(LIMITER_RESULT(path), ['touched'], 'access_id_limiter = ?'), [Date.now(), resultAccessId]);
+                await fs.set(LIMITER_RESULT(path), resultAccessId, { touched: Date.now() });
                 return [thisData.data];
             }
 
@@ -253,7 +212,7 @@ export const getRecord = async (builder, accessIdWithoutLimit, episode = 0) => {
                 latest_limiter === undefined ||
                 (Validator.POSITIVE_NUMBER(limit) && latest_limiter >= limit)
             ) {
-                await sqlite.executeSql(SQLITE_COMMANDS.UPDATE_COLUMNS(LIMITER_DATA(path), ['touched'], 'access_id = ?'), [Date.now(), accessIdWithoutLimit]);
+                await fs.set(LIMITER_DATA(path), accessIdWithoutLimit, { touched: Date.now() });
                 return [transformData(data)];
             }
         });
@@ -457,46 +416,28 @@ export const addPendingWrites = async (builder, writeId, result) => {
                     )
                 );
         } else {
-            const sqlite = await openDB(builder);
-            try {
-                const colListing = await sqlite.executeSql(`SELECT access_id FROM ${LIMITER_DATA(path)}`).then(v =>
-                    v[0].rows.raw().map(d => d.access_id)
-                ).catch(() => []);
-                const pathFinder = {};
-
-                await Promise.all(colListing.map(async access_id =>
-                    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 =>
-                                    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, editedBlobData, Date.now(), data[1].size]
-                        );
-                    })
-                ));
-            } catch (error) {
-                throw error;
-            } finally {
-                sqlite.close();
-            }
+            const colListing = await getSystem(builder).list(LIMITER_DATA(path), []).catch(() => []);
+            const pathFinder = {};
+
+            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));
+
+                    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())
+                                .catch(() => [])
+                        )
+                    );
+                    await fs.set(LIMITER_DATA(path), access_id, {
+                        touched: Date.now(),
+                        value: serializeToBase64(data),
+                        size: data.size
+                    });
+                })
+            ));
         }
 
         async function MutateDataInstance([entityId, dataObj], pathGetter) {
@@ -706,7 +647,7 @@ export const addPendingWrites = async (builder, writeId, result) => {
         addedOn: Date.now()
     }));
 
-    updateCacheStore(undefined, ['DatabaseStore', 'PendingWrites', 'DatabaseStats']);
+    updateCacheStore(['DatabaseStore', 'PendingWrites', 'DatabaseStats']);
     notifyDatabaseNodeChanges(builder, [...pathChanges]);
 };
 
@@ -724,22 +665,17 @@ 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, 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);
+                await useFS(builder, access_id, 'database')(async fs => {
+                    const colObj = await fs.find(LIMITER_DATA(path), access_id, ['value'])
+                        .then(v => deserializeBSON(v.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, revertedBlobData, Date.now(), colObj.size]
-                    );
+                    await fs.set(LIMITER_DATA(path), access_id, {
+                        value: serializeToBase64(colObj),
+                        touched: Date.now(),
+                        size: colObj.size
+                    });
                 });
             }
 
@@ -782,7 +718,7 @@ export const removePendingWrite = async (builder, writeId, revert) => {
     }
 
     unsetLodash(CacheStore.PendingWrites, [projectUrl, writeId]);
-    updateCacheStore(undefined, ['PendingWrites', 'DatabaseStore', 'DatabaseStats']);
+    updateCacheStore(['PendingWrites', 'DatabaseStore', 'DatabaseStats']);
     notifyDatabaseNodeChanges(builder, [...pathChanges]);
 };
 

package/src/products/database/index.js

@@ -396,7 +396,7 @@ const countCollection = async (builder, config) => {
 
             if (e?.simpleError) {
                 finalize(undefined, e.simpleError);
-            } else if (!disableCache && !Validator.NUMBER(b4Data)) {
+            } else if (!disableCache && Validator.NUMBER(b4Data)) {
                 finalize(b4Data);
             } else if (retries > maxRetries) {
                 finalize(undefined, { error: 'retry_limit_exceeded', message: `retry exceed limit(${maxRetries})` });

package/src/products/http_callable/accessor.js

@@ -2,11 +2,10 @@ import { updateCacheStore } from "../../helpers/utils";
 import { CacheStore, Scoped } from "../../helpers/variables";
 import cloneDeep from "lodash/cloneDeep";
 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";
+import { FS_PATH, useFS } from "../../helpers/fs_manager";
 
-const { FETCH_RESOURCES } = SQLITE_PATH;
+const { FETCH_RESOURCES } = FS_PATH;
 
 export const insertFetchResources = async (projectUrl, access_id, value) => {
     value = cloneDeep(value);
@@ -23,35 +22,16 @@ export const insertFetchResources = async (projectUrl, access_id, value) => {
             data: value,
             size: dataSize
         };
+        updateCacheStore(['FetchedStore', 'DatabaseStats']);
     } else {
-        const initNode = projectUrl;
+        await useFS(FETCH_RESOURCES(projectUrl), access_id, 'httpFetch')(async fs => {
+            const b4Data = await fs.find('main', access_id, ['size']).catch(() => null);
 
-        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 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']))
-                    ]);
-                })();
-            }
-
-            await Scoped.initedSqliteInstances.httpFetch[initNode];
-            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, blobData, Date.now(), dataSize]
-            );
+            await fs.set('main', access_id, { value, size: dataSize, touched: Date.now() });
             incrementFetcherSize(projectUrl, dataSize - (b4Data?.size || 0));
         });
+        updateCacheStore(['DatabaseStats']);
     }
-
-    updateCacheStore(undefined, ['FetchedStore']);
 }
 
 export const getFetchResources = async (projectUrl, access_id) => {
@@ -63,15 +43,12 @@ export const getFetchResources = async (projectUrl, access_id) => {
         return record && cloneDeep(record?.data);
     }
 
-    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 res = await useFS(FETCH_RESOURCES(projectUrl), access_id, 'httpFetch')(async fs => {
+        const query = await fs.find('main', access_id, ['value']).catch(() => null);
+        if (!query) return null;
 
-        const data = await parseBigData(rawData);
-        await sqlite.executeSql(SQLITE_COMMANDS.UPDATE_COLUMNS('main', ['touched'], 'access_id = ?'), [Date.now(), access_id]);
-        return data;
+        await fs.set('main', access_id, { touched: Date.now() });
+        return query.value;
     });
     return res;
 }

package/src/products/http_callable/index.js

@@ -106,7 +106,7 @@ export const mfetch = async (input = '', init, config) => {
 
         await awaitStore();
         const resolveCache = (reqData) => {
-            finalize(buildFetchData(reqData), { fromCache: true });
+            finalize(buildFetchData(reqData, { fromCache: true }));
         };
 
         try {

package/src/helpers/sqlite_manager.js

@@ -1,144 +0,0 @@
-import { enablePromise, openDatabase } from 'react-native-sqlite-storage';
-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
- * 
- * @param {string} name 
- * @returns {Promise<import('react-native-sqlite-storage').SQLiteDatabase>}
- */
-export const openDB = async (name, onName) => {
-
-    if (name?.projectUrl) {
-        const { projectUrl, dbUrl, dbName } = name;
-        name = encodeURIComponent(`${projectUrl}_${dbUrl}_${dbName}`) + '.db';
-    }
-
-    const { sqliteKey } = Scoped.ReleaseCacheData;
-
-    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] = Promise.allSettled([SqliteCollective.closeDbPromises[name] || Promise.resolve()]).then(() =>
-            openDatabase({
-                location: 'default',
-                name,
-                key: sqliteKey
-            }).then(db => {
-                const prevClose = db.close.bind(db);
-
-                db.close = () => new Promise((resolve, reject) => {
-                    if (--SqliteCollective.openedDbProcess[name] === 0) {
-                        let willClose;
-                        const timer = setTimeout(async () => {
-                            willClose = true;
-                            delete SqliteCollective.openedDb[name];
-                            delete SqliteCollective.openedDbProcess[name];
-                            SqliteCollective.closeDbPromises[name] = prevClose().then(() => {
-                                resolve('active');
-                            }).catch(e => {
-                                reject(new Error(`${e}`));
-                            }).finally(() => {
-                                delete SqliteCollective.closeDbPromises[name];
-                            });
-                            delete SqliteCollective.openedDbReducerTimer[name];
-                        }, 7);
-
-                        SqliteCollective.openedDbReducerTimer[name] = () => {
-                            clearTimeout(timer);
-                            if (!willClose) resolve('passive');
-                            delete SqliteCollective.openedDbReducerTimer[name];
-                        }
-                    } else resolve('passive');
-                });
-                return db;
-            })
-        );
-    }
-
-    SqliteCollective.openedDbReducerTimer[name]?.();
-    ++SqliteCollective.openedDbProcess[name];
-    const thisDb = await SqliteCollective.openedDb[name];
-    let hasClosed;
-
-    const thisClose = async () => {
-        if (hasClosed) return;
-        hasClosed = true;
-        return (await thisDb.close());
-    }
-
-    return new Proxy({}, {
-        get: (_, n) => {
-            if (n === 'close') {
-                return thisClose;
-            } else if (typeof thisDb[n] === 'function')
-                return thisDb[n].bind(thisDb);
-            return thisDb[n];
-        },
-        set: (_, n, v) => {
-            thisDb[n] = v;
-        }
-    });
-};
-
-/**
- * this method linearize read/write on sqlite ensuring consistency across concurrent operations
- * 
- * @param {any} builder 
- * @param {string} access_id 
- * @param {'database' | 'dbQueryCount' | 'httpFetch'} node
- * @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, n => db_filename = n);
-
-    const thatProcess = Scoped.linearSqliteProcess[node][nodeId];
-
-    const thisPromise = new Promise(async (resolve, reject) => {
-        try {
-            if (thatProcess !== undefined) await thatProcess;
-        } catch (_) { }
-        try {
-            resolve(await task(sqlite, db_filename));
-        } catch (error) {
-            console.error('useSqliteLinearAccessId err:', error, ' builder:', builder);
-            reject(error);
-        } finally {
-            if (Scoped.linearSqliteProcess[node][nodeId] === thisPromise)
-                delete Scoped.linearSqliteProcess[node][nodeId];
-            sqlite.close();
-        }
-    });
-
-    Scoped.linearSqliteProcess[node][nodeId] = thisPromise;
-    return (await thisPromise);
-};
-
-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`
-};
-
-export const SQLITE_COMMANDS = {
-    MERGE: (table, columns = []) => `INSERT OR REPLACE INTO ${table} (${columns.join(', ')}) VALUES (${columns.fill('?').join(', ')})`,
-    UPDATE_COLUMNS: (table, columns = [], query = '') => `UPDATE ${table} SET ${columns.map(v => `${v} = ?`).join(', ')} WHERE ${query}`,
-    CREATE_INDEX: (table, columns) => `CREATE INDEX idx_${columns.join('_')} ON ${table}(${columns.join(', ')})`,
-    DELETE_ROW: (table, query) => `DELETE FROM ${table} WHERE ${query}`
-}