react-native-mosquito-transport 0.0.18 → 0.0.21

package/src/index.js

@@ -1,20 +1,20 @@
 import 'react-native-get-random-values';
-import { IS_WHOLE_NUMBER, deserializeE2E, listenReachableServer, serializeE2E } from "./helpers/peripherals";
-import { releaseCacheStore } from "./helpers/utils";
-import { Scoped } from "./helpers/variables";
-import { MTAuth } from "./products/auth";
-import { MTCollection, batchWrite } from "./products/database";
+import { deserializeE2E, listenReachableServer, serializeE2E } from "./helpers/peripherals";
+import { awaitStore, releaseCacheStore } from "./helpers/utils";
+import { CacheStore, Scoped } from "./helpers/variables";
+import { MTCollection, batchWrite, trySendPendingWrite } from "./products/database";
 import { MTStorage } from "./products/storage";
 import { ServerReachableListener, TokenRefreshListener } from "./helpers/listeners";
-import { initTokenRefresher, listenToken, listenTokenReady, parseToken, triggerAuthToken } from "./products/auth/accessor";
+import { initTokenRefresher, listenToken, listenTokenReady, triggerAuthToken } from "./products/auth/accessor";
 import { TIMESTAMP, DOCUMENT_EXTRACTION, FIND_GEO_JSON, GEO_JSON } from "./products/database/types";
 import { mfetch } from "./products/http_callable";
 import { io } from "socket.io-client";
