@rockster/core 0.0.1

package/web-socket/interfaces/enum/client-type.d.ts

@@ -0,0 +1,4 @@
+export declare enum ClientType {
+    external = "external",
+    internal = "internal"
+}

package/web-socket/interfaces/enum/client-type.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientType = void 0;
+var ClientType;
+(function (ClientType) {
+    ClientType["external"] = "external";
+    ClientType["internal"] = "internal";
+})(ClientType || (exports.ClientType = ClientType = {}));

package/web-socket/interfaces/enum/index.d.ts

@@ -0,0 +1,3 @@
+export * from './client-type';
+export * from './message-type';
+export * from './ws-connection-type';

package/web-socket/interfaces/enum/index.js

@@ -0,0 +1,19 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client-type"), exports);
+__exportStar(require("./message-type"), exports);
+__exportStar(require("./ws-connection-type"), exports);

package/web-socket/interfaces/enum/message-type.d.ts

@@ -0,0 +1,6 @@
+export declare enum MessageType {
+    connect = "connect",
+    response = "response",
+    request = "request",
+    continue = "continue"
+}

package/web-socket/interfaces/enum/message-type.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageType = void 0;
+var MessageType;
+(function (MessageType) {
+    MessageType["connect"] = "connect";
+    MessageType["response"] = "response";
+    MessageType["request"] = "request";
+    MessageType["continue"] = "continue";
+})(MessageType || (exports.MessageType = MessageType = {}));

package/web-socket/interfaces/enum/ws-connection-type.d.ts

@@ -0,0 +1,4 @@
+export declare enum WsConnectionType {
+    service = "service",
+    client = "client"
+}

package/web-socket/interfaces/enum/ws-connection-type.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsConnectionType = void 0;
+var WsConnectionType;
+(function (WsConnectionType) {
+    WsConnectionType["service"] = "service";
+    WsConnectionType["client"] = "client";
+})(WsConnectionType || (exports.WsConnectionType = WsConnectionType = {}));

package/web-socket/interfaces/index.d.ts

@@ -0,0 +1,4 @@
+export * from './enum';
+export * from './client';
+export * from './message';
+export * from './ws-connection';

package/web-socket/interfaces/index.js

@@ -0,0 +1,20 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./enum"), exports);
+__exportStar(require("./client"), exports);
+__exportStar(require("./message"), exports);
+__exportStar(require("./ws-connection"), exports);

package/web-socket/interfaces/message.d.ts

@@ -0,0 +1,30 @@
+import { MessageType } from "./enum";
+import { IncomingHttpHeaders } from "http";
+import { Dictionary, HttpMethod, HttpStatus } from "@rockster/common";
+export interface IMessage<T> {
+    type: MessageType;
+    sender: string;
+    targets: string[];
+    id?: string;
+    method?: HttpMethod;
+    status?: HttpStatus;
+    path?: string;
+    headers?: IncomingHttpHeaders;
+    params?: Dictionary<string>;
+    query?: Dictionary<string>;
+    body?: T;
+}
+export interface IConnectMessage<T = any> extends IMessage<T> {
+    readonly type: MessageType.connect;
+    events?: string[];
+}
+export interface IRequestMessage<T = any> extends IMessage<T> {
+    readonly type: MessageType.request;
+}
+export interface IResponseMessage<T = any> extends IMessage<T> {
+    readonly type: MessageType.response;
+}
+export interface IContinueMessage<T = any> extends IMessage<T> {
+    readonly type: MessageType.continue;
+}
+export type Message<T> = IConnectMessage<T> | IRequestMessage<T> | IResponseMessage<T> | IContinueMessage<T>;

package/web-socket/interfaces/message.js

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

package/web-socket/interfaces/ws-connection.d.ts

@@ -0,0 +1,4 @@
+export type WsConnection = {
+    milliseconds: number;
+    userId?: string;
+};

package/web-socket/interfaces/ws-connection.js

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

package/web-socket/web-socket.controller.d.ts

