@quatrain/worker 0.1.0

package/lib/AbstractQueueAdapter.d.ts

@@ -0,0 +1,8 @@
+import { QueueParameters } from './types/QueueParameters';
+export declare abstract class AbstractQueueAdapter {
+    protected _params: QueueParameters;
+    protected _client: any;
+    constructor(params: QueueParameters);
+    abstract send(data: any, topic: string): Promise<string>;
+    abstract listen(topic: string): any;
+}

package/lib/AbstractQueueAdapter.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractQueueAdapter = void 0;
+class AbstractQueueAdapter {
+    constructor(params) {
+        this._params = params;
+    }
+}
+exports.AbstractQueueAdapter = AbstractQueueAdapter;

package/lib/Worker.d.ts

@@ -0,0 +1,31 @@
+import { Core } from '@quatrain/core';
+export declare class Worker extends Core {
+    static endpoint: string;
+    static log(message: any, src?: string): void;
+    /**
+     * 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: string, args?: any[], cwd?: string) => Promise<any>;
+    static prepare(folder: string): void;
+    static makeFolder(folder: string): void;
+    static removeFolder(folder: string): void;
+    static downloadFile(url: string, filepath: string): Promise<unknown>;
+    static safeString(name: string): string;
+    static pushEvent(event: string, data?: {}, ts?: number): void;
+    static pushFile(filepath: string, folder: string, extension?: string): Promise<{
+        ref: string;
+        label: string | undefined;
+        worker: string;
+        size: number;
+    } | {
+        ref?: undefined;
+        label?: undefined;
+        worker?: undefined;
+        size?: undefined;
+    }>;
+}

package/lib/Worker.js

@@ -0,0 +1,141 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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 fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const axios_1 = __importDefault(require("axios"));
+const child_process_1 = require("child_process");
+class Worker extends core_1.Core {
+    static log(message, src = 'Worker') {
+        super.log(message, src);
+    }
+    static prepare(folder) {
+        Worker.log(`Setting up process folder ${folder}`);
+        this.removeFolder(folder);
+        fs_1.default.mkdirSync(folder);
+        fs_1.default.mkdirSync(folder + path_1.default.sep + 'images');
+        fs_1.default.mkdirSync(folder + path_1.default.sep + 'vecto');
+    }
+    static makeFolder(folder) {
+        fs_1.default.mkdirSync(folder);
+    }
+    static removeFolder(folder) {
+        if (fs_1.default.existsSync(folder)) {
+            fs_1.default.readdirSync(folder).forEach((element) => {
+                const item = path_1.default.join(folder, element);
+                if (fs_1.default.lstatSync(item).isDirectory()) {
+                    this.removeFolder(item);
+                }
+                else {
+                    fs_1.default.unlinkSync(item);
+                }
+            });
+            fs_1.default.rmdirSync(folder);
+        }
+    }
+    static downloadFile(url, filepath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const writer = fs_1.default.createWriteStream(filepath);
+                const response = yield 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 (error) {
+                console.error(`Download error: ${error.message}`);
+                throw error;
+            }
+        });
+    }
+    static safeString(name) {
+        return name.replace(/\s+/g, '_');
+    }
+    static pushEvent(event, data = {}, ts = 0) {
+        ts = ts === Date.now() ? Date.now() + 1 : Date.now();
+        const payload = Object.assign(Object.assign({ 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 });
+        axios_1.default
+            .put(Worker.endpoint, payload)
+            .then((res) => Worker.log(`Event pushed to backend: ${res.statusText}`))
+            .catch((err) => Worker.log(`Failed to push event to backend: ${err}`));
+    }
+    static pushFile(filepath, folder, extension = 'zip') {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const filename = filepath.split('/').pop();
+                const destination = `${folder}.${extension}`;
+                // const storage = new Storage({
+                //    keyFilename: params.keyFilename,
+                // })
+                // const bucket = storage.bucket(params.storageBucket)
+                // console.log(`Uploading ${filepath} to ${destination}`)
+                // const {
+                //    0: { metadata },
+                // } = await bucket.upload(filepath, {
+                //    destination,
+                //    resumable: false,
+                // })
+                return {
+                    ref: destination,
+                    label: filename,
+                    worker: `Container ${os_1.default.hostname}`,
+                    size: 0, //parseInt(metadata.size),
+                };
+            }
+            catch (err) {
+                return {};
+            }
+        });
+    }
+}
+exports.Worker = Worker;
+Worker.endpoint = '';
+/**
+ * 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
+ */
+Worker.execPromise = (command, args = [], cwd = process.cwd()) => {
+    Worker.log(`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) => {
+            console.info(`stdout: ${data}`);
+        });
+        child.stderr.on('data', (data) => {
+            console.info(`stderr: ${data}`);
+        });
+        child.on('close', (code) => {
+            if (code !== 0) {
+                console.error(`Command execution failed with code: ${code}`);
+                reject(code);
+            }
+            else {
+                console.info(`Command execution completed with code: ${code}`);
+                resolve(undefined);
+            }
+        });
+    });
+};

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+import { Worker } from './Worker';
+export { Worker };

package/lib/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Worker = void 0;
+const Worker_1 = require("./Worker");
+Object.defineProperty(exports, "Worker", { enumerable: true, get: function () { return Worker_1.Worker; } });

package/lib/types/QueueAdapterInterface.d.ts

@@ -0,0 +1,4 @@
+export interface QueueAdapterInterface {
+    send(data: any, topic: string): Promise<string>;
+    listen(topic: string): any;
+}

package/lib/types/QueueAdapterInterface.js

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

package/lib/types/QueueParameters.d.ts

@@ -0,0 +1,4 @@
+export interface QueueParameters {
+    topic?: string;
+    config?: any;
+}

package/lib/types/QueueParameters.js

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

package/package.json

@@ -0,0 +1,37 @@
+{
+   "name": "@quatrain/worker",
+   "version": "0.1.0",
+   "description": "Worker helpers",
+   "main": "lib/index.js",
+   "types": "lib/index.d.ts",
+   "files": [
+      "lib/",
+      "README.md"
+   ],
+   "author": "Quatrain Développement SAS <developers@quatrain.com>",
+   "license": "MIT",
+   "devDependencies": {
+      "@tsconfig/recommended": "^1.0.1",
+      "@types/fs-extra": "^11.0.4",
+      "@types/jest": "^27.0.3",
+      "@types/object-hash": "^3.0.6",
+      "jest": "^27.4.7",
+      "jest-node-exports-resolver": "^1.1.6",
+      "trace-unhandled": "^2.0.1",
+      "ts-jest": "^27.1.2",
+      "ts-node": "^10.4.0",
+      "typescript": "^5.1.5"
+   },
+   "dependencies": {
+      "@quatrain/core": "^1.0.0-beta13",
+      "axios": "^1.7.7",
+      "fs-extra": "^11.2.0"
+   },
+   "scripts": {
+      "test": "tsc && jest --verbose",
+      "build": "tsc --watch",
+      "patch": "yarn version --patch --no-git-tag-version",
+      "push": "yarn publish --access public",
+      "prepublish": "tsc"
+   }
+}