velocious 1.0.108 → 1.0.110

package/dist/src/http-server/server-client.d.ts

@@ -0,0 +1,43 @@
+export default class ServerClient {
+    /**
+     * @param {object} args
+     * @param {import("../configuration.js").default} args.configuration
+     * @param {import("net").Socket} args.socket
+     * @param {number} args.clientCount
+     */
+    constructor({ configuration, socket, clientCount }: {
+        configuration: import("../configuration.js").default;
+        socket: import("net").Socket;
+        clientCount: number;
+    });
+    events: EventEmitter<[never]>;
+    configuration: import("../configuration.js").default;
+    logger: Logger;
+    socket: import("net").Socket;
+    clientCount: number;
+    listen(): void;
+    end(): Promise<any>;
+    /**
+     * @param {Buffer} chunk
+     * @returns {void}
+     */
+    onSocketData: (chunk: Buffer) => void;
+    /**
+     * @returns {void}
+     */
+    onSocketEnd: () => void;
+    /**
+     * @param {string} data
+     * @returns {Promise<void>}
+     */
+    send(data: string): Promise<void>;
+    /**
+     * @param {import("worker_threads").Worker} newWorker
+     * @returns {void}
+     */
+    setWorker(newWorker: import("worker_threads").Worker): void;
+    worker: import("worker_threads").Worker;
+}
+import EventEmitter from "events";
+import { Logger } from "../logger.js";
+//# sourceMappingURL=server-client.d.ts.map

package/dist/src/http-server/server-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-client.d.ts","sourceRoot":"","sources":["../../../src/http-server/server-client.js"],"names":[],"mappings":"AAKA;IAGE;;;;;OAKG;IACH,oDAJG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACV,MAAM,EAAjC,OAAO,KAAK,EAAE,MAAM;QACP,WAAW,EAAxB,MAAM;KAChB,EAUA;IAjBD,8BAA2B;IAWzB,qDAAkC;IAClC,eAA8B;IAC9B,6BAAoB;IACpB,oBAA8B;IAKhC,eAEC;IAED,oBAKC;IAED;;;OAGG;IACH,eAAgB,OAHL,MAGU,KAFR,IAAI,CAYhB;IAED;;OAEG;IACH,mBAFa,IAAI,CAKhB;IAED;;;OAGG;IACH,WAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CASzB;IAED;;;OAGG;IACH,qBAHW,OAAO,gBAAgB,EAAE,MAAM,GAC7B,IAAI,CAIhB;IADC,wCAAuB;CAE1B;yBA9EwB,QAAQ;uBACZ,cAAc"}

package/dist/src/http-server/server-client.js

@@ -0,0 +1,70 @@
+// @ts-check
+import EventEmitter from "events";
+import { Logger } from "../logger.js";
+export default class ServerClient {
+    events = new EventEmitter();
+    /**
+     * @param {object} args
+     * @param {import("../configuration.js").default} args.configuration
+     * @param {import("net").Socket} args.socket
+     * @param {number} args.clientCount
+     */
+    constructor({ configuration, socket, clientCount }) {
+        if (!configuration)
+            throw new Error("No configuration given");
+        this.configuration = configuration;
+        this.logger = new Logger(this);
+        this.socket = socket;
+        this.clientCount = clientCount;
+        socket.on("end", this.onSocketEnd);
+    }
+    listen() {
+        this.socket.on("data", this.onSocketData);
+    }
+    end() {
+        return new Promise((resolve) => {
+            this.socket.once("close", () => resolve(null));
+            this.socket.end();
+        });
+    }
+    /**
+     * @param {Buffer} chunk
+     * @returns {void}
+     */
+    onSocketData = (chunk) => {
+        this.logger.debug(() => [`Socket ${this.clientCount}: ${chunk}`]);
+        if (!this.worker)
+            throw new Error("No worker");
+        this.worker.postMessage({
+            command: "clientWrite",
+            chunk,
+            clientCount: this.clientCount
+        });
+    };
+    /**
+     * @returns {void}
+     */
+    onSocketEnd = () => {
+        this.logger.debug(`Socket ${this.clientCount} end`);
+        this.events.emit("close", this);
+    };
+    /**
+     * @param {string} data
+     * @returns {Promise<void>}
+     */
+    async send(data) {
+        return new Promise((resolve) => {
+            this.logger.debug("Send", data);
+            this.socket.write(data, () => {
+                resolve();
+            });
+        });
+    }
+    /**
+     * @param {import("worker_threads").Worker} newWorker
+     * @returns {void}
+     */
+    setWorker(newWorker) {
+        this.worker = newWorker;
+    }
+}

