@quatrain/worker 1.2.10 → 1.2.12

package/dist/FileSystem.js

@@ -37,7 +37,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileSystem = void 0;
-const node_fs_1 = __importStar(require("node:fs"));
+const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const axios_1 = __importDefault(require("axios"));
 const Worker_1 = require("./Worker");
@@ -141,63 +141,26 @@ class FileSystem {
         meta = { ...meta, ...info };
         Worker_1.Worker.info(`Uploading file ${filename} to ${meta.uploadUrl}`);
         const { size } = node_fs_1.default.statSync(filename);
-        if (size < 32 * 1024) {
-            return new Promise((resolve, reject) => {
-                (0, node_fetch_native_1.default)(meta.uploadUrl, {
-                    method: 'PUT',
-                    mode: 'cors',
-                    duplex: 'half',
-                    body: (0, node_fs_1.readFileSync)(filename),
-                    headers: {
-                        'Content-Type': meta.contentType || mime,
-                        'Content-length': String(size),
-                    },
-                })
-                    .then(() => resolve({ ...meta, size, uploadUrl: undefined }))
-                    .catch((err) => {
-                    Worker_1.Worker.error(`An error occured while uploading ${filename}: ${err.message}`);
-                    reject(err);
-                });
+        try {
+            Worker_1.Worker.info(`Uploading file ${filename} with size ${size} bytes`);
+            const fileBuffer = node_fs_1.default.readFileSync(filename);
+            const res = await (0, node_fetch_native_1.default)(meta.uploadUrl, {
+                method: 'PUT',
+                body: fileBuffer,
+                headers: {
+                    'Content-Type': meta.contentType || mime,
+                },
             });
-        }
-        return new Promise((resolve, reject) => {
-            try {
-                let done = 0; // total bytes uploaded
-                let prev = 0; // latest value of done stored when % done was displayed
-                const { size } = node_fs_1.default.statSync(filename);
-                const readStream = node_fs_1.default.createReadStream(filename);
-                const sizeMB = (size / (1024 * 1024)).toFixed(2);
-                readStream.on('data', (data) => {
-                    done += data.length;
-                    if (done - prev >= size / 20) {
-                        // only display message when 5% more has been uploaded
-                        Worker_1.Worker.info(`${((done / size) * 100).toFixed(2)}% - ${(done /
-                            (1024 * 1024)).toFixed(2)}MB / ${sizeMB}MB`);
-                        prev = done;
-                    }
-                });
-                Worker_1.Worker.info(`Uploading file ${filename} with size ${size} bytes`);
-                (0, node_fetch_native_1.default)(meta.uploadUrl, {
-                    method: 'PUT',
-                    mode: 'cors',
-                    duplex: 'half',
-                    body: readStream,
-                    headers: {
-                        'Content-Type': meta.contentType || mime,
-                        'Content-length': String(size),
-                    },
-                })
-                    .then(() => resolve({ ...meta, size, uploadUrl: undefined }))
-                    .catch((err) => {
-                    Worker_1.Worker.error(`An error occured while uploading ${filename}: ${err.message}`);
-                    reject(err);
-                });
+            if (res && res.ok === false) {
+                const errorText = typeof res.text === 'function' ? await res.text().catch(() => '') : '';
+                throw new Error(`HTTP upload failed with status ${res.status || 'unknown'}: ${errorText}`);
             }
-            catch (err) {
-                Worker_1.Worker.error(err);
-                reject(err);
-            }
-        });
+            return { ...meta, size, uploadUrl: undefined };
+        }
+        catch (err) {
+            Worker_1.Worker.error(`An error occured while uploading ${filename}: ${err.message}`);
+            throw err;
+        }
     }
     /**
      * Return meta data on given file

package/dist/FileSystem.test.js

@@ -94,6 +94,12 @@ describe('FileSystem Utilities (Worker)', () => {
         jest.spyOn(node_fs_1.default, 'createReadStream').mockImplementation(() => {
             return node_stream_1.Readable.from(Buffer.alloc(35 * 1024));
         });
+        jest.spyOn(node_fs_1.default, 'readFileSync').mockImplementation((p) => {
+            if (typeof p === 'string' && (p.endsWith('test.txt') || p.endsWith('small.mp4') || p.endsWith('large.mp4') || p.endsWith('large-fail.mp4') || p.endsWith('small-fail.mp4') || p.endsWith('large-sync-fail.mp4'))) {
+                return Buffer.alloc(35 * 1024);
+            }
+            return (jest.requireActual('node:fs').readFileSync)(p);
+        });
         jest.spyOn(node_fs_1.default, 'existsSync').mockImplementation((p) => {
             if (typeof p === 'string' && (p.endsWith('test.txt') || p.endsWith('small.mp4') || p.endsWith('large.mp4') || p.endsWith('large-fail.mp4') || p.endsWith('small-fail.mp4') || p.endsWith('large-sync-fail.mp4'))) {
                 return true;
@@ -330,8 +336,8 @@ describe('FileSystem Utilities (Worker)', () => {
             ffmpeg.ffprobe.mockImplementation((file, callback) => {
                 callback(null, mockMetadata);
             });
-            // Make createReadStream throw a synchronous error
-            jest.spyOn(node_fs_1.default, 'createReadStream').mockImplementationOnce(() => {
+            // Make readFileSync throw a synchronous error
+            jest.spyOn(node_fs_1.default, 'readFileSync').mockImplementationOnce(() => {
                 throw new Error('Sync stream error');
             });
             const meta = {

package/dist/Helpers.d.ts

@@ -2,8 +2,9 @@
  * General utility class providing common static helpers for workers.
  */
 export declare class Helpers {
+    private static _ffmpegPathPromise;
     /** Default absolute path to the system's FFmpeg binary. */
-    static FFMPEG: Promise<string>;
+    static get FFMPEG(): Promise<string>;
     /**
      * Generate a thubnail from a video file at given frame position
      * @param videoPath path to video file

package/dist/Helpers.js

@@ -6,8 +6,14 @@ const Worker_1 = require("./Worker");
  * General utility class providing common static helpers for workers.
  */
 class Helpers {
+    static _ffmpegPathPromise = null;
     /** Default absolute path to the system's FFmpeg binary. */
-    static FFMPEG = Worker_1.Worker.getSystemCommandPath('ffmpeg');
+    static get FFMPEG() {
+        if (!this._ffmpegPathPromise) {
+            this._ffmpegPathPromise = Worker_1.Worker.getSystemCommandPath('ffmpeg').catch(() => 'ffmpeg');
+        }
+        return this._ffmpegPathPromise;
+    }
     /**
      * Generate a thubnail from a video file at given frame position
      * @param videoPath path to video file

package/dist/Worker.d.ts

@@ -25,7 +25,7 @@ export declare class Worker extends Core {
      * @param ts timestamp
      * @returns boolean
      */
-    static pushEvent(event: string, data?: {}, ts?: number): false | undefined;
+    static pushEvent(event: string, data?: {}, ts?: number): void;
     /**
      * Async Push an event to the backend endpoint, if available
      * @param event string
@@ -33,7 +33,7 @@ export declare class Worker extends Core {
      * @param ts timestamp
      * @returns boolean
      */
-    static pushEventAsync(event: string, data?: {}, ts?: number): Promise<boolean | undefined>;
+    static pushEventAsync(event: string, data?: {}, ts?: number): Promise<true | undefined>;
     /**
      * Global handling function to process received messages
      * @param messageHandler function

package/dist/Worker.js

@@ -59,8 +59,8 @@ class Worker extends core_1.Core {
      */
     static pushEvent(event, data = {}, ts = 0) {
         if (!this.endpoint) {
-            Worker.warn(`Events endpoint is not set, can't send update!`);
-            return false;
+            Worker.error(`Events endpoint is mandatory but missing! Cannot report job status to source.`);
+            throw new Error(`Events endpoint is mandatory but missing`);
         }
         ts = ts === Date.now() ? Date.now() + 1 : Date.now();
         const payload = {
@@ -79,8 +79,7 @@ class Worker extends core_1.Core {
             return true;
         })
             .catch((err) => {
-            Worker.error(`Failed to push event to backend: ${err}`);
-            return false;
+            Worker.error(`Failed to push event to backend: ${err.message}`);
         });
     }
     /**
@@ -92,8 +91,8 @@ class Worker extends core_1.Core {
      */
     static async pushEventAsync(event, data = {}, ts = 0) {
         if (!this.endpoint) {
-            Worker.warn(`Events endpoint is not set, can't send update!`);
-            return false;
+            Worker.error(`Events endpoint is mandatory but missing! Cannot report job status to source.`);
+            throw new Error(`Events endpoint is mandatory but missing`);
         }
         try {
             ts = ts === Date.now() ? Date.now() + 1 : Date.now();
@@ -105,14 +104,14 @@ class Worker extends core_1.Core {
                 ts,
             };
             const res = await axios_1.default.patch(Worker.endpoint, payload);
-            if (res.statusText === 'OK') {
+            if (res.statusText === 'OK' || res.status === 200) {
                 Worker.info(`Event pushed to backend: ${res.statusText}`);
                 return true;
             }
         }
         catch (err) {
-            Worker.error(`Failed to push event to backend: ${err}`);
-            return false;
+            Worker.error(`Failed to push event to backend: ${err.message}`);
+            throw new Error(`Failed to push event to backend: ${err.message}`);
         }
     }
     /**

package/dist/Worker.test.js

@@ -40,9 +40,8 @@ describe('Worker', () => {
         });
     });
     describe('pushEvent', () => {
-        it('should return false when endpoint is not set', () => {
-            const result = Worker_1.Worker.pushEvent('test-event');
-            expect(result).toBe(false);
+        it('should throw error when endpoint is not set', () => {
+            expect(() => Worker_1.Worker.pushEvent('test-event')).toThrow('Events endpoint is mandatory but missing');
             expect(mockedAxios.patch).not.toHaveBeenCalled();
         });
         it('should send event when endpoint is set', () => {
@@ -110,9 +109,8 @@ describe('Worker', () => {
         });
     });
     describe('pushEventAsync', () => {
-        it('should return false when endpoint is not set', async () => {
-            const result = await Worker_1.Worker.pushEventAsync('test-event');
-            expect(result).toBe(false);
+        it('should throw error when endpoint is not set', async () => {
+            await expect(Worker_1.Worker.pushEventAsync('test-event')).rejects.toThrow('Events endpoint is mandatory but missing');
             expect(mockedAxios.patch).not.toHaveBeenCalled();
         });
         it('should send event and return true on success', async () => {
@@ -130,11 +128,10 @@ describe('Worker', () => {
                 foo: 'bar',
             }));
         });
-        it('should return false on axios error', async () => {
+        it('should throw error on axios error', async () => {
             Worker_1.Worker.endpoint = 'https://api.example.com/events';
             mockedAxios.patch.mockRejectedValue(new Error('Network error'));
-            const result = await Worker_1.Worker.pushEventAsync('test-event');
-            expect(result).toBe(false);
+            await expect(Worker_1.Worker.pushEventAsync('test-event')).rejects.toThrow('Failed to push event to backend: Network error');
         });
         it('should handle non-OK status response', async () => {
             Worker_1.Worker.endpoint = 'https://api.example.com/events';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quatrain/worker",
-  "version": "1.2.10",
+  "version": "1.2.12",
   "description": "Container Worker helpers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/FileSystem.test.ts

@@ -63,6 +63,13 @@ describe('FileSystem Utilities (Worker)', () => {
          return Readable.from(Buffer.alloc(35 * 1024)) as any
       })
 
+      jest.spyOn(fs, 'readFileSync').mockImplementation((p) => {
+         if (typeof p === 'string' && (p.endsWith('test.txt') || p.endsWith('small.mp4') || p.endsWith('large.mp4') || p.endsWith('large-fail.mp4') || p.endsWith('small-fail.mp4') || p.endsWith('large-sync-fail.mp4'))) {
+            return Buffer.alloc(35 * 1024)
+         }
+         return (jest.requireActual('node:fs').readFileSync)(p)
+      })
+
       jest.spyOn(fs, 'existsSync').mockImplementation((p) => {
          if (typeof p === 'string' && (p.endsWith('test.txt') || p.endsWith('small.mp4') || p.endsWith('large.mp4') || p.endsWith('large-fail.mp4') || p.endsWith('small-fail.mp4') || p.endsWith('large-sync-fail.mp4'))) {
             return true
@@ -346,8 +353,8 @@ describe('FileSystem Utilities (Worker)', () => {
             callback(null, mockMetadata)
          });
 
-         // Make createReadStream throw a synchronous error
-         jest.spyOn(fs, 'createReadStream').mockImplementationOnce(() => {
+         // Make readFileSync throw a synchronous error
+         jest.spyOn(fs, 'readFileSync').mockImplementationOnce(() => {
             throw new Error('Sync stream error')
          })
 

package/src/FileSystem.ts

@@ -116,74 +116,28 @@ export class FileSystem {
       Worker.info(`Uploading file ${filename} to ${meta.uploadUrl}`)
       const { size } = fs.statSync(filename)
 
-      if (size < 32 * 1024) {
-         return new Promise((resolve, reject) => {
-            fetch(meta.uploadUrl, {
-               method: 'PUT',
-               mode: 'cors',
-               duplex: 'half',
-               body: readFileSync(filename),
-               headers: {
-                  'Content-Type': meta.contentType || mime,
-                  'Content-length': String(size),
-               },
-            } as any)
-               .then(() => resolve({ ...meta, size, uploadUrl: undefined }))
-               .catch((err) => {
-                  Worker.error(
-                     `An error occured while uploading ${filename}: ${err.message}`
-                  )
-                  reject(err)
-               })
+      try {
+         Worker.info(`Uploading file ${filename} with size ${size} bytes`)
+         const fileBuffer = fs.readFileSync(filename)
+
+         const res = await fetch(meta.uploadUrl, {
+            method: 'PUT',
+            body: fileBuffer,
+            headers: {
+               'Content-Type': meta.contentType || mime,
+            },
          })
-      }
-
-      return new Promise((resolve, reject) => {
-         try {
-            let done = 0 // total bytes uploaded
-            let prev = 0 // latest value of done stored when % done was displayed
-            const { size } = fs.statSync(filename)
-            const readStream = fs.createReadStream(filename)
 
-            const sizeMB = (size / (1024 * 1024)).toFixed(2)
-
-            readStream.on('data', (data) => {
-               done += data.length
-               if (done - prev >= size / 20) {
-                  // only display message when 5% more has been uploaded
-                  Worker.info(
-                     `${((done / size) * 100).toFixed(2)}% - ${(
-                        done /
-                        (1024 * 1024)
-                     ).toFixed(2)}MB / ${sizeMB}MB`
-                  )
-                  prev = done
-               }
-            })
-
-            Worker.info(`Uploading file ${filename} with size ${size} bytes`)
-            fetch(meta.uploadUrl, {
-               method: 'PUT',
-               mode: 'cors',
-               duplex: 'half',
-               body: readStream,
-               headers: {
-                  'Content-Type': meta.contentType || mime,
-                  'Content-length': String(size),
-               },
-            } as any)
-               .then(() => resolve({ ...meta, size, uploadUrl: undefined }))
-               .catch((err) => {
-                  Worker.error(
-                     `An error occured while uploading ${filename}: ${err.message}`
-                  )
-                  reject(err)
-               })
-         } catch (err) {
-            Worker.error(err)
-            reject(err)
+         if (res && res.ok === false) {
+            const errorText = typeof res.text === 'function' ? await res.text().catch(() => '') : ''
+            throw new Error(`HTTP upload failed with status ${res.status || 'unknown'}: ${errorText}`)
          }
-      })
+
+         return { ...meta, size, uploadUrl: undefined }
+      } catch (err: any) {
+         Worker.error(`An error occured while uploading ${filename}: ${err.message}`)
+         throw err
+      }
    }
 
    /**

package/src/Helpers.ts

@@ -5,8 +5,15 @@ import path from 'node:path'
  * General utility class providing common static helpers for workers.
  */
 export class Helpers {
+   private static _ffmpegPathPromise: Promise<string> | null = null
+
    /** Default absolute path to the system's FFmpeg binary. */
-   static FFMPEG = Worker.getSystemCommandPath('ffmpeg')
+   static get FFMPEG(): Promise<string> {
+      if (!this._ffmpegPathPromise) {
+         this._ffmpegPathPromise = Worker.getSystemCommandPath('ffmpeg').catch(() => 'ffmpeg')
+      }
+      return this._ffmpegPathPromise
+   }
 
    /**
     * Generate a thubnail from a video file at given frame position

package/src/Worker.test.ts

@@ -42,9 +42,8 @@ describe('Worker', () => {
    })
 
    describe('pushEvent', () => {
-      it('should return false when endpoint is not set', () => {
-         const result = Worker.pushEvent('test-event')
-         expect(result).toBe(false)
+      it('should throw error when endpoint is not set', () => {
+         expect(() => Worker.pushEvent('test-event')).toThrow('Events endpoint is mandatory but missing')
          expect(mockedAxios.patch).not.toHaveBeenCalled()
       })
 
@@ -145,9 +144,8 @@ describe('Worker', () => {
    })
 
    describe('pushEventAsync', () => {
-      it('should return false when endpoint is not set', async () => {
-         const result = await Worker.pushEventAsync('test-event')
-         expect(result).toBe(false)
+      it('should throw error when endpoint is not set', async () => {
+         await expect(Worker.pushEventAsync('test-event')).rejects.toThrow('Events endpoint is mandatory but missing')
          expect(mockedAxios.patch).not.toHaveBeenCalled()
       })
 
@@ -173,14 +171,12 @@ describe('Worker', () => {
          )
       })
 
-      it('should return false on axios error', async () => {
+      it('should throw error on axios error', async () => {
          Worker.endpoint = 'https://api.example.com/events'
 
          mockedAxios.patch.mockRejectedValue(new Error('Network error'))
 
-         const result = await Worker.pushEventAsync('test-event')
-
-         expect(result).toBe(false)
+         await expect(Worker.pushEventAsync('test-event')).rejects.toThrow('Failed to push event to backend: Network error')
       })
 
       it('should handle non-OK status response', async () => {

package/src/Worker.ts

@@ -66,8 +66,8 @@ export class Worker extends Core {
     */
    static pushEvent(event: string, data = {}, ts = 0) {
       if (!this.endpoint) {
-         Worker.warn(`Events endpoint is not set, can't send update!`)
-         return false
+         Worker.error(`Events endpoint is mandatory but missing! Cannot report job status to source.`)
+         throw new Error(`Events endpoint is mandatory but missing`)
       }
 
       ts = ts === Date.now() ? Date.now() + 1 : Date.now()
@@ -89,8 +89,7 @@ export class Worker extends Core {
             return true
          })
          .catch((err) => {
-            Worker.error(`Failed to push event to backend: ${err}`)
-            return false
+            Worker.error(`Failed to push event to backend: ${err.message}`)
          })
    }
 
@@ -103,8 +102,8 @@ export class Worker extends Core {
     */
    static async pushEventAsync(event: string, data = {}, ts = 0) {
       if (!this.endpoint) {
-         Worker.warn(`Events endpoint is not set, can't send update!`)
-         return false
+         Worker.error(`Events endpoint is mandatory but missing! Cannot report job status to source.`)
+         throw new Error(`Events endpoint is mandatory but missing`)
       }
 
       try {
@@ -119,13 +118,13 @@ export class Worker extends Core {
 
          const res = await axios.patch(Worker.endpoint, payload)
 
-         if (res.statusText === 'OK') {
+         if (res.statusText === 'OK' || res.status === 200) {
             Worker.info(`Event pushed to backend: ${res.statusText}`)
             return true
          }
-      } catch (err) {
-         Worker.error(`Failed to push event to backend: ${err}`)
-         return false
+      } catch (err: any) {
+         Worker.error(`Failed to push event to backend: ${err.message}`)
+         throw new Error(`Failed to push event to backend: ${err.message}`)
       }
    }