@quatrain/worker 1.2.11 → 1.2.14-pr25.8334

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");
@@ -137,80 +137,66 @@ class FileSystem {
      */
     static async uploadFile(filename, meta, mime = 'video/mp4') {
         // try to get more file metadata
-        const info = await FileSystem.getInfo(filename);
+        let info = {};
+        try {
+            info = await FileSystem.getInfo(filename);
+        }
+        catch (err) {
+            Worker_1.Worker.warn(`Could not probe media info for ${filename}: ${err?.message || err}`);
+        }
         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
      */
     static getInfo = (file) => {
         if (file.endsWith('.mp4') || file.endsWith('.insv')) {
+            try {
+                const ffprobeStatic = require('ffprobe-static');
+                if (ffprobeStatic && ffprobeStatic.path) {
+                    ffmpeg.setFfprobePath(ffprobeStatic.path);
+                }
+            }
+            catch {
+                // ffprobe-static not present, fallback to system PATH
+            }
             return new Promise((resolve, reject) => ffmpeg.ffprobe(file, (err, metadata) => {
                 if (err) {
                     Worker_1.Worker.error(err);
-                    reject(err);
+                    return reject(err);
+                }
+                if (!metadata || !metadata.streams || !metadata.streams.length) {
+                    Worker_1.Worker.warn(`No streams found in ffprobe metadata for ${file}`);
+                    return resolve({});
+                }
+                const videoStream = metadata.streams.find((s) => s.codec_type === 'video') ||
+                    metadata.streams[0];
+                if (!videoStream) {
+                    return resolve({});
                 }
-                //   Worker.debug(`ffprobe getInfo: ${JSON.stringify(metadata)}`)
-                const { width, height, duration, bit_rate: bitrate, nb_frames: nbFramees, } = metadata.streams[0];
+                const { width, height, duration, bit_rate: bitrate, nb_frames: nbFramees, } = videoStream;
                 const nb_frames = Number.parseFloat(nbFramees);
                 const framerate = nb_frames / Number.parseFloat(duration);
                 resolve({

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/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.11",
+  "version": "1.2.14-pr25.8334",
   "description": "Container Worker helpers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -34,7 +34,7 @@
     "typescript": "^5.1.5"
   },
   "dependencies": {
-    "@quatrain/core": "^1.2.17",
+    "@quatrain/core": "^1.2.18",
     "@quatrain/queue": "^1.2.3",
     "@quatrain/storage": "^1.2.13",
     "axios": "^1.7.7",

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

@@ -111,79 +111,38 @@ export class FileSystem {
       mime = 'video/mp4'
    ): Promise<FileType> {
       // try to get more file metadata
-      const info = await FileSystem.getInfo(filename)
+      let info = {}
+      try {
+         info = await FileSystem.getInfo(filename)
+      } catch (err: any) {
+         Worker.warn(`Could not probe media info for ${filename}: ${(err as Error)?.message || err}`)
+      }
       meta = { ...meta, ...info }
       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
+      }
    }
 
    /**
@@ -191,22 +150,46 @@ export class FileSystem {
     */
    static getInfo = (file: string): Promise<any> => {
       if (file.endsWith('.mp4') || file.endsWith('.insv')) {
+         try {
+            const ffprobeStatic = require('ffprobe-static')
+            if (ffprobeStatic && ffprobeStatic.path) {
+               ffmpeg.setFfprobePath(ffprobeStatic.path)
+            }
+         } catch {
+            // ffprobe-static not present, fallback to system PATH
+         }
+
          return new Promise((resolve, reject) =>
             ffmpeg.ffprobe(file, (err: any, metadata: any) => {
                if (err) {
                   Worker.error(err)
-                  reject(err)
+                  return reject(err)
+               }
+
+               if (!metadata || !metadata.streams || !metadata.streams.length) {
+                  Worker.warn(`No streams found in ffprobe metadata for ${file}`)
+                  return resolve({})
                }
-               //   Worker.debug(`ffprobe getInfo: ${JSON.stringify(metadata)}`)
+
+               const videoStream =
+                  metadata.streams.find((s: any) => s.codec_type === 'video') ||
+                  metadata.streams[0]
+
+               if (!videoStream) {
+                  return resolve({})
+               }
+
                const {
                   width,
                   height,
                   duration,
                   bit_rate: bitrate,
                   nb_frames: nbFramees,
-               } = metadata.streams[0]
+               } = videoStream
+
                const nb_frames: number = Number.parseFloat(nbFramees as string)
                const framerate = nb_frames / Number.parseFloat(duration as string)
+
                resolve({
                   width,
                   height,

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}`)
       }
    }