package/dist/src/http-server/worker-handler/index.d.ts

@@ -0,0 +1,49 @@
+export default class VelociousHttpServerWorker {
+    /**
+     * @param {object} args
+     * @param {import("../../configuration.js").default} args.configuration
+     * @param {number} args.workerCount
+     */
+    constructor({ configuration, workerCount }: {
+        configuration: import("../../configuration.js").default;
+        workerCount: number;
+    });
+    configuration: import("../../configuration.js").default;
+    /** @type {Record<number, import("../server-client.js").default>} */
+    clients: Record<number, import("../server-client.js").default>;
+    logger: Logger;
+    workerCount: number;
+    start(): Promise<any>;
+    onStartCallback: (value: any) => void;
+    _spawnWorker(): Promise<void>;
+    worker: Worker;
+    /**
+     * @param {import("../server-client.js").default} client
+     * @returns {void}
+     */
+    addSocketConnection(client: import("../server-client.js").default): void;
+    /**
+     * @param {any} error
+     */
+    onWorkerError: (error: any) => never;
+    /**
+     * @param {number} code
+     * @returns {void}
+     */
+    onWorkerExit: (code: number) => void;
+    /**
+     * @param {object} data
+     * @param {string} data.command
+     * @param {number} data.clientCount
+     * @param {string} data.output
+     * @returns {void}
+     */
+    onWorkerMessage: (data: {
+        command: string;
+        clientCount: number;
+        output: string;
+    }) => void;
+}
+import { Logger } from "../../logger.js";
+import { Worker } from "worker_threads";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/http-server/worker-handler/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/http-server/worker-handler/index.js"],"names":[],"mappings":"AAMA;IACE;;;;OAIG;IACH,4CAHG;QAAuD,aAAa,EAA5D,OAAO,wBAAwB,EAAE,OAAO;QAC3B,WAAW,EAAxB,MAAM;KAChB,EASA;IAPC,wDAAkC;IAElC,oEAAoE;IACpE,SADW,MAAM,CAAC,MAAM,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAC,CAC/C;IAEjB,eAA8B;IAC9B,oBAA8B;IAGhC,sBAKC;IAHG,sCAA8B;IAKlC,8BAgBC;IAXC,eAOE;IAMJ;;;OAGG;IACH,4BAHW,OAAO,qBAAqB,EAAE,OAAO,GACnC,IAAI,CAiBhB;IAED;;OAEG;IACH,gBAAiB,OAFN,GAEW,WAErB;IAED;;;OAGG;IACH,eAAgB,MAHL,MAGS,KAFP,IAAI,CAQhB;IAED;;;;;;OAMG;IACH,kBAAmB,MALhB;QAAqB,OAAO,EAApB,MAAM;QACO,WAAW,EAAxB,MAAM;QACO,MAAM,EAAnB,MAAM;KAGM,KAFV,IAAI,CA0BhB;CACF;uBArHoB,iBAAiB;uBACjB,gBAAgB"}

package/dist/src/http-server/worker-handler/index.js