@@ -0,0 +1,25 @@
+import { Server } from 'http';
+import WebSocket from "ws";
+import { Client, IConnectMessage, Message } from "./interfaces";
+import { Logger } from "@rockster/logger";
+import { CacheClient } from "../cache";
+import { ContextBuilder } from "../core/services/context-builder";
+import { HttpController } from "../http";
+export declare class WebSocketController {
+    protected readonly contextBuilder: ContextBuilder;
+    protected readonly httpController: HttpController;
+    protected cache: CacheClient;
+    protected logger: Logger;
+    private static _clients;
+    protected get clients(): Map<string, Client>;
+    constructor(contextBuilder: ContextBuilder, httpController: HttpController);
+    start(server: Server): Promise<void>;
+    protected connection(socket: WebSocket): void;
+    protected checkIsReady(client: Client): void;
+    protected message(client: Client, data: WebSocket.RawData): void;
+    protected getRoute(message: Message<any>): import("../http").HttpRoute;
+    protected connect(client: Client, message: IConnectMessage<any>): Promise<void>;
+    protected addClient(client: Client): void;
+    protected createClient(socket: WebSocket): Client;
+    protected removeClient(client: Client): void;
+}

package/web-socket/web-socket.controller.js

@@ -0,0 +1,184 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var WebSocketController_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketController = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const common_1 = require("@rockster/common");
+const ws_1 = require("ws");
+const enum_1 = require("./interfaces/enum");
+const parse_message_1 = require("./functions/parse-message");
+const logger_1 = require("@rockster/logger");
+const encode_message_1 = require("./functions/encode-message");
+const use_auth_1 = require("../security/functions/use-auth");
+const cache_1 = require("../cache");
+const context_builder_1 = require("../core/services/context-builder");
+const http_1 = require("../http");
+const path_to_regexp_1 = require("path-to-regexp");
+const timeout = 15000;
+let WebSocketController = WebSocketController_1 = class WebSocketController {
+    get clients() {
+        return WebSocketController_1._clients;
+    }
+    constructor(contextBuilder, httpController) {
+        this.contextBuilder = contextBuilder;
+        this.httpController = httpController;
+        this.logger = new logger_1.Logger('Router');
+    }
+    async start(server) {
+        return new Promise((resolve, reject) => {
+            const wss = new ws_1.WebSocketServer({ noServer: true });
+            wss.on('connection', this.connection);
+            wss.on('error', reject);
+            server.on('upgrade', (request, socket, head) => {
+                wss.handleUpgrade(request, socket, head, (ws, req) => {
+                    wss.emit('connection', ws, req);
+                });
+            });
+            server.on('listening', async () => {
+                resolve();
+            });
+        });
+    }
+    connection(socket) {
+        let ready = false;
+        const client = this.createClient(socket);
+        this.checkIsReady(client);
+        socket.on('message', (data) => this.message(client, data));
+        socket.on('close', () => this.removeClient(client));
+    }
+    checkIsReady(client) {
+        const handle = () => {
+            if (!client.ready) {
+                client.send({
+                    type: enum_1.MessageType.response,
+                    status: common_1.HttpStatus.unauthorized,
+                    sender: core.options.name,
+                    targets: [client.id]
+                });
+                this.removeClient(client);
+            }
+        };
+        setTimeout(handle.bind(this), timeout);
+    }
+    message(client, data) {
+        const strMessage = data.toString();
+        const message = (0, parse_message_1.parseMessage)(strMessage);
+        if (!client.ready
+            && message.type !== enum_1.MessageType.connect) {
+            return;
+        }
+        switch (message.type) {
+            case enum_1.MessageType.connect:
+                this.connect(client, message);
+                break;
+            case enum_1.MessageType.request:
+                const route = this.getRoute(message);
+                if (!route) {
+                    client.send({
+                        id: message.id,
+                        sender: core.options.name,
+                        targets: [message.sender],
+                        type: enum_1.MessageType.response,
+                        status: common_1.HttpStatus.notFound
+                    });
+                }
+                break;
+        }
+    }
+    getRoute(message) {
+        const { method, path } = message;
+        for (const route of this.httpController.routes) {
+            if (method.toLowerCase() !== route.method.toLowerCase())
+                continue;
+            const matcher = (0, path_to_regexp_1.match)(route.path, { decode: decodeURIComponent });
+            const result = matcher(path);
+            if (result) {
+                return route;
+            }
+        }
+        return null;
+    }
+    async connect(client, message) {
+        try {
+            const auth = (0, use_auth_1.useAuth)();
+            const connection = await auth
+                .wsInterceptor(message);
+            if (this.clients.has(client.id)) {
+                throw new Error('Client alreay exists');
+            }
+            if (client.timeout) {
+                clearTimeout(client.timeout);
+            }
+            client.id = connection.userId;
+            client.connection = connection;
+            client.ready = true;
+            client.timeout = setTimeout(() => {
+                client.send({
+                    sender: core.options.name,
+                    targets: [client.id],
+                    type: enum_1.MessageType.response,
+                    status: common_1.HttpStatus.unauthorized
+                });
+                this.removeClient(client);
+            }, connection.milliseconds);
+            client.send({
+                id: message.id,
+                type: enum_1.MessageType.response,
+                status: common_1.HttpStatus.ok,
+                sender: core.options.name,
+                targets: [message.sender]
+            });
+            this.addClient(client);
+        }
+        catch (error) {
+            client.send({
+                type: enum_1.MessageType.response,
+                id: message.id,
+                sender: core.options.name,
+                targets: [message.sender],
+                status: common_1.HttpStatus.unauthorized,
+                body: {
+                    message: error.message
+                }
+            });
+            this.removeClient(client);
+        }
+    }
+    addClient(client) {
+        this.clients.set(client.id, client);
+    }
+    createClient(socket) {
+        const client = {
+            socket,
+            ready: false,
+            send: (message) => {
+                socket.send((0, encode_message_1.encodeMessage)(message));
+            }
+        };
+        return client;
+    }
+    removeClient(client) {
+        client.socket.terminate();
+        this.clients.delete(client.id);
+    }
+};
+exports.WebSocketController = WebSocketController;
+WebSocketController._clients = new Map();
+__decorate([
+    (0, cache_1.InjectCache)(),
+    __metadata("design:type", Object)
+], WebSocketController.prototype, "cache", void 0);
+exports.WebSocketController = WebSocketController = WebSocketController_1 = __decorate([
+    (0, class_injector_1.Injectable)(),
+    __metadata("design:paramtypes", [context_builder_1.ContextBuilder,
+        http_1.HttpController])
+], WebSocketController);

