@quatrain/worker 1.1.44 → 1.1.45

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@quatrain/worker",
-   "version": "1.1.44",
+   "version": "1.1.45",
    "description": "Container Worker helpers",
    "main": "lib/index.js",
    "types": "lib/index.d.ts",
@@ -29,7 +29,7 @@
    },
    "dependencies": {
       "@quatrain/core": "^1.1.43",
-      "@quatrain/queue": "^1.1.21",
+      "@quatrain/queue": "^1.1.22",
       "@quatrain/storage": "^1.1.24",
       "axios": "^1.7.7",
       "fluent-ffmpeg": "^2.1.2",

package/lib/FileSystem.d.ts

@@ -1,20 +0,0 @@
-import { FileType } from '@quatrain/storage';
-export declare class FileSystem {
-    static prepare(folder: string): void;
-    static makeFolder(folder: string): void;
-    static removeFolder(folder: string, recursively?: boolean): void;
-    static downloadFile(url: string, filepath: string): Promise<unknown>;
-    static safeString(name: string): string;
-    /**
-     * Upload file to public URL and return meta data
-     * @param filename string
-     * @param meta
-     * @param mime
-     * @returns Promise
-     */
-    static uploadFile(filename: string, meta: FileType, mime?: string): Promise<FileType>;
-    /**
-     * Return meta data on given file
-     */
-    static getInfo: (file: string) => Promise<any>;
-}

package/lib/FileSystem.js

@@ -1,182 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileSystem = void 0;
-const node_fs_1 = __importStar(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const axios_1 = __importDefault(require("axios"));
-const Worker_1 = require("./Worker");
-const node_fetch_native_1 = __importDefault(require("node-fetch-native"));
-const ffmpeg = __importStar(require("fluent-ffmpeg"));
-class FileSystem {
-    static prepare(folder) {
-        Worker_1.Worker.debug(`Setting up process folder ${folder}`);
-        this.removeFolder(folder);
-        node_fs_1.default.mkdirSync(folder);
-        node_fs_1.default.mkdirSync(folder + node_path_1.default.sep + 'images');
-        node_fs_1.default.mkdirSync(folder + node_path_1.default.sep + 'vecto');
-    }
-    static makeFolder(folder) {
-        node_fs_1.default.mkdirSync(folder);
-    }
-    static removeFolder(folder, recursively = true) {
-        if (node_fs_1.default.existsSync(folder)) {
-            node_fs_1.default.readdirSync(folder).forEach((element) => {
-                const item = node_path_1.default.join(folder, element);
-                if (node_fs_1.default.lstatSync(item).isDirectory()) {
-                    if (recursively !== true) {
-                        throw new Error(`Folder contains folder`);
-                    }
-                    this.removeFolder(item);
-                }
-                else {
-                    node_fs_1.default.unlinkSync(item);
-                }
-            });
-            node_fs_1.default.rmdirSync(folder);
-        }
-    }
-    static async downloadFile(url, filepath) {
-        try {
-            Worker_1.Worker.debug(`Downloading file at ${url} to ${filepath}`);
-            const writer = node_fs_1.default.createWriteStream(filepath);
-            const response = await axios_1.default.get(url, {
-                responseType: 'stream',
-            });
-            response.data.pipe(writer);
-            return new Promise((resolve, reject) => {
-                writer.on('finish', resolve);
-                writer.on('error', reject);
-            });
-        }
-        catch (err) {
-            Worker_1.Worker.error(`Download error: ${err.message}`);
-            throw err;
-        }
-    }
-    static safeString(name) {
-        return name.replace(/\s+/g, '_');
-    }
-    /**
-     * Upload file to public URL and return meta data
-     * @param filename string
-     * @param meta
-     * @param mime
-     * @returns Promise
-     */
-    static uploadFile(filename, meta, mime = 'video/mp4') {
-        // try to get more file metadata
-        meta = { ...meta, ...FileSystem.getInfo(filename) };
-        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);
-                });
-            });
-        }
-        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);
-                });
-            }
-            catch (err) {
-                Worker_1.Worker.error(err);
-                reject(err);
-            }
-        });
-    }
-    /**
-     * Return meta data on given file
-     */
-    static getInfo = (file) => {
-        if (file.endsWith('.mp4') || file.endsWith('.insv')) {
-            return new Promise((resolve, reject) => ffmpeg.ffprobe(file, (err, metadata) => {
-                if (err) {
-                    Worker_1.Worker.error(err);
-                    reject(err);
-                }
-                //   Worker.debug(`ffprobe getInfo: ${JSON.stringify(metadata)}`)
-                const { width, height, duration, bit_rate: bitrate, nb_frames: nbFramees, } = metadata.streams[0];
-                const nb_frames = parseFloat(nbFramees);
-                const framerate = nb_frames / parseFloat(duration);
-                resolve({
-                    width,
-                    height,
-                    framerate: parseInt(framerate.toFixed(0)),
-                    duration: parseInt(duration),
-                    bitrate,
-                });
-            }));
-        }
-        // Handle other cases silently
-        return new Promise((resolve) => resolve({}));
-    };
-}
-exports.FileSystem = FileSystem;

