@wooch-tickets/wookster-cli 1.0.0

package/dist/client/logger/logger-service.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogService = void 0;
+exports.allowSeverity = allowSeverity;
+exports.disallowSeverity = disallowSeverity;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const global_logger_1 = require("./global-logger");
+const allowedSeverities = ['info', 'warn', 'error'];
+function allowSeverity(severity) {
+    if (!allowedSeverities.includes(severity)) {
+        allowedSeverities.push(severity);
+    }
+}
+function disallowSeverity(severity) {
+    const index = allowedSeverities.indexOf(severity);
+    if (index !== -1) {
+        allowedSeverities.splice(index, 1);
+    }
+}
+class LogService {
+    logger;
+    source;
+    messageQueue = [];
+    constructor(logger, source) {
+        this.logger = logger;
+        this.source = source;
+    }
+    info(message, context = {}) {
+        this.sendToLogger('info', message, context);
+    }
+    warn(message, context = {}) {
+        this.sendToLogger('warn', message, context);
+    }
+    error(message, context = {}) {
+        this.sendToLogger('error', message, context);
+    }
+    debug(message, context = {}) {
+        this.sendToLogger('debug', message, context);
+    }
+    sendToLogger(severity, message, context) {
+        const log = {
+            severity: severity,
+            source: this.source || 'unknown',
+            message: this.tryReplace(message, context),
+            timestamp: new Date(),
+            context
+        };
+        this.ensureLoggerState(log);
+        this.log(log);
+    }
+    log(log) {
+        if (allowedSeverities.includes(log.severity)) {
+            this.logger.log(log);
+        }
+    }
+    tryReplace(message, context) {
+        for (const key in context) {
+            const placeholder = `{${key}}`;
+            if (message.includes(placeholder)) {
+                message = message.replace(placeholder, String(context[key]));
+            }
+        }
+        return message;
+    }
+    ensureLoggerState(log = null) {
+        if (this.logger) {
+            if (this.messageQueue.length) {
+                for (const queuedLog of this.messageQueue) {
+                    this.log(queuedLog);
+                }
+                this.messageQueue = [];
+            }
+            return;
+        }
+        const globalLogger = (0, global_logger_1.getGlobalLogger)();
+        if (!globalLogger) {
+            if (log) {
+                this.messageQueue.push(log);
+                if (this.messageQueue.length > 5) {
+                    console.error(`Please set a global logger, you are losing log messages in ${this.source}`);
+                }
+            }
+        }
+        this.logger = globalLogger;
+    }
+    flushQueue() {
+        this.ensureLoggerState();
+    }
+}
+exports.LogService = LogService;

package/dist/client/logger/logger.decorator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithLogger = void 0;
+exports.Log = Log;
+const global_logger_1 = require("./global-logger");
+const logger_service_1 = require("./logger-service");
+/*
+* Add a logger to the class, accessible in this.log
+ */
+function Log(loggerName) {
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    return function (constructor) {
+        const name = loggerName ?? constructor.name;
+        const service = new logger_service_1.LogService((0, global_logger_1.getGlobalLogger)(), name);
+        service.debug(`Logger for ${name} created successfully`);
+        return class extends constructor {
+            log = service;
+        };
+    };
+}
+/*
+* Structure for logger type
+ */
+class WithLogger {
+    log;
+    constructor() {
+    }
+}
+exports.WithLogger = WithLogger;

package/dist/client/logger/noop.logger.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoopLogger = void 0;
+class NoopLogger {
+    log() {
+        // do nothing about it
+    }
+}
+exports.NoopLogger = NoopLogger;