package/workers/functions/decode-message.d.ts

@@ -0,0 +1,2 @@
+import { WorkerMessage } from "../interfaces";
+export declare const decodeMessage: (message: string) => WorkerMessage;

package/workers/functions/decode-message.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeMessage = void 0;
+const decodeMessage = (message) => {
+    return JSON.parse(message);
+};
+exports.decodeMessage = decodeMessage;

package/workers/functions/dispatch-task.d.ts

@@ -0,0 +1,2 @@
+import { IWorkerFinishRunMessage, IWorkerInitRunMessage } from "../interfaces";
+export declare const dispatchTask: (message: IWorkerInitRunMessage, callback: (message: IWorkerFinishRunMessage) => Promise<void>) => Promise<void>;

package/workers/functions/dispatch-task.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchTask = void 0;
+const dispatchTask = (message, callback) => {
+    return new Promise((resolve) => {
+        const worker = core
+            .workers
+            .find((worker) => {
+            return !worker.busy;
+        });
+        if (!worker) {
+            setTimeout(() => {
+                resolve((0, exports.dispatchTask)(message, callback));
+            }, 3000);
+        }
+        else {
+            worker.dispatch(message);
+            worker.finish = callback;
+            resolve();
+        }
+    });
+};
+exports.dispatchTask = dispatchTask;

package/workers/functions/encode-message.d.ts

@@ -0,0 +1,2 @@
+import { WorkerMessage } from "../interfaces";
+export declare const encodeMessage: (message: WorkerMessage) => string;

package/workers/functions/encode-message.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeMessage = void 0;
+const encodeMessage = (message) => {
+    return JSON.stringify(message);
+};
+exports.encodeMessage = encodeMessage;

package/workers/interfaces/enum/index.d.ts

@@ -0,0 +1 @@
+export * from './worker-message-type';

package/workers/interfaces/enum/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./worker-message-type"), exports);

package/workers/interfaces/enum/worker-message-type.d.ts

@@ -0,0 +1,6 @@
+export declare enum WorkerMessageType {
+    log = "log",
+    done = "done",
+    initRun = "initRun",
+    finishRun = "finishRun"
+}

package/workers/interfaces/enum/worker-message-type.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerMessageType = void 0;
+var WorkerMessageType;
+(function (WorkerMessageType) {
+    WorkerMessageType["log"] = "log";
+    WorkerMessageType["done"] = "done";
+    WorkerMessageType["initRun"] = "initRun";
+    WorkerMessageType["finishRun"] = "finishRun";
+})(WorkerMessageType || (exports.WorkerMessageType = WorkerMessageType = {}));

package/workers/interfaces/index.d.ts

@@ -0,0 +1,3 @@
+export * from './enum';
+export * from './worker-data';
+export * from './worker-message';

package/workers/interfaces/index.js

@@ -0,0 +1,19 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./enum"), exports);
+__exportStar(require("./worker-data"), exports);
+__exportStar(require("./worker-message"), exports);

package/workers/interfaces/worker-data.d.ts

@@ -0,0 +1,9 @@
+import { Worker } from "worker_threads";
+import { IWorkerFinishRunMessage, IWorkerInitRunMessage } from "./worker-message";
+export type WorkerData = {
+    busy: boolean;
+    instance: Worker;
+    dispatch?: (message: IWorkerInitRunMessage) => Promise<void>;
+    finish?: (message: IWorkerFinishRunMessage) => Promise<void>;
+    done: boolean;
+};

package/workers/interfaces/worker-data.js

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

package/workers/interfaces/worker-message.d.ts

@@ -0,0 +1,20 @@
+import { Log } from "@rockster/logger";
+import { WorkerMessageType } from "./enum/worker-message-type";
+export interface IWorkerDoneMessage {
+    readonly type: WorkerMessageType.done;
+}
+export interface IWorkerInitRunMessage {
+    readonly type: WorkerMessageType.initRun;
+    jobName: string;
+}
+export interface IWorkerFinishRunMessage {
+    readonly type: WorkerMessageType.finishRun;
+    jobName: string;
+    error?: Error;
+}
+export interface IWorkerLogMessage {
+    readonly type: WorkerMessageType.log;
+    event: string;
+    data: Log;
+}
+export type WorkerMessage = IWorkerDoneMessage | IWorkerInitRunMessage | IWorkerFinishRunMessage | IWorkerLogMessage;

package/workers/interfaces/worker-message.js

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

package/workers/workers.controller.d.ts

@@ -0,0 +1,6 @@
+import { Logger } from "@rockster/logger";
+export declare class WorkersController {
+    protected logger: Logger;
+    init(workers: true | number): Promise<void>;
+    createWorker(): Promise<void>;
+}

package/workers/workers.controller.js

@@ -0,0 +1,72 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkersController = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const logger_1 = require("@rockster/logger");
+const os_1 = require("os");
+const worker_threads_1 = require("worker_threads");
+const decode_message_1 = require("./functions/decode-message");
+const interfaces_1 = require("./interfaces");
+const encode_message_1 = require("./functions/encode-message");
+let WorkersController = class WorkersController {
+    constructor() {
+        this.logger = new logger_1.Logger('Workers');
+    }
+    async init(workers) {
+        core.workers = [];
+        const count = workers === true
+            ? (0, os_1.cpus)().length
+            : workers;
+        for (let i = 0; i < count; i++) {
+            await this.createWorker();
+        }
+    }
+    async createWorker() {
+        return new Promise((resolve, reject) => {
+            const worker = {
+                busy: false,
+                instance: new worker_threads_1.Worker(require.main.filename),
+                done: false
+            };
+            core.workers.push(worker);
+            worker.dispatch = async (message) => {
+                const encoded = (0, encode_message_1.encodeMessage)(message);
+                worker.busy = true;
+                worker.instance.postMessage(encoded);
+            };
+            worker.instance.on('error', (err) => {
+                this.logger.error(err.message, err.stack);
+            });
+            worker.instance.on('message', (value) => {
+                const message = (0, decode_message_1.decodeMessage)(value);
+                switch (message.type) {
+                    case interfaces_1.WorkerMessageType.done:
+                        worker.done = true;
+                        this.logger.log(`Worker {${worker.instance.threadId}} successfully created`);
+                        resolve();
+                        break;
+                    case interfaces_1.WorkerMessageType.log:
+                        if (worker.done) {
+                            (0, logger_1.emitLog)(message.event, message.data);
+                        }
+                        break;
+                    case interfaces_1.WorkerMessageType.finishRun:
+                        worker.finish?.apply(this, [message]);
+                        worker.busy = false;
+                        break;
+                }
+            });
+            this.logger.log(`Creating worker {${worker.instance.threadId}}`);
+        });
+    }
+};
+exports.WorkersController = WorkersController;
+exports.WorkersController = WorkersController = __decorate([
+    (0, class_injector_1.Injectable)()
+], WorkersController);