package/lib/Handler.d.ts

@@ -1 +0,0 @@
-export declare const handler: (messageHandler: Function, config: any, adapters: any) => Promise<void>;

package/lib/Handler.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handler = void 0;
-const Worker_1 = require("./Worker");
-const handler = async (messageHandler, config, adapters) => {
-    try {
-        Worker_1.Worker.info(`Worker version ${require('../package.json').version} started in ${config.MQ_MODE} mode`);
-        switch (config.MQ_MODE) {
-            case 'queue':
-                const { Queue } = require('@quatrain/queue');
-                Queue.addQueue(adapters.queue, 'default', true);
-                Queue.info(`Connecting to amqp://${config.MQ_HOST}:${config.MQ_PORT}`);
-                Queue.getQueue().listen(config.MQ_TOPIC, messageHandler, {
-                    concurrency: config.MQ_CONCURRENCY,
-                    gpu: config.MQ_GPU,
-                });
-                break;
-            case 'cli':
-            case 'test':
-                Worker_1.Worker.warn(`Message received from CLI.`);
-                const json = config.MQ_MODE === 'test'
-                    ? require('../test.json')
-                    : process.env.JSON;
-                if (!json) {
-                    throw new Error(`CLI call with missing environment variables`);
-                }
-                await messageHandler(json);
-                break;
-            default:
-                Worker_1.Worker.error(`Unknown mode option: '${config.MQ_MODE}'`);
-                process.exit(1);
-        }
-    }
-    catch (error) {
-        Worker_1.Worker.error(error.message);
-        process.exit(1);
-    }
-};
-exports.handler = handler;

package/lib/Helpers.d.ts

@@ -1,11 +0,0 @@
-export declare class Helpers {
-    static FFMPEG: string;
-    /**
-     * Generate a thubnail from a video file at given frame position
-     * @param videoPath path to video file
-     * @param frame frame to extract thumbnail from
-     * @param width width of thumbnail (4/3 ratio)
-     * @returns
-     */
-    static generateVideoThumbnail: (videoPath: string, outputPath: string, frame?: number, width?: number) => Promise<any>;
-}

package/lib/Helpers.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Helpers = void 0;
-const Worker_1 = require("./Worker");
-class Helpers {
-    static FFMPEG = '/usr/bin/ffmpeg';
-    /**
-     * Generate a thubnail from a video file at given frame position
-     * @param videoPath path to video file
-     * @param frame frame to extract thumbnail from
-     * @param width width of thumbnail (4/3 ratio)
-     * @returns
-     */
-    static generateVideoThumbnail = async (videoPath, outputPath, frame = 0, width = 320) => {
-        const resolution = `${width}x${Math.ceil(width * 0.75)}`;
-        const ffmpegParams = [
-            '-i',
-            videoPath,
-            '-vframes',
-            '1',
-            '-vf',
-            String.raw `select=gte(n\,${frame})`,
-            '-s',
-            resolution,
-            '-ss',
-            '1',
-            outputPath,
-            '-y',
-        ];
-        Worker_1.Worker.info(`Generating Thumbnail : ${outputPath}`);
-        return await Worker_1.Worker.execPromise(Helpers.FFMPEG, ffmpegParams);
-    };
-}
-exports.Helpers = Helpers;

package/lib/Worker.d.ts