@@ -0,0 +1,104 @@
+// @ts-check
+import { Logger } from "../../logger.js";
+import { Worker } from "worker_threads";
+import ensureError from "../../utils/ensure-error.js";
+export default class VelociousHttpServerWorker {
+    /**
+     * @param {object} args
+     * @param {import("../../configuration.js").default} args.configuration
+     * @param {number} args.workerCount
+     */
+    constructor({ configuration, workerCount }) {
+        this.configuration = configuration;
+        /** @type {Record<number, import("../server-client.js").default>} */
+        this.clients = {};
+        this.logger = new Logger(this);
+        this.workerCount = workerCount;
+    }
+    start() {
+        return new Promise((resolve) => {
+            this.onStartCallback = resolve;
+            this._spawnWorker();
+        });
+    }
+    async _spawnWorker() {
+        const debug = this.configuration.debug;
+        const directory = this.configuration.getDirectory();
+        const velociousPath = await this.configuration.getEnvironmentHandler().getVelociousPath();
+        this.worker = new Worker(`${velociousPath}/src/http-server/worker-handler/worker-script.js`, {
+            workerData: {
+                debug,
+                directory,
+                environment: this.configuration.getEnvironment(),
+                workerCount: this.workerCount
+            }
+        });
+        this.worker.on("error", this.onWorkerError);
+        this.worker.on("exit", this.onWorkerExit);
+        this.worker.on("message", this.onWorkerMessage);
+    }
+    /**
+     * @param {import("../server-client.js").default} client
+     * @returns {void}
+     */
+    addSocketConnection(client) {
+        const clientCount = client.clientCount;
+        client.socket.on("end", () => {
+            this.logger.debug(`Removing ${clientCount} from clients`);
+            delete this.clients[clientCount];
+        });
+        if (!this.worker)
+            throw new Error("Worker not initialized");
+        client.setWorker(this.worker);
+        client.listen();
+        this.clients[clientCount] = client;
+        this.worker.postMessage({ command: "newClient", clientCount });
+    }
+    /**
+     * @param {any} error
+     */
+    onWorkerError = (error) => {
+        throw ensureError(error); // Throws original error with backtrace and everything into the console
+    };
+    /**
+     * @param {number} code
+     * @returns {void}
+     */
+    onWorkerExit = (code) => {
+        if (code !== 0) {
+            throw new Error(`Client worker stopped with exit code ${code}`);
+        }
+        else {
+            this.logger.debug(() => [`Client worker stopped with exit code ${code}`]);
+        }
+    };
+    /**
+     * @param {object} data
+     * @param {string} data.command
+     * @param {number} data.clientCount
+     * @param {string} data.output
+     * @returns {void}
+     */
+    onWorkerMessage = (data) => {
+        this.logger.debug(`Worker message`, data);
+        const { command } = data;
+        if (command == "started") {
+            if (this.onStartCallback) {
+                this.onStartCallback(null);
+            }
+            this.onStartCallback = null;
+        }
+        else if (command == "clientOutput") {
+            this.logger.debug("CLIENT OUTPUT", data);
+            const { clientCount, output } = data;
+            this.clients[clientCount]?.send(output);
+        }
+        else if (command == "clientClose") {
+            const { clientCount } = data;
+            this.clients[clientCount]?.end();
+        }
+        else {
+            throw new Error(`Unknown command: ${command}`);
+        }
+    };
+}

package/dist/src/http-server/worker-handler/worker-script.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=worker-script.d.ts.map

package/dist/src/http-server/worker-handler/worker-script.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-script.d.ts","sourceRoot":"","sources":["../../../../src/http-server/worker-handler/worker-script.js"],"names":[],"mappings":""}

package/dist/src/http-server/worker-handler/worker-script.js

@@ -0,0 +1,4 @@
+// @ts-check
+import { workerData, parentPort } from "worker_threads";
+import WorkerThread from "./worker-thread.js";
+new WorkerThread({ parentPort, workerData });

package/dist/src/http-server/worker-handler/worker-thread.d.ts

