roboto-js 1.4.50 → 1.5.1

package/dist/esm/rbt_file.js

@@ -1,17 +1,16 @@
+import { Upload } from 'tus-js-client';
 import _ from 'lodash';
 import EventEmitter from 'eventemitter3';
 export default class RbtFile extends EventEmitter {
-  static FRAME_SIZE = 1024 * 1024; // 1MB, for example
-
-  constructor(record, axiosInstance, localDb) {
+  constructor(record, axiosInstance) {
     super(); // Call the constructor of EventEmitter
+
+    this.isRbtFile = true;
     this.id = record.id;
     this._axios = axiosInstance;
     this._internalData = record;
     this._data = record.data ? record.data : record.dataJson ? JSON.parse(record.dataJson) : {};
-    this._localDb = localDb;
     this.progress = 0;
-    this.fileHeader = {};
   }
   get(path) {
     return _.get(this._data, path);
@@ -24,6 +23,13 @@ export default class RbtFile extends EventEmitter {
       ...this._data
     };
   }
+  setData(data) {
+    // Use lodash's merge to deeply merge the incoming data into _data
+    _.merge(this._data, data);
+    return {
+      ...this._data
+    }; // Return the updated _data as a new object
+  }
   toRecord() {
     return {
       ...this._internalData,
@@ -53,7 +59,7 @@ export default class RbtFile extends EventEmitter {
     }
     try {
       const record = this.toRecord();
-      const response = await this._axios.post('/object_service/deleteObject', [record]);
+      const response = await this._axios.delete(`/object_service/deleteObject/${this.id}`);
       if (response.data.ok === false) {
         throw new Error(response.data.message);
       }
@@ -64,175 +70,66 @@ export default class RbtFile extends EventEmitter {
       throw e; // Propagate the error
     }
   }
-  async getFileBlobUrl() {
-    const db = this._localDb;
-    const tx = db.transaction('files', 'readonly');
-    const cursor = await tx.store.openCursor();
-    if (!cursor) return null;
-    const fileData = cursor.value.chunk; // Assuming the first chunk has enough data
-    const blob = new Blob([fileData], {
-      type: 'application/octet-stream'
-    });
-    return URL.createObjectURL(blob);
-  }
-  setProgress(newProgress) {
-    this.progress = newProgress;
-    //console.log(`Progress: ${this.progress * 100}%`);
-    this.emit('progress', this.progress); // Emit a progress event
-  }
-  async readAndStoreFile(file) {
-    let offset = 0;
-    this.fileHeader = {
-      id: this.id,
-      name: file.name,
-      size: file.size,
-      ext: this._extractFileExtension(file.name),
-      mimeType: file.type,
-      numFrames: Math.ceil(file.size / RbtFile.FRAME_SIZE)
-    };
-    while (offset < file.size) {
-      const chunk = file.slice(offset, offset + RbtFile.FRAME_SIZE);
-      await new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onload = async e => {
-          const arrayBuffer = e.target.result;
-          const frameIndex = offset / RbtFile.FRAME_SIZE;
-          await this._storeChunkInIDB(arrayBuffer, frameIndex, this.fileHeader);
-          this.setProgress((frameIndex + 1) / this.fileHeader.numFrames);
-          resolve();
-        };
-        reader.onerror = () => reject(reader.error);
-        reader.readAsArrayBuffer(chunk);
-      });
-      offset += RbtFile.FRAME_SIZE;
-    }
-  }
-  _extractFileExtension(fileName) {
-    // Find the last dot in the filename
-    const lastDotIndex = fileName.lastIndexOf('.');
-
-    // No dot found, or the dot is the first character (hidden files)
-    if (lastDotIndex === -1 || lastDotIndex === 0) return '';
+  uploadFile(file) {
+    return new Promise((resolve, reject) => {
+      const upload = new Upload(file, {
+        endpoint: this._axios.defaults.baseURL + "/file_service/files",
+        retryDelays: [0, 1000, 3000, 5000],
+        metadata: {
+          rbtfileid: this.id,
+          filename: file.name,
+          filetype: file.type
+        },
+        onError: error => {
+          console.error("Failed because:", error);
+          this.emit('error', error);
+          reject(error); // Reject the promise on error
+        },
+        onProgress: (bytesUploaded, bytesTotal) => {
+          const percentage = (bytesUploaded / bytesTotal * 100).toFixed(2);
+          this.emit('progress', percentage / 100); // Emit normalized progress
+        },
+        onSuccess: () => {
+          //console.log("File uploaded to:", upload.url);
+          const m1 = upload.url.match(/\/([^\/]+)$/);
+          const remoteId = m1 ? m1[1] : null;
+          this.setData({
+            'remoteId': remoteId,
+            'remoteSrc': upload.url,
+            'sourceFile': {
+              name: upload.file.name,
+              size: upload.file.size,
+              type: upload.file.type,
+              lastModified: upload.file.lastModified
+            }
+          });
 
-    // Extract the extension
-    return fileName.substring(lastDotIndex + 1);
-  }
-  async _storeChunkInIDB(chunk, frameIndex, fileHeader) {
-    const db = this._localDb;
-    if (!db) {
-      console.error('Database not initialized');
-      return;
-    }
-    const tx = db.transaction('files', 'readwrite');
-    const frameKey = `${this.id}_${frameIndex}`; // Unique key combining id and frameIndex
-    await tx.store.put({
-      key: frameKey,
-      chunk,
-      fileHeader
-    }, frameKey);
-    await tx.done;
-  }
-  async _readFrameFromIDB(frameIndex) {
-    const db = this._localDb;
-    if (!db) {
-      console.error('Database not initialized');
-      return null;
-    }
-    const frameKey = `${this.id}_${frameIndex}`; // Same key as used in _storeChunkInIDB
-    const tx = db.transaction('files', 'readonly');
-    const frame = await tx.store.get(frameKey);
-    return frame ? frame.chunk : null;
-  }
-  async uploadFile() {
-    if (!this.fileHeader || !this.fileHeader.numFrames) {
-      throw new Error("File not ready for upload.");
-    }
-    this.fileRecord = this.toRecord();
-    let frameRes;
-    for (let frameIndex = 0; frameIndex < this.fileHeader.numFrames; frameIndex++) {
-      try {
-        const frameData = await this._readFrameFromIDB(frameIndex);
-        if (!frameData) {
-          throw new Error(`Failed to read frame ${frameIndex}`);
+          // Ensure save is called and finished before resolving the promise
+          this.save().then(() => {
+            this.emit('success', upload.url);
+            resolve(); // Resolve the promise after save is complete
+          }).catch(error => {
+            console.error("Save failed:", error);
+            reject(error); // Reject the promise if save fails
+          });
         }
-        frameRes = await this._uploadFrameToServer(frameData, frameIndex, this.fileHeader, this.fileRecord);
-
-        // Update progress after each frame is uploaded
-        this.setProgress((frameIndex + 1) / this.fileHeader.numFrames);
-      } catch (error) {
-        console.error(`Error uploading frame ${frameIndex}:`, error);
-        throw error; // Stop the upload process if an error occurs
-      }
-    }
-
-    //
-    // DONE UPLOADING, PROCESSING
-    //
-
-    try {
-      const statusRes = await this._checkUploadStatusUntilDone(this.fileRecord);
-      this.set('remoteSrc', statusRes.remoteSrc);
-      this.set('progress', 1);
-      await this.save();
-    } catch (error) {
-      console.error('Error during upload status check:', error);
-      // Handle error, possibly update UI or retry logic
-    }
-  }
-  async _uploadFrameToServer(frameData, frameIndex, fileHeader, fileRecord) {
-    const base64Data = this.convertToBase64(frameData);
-    const payload = ["@filekit.ffs_server_receiveAndStore_toS3_flow", {
-      "fileObject": fileRecord,
-      // using fileRecord from newFile.toRecord()
-      "fileHeader": fileHeader,
-      "frameIndex": frameIndex,
-      "frameData": `rpcBase64:${base64Data}`,
-      "timeout": 86400000
-    }];
+      });
 
-    //console.log(payload);
+      // Check if there are any previous uploads to continue.
+      // upload.findPreviousUploads().then(function (previousUploads) {
+      //     // Found previous uploads so we select the first one.
+      //     if (previousUploads.length) {
+      //       upload.resumeFromPreviousUpload(previousUploads[0])
+      //     }
 
-    const response = await this._axios.post('/file_service/ffs_runFlow', payload);
-    if (!response || response.status != 200) {
-      throw new Error('Error uploading frame to server');
-    }
-    return response;
-  }
-  async _checkUploadStatusUntilDone(fileRecord) {
-    return new Promise((resolve, reject) => {
-      const intervalId = setInterval(async () => {
-        try {
-          const statusRes = await this._uploadGetStatusUpdate(fileRecord);
-          if (statusRes.data && statusRes.data.fileHeader && statusRes.data.fileHeader.status === 'DONE') {
-            clearInterval(intervalId); // Stop the interval
-            resolve(statusRes.data.fileHeader); // Resolve the promise with the final status
-          } else {
-            // Optionally update progress or handle other status cases here
-            //this.emit('progress', statusRes.progress); // Emit progress updates if available
-          }
-        } catch (error) {
-          clearInterval(intervalId); // Stop the interval on error
-          reject(error); // Reject the promise if there's an error
-        }
-      }, 2000); // Check every 2 seconds
+      //     // Start the upload
+      //     upload.start();
+      // })
+      upload.start(); // Start the upload
     });
   }
-  async _uploadGetStatusUpdate(fileRecord) {
-    const payload = ["@filekit.ffs_server_receiveAndStore_toS3_flow", {
-      "fileObject": fileRecord,
-      // using fileRecord from newFile.toRecord()
-      "getStatusUpdate": true
-    }];
-
-    //console.log(payload);
-
-    const response = await this._axios.post('/file_service/ffs_runFlow', payload);
-    if (!response || response.status != 200) {
-      throw new Error('Error getting upload status');
-    }
-    return response;
-  }
-  convertToBase64(buffer) {
-    return btoa(new Uint8Array(buffer).reduce((data, byte) => data + String.fromCharCode(byte), ''));
+  setProgress(newProgress) {
+    this.progress = newProgress;
+    this.emit('progress', this.progress); // Emit a progress event
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roboto-js",
-  "version": "1.4.50",
+  "version": "1.5.1",
   "type": "module",
   "description": "",
   "main": "dist/cjs/index.cjs",
@@ -25,7 +25,8 @@
     "crypto-js": "^4.1.1",
     "eventemitter3": "^5.0.1",
     "idb": "^8.0.0",
-    "lodash": "^4.17.21"
+    "lodash": "^4.17.21",
+    "tus-js-client": "^4.2.3"
   },
   "devDependencies": {
     "@babel/cli": "^7.23.9",

package/src/index.js

@@ -132,6 +132,9 @@ export default class Roboto{
   async loadFile(id){
     return this.api.loadFile(id);
   }
+  async loadFiles(ids){
+    return this.api.loadFiles(ids);
+  }
 
   //
   //

package/src/rbt_api.js

@@ -403,6 +403,27 @@ export default class RbtApi {
   
   }
 
+  async loadFiles(ids) {
+    try {
+      // Use the bulk load method with the provided IDs
+      const responses = await this.load('<@filekit.file>', ids);
+
+      if (!responses || !Array.isArray(responses)) {
+        return []; // Return an empty array if no responses or invalid data
+      }
+
+      // Map over the responses to create RbtFile instances
+      return responses.map(response => {
+        const record = response.toRecord();
+        return new RbtFile(record, this.axios, this.localDb);
+      });
+    } catch (e) {
+      this._handleError(e); // Handle errors (log or process as needed)
+      return []; // Return an empty array on failure
+    }
+  }
+
+
 
   /**
    * Creates a new object of the given type.

package/src/rbt_file.js

@@ -1,22 +1,18 @@
-
+import { Upload } from 'tus-js-client';
 import _ from 'lodash';
 import EventEmitter from 'eventemitter3';
 
-export default class RbtFile extends EventEmitter{
-
-    static FRAME_SIZE = 1024 * 1024; // 1MB, for example
-
-    constructor(record, axiosInstance, localDb) {
+export default class RbtFile extends EventEmitter {
 
+    constructor(record, axiosInstance) {
         super(); // Call the constructor of EventEmitter
+    
+        this.isRbtFile = true;
         this.id = record.id;
         this._axios = axiosInstance;
         this._internalData = record;
         this._data = record.data ? record.data : (record.dataJson ? JSON.parse(record.dataJson) : {});
-        this._localDb = localDb;
         this.progress = 0;
-
-        this.fileHeader = {};
     }
 
     get(path) {
@@ -31,6 +27,12 @@ export default class RbtFile extends EventEmitter{
         return { ...this._data };
     }
 
+    setData(data) {
+        // Use lodash's merge to deeply merge the incoming data into _data
+        _.merge(this._data, data);
+        return { ...this._data }; // Return the updated _data as a new object
+    }
+
     toRecord() {
         return {
             ...this._internalData,
@@ -52,7 +54,6 @@ export default class RbtFile extends EventEmitter{
             }
 
             this._internalData = response.data;
-
             return this;
 
         } catch (e) {
@@ -68,7 +69,7 @@ export default class RbtFile extends EventEmitter{
 
         try {
             const record = this.toRecord();
-            const response = await this._axios.post('/object_service/deleteObject', [record]);
+            const response = await this._axios.delete(`/object_service/deleteObject/${this.id}`);
 
             if (response.data.ok === false) {
                 throw new Error(response.data.message);
@@ -83,210 +84,71 @@ export default class RbtFile extends EventEmitter{
         }
     }
 
-    async getFileBlobUrl() {
-        const db = this._localDb;
-        const tx = db.transaction('files', 'readonly');
-        const cursor = await tx.store.openCursor();
-        if (!cursor) return null;
-        const fileData = cursor.value.chunk; // Assuming the first chunk has enough data
-        const blob = new Blob([fileData], { type: 'application/octet-stream' });
-        return URL.createObjectURL(blob);
-    }
-
-    setProgress(newProgress) {
-        this.progress = newProgress;
-        //console.log(`Progress: ${this.progress * 100}%`);
-        this.emit('progress', this.progress); // Emit a progress event
-    
-    }
-
-
-    async readAndStoreFile(file) {
-        let offset = 0;
-        this.fileHeader = {
-            id: this.id,
-            name: file.name,
-            size: file.size,
-            ext: this._extractFileExtension(file.name),
-            mimeType: file.type,
-            numFrames: Math.ceil(file.size / RbtFile.FRAME_SIZE)
-        };
-
-        while (offset < file.size) {
-            const chunk = file.slice(offset, offset + RbtFile.FRAME_SIZE);
-            await new Promise((resolve, reject) => {
-                const reader = new FileReader();
-                reader.onload = async (e) => {
-                    const arrayBuffer = e.target.result;
-                    const frameIndex = offset / RbtFile.FRAME_SIZE;
-                    await this._storeChunkInIDB(arrayBuffer, frameIndex, this.fileHeader);
-                    this.setProgress((frameIndex + 1) / this.fileHeader.numFrames);
-                    resolve();
-                };
-                reader.onerror = () => reject(reader.error);
-                reader.readAsArrayBuffer(chunk);
-            });
-            offset += RbtFile.FRAME_SIZE;
-        }
-    }
-
-    _extractFileExtension(fileName) {
-        // Find the last dot in the filename
-        const lastDotIndex = fileName.lastIndexOf('.');
-
-        // No dot found, or the dot is the first character (hidden files)
-        if (lastDotIndex === -1 || lastDotIndex === 0) return '';
-
-        // Extract the extension
-        return fileName.substring(lastDotIndex + 1);
-    }
-
-    async _storeChunkInIDB(chunk, frameIndex, fileHeader) {
-        const db = this._localDb;
-        if (!db) {
-            console.error('Database not initialized');
-            return;
-        }
-        const tx = db.transaction('files', 'readwrite');
-        const frameKey = `${this.id}_${frameIndex}`; // Unique key combining id and frameIndex
-        await tx.store.put({ key: frameKey, chunk, fileHeader }, frameKey);
-        await tx.done;
-    }
-
-    async _readFrameFromIDB(frameIndex) {
-        const db = this._localDb;
-        if (!db) {
-            console.error('Database not initialized');
-            return null;
-        }
-        const frameKey = `${this.id}_${frameIndex}`; // Same key as used in _storeChunkInIDB
-        const tx = db.transaction('files', 'readonly');
-        const frame = await tx.store.get(frameKey);
-
-        return frame ? frame.chunk : null;
-    }
-
-    async uploadFile() {
-        if (!this.fileHeader || !this.fileHeader.numFrames) {
-            throw new Error("File not ready for upload.");
-        }
-
-        this.fileRecord = this.toRecord();
-
-        let frameRes;
-
-        for (let frameIndex = 0; frameIndex < this.fileHeader.numFrames; frameIndex++) {
-            try {
-                const frameData = await this._readFrameFromIDB(frameIndex);
-                if (!frameData) {
-                    throw new Error(`Failed to read frame ${frameIndex}`);
+    uploadFile(file) {
+        return new Promise((resolve, reject) => {
+            const upload = new Upload(file, {
+                endpoint: this._axios.defaults.baseURL + "/file_service/files",
+                retryDelays: [0, 1000, 3000, 5000],
+                metadata: {
+                    rbtfileid: this.id,
+                    filename: file.name,
+                    filetype: file.type,
+                },
+                onError: error => {
+                    console.error("Failed because:", error);
+                    this.emit('error', error);
+                    reject(error); // Reject the promise on error
+                },
+                onProgress: (bytesUploaded, bytesTotal) => {
+                    const percentage = (bytesUploaded / bytesTotal * 100).toFixed(2);
+                    this.emit('progress', percentage / 100); // Emit normalized progress
+                },
+                onSuccess: () => {
+                    //console.log("File uploaded to:", upload.url);
+                    const m1 = upload.url.match(/\/([^\/]+)$/);
+                    const remoteId = m1 ? m1[1] : null;
+
+                    this.setData({
+                        'remoteId': remoteId,
+                        'remoteSrc': upload.url,
+                        'sourceFile': {
+                            name: upload.file.name,
+                            size: upload.file.size,
+                            type: upload.file.type,
+                            lastModified: upload.file.lastModified,
+                        }
+                    });
+                    
+                    // Ensure save is called and finished before resolving the promise
+                    this.save().then(() => {
+                        this.emit('success', upload.url);
+                        resolve(); // Resolve the promise after save is complete
+                    }).catch(error => {
+                        console.error("Save failed:", error);
+                        reject(error); // Reject the promise if save fails
+                    });
                 }
+            });
 
-                frameRes = await this._uploadFrameToServer(frameData, frameIndex, this.fileHeader, this.fileRecord);
-
-                // Update progress after each frame is uploaded
-                this.setProgress((frameIndex + 1) / this.fileHeader.numFrames);
-            } catch (error) {
-                console.error(`Error uploading frame ${frameIndex}:`, error);
-                throw error; // Stop the upload process if an error occurs
-            }
-        }
-    
-
-        //
-        // DONE UPLOADING, PROCESSING
-        //
-
-        try {
-          const statusRes = await this._checkUploadStatusUntilDone(this.fileRecord);
-
-          this.set('remoteSrc', statusRes.remoteSrc);
-          this.set('progress', 1);
-          await this.save();
-        } catch (error) {
-          console.error('Error during upload status check:', error);
-          // Handle error, possibly update UI or retry logic
-        }
-
-    }
-
-    async _uploadFrameToServer(frameData, frameIndex, fileHeader, fileRecord) {
-
-        const base64Data = this.convertToBase64(frameData);
-        const payload = [
-            "@filekit.ffs_server_receiveAndStore_toS3_flow",
-            {
-                "fileObject": fileRecord, // using fileRecord from newFile.toRecord()
-                "fileHeader": fileHeader,
-                "frameIndex": frameIndex,
-                "frameData": `rpcBase64:${base64Data}`,
-                "timeout": 86400000
-            }
-        ];
-
-        //console.log(payload);
-
-        const response = await this._axios.post('/file_service/ffs_runFlow', payload);
-
-        if (!response || response.status != 200) {
-            throw new Error('Error uploading frame to server');
-        }
-
-        return response;
-    }
-
-
-    async _checkUploadStatusUntilDone(fileRecord) {
 
-      return new Promise((resolve, reject) => {
-        const intervalId = setInterval(async () => {
-          try {
-            const statusRes = await this._uploadGetStatusUpdate(fileRecord);
-            if (statusRes.data && statusRes.data.fileHeader && statusRes.data.fileHeader.status === 'DONE') {
-              clearInterval(intervalId); // Stop the interval
-              resolve(statusRes.data.fileHeader); // Resolve the promise with the final status
-            } else {
-              // Optionally update progress or handle other status cases here
-              //this.emit('progress', statusRes.progress); // Emit progress updates if available
-            }
-          } catch (error) {
-            clearInterval(intervalId); // Stop the interval on error
-            reject(error); // Reject the promise if there's an error
-          }
-        }, 2000); // Check every 2 seconds
-      });
+        // Check if there are any previous uploads to continue.
+      // upload.findPreviousUploads().then(function (previousUploads) {
+      //     // Found previous uploads so we select the first one.
+      //     if (previousUploads.length) {
+      //       upload.resumeFromPreviousUpload(previousUploads[0])
+      //     }
 
+      //     // Start the upload
+      //     upload.start();
+      // })
+            upload.start(); // Start the upload
+        });
     }
 
 
 
-    async _uploadGetStatusUpdate(fileRecord){
-
-      const payload = [
-            "@filekit.ffs_server_receiveAndStore_toS3_flow",
-            {
-                "fileObject": fileRecord, // using fileRecord from newFile.toRecord()
-                "getStatusUpdate": true
-            }
-        ];
-
-        //console.log(payload);
-
-        const response = await this._axios.post('/file_service/ffs_runFlow', payload);
-
-        if (!response || response.status != 200) {
-            throw new Error('Error getting upload status');
-        }
-
-        return response;
-
-
-    }
-
-    convertToBase64(buffer) {
-        return btoa(
-            new Uint8Array(buffer)
-            .reduce((data, byte) => data + String.fromCharCode(byte), '')
-        );
+    setProgress(newProgress) {
+        this.progress = newProgress;
+        this.emit('progress', this.progress); // Emit a progress event
     }
 }