package/dist/client/logger/pretty.logger.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrettyLogger = void 0;
+const LOG_TEMPLATE = '{timestamp} {severity} -- {source} : {message} {context}';
+class PrettyLogger {
+    color;
+    template;
+    constructor(color = true, template = LOG_TEMPLATE) {
+        this.color = color;
+        this.template = template;
+    }
+    log(log) {
+        const timestamp = log.timestamp.toISOString();
+        let severity = this.prettySeverity(log.severity);
+        const source = this.prettySource(log.source);
+        const message = log.message;
+        const context = Object.keys(log.context).length ? JSON.stringify(log.context) : '';
+        if (this.color) {
+            switch (log.severity) {
+                case 'info':
+                    severity = `\x1b[32m${severity}\x1b[0m`; // Green
+                    break;
+                case 'warn':
+                    severity = `\x1b[33m${severity}\x1b[0m`; // Yellow
+                    break;
+                case 'error':
+                    severity = `\x1b[31m${severity}\x1b[0m`; // Red
+                    break;
+                case 'debug':
+                    severity = `\x1b[34m${severity}\x1b[0m`; // Blue
+                    break;
+            }
+        }
+        const formattedLog = this.template
+            .replace('{timestamp}', timestamp)
+            .replace('{severity}', severity)
+            .replace('{source}', source)
+            .replace('{message}', message)
+            .replace('{context}', context);
+        console.log(formattedLog);
+    }
+    prettySource(source) {
+        const maxLength = 30;
+        if (source.length > maxLength) {
+            return source.substring(source.length - maxLength);
+        }
+        else {
+            return source.padEnd(maxLength, ' ');
+        }
+    }
+    //severity with fixed width (max 5 chars)
+    prettySeverity(severity) {
+        return severity.toUpperCase().padStart(5, ' ');
+    }
+}
+exports.PrettyLogger = PrettyLogger;

package/dist/client/models/handler-models.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookResult = void 0;
+class WebhookResult {
+    code;
+    message;
+    state = 'success';
+    executionTime;
+    constructor(state, code, message) {
+        this.state = state;
+        this.code = code;
+        this.message = message;
+    }
+    static success(message = 'OK', code = 200) {
+        return new WebhookResult('success', code, message);
+    }
+    static failure(message = 'Error', code = 500) {
+        return new WebhookResult('failure', code, message);
+    }
+}
+exports.WebhookResult = WebhookResult;

package/dist/client/models/webhook-request.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookRequest = void 0;
+/*
+  Model for a webhook request
+ */
+class WebhookRequest {
+    id;
+    method;
+    body;
+    headers;
+    type;
+    signature;
+    constructor(data) {
+        this.id = data.id;
+        this.method = data.method;
+        this.body = data.body;
+        this.headers = data.headers;
+        this.type = data.type;
+        this.signature = data.signature;
+    }
+}
+exports.WebhookRequest = WebhookRequest;

package/dist/client/services/request-handler.service.js

