mosquito-transport-js 0.2.8 → 0.2.9

package/.jshintignore

@@ -0,0 +1,2 @@
+node_modules/
+dist/

package/.jshintrc

@@ -0,0 +1,15 @@
+{
+    "undef": true,  // Warns on variables used before declaration
+    "esversion": 12,
+    "globals": {
+        "process": true,
+        "clearTimeout": true,
+        "setTimeout": true,
+        "console": true,
+        "Buffer": true,
+        "clearInterval": true,
+        "setInterval": true,
+        "AbortController": true,
+        "URLSearchParams": true
+    }
+}

package/TODO

@@ -3,4 +3,7 @@
 - reauthenticate
 - change `Object` in d.ts to [key: string]: any
 - add `getServerTimeOffset` method
-- change null to undefined in `value`
+- change null to undefined in `value`
+- `provide functionality to add extra header to MT instance (all outgoing request)`
+- borrowToken
+- `add sqlite`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mosquito-transport-js",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "Javascript web sdk for mosquito-transport (https://github.com/deflexable/mosquito-transport)",
   "main": "src/index.js",
   "type": "module",
@@ -28,18 +28,18 @@
   },
   "homepage": "https://github.com/brainbehindx/mosquito-transport-js#readme",
   "dependencies": {
-    "@types/crypto-js": "^4.2.1",
-    "@types/lodash": "^4.14.194",
+    "@turf/turf": "^7.1.0",
+    "bson": "^6.8.0",
     "buffer": "^6.0.3",
     "crypto-js": "^4.2.0",
-    "fast-json-stable-stringify": "^2.1.0",
-    "guard-object": "^1.0.9",
+    "guard-object": "^1.1.0",
     "json-buffer": "^3.0.1",
+    "lodash.clonedeep": "^4.5.0",
     "lodash.get": "^4.4.2",
-    "lodash.isequal": "^4.5.0",
     "lodash.set": "^4.3.2",
     "lodash.unset": "^4.5.2",
     "set-large-timeout": "^1.0.1",
+    "simplify-error": "^1.0.1",
     "socket.io-client": "^4.6.2",
     "subscription-listener": "^1.1.2",
     "tweetnacl": "^1.0.3"

package/src/helpers/broadcaster.js

@@ -0,0 +1,53 @@
+import { initTokenRefresher, triggerAuthToken } from "../products/auth/accessor";
+import { notifyDatabaseNodeChanges, revertChanges, syncCache } from "../products/database/accessor";
+import { deserializeBSON } from "../products/database/bson";
+import { TokenRefreshListener } from "./listeners";
+import { awaitStore } from "./utils";
+import { CacheStore, Scoped } from "./variables";
+
+const InstanceID = `${Math.random()}`;
+const broadcaster = new BroadcastChannel('MT_BROADCASTER');
+
+broadcaster.onmessage = async (e) => {
+    const { kind, context, data } = JSON.parse(e.data);
+    if (context === InstanceID) return;
+    await awaitStore();
+
+    if (kind === 'auth') {
+        const { projectUrl, authData } = data;
+        CacheStore.AuthStore[projectUrl] = authData;
+        Scoped.AuthJWTToken[projectUrl] = authData?.token;
+        TokenRefreshListener.dispatch(projectUrl);
+        triggerAuthToken(projectUrl);
+        initTokenRefresher(Scoped.InitializedProject[projectUrl]);
+    } else if (kind === 'database-sync') {
+        // only if cache protocol is in-memory
+        const { builder, result, writeId } = data;
+        const { editions, pathChanges } = syncCache(builder, deserializeBSON(result)._);
+        Scoped.broadcastedWrites[writeId] = { editions, builder };
+        notifyDatabaseNodeChanges(builder, pathChanges);
+    } else if (kind === 'database-revert') {
+        // only if cache protocol is in-memory
+        const { writeId, revert } = data;
+        if (!Scoped.broadcastedWrites[writeId]) return;
+
+        const { editions, builder } = Scoped.broadcastedWrites[writeId];
+        if (revert) {
+            const pathChanges = revertChanges(builder, editions);
+            notifyDatabaseNodeChanges(builder, pathChanges);
+        }
+        delete Scoped.broadcastedWrites[writeId];
+    }
+};
+
+const sendMessage = (event, data) => {
+    broadcaster.postMessage(
+        JSON.stringify({
+            kind: event,
+            context: InstanceID,
+            data
+        })
+    );
+};
+
+export default sendMessage;

package/src/helpers/engine_api.js

@@ -0,0 +1,39 @@
+import { encodeBinary } from './peripherals';
+
+const EngineApiBase = (baseApi, ugly, path) => {
+    const url = new URL(baseApi);
+    if (ugly) {
+        url.pathname = `/e2e/${encodeBinary(path)}`;
+    } else url.pathname = path;
+    return url.href;
+};
+
+const apis = {
+    _readDocument: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_readDocument'),
+    _queryCollection: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_queryCollection'),
+    _documentCount: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_documentCount'),
+    _writeDocument: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_writeDocument'),
+    _writeMapDocument: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_writeMapDocument'),
+    _customSignin: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_customSignin'),
+    _customSignup: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_customSignup'),
+    _googleSignin: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_googleSignin'),
+    _appleSignin: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_appleSignin'),
+    _facebookSignin: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_facebookSignin'),
+    _twitterSignin: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_twitterSignin'),
+    _githubSignin: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_githubSignin'),
+    _signOut: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_signOut'),
+    _refreshAuthToken: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_refreshAuthToken'),
+    _uploadFile: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_uploadFile'),
+    _deleteFile: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_deleteFile'),
+    _deleteFolder: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_deleteFolder'),
+    staticStorage: (baseApi) => `${baseApi}/storage`,
+    _areYouOk: (baseApi) => `${baseApi}/_areYouOk`,
+    // static path
+    _listenCollection: (ugly) => ugly ? encodeBinary(apis._listenCollection()) : '_listenCollection',
+    _listenDocument: (ugly) => ugly ? encodeBinary(apis._listenDocument()) : '_listenDocument',
+    _startDisconnectWriteTask: (ugly) => ugly ? encodeBinary(apis._startDisconnectWriteTask()) : '_startDisconnectWriteTask',
+    _cancelDisconnectWriteTask: (ugly) => ugly ? encodeBinary(apis._cancelDisconnectWriteTask()) : '_cancelDisconnectWriteTask',
+    _listenUserVerification: (ugly) => ugly ? encodeBinary(apis._listenUserVerification()) : '_listenUserVerification'
+};
+
+export default { ...apis };

package/src/helpers/peripherals.js

@@ -3,123 +3,33 @@ import { ServerReachableListener } from "./listeners";
 import aes_pkg from 'crypto-js/aes.js';
 import Utf8Encoder from 'crypto-js/enc-utf8.js';
 import naclPkg from 'tweetnacl';
+import getLodash from "lodash.get";
 
 const { encrypt, decrypt } = aes_pkg;
 const { box, randomBytes } = naclPkg;
 
-export const simplifyError = (error, message) => ({
-    simpleError: { error, message }
-});
-
-export const simplifyCaughtError = (e) => e?.simpleError ? e : simplifyError('unexpected_error', `${e}`);
-
-export const everyEntrie = (obj, callback) => {
-    if (typeof obj !== 'object' || Array.isArray(obj)) return;
-    oEntries(obj).forEach(e => {
-        callback?.(e);
-    });
-}
-
-export const flatEntries = (obj) => oEntries(obj);
-
-export const flatRawEntries = () => oEntries(obj, false);
-
-export const oEntries = (obj, includeObj = true) => {
-    let o = [];
-
-    Object.entries(obj).forEach(e => {
-        o.push(e);
-        if (e[1] && typeof e[1] === 'object' && !Array.isArray(e[1])) {
-            o = [...o, ...oEntries(e[1])];
-        }
-    });
-
-    return o.filter(v => includeObj || typeof v[1] !== 'object' || Array.isArray(v[1]));
-}
-
-export const IS_RAW_OBJECT = (e) => e && typeof e === 'object' && !Array.isArray(e) && !(e instanceof Date);
-
-export const IS_WHOLE_NUMBER = (v) => typeof v === 'number' && !`${v}`.includes('.');
-
-export const IS_DECIMAL_NUMBER = (v) => typeof v === 'number' && `${v}`.includes('.');
-
-export const queryEntries = (obj, lastPath = '', exceptions = [], seperator = '.') => {
-    let o = [];
-    const isArraySeperator = Array.isArray(lastPath);
-
-    Object.entries(obj).forEach(([key, value]) => {
-        if (IS_RAW_OBJECT(value) && !exceptions.includes(key)) {
-            o = [
-                ...o,
-                ...queryEntries(
-                    value,
-                    isArraySeperator ? [...lastPath, key] : `${lastPath}${key}${seperator}`,
-                    exceptions,
-                    seperator
-                )
-            ];
-        } else o.push(isArraySeperator ? [[...lastPath, key], value] : [`${lastPath}${key}`, value]);
-    });
-
-    return o;
-}
-
-export const objToUniqueString = (obj) => {
-    const keys = [],
-        values = [];
-
-    if (Array.isArray(obj)) {
-        obj.forEach(e => {
-            if (IS_RAW_OBJECT(e)) {
-                queryEntries(e).map(([k, v]) => {
-                    keys.push(k);
-                    values.push(v);
-                });
-            } else keys.push(Array.isArray(e) ? JSON.stringify(e) : `${e}`);
-        });
-    } else if (!IS_RAW_OBJECT(obj))
-        return `${obj}`;
-    else
-        queryEntries(obj).map(([k, v]) => {
-            keys.push(k);
-            values.push(v);
-        });
-
-    return [
-        ...keys.sort(),
-        ...values.map(v => `${Array.isArray(v) ? JSON.stringify(v) : v}`).sort()
-    ].join(',');
-}
-
-export const cloneInstance = (v) => {
-    if (v && typeof v === 'object') {
-        return Array.isArray(v) ? [...v] : { ...v };
-    }
-    return v;
-}
-
 export const listenReachableServer = (callback, projectUrl) => {
     let lastValue;
     return ServerReachableListener.listenTo(projectUrl, t => {
         if (typeof t === 'boolean' && t !== lastValue) callback?.(t);
     }, true);
-}
+};
 
 export const prefixStoragePath = (path, prefix = 'file:///') => {
-    if (!path) return path;
+    let cleanedPath = path.replace(/^[^/]+:\/{1,3}/, '');
 
-    if (!path.startsWith('/') && !path.includes(':')) return prefix + path;
+    // Continuously remove any remaining protocol patterns until none are left
+    while (/^[^/]+:\/{1,3}/.test(cleanedPath)) {
+        cleanedPath = cleanedPath.replace(/^[^/]+:\/{1,3}/, '');
+    }
 
-    return prefix + path.split('/').filter((v, i) => i && v).join('/');
-}
+    // Remove any leading slashes after protocol removal
+    cleanedPath = cleanedPath.replace(/^\/+/, '');
 
