react-native-mosquito-transport 0.0.19 → 0.0.22

package/src/helpers/purger.js

@@ -0,0 +1,264 @@
+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';
+
+const { LIMITER_DATA, LIMITER_RESULT, DB_COUNT_QUERY, FETCH_RESOURCES } = SQLITE_PATH;
+
+export const purgeRedundantRecords = async (data, builder) => {
+    const { io, maxLocalDatabaseSize = 10485760, maxLocalFetchHttpSize = 10485760 } = builder;
+
+    /**
+     * @type {import('./variables')['CacheStore']['DatabaseStats']}
+     */
+    const { _db_size, _fetcher_size, counters, database, fetchers } = data.DatabaseStats || {};
+
+    if (io) {
+        const purgeDatabase = () => {
+            if (!Validator.POSITIVE_NUMBER(_db_size) || !maxLocalDatabaseSize || _db_size < maxLocalDatabaseSize) return;
+            const DbListing = [];
+
+            breakDbMap(data.DatabaseStore, (projectUrl, dbUrl, dbName, path, value) => {
+                Object.entries(value.instance).forEach(([access_id, obj]) => {
+                    DbListing.push({
+                        builder: { projectUrl, dbUrl, dbName },
+                        path,
+                        access_id,
+                        value: obj
+                    });
+                });
+                Object.entries(value.episode).forEach(([access_id, limitObj]) => {
+                    Object.entries(limitObj).forEach(([limit, obj]) => {
+                        DbListing.push({
+                            builder: { projectUrl, dbUrl, dbName },
+                            path,
+                            access_id,
+                            limit,
+                            value: obj,
+                            isEpisode: true
+                        });
+                    });
+                });
+            });
+
+            breakDbMap(data.DatabaseCountResult, (projectUrl, dbUrl, dbName, path, value) => {
+                Object.entries(value).forEach(([access_id, obj]) => {
+                    DbListing.push({
+                        builder: { projectUrl, dbUrl, dbName },
+                        path,
+                        access_id,
+                        value: obj,
+                        isCount: true
+                    });
+                });
+            });
+
+            const redundantDbRanking = DbListing.sort((a, b) =>
+                a.value.touched - b.value.touched
+            );
+
+            const newSize = maxLocalDatabaseSize / 2;
+            let sizer = _db_size;
+            let cuts = 0;
+
+            for (let i = 0; i < redundantDbRanking.length; i++) {
+                sizer -= redundantDbRanking[i].value.size || 0;
+                ++cuts;
+                if (sizer < newSize) break;
+            }
+
+            console.warn(`purging ${cuts} of ${redundantDbRanking.length} db entities`);
+            redundantDbRanking.slice(0, cuts).forEach(({
+                builder,
+                path,
+                access_id,
+                isCount,
+                isEpisode,
+                limit,
+                value: { size }
+            }) => {
+                const { projectUrl, dbUrl, dbName } = builder;
+                if (isCount) {
+                    unsetLodash(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]);
+                    } else {
+                        unsetLodash(data.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'instance', access_id]);
+                    }
+                }
+            });
+        }
+        const purgeFetcher = () => {
+            if (!Validator.POSITIVE_NUMBER(_fetcher_size) || !maxLocalFetchHttpSize || _fetcher_size < maxLocalFetchHttpSize) return;
+            const redundantFetchRanking = Object.entries(data.FetchedStore).map(([projectUrl, access_id_Obj]) =>
+                Object.entries(access_id_Obj).map(([access_id, data]) => ({
+                    access_id,
+                    projectUrl,
+                    data
+                }))
+            ).flat().sort(([a], [b]) =>
+                a.data.touched - b.data.touched
+            );
+
+            const newSize = maxLocalFetchHttpSize / 2;
+            let sizer = _fetcher_size;
+            let cuts = 0;
+
+            for (let i = 0; i < redundantFetchRanking.length; i++) {
+                sizer -= redundantFetchRanking[i].data.size || 0;
+                ++cuts;
+                if (sizer < newSize) break;
+            }
+
+            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]);
+            });
+            console.log('fetcher purging complete');
+        }
+        purgeDatabase();
+        purgeFetcher();
+    } else {
+        // purge redundant data
+        await Promise.allSettled([
+            (async () => {
+                try {
+                    if (!Validator.POSITIVE_NUMBER(_db_size) || !maxLocalDatabaseSize || _db_size < maxLocalDatabaseSize) return;
+                    const instances = [];
+
+                    [database, counters].forEach((map, i) => {
+                        breakDbMap(map, (projectUrl, dbUrl, dbName, path) => {
+                            instances.push({
+                                builder: { projectUrl, dbUrl, dbName },
+                                isCounter: !!i,
+                                path
+                            });
+                        });
+                    });
+
+                    const redundantDbRanking = await Promise.all(
+                        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()
+                                    );
+                                    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-limit, touched, size FROM ${LIMITER_RESULT(path)}`)
+                                ]).then(r =>
+                                    r.map(v => v[0].rows.raw())
+                                );
+                                return [...instanceData, ...resultData].map(v => [v, obj]);
+                            } catch (error) {
+                                console.error('redundantDbRanking err:', error);
+                                return [];
+                            } finally {
+                                sqlite.close();
+                            }
+                        })
+                    ).then(r =>
+                        r.flat().sort(([a], [b]) =>
+                            a.touched - b.touched
+                        )
+                    );
+                    const newSize = maxLocalDatabaseSize / 2;
+                    let sizer = _db_size;
+                    let cuts = 0;
+
+                    for (let i = 0; i < redundantDbRanking.length; i++) {
+                        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);
+                        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';
+
+                            await sqlite.executeSql(SQLITE_COMMANDS.DELETE_ROW(table, `${id_field} = ?`), [v[id_field]]);
+                            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) {
+                    console.error('database purging err:', error);
+                }
+            })(),
+            (async () => {
+                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 =>
+                        r.flat().sort(([a], [b]) =>
+                            a.touched - b.touched
+                        )
+                    );
+
+                    const newSize = maxLocalFetchHttpSize / 2;
+                    let sizer = _fetcher_size;
+                    let cuts = 0;
+
+                    for (let i = 0; i < redundantFetchRanking.length; i++) {
+                        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));
+                        try {
+                            await sqlite.executeSql(SQLITE_COMMANDS.DELETE_ROW('main', 'access_id = ?'), [v.access_id]);
+                            incrementFetcherSizeCore(data.DatabaseStats, projectUrl, -v.size);
+                        } catch (error) {
+                            console.log('fetcher redundantClearing err:', error);
+                        }
+                        sqlite.close();
+                    }));
+                    console.log('fetcher purging complete');
+                } catch (error) {
+                    console.error('fetcher purging err:', error);
+                }
+            })()
+        ]);
+    }
+}
+
+const breakDbMap = (obj, callback) =>
+    Object.entries(obj).forEach(([projectUrl, dbUrlObj]) => {
+        Object.entries(dbUrlObj).forEach(([dbUrl, dbNameObj]) => {
+            Object.entries(dbNameObj).forEach(([dbName, pathObj]) => {
+                Object.entries(pathObj).forEach(([path, value]) => {
+                    callback(projectUrl, dbUrl, dbName, path, value);
+                });
+            });
+        });
+    });
+
+export const purgeInstance = (projectUrl) => {
+    // TODO: purge when signed-out
+}

package/src/helpers/sqlite_manager.js

@@ -0,0 +1,138 @@
+import { enablePromise, openDatabase } from 'react-native-sqlite-storage';
+import { Scoped, SqliteCollective } from './variables';
+import { niceHash } from './peripherals';
+
+enablePromise(true);
+
+/**
+ * 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) => {
+
+    if (name?.projectUrl) {
+        const { projectUrl, dbUrl, dbName } = name;
+        name = encodeURIComponent(`${projectUrl}_${dbUrl}_${dbName}`) + '.db';
+    }
+
+    const { sqliteKey } = Scoped.ReleaseCacheData;
+
+    if (sqliteKey) name = `${niceHash(sqliteKey)}__${name}`;
+
+    if (!SqliteCollective.openedDb[name]) {
+        SqliteCollective.openedDbProcess[name] = 0;
+        SqliteCollective.openedDb[name] = (SqliteCollective.closeDbPromises[name] || Promise.resolve()).finally(() =>
+            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) => 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}`;
+
+    const sqlite = await openDB(builder);
+
+    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));
+        } catch (error) {
+            console.error('useSqliteLinearAccessId err:', error);
+            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 INTO ${table} (${columns.join(', ')}) VALUES (${columns.map(() => '?').join(', ')}) ON CONFLICT(${columns[0]}) DO UPDATE SET ${columns.slice(1).map(v => `${v} = excluded.${v}`).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}`
+}

package/src/helpers/utils.js

@@ -1,57 +1,103 @@
-import AsyncStorage from "@react-native-async-storage/async-storage";
 import { ServerReachableListener, StoreReadyListener } from "./listeners";
-import { CACHE_PROTOCOL, CACHE_STORAGE_PATH, DEFAULT_CACHE_PASSWORD, LOCAL_STORAGE_PATH } from "./values";
 import { CacheStore, Scoped } from "./variables";
-import { decryptString, encryptString, niceTry, serializeE2E } from "./peripherals";
+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";
 
-export const updateCacheStore = () => {
-    const { cachePassword = DEFAULT_CACHE_PASSWORD, cacheProtocol = CACHE_PROTOCOL.ASYNC_STORAGE, io } = Scoped.ReleaseCacheData;
+const { FILE_NAME, TABLE_NAME } = SQLITE_PATH;
 
-    clearTimeout(Scoped.cacheStorageReducer);
-    Scoped.cacheStorageReducer = setTimeout(() => {
-        const txt = encryptString(
-            JSON.stringify({ ...CacheStore }),
-            cachePassword,
-            cachePassword
-        );
+const CacheKeys = Object.keys(CacheStore);
+
+export const updateCacheStore = (timer = 300, node) => {
+    const { io, promoteCache } = Scoped.ReleaseCacheData;
+
+    const doUpdate = async () => {
+        const {
+            AuthStore,
+            EmulatedAuth,
+            PendingAuthPurge,
+            DatabaseStore,
+            PendingWrites,
+            ...restStore
+        } = CacheStore;
 
         if (io) {
-            io.output(txt);
-        } else if (cacheProtocol === CACHE_PROTOCOL.ASYNC_STORAGE) {
-            AsyncStorage.setItem(CACHE_STORAGE_PATH, txt);
+            const txt = JSON.stringify({
+                AuthStore,
+                EmulatedAuth,
+                PendingAuthPurge,
+                ...promoteCache ? {
+                    DatabaseStore: serializeToBase64(DatabaseStore),
+                    PendingWrites: serializeToBase64(PendingWrites)
+                } : {},
+                ...promoteCache ? restStore : {}
+            });
+
+            io.output(txt, node);
         } else {
-            const fs = require('react-native-fs');
-            fs.writeFile(LOCAL_STORAGE_PATH(), txt, 'utf8');
+            // 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.allSettled(
+                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();
         }
-    }, 500);
-}
+    };
+
+    clearTimeout(Scoped.cacheStorageReducer);
+    if (timer) {
+        Scoped.cacheStorageReducer = setTimeout(doUpdate, timer);
+    } else doUpdate();
+};
 
 export const releaseCacheStore = async (builder) => {
-    const { cachePassword = DEFAULT_CACHE_PASSWORD, cacheProtocol = CACHE_PROTOCOL.ASYNC_STORAGE, io } = builder;
+    const { io } = builder;
 
-    let txt;
+    let data = {};
 
-    if (io) {
-        txt = await io.input();
-    } else if (cacheProtocol === CACHE_PROTOCOL.ASYNC_STORAGE) {
-        txt = await niceTry(() => AsyncStorage.getItem(CACHE_STORAGE_PATH));
-    } else {
-        const fs = require('react-native-fs');
-        txt = await niceTry(() => fs.readFile(LOCAL_STORAGE_PATH(), 'utf8'));
+    try {
+        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 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 purgeRedundantRecords(data, builder);
+    } catch (e) {
+        console.error('releaseCacheStore data err:', e);
     }
 
-    const j = JSON.parse(decryptString(txt || '', cachePassword, cachePassword) || '{}');
-
-    Object.entries(j).forEach(([k, v]) => {
-        CacheStore[k] = v;
+    Object.entries(data).forEach(([k, v]) => {
+        if (['DatabaseStore', 'PendingWrites'].includes(k)) {
+            CacheStore[k] = deserializeBSON(v);
+        } else 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');
-    // TODO: commit pending write
-}
+};
+
+export const getPrefferTime = () => Date.now() + (Scoped.serverTimeOffset || 0);
 
 export const awaitStore = () => new Promise(resolve => {
     if (Scoped.IsStoreReady) {
@@ -92,26 +138,29 @@ export const getReachableServer = (projectUrl) => new Promise(resolve => {
     }, true);
 });
 
-export const buildFetchInterface = ({ body, accessKey, authToken, method, uglify, serverE2E_PublicKey }) => {
+export const buildFetchInterface = async ({ body, authToken, method, uglify, serverE2E_PublicKey, extraHeaders }) => {
     if (!uglify) body = JSON.stringify({ ...body });
-    const [plate, keyPair] = uglify ? serializeE2E(body, authToken, serverE2E_PublicKey) : [undefined, []];
+    const [plate, keyPair] = uglify ? await serializeE2E(body, authToken, serverE2E_PublicKey) : [undefined, []];
 
     return [{
         body: uglify ? plate : body,
-        cache: 'no-cache',
+        // cache: 'no-cache',
         headers: {
-            'Content-type': uglify ? 'text/plain' : 'application/json',
-            'Authorization': accessKey,
-            ...((authToken && !uglify) ? { 'Mosquito-Token': authToken } : {})
+            ...extraHeaders,
+            'Content-type': uglify ? 'request/buffer' : 'application/json',
+            ...(authToken && !uglify) ? { 'Mosquito-Token': authToken } : {}
         },
         method: method || 'POST'
     }, keyPair];
 };
 
-export const simplifyError = (error, message) => ({
-    simpleError: { error, message }
-});
-
-export const validateRequestMethod = (method) => {
-    // TODO:
-}
+export const buildFetchResult = async (fetchRef, ugly) => {
+    if (ugly) {
+        const [data, simpleError] = deserialize(await fetchRef.arrayBuffer());
+        if (simpleError) throw simpleError;
+        return data;
+    }
+    const json = await fetchRef.json();
+    if (json.simpleError) throw json;
+    return json;
+};

package/src/helpers/values.js

@@ -1,82 +1,28 @@
-import { Platform } from 'react-native';
-import { encodeBinary } from './peripherals';
-
-export const CACHE_STORAGE_PATH = encodeBinary('MOSQUITO_TRANSPORT_FREEZER'),
-    DEFAULT_CACHE_PASSWORD = encodeBinary('MOSQUITO_TRANSPORT_CACHE_PASSWORD'),
-    LOCAL_STORAGE_PATH = () => {
-        const fs = require('react-native-fs');
-        return `${Platform.OS === 'android' ? fs.ExternalCachesDirectoryPath : fs.CachesDirectoryPath}/${encodeBinary('MOSQUITO_TRANSPORT_STORAGE')}`;
-    },
-    DEFAULT_DB_NAME = 'DEFAULT_DB',
-    DEFAULT_DB_URL = 'mongodb://127.0.0.1:27017',
-    DEFAULT_ENCRYPT_IV = '****';
-
-export const CACHE_PROTOCOL = {
-    ASYNC_STORAGE: 'async-storage',
-    REACT_NATIVE_FS: 'reat-native-fs',
-    SQLITE: 'sqlite' // TODO:
-};
 
 export const RETRIEVAL = {
     STICKY: 'sticky',
     STICKY_NO_AWAIT: 'sticky-no-await',
     STICKY_RELOAD: 'sticky-reload',
     DEFAULT: 'default',
+    CACHE_AWAIT: 'cache-await',
     CACHE_NO_AWAIT: 'cache-no-await',
-    NO_CACHE_NO_AWAIT: 'no-cache-no-await'
+    NO_CACHE_NO_AWAIT: 'no-cache-no-await',
+    NO_CACHE_AWAIT: 'no-cache-await'
 };
 
 export const DELIVERY = {
     DEFAULT: 'default',
-    NO_CACHE: 'no-cache',
-    NO_AWAIT: 'no-await',
-    NO_AWAIT_NO_CACHE: 'no-await-no-cache',
-    AWAIT_NO_CACHE: 'await-no-cache',
-    CACHE_NO_AWAIT: 'cache-no-await'
-};
-
-export const WRITE_OPS = {
-    $SET: '$set',
-    $PUSH: '$push',
-    $PULL: '$pull',
-    $UNSET: '$unset',
-    $INC: '$inc',
-    $MAX: '$max',
-    $MIN: '$min',
-    $MUL: '$mul',
-    $RENAME: '$rename',
-    $SET_ON_INSERT: '$setOnInsert'
-};
-export const WRITE_OPS_LIST = Object.values(WRITE_OPS);
-
-export const READ_OPS = {
-    $IN: '$in',
-    $ALL: '$all',
-    $NIN: '$nin',
-    $GT: '$gt',
-    $GTE: '$gte',
-    $LT: '$lt',
-    $LTE: '$lte',
-    $TEXT: '$text',
-    // $EQ: '$eq',
-    // $REGEX: '$regex',
-    // $EXISTS: '$exists',
-    $NEAR: '$near',
-    $TYPE: '$type',
-    $SIZE: '$size',
-    // $NE: '$ne'
-};
-export const READ_OPS_LIST = Object.values(READ_OPS);
-
-export const Regexs = {
-    LINK: () => /(\b(https?|ftp):\/\/[-A-Z0-9+&@#\/%?=~_|!:,.;]*[-A-Z0-9+&@#\/%=~_|])/ig
+    CACHE_AWAIT: 'cache-await',
+    CACHE_NO_AWAIT: 'cache-no-await',
+    NO_CACHE_NO_AWAIT: 'no-cache-no-await',
+    NO_CACHE_AWAIT: 'no-cache-await'
 };
 
 export const AUTH_PROVIDER_ID = {
-    GOOGLE: 'google.com',
-    FACEBOOK: 'facebook.com',
+    GOOGLE: 'google',
+    FACEBOOK: 'facebook',
     PASSWORD: 'password',
-    TWITTER: 'x.com',
-    GITHUB: 'github.com',
-    APPLE: 'apple.com'
+    TWITTER: 'x',
+    GITHUB: 'github',
+    APPLE: 'apple'
 };