@weapnl/js-junction 0.1.4 → 0.3.0

package/index.d.ts

@@ -9,6 +9,7 @@ declare class Api {
     constructor();
 
     host(host: string): this;
+    chunkUploadsBySize(bytes: number): this;
     suffix(suffix: string): this;
     readonly baseUrl: string;
 
@@ -80,7 +81,7 @@ declare class Request extends Mixins {
     post(data?: object): Promise<this>;
     put(data?: object): Promise<this>;
     setKey(key: string): this;
-    delete(): Promise<this>;
+    delete(data?: object): Promise<this>;
     storeFiles(files?: object, data?: object, url?: string|null): Promise<this>;
     readonly bodyParameters: object;
     onSuccess<T = any>(callback?: (result: T, data: any, response: Response) => void): this;
@@ -126,7 +127,7 @@ export class Model extends Request {
 
     update(extraData?: JsonMap): Promise<Model>;
 
-    destroy(): Promise<boolean>;
+    destroy(extraData?: JsonMap): Promise<boolean>;
 
     save(extraData?: JsonMap): Promise<Model>;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weapnl/js-junction",
-  "version": "0.1.4",
+  "version": "0.3.0",
   "description": "This project allows you to easily consume API's built with Junction.",
   "main": "./src/index.js",
   "scripts": {

package/src/api.js

@@ -12,6 +12,7 @@ export default class Api {
         this.setHeader('X-Requested-With', 'XMLHttpRequest');
 
         this._requests = [];
+        this._chunkUploadSize = null;
 
         this.host('/').suffix('');
 
@@ -29,6 +30,20 @@ export default class Api {
         return this;
     }
 
+    /**
+     * Chunk file uploads into multiple requests when total size exceeds the given size.
+     * Useful when the API has a max upload limit, or to split large batches into smaller requests.
+     *
+     * @param {number} bytes Maximum total file size per request in bytes.
+     *
+     * @returns {this} The current instance.
+     */
+    chunkUploadsBySize (bytes) {
+        this._chunkUploadSize = bytes;
+
+        return this;
+    }
+
     /**
      * @param {string} suffix
      *

package/src/builder/model.js

@@ -202,7 +202,12 @@ export default class Model extends Request {
 
         this._response = await this._connection.post(
             this._queryString(),
-            { ...this._attributes.toJson(this), ...this._mediaCollections.toJson(this), ...extraData },
+            {
+                ...this._attributes.toJson(this),
+                ...this._mediaCollections.toJson(this),
+                ..._.merge(...this._customParameters),
+                ...extraData,
+            },
         );
 
         this._connection.removeRequest(this);
@@ -234,7 +239,12 @@ export default class Model extends Request {
 
         this._response = await this._connection.put(
             this._queryString(this._identifier),
-            { ...this._attributes.toJson(this), ...this._mediaCollections.toJson(this), ...extraData },
+            {
+                ...this._attributes.toJson(this),
+                ...this._mediaCollections.toJson(this),
+                ..._.merge(...this._customParameters),
+                ...extraData,
+            },
         );
 
         this._connection.removeRequest(this);
@@ -257,13 +267,19 @@ export default class Model extends Request {
     /**
      * Delete the current model.
      *
+     * @param {Object} [extraData] Extra data to send to the API
+     *
      * @returns {boolean} Whether the deletion was successful.
      */
-    async destroy () {
+    async destroy (extraData = {}) {
         this._connection.cancelRunning(this);
 
         this._response = await this._connection.delete(
             this._queryString(this._identifier),
+            {
+                ..._.merge(...this._customParameters),
+                ...extraData,
+            },
         );
 
         this._connection.removeRequest(this);
@@ -286,20 +302,69 @@ export default class Model extends Request {
      */
     async upload (files, collection) {
         this._media ??= {};
-        const filesArray = (Array.isArray(files) ? files : [files]).filter((value) => value !== null);
+        files = _.flatMapDeep(Array.isArray(files) ? files : [files]).filter((value) => value instanceof File);
 
-        if (filesArray.length === 0) {
+        if (files.length === 0) {
             this._media[collection] = {};
             return;
         }
 
-        const request = await this.storeFiles({
-            files: _.flatMapDeep(filesArray),
-        }, {}, '/media/upload');
+        const chunkSize = this._connection.getChunkUploadSize();
+
+        const chunks = chunkSize ? this._chunkFilesBySize(files, chunkSize) : [files];
+
+        let allResponseData = [];
+
+        for (const chunk of chunks) {
+            const request = await this.storeFiles({
+                files: chunk,
+            }, {}, '/media/upload');
+
+            if (request._response.data) {
+                allResponseData = allResponseData.concat(
+                    _.castArray(request._response.data),
+                );
+            }
+        }
+
+        this._media[collection] = allResponseData;
+
+        return allResponseData;
+    }
 
-        this._media[collection] = request._response.data;
+    /**
+     * Split files into chunks that don't exceed the given max size.
+     * A single file that exceeds the limit will still be sent as its own chunk.
+     *
+     * @param {File[]} files
+     * @param {number} maxSize Maximum total file size per chunk in bytes.
+     *
+     * @returns {File[][]} Array of file arrays (chunks).
+     * @private
+     */
+    _chunkFilesBySize (files, maxSize) {
+        const chunks = [];
+        let currentChunk = [];
+        let currentSize = 0;
+
+        for (const file of files) {
+            const fileSize = file.size || 0;
+
+            if (currentChunk.length > 0 && currentSize + fileSize > maxSize) {
+                chunks.push(currentChunk);
+                currentChunk = [];
+                currentSize = 0;
+            }
+
+            currentChunk.push(file);
+            currentSize += fileSize;
+        }
+
+        if (currentChunk.length > 0) {
+            chunks.push(currentChunk);
+        }
 
-        return request._response.data;
+        return chunks;
     }
 
     /**

package/src/connection.js

@@ -33,6 +33,10 @@ export default class Connection {
         return this._config;
     }
 
+    getChunkUploadSize () {
+        return this._api?._chunkUploadSize ?? null;
+    }
+
     setConfig (config) {
         this._config = config;
     }
@@ -49,12 +53,12 @@ export default class Connection {
         return this._execute(query, 'post', data);
     }
 
-    async put (query, params) {
-        return this._execute(query, 'put', params);
+    async put (query, data) {
+        return this._execute(query, 'put', data);
     }
 
-    async delete (query) {
-        return this._execute(query, 'delete');
+    async delete (query, data) {
+        return this._execute(query, 'delete', data);
     }
 
     async _execute (url, method, data) {

package/src/request.js

@@ -150,15 +150,18 @@ export default class Request {
     }
 
     /**
+     * @param {Object} data
+     *
      * @returns {this} The current instance.
      */
-    async delete () {
+    async delete (data = {}) {
         const url = this.url ?? this.constructor.endpoint;
 
         this._connection.cancelRunning(this);
 
         this._response = await this._connection.delete(
             url,
+            { ...data, ...this.bodyParameters },
         );
 
         this._connection.removeRequest(this);