@@ -0,0 +1,47 @@
+export default class VelociousHttpServerWorkerHandlerWorkerThread {
+    /**
+     * @param {object} args
+     * @param {import("worker_threads").parentPort} args.parentPort
+     * @param {{directory: string, environment: string, workerCount: number}} args.workerData
+     */
+    constructor({ parentPort, workerData }: {
+        parentPort: import("worker_threads").MessagePort;
+        workerData: {
+            directory: string;
+            environment: string;
+            workerCount: number;
+        };
+    });
+    /** @type {Record<number, Client>} */
+    clients: Record<number, Client>;
+    logger: Logger;
+    parentPort: import("worker_threads").MessagePort;
+    workerData: {
+        directory: string;
+        environment: string;
+        workerCount: number;
+    };
+    workerCount: number;
+    /**
+     * @returns {Promise<void>}
+     */
+    initialize(): Promise<void>;
+    /** @type {import("../../configuration.js").default} */
+    configuration: import("../../configuration.js").default;
+    application: Application;
+    /**
+     * @param {object} data
+     * @param {string} data.command
+     * @param {string} [data.chunk]
+     * @param {number} data.clientCount
+     */
+    onCommand: (data: {
+        command: string;
+        chunk?: string;
+        clientCount: number;
+    }) => Promise<void>;
+}
+import Client from "../client/index.js";
+import { Logger } from "../../logger.js";
+import Application from "../../application.js";
+//# sourceMappingURL=worker-thread.d.ts.map

package/dist/src/http-server/worker-handler/worker-thread.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-thread.d.ts","sourceRoot":"","sources":["../../../../src/http-server/worker-handler/worker-thread.js"],"names":[],"mappings":"AAQA;IACE;;;;OAIG;IACH,wCAHG;QAAkD,UAAU,EAApD,oCAAmC;QACiC,UAAU,EAA9E;YAAC,SAAS,EAAE,MAAM,CAAC;YAAC,WAAW,EAAE,MAAM,CAAC;YAAC,WAAW,EAAE,MAAM,CAAA;SAAC;KACvE,EAwBA;IAlBC,qCAAqC;IACrC,SADW,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAChB;IAEjB,eAA8C;IAC9C,iDAA4B;IAC5B;mBAZqB,MAAM;qBAAe,MAAM;qBAAe,MAAM;MAYzC;IAC5B,oBAA8B;IAchC;;OAEG;IACH,cAFa,OAAO,CAAC,IAAI,CAAC,CAoBzB;IAbC,uDAAuD;IACvD,eADW,OAAO,wBAAwB,EAAE,OAAO,CACH;IAOhD,yBAA+F;IAOjG;;;;;OAKG;IACH,YAAmB,MAJhB;QAAqB,OAAO,EAApB,MAAM;QACQ,KAAK,GAAnB,MAAM;QACO,WAAW,EAAxB,MAAM;KAEM,mBAoCtB;CACF;mBAtGkB,oBAAoB;uBAGlB,iBAAiB;wBAJd,sBAAsB"}

package/dist/src/http-server/worker-handler/worker-thread.js

