react-native-mosquito-transport 0.0.21 → 0.0.23

package/src/products/database/validator.js

@@ -1,7 +1,7 @@
 import { guardArray, GuardError, guardObject, GuardSignal, niceGuard, Validator } from "guard-object";
 import { sameInstance } from "../../helpers/peripherals";
 import { RETRIEVAL } from "../../helpers/values";
-import getLodash from 'lodash.get';
+import getLodash from 'lodash/get';
 import { Binary, BSONRegExp, BSONSymbol, Code, DBRef, Decimal128, Double, Int32, Long, MaxKey, MinKey, ObjectId, Timestamp, UUID } from 'bson';
 import { bboxPolygon, booleanIntersects, booleanWithin, circle, distance, polygon } from "@turf/turf";
 

package/src/products/http_callable/accessor.js

@@ -0,0 +1,77 @@
+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";
+
+const { FETCH_RESOURCES } = SQLITE_PATH;
+
+export const insertFetchResources = async (projectUrl, access_id, value) => {
+    value = cloneDeep(value);
+    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, dataSize - (b4?.size || 0));
+        CacheStore.FetchedStore[projectUrl][access_id] = {
+            touched: Date.now(),
+            data: value,
+            size: dataSize
+        };
+    } else {
+        const initNode = projectUrl;
+
+        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]
+            );
+            incrementFetcherSize(projectUrl, dataSize - (b4Data?.size || 0));
+        });
+    }
+
+    updateCacheStore(undefined, ['FetchedStore']);
+}
+
+export const getFetchResources = async (projectUrl, access_id) => {
+    const { io } = Scoped.ReleaseCacheData;
+
+    if (io) {
+        const record = CacheStore.FetchedStore[projectUrl]?.[access_id];
+        if (record) record.touched = Date.now();
+        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 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/counter.js

@@ -0,0 +1,11 @@
+import { CacheStore } from "../../helpers/variables";
+import getLodash from 'lodash/get';
+import setLodash from 'lodash/set';
+
+export const incrementFetcherSize = (projectUrl, size = 0) => incrementFetcherSizeCore(CacheStore.DatabaseStats, projectUrl, size);
+
+export const incrementFetcherSizeCore = (baseObj, projectUrl, size = 0) => {
+    baseObj._fetcher_size += size;
+    const b4 = getLodash(baseObj.fetchers, [projectUrl], 0);
+    setLodash(baseObj.fetchers, [projectUrl], b4 + size);
+}

package/src/products/http_callable/index.js

@@ -1,15 +1,16 @@
 import { Buffer } from "buffer";
 import { deserializeE2E, listenReachableServer, niceHash, normalizeRoute, serializeE2E } from "../../helpers/peripherals";
-import { awaitStore, getReachableServer, updateCacheStore } from "../../helpers/utils";
+import { awaitStore, getReachableServer } from "../../helpers/utils";
 import { RETRIEVAL } from "../../helpers/values";
-import { CacheStore, Scoped } from "../../helpers/variables";
+import { Scoped } from "../../helpers/variables";
 import { awaitRefreshToken } from "../auth/accessor";
 import { simplifyCaughtError } from "simplify-error";
 import { guardObject, Validator } from "guard-object";
-import cloneDeep from "lodash.clonedeep";
+import cloneDeep from "lodash/cloneDeep";
 import { serialize } from "entity-serializer";
+import { getFetchResources, insertFetchResources } from "./accessor";
 
-const buildFetchData = (data) => {
+const buildFetchData = (data, extras) => {
     const { ok, type, status, statusText, redirected, url, headers, size, base64 } = data;
 
     const response = new Response(Buffer.from(base64, 'base64'), {
@@ -20,7 +21,7 @@ const buildFetchData = (data) => {
         size
     });
 
-    Object.entries({ ok, type, url, redirected, size })
+    Object.entries({ ok, type, url, redirected, size, ...extras })
         .forEach(([k, v]) => {
             if (response[k] !== v)
                 Object.defineProperty(response, k, {
@@ -33,7 +34,7 @@ const buildFetchData = (data) => {
 }
 
 export const mfetch = async (input = '', init, config) => {
-    const { projectUrl, serverE2E_PublicKey, method, maxRetries = 7, disableCache, accessKey, uglify, extraHeaders } = config;
+    const { projectUrl, serverE2E_PublicKey, method, maxRetries = 1, disableCache = false, uglify, extraHeaders } = config;
     const { headers, body } = init || {};
 
     if (method !== undefined)
@@ -45,24 +46,22 @@ export const mfetch = async (input = '', init, config) => {
         }).validate(method);
 
     const { retrieval = RETRIEVAL.DEFAULT, enableMinimizer, rawApproach } = method || {};
-    const isBaseUrl = Validator.LINK(input);
+    const isLink = Validator.LINK(input);
+    const isBaseUrl = isLink || rawApproach;
     const disableAuth = method?.disableAuth || isBaseUrl;
-    const shouldCache = (retrieval !== RETRIEVAL.DEFAULT || !disableCache) &&
-        retrieval !== RETRIEVAL.NO_CACHE_NO_AWAIT;
+    const hasBody = body !== undefined;
+    const shouldCache = (retrieval !== RETRIEVAL.DEFAULT || (config.disableCache === undefined ? !hasBody : !disableCache)) &&
+        ![RETRIEVAL.NO_CACHE_NO_AWAIT, RETRIEVAL.NO_CACHE_AWAIT].includes(retrieval);
     const uglified = !!(!isBaseUrl && uglify);
 
     const rawHeader = Object.fromEntries(
         [...new Headers(headers).entries()]
     );
 
-    if ('mtoken' in rawHeader)
-        throw '"mtoken" in header is a reserved prop';
-
-    if ('uglified' in rawHeader)
-        throw '"uglified" in header is a reserved prop';
-
-    // if (isBaseUrl && !rawApproach)
-    //     throw `please set { rawApproach: true } if you're trying to access different endpoint at "${input}"`;
+    ['mtoken', 'uglified'].forEach(e => {
+        if ([e] in rawHeader)
+            throw `"${e}" in header is a reserved prop`;
+    });
 
     if (body !== undefined) {
         if (
@@ -80,6 +79,7 @@ export const mfetch = async (input = '', init, config) => {
             input
         ]).toString('base64')
     );
+    const processReqId = `${reqId}_${disableCache}_${retrieval}`;
 
     let retries = 0, hasFinalize;
 
@@ -93,44 +93,41 @@ export const mfetch = async (input = '', init, config) => {
             hasFinalize = true;
 
             if (enableMinimizer) {
-                (Scoped.PendingFetchCollective.pendingResolution[reqId] || []).forEach(e => {
+                const resolutionList = (Scoped.PendingFetchCollective[processReqId] || []).slice(0);
+
+                if (Scoped.PendingFetchCollective[processReqId])
+                    delete Scoped.PendingFetchCollective[processReqId];
+
+                resolutionList.forEach(e => {
                     e(a, b);
                 });
-                if (Scoped.PendingFetchCollective.pendingResolution[reqId])
-                    delete Scoped.PendingFetchCollective.pendingResolution[reqId];
-
-                if (Scoped.PendingFetchCollective.pendingProcess[reqId])
-                    delete Scoped.PendingFetchCollective.pendingProcess[reqId];
             }
         };
 
         await awaitStore();
-        const reqData = CacheStore.FetchedStore[projectUrl]?.[reqId];
-        const resolveCache = () => {
-            finalize({
-                ...buildFetchData(reqData),
-                fromCache: true
-            });
+        const resolveCache = (reqData) => {
+            finalize(buildFetchData(reqData), { fromCache: true });
         };
 
         try {
             if (retryProcess === 1) {
                 if (enableMinimizer) {
-                    if (Scoped.PendingFetchCollective.pendingProcess[reqId]) {
-                        if (!Scoped.PendingFetchCollective.pendingResolution[reqId])
-                            Scoped.PendingFetchCollective.pendingResolution[reqId] = [];
-
-                        Scoped.PendingFetchCollective.pendingResolution[reqId].push((a, b) => {
+                    if (Scoped.PendingFetchCollective[processReqId]) {
+                        Scoped.PendingFetchCollective[processReqId].push((a, b) => {
                             if (a) resolve(cloneDeep(a.result));
                             else reject(cloneDeep(b));
                         });
                         return;
                     }
-                    Scoped.PendingFetchCollective.pendingProcess[reqId] = true;
+                    Scoped.PendingFetchCollective[processReqId] = [];
                 }
 
-                if (retrieval.startsWith('sticky') && reqData) {
-                    resolveCache();
+                let reqData;
+                if (
+                    retrieval.startsWith('sticky') &&
+                    (reqData = await getFetchResources(projectUrl, reqId))
+                ) {
+                    resolveCache(reqData);
                     if (retrieval !== RETRIEVAL.STICKY_RELOAD) return;
                 }
             }
@@ -140,25 +137,26 @@ export const mfetch = async (input = '', init, config) => {
 
             const mtoken = Scoped.AuthJWTToken[projectUrl];
             const initType = rawHeader['content-type'];
+            const encodeBody = initType === undefined && hasBody && !isBaseUrl;
 
             const [reqBuilder, [privateKey]] = uglified ? await serializeE2E(body, mtoken, serverE2E_PublicKey) : [null, []];
 
-            const f = await fetch(isBaseUrl ? input : `${projectUrl}/${normalizeRoute(input)}`, {
-                ...isBaseUrl ? {} : { method: 'POST' },
+            const f = await fetch(isLink ? input : `${projectUrl}/${normalizeRoute(input)}`, {
+                ...(!isBaseUrl || hasBody) ? { method: 'POST' } : {},
                 ...init,
-                ...uglified ? { body: reqBuilder } : {},
-                cache: 'no-cache',
+                ...uglified ? { body: reqBuilder } : encodeBody ? { body: serialize(body) } : {},
+                // cache: 'no-cache',
                 headers: {
                     ...extraHeaders,
-                    ...isBaseUrl ? {} : { 'content-type': 'application/json' },
                     ...rawHeader,
                     ...uglified ? {
                         uglified,
                         'content-type': 'request/buffer',
                         ...initType ? { 'init-content-type': initType } : {}
-                    } : {},
-                    ...(disableAuth || !mtoken || uglified || isBaseUrl) ? {} : { mtoken },
-                    ...isBaseUrl ? {} : { authorization: `Bearer ${accessKey}` }
+                    } : encodeBody
+                        ? { 'content-type': 'request/buffer', 'entity-encoded': '1' }
+                        : {},
+                    ...(disableAuth || !mtoken || uglified || isBaseUrl) ? {} : { mtoken }
                 }
             });
             const { ok, type, status, statusText, redirected, url, headers, size } = f;
@@ -184,46 +182,42 @@ export const mfetch = async (input = '', init, config) => {
                 )
             };
 
-            if (shouldCache) {
-                if (!CacheStore.FetchedStore[projectUrl])
-                    CacheStore.FetchedStore[projectUrl] = {};
-                CacheStore.FetchedStore[projectUrl][reqId] = cloneDeep(resObj);
-                updateCacheStore();
-            }
+            if (shouldCache) insertFetchResources(projectUrl, reqId, resObj);
 
             finalize(buildFetchData(resObj));
         } catch (e) {
+            let thisRecord;
+
+            const getThisRecord = async () => thisRecord ? thisRecord[0]
+                : (thisRecord = [await getFetchResources(projectUrl, reqId)])[0];
+
             if (e?.simpleError) {
                 finalize(undefined, e.simpleError);
             } else if (
-                (retrieval === RETRIEVAL.CACHE_NO_AWAIT && !reqData) ||
+                (retrieval === RETRIEVAL.CACHE_NO_AWAIT && !(await getThisRecord())) ||
                 retrieval === RETRIEVAL.STICKY_NO_AWAIT ||
                 retrieval === RETRIEVAL.NO_CACHE_NO_AWAIT
             ) {
                 finalize(undefined, simplifyCaughtError(e).simpleError);
             } else if (
                 shouldCache &&
-                (retrieval === RETRIEVAL.DEFAULT || retrieval === RETRIEVAL.CACHE_NO_AWAIT) &&
-                reqData
+                [
+                    RETRIEVAL.DEFAULT,
+                    RETRIEVAL.CACHE_NO_AWAIT,
+                    RETRIEVAL.CACHE_AWAIT
+                ].includes(retrieval) &&
+                await getThisRecord()
             ) {
-                resolveCache();
-            } else if (retries >= maxRetries) {
+                resolveCache(await getThisRecord());
+            } else if (retries > maxRetries) {
                 finalize(undefined, simplifyCaughtError(e).simpleError);
             } else {
                 const listener = listenReachableServer(async online => {
                     if (online) {
                         listener();
                         callFetch().then(
-                            e => {
-                                if (retryProcess === 1) {
-                                    finalize(e);
-                                } else resolve(e);
-                            },
-                            e => {
-                                if (retryProcess === 1) {
-                                    finalize(undefined, e);
-                                } else reject(e);
-                            }
+                            e => finalize(e),
+                            e => finalize(undefined, e)
                         );
                     }
                 }, projectUrl);
@@ -231,5 +225,5 @@ export const mfetch = async (input = '', init, config) => {
         }
     });
 
-    return await callFetch();
+    return (await callFetch());
 };

package/src/products/storage/index.js

@@ -1,8 +1,8 @@
 import EngineApi from "../../helpers/engine_api";
-import { encodeBinary, prefixStoragePath } from "../../helpers/peripherals";
+import { deserializeE2E, prefixStoragePath } from "../../helpers/peripherals";
 import { Scoped } from "../../helpers/variables";
 import { DeviceEventEmitter, NativeEventEmitter, NativeModules, Platform } from 'react-native';
-import { awaitReachableServer, buildFetchInterface } from "../../helpers/utils";
+import { awaitReachableServer, buildFetchInterface, buildFetchResult } from "../../helpers/utils";
 import { awaitRefreshToken } from "../auth/accessor";
 import { simplifyError } from "simplify-error";
 
@@ -31,7 +31,7 @@ export class MTStorage {
         const { awaitServer } = options || {};
         let hasFinished, isPaused, hasCancelled;
 
-        const { projectUrl, accessKey, extraHeaders } = this.builder;
+        const { projectUrl, extraHeaders } = this.builder;
 
         if (destination && (typeof destination !== 'string' || !destination.trim())) {
             onComplete?.({ error: 'destination_invalid', message: 'destination must be a non-empty string' });
@@ -98,7 +98,6 @@ export class MTStorage {
                 } : {},
                 processID,
                 urlName: link.split('/').pop(),
-                authorization: `Bearer ${encodeBinary(accessKey)}`,
                 extraHeaders: extraHeaders || {},
             });
         }
@@ -136,7 +135,7 @@ export class MTStorage {
 
         file = isAsset ? file.trim() : prefixStoragePath(file.trim());
 
-        const { projectUrl, accessKey, uglify, extraHeaders } = this.builder;
+        const { projectUrl, uglify, extraHeaders } = this.builder;
         const processID = `${++Scoped.StorageProcessID}`;
 
         const init = async () => {
@@ -171,7 +170,6 @@ export class MTStorage {
                 createHash: createHash ? 'yes' : 'no',
                 destination,
                 processID,
-                authorization: `Bearer ${encodeBinary(accessKey)}`,
                 extraHeaders: extraHeaders || {}
             });
         }
@@ -192,16 +190,25 @@ export class MTStorage {
     deleteFolder = (path) => deleteContent(this.builder, path, true);
 }
 
+const { _deleteFile, _deleteFolder } = EngineApi;
+
 const deleteContent = async (builder, path, isFolder) => {
-    const { projectUrl, accessKey, uglify } = builder;
+    const { projectUrl, uglify, extraHeaders, serverE2E_PublicKey } = builder;
 
     try {
-        const r = await (await fetch(
-            EngineApi[isFolder ? '_deleteFolder' : '_deleteFile'](projectUrl, uglify),
-            await buildFetchInterface({ path }, accessKey, Scoped.AuthJWTToken[projectUrl], 'DELETE')
-        )).json();
-        if (r.simpleError) throw r;
-        if (r.status !== 'success') throw 'operation not successful';
+        const [reqBuilder, [privateKey]] = await buildFetchInterface({
+            method: 'DELETE',
+            authToken: Scoped.AuthJWTToken[projectUrl],
+            body: { path },
+            extraHeaders,
+            serverE2E_PublicKey,
+            uglify
+        });
+
+        const data = await buildFetchResult(await fetch((isFolder ? _deleteFolder : _deleteFile)(projectUrl, uglify), reqBuilder), uglify);
+        const result = uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data;
+
+        if (result.status !== 'success') throw 'operation not successful';
     } catch (e) {
         if (e?.simpleError) throw e.simpleError;
         throw simplifyError('unexpected_error', `${e}`).simpleError;