@@ -1,37 +0,0 @@
-import { Core } from '@quatrain/core';
-import { HandlerParameters } from './types/HandlerParameters';
-export declare class Worker extends Core {
-    static endpoint: string;
-    static readonly logger: any;
-    /**
-     * Execute an external command in a promise
-     * @see https://stackoverflow.com/questions/46289682/how-to-wait-for-child-process-spawn-execution-with-async-await
-     * @see https://dzone.com/articles/understanding-execfile-spawn-exec-and-fork-in-node
-     * @param string command
-     * @param array args
-     * @return Promise
-     */
-    static readonly execPromise: (command: string, args?: any[], cwd?: string) => Promise<any>;
-    /**
-     * Push an event to the backend endpoint, if available
-     * @param event string
-     * @param data
-     * @param ts timestamp
-     * @returns boolean
-     */
-    static pushEvent(event: string, data?: {}, ts?: number): false | undefined;
-    /**
-     * Async Push an event to the backend endpoint, if available
-     * @param event string
-     * @param data
-     * @param ts timestamp
-     * @returns boolean
-     */
-    static pushEventAsync(event: string, data?: {}, ts?: number): Promise<boolean | undefined>;
-    /**
-     * Global handling function to process received messages
-     * @param messageHandler function
-     * @param config object
-     */
-    static readonly handler: (messageHandler: Function, config: HandlerParameters) => Promise<void>;
-}

package/lib/Worker.js

@@ -1,151 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Worker = void 0;
-const core_1 = require("@quatrain/core");
-const os_1 = __importDefault(require("os"));
-const axios_1 = __importDefault(require("axios"));
-const child_process_1 = require("child_process");
-class Worker extends core_1.Core {
-    static endpoint = '';
-    static logger = this.addLogger('Worker');
-    /**
-     * Execute an external command in a promise
-     * @see https://stackoverflow.com/questions/46289682/how-to-wait-for-child-process-spawn-execution-with-async-await
-     * @see https://dzone.com/articles/understanding-execfile-spawn-exec-and-fork-in-node
-     * @param string command
-     * @param array args
-     * @return Promise
-     */
-    static execPromise = (command, args = [], cwd = process.cwd()) => {
-        try {
-            Worker.info(`Executing command ${command} in ${cwd} with arguments:`);
-            args.forEach((arg) => console.log(`\t${arg}`));
-            return new Promise((resolve, reject) => {
-                const child = (0, child_process_1.spawn)(command, args, { cwd });
-                child.stdout.on('data', (data) => Worker.debug(data.toString()));
-                child.stderr.on('data', (data) => Worker.debug(data.toString()));
-                child.on('close', (code) => {
-                    if (code !== 0) {
-                        Worker.error(`Command execution failed with code: ${code}`);
-                        reject(new Error(`Process failed and returned code: ${code}`));
-                    }
-                    else {
-                        Worker.info(`Command execution completed with code: ${code}`);
-                        resolve(undefined);
-                    }
-                });
-            });
-        }
-        catch (err) {
-            Worker.error(err.message);
-            throw err;
-        }
-    };
-    /**
-     * Push an event to the backend endpoint, if available
-     * @param event string
-     * @param data
-     * @param ts timestamp
-     * @returns boolean
-     */
-    static pushEvent(event, data = {}, ts = 0) {
-        if (!this.endpoint) {
-            Worker.warn(`Events endpoint is not set, can't send update!`);
-            return false;
-        }
-        ts = ts === Date.now() ? Date.now() + 1 : Date.now();
-        const payload = {
-            event,
-            worker: `Container ${os_1.default.hostname}`,
-            os: `${os_1.default.type} ${os_1.default.release} (${os_1.default.platform} ${os_1.default.arch})`,
-            ...data,
-            ts,
-        };
-        Worker.debug('event payload', payload);
-        axios_1.default
-            .patch(Worker.endpoint, payload)
-            .then((res) => {
-            Worker.info(`Event pushed to backend: ${res.statusText}`);
-            Worker.info(res.data);
-            return true;
-        })
-            .catch((err) => {
-            Worker.error(`Failed to push event to backend: ${err}`);
-            return false;
-        });
-    }
-    /**
-     * Async Push an event to the backend endpoint, if available
-     * @param event string
-     * @param data
-     * @param ts timestamp
-     * @returns boolean
-     */
-    static async pushEventAsync(event, data = {}, ts = 0) {
-        if (!this.endpoint) {
-            Worker.warn(`Events endpoint is not set, can't send update!`);
-            return false;
-        }
-        try {
-            ts = ts === Date.now() ? Date.now() + 1 : Date.now();
-            const payload = {
-                event,
-                worker: `Container ${os_1.default.hostname}`,
-                os: `${os_1.default.type} ${os_1.default.release} (${os_1.default.platform} ${os_1.default.arch})`,
-                ...data,
-                ts,
-            };
-            const res = await axios_1.default.patch(Worker.endpoint, payload);
-            if (res.statusText === 'OK') {
-                Worker.info(`Event pushed to backend: ${res.statusText}`);
-                return true;
-            }
-        }
-        catch (err) {
-            Worker.error(`Failed to push event to backend: ${err}`);
-            return false;
-        }
-    }
-    /**
-     * Global handling function to process received messages
-     * @param messageHandler function
-     * @param config object
-     */
-    static handler = async (messageHandler, config) => {
-        try {
-            switch (config.mode) {
-                case 'queue':
-                    const { Queue } = require('@quatrain/queue');
-                    Queue.addQueue(config.queueAdapter, 'default', true);
-                    Queue.getQueue().listen(config.topic, messageHandler, {
-                        concurrency: config.concurrency,
-                        gpu: config.gpu,
-                    });
-                    Queue.info(`Connected and listening to ${config.topic}, ready to receive messages.`);
-                    break;
-                case 'cli':
-                case 'test':
-                    Worker.warn(`Message received from CLI.`);
-                    const json = config.mode === 'test'
-                        ? require('../test.json')
-                        : process.env.JSON;
-                    if (!json) {
-                        throw new Error(`CLI call with missing environment variables`);
-                    }
-                    await messageHandler(json);
-                    break;
-                default:
-                    Worker.error(`Unknown mode option: '${config.mode}'`);
-                    process.exit(1);
-            }
-        }
-        catch (error) {
-            Worker.error(error.message);
-            process.exit(1);
-        }
-    };
-}
-exports.Worker = Worker;

