roboto-js 1.4.50 → 1.5.0

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,60 @@ 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) {
+    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);
+      },
+      onProgress: (bytesUploaded, bytesTotal) => {
+        console.log("File progress", bytesUploaded, bytesTotal);
+        const percentage = (bytesUploaded / bytesTotal * 100).toFixed(2);
+        this.setProgress(percentage / 100); // Update progress normalized between 0 and 1
+      },
+      onSuccess: () => {
+        console.log("File uploaded to:", upload.url);
 
-    // 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}`);
-        }
-        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
+        // Remove the `options.endpoint` from the start of the `url`
+        const m1 = upload.url.match(/\/([^\/]+)$/);
+        const remoteId = m1 ? m1[1] : null;
+        this.setData({
+          'remoteId': remoteId,
+          'sourceFile': {
+            name: upload.file.name,
+            size: upload.file.size,
+            type: upload.file.type,
+            lastModified: upload.file.lastModified
           }
-        } catch (error) {
-          clearInterval(intervalId); // Stop the interval on error
-          reject(error); // Reject the promise if there's an error
-        }
-      }, 2000); // Check every 2 seconds
+        });
+        this.save().then(() => {
+          this.emit('success', upload.url);
+        });
+      }
     });
-  }
-  async _uploadGetStatusUpdate(fileRecord) {
-    const payload = ["@filekit.ffs_server_receiveAndStore_toS3_flow", {
-      "fileObject": fileRecord,
-      // using fileRecord from newFile.toRecord()
-      "getStatusUpdate": true
-    }];
 
-    //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 getting upload status');
-    }
-    return response;
+    //     // Start the upload
+    //     upload.start();
+    // })
+    upload.start();
   }
-  convertToBase64(buffer) {
-    return btoa(new Uint8Array(buffer).reduce((data, byte) => data + String.fromCharCode(byte), ''));
+  setProgress(newProgress) {
+    this.progress = newProgress;
+    console.log(`Progress: ${this.progress * 100}%`);
+    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.0",
   "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,63 @@ 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}`);
-                }
-
-                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
+    uploadFile(file) {
+
+        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);
+            },
+            onProgress: (bytesUploaded, bytesTotal) => {
+                console.log("File progress", bytesUploaded, bytesTotal);
+                const percentage = (bytesUploaded / bytesTotal * 100).toFixed(2);
+                this.setProgress(percentage / 100); // Update progress normalized between 0 and 1
+            },
+            onSuccess: () => {
+                console.log("File uploaded to:", upload.url);
+                
+                // Remove the `options.endpoint` from the start of the `url`
+                const m1 = upload.url.match(/\/([^\/]+)$/);
+                const remoteId = m1 ? m1[1] : null;
+
+                this.setData({
+                    'remoteId': remoteId,
+                    'sourceFile': {
+                        name: upload.file.name,
+                        size: upload.file.size,
+                        type: upload.file.type,
+                        lastModified: upload.file.lastModified,
+                    }
+                });
+                this.save().then(() => {
+                    this.emit('success', upload.url);
+                });
             }
-          } catch (error) {
-            clearInterval(intervalId); // Stop the interval on error
-            reject(error); // Reject the promise if there's an error
-          }
-        }, 2000); // Check every 2 seconds
-      });
-
-    }
-
-
-
-    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;
+        });
 
+        // 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();
     }
 
-    convertToBase64(buffer) {
-        return btoa(
-            new Uint8Array(buffer)
-            .reduce((data, byte) => data + String.fromCharCode(byte), '')
-        );
+    setProgress(newProgress) {
+        this.progress = newProgress;
+        console.log(`Progress: ${this.progress * 100}%`);
+        this.emit('progress', this.progress); // Emit a progress event
     }
 }