@roeehrl/tinode-sdk 0.25.1-sqlite.10 → 0.25.1-sqlite.11

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@roeehrl/tinode-sdk",
   "description": "Tinode SDK fork with Storage interface for SQLite persistence in React Native",
-  "version": "0.25.1-sqlite.10",
+  "version": "0.25.1-sqlite.11",
   "types": "./types/index.d.ts",
   "scripts": {
     "format": "js-beautify -r src/*.js",

package/src/large-file.native.js

@@ -112,21 +112,30 @@ export default class LargeFileHelperNative {
     const url = this._buildUploadUrl(baseUrl);
     const headers = this._buildHeaders();
 
+    // Log upload details
+    this._tinode.logger("Starting upload to:", url);
+    this._tinode.logger("Upload file:", { uri, filename, mimetype, size });
+
     // Create AbortController for cancellation
     const abortController = new AbortController();
     this._abortControllers.push(abortController);
 
-    return new Promise((resolve, reject) => {
+    // Use fetch instead of XHR - React Native XHR has issues with FormData uploads
+    // where the response body is not accessible. Fetch works correctly.
+    // Note: We lose upload progress tracking with fetch, but the upload works.
+    return (async () => {
       try {
         // Build FormData with file URI (React Native specific)
         const formData = new FormData();
 
         // React Native FormData accepts objects with uri, type, and name
-        formData.append('file', {
+        const fileObj = {
           uri: uri,
           type: mimetype,
           name: filename,
-        });
+        };
+        instance._tinode.logger("FormData file object:", fileObj);
+        formData.append('file', fileObj);
 
         formData.append('id', this._tinode.getNextUniqueId());
 
@@ -134,103 +143,96 @@ export default class LargeFileHelperNative {
           formData.append('topic', avatarFor);
         }
 
-        // Use fetch with upload progress via XMLHttpRequest
-        // Note: fetch doesn't support upload progress, so we use XMLHttpRequest
-        const xhr = new XMLHttpRequest();
+        // Signal progress start (we can't track actual progress with fetch)
+        if (onProgress) {
+          onProgress(0.1); // Indicate upload started
+        }
+        if (instance.onProgress) {
+          instance.onProgress(0.1);
+        }
 
-        xhr.open('POST', url, true);
+        instance._tinode.logger("Sending fetch request...");
 
-        // Set headers
-        Object.keys(headers).forEach(key => {
-          xhr.setRequestHeader(key, headers[key]);
+        const response = await fetch(url, {
+          method: 'POST',
+          headers: headers,
+          body: formData,
+          signal: abortController.signal,
         });
 
-        // Handle abort
-        abortController.signal.addEventListener('abort', () => {
-          xhr.abort();
+        instance._tinode.logger("Fetch response:", {
+          status: response.status,
+          statusText: response.statusText,
+          ok: response.ok,
         });
 
-        // Progress tracking
-        if (onProgress || instance.onProgress) {
-          xhr.upload.onprogress = (e) => {
-            if (e.lengthComputable) {
-              const progress = e.loaded / e.total;
-              if (onProgress) {
-                onProgress(progress);
-              }
-              if (instance.onProgress) {
-                instance.onProgress(progress);
-              }
-            } else if (size > 0) {
-              // Use provided size if available
-              const progress = Math.min(e.loaded / size, 1);
-              if (onProgress) {
-                onProgress(progress);
-              }
-              if (instance.onProgress) {
-                instance.onProgress(progress);
-              }
+        // Signal progress near completion
+        if (onProgress) {
+          onProgress(0.9);
+        }
+        if (instance.onProgress) {
+          instance.onProgress(0.9);
+        }
+
+        const responseText = await response.text();
+        instance._tinode.logger("Response text:", responseText.substring(0, 200));
+
+        let pkt;
+        try {
+          pkt = JSON.parse(responseText);
+        } catch (err) {
+          instance._tinode.logger("ERROR: Failed to parse server response:", responseText);
+          pkt = {
+            ctrl: {
+              code: response.status,
+              text: response.statusText || 'Unknown error'
             }
           };
         }
 
-        xhr.onload = function() {
-          let pkt;
-          try {
-            pkt = JSON.parse(this.response);
-          } catch (err) {
-            instance._tinode.logger("ERROR: Invalid server response in LargeFileHelperNative", this.response);
-            pkt = {
-              ctrl: {
-                code: this.status,
-                text: this.statusText
-              }
-            };
-          }
+        // Signal completion
+        if (onProgress) {
+          onProgress(1);
+        }
+        if (instance.onProgress) {
+          instance.onProgress(1);
+        }
 
-          if (this.status >= 200 && this.status < 300) {
-            const uploadUrl = pkt.ctrl.params.url;
-            resolve(uploadUrl);
-            if (onSuccess) {
-              onSuccess(pkt.ctrl);
-            }
-          } else if (this.status >= 400) {
-            const error = new CommError(pkt.ctrl.text, pkt.ctrl.code);
-            reject(error);
-            if (onFailure) {
-              onFailure(pkt.ctrl);
-            }
-          } else {
-            instance._tinode.logger("ERROR: Unexpected server response status", this.status, this.response);
-            reject(new Error(`Unexpected status: ${this.status}`));
+        if (response.ok && pkt.ctrl && pkt.ctrl.params && pkt.ctrl.params.url) {
+          const uploadUrl = pkt.ctrl.params.url;
+          instance._tinode.logger("Upload success, URL:", uploadUrl);
+          if (onSuccess) {
+            onSuccess(pkt.ctrl);
           }
-        };
-
-        xhr.onerror = function(e) {
-          const error = e || new Error("Upload failed");
-          reject(error);
+          return uploadUrl;
+        } else if (response.status >= 400) {
+          const errorCode = pkt.ctrl?.code || response.status;
+          const errorText = pkt.ctrl?.text || 'Upload failed';
+          instance._tinode.logger("Upload error:", errorCode, errorText);
+          const error = new CommError(errorText, errorCode);
           if (onFailure) {
-            onFailure(null);
+            onFailure(pkt.ctrl);
           }
-        };
-
-        xhr.onabort = function() {
-          const error = new Error("Upload cancelled by user");
-          reject(error);
+          throw error;
+        } else {
+          instance._tinode.logger("ERROR: Unexpected response - status:", response.status, "response:", responseText);
+          throw new Error(`Unexpected status: ${response.status}, response: ${responseText ? responseText.substring(0, 100) : 'empty'}`);
+        }
+      } catch (err) {
+        if (err.name === 'AbortError') {
+          instance._tinode.logger("Upload aborted");
           if (onFailure) {
             onFailure(null);
           }
-        };
-
-        xhr.send(formData);
-
-      } catch (err) {
-        reject(err);
+          throw new Error("Upload cancelled by user");
+        }
+        instance._tinode.logger("Upload error:", err.message);
         if (onFailure) {
           onFailure(null);
         }
+        throw err;
       }
-    });
+    })();
   }
 
   /**