package/lib/Worker.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/Worker.test.js

@@ -1,219 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const Worker_1 = require("./Worker");
-const axios_1 = __importDefault(require("axios"));
-const child_process_1 = require("child_process");
-// Mock dependencies
-jest.mock('axios');
-jest.mock('child_process');
-const mockedAxios = axios_1.default;
-const mockedSpawn = child_process_1.spawn;
-describe('Worker', () => {
-    beforeEach(() => {
-        // Clear all mocks before each test
-        jest.clearAllMocks();
-        // Reset Worker.endpoint
-        Worker_1.Worker.endpoint = '';
-    });
-    describe('endpoint property', () => {
-        it('should have an empty endpoint by default', () => {
-            expect(Worker_1.Worker.endpoint).toBe('');
-        });
-        it('should allow setting the endpoint', () => {
-            Worker_1.Worker.endpoint = 'https://api.example.com/events';
-            expect(Worker_1.Worker.endpoint).toBe('https://api.example.com/events');
-        });
-    });
-    describe('pushEvent', () => {
-        it('should return false when endpoint is not set', () => {
-            const result = Worker_1.Worker.pushEvent('test-event');
-            expect(result).toBe(false);
-            expect(mockedAxios.patch).not.toHaveBeenCalled();
-        });
-        it('should send event when endpoint is set', () => {
-            Worker_1.Worker.endpoint = 'https://api.example.com/events';
-            mockedAxios.patch.mockResolvedValue({
-                statusText: 'OK',
-                data: { success: true },
-            });
-            Worker_1.Worker.pushEvent('test-event', { foo: 'bar' });
-            expect(mockedAxios.patch).toHaveBeenCalledWith('https://api.example.com/events', expect.objectContaining({
-                event: 'test-event',
-                foo: 'bar',
-            }));
-        });
-        it('should include custom timestamp in payload', () => {
-            Worker_1.Worker.endpoint = 'https://api.example.com/events';
-            const customTs = 1234567890;
-            mockedAxios.patch.mockResolvedValue({
-                statusText: 'OK',
-                data: { success: true },
-            });
-            Worker_1.Worker.pushEvent('test-event', {}, customTs);
-            expect(mockedAxios.patch).toHaveBeenCalledWith('https://api.example.com/events', expect.objectContaining({
-                event: 'test-event',
-                ts: expect.any(Number),
-            }));
-        });
-        it('should include additional data in payload', () => {
-            Worker_1.Worker.endpoint = 'https://api.example.com/events';
-            mockedAxios.patch.mockResolvedValue({
-                statusText: 'OK',
-                data: { success: true },
-            });
-            const additionalData = {
-                userId: '123',
-                action: 'upload',
-                metadata: { size: 1024 },
-            };
-            Worker_1.Worker.pushEvent('custom-event', additionalData);
-            expect(mockedAxios.patch).toHaveBeenCalledWith('https://api.example.com/events', expect.objectContaining({
-                event: 'custom-event',
-                userId: '123',
-                action: 'upload',
-                metadata: { size: 1024 },
-            }));
-        });
-    });
-    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);
-            expect(mockedAxios.patch).not.toHaveBeenCalled();
-        });
-        it('should send event and return true on success', async () => {
-            Worker_1.Worker.endpoint = 'https://api.example.com/events';
-            mockedAxios.patch.mockResolvedValue({
-                statusText: 'OK',
-                data: { success: true },
-            });
-            const result = await Worker_1.Worker.pushEventAsync('test-event', {
-                foo: 'bar',
-            });
-            expect(result).toBe(true);
-            expect(mockedAxios.patch).toHaveBeenCalledWith('https://api.example.com/events', expect.objectContaining({
-                event: 'test-event',
-                foo: 'bar',
-            }));
-        });
-        it('should return false 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);
-        });
-        it('should handle non-OK status response', async () => {
-            Worker_1.Worker.endpoint = 'https://api.example.com/events';
-            mockedAxios.patch.mockResolvedValue({
-                statusText: 'Bad Request',
-                data: { error: 'Invalid payload' },
-            });
-            const result = await Worker_1.Worker.pushEventAsync('test-event');
-            expect(result).toBe(undefined);
-        });
-        it('should include custom timestamp', async () => {
-            Worker_1.Worker.endpoint = 'https://api.example.com/events';
-            const customTs = 9876543210;
-            mockedAxios.patch.mockResolvedValue({
-                statusText: 'OK',
-                data: { success: true },
-            });
-            await Worker_1.Worker.pushEventAsync('test-event', {}, customTs);
-            expect(mockedAxios.patch).toHaveBeenCalledWith('https://api.example.com/events', expect.objectContaining({
-                event: 'test-event',
-                ts: expect.any(Number),
-            }));
-        });
-    });
-    describe('execPromise', () => {
-        it('should execute command successfully', async () => {
-            const mockChild = {
-                stdout: {
-                    on: jest.fn((event, callback) => {
-                        if (event === 'data') {
-                            // Simulate stdout data
-                            setTimeout(() => callback(Buffer.from('Command output')), 10);
-                        }
-                    }),
-                },
-                stderr: {
-                    on: jest.fn(),
-                },
-                on: jest.fn((event, callback) => {
-                    if (event === 'close') {
-                        // Simulate successful completion
-                        setTimeout(() => callback(0), 20);
-                    }
-                }),
-            };
-            mockedSpawn.mockReturnValue(mockChild);
-            await expect(Worker_1.Worker.execPromise('ls', ['-la'], '/tmp')).resolves.toBeUndefined();
-            expect(mockedSpawn).toHaveBeenCalledWith('ls', ['-la'], {
-                cwd: '/tmp',
-            });
-        });
-        it('should reject on command failure', async () => {
-            const mockChild = {
-                stdout: {
-                    on: jest.fn(),
-                },
-                stderr: {
-                    on: jest.fn((event, callback) => {
-                        if (event === 'data') {
-                            setTimeout(() => callback(Buffer.from('Error output')), 10);
-                        }
-                    }),
-                },
-                on: jest.fn((event, callback) => {
-                    if (event === 'close') {
-                        // Simulate failure with exit code 1
-                        setTimeout(() => callback(1), 20);
-                    }
-                }),
-            };
-            mockedSpawn.mockReturnValue(mockChild);
-            await expect(Worker_1.Worker.execPromise('invalid-command', [])).rejects.toThrow('Process failed and returned code: 1');
-        });
-        it('should use current working directory by default', async () => {
-            const mockChild = {
-                stdout: { on: jest.fn() },
-                stderr: { on: jest.fn() },
-                on: jest.fn((event, callback) => {
-                    if (event === 'close') {
-                        setTimeout(() => callback(0), 10);
-                    }
-                }),
-            };
-            mockedSpawn.mockReturnValue(mockChild);
-            await Worker_1.Worker.execPromise('echo', ['test']);
-            expect(mockedSpawn).toHaveBeenCalledWith('echo', ['test'], {
-                cwd: process.cwd(),
-            });
-        });
-        it('should pass arguments to command', async () => {
-            const mockChild = {
-                stdout: { on: jest.fn() },
-                stderr: { on: jest.fn() },
-                on: jest.fn((event, callback) => {
-                    if (event === 'close') {
-                        setTimeout(() => callback(0), 10);
-                    }
-                }),
-            };
-            mockedSpawn.mockReturnValue(mockChild);
-            const args = ['arg1', 'arg2', '--flag'];
-            await Worker_1.Worker.execPromise('command', args, '/custom/path');
-            expect(mockedSpawn).toHaveBeenCalledWith('command', args, {
-                cwd: '/custom/path',
-            });
-        });
-    });
-    describe('logger', () => {
-        it('should have a logger instance', () => {
-            expect(Worker_1.Worker.logger).toBeDefined();
-        });
-    });
-});