@@ -0,0 +1,226 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestHandlerService = void 0;
+const rx_stomp_1 = require("@stomp/rx-stomp");
+const node_assert_1 = __importDefault(require("node:assert"));
+const logger_decorator_1 = require("../logger/logger.decorator");
+const handler_models_1 = require("../models/handler-models");
+const webhook_request_1 = require("../models/webhook-request");
+function assertExists(object, key) {
+    const value = object[key];
+    (0, node_assert_1.default)(value !== undefined && value !== null, `Missing required property: ${String(key)}`);
+    if (typeof value === 'string') {
+        (0, node_assert_1.default)(value.trim().length > 0, `Property ${String(key)} cannot be an empty string`);
+    }
+}
+const WEBHOOK_QUEUE = '/queue/worker/webhook_request';
+const WEBHOOK_RESPONSE_CHANNEL = '/messages/worker/webhook-request/{requestId}';
+let RequestHandlerService = (() => {
+    let _classDecorators = [(0, logger_decorator_1.Log)()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = logger_decorator_1.WithLogger;
+    var RequestHandlerService = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            RequestHandlerService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        options;
+        handler;
+        client;
+        tunnelSub;
+        listenerSub;
+        intervalHandle;
+        constructor(options) {
+            super();
+            (0, node_assert_1.default)(options, 'RequestHandlerService requires options');
+            assertExists(options, 'worker');
+            assertExists(options, 'apiKey');
+            assertExists(options, 'serverUrl');
+            this.options = options;
+            this.handler = options.handler;
+            this.client = new rx_stomp_1.RxStomp();
+            const connectHeaders = {
+                'api-key': this.options.apiKey
+            };
+            if (options.worker) {
+                connectHeaders['worker'] = options.worker;
+            }
+            this.client.configure({
+                reconnectTimeMode: rx_stomp_1.ReconnectionTimeMode.LINEAR,
+                maxReconnectDelay: 10000,
+                brokerURL: this.options.serverUrl,
+                connectHeaders: connectHeaders,
+                reconnectDelay: 1000,
+                beforeConnect: () => {
+                    this.log.info('Connecting to server...');
+                    return Promise.resolve();
+                }
+            });
+        }
+        setHandler(handler) {
+            this.handler = handler;
+        }
+        start() {
+            if (!this.handler) {
+                throw new Error('Cannot start RequestHandlerService without a handler set');
+            }
+            this.tunnelSub = this.client.connected$.subscribe({
+                next: async (state) => {
+                    this.log.debug(`Connection state changed: ${rx_stomp_1.RxStompState[state]}`);
+                    switch (state) {
+                        case rx_stomp_1.RxStompState.OPEN:
+                            this.log.info('Connected to server');
+                            await this.handler.connected();
+                            break;
+                        case rx_stomp_1.RxStompState.CLOSED:
+                            await this.handler.disconnected();
+                            this.log.info('Disconnected from server');
+                            break;
+                    }
+                }
+            });
+            this.client.webSocketErrors$.subscribe({
+                next: (error) => {
+                    //try to reconnect on websocket errors
+                    this.log.error(`Tunnel error, client disconnected ....${error}`);
+                }
+            });
+            this.client.stompErrors$.subscribe({
+                next: (frame) => {
+                    if (frame.headers['message']) {
+                        if (frame.headers['message'].includes('Failed to send message')) {
+                            //forbidden, likely bad api key
+                            this.log.error(`Error, forbidden access to the ressource. Please check your API key and worker ID.`);
+                            this.reportError({ type: 'connection', level: 'fatal', message: 'Forbidden access to the resource, likely due to invalid API key or worker ID' });
+                            return;
+                        }
+                    }
+                    else {
+                        this.log.error(`STOMP Error: ${frame.body}`);
+                    }
+                }
+            });
+            this.listenerSub = this.client.watch(`${WEBHOOK_QUEUE}/${this.options.worker}`).subscribe(async (message) => {
+                if (!this.handler) {
+                    return;
+                }
+                let payload;
+                try {
+                    payload = JSON.parse(message.body);
+                    payload = new webhook_request_1.WebhookRequest(payload);
+                }
+                catch (error) {
+                    this.sendState('unknown', handler_models_1.WebhookResult.failure('Invalid request payload'));
+                    this.log.error(`Received invalid request payload: ${error.message}`);
+                    return;
+                }
+                const startTime = Date.now();
+                try {
+                    this.log.debug('Processing request ' + payload.id);
+                    this.ackMessage(payload.id);
+                    const result = await this.handler.handle(payload);
+                    result.executionTime = Date.now() - startTime;
+                    this.sendState(payload.id, result);
+                }
+                catch (error) {
+                    this.log.error(`Error processing request ${payload.id}: ${error.message}`);
+                    const result = handler_models_1.WebhookResult.failure(error.message);
+                    result.executionTime = Date.now() - startTime;
+                    this.sendState(payload.id, result);
+                }
+            });
+            this.log.info('Starting Outbound tunnel...');
+            this.client.activate();
+            this.intervalHandle = setInterval(async () => {
+                if (this.client.connected()) {
+                    this.log.debug('Connection is healthy');
+                }
+                else {
+                    this.log.warn('Connection is not healthy, attempting to reconnect...');
+                    await this.client.deactivate({ force: true });
+                    this.client.activate();
+                    this.log.info("Reconnection attempt initiated");
+                }
+            }, 5000);
+        }
+        async destroy(force = false) {
+            this.tunnelSub?.unsubscribe();
+            await this.client.deactivate({ force: force });
+            this.intervalHandle?.close();
+        }
+        ackMessage(requestId) {
+            this.log.debug('Sending ack for request ' + requestId);
+            this.client.publish({ destination: WEBHOOK_RESPONSE_CHANNEL.replace('{requestId}', requestId), body: JSON.stringify({ type: 'ack' }) });
+        }
+        sendState(requestId, result) {
+            this.log.debug('Sending result for request ' + requestId + ': ' + result.state, result);
+            const destination = WEBHOOK_RESPONSE_CHANNEL.replace('{requestId}', requestId);
+            this.client.publish({
+                destination, body: JSON.stringify({
+                    type: 'response',
+                    data: {
+                        state: result.state,
+                        message: result.message,
+                        code: result.code,
+                        executionTime: result.executionTime
+                    }
+                })
+            });
+        }
+        //error
+        errorHandler;
+        setErrorHandler(handler) {
+            this.errorHandler = handler;
+        }
+        reportError(error) {
+            if (this.errorHandler) {
+                this.errorHandler(error);
+            }
+        }
+    };
+    return RequestHandlerService = _classThis;
+})();
+exports.RequestHandlerService = RequestHandlerService;

package/dist/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_timers_1 = require("node:timers");
+const fromEvent_1 = require("rxjs/internal/observable/fromEvent");
+const method_request_handler_1 = require("./client/handlers/method.request-handler");
+const global_logger_1 = require("./client/logger/global-logger");
+const pretty_logger_1 = require("./client/logger/pretty.logger");
+const handler_models_1 = require("./client/models/handler-models");
+const request_handler_service_1 = require("./client/services/request-handler.service");
+(0, global_logger_1.setGlobalLogger)(pretty_logger_1.PrettyLogger);
+const mainLogger = (0, global_logger_1.generateLogService)('main');
+mainLogger.info(`Starting client at ${new Date().toISOString()}`);
+const service = new request_handler_service_1.RequestHandlerService({
+    worker: 'worker-f35a23c047df44b29d7d7d316a5a4aa7',
+    apiKey: '6g5ZE0CH.ZjTnaGKAp0Vg8It6DrKmdfceziPwx8Sy',
+    serverUrl: 'ws://localhost:8080/virtual-hooks',
+});
+service.
+(new method_request_handler_1.MethodRequestHandler((request) => {
+    mainLogger.info('Received request:', request);
+    return Promise.resolve(handler_models_1.WebhookResult.success());
+}));
+(0, fromEvent_1.fromEvent)(process, 'SIGINT').subscribe(async () => {
+    mainLogger.info('Received SIGINT, shutting down...');
+    await service.destroy();
+    process.exit(0);
+});
+(0, node_timers_1.setInterval)(() => { }, 5000);

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@wooch-tickets/wookster-cli",
+  "version": "1.0.0",
+  "description": "A TypeScript cli library for connecting to Wookster's services",
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "type": "commonjs",
+  "bin": {
+    "wookster": "./dist/cli/index.js"
+  },
+  "main": "./dist/cli/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start:dev": "concurrently \"npm run dev\" \"nodemon --watch 'dist/**/*.js' --exec 'node' dist/cli/index.js\"",
+    "lint": "eslint src/**/*.ts --fix",
+    "prepublishOnly": "npm run lint && npm run build"
+  },
+  "dependencies": {
+    "@sindresorhus/tsconfig": "^8.1.0",
+    "@stomp/rx-stomp": "^2.3.0",
+    "commander": "^14.0.2",
+    "prettier": "^3.7.4",
+    "rxjs": "^7.8.2",
+    "ws": "^8.18.3"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@types/eslint": "^9.6.1",
+    "@types/node": "^25.0.3",
+    "@types/ws": "^8.5.4",
+    "concurrently": "^9.2.1",
+    "eslint": "^8.57.1",
+    "globals": "^16.5.0",
+    "nodemon": "^3.1.11",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.51.0"
+  },
+  "files": [
+    "dist"
+  ]
+}