-export const getUrlExtension = (url) => {
-    const r = url.split(/[#?]/)[0].split(".").pop().trim();
-    return r === url ? '' : r;
-}
+    return `${prefix}${cleanedPath}`;
+};
 
 export const niceTry = (promise) => new Promise(async resolve => {
-
     try {
         const r = await promise();
         resolve(r);
@@ -143,21 +53,50 @@ export const shuffleArray = (n) => {
 }
 
 export function sortArrayByObjectKey(arr = [], key) {
-    return arr.slice(0).sort(function (a, b) {
+    return arr.sort(function (a, b) {
         const left = getLodash(a, key),
             right = getLodash(b, key);
 
         return (left > right) ? 1 : (left < right) ? -1 : 0;
     });
-}
+};
+
+export async function niceHash(str) {
+    try {
+        // Convert the string to a Uint8Array
+        const encoder = new TextEncoder();
+        const data = encoder.encode(str);
+
+        // Use the Web Crypto API to compute the hash
+        const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+
+        // Convert the ArrayBuffer to a hex string for readability
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        const hashHex = hashArray.map(byte => byte.toString(16).padStart(2, '0')).join('');
+
+        // Convert to base64
+        return Buffer.from(hashHex, 'hex').toString('base64');
+    } catch (_) {
+        return str;
+    }
+};
+
+export const sameInstance = (var1, var2) => {
+    try {
+        return var1.constructor === var2.constructor &&
+            Object.getPrototypeOf(var1) === Object.getPrototypeOf(var2)
+    } catch (_) {
+        return false;
+    }
+};
 
 export const encryptString = (txt, password, iv) => {
     return encrypt(txt, `${password || ''}${iv || ''}`).toString();
-}
+};
 
 export const decryptString = (txt, password, iv) => {
     return decrypt(txt, `${password || ''}${iv || ''}`).toString(Utf8Encoder);
-}
+};
 
 export const serializeE2E = (data, auth_token, serverPublicKey) => {
     const pair = box.keyPair(),
@@ -179,7 +118,7 @@ export const serializeE2E = (data, auth_token, serverPublicKey) => {
         ).toString('base64')}`,
         [pair.secretKey, pair.publicKey]
     ];
-}
+};
 
 export const deserializeE2E = (data, serverPublicKey, clientPrivateKey) => {
     const [binaryNonce, binaryData] = data.split('.'),
@@ -192,7 +131,7 @@ export const deserializeE2E = (data, serverPublicKey, clientPrivateKey) => {
 
     if (!baseArray) throw 'Decrypting e2e message failed';
     return JSON.parse(Buffer.from(baseArray).toString('utf8'))[0];
-}
+};
 
 export const encodeBinary = (s) => Buffer.from(s, 'utf8').toString('base64');
 export const decodeBinary = (s) => Buffer.from(s, 'base64').toString('utf8');

package/src/helpers/utils.js

@@ -2,19 +2,31 @@ import { ServerReachableListener, StoreReadyListener } from "./listeners";
 import { CACHE_PROTOCOL, CACHE_STORAGE_PATH, DEFAULT_CACHE_PASSWORD } from "./values";
 import { CacheStore, Scoped } from "./variables";
 import { decryptString, encryptString, serializeE2E } from "./peripherals";
+import { deserializeBSON, serializeToBase64 } from "../products/database/bson";
+import { trySendPendingWrite } from "../products/database";
 
-export const updateCacheStore = () => {
+export const updateCacheStore = (timer = 300) => {
     try { window } catch (_) { return; }
     const {
         cachePassword = DEFAULT_CACHE_PASSWORD,
         cacheProtocol = CACHE_PROTOCOL.LOCAL_STORAGE,
-        io
+        io,
+        promoteCache
     } = Scoped.ReleaseCacheData;
 
     clearTimeout(Scoped.cacheStorageReducer);
     Scoped.cacheStorageReducer = setTimeout(() => {
+        const { AuthStore, DatabaseStore, PendingWrites, ...restStore } = CacheStore;
+
         const txt = encryptString(
-            JSON.stringify({ ...CacheStore }),
+            JSON.stringify({
+                AuthStore,
+                ...promoteCache ? {
+                    DatabaseStore: serializeToBase64(DatabaseStore),
+                    PendingWrites: serializeToBase64(PendingWrites)
+                } : {},
+                ...promoteCache ? restStore : {}
+            }),
             cachePassword,
             cachePassword
         );
@@ -24,8 +36,8 @@ export const updateCacheStore = () => {
         } else if (cacheProtocol === CACHE_PROTOCOL.LOCAL_STORAGE) {
             window.localStorage.setItem(CACHE_STORAGE_PATH, txt);
         }
-    }, 500);
-}
+    }, timer);
+};
 
 export const releaseCacheStore = async (builder) => {
     try { window } catch (_) { return; }
@@ -44,17 +56,26 @@ export const releaseCacheStore = async (builder) => {
     }
 
     const j = JSON.parse(decryptString(txt || '', cachePassword, cachePassword) || '{}');
+    const projectList = new Set([]);
 
     Object.entries(j).forEach(([k, v]) => {
-        CacheStore[k] = v;
+        if (['DatabaseStore', 'PendingWrites'].includes(k)) {
+            CacheStore[k] = deserializeBSON(v);
+        } else CacheStore[k] = v;
+        projectList.add(k);
     });
     Object.entries(CacheStore.AuthStore).forEach(([key, value]) => {
         Scoped.AuthJWTToken[key] = value?.token;
     });
+    projectList.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) {
@@ -109,12 +130,4 @@ export const buildFetchInterface = ({ body, accessKey, authToken, method, uglify
         },
         method: method || 'POST'
     }, keyPair];
-};
-
-export const simplifyError = (error, message) => ({
-    simpleError: { error, message }
-});
-
-export const validateRequestMethod = (method) => {
-    // TODO:
-}
+};

package/src/helpers/values.js

@@ -1,10 +1,7 @@
 import { encodeBinary } from './peripherals';
 
 export const CACHE_STORAGE_PATH = encodeBinary('MOSQUITO_TRANSPORT_FREEZER'),
-    DEFAULT_CACHE_PASSWORD = encodeBinary('MOSQUITO_TRANSPORT_CACHE_PASSWORD'),
-    DEFAULT_DB_NAME = 'DEFAULT_DB',
-    DEFAULT_DB_URL = 'mongodb://127.0.0.1:27017',
-    DEFAULT_ENCRYPT_IV = '****';
+    DEFAULT_CACHE_PASSWORD = encodeBinary('MOSQUITO_TRANSPORT_CACHE_PASSWORD');
 
 export const CACHE_PROTOCOL = {
     LOCAL_STORAGE: 'local-storage'
@@ -16,7 +13,8 @@ export const RETRIEVAL = {
     STICKY_RELOAD: 'sticky-reload',
     DEFAULT: 'default',
     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 = {
@@ -28,43 +26,6 @@ export const DELIVERY = {
     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
-};
-
 export const AUTH_PROVIDER_ID = {
     GOOGLE: 'google.com',
     FACEBOOK: 'facebook.com',

package/src/helpers/variables.js

@@ -1,4 +1,6 @@
+
 export const Scoped = {
+    serverTimeOffset: undefined,
     PendingIte: 0,
     AnyProcessIte: 0,
     IS_CONNECTED: {},
@@ -19,16 +21,21 @@ export const Scoped = {
     PendingDbReadCollective: {
         pendingProcess: {},
         pendingResolution: {}
-    }
-}
+    },
+    ActiveDatabaseListeners: {},
+    OutgoingWrites: {},
+    /**
+     * @type {Promise<any> | undefined}
+     */
+    dispatchingWritesPromise: undefined,
+    broadcastedWrites: {}
+};
 
 export const CacheStore = {
     DatabaseStore: {},
-    DatabaseRecords: {},
     DatabaseCountResult: {},
+    DatabaseStats: {},
     AuthStore: {},
     PendingWrites: {},
     FetchedStore: {}
-}
-
-export const CacheConstant = { ...CacheStore };
+};

package/src/index.d.ts

@@ -1,10 +1,12 @@
 interface MTConfig {
     dbName?: string;
     dbUrl?: string;
-    heapMemory?: number;
     projectUrl: string;
     disableCache?: boolean;
     accessKey: string;
+    /**
+     * maximum numbers of attempts to retry sending a request
+     */
     maxRetries?: number;
     /**
      * setting this to true will encrypt all outgoing and incoming request. This enables end-to-end encryption using [Tweetnacl](https://github.com/dchest/tweetnacl-js) and to prevent request interception by browser extensions, network intermediaries or other hijacking tools
@@ -14,6 +16,12 @@ interface MTConfig {
      * this is the base64 public key for end-to-end encryption on the server
      */
     serverE2E_PublicKey?: string;
+    /**
+     * true to deserialize BSON values to their Node.js closest equivalent types
+     * 
+     * @default true
+     */
+    castBSON?: boolean;
 }
 
 interface GetDatabase {
@@ -34,7 +42,7 @@ export function GEO_JSON(latitude: latitude, longitude: longitude): {
 };
 
 export function FIND_GEO_JSON(coordinates: [latitude, longitude], offSetMeters: number, centerMeters?: number): {
-    $near: {
+    $nearSphere: {
         $geometry: {
             type: "Point",
             coordinates: [longitude, latitude]
@@ -76,7 +84,7 @@ interface ReleaseCacheOption_IO {
          * emits mosquito-transport internal data
          */
         output: (data: string) => void;
-    }
+    };
 }
 
 interface ReleaseCacheOption {
@@ -88,7 +96,18 @@ interface ReleaseCacheOption {
      * select the mechanism for storing data locally
      * - local-storage: uses [@react-native-async-storage/async-storage]() for storing data
      */
-    cacheProtocol?: 'local-storage';
+    cacheProtocol?: 'local-storage' | 'indexdb';
+    /**
+     * the maximum database size
+     */
+    heapMemory?: number;
+    /**
+     * true to cache database and {@link MosquitoTransport.fetchHttp} data.
+     * the value only applies to in-memory storage protocol such as `io` and `local-storage`
+     * 
+     * @default false
+     */
+    promoteCache?: boolean;
 }
 
 interface MTSocket {
@@ -243,7 +262,7 @@ interface WriteConfig {
     delivery?: Delievery;
 }
 
-type Retrieval = 'sticky' | 'sticky-no-await' | 'sticky-reload' | 'default' | 'cache-no-await' | 'no-cache-no-await';
+type Retrieval = 'sticky' | 'sticky-no-await' | 'sticky-reload' | 'default' | 'cache-no-await' | 'no-cache-no-await' | 'no-cache-await';
 
 interface GetConfig {
     excludeFields?: string | string[];
@@ -252,17 +271,19 @@ interface GetConfig {
     /**
      * This property determines how requested data is being access and handled
      * 
-     * - default: we try getting fresh data from server if server is reachable, else we check if local data exists and return it, if no local data exist we await for client->server connectivity, then try getting the data, return it and cache it for future need. ⚠️ This respect disableCache value
+     * - default: will try getting fresh data from server if server is reachable, else we check if local data exists and return it, if no local data exist we await for client->server connectivity, then try getting the data, return it and cache it for future need. ⚠️ This respect disableCache value
      * 
      * - sticky: if local data exists for the specified query, such data is returned and no-ops afterwards. If no local data is found, we await for client->server connectivity and try to get fresh data from serve, return the data and cache it for future need. ⚠️ This does not respect disableCache value
      * 
-     * - sticky-no-await: if local data exists for the specified query, such data is returned and no-ops afterwards. If no local data is found, we try to get fresh data from serve, we throw an error if server is not reachable else if server returns requested data, we return such data and cache it for future need. ⚠️ This does not respect disableCache value
+     * - sticky-no-await: if local data exists for the specified query, such data is returned and no-ops afterwards. If no local data is found, will try to get fresh data from serve, we throw an error if server is not reachable else if server returns requested data, we return such data and cache it for future need. ⚠️ This does not respect disableCache value
+     * 
+     * - sticky-reload: if local data exists for the specified query, such data is returned, then will try getting fresh data from the server and caching it for future need. If no local data is found, we await for client->server connectivity and try to get fresh data from serve, return the data and cache it for future need
      * 
-     * - sticky-reload: if local data exists for the specified query, such data is returned, then we try getting fresh data from the server and caching it for future need. If no local data is found, we await for client->server connectivity and try to get fresh data from serve, return the data and cache it for future need
+     * - cache-no-await: will try getting fresh data from server if server is reachable, else we check if local data exists and return it, if no local data exist we throw an error
      * 
-     * - cache-no-await: we try getting fresh data from server if server is reachable, else we check if local data exists and return it, if no local data exist we throw an error
+     * - no-cache-no-await: will try getting fresh data from server if server is reachable, else we throw an error
      * 
-     * - no-cache-no-await: we try getting fresh data from server if server is reachable, else we throw an error
+     * - no-cache-await: will try getting fresh data from server when server is reachable and the result won't be cache
      * 
      * To learn and see more examples on this, Please visit https://brainbehindx.com/mosquito-transport/docs/reading_data/retrieval
      */
@@ -417,11 +438,12 @@ declare type Base64String = string;
 
 interface ReqOptions {
     awaitServer?: boolean;
+    createHash?: boolean;
 }
 
 interface MTStorage {
     downloadFile: (link: string, onComplete?: (error?: ErrorResponse, filepath?: string) => void, destination?: string, onProgress?: (stats: DownloadProgressStats) => void) => () => void;
-    uploadFile: (file: Base64String | Blob | Buffer, destination: string, onComplete?: (error?: ErrorResponse, downloadUrl?: string) => void, onProgress?: (stats: UploadProgressStats) => void, options?: ReqOptions) => () => void;
+    uploadFile: (file: Base64String | Blob | Buffer | File, destination: string, onComplete?: (error?: ErrorResponse, downloadUrl?: string) => void, onProgress?: (stats: UploadProgressStats) => void, options?: ReqOptions) => () => void;
     deleteFile: (path: string) => Promise<void>;
     deleteFolder: (folder: string) => Promise<void>;
 }