package/lib/index.d.ts

@@ -1,7 +0,0 @@
-import { Worker } from './Worker';
-import { FileSystem } from './FileSystem';
-import { Helpers } from './Helpers';
-import { HandlerParameters } from './types/HandlerParameters';
-import { MessagehandlerParameters } from './types/MessagehandlerParameters';
-import { ModeEnum } from './types/ModeEnum';
-export { Worker, FileSystem, Helpers, ModeEnum, HandlerParameters, MessagehandlerParameters, };

package/lib/index.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModeEnum = exports.Helpers = exports.FileSystem = exports.Worker = void 0;
-const Worker_1 = require("./Worker");
-Object.defineProperty(exports, "Worker", { enumerable: true, get: function () { return Worker_1.Worker; } });
-const FileSystem_1 = require("./FileSystem");
-Object.defineProperty(exports, "FileSystem", { enumerable: true, get: function () { return FileSystem_1.FileSystem; } });
-const Helpers_1 = require("./Helpers");
-Object.defineProperty(exports, "Helpers", { enumerable: true, get: function () { return Helpers_1.Helpers; } });
-const ModeEnum_1 = require("./types/ModeEnum");
-Object.defineProperty(exports, "ModeEnum", { enumerable: true, get: function () { return ModeEnum_1.ModeEnum; } });

