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

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.12",
   "types": "./types/index.d.ts",
   "scripts": {
     "format": "js-beautify -r src/*.js",

package/src/comm-error.js

@@ -1,14 +1,15 @@
 /**
- * @file Throwable error with numeric error code.
+ * @file Throwable error with numeric error code and optional params.
  *
  * @copyright 2015-2023 Tinode LLC.
  */
 'use strict';
 
 export default class CommError extends Error {
-  constructor(message, code) {
+  constructor(message, code, params) {
     super(`${message} (${code})`);
     this.name = 'CommError';
     this.code = code;
+    this.params = params;
   }
 }

package/src/large-file.native.js

@@ -112,21 +112,35 @@ 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 +148,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;
       }
-    });
+    })();
   }
 
   /**

package/src/tinode.js

@@ -495,6 +495,7 @@ export class Tinode {
 
   // Resolve or reject a pending promise.
   // Unresolved promises are stored in _pendingPromises.
+  // onOK is the full ctrl object, which contains params for error responses.
   #execPromise(id, code, onOK, errorText) {
     const callbacks = this._pendingPromises[id];
     if (callbacks) {
@@ -504,7 +505,8 @@ export class Tinode {
           callbacks.resolve(onOK);
         }
       } else if (callbacks.reject) {
-        callbacks.reject(new CommError(errorText, code));
+        // Pass params from ctrl response to CommError for richer error handling
+        callbacks.reject(new CommError(errorText, code, onOK?.params));
       }
     }
   }

package/umd/tinode.dev.js

@@ -360,10 +360,11 @@ __webpack_require__.r(__webpack_exports__);
 
 
 class CommError extends Error {
-  constructor(message, code) {
+  constructor(message, code, params) {
     super(`${message} (${code})`);
     this.name = 'CommError';
     this.code = code;
+    this.params = params;
   }
 }
 
@@ -852,15 +853,9 @@ class DB {
     });
   }
   initDatabase() {
-    console.log('[DB] initDatabase CALLED, shouldDelegate:', this.#shouldDelegate(), 'delegateStorage:', !!this.#delegateStorage);
     if (this.#shouldDelegate()) {
-      console.log('[DB] initDatabase DELEGATING to SQLiteStorage');
-      return this.#delegateStorage.initDatabase().then(result => {
-        console.log('[DB] initDatabase: SQLiteStorage initialized successfully');
-        return result;
-      });
+      return this.#delegateStorage.initDatabase();
     }
-    console.log('[DB] initDatabase using IndexedDB');
     return new Promise((resolve, reject) => {
       const req = IDBProvider.open(DB_NAME, DB_VERSION);
       req.onsuccess = event => {
@@ -955,10 +950,8 @@ class DB {
   }
   updTopic(topic) {
     if (topic?._new) {
-      console.log('[DB] updTopic DEFERRED - topic not yet confirmed by server:', topic.name);
       return Promise.resolve();
     }
-    console.log('[DB] updTopic CALLED:', topic?.name, 'shouldDelegate:', this.#shouldDelegate());
     if (this.#shouldDelegate()) {
       return this.#delegateStorage.updTopic(topic);
     }
@@ -1031,15 +1024,9 @@ class DB {
     });
   }
   mapTopics(callback, context) {
-    console.log('[DB] mapTopics CALLED, shouldDelegate:', this.#shouldDelegate());
     if (this.#shouldDelegate()) {
-      console.log('[DB] mapTopics DELEGATING to SQLiteStorage');
-      return this.#delegateStorage.mapTopics(callback, context).then(result => {
-        console.log('[DB] mapTopics: SQLiteStorage returned', result ? result.length : 0, 'topics');
-        return result;
-      });
+      return this.#delegateStorage.mapTopics(callback, context);
     }
-    console.log('[DB] mapTopics using IndexedDB');
     return this.#mapObjects('topic', callback, context);
   }
   deserializeTopic(topic, src) {
@@ -1246,12 +1233,9 @@ class DB {
     });
   }
   readMessages(topicName, query, callback, context) {
-    console.log('[DB] readMessages CALLED:', topicName, 'shouldDelegate:', this.#shouldDelegate(), 'delegateStorage:', !!this.#delegateStorage);
     if (this.#shouldDelegate()) {
-      console.log('[DB] readMessages DELEGATING to SQLiteStorage');
       return this.#delegateStorage.readMessages(topicName, query, callback, context);
     }
-    console.log('[DB] readMessages NOT delegating, using IndexedDB');
     query = query || {};
     if (!this.isReady()) {
       return this.disabled ? Promise.resolve([]) : Promise.reject(new Error("not initialized"));
@@ -5267,13 +5251,10 @@ class Topic {
     return this._queuedSeqId++;
   }
   _loadMessages(db, query) {
-    console.log('[Topic] _loadMessages CALLED:', this.name, 'query:', JSON.stringify(query), 'db:', !!db);
     query = query || {};
     query.limit = query.limit || _config_js__WEBPACK_IMPORTED_MODULE_3__.DEFAULT_MESSAGES_PAGE;
     let count = 0;
-    console.log('[Topic] _loadMessages: calling db.readMessages');
     return db.readMessages(this.name, query).then(msgs => {
-      console.log('[Topic] _loadMessages: db.readMessages returned', msgs ? msgs.length : 0, 'messages');
       msgs.forEach(data => {
         if (data.seq > this._maxSeq) {
           this._maxSeq = data.seq;
@@ -5285,7 +5266,6 @@ class Topic {
         this._maybeUpdateMessageVersionsCache(data);
       });
       count = msgs.length;
-      console.log('[Topic] _loadMessages: processed', count, 'messages, _maxSeq:', this._maxSeq, '_minSeq:', this._minSeq);
     }).then(_ => db.readDelLog(this.name, query)).then(dellog => {
       return dellog.forEach(rec => {
         this._messages.put({
@@ -5565,7 +5545,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   PACKAGE_VERSION: function() { return /* binding */ PACKAGE_VERSION; }
 /* harmony export */ });
-const PACKAGE_VERSION = "0.25.1-sqlite.8";
+const PACKAGE_VERSION = "0.25.1-sqlite.12";
 
 /***/ })
 
@@ -6027,7 +6007,7 @@ class Tinode {
           callbacks.resolve(onOK);
         }
       } else if (callbacks.reject) {
-        callbacks.reject(new _comm_error_js__WEBPACK_IMPORTED_MODULE_2__["default"](errorText, code));
+        callbacks.reject(new _comm_error_js__WEBPACK_IMPORTED_MODULE_2__["default"](errorText, code, onOK?.params));
       }
     }
   }