react-native-mosquito-transport 0.0.26 → 0.0.28

package/README.md

@@ -13,6 +13,7 @@ or using yarn
 ```sh
 yarn add react-native-mosquito-transport
 ```
+internal bson
 
 ## Usage
 

package/TODO

@@ -20,4 +20,5 @@
 - lodashes ✅
 - switch to events package
 - serverTimeOffset
+- avoid sending cookies
 <!-- - error: "refreshToken retry limit exceeded" <--- no need -->

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.26",
+  "version": "0.0.28",
   "description": "React native javascript sdk for mosquito-transport (https://github.com/brainbehindx/mosquito-transport)",
   "main": "src/index.js",
   "type": "module",

package/src/index.d.ts

@@ -531,7 +531,7 @@ interface DownloadProgressStats {
 }
 
 interface UploadProgressStats {
-    sentBtyes: number;
+    sentBytes: number;
     totalBytes: number;
 }
 

package/src/products/database/accessor.js

@@ -7,7 +7,7 @@ import setLodash from 'lodash/set';
 import unsetLodash from 'lodash/unset';
 import { DatabaseRecordsListener } from "../../helpers/listeners";
 import cloneDeep from "lodash/cloneDeep";
-import { BSONRegExp, ObjectId, Timestamp } from "bson";
+import { BSONRegExp, ObjectId, Timestamp } from "bson/lib/bson.rn.cjs";
 import { niceGuard, Validator } from "guard-object";
 import { TIMESTAMP } from "../..";
 import { docSize, incrementDatabaseSize } from "./counter";

package/src/products/database/bson.js

@@ -1,4 +1,4 @@
-import { deserialize, serialize } from "bson";
+import { deserialize, serialize } from "bson/lib/bson.rn.cjs";
 import { Buffer } from "buffer";
 
 export const deserializeBSON = (data, cast) => {

package/src/products/database/index.js

@@ -8,7 +8,7 @@ import { addPendingWrites, generateRecordID, getCountQuery, getRecord, insertCou
 import { validateCollectionName, validateFilter, validateFindConfig, validateFindObject, validateListenFindConfig } from "./validator";
 import { awaitRefreshToken, listenToken } from "../auth/accessor";
 import { DELIVERY, RETRIEVAL } from "../../helpers/values";
-import { ObjectId } from "bson";
+import { ObjectId } from "bson/lib/bson.rn.cjs";
 import { guardObject, Validator } from "guard-object";
 import { simplifyCaughtError } from "simplify-error";
 import cloneDeep from "lodash/cloneDeep";

package/src/products/database/validator.js

@@ -2,7 +2,7 @@ import { guardArray, GuardError, guardObject, GuardSignal, niceGuard, Validator
 import { sameInstance } from "../../helpers/peripherals";
 import { RETRIEVAL } from "../../helpers/values";
 import getLodash from 'lodash/get';
-import { Binary, BSONRegExp, BSONSymbol, Code, DBRef, Decimal128, Double, Int32, Long, MaxKey, MinKey, ObjectId, Timestamp, UUID } from 'bson';
+import { Binary, BSONRegExp, BSONSymbol, Code, DBRef, Decimal128, Double, Int32, Long, MaxKey, MinKey, ObjectId, Timestamp, UUID } from 'bson/lib/bson.rn.cjs';
 import { bboxPolygon, booleanIntersects, booleanWithin, circle, distance, polygon } from "@turf/turf";
 
 const DirectionList = [1, -1, 'asc', 'desc', 'ascending', 'descending'];

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);
         }
     }