package/lib/types/HandlerParameters.d.ts

@@ -1,9 +0,0 @@
-import { ModeEnum } from './ModeEnum';
-import { AbstractQueueAdapter } from '@quatrain/queue';
-export interface HandlerParameters {
-    mode: string | typeof ModeEnum;
-    topic?: string;
-    concurrency?: number;
-    queueAdapter?: AbstractQueueAdapter;
-    gpu?: boolean;
-}

package/lib/types/HandlerParameters.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/MessagehandlerParameters.d.ts

@@ -1,4 +0,0 @@
-export interface MessagehandlerParameters {
-    concurrency?: number;
-    gpu?: boolean;
-}

package/lib/types/MessagehandlerParameters.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/ModeEnum.d.ts

@@ -1,5 +0,0 @@
-export declare enum ModeEnum {
-    MODE_CLI = "cli",
-    MODE_QUEUE = "queue",
-    MODE_TEST = "test"
-}

package/lib/types/ModeEnum.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModeEnum = void 0;
-var ModeEnum;
-(function (ModeEnum) {
-    ModeEnum["MODE_CLI"] = "cli";
-    ModeEnum["MODE_QUEUE"] = "queue";
-    ModeEnum["MODE_TEST"] = "test";
-})(ModeEnum || (exports.ModeEnum = ModeEnum = {}));