-import { validateCollectionPath } from "./products/database/validator";
-import { AUTH_PROVIDER_ID, CACHE_PROTOCOL, Regexs } from "./helpers/values";
-import { trySendPendingWrite } from "./products/database/accessor";
-import EngineApi from './helpers/EngineApi';
-import { parse, stringify } from 'json-buffer';
+import { AUTH_PROVIDER_ID, CACHE_PROTOCOL } from "./helpers/values";
+import EngineApi from './helpers/engine_api';
+import { Validator } from 'guard-object';
+import cloneDeep from 'lodash.clonedeep';
+import { Buffer } from 'buffer';
+import MTAuth, { purgePendingToken } from './products/auth';
 
 const {
     _listenCollection,
@@ -24,69 +24,86 @@ const {
     _listenUserVerification
 } = EngineApi;
 
+// https://socket.io/docs/v3/emit-cheatsheet/#reserved-events
+const reservedEventName = [
+    'connect',
+    'connect_error',
+    'disconnect',
+    'disconnecting',
+    'newListener',
+    'removeListener'
+];
+
 class RNMT {
     constructor(config) {
         validateMTConfig(config, this);
         this.config = {
             ...config,
-            uglify: config.enableE2E_Encryption,
-            apiUrl: config.projectUrl,
-            projectUrl: config.projectUrl.split('/').slice(0, -1).join('/')
+            serverE2E_PublicKey: config.serverE2E_PublicKey && new Uint8Array(Buffer.from(config.serverE2E_PublicKey, 'base64')),
+            castBSON: config.castBSON === undefined || config.castBSON,
+            maxRetries: config.maxRetries || 3,
+            uglify: config.enableE2E_Encryption
         };
-        const { projectUrl } = this.config;
+        const { projectUrl, extraHeaders } = this.config;
 
         this.config.secureUrl = projectUrl.startsWith('https');
         this.config.baseUrl = projectUrl.split('://')[1];
         this.config.wsPrefix = this.config.secureUrl ? 'wss' : 'ws';
 
         if (!Scoped.ReleaseCacheData)
-            throw `releaseCache must be called before creating any ${this.constructor.name} instance`;
+            throw `initializeCache must be called before creating any ${this.constructor.name} instance`;
 
         if (!Scoped.InitializedProject[projectUrl]) {
-            Scoped.InitializedProject[projectUrl] = true;
+            Scoped.InitializedProject[projectUrl] = cloneDeep(this.config);
             Scoped.LastTokenRefreshRef[projectUrl] = 0;
             triggerAuthToken(projectUrl);
             initTokenRefresher({ ...this.config }, true);
 
-            const disconnectionGlich = {};
-            let socket, lastUid, lastSocketProcess = 0, hasInited;
-
-            listenToken((token, thisInited) => {
-                const user = token && parseToken(token);
+            let isConnected,
+                lastSentToken,
+                queuedToken;
 
-                const thisUid = (user?.uid || null);
-                if (lastUid === thisUid && (hasInited || !thisInited)) return;
-                if (!hasInited) hasInited = thisInited;
-                lastUid = thisUid;
+            const socket = io(`${this.config.wsPrefix}://${this.config.baseUrl}`, {
+                transports: ['websocket', 'polling', 'flashsocket'],
+                extraHeaders,
+                auth: {
+                    _m_internal: true,
+                    _from_base: true
+                }
+            });
 
-                if (lastSocketProcess) disconnectionGlich[lastSocketProcess] = true;
-                if (socket) socket.close();
+            socket.on('_signal_signout', () => {
+                this.auth().signOut();
+            });
 
-                const thisProcess = ++lastSocketProcess;
-                socket = io(`${this.config.wsPrefix}://${projectUrl.split('://')[1]}`, {
-                    auth: {
-                        _m_internal: true,
-                        _from_base: true,
-                        atoken: token
-                    }
+            socket.on('connect', () => {
+                isConnected = true;
+                Scoped.IS_CONNECTED[projectUrl] = true;
+                if (queuedToken) updateMountedToken(queuedToken.token);
+                ServerReachableListener.dispatch(projectUrl, true);
+                awaitStore().then(() => {
+                    trySendPendingWrite(projectUrl);
                 });
+            });
 
-                socket.on('_signal_signout', () => {
-                    this.auth().signOut();
-                });
+            socket.on('disconnect', () => {
+                isConnected = false;
+                Scoped.IS_CONNECTED[projectUrl] = false;
+                ServerReachableListener.dispatch(projectUrl, false);
+            });
 
-                socket.on('connect', () => {
-                    ServerReachableListener.dispatch(projectUrl, true);
-                });
-                socket.on('disconnect', () => {
-                    if (!disconnectionGlich[thisProcess])
-                        ServerReachableListener.dispatch(projectUrl, false);
-                });
-            }, projectUrl);
+            const updateMountedToken = (token) => {
+                if ((lastSentToken || null) !== (token || null)) {
+                    socket.emit('_update_mounted_user', token || null);
+                    lastSentToken = token;
+                }
+                queuedToken = undefined;
+            };
 
-            listenReachableServer(c => {
-                Scoped.IS_CONNECTED[projectUrl] = c;
-                if (c) trySendPendingWrite();
+            listenToken(token => {
+                if (isConnected) {
+                    updateMountedToken(token);
+                } else queuedToken = { token };
             }, projectUrl);
 
             TokenRefreshListener.listenTo(projectUrl, v => {
@@ -95,25 +112,29 @@ class RNMT {
         }
     }
 
-    static releaseCache(prop) {
+    static initializeCache(prop) {
         if (Scoped.ReleaseCacheData) throw `calling ${this.name}() multiple times is prohibited`;
         validateReleaseCacheProp({ ...prop });
         Scoped.ReleaseCacheData = { ...prop };
         releaseCacheStore({ ...prop });
+        // purge residue tokens
+        awaitStore().then(() => {
+            Object.keys(CacheStore.PendingAuthPurge).forEach(k => {
+                purgePendingToken(k);
+            });
+        });
     }
 
     getDatabase = (dbName, dbUrl) => ({
         collection: (path) => new MTCollection({
             ...this.config,
             path,
-            ...(dbName ? { dbName } : {}),
-            ...(dbUrl ? { dbUrl } : {})
+            ...dbName ? { dbName } : {},
+            ...dbUrl ? { dbUrl } : {}
         })
     });
-    collection = (path) => {
-        validateCollectionPath(path);
-        return new MTCollection({ ...this.config, path });
-    }
+
+    collection = (path) => new MTCollection({ ...this.config, path });
     batchWrite = (map, configx) => batchWrite({ ...this.config }, map, configx);
     auth = () => new MTAuth({ ...this.config });
     storage = () => new MTStorage({ ...this.config });
@@ -121,8 +142,8 @@ class RNMT {
     listenReachableServer = (callback) => listenReachableServer(callback, this.config.projectUrl);
 
     getSocket = (configOpts) => {
-        const { disableAuth, authHandshake } = configOpts || {},
-            { projectUrl, uglify, accessKey, serverE2E_PublicKey, wsPrefix } = this.config;
+        const { disableAuth, authHandshake } = configOpts || {};
+        const { projectUrl, uglify, accessKey, serverE2E_PublicKey, wsPrefix, extraHeaders } = this.config;
 
         const restrictedRoute = [
             _listenCollection,
@@ -130,12 +151,14 @@ class RNMT {
             _startDisconnectWriteTask,
             _cancelDisconnectWriteTask,
             _listenUserVerification
-        ];
+        ].map(v => [v(), v(true)]).flat();
 
-        let socketReadyCallback,
-            makeSocketCallback = () => new Promise(resolve => {
+        const makeSocketCallback = () =>
+            new Promise(resolve => {
                 socketReadyCallback = resolve;
-            }),
+            });
+
+        let socketReadyCallback,
             socketReadyPromise = makeSocketCallback(),
             socketListenerList = [],
             socketListenerIte = 0;
@@ -145,25 +168,31 @@ class RNMT {
             tokenListener,
             clientPrivateKey;
 
-        const listenerCallback = (callback) => function () {
-            const [args, ...restArgs] = [...arguments];
+        const listenerCallback = (route, callback) => async function () {
+            if (reservedEventName.includes(route)) {
+                callback?.(...[...arguments]);
+                return;
+            }
+
+            const [[args, not_encrypted], emitable] = [...arguments];
             let res;
 
             if (uglify) {
-                res = parse(deserializeE2E(args, serverE2E_PublicKey, clientPrivateKey));
+                res = await deserializeE2E(args, serverE2E_PublicKey, clientPrivateKey);
             } else res = args;
+            const sortedArgs = discloseSocketArguments([res, not_encrypted]);
 
-            callback?.(...res || [], ...typeof restArgs[0] === 'function' ? [function () {
-                const args = [...arguments];
+            callback?.(...sortedArgs, ...typeof emitable === 'function' ? [async function () {
+                const [args, not_encrypted] = encloseSocketArguments([...arguments]);
                 let res;
 
                 if (uglify) {
-                    res = serializeE2E(stringify(args), undefined, serverE2E_PublicKey)[0];
+                    res = (await serializeE2E(args, undefined, serverE2E_PublicKey))[0];
                 } else res = args;
 
-                restArgs[0](res);
+                emitable([res, not_encrypted]);
             }] : []);
-        }
+        };
 
         const emit = ({ timeout, promise, emittion: emittionx }) => new Promise(async (resolve, reject) => {
             const [route, ...emittion] = emittionx;
@@ -176,41 +205,43 @@ class RNMT {
 
             let hasResolved, stime = Date.now();
 
-            const timer = isNaN(timeout) ? undefined : setTimeout(() => {
+            const timer = timeout ? setTimeout(() => {
                 hasResolved = true;
                 reject(new Error('emittion timeout'));
-            }, timeout);
+            }, timeout) : undefined;
 
             await socketReadyPromise;
             if (hasResolved) return;
             clearTimeout(timer);
 
             try {
-                const h = isNaN(timeout) ? socket : socket.timeout(timeout - (Date.now() - stime));
+                const thisSocket = timeout ? socket.timeout(Math.max(timeout - (Date.now() - stime), 0)) : socket;
 
-                const lastEmit = emittion.slice(-1)[0],
-                    mit = typeof lastEmit === 'function' ? emittion.slice(0, -1) : emittion;
+                const lastEmit = emittion.slice(-1)[0];
+                const hasEmitable = typeof lastEmit === 'function';
+                const [mit, not_encrypted] = encloseSocketArguments(hasEmitable ? emittion.slice(0, -1) : emittion);
 
-                const [reqBuilder, [privateKey]] = uglify ? serializeE2E(stringify(mit), undefined, serverE2E_PublicKey) : [undefined, []];
+                const [reqBuilder, [privateKey]] = uglify ? await serializeE2E(mit, undefined, serverE2E_PublicKey) : [undefined, []];
 
-                if (typeof lastEmit === 'function' && promise)
-                    throw 'emitWithAck cannot have function in it parameter';
+                if (hasEmitable && promise)
+                    throw 'emitWithAck cannot have function in it argument';
 
-                const p = await h[promise ? 'emitWithAck' : 'emit'](route,
-                    ...uglify ? [reqBuilder] : [mit],
-                    ...typeof lastEmit === 'function' ? [function () {
-                        const args = [...arguments][0];
+                const result = await thisSocket[promise ? 'emitWithAck' : 'emit'](route,
+                    [uglify ? reqBuilder : mit, not_encrypted],
+                    ...hasEmitable ? [async function () {
+                        const [[args, not_encrypted]] = [...arguments];
                         let res;
 
                         if (uglify) {
-                            res = parse(deserializeE2E(args, serverE2E_PublicKey, privateKey));
+                            res = await deserializeE2E(args, serverE2E_PublicKey, privateKey);
                         } else res = args;
 
-                        lastEmit(...res || []);
+                        lastEmit(...discloseSocketArguments([res, not_encrypted]));
                     }] : []
                 );
-
-                resolve((promise && p) ? uglify ? parse(deserializeE2E(p, serverE2E_PublicKey, privateKey))[0] : p[0] : undefined);
+                if (promise && result) {
+                    resolve(discloseSocketArguments([uglify ? await deserializeE2E(result[0], serverE2E_PublicKey, privateKey) : result[0], result[1]])[0]);
+                } else resolve();
             } catch (e) {
                 reject(e);
             }
@@ -219,12 +250,14 @@ class RNMT {
         const init = async () => {
             if (hasCancelled) return;
             const mtoken = disableAuth ? undefined : Scoped.AuthJWTToken[projectUrl];
-            const [reqBuilder, [privateKey]] = uglify ? serializeE2E({ accessKey, a_extras: authHandshake }, mtoken, serverE2E_PublicKey) : [null, []];
+            const [reqBuilder, [privateKey]] = uglify ? await serializeE2E({ accessKey, a_extras: authHandshake }, mtoken, serverE2E_PublicKey) : [null, []];
 
             socket = io(`${wsPrefix}://${projectUrl.split('://')[1]}`, {
+                transports: ['websocket', 'polling', 'flashsocket'],
+                extraHeaders,
                 auth: uglify ? {
                     ugly: true,
-                    e2e: reqBuilder
+                    e2e: reqBuilder.toString('base64')
                 } : {
                     ...mtoken ? { mtoken } : {},
                     a_extras: authHandshake,
@@ -259,15 +292,20 @@ class RNMT {
         }
 
         return {
-            timeout: (timeout) => ({
-                emitWithAck: function () {
-                    return emit({
-                        timeout,
-                        promise: true,
-                        emittion: [...arguments]
-                    });
-                }
-            }),
+            timeout: (timeout) => {
+                if (timeout !== undefined && !Validator.POSITIVE_INTEGER(timeout))
+                    throw `expected a positive integer for timeout but got ${timeout}`;
+
+                return {
+                    emitWithAck: function () {
+                        return emit({
+                            timeout,
+                            promise: true,
+                            emittion: [...arguments]
+                        });
+                    }
+                };
+            },
             emit: function () { emit({ emittion: [...arguments] }) },
             emitWithAck: function () {
                 return emit({
@@ -279,7 +317,7 @@ class RNMT {
                 if (restrictedRoute.includes(route))
                     throw `${route} is a restricted socket path, avoid using any of ${restrictedRoute}`;
                 const ref = ++socketListenerIte,
-                    listener = listenerCallback(callback);
+                    listener = listenerCallback(route, callback);
 
                 socketListenerList.push([ref, 'on', route, listener]);
                 if (socket) socket.on(route, listener);
@@ -293,7 +331,7 @@ class RNMT {
                 if (restrictedRoute.includes(route))
                     throw `${route} is a restricted socket path, avoid using any of ${restrictedRoute}`;
                 const ref = ++socketListenerIte,
-                    listener = listenerCallback(callback);
+                    listener = listenerCallback(route, callback);
 
                 socketListenerList.push([ref, 'once', route, listener]);
                 if (socket) socket.once(route, listener);
@@ -311,10 +349,31 @@ class RNMT {
             }
         }
     }
+};
 
-    wipeDatabaseCache = () => {
-
+class DoNotEncrypt {
+    constructor(value) {
+        this.value = value;
     }
+};
+
+const encloseSocketArguments = (args) => {
+    const [encrypted, unencrypted] = [{}, {}];
+
+    args.forEach((v, i) => {
+        if (v instanceof DoNotEncrypt) {
+            unencrypted[i] = v.value;
+        } else encrypted[i] = v;
+    });
+    return [encrypted, unencrypted];
+}
+
+const discloseSocketArguments = (args = []) => {
+    return args.map((obj, i) => Object.entries(obj).map(v => i ? [v[0], new DoNotEncrypt(v[1])] : v)).flat()
+        .sort((a, b) => (a[0] * 1) - (b[0] * 1)).map((v, i) => {
+            if (v[0] * 1 !== i) throw 'corrupted socket arguments';
+            return v[1];
+        });
 }
 
 const validateReleaseCacheProp = (prop) => {
@@ -333,6 +392,11 @@ const validateReleaseCacheProp = (prop) => {
                         throw `Invalid value supplied to "io.${k}", expected a function but got "${v}"`;
                 } else throw `Unexpected property named "io.${k}"`;
             });
+        } else if (k === 'promoteCache') {
+            if (typeof v !== 'boolean') throw 'promoteCache should be a boolean';
+        } else if (k === 'heapMemory') {
+            if (typeof v !== 'number' || v <= 0)
+                throw `Invalid value supplied to heapMemory, value must be an integer greater than zero`;
         } else throw `Unexpected property named ${k}`;
     });
 
@@ -342,19 +406,15 @@ const validateReleaseCacheProp = (prop) => {
 const validator = {
     dbName: (v) => {
         if (typeof v !== 'string' || !v.trim())
-            throw `Invalid value supplied to dbName, value must be string and greater than one`;
+            throw `Invalid value supplied to dbName, value must be a non-empty string`;
     },
     dbUrl: (v) => {
         if (typeof v !== 'string' || !v.trim())
-            throw `Invalid value supplied to dbUrl, value must be string and greater than one`;
-    },
-    heapMemory: (v) => {
-        if (typeof v !== 'number' || v <= 0)
-            throw `Invalid value supplied to heapMemory, value must be number and greater than zero`;
+            throw `Invalid value supplied to dbUrl, value must be a non-empty string`;
     },
     projectUrl: (v) => {
-        if (typeof v !== 'string' || !Regexs.LINK().test(v.trim()))
-            throw `Invalid value supplied to projectUrl, value must be a string and greater than one`;
+        if (typeof v !== 'string' || (!Validator.HTTPS(v) && !Validator.HTTP(v)))
+            throw `Expected "projectUrl" to be valid https or http link but got "${v}"`;
     },
     disableCache: (v) => {
         if (typeof v !== 'boolean')
@@ -362,40 +422,57 @@ const validator = {
     },
     accessKey: (v) => {
         if (typeof v !== 'string' || !v.trim())
-            throw `Invalid value supplied to accessKey, value must be a string and greater than one`;
+            throw `Invalid value supplied to accessKey, value must be a non-empty string`;
     },
     maxRetries: (v) => {
-        if (typeof v !== 'number' || v <= 0 || !IS_WHOLE_NUMBER(v))
-            throw `Invalid value supplied to maxRetries, value must be whole number and greater than zero`;
+        if (v <= 0 || !Validator.POSITIVE_INTEGER(v))
+            throw `Invalid value supplied to maxRetries, value must be positive integer greater than zero`;
     },
     enableE2E_Encryption: (v) => {
         if (typeof v !== 'boolean')
             throw `Invalid value supplied to enableE2E_Encryption, value must be a boolean`;
     },
+    castBSON: v => {
+        if (typeof v !== 'boolean')
+            throw `Invalid value supplied to castBSON, value must be a boolean`;
+    },
+    borrowToken: v => {
+        if (typeof v !== 'string' || (!Validator.HTTPS(v) && !Validator.HTTP(v)))
+            throw `Expected "borrowToken" to be valid https or http link but got "${v}"`;
+    },
     serverE2E_PublicKey: (v) => {
         if (typeof v !== 'string' || !v.trim())
-            throw `Invalid value supplied to serverETE_PublicKey, value must be string and greater than one`;
+            throw `Invalid value supplied to serverETE_PublicKey, value must be a non-empty string`;
+    },
+    extraHeaders: v => {
+        if (!Validator.OBJECT(v)) throw '"extraHeaders" must be an object';
+        const reservedHeaders = ['mtoken', 'mosquito-token', 'init-content-type', 'content-type', 'authorization', 'uglified'];
+
+        Object.entries(v).forEach(([k, v]) => {
+            if (typeof v !== 'string') throw `expected a string at extraHeaders.${k} but got "${v}"`;
+            if (reservedHeaders.includes(v.toLowerCase()))
+                throw `extraHeaders must not include any reserved props which are: ${reservedHeaders}`;
+        });
     }
 };
 
 const validateMTConfig = (config, that) => {
-    if (typeof config !== 'object') throw `${that.constructor.name} config is not an object`;
-    const h = Object.keys(config);
-
-    for (let i = 0; i < h.length; i++) {
-        const k = h[i];
+    if (!Validator.OBJECT(config))
+        throw `${that.constructor.name} config is not an object`;
 
+    for (const [k, v] of Object.entries(config)) {
         if (!validator[k]) throw `Unexpected property named ${k}`;
-        validator[k](config[k]);
+        validator[k](v);
     }
 
     if (config.enableE2E_Encryption && !config.serverE2E_PublicKey)
         throw '"serverE2E_PublicKey" is missing, enabling end-to-end encryption requires a public encryption key from the server';
-    if (!config['projectUrl']) throw `projectUrl is a required property in ${that.constructor.name}() constructor`;
-    if (!config['accessKey']) throw `accessKey is a required property in ${that.constructor.name}() constructor`;
+    if (!config.projectUrl) throw `projectUrl is a required property in ${that.constructor.name}() constructor`;
+    if (!config.accessKey) throw `accessKey is a required property in ${that.constructor.name}() constructor`;
 }
 
 export {
+    DoNotEncrypt,
     TIMESTAMP,
     DOCUMENT_EXTRACTION,
     FIND_GEO_JSON,