@@ -0,0 +1,88 @@
+// @ts-check
+import Application from "../../application.js";
+import Client from "../client/index.js";
+import { digg } from "diggerize";
+import errorLogger from "../../error-logger.js";
+import { Logger } from "../../logger.js";
+export default class VelociousHttpServerWorkerHandlerWorkerThread {
+    /**
+     * @param {object} args
+     * @param {import("worker_threads").parentPort} args.parentPort
+     * @param {{directory: string, environment: string, workerCount: number}} args.workerData
+     */
+    constructor({ parentPort, workerData }) {
+        if (!parentPort)
+            throw new Error("parentPort is required");
+        const { workerCount } = workerData;
+        /** @type {Record<number, Client>} */
+        this.clients = {};
+        this.logger = new Logger(this, { debug: false });
+        this.parentPort = parentPort;
+        this.workerData = workerData;
+        this.workerCount = workerCount;
+        parentPort.on("message", errorLogger(this.onCommand));
+        this.initialize().then(() => {
+            if (!this.application)
+                throw new Error("Application not initialized");
+            this.application.initialize().then(() => {
+                this.logger.debug(`Worker ${workerCount} started`);
+                parentPort.postMessage({ command: "started" });
+            });
+        });
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async initialize() {
+        const { directory, environment } = this.workerData;
+        const configurationPath = `${directory}/src/config/configuration.js`;
+        const configurationImport = await import(configurationPath);
+        /** @type {import("../../configuration.js").default} */
+        this.configuration = configurationImport.default;
+        if (!this.configuration)
+            throw new Error(`Configuration couldn't be loaded from: ${configurationPath}`);
+        this.configuration.setEnvironment(environment);
+        this.configuration.setCurrent();
+        this.application = new Application({ configuration: this.configuration, type: "worker-handler" });
+        if (this.configuration.isInitialized()) {
+            await this.configuration.initialize({ type: "worker-handler" });
+        }
+    }
+    /**
+     * @param {object} data
+     * @param {string} data.command
+     * @param {string} [data.chunk]
+     * @param {number} data.clientCount
+     */
+    onCommand = async (data) => {
+        await this.logger.debug(() => [`Worker ${this.workerCount} received command`, data]);
+        const command = data.command;
+        if (command == "newClient") {
+            if (!this.configuration)
+                throw new Error("Configuration not initialized");
+            const { clientCount } = data;
+            const client = new Client({
+                clientCount,
+                configuration: this.configuration
+            });
+            client.events.on("output", (output) => {
+                this.parentPort.postMessage({ command: "clientOutput", clientCount, output });
+            });
+            client.events.on("close", (output) => {
+                this.logger.log("Close received from client in worker - forwarding to worker parent");
+                this.parentPort.postMessage({ command: "clientClose", clientCount, output });
+            });
+            this.clients[clientCount] = client;
+        }
+        else if (command == "clientWrite") {
+            await this.logger.debug("Looking up client");
+            const { chunk, clientCount } = data;
+            const client = digg(this.clients, clientCount);
+            await this.logger.debug(`Sending to client ${clientCount}`);
+            client.onWrite(chunk);
+        }
+        else {
+            throw new Error(`Unknown command: ${command}`);
+        }
+    };
+}

package/dist/src/initializer.d.ts

@@ -0,0 +1,27 @@
+export default class VelociousInitializer {
+    /**
+     * @param {object} args
+     * @param {import("./configuration.js").default} args.configuration
+     * @param {string} args.type
+     */
+    constructor({ configuration, type, ...restArgs }: {
+        configuration: import("./configuration.js").default;
+        type: string;
+    });
+    _configuration: import("./configuration.js").default;
+    _type: string;
+    /**
+     * @returns {import("./configuration.js").default}
+     */
+    getConfiguration(): import("./configuration.js").default;
+    /**
+     * @returns {string}
+     */
+    getType(): string;
+    /**
+     * @abstract
+     * @returns {Promise<void>}
+     */
+    run(): Promise<void>;
+}
+//# sourceMappingURL=initializer.d.ts.map

package/dist/src/initializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initializer.d.ts","sourceRoot":"","sources":["../../src/initializer.js"],"names":[],"mappings":"AAIA;IACE;;;;OAIG;IACH,kDAHG;QAAmD,aAAa,EAAxD,OAAO,oBAAoB,EAAE,OAAO;QACvB,IAAI,EAAjB,MAAM;KAChB,EAMA;IAFC,qDAAmC;IACnC,cAAiB;IAGnB;;OAEG;IACH,oBAFa,OAAO,oBAAoB,EAAE,OAAO,CAEA;IAEjD;;OAEG;IACH,WAFa,MAAM,CAEY;IAE/B;;;OAGG;IACH,OAFa,OAAO,CAAC,IAAI,CAAC,CAIzB;CACF"}

package/dist/src/initializer.js

@@ -0,0 +1,29 @@
+// @ts-check
+import restArgsError from "./utils/rest-args-error.js";
+export default class VelociousInitializer {
+    /**
+     * @param {object} args
+     * @param {import("./configuration.js").default} args.configuration
+     * @param {string} args.type
+     */
+    constructor({ configuration, type, ...restArgs }) {
+        restArgsError(restArgs);
+        this._configuration = configuration;
+        this._type = type;
+    }
+    /**
+     * @returns {import("./configuration.js").default}
+     */
+    getConfiguration() { return this._configuration; }
+    /**
+     * @returns {string}
+     */
+    getType() { return this._type; }
+    /**
+     * @abstract
+     * @returns {Promise<void>}
+     */
+    run() {
+        throw new Error(`'run' hasn't been implemented on ${this.constructor.name})`);
+    }
+}

package/dist/src/logger.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @param {any} object
+ * @param {...Parameters<typeof functionOrMessages>} messages - forwarded args
+ */
+export default function logger(object: any, ...messages: Parameters<typeof functionOrMessages>[]): Promise<void>;
+/**
+ * @param {...any|function() : Array<any>} messages
+ * @returns {Array<any>} - Either the function result or the messages
+ */
+declare function functionOrMessages(...messages: (any | (() => Array<any>))[]): Array<any>;
+export class Logger {
+    /**
+     * @param {any} object
+     * @param {object} args
+     * @param {boolean} args.debug
+     */
+    constructor(object: any, { debug, ...restArgs }?: {
+        debug: boolean;
+    });
+    _debug: boolean;
+    _subject: any;
+    _object: any;
+    /**
+     * @returns {import("./configuration.js").default}
+     */
+    getConfiguration(): import("./configuration.js").default;
+    _configuration: any;
+    debug(...args: Parameters<typeof functionOrMessages>): Promise<void>;
+    log(...args: Parameters<typeof functionOrMessages>): Promise<void>;
+    error(...args: Parameters<typeof functionOrMessages>): Promise<void>;
+    /**
+     * @param {boolean} newValue
+     * @returns {void}
+     */
+    setDebug(newValue: boolean): void;
+    warn(...args: Parameters<typeof functionOrMessages>): Promise<void>;
+}
+export {};
+//# sourceMappingURL=logger.d.ts.map

package/dist/src/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/logger.js"],"names":[],"mappings":"AAkKA;;;GAGG;AACH,uCAHW,GAAG,eACA,UAAU,CAAC,OAAO,kBAAkB,CAAC,EAAA,iBASlD;AA3HD;;;GAGG;AACH,iDAHW,CAAG,GAAG,IAAC,MAAa,KAAK,CAAC,GAAG,CAAC,CAAA,GAAA,GAC5B,KAAK,CAAC,GAAG,CAAC,CAQtB;AA2BD;IACE;;;;OAIG;IACH,oBAJW,GAAG,2BAEX;QAAsB,KAAK,EAAnB,OAAO;KACjB,EAgBA;IAZC,gBAAmB;IAGjB,cAAsB;IAEtB,aAAqB;IASzB;;OAEG;IACH,oBAFa,OAAO,oBAAoB,EAAE,OAAO,CAQhD;IAJG,oBAA4E;IAOtE,eAAU,UAAU,CAAC,OAAO,kBAAkB,CAAC,GAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IASjE,aAAU,UAAU,CAAC,OAAO,kBAAkB,CAAC,GAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAOjE,eAAU,UAAU,CAAC,OAAO,kBAAkB,CAAC,GAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAM3E;;;OAGG;IACH,mBAHW,OAAO,GACL,IAAI,CAIhB;IAGS,cAAU,UAAU,CAAC,OAAO,kBAAkB,CAAC,GAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CAK5E"}