@wooch-tickets/wookster-cli 1.0.0

package/dist/cli/commands/listener/script-executor.js

@@ -0,0 +1,285 @@
+"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 __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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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.ScriptExecutor = void 0;
+const fs = __importStar(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const vm = __importStar(require("node:vm"));
+const global_logger_1 = require("../../../client/logger/global-logger");
+const logger_decorator_1 = require("../../../client/logger/logger.decorator");
+const handler_models_1 = require("../../../client/models/handler-models");
+const base_request_handler_command_1 = require("./base-request-handler-command");
+let ScriptExecutor = (() => {
+    let _classDecorators = [(0, logger_decorator_1.Log)()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_request_handler_command_1.BaseRequestHandlerCommand;
+    var ScriptExecutor = 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);
+            ScriptExecutor = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        constructor() {
+            super();
+        }
+        init(opts) {
+            super.init(opts);
+            const path = opts.script;
+            if (!path) {
+                throw new Error('Script path is required');
+            }
+            this.log.info(`Loading script from: ${path}`);
+            try {
+                const handler = new ScriptHandler(path);
+                this.setHandler(handler);
+                this.log.info(`Script ${handler.handlerType} loaded successfully !`);
+            }
+            catch (e) {
+                this.log.error(`Failed to load script: ${e.message}`);
+                process.exit(1);
+            }
+        }
+    };
+    return ScriptExecutor = _classThis;
+})();
+exports.ScriptExecutor = ScriptExecutor;
+class ScriptHandler {
+    path;
+    method;
+    handlerType = 'method';
+    constructor(path) {
+        this.path = path;
+        this.loadScript(this.path);
+    }
+    connected() {
+        return Promise.resolve();
+    }
+    disconnected() {
+        return Promise.resolve();
+    }
+    handle(request) {
+        return new Promise((resolve, reject) => {
+            if (!this.method) {
+                return reject(new Error('Method not loaded'));
+            }
+            const responseFactory = {
+                ok: (message, code = 200) => {
+                    return handler_models_1.WebhookResult.success(message, code);
+                },
+                error: (message, code = 500) => {
+                    return handler_models_1.WebhookResult.failure(message, code);
+                }
+            };
+            try {
+                const result = this.method(request, responseFactory);
+                if (result instanceof Promise) {
+                    result.then(resolve).catch(reject);
+                    return;
+                }
+                resolve(result);
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    }
+    loadScript(path) {
+        const basePath = process.cwd() + '/' + path;
+        if (!fs.existsSync(basePath)) {
+            throw new Error(`Script file not found at path: ${basePath}`);
+        }
+        const scriptContent = fs.readFileSync(basePath, 'utf-8');
+        const scriptHeaderRegex = /^\/\/@wookster\/(\w+):?(\w+)?$/m;
+        const headerMatch = scriptContent.match(scriptHeaderRegex);
+        if (!headerMatch) {
+            throw new Error(SCRIPT_MISSING_ERROR);
+        }
+        const scriptType = headerMatch[1];
+        const scriptOption = headerMatch[2] || '';
+        if (scriptType !== 'method' && scriptType !== 'file') {
+            throw new Error(`Unsupported script type: ${scriptType}. Supported types are 'method' and 'file',\n\n${SCRIPT_MISSING_ERROR}`);
+        }
+        this.handlerType = scriptType;
+        if (scriptType === 'method') {
+            this.loadMethodScript(scriptContent, basePath, scriptOption);
+        }
+        else if (scriptType === 'file') {
+            this.loadFileScript(scriptContent, basePath);
+        }
+    }
+    getConsoleProxy(name) {
+        const logger = (0, global_logger_1.generateLogService)(name);
+        function argsToString(args) {
+            return args.map(arg => {
+                if (typeof arg === 'string') {
+                    return arg;
+                }
+                else if (typeof arg === 'object') {
+                    try {
+                        return JSON.stringify(arg);
+                    }
+                    catch {
+                        return String(arg);
+                    }
+                }
+                else {
+                    return String(arg);
+                }
+            }).join(' ');
+        }
+        return {
+            log: (...args) => logger.info(argsToString(args)),
+            info: (...args) => logger.info(argsToString(args)),
+            warn: (...args) => logger.warn(argsToString(args)),
+            error: (...args) => logger.error(argsToString(args)),
+            debug: (...args) => logger.debug(argsToString(args)),
+            trace: (...args) => logger.debug(argsToString(args)),
+            dir: (obj) => logger.debug(JSON.stringify(obj, null, 2)),
+            assert: (condition, ...args) => {
+                if (!condition) {
+                    logger.error('Assertion failed: ' + args.join(' '));
+                }
+            }
+        };
+    }
+    loadMethodScript(scriptContent, basePath, methodName) {
+        if (!methodName || methodName.trim() === '') {
+            methodName = 'handle';
+        }
+        const script = new vm.Script(scriptContent, { filename: basePath });
+        const filename = node_path_1.default.basename(basePath);
+        const console = this.getConsoleProxy(filename);
+        const context = vm.createContext({ console: console, exports: {}, require, module: {} });
+        script.runInContext(context);
+        const exported = context.exports;
+        if (exported && typeof exported[methodName] === 'function') {
+            console.debug(`Loaded method from exports: ${methodName}`);
+            this.method = exported[methodName];
+            return;
+        }
+        else if (typeof context[methodName] === 'function') {
+            console.debug(`Loaded method from context: ${methodName}`);
+            this.method = context[methodName];
+            return;
+        }
+        else {
+            throw new Error(`Method ${methodName} not found in script`);
+        }
+    }
+    loadFileScript(scriptContent, basePath) {
+        // for file scripts, we expect the script to export a function named 'handle'
+        const script = new vm.Script(scriptContent, { filename: basePath });
+        const filename = node_path_1.default.basename(basePath);
+        this.method = (request) => {
+            let result;
+            const middlewareFactory = {
+                ok: (message, code = 200) => {
+                    if (!result) {
+                        result = handler_models_1.WebhookResult.success(message, code);
+                    }
+                    return result;
+                },
+                error: (message, code = 500) => {
+                    if (!result) {
+                        result = handler_models_1.WebhookResult.failure(message, code);
+                    }
+                    return result;
+                }
+            };
+            const context = vm.createContext({ console: this.getConsoleProxy(filename), require, request: request, response: middlewareFactory });
+            script.runInContext(context);
+            if (!result) {
+                throw new Error('Script did not return a response. Please use response.ok() or response.error() to return a response.');
+            }
+            return result;
+        };
+    }
+}
+const SCRIPT_MISSING_ERROR = `Script file is missing required header.
+Please add a header in the following format at the top of your script file:
+//@wookster/method:<function_name>
+or
+//@wookster/file
+
+Ex:
+//@wookster/method:handle
+
+function handle(request, response) {
+	// your code here
+	return response.ok('Request handled successfully');
+}
+`;

package/dist/cli/commands/script-executor.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+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 noop_logger_1 = require("../../client/logger/noop.logger");
+const handler_models_1 = require("../../client/models/handler-models");
+const request_handler_service_1 = require("../../client/services/request-handler.service");
+async function execute() {
+    (0, global_logger_1.setGlobalLogger)(noop_logger_1.NoopLogger);
+    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.setHandler(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);
+    });
+    service.start();
+    (0, node_timers_1.setInterval)(() => { }, 5000);
+}

package/dist/cli/env.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnvVarNames = getEnvVarNames;
+exports.getEnvVar = getEnvVar;
+exports.saveAsEnv = saveAsEnv;
+exports.getEnv = getEnv;
+const ENV_AVAILABLE_VARS = ['WOOKSTER_URL', 'WOOKSTER_API_KEY', 'WOOKSTER_WORKER_ID', 'WOOKSTER_LOGGER', 'WOOKSTER_VERBOSE'];
+const globalSavedEnv = {};
+function getEnvVarNames() {
+    return ENV_AVAILABLE_VARS;
+}
+function getEnvVar(key) {
+    const savedData = globalSavedEnv[key];
+    if (savedData) {
+        return savedData;
+    }
+    return process.env[key];
+}
+function saveAsEnv(key, value) {
+    globalSavedEnv[key] = value;
+}
+function getEnv() {
+    const env = {};
+    for (const key of ENV_AVAILABLE_VARS) {
+        env[key] = process.env[key];
+    }
+    return env;
+}

package/dist/cli/global-option-applier.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalOptionApplier = globalOptionApplier;
+const global_logger_1 = require("../client/logger/global-logger");
+const json_logger_1 = require("../client/logger/json.logger");
+const logger_service_1 = require("../client/logger/logger-service");
+const noop_logger_1 = require("../client/logger/noop.logger");
+const pretty_logger_1 = require("../client/logger/pretty.logger");
+const env_1 = require("./env");
+function setLoggerFromType(logger) {
+    if (!logger) {
+        logger = (0, env_1.getEnvVar)('WOOKSTER_LOGGER') ?? 'pretty';
+    }
+    switch (logger) {
+        case 'json':
+            (0, global_logger_1.setGlobalLogger)(json_logger_1.JsonLogger);
+            break;
+        case 'pretty':
+            (0, global_logger_1.setGlobalLogger)(pretty_logger_1.PrettyLogger);
+            break;
+        case 'noop':
+            (0, global_logger_1.setGlobalLogger)(noop_logger_1.NoopLogger);
+            break;
+        default:
+            throw new Error(`Unknown logger type: ${logger}`);
+    }
+}
+function globalOptionApplier(command) {
+    const opts = command.opts();
+    if (opts.verbose) {
+        (0, logger_service_1.allowSeverity)('debug');
+    }
+    setLoggerFromType(opts.logger);
+    (0, env_1.saveAsEnv)('WOOKSTER_API_KEY', opts.apiKey);
+    (0, env_1.saveAsEnv)('WOOKSTER_URL', opts.serverUrl);
+}

package/dist/cli/global-option-parsing.js

@@ -0,0 +1,70 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalOptionApplier = globalOptionApplier;
+function setLoggerFromType(logger) {
+    switch (logger) {
+        case 'json':
+            Promise.resolve().then(() => __importStar(require('../client/logger/json.logger'))).then(module => {
+                const { setGlobalLogger } = require('../client/logger/global-logger');
+                setGlobalLogger(module.JsonLogger);
+            });
+            break;
+        case 'pretty':
+            Promise.resolve().then(() => __importStar(require('../client/logger/pretty.logger'))).then(module => {
+                const { setGlobalLogger } = require('../client/logger/global-logger');
+                setGlobalLogger(module.PrettyLogger);
+            });
+            break;
+        case 'noop':
+            Promise.resolve().then(() => __importStar(require('../client/logger/noop.logger'))).then(module => {
+                const { setGlobalLogger } = require('../client/logger/global-logger');
+                setGlobalLogger(module.NoopLogger);
+            });
+            break;
+        default:
+            throw new Error(`Unknown logger type: ${logger}`);
+    }
+}
+function globalOptionApplier(command) {
+    const opts = command.opts();
+    if (opts.verbose) {
+        const { allowSeverity } = require('../client/logger/logger-service');
+        allowSeverity('debug');
+    }
+    if (opts.logger) {
+        setLoggerFromType(opts.logger);
+    }
+}

package/dist/cli/index.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const base_request_handler_command_1 = require("./commands/listener/base-request-handler-command");
+const proxy_executor_1 = require("./commands/listener/proxy-executor");
+const script_executor_1 = require("./commands/listener/script-executor");
+const global_option_applier_1 = require("./global-option-applier");
+const program = new commander_1.Command();
+program
+    .name('wookster')
+    .description('CLI for Wookster Virtual Hooks')
+    .version('0.0.1');
+program.hook('preAction', global_option_applier_1.globalOptionApplier);
+//global actions:
+program.addOption(new commander_1.Option('--verbose').default(false, 'Enable verbose logging'));
+program.addOption(new commander_1.Option('--logger <type>', "Specify logger type").choices(['json', 'pretty', 'noop']));
+program.addOption(new commander_1.Option('-k, --api-key <apiKey>', "Api key for authentication"));
+program.addOption(new commander_1.Option('-u, --server-url <serverUrl>', 'Server URL to connect to'));
+program
+    .command('execute')
+    .description('Start a virtual hook client and execute a provided script for each request')
+    .requiredOption("-w, --worker <worker>", 'Worker identifier to process requests')
+    .requiredOption('-s, --script <script>', 'Path to the script to execute for each request')
+    .action(async (options) => {
+    (0, base_request_handler_command_1.runCommand)(script_executor_1.ScriptExecutor, options);
+});
+program
+    .command('proxy')
+    .description('Start a virtual hook client and proxy request to another server')
+    .requiredOption('-w, --worker <worker>', 'Worker identifier to process requests')
+    .requiredOption('-t, --target <target>', 'Target url to proxy webhook request (http.s)')
+    .action(async (argument) => {
+    (0, base_request_handler_command_1.runCommand)(proxy_executor_1.ProxyExecutor, argument);
+});
+program.parseAsync();

package/dist/cli/rx-event-counter.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rxEventCounter = rxEventCounter;
+const of_1 = require("rxjs/internal/observable/of");
+const operators_1 = require("rxjs/operators");
+function rxEventCounter(counts, timeSpan) {
+    return (0, operators_1.switchMap)((source) => {
+        return (0, of_1.of)(source).pipe((0, operators_1.map)(() => new Date().getTime()), (0, operators_1.bufferCount)(counts, 1), (0, operators_1.filter)((timestamps) => {
+            return timestamps[0] > new Date().getTime() - timeSpan;
+        }));
+    });
+}

package/dist/client/handlers/base.request-handler.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseRequestHandler = void 0;
+class BaseRequestHandler {
+    connected() {
+        return Promise.resolve();
+    }
+    disconnected() {
+        return Promise.resolve();
+    }
+}
+exports.BaseRequestHandler = BaseRequestHandler;

package/dist/client/handlers/method.request-handler.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodRequestHandler = void 0;
+const base_request_handler_1 = require("./base.request-handler");
+class MethodRequestHandler extends base_request_handler_1.BaseRequestHandler {
+    method;
+    constructor(method) {
+        super();
+        this.method = method;
+    }
+    handle(request) {
+        return this.method(request);
+    }
+    static from(method) {
+        return new MethodRequestHandler(method);
+    }
+    static forObject(object, methodName) {
+        const method = object[methodName];
+        if (typeof method !== 'function') {
+            throw new Error(`Property ${String(methodName)} is not a function on the provided object`);
+        }
+        return new MethodRequestHandler((request) => {
+            return method.call(object, request);
+        });
+    }
+}
+exports.MethodRequestHandler = MethodRequestHandler;

package/dist/client/handlers/multi.request-handler.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiRequestHandler = void 0;
+const handler_models_1 = require("../models/handler-models");
+const base_request_handler_1 = require("./base.request-handler");
+class MultiRequestHandler extends base_request_handler_1.BaseRequestHandler {
+    handlers;
+    constructor(handlers) {
+        super();
+        this.handlers = handlers;
+    }
+    async handle(request) {
+        for (const handler of this.handlers) {
+            await handler.handle(request);
+        }
+        return handler_models_1.WebhookResult.success();
+    }
+}
+exports.MultiRequestHandler = MultiRequestHandler;

package/dist/client/handlers/subject.request-handler.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodRequestHandler = void 0;
+const base_request_handler_1 = require("./base.request-handler");
+const handler_models_1 = require("../models/handler-models");
+/**
+ * A request handler that converts incoming requests into events on an RxJS Subject.
+ * /!\ Note that the handler always returns a successful WebhookResult, regardless of whether there are subscribers to the Subject or not.
+ */
+class MethodRequestHandler extends base_request_handler_1.BaseRequestHandler {
+    subject;
+    constructor(subject) {
+        super();
+        this.subject = subject;
+    }
+    handle(request) {
+        this.subject.next(request);
+        return Promise.resolve(handler_models_1.WebhookResult.success());
+    }
+}
+exports.MethodRequestHandler = MethodRequestHandler;

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalLogger = void 0;
+exports.getGlobalLogger = getGlobalLogger;
+exports.setGlobalLogger = setGlobalLogger;
+exports.generateLogService = generateLogService;
+const logger_service_1 = require("./logger-service");
+let __globalLogger;
+let __globalLoggerService;
+function getGlobalLogger() {
+    return __globalLogger;
+}
+function setGlobalLogger(logger) {
+    if (typeof logger === 'function') {
+        logger = new logger();
+    }
+    __globalLogger = logger;
+    __globalLoggerService = generateLogService();
+}
+function generateLogService(source) {
+    return new logger_service_1.LogService(getGlobalLogger(), source || 'global');
+}
+const globalLogger = () => {
+    if (!__globalLoggerService) {
+        __globalLoggerService = generateLogService();
+    }
+    return Object.freeze(__globalLoggerService);
+};
+exports.globalLogger = globalLogger;

package/dist/client/logger/json.logger.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonLogger = void 0;
+class JsonLogger {
+    mapping = {
+        timestamp: 'timestamp',
+        severity: 'level',
+        source: 'source',
+        message: 'message',
+        context: 'context'
+    };
+    constructor(mapping) {
+        if (mapping) {
+            this.mapping = { ...this.mapping, ...mapping };
+        }
+    }
+    log(log) {
+        const result = {};
+        result[this.mapping.timestamp] = log.timestamp.toISOString();
+        result[this.mapping.severity] = log.severity;
+        result[this.mapping.source] = log.source;
+        result[this.mapping.message] = log.message;
+        if (Object.keys(log.context).length) {
+            result[this.mapping.context] = log.context;
+        }
+        console.log(JSON.stringify(result));
+    }
+}
+exports.JsonLogger = JsonLogger;

package/dist/client/logger/log.js

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