react-native-mosquito-transport 0.0.47 → 0.0.48

package/TODO

@@ -25,3 +25,11 @@
 - transform undefined to void instead of null
 - add metadata to provider auth login
 <!-- - error: "refreshToken retry limit exceeded" <--- no need -->
+
+- _areYouOk() should timeout max 5000
+- .json() should be parse nicely
+- when server is offline and suddenly comes online, fetchHttp throw some error
+- string to Buffer may be in utf16
+
+# changes made
+storage uploadFile method and others

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-mosquito-transport",
-  "version": "0.0.47",
+  "version": "0.0.48",
   "description": "React native javascript sdk for mosquito-transport (https://github.com/brainbehindx/mosquito-transport)",
   "main": "src/index.js",
   "type": "module",
@@ -29,7 +29,7 @@
   "dependencies": {
     "@turf/turf": "^7.2.0",
     "buffer": "^6.0.3",
-    "entity-serializer": "^1.0.3",
+    "entity-serializer": "^1.0.4",
     "guard-object": "^1.1.4",
     "poke-object": "^1.0.1",
     "simplify-error": "^1.0.1",

package/src/index.d.ts

@@ -1,6 +1,6 @@
 import { BSON } from "./vendor/bson";
 
-interface RNMTConfig {
+export interface RNMTConfig {
     dbName?: string;
     dbUrl?: string;
     projectUrl: string;
@@ -38,7 +38,7 @@ interface RNMTConfig {
     castBSON?: boolean;
 }
 
-interface GetDatabase {
+export interface GetDatabase {
     collection: (path: string) => RNMTCollection;
 }
 
@@ -98,7 +98,7 @@ type auth_provider_id_values = auth_provider_id['GOOGLE'] |
 interface ReleaseCacheOption_IO {
 }
 
-interface ReleaseCacheOption {
+export interface ReleaseCacheOption {
     /**
      * fs is used as the default caching mechanism
      * 
@@ -137,7 +137,7 @@ interface ReleaseCacheOption {
     promoteCache?: boolean;
 }
 
-interface RNMTSocket {
+export interface RNMTSocket {
     timeout: (timeout?: number) => ({
         emitWithAck: (...args: any) => Promise<any>;
     });
@@ -167,13 +167,18 @@ interface CountConfig {
     disableAuth?: boolean;
 }
 
-interface FetchHttpResponse extends Response {
+export interface FetchHttpResponse extends Response {
     /**
      * true if this response was from local cache
      */
     fromCache?: boolean | undefined;
 }
 
+interface CustomSocketOption extends OveridenProjectUrl {
+    disableAuth?: boolean;
+    authHandshake?: Object;
+}
+
 export default class RNMT {
     constructor(config: RNMTConfig);
     static initializeCache(option?: ReleaseCacheOption): void;
@@ -183,12 +188,12 @@ export default class RNMT {
     storage(): RNMTStorage;
     fetchHttp(endpoint: string, init?: RequestInit, config?: FetchHttpConfig): Promise<FetchHttpResponse>;
     listenReachableServer(callback: (reachable: boolean) => void): () => void;
-    getSocket(options: { disableAuth?: boolean; authHandshake?: Object }): RNMTSocket;
+    getSocket(options?: CustomSocketOption): RNMTSocket;
     onConnect: () => CollectionIO;
     batchWrite(map: BatchWriteValue[], config?: BatchWriteConfig): Promise<DocumentWriteResult[] | undefined>;
 }
 
-interface RNMTCollection {
+export interface RNMTCollection {
     find: (find?: DocumentFind) => ({
         get: (config?: GetConfig) => Promise<DocumentResult[]>;
         listen: (callback: (snapshot?: DocumentResult[]) => void, onError?: (error?: DocumentError) => void, config?: GetConfig) => void;
@@ -258,7 +263,7 @@ interface RNMTCollection {
     deleteMany: (find?: DocumentFind, config?: WriteConfig) => Promise<DocumentWriteResult>;
 }
 
-interface CollectionTaskIO<T> {
+export interface CollectionTaskIO<T> {
     batchWrite(map: BatchWriteValue[], config?: BatchWriteConfig): T;
 }
 
@@ -270,7 +275,7 @@ interface OnConnectChain extends StartStop {
     onDisconnect: () => CollectionTaskIO<StartStop>;
 }
 
-interface CollectionIO extends CollectionTaskIO<OnConnectChain> {
+export interface CollectionIO extends CollectionTaskIO<OnConnectChain> {
     onDisconnect: () => CollectionTaskIO<StartStop>;
 }
 
@@ -282,7 +287,7 @@ interface DocumentError extends ErrorResponse {
 
 }
 
-interface FetchHttpConfig {
+export interface FetchHttpConfig {
     retrieval?: GetConfig['retrieval'];
     /**
      * disable sending authentication token along with this request
@@ -429,7 +434,7 @@ interface DocumentWriteValue {
 
 }
 
-interface RNMTAuth {
+export interface RNMTAuth {
     customSignin: (email: string, password: string) => Promise<SigninResult>;
     customSignup: (email: string, password: string, name?: string, metadata?: Object) => Promise<SignupResult>;
     /**
@@ -465,7 +470,7 @@ export interface SignupResult extends SigninResult {
     isNewUser: boolean;
 }
 
-interface AuthData {
+export interface AuthData {
     email?: string;
     metadata: Object;
     signupMethod: auth_provider_id_values;
@@ -473,7 +478,8 @@ interface AuthData {
     joinedOn: number;
     uid: string;
     claims: Object;
-    emailVerified: boolean;
+    authVerified: boolean;
+    passwordVerified?: boolean | undefined;
     tokenID: string;
     disabled: boolean;
     entityOf: string;
@@ -487,7 +493,7 @@ interface AuthData {
     sub: string;
 }
 
-interface RefreshTokenData {
+export interface RefreshTokenData {
     uid: string;
     tokenID: string;
     isRefreshToken: true;
@@ -497,24 +503,37 @@ interface RefreshTokenData {
     sub: string;
 }
 
-interface TokenEventData extends AuthData {
+export interface TokenEventData extends AuthData {
     tokenManager: TokenManager;
 }
 
-interface TokenManager {
+export interface TokenManager {
     refreshToken: string;
     accessToken: string;
 }
 
-interface UploadOptions {
+interface OveridenProjectUrl {
+    /**
+     * The server instance to send requests to. This overrides the parent `projectUrl`, but still relies on the parent `projectUrl` for authentication token resolution and verify server reachability.
+     */
+    projectUrl?: string;
+}
+
+interface UploadOptions extends OveridenProjectUrl {
     /**
      * optionally create hash for this upload to save disk space
      */
     createHash?: boolean;
+
     /**
      * wait for a reachable server before initiating the upload task
      */
     awaitServer?: boolean;
+
+    /**
+     * monitor upload progress stats
+     */
+    onProgress?: (stats: UploadProgressStats) => void;
 }
 
 interface DownloadOptions {
@@ -522,16 +541,28 @@ interface DownloadOptions {
      * wait for a reachable server before initiating the download task
      */
     awaitServer?: boolean;
+
+    /**
+     * monitor download progress stats
+     */
+    onProgress?: (stats: DownloadProgressStats) => void;
+}
+
+interface StorageTask extends Promise<string> {
+    /**
+     * abort the running task process
+     */
+    abort: () => void;
 }
 
-interface RNMTStorage {
-    downloadFile: (link: string, onComplete?: (error?: ErrorResponse, filepath?: string) => void, destination?: string, onProgress?: (stats: DownloadProgressStats) => void, options?: DownloadOptions) => () => void;
-    uploadFile: (file: string, destination: string, onComplete?: (error?: ErrorResponse, downloadUrl?: string) => void, onProgress?: (stats: UploadProgressStats) => void, options?: UploadOptions) => () => void;
-    deleteFile: (path: string) => Promise<void>;
-    deleteFolder: (folder: string) => Promise<void>;
+export interface RNMTStorage {
+    downloadFile: (link: string, filepath?: string | undefined, options?: DownloadOptions | undefined) => StorageTask;
+    uploadFile: (filepath: string, destination: string, options?: UploadOptions | undefined) => StorageTask;
+    deleteFile: (path: string, options?: OveridenProjectUrl | undefined) => Promise<void>;
+    deleteFolder: (folder: string, options?: OveridenProjectUrl | undefined) => Promise<void>;
 }
 
-interface DownloadProgressStats {
+export interface DownloadProgressStats {
     receivedBtyes: number;
     expectedBytes: number;
     isPaused: boolean;

package/src/index.js

@@ -165,7 +165,7 @@ class RNMT {
     listenReachableServer = (callback) => listenReachableServer(callback, this.config.projectUrl);
 
     getSocket = (configOpts) => {
-        const { disableAuth, authHandshake } = configOpts || {};
+        const { disableAuth, authHandshake, projectUrl: overidenUrl } = configOpts || {};
         const { projectUrl, uglify, serverE2E_PublicKey, wsPrefix, extraHeaders } = this.config;
 
         const restrictedRoute = [
@@ -278,7 +278,10 @@ class RNMT {
             const mtoken = disableAuth ? undefined : Scoped.AuthJWTToken[projectUrl];
             const [reqBuilder, [privateKey]] = uglify ? await serializeE2E({ a_extras: authHandshake }, mtoken, serverE2E_PublicKey) : [null, []];
 
-            socket = io(`${wsPrefix}://${projectUrl.split('://')[1]}`, {
+            const getWsPrefix = url => url.startsWith('https') ? 'wss' : 'ws';
+            const wsUrl = overidenUrl ? `${getWsPrefix(overidenUrl)}://${overidenUrl.split('://')[1]}` : `${wsPrefix}://${projectUrl.split('://')[1]}`;
+
+            socket = io(wsUrl, {
                 transports: ['websocket', 'polling', 'flashsocket'],
                 extraHeaders,
                 auth: uglify ? {

package/src/products/auth/accessor.js

@@ -1,4 +1,4 @@
-import { doSignOut, revokeAuthIntance } from ".";
+import { doSignOut, revokeAuthIntance } from "./index.js";
 import EngineApi from "../../helpers/engine_api";
 import { AuthTokenListener, TokenRefreshListener } from "../../helpers/listeners";
 import { decodeBinary, deserializeE2E, listenReachableServer } from "../../helpers/peripherals";

package/src/products/auth/index.js

@@ -254,11 +254,13 @@ const clearCacheForSignout = (builder, disposeEmulated) => {
 export const doSignOut = async (builder) => {
     if (!Scoped.IsStoreReady) await awaitStore();
     const emulatedURL = CacheStore.EmulatedAuth[builder.projectUrl];
+    const thisAuthStore = emulatedURL ? undefined : basicClone(CacheStore.AuthStore[builder.projectUrl]);
 
     clearCacheForSignout(builder, !emulatedURL);
     updateCacheStore(['AuthStore', 'EmulatedAuth']);
     if (emulatedURL) return;
-    await revokeAuthIntance(builder);
+
+    await revokeAuthIntance(builder, thisAuthStore);
 };
 
 export const revokeAuthIntance = async (builder, authStore) => {
@@ -288,8 +290,7 @@ export const purgePendingToken = async (nodeId) => {
             isConnected = (await (await fetch(_areYouOk(projectUrl), { credentials: 'omit' })).json()).status === 'yes';
         } catch (_) { }
 
-        if (!isConnected)
-            await awaitReachableServer(projectUrl);
+        if (!isConnected) await awaitReachableServer(projectUrl);
 
         const [reqBuilder] = await buildFetchInterface({
             body: { token, r_token },

package/src/products/http_callable/index.js

@@ -3,7 +3,7 @@ import { deserializeE2E, listenReachableServer, niceHash, normalizeRoute, serial
 import { awaitStore, getReachableServer } from "../../helpers/utils";
 import { RETRIEVAL } from "../../helpers/values";
 import { Scoped } from "../../helpers/variables";
-import { awaitRefreshToken } from "../auth/accessor";
+import { awaitRefreshToken, parseToken } from "../auth/accessor";
 import { simplifyCaughtError } from "simplify-error";
 import { guardObject, Validator } from "guard-object";
 import { serialize } from "entity-serializer";
@@ -71,17 +71,18 @@ export const mfetch = async (input = '', init, config) => {
         ) throw `"body" must be any of string, buffer, object`;
     }
     await awaitStore();
+    const thisToken = disableAuth ? '' : (Scoped.AuthJWTToken[projectUrl] || '');
 
     const reqId = await niceHash(
         serialize([
             rawHeader,
             body,
-            !!disableAuth,
+            // !!disableAuth,
             input,
-            disableAuth ? '' : (Scoped.AuthJWTToken[projectUrl] || '')
+            thisToken && await parseToken(thisToken).uid
         ]).toString('base64')
     );
-    const processReqId = `${reqId}_${disableCache}_${retrieval}`;
+    const processReqId = `${reqId}_${thisToken}_${disableCache}_${retrieval}`;
 
     let retries = 0, hasFinalize;
 
@@ -143,7 +144,7 @@ export const mfetch = async (input = '', init, config) => {
             const [reqBuilder, [privateKey]] = uglified ? await serializeE2E(body, mtoken, serverE2E_PublicKey) : [null, []];
 
             const f = await fetch(isLink ? input : `${projectUrl}/${normalizeRoute(input)}`, {
-                ...(encodeBody || uglified) ? { method: 'POST' } : {},
+                ...(hasBody || uglified) ? { method: 'POST' } : {},
                 credentials: 'omit',
                 ...init,
                 ...uglified ? { body: reqBuilder } : encodeBody ? { body: serialize(body) } : {},

package/src/products/storage/index.js

@@ -5,6 +5,7 @@ import { DeviceEventEmitter, NativeEventEmitter, NativeModules, Platform } from
 import { awaitReachableServer, buildFetchInterface, buildFetchResult } from "../../helpers/utils";
 import { awaitRefreshToken } from "../auth/accessor";
 import { simplifyError } from "simplify-error";
+import { Validator } from "guard-object";
 
 const LINKING_ERROR =
     `The package 'react-native-mosquito-transport' doesn't seem to be linked. Make sure: \n\n` +
@@ -19,6 +20,7 @@ const RNMTModule = NativeModules.Mosquitodb || (
         },
     })
 );
+
 const emitter = Platform.OS === 'android' ?
     DeviceEventEmitter : new NativeEventEmitter(RNMTModule);
 
@@ -27,26 +29,43 @@ export class MTStorage {
         this.builder = { ...config };
     }
 
-    downloadFile(link = '', onComplete, destination, onProgress, options) {
-        const { awaitServer } = options || {};
+    downloadFile = (link = '', destination, options) => {
+        const { awaitServer, onProgress } = options || {};
         let hasFinished, isPaused, hasCancelled;
 
         const { projectUrl, extraHeaders } = this.builder;
+        let onComplete;
+
+        const promise = new Promise((resolve, reject) => {
+            onComplete = (err, path) => {
+                if (hasFinished) return;
+                hasFinished = true;
+                if (path) {
+                    resolve(path);
+                } else reject(err);
+            }
+        });
+
+        promise.abort = () => {
+            if (hasFinished || hasCancelled) return;
+            RNMTModule.cancelDownload(processID);
+            hasCancelled = true;
+            onComplete?.({ error: 'download_aborted', message: 'The download process was aborted' });
+        }
 
         if (destination && (typeof destination !== 'string' || !destination.trim())) {
             onComplete?.({ error: 'destination_invalid', message: 'destination must be a non-empty string' });
-            return () => { };
+            return promise;
         }
         if (destination) destination = prefixStoragePath(destination?.trim());
 
-        if (typeof link !== 'string' || !link.trim().startsWith(`${EngineApi.staticStorage(projectUrl)}/`)) {
+        if (typeof link !== 'string' || !Validator.LINK(link = link.trim())) {
             onComplete?.({
                 error: 'invalid_link',
-                message: `link has an invalid value, expected a string that starts with "${EngineApi.staticStorage(projectUrl)}/"`
+                message: `downloadFile first argument has an invalid value, expected a valid link string but got '${link}' instead`
             });
-            return () => { };
+            return promise;
         }
-        link = link.trim();
 
         const processID = `${++Scoped.StorageProcessID}`;
         const init = async () => {
@@ -86,7 +105,6 @@ export class MTStorage {
                     onComplete?.(path ? undefined : (result?.simpleError || { error, message: errorDes }), path);
                 resultListener.remove();
                 progressListener.remove();
-                hasFinished = true;
             });
 
             RNMTModule.downloadFile({
@@ -103,30 +121,36 @@ export class MTStorage {
         }
 
         init();
-
-        return () => {
-            if (hasFinished || hasCancelled) return;
-            RNMTModule.cancelDownload(processID);
-            hasCancelled = true;
-            setTimeout(() => {
-                onComplete?.({ error: 'download_aborted', message: 'The download process was aborted' });
-            }, 1);
-        }
+        return promise;
     }
 
-    uploadFile(file = '', destination = '', onComplete, onProgress, options) {
-        const { createHash, awaitServer } = options || {};
+    uploadFile = (file = '', destination = '', options) => {
+        const { createHash, awaitServer, onProgress } = options || {};
         let hasFinished, hasCancelled;
+        let thisComplete;
 
-        const thisComplete = (...args) => {
-            if (hasFinished) return;
-            hasFinished = true;
-            onComplete?.(...args);
-        }
+        const promise = new Promise((resolve, reject) => {
+            thisComplete = (err, url) => {
+                if (hasFinished) return;
+                hasFinished = true;
+                if (url) {
+                    resolve(url);
+                } else reject(err);
+            }
+        });
+
+        promise.abort = () => {
+            if (hasFinished || hasCancelled) return;
+            hasCancelled = true;
+            setTimeout(() => {
+                thisComplete?.({ error: 'upload_aborted', message: 'The upload process was aborted' });
+            }, 0);
+            RNMTModule.cancelUpload(processID);
+        };
 
         if (typeof file !== 'string' || !file.trim()) {
             thisComplete?.({ error: 'file_path_invalid', message: 'file must be a non-empty string in uploadFile()' });
-            return () => { };
+            return promise;
         }
         destination = destination?.trim?.();
 
@@ -134,7 +158,7 @@ export class MTStorage {
             validateDestination(destination);
         } catch (error) {
             thisComplete?.({ error: 'destination_invalid', message: error });
-            return () => { };
+            return promise;
         }
 
         const isAsset = file.startsWith('ph://') || file.startsWith('content://');
@@ -142,6 +166,7 @@ export class MTStorage {
 
         const { projectUrl, uglify, extraHeaders } = this.builder;
         const processID = `${++Scoped.StorageProcessID}`;
+        const thisProjectUrl = options?.projectUrl || projectUrl;
 
         const init = async () => {
             if (awaitServer) await awaitReachableServer(projectUrl);
@@ -167,7 +192,7 @@ export class MTStorage {
             const authToken = Scoped.AuthJWTToken[projectUrl];
 
             RNMTModule.uploadFile({
-                url: EngineApi._uploadFile(projectUrl, uglify),
+                url: EngineApi._uploadFile(thisProjectUrl, uglify),
                 file: isAsset ? file : file.substring('file://'.length),
                 ...authToken ? { authToken } : {},
                 createHash: createHash ? 'yes' : 'no',
@@ -178,24 +203,16 @@ export class MTStorage {
         }
 
         init();
-
-        return () => {
-            if (hasFinished || hasCancelled) return;
-            hasCancelled = true;
-            setTimeout(() => {
-                thisComplete?.({ error: 'upload_aborted', message: 'The upload process was aborted' });
-            }, 0);
-            RNMTModule.cancelUpload(processID);
-        }
+        return promise;
     }
 
-    deleteFile = (path) => deleteContent(this.builder, path);
-    deleteFolder = (path) => deleteContent(this.builder, path, true);
+    deleteFile = (path, options) => deleteContent(this.builder, path, options);
+    deleteFolder = (path, options) => deleteContent(this.builder, path, options, true);
 }
 
 const { _deleteFile, _deleteFolder } = EngineApi;
 
-const deleteContent = async (builder, path, isFolder) => {
+const deleteContent = async (builder, path, options, isFolder) => {
     const { projectUrl, uglify, extraHeaders, serverE2E_PublicKey } = builder;
 
     try {
@@ -207,8 +224,10 @@ const deleteContent = async (builder, path, isFolder) => {
             serverE2E_PublicKey,
             uglify
         });
+        const thisProjectUrl = options?.projectUrl || projectUrl;
 
-        const data = await buildFetchResult(await fetch((isFolder ? _deleteFolder : _deleteFile)(projectUrl, uglify), reqBuilder), uglify);
+        const res = await fetch((isFolder ? _deleteFolder : _deleteFile)(thisProjectUrl, uglify), reqBuilder);
+        const data = await buildFetchResult(res, uglify);
         const result = uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data;
 
         if (result.status !== 'success') throw 'operation not successful';