react-native-mosquito-transport 0.0.27 → 0.0.29

package/android/src/main/java/com/mosquitodb/MosquitodbModule.java

@@ -1,16 +1,25 @@
 package com.mosquitodb;
 
+import android.util.ArrayMap;
+
 import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 
-import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
 import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.mosquitodb.utils.FileUploader;
+import com.mosquitodb.utils.UploadCallback;
 
 @ReactModule(name = MosquitodbModule.NAME)
 public class MosquitodbModule extends ReactContextBaseJavaModule {
   public static final String NAME = "Mosquitodb";
+  private final ArrayMap<String, FileUploader> uploaderMap = new ArrayMap<>();
 
   public MosquitodbModule(ReactApplicationContext reactContext) {
     super(reactContext);
@@ -22,11 +31,52 @@ public class MosquitodbModule extends ReactContextBaseJavaModule {
     return NAME;
   }
 
+  @ReactMethod
+  public void uploadFile(ReadableMap readable) {
+    String processId = readable.getString("processID");
+    FileUploader uploader = new FileUploader();
+
+    uploader.uploadFile(readable, new UploadCallback() {
+      @Override
+      public void onProgress(long sentBytes, long totalBytes) {
+        WritableMap progress = new WritableNativeMap();
+        progress.putInt("sentBytes", (int) sentBytes);
+        progress.putInt("totalBytes", (int) totalBytes);
+        progress.putString("processID", processId);
+        sendEvent("mt-uploading-progress", progress);
+      }
+
+      @Override
+      public void onComplete(int responseCode, String responseBody) {
+        WritableMap statusData = new WritableNativeMap();
+        statusData.putString("processID", processId);
+        statusData.putString("result", responseBody);
+        sendEvent("mt-uploading-status", statusData);
+      }
+
+      @Override
+      public void onError(Exception e) {
+        WritableMap statusData = new WritableNativeMap();
+        statusData.putString("processID", processId);
+        statusData.putString("error", "internal_error");
+        statusData.putString("errorDes", e.getLocalizedMessage());
+        sendEvent("mt-uploading-status", statusData);
+      }
+    });
+    uploaderMap.put(processId, uploader);
+  }
 
-  // Example method
-  // See https://reactnative.dev/docs/native-modules-android
   @ReactMethod
-  public void multiply(double a, double b, Promise promise) {
-    promise.resolve(a * b);
+  public void cancelUpload(String processID) {
+    FileUploader uploader = uploaderMap.get(processID);
+    if (uploader != null) {
+      uploader.cancelUpload();
+    }
+  }
+
+  private void sendEvent(String eventName, @Nullable WritableMap params) {
+    getReactApplicationContext()
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+            .emit(eventName, params);
   }
 }

package/android/src/main/java/com/mosquitodb/utils/FileUploader.java

@@ -0,0 +1,101 @@
+package com.mosquitodb.utils;
+
+import java.io.*;
+import java.net.*;
+import java.util.Objects;
+
+import android.net.Uri;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+
+public class FileUploader {
+
+    private volatile boolean isCancelled = false;
+
+    public void cancelUpload() {
+        isCancelled = true;
+    }
+
+    public void uploadFile(ReadableMap config, UploadCallback callback) {
+        new Thread(() -> {
+            try {
+                Uri fileUri = Uri.parse(config.getString("file"));
+                File file = new File(Objects.requireNonNull(fileUri.getPath()));
+
+                if (!file.exists()) {
+                    throw new FileNotFoundException("File not found: " + file.getAbsolutePath());
+                }
+
+                long totalBytes = file.length();
+                HttpURLConnection connection = (HttpURLConnection) new URL(config.getString("url")).openConnection();
+                connection.setDoOutput(true);
+                connection.setRequestMethod("POST");
+
+                ReadableMap extraHeaders = config.getMap("extraHeaders");
+                ReadableMapKeySetIterator iterator = Objects.requireNonNull(extraHeaders).keySetIterator();
+                while (iterator.hasNextKey()) {
+                    String key = iterator.nextKey();
+                    connection.setRequestProperty(key, extraHeaders.getString(key));
+                }
+
+                connection.setRequestProperty("Content-Type", "buffer/upload");
+                connection.setRequestProperty("hash-upload", config.getString("createHash"));
+                connection.setRequestProperty("Mosquito-Destination", config.getString("destination"));
+                if (config.hasKey("authToken")) {
+                    connection.setRequestProperty("Mosquito-Token", config.getString("authToken"));
+                }
+                connection.setFixedLengthStreamingMode((int) totalBytes);
+
+                OutputStream out = connection.getOutputStream();
+                FileInputStream in = new FileInputStream(file);
+
+                byte[] buffer = new byte[8192];
+                long sentBytes = 0;
+                int bytesRead;
+
+                while ((bytesRead = in.read(buffer)) != -1) {
+                    if (isCancelled) {
+                        in.close();
+                        out.close();
+                        connection.disconnect();
+                        callback.onError(new IOException("Upload cancelled"));
+                        return;
+                    }
+
+                    out.write(buffer, 0, bytesRead);
+                    sentBytes += bytesRead;
+                    callback.onProgress(sentBytes, totalBytes);
+                }
+
+                out.flush();
+                in.close();
+                out.close();
+
+                int responseCode = connection.getResponseCode();
+                InputStream responseStream = (responseCode >= 200 && responseCode < 400)
+                        ? connection.getInputStream()
+                        : connection.getErrorStream();
+                String responseBody = readStream(responseStream);
+
+                callback.onComplete(responseCode, responseBody);
+                connection.disconnect();
+            } catch (Exception e) {
+                callback.onError(e);
+            }
+        }).start();
+    }
+
+    private String readStream(InputStream stream) throws IOException {
+        if (stream == null) return "";
+
+        BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
+        StringBuilder result = new StringBuilder();
+        String line;
+        while ((line = reader.readLine()) != null) {
+            result.append(line).append("\n");
+        }
+        reader.close();
+        return result.toString().trim();
+    }
+}

package/android/src/main/java/com/mosquitodb/utils/UploadCallback.java

@@ -0,0 +1,7 @@
+package com.mosquitodb.utils;
+
+public interface UploadCallback {
+    void onProgress(long sentBytes, long totalBytes);
+    void onComplete(int responseCode, String responseBody);
+    void onError(Exception e);
+}

package/ios/Mosquitodb.swift

@@ -100,7 +100,6 @@ class MosquitodbUploadTask: NSObject, URLSessionDataDelegate {
                     request.setValue(value, forHTTPHeaderField: key)
                 }
             }
-            request.setValue("application/json", forHTTPHeaderField: "Accept")
             if options["authToken"] != nil {
                 request.setValue(options["authToken"] as? String, forHTTPHeaderField: "Mosquito-Token")
             }
@@ -137,7 +136,7 @@ class MosquitodbUploadTask: NSObject, URLSessionDataDelegate {
         
         trigger!([
             "mt-uploading-progress", [
-                "sentBtyes": Float(totalBytesSent),
+                "sentBytes": Float(totalBytesSent),
                 "totalBytes": Float(totalBytesExpectedToSend),
                 "processID": mainProcessID
             ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-mosquito-transport",
-  "version": "0.0.27",
+  "version": "0.0.29",
   "description": "React native javascript sdk for mosquito-transport (https://github.com/brainbehindx/mosquito-transport)",
   "main": "src/index.js",
   "type": "module",
@@ -42,7 +42,7 @@
   "peerDependencies": {
     "react": "*",
     "react-native": "*",
-    "react-native-file-access": "*",
+    "react-native-fs": "*",
     "react-native-sha256": "*",
     "react-native-sqlite-storage": "*"
   },

package/src/helpers/fs_manager.js

@@ -1,28 +1,28 @@
 import { Platform } from "react-native";
 import { Buffer } from 'buffer';
 import { deserialize, serialize } from 'entity-serializer';
-import { Dirs, FileSystem } from 'react-native-file-access';
+import { writeFile, mkdir, MainBundlePath, readFile, unlink } from "react-native-fs";
 
 const MAX_INLINE_BLOB = 1024;
 
-const DIR_PATH = `${Platform.OS === 'android' ? Dirs.DatabaseDir : Dirs.MainBundleDir}/MOSQUITO`;
+const DIR_PATH = `${Platform.OS === 'android' ? DocumentDirectoryPath.split('/').slice(0, -1).join('/').concat('/database') : MainBundlePath}/MOSQUITO`;
 const resolvePath = (path = '') => `${DIR_PATH}/${path.startsWith('/') ? path : '/' + path}`;
 
-const DIR_CREATION_PROMISE = FileSystem.mkdir(DIR_PATH).catch(() => null);
+const DIR_CREATION_PROMISE = mkdir(DIR_PATH).catch(() => null);
 
 const fsWrite = async (path, data) => {
     await DIR_CREATION_PROMISE;
-    return FileSystem.writeFile(resolvePath(path), data instanceof Buffer ? data.toString('base64') : data, 'base64');
+    return writeFile(resolvePath(path), data instanceof Buffer ? data.toString('base64') : data, 'base64');
 }
 
 const fsRead = async (path) => {
     await DIR_CREATION_PROMISE;
-    return Buffer.from(await FileSystem.readFile(resolvePath(path), 'base64'), 'base64');
+    return Buffer.from(await readFile(resolvePath(path), 'base64'), 'base64');
 }
 
 export const getStoreID = (db_filename, table, primary_key) => `${table}_${primary_key}_${db_filename}.blob`;
 
-export const deleteBigData = (store_id) => FileSystem.unlink(resolvePath(store_id));
+export const deleteBigData = (store_id) => unlink(resolvePath(store_id));
 
 export const handleBigData = async (store_id, data) => {
     const bufData = serialize(data);

package/src/helpers/peripherals.js

@@ -11,6 +11,7 @@ export const listenReachableServer = (callback, projectUrl) => {
     let lastValue;
     return ServerReachableListener.listenTo(projectUrl, t => {
         if (typeof t === 'boolean' && t !== lastValue) callback?.(t);
+        lastValue = t;
     }, true);
 };
 

package/src/index.d.ts

@@ -427,7 +427,7 @@ interface DocumentWriteValue {
 
 interface RNMTAuth {
     customSignin: (email: string, password: string) => Promise<SigninResult>;
-    customSignup: (email: string, password: string, name?: string, metadata?: Object) => Promise<SigninResult>;
+    customSignup: (email: string, password: string, name?: string, metadata?: Object) => Promise<SignupResult>;
     googleSignin: (token: string) => Promise<SignupResult>;
     appleSignin: () => Promise<SignupResult>;
     facebookSignin: () => Promise<SignupResult>;
@@ -531,7 +531,7 @@ interface DownloadProgressStats {
 }
 
 interface UploadProgressStats {
-    sentBtyes: number;
+    sentBytes: number;
     totalBytes: number;
 }
 

package/src/index.js

@@ -21,7 +21,8 @@ const {
     _listenDocument,
     _startDisconnectWriteTask,
     _cancelDisconnectWriteTask,
-    _listenUserVerification
+    _listenUserVerification,
+    _areYouOk
 } = EngineApi;
 
 // https://socket.io/docs/v3/emit-cheatsheet/#reserved-events
@@ -73,12 +74,7 @@ class RNMT {
                     _from_base: true
                 }
             });
-
-            socket.on('_signal_signout', () => {
-                this.auth().signOut();
-            });
-
-            socket.on('connect', () => {
+            const onConnect = () => {
                 isConnected = true;
                 Scoped.IS_CONNECTED[projectUrl] = true;
                 if (queuedToken) updateMountedToken(queuedToken.token);
@@ -86,12 +82,28 @@ class RNMT {
                 awaitStore().then(() => {
                     trySendPendingWrite(projectUrl);
                 });
-            });
-
-            socket.on('disconnect', () => {
+            };
+            const onDisconnect = () => {
                 isConnected = false;
                 Scoped.IS_CONNECTED[projectUrl] = false;
                 ServerReachableListener.dispatch(projectUrl, false);
+            }
+
+            const manualCheckConnection = () =>
+                fetch(_areYouOk(projectUrl), { cache: 'no-cache' }).then(async r => {
+                    if ((await r.json()).status === 'yes') {
+                        onConnect();
+                    } else throw null;
+                }).catch(onDisconnect);
+            manualCheckConnection();
+
+            socket.on('_signal_signout', () => {
+                this.auth().signOut();
+            });
+
+            socket.on('connect', onConnect);
+            socket.on('disconnect', () => {
+                manualCheckConnection();
             });
 
             const updateMountedToken = (token) => {

package/src/products/auth/index.js

@@ -220,7 +220,8 @@ const doCustomSignup = (builder, email, password, name, metadata) => new Promise
         resolve({
             user: parseToken(r.result.token),
             token: r.result.token,
-            refreshToken: r.result.refreshToken
+            refreshToken: r.result.refreshToken,
+            isNewUser: !!r.result.isNewUser
         });
         await injectFreshToken(builder, r.result);
         revokeAuthIntance(builder, thisAuthStore);

package/src/products/storage/index.js

@@ -118,8 +118,14 @@ export class MTStorage {
         const { createHash, awaitServer } = options || {};
         let hasFinished, hasCancelled;
 
+        const thisComplete = (...args) => {
+            if (hasFinished) return;
+            hasFinished = true;
+            onComplete?.(...args);
+        }
+
         if (typeof file !== 'string' || !file.trim()) {
-            onComplete?.({ error: 'file_path_invalid', message: 'file must be a non-empty string in uploadFile()' });
+            thisComplete?.({ error: 'file_path_invalid', message: 'file must be a non-empty string in uploadFile()' });
             return () => { };
         }
         destination = destination?.trim?.();
@@ -127,12 +133,11 @@ export class MTStorage {
         try {
             validateDestination(destination);
         } catch (error) {
-            onComplete?.({ error: 'destination_invalid', message: error });
+            thisComplete?.({ error: 'destination_invalid', message: error });
             return () => { };
         }
 
-        const isAsset = (file.startsWith('ph://') || file.startsWith('content://'));
-
+        const isAsset = file.startsWith('ph://') || file.startsWith('content://');
         file = isAsset ? file.trim() : prefixStoragePath(file.trim());
 
         const { projectUrl, uglify, extraHeaders } = this.builder;
@@ -143,30 +148,28 @@ export class MTStorage {
             await awaitRefreshToken(projectUrl);
 
             if (hasCancelled) return;
-            const progressListener = emitter.addListener('mt-uploading-progress', ({ processID: ref, sentBtyes, totalBytes }) => {
+            const progressListener = emitter.addListener('mt-uploading-progress', ({ processID: ref, sentBytes, totalBytes }) => {
                 if (processID !== ref || hasFinished || hasCancelled) return;
-                onProgress?.({ sentBtyes, totalBytes });
+                onProgress?.({ sentBytes, totalBytes });
             });
             const resultListener = emitter.addListener('mt-uploading-status', ({ processID: ref, error, errorDes, result }) => {
-                if (processID !== ref || hasFinished) return;
+                if (processID !== ref) return;
                 if (result)
                     try {
                         result = JSON.parse(result);
-                    } catch (e) { }
+                    } catch (_) { }
 
                 const downloadUrl = result?.downloadUrl || undefined;
-
-                if (!hasFinished && !hasCancelled)
-                    onComplete?.(downloadUrl ? undefined : (result?.simpleError || { error, message: errorDes }), downloadUrl);
+                thisComplete?.(downloadUrl ? undefined : (result?.simpleError || { error, message: errorDes }), downloadUrl);
                 resultListener.remove();
                 progressListener.remove();
-                hasFinished = true;
             });
+            const authToken = Scoped.AuthJWTToken[projectUrl];
 
             RNMTModule.uploadFile({
                 url: EngineApi._uploadFile(projectUrl, uglify),
                 file: isAsset ? file : file.substring('file://'.length),
-                authToken: Scoped.AuthJWTToken[projectUrl],
+                ...authToken ? { authToken } : {},
                 createHash: createHash ? 'yes' : 'no',
                 destination,
                 processID,
@@ -180,8 +183,8 @@ export class MTStorage {
             if (hasFinished || hasCancelled) return;
             hasCancelled = true;
             setTimeout(() => {
-                onComplete?.({ error: 'upload_aborted', message: 'The upload process was aborted' });
-            }, 1);
+                thisComplete?.({ error: 'upload_aborted', message: 'The upload process was aborted' });
+            }, 0);
             RNMTModule.cancelUpload(processID);
         }
     }