thor-io.vnext 2.0.5-beta.3 → 3.1.0-beta.1

package/src/Server/ThorIOServer.ts

@@ -0,0 +1,121 @@
+import * as net from 'net';
+
+import { Connection } from '../Connection/Connection';
+import { ControllerBase } from '../Controller/ControllerBase';
+import { ITransport } from '../Interfaces/ITransport';
+import { Plugin } from '../Server/Plugin';
+import {
+  WebSocketMessageTransport,
+} from '../Transports/WebSocketMessageTransport';
+
+/**
+ * ThorIOServer server class for managing connections and controllers.
+ */
+export class ThorIOServer {
+    /**
+     * An array of plugins containing registered controllers.
+     */
+    private controllers: Map<string, Plugin<ControllerBase>>;
+    /**
+     * A Map of connections indexed by their ID.
+     */
+    private connections: Map<string, Connection>;
+    /**
+     * An array of active net.Server instances representing endpoints.
+     */
+    private endpoints: Array<net.Server>;
+    /**
+     * (Optional) Interceptors for custom logic during communication.
+     */
+    interceptors: any;
+
+    /**
+     * Creates a new instance of ThorIOServer.
+     *
+     * @param {Array<ControllerBase>} controllers An array of controllers to register.
+     * @returns {ThorIOServer} A new ThorIOServer instance.
+     */
+    static createInstance(controllers: Array<any>): ThorIOServer {
+        return new ThorIOServer(controllers);
+    }
+
+    /**
+     * Constructor for ThorIOServer.
+     *
+     * @param {Array<ControllerBase>} controllers An array of controllers to register.
+     */
+    constructor(controllers: Array<ControllerBase>) {
+        this.endpoints = new Array<net.Server>();
+        this.connections = new Map<string, Connection>();
+        this.controllers = new Map<string, Plugin<ControllerBase>>();
+        controllers.forEach((ctrl: ControllerBase) => {
+            if (!Reflect.hasOwnMetadata("alias", ctrl)) {
+                throw "Failed to register one of the specified Controllers, missing ControllerProperties alias attribute";
+            } else {
+                console.log(`Starting registering the '${Reflect.getMetadata("alias", ctrl)}' controller.`);
+            }
+            const plugin = new Plugin<ControllerBase>(ctrl as ControllerBase);
+            this.controllers.set(Reflect.getMetadata("alias", ctrl), plugin);
+        });
+    }
+
+    /**
+     * Removes a connection from the server.
+     *
+     * @param {string} id The ID of the connection to remove.
+     * @param {number} reason The reason for removing the connection.
+     */
+    removeConnection(id: string, reason: number): void {
+        try {
+            this.connections.delete(id);
+        }
+        catch (error) {
+            console.warn(`Failed to delete a connection with id ${id}, reason: ${reason}`);
+        }
+    }
+
+    /**
+     * Adds a new endpoint to the server using the specified transport type, host, and port.
+     *
+     * @param {new (...args: any[]) => ITransport} typeOfTransport A constructor function for the transport type.
+     * @param {string} host The hostname or IP address to listen on.
+     * @param {number} port The port number to listen on.
+     * @returns {net.Server} The created net.Server instance.
+     */
+    addEndpoint(typeOfTransport: { new(...args: any[]): ITransport; }, host: string, port: number): net.Server {
+        const endpoint = net.createServer((socket: net.Socket) => {
+            const transport = new typeOfTransport(socket);
+            this.addConnection(transport);
+        });
+        endpoint.listen(port, host, ((listener: any) => {
+            // do op
+        }));
+        this.endpoints.push(endpoint);
+        return endpoint;
+    }
+
+    /**
+     * Adds a WebSocket connection to the server.
+     *
+     * @param {any} ws The WebSocket object.
+     * @param {any} req The request object (if applicable).
+     */
+    addWebSocket(ws: any, req: any): void {
+        const transport = new WebSocketMessageTransport(ws, req);
+        this.addConnection(transport);
+    }
+
+    /**
+     * Adds a new connection to the server's internal state.
+     *
+     * @param {ITransport} transport The transport object representing the connection.
+     */
+    private addConnection(transport: ITransport): void {
+        transport.addEventListener("close", (reason: number) => {
+            if (transport.onClose)
+                transport.onClose(reason);
+            this.removeConnection(transport.id, reason);
+        });
+        this.connections.set(transport.id, new Connection(transport, this.connections, this.controllers));
+    }
+}

package/src/ThorIOServer.ts

@@ -0,0 +1,117 @@
+import * as net from 'net';
+
+import { Connection } from './Connection/Connection';
+import { ControllerBase } from './Controller/ControllerBase';
+import { ITransport } from './Interfaces/ITransport';
+import { Plugin } from './Server/Plugin';
+import {
+  WebSocketMessageTransport,
+} from './Transports/WebSocketMessageTransport';
+
+/**
+ * ThorIOServer server class for managing connections and controllers.
+ */
+export class ThorIOServer {
+    /**
+     * An array of plugins containing registered controllers.
+     */
+    private controllers: Map<string, Plugin<ControllerBase>>;
+    /**
+     * A Map of connections indexed by their ID.
+     */
+    private connections: Map<string, Connection>;
+    /**
+     * An array of active net.Server instances representing endpoints.
+     */
+    private endpoints: Array<net.Server>;
+
+    /**
+     * Creates a new instance of ThorIOServer.
+     *
+     * @param {Array<ControllerBase>} controllers An array of controllers to register.
+     * @returns {ThorIOServer} A new ThorIOServer instance.
+     */
+    static createInstance(controllers: Array<any>): ThorIOServer {
+        return new ThorIOServer(controllers);
+    }
+
+    /**
+     * Constructor for ThorIOServer.
+     *
+     * @param {Array<ControllerBase>} controllers An array of controllers to register.
+     */
+    constructor(controllers: Array<ControllerBase>) {
+        this.endpoints = new Array<net.Server>();
+        this.connections = new Map<string, Connection>();
+        this.controllers = new Map<string, Plugin<ControllerBase>>();
+        controllers.forEach((ctrl: ControllerBase) => {
+            if (!Reflect.hasOwnMetadata("alias", ctrl)) {
+                throw "Failed to register one of the specified Controllers, missing ControllerProperties alias attribute";
+            } else {
+                console.log(`Starting registering the '${Reflect.getMetadata("alias", ctrl)}' controller.`);
+            }
+            const plugin = new Plugin<ControllerBase>(ctrl as ControllerBase);
+            this.controllers.set(Reflect.getMetadata("alias", ctrl), plugin);
+        });
+    }
+
+    /**
+     * Removes a connection from the server.
+     *
+     * @param {string} id The ID of the connection to remove.
+     * @param {number} reason The reason for removing the connection.
+     */
+    removeConnection(id: string, reason: number): void {
+        try {
+            this.connections.delete(id);
+        }
+        catch (error) {
+            console.warn(`Failed to delete a connection with id ${id}, reason: ${reason}`);
+        }
+    }
+
+    /**
+     * Adds a new endpoint to the server using the specified transport type, host, and port.
+     *
+     * @param {new (...args: any[]) => ITransport} typeOfTransport A constructor function for the transport type.
+     * @param {string} host The hostname or IP address to listen on.
+     * @param {number} port The port number to listen on.
+     * @returns {net.Server} The created net.Server instance.
+     */
+    addEndpoint(typeOfTransport: { new(...args: any[]): ITransport; }, host: string, port: number): net.Server {
+        const endpoint = net.createServer((socket: net.Socket) => {
+            const transport = new typeOfTransport(socket);
+            this.addConnection(transport);
+        });
+        endpoint.listen(port, host, ((listener: any) => {
+            // do op
+        }));
+        this.endpoints.push(endpoint);
+        return endpoint;
+    }
+
+    /**
+     * Adds a WebSocket connection to the server.
+     *
+     * @param {any} ws The WebSocket object.
+     * @param {any} req The request object (if applicable).
+     */
+    addWebSocket(ws: any, req: any): void {
+        const transport = new WebSocketMessageTransport(ws, req);
+        this.addConnection(transport);
+    }
+
+    /**
+     * Adds a new connection to the server's internal state.
+     *
+     * @param {ITransport} transport The transport object representing the connection.
+     */
+    private addConnection(transport: ITransport): void {
+        transport.addEventListener("close", (reason: number) => {
+            if (transport.onClose)
+                transport.onClose(reason);
+            this.removeConnection(transport.id, reason);
+        });
+        this.connections.set(transport.id, new Connection(transport, this.connections, this.controllers));
+    }
+}

package/src/Transports/BufferMessageTransport.ts

@@ -1,100 +1,109 @@
-import * as net from 'net';
-import { ITransport } from '../Interfaces/ITransport';
-import { ITransportMessage } from '../Interfaces/ITransportMessage';
-import { BufferMessage } from '../Messages/BufferMessage';
-import { StringUtils } from '../Utils/StringUtils';
-import { IInterceptor } from '../Interfaces/IInterceptor';
-import { IncomingMessage } from 'http';
-/**
- *
- *
- * @export
- * @class BufferMessageTransport
- * @implements {ITransport}
- */
-export class BufferMessageTransport implements ITransport {
- 
-    /**
-     *
-     *
-     * @type {string}
-     * @memberOf BufferMessageTransport
-     */
-    id: string;
-    /**
-     *
-     *
-     *
-     * @memberOf BufferMessageTransport
-     */
-    onMessage: (messsage: ITransportMessage) => void;
-    /**
-     * Creates an instance of BufferMessageTransport.
-     *
-     * @param {net.Socket} socket
-     *
-     * @memberOf BufferMessageTransport
-     */
-    constructor(public socket: net.Socket) {
-        this.id = StringUtils.newGuid();
-        this.socket.addListener("data", (buffer: Buffer) => {
-            let bm = new BufferMessage(buffer, false);
-            this.onMessage(bm);
-        });
-    }
-    request: IncomingMessage | any;
-    interceptors: Map<string, IInterceptor>;
-    onClose: () => void;
-    onOpen: () => void;
-    /**
-     *
-     *
-     * @readonly
-     *
-     * @memberOf BufferMessageTransport
-     */
-    get readyState() {
-        return 1;
-    }
-    /**
-     *
-     *
-     * @param {string} data
-     *
-     * @memberOf BufferMessageTransport
-     */
-    send(data: string) {
-        let bm = new BufferMessage(new Buffer(data), false);
-        this.socket.write(bm.toBuffer());
-    }
-    /**
-     *
-     *
-     * @param {string} name
-     * @param {Function} fn
-     *
-     * @memberOf BufferMessageTransport
-     */
-    addEventListener(name: string, fn: any) {
-        this.socket.addListener(name, fn);
-    }
-    /**
-     *
-     *
-     * @returns
-     *
-     * @memberOf BufferMessageTransport
-     */
-    ping() {
-        return;
-    }
-    /**
-     *
-     *
-     *
-     * @memberOf BufferMessageTransport
-     */
-    close() {
-        this.socket.destroy();
-    }
-}
+import { IncomingMessage } from 'http';
+import * as net from 'net';
+
+import { ITransport } from '../Interfaces/ITransport';
+import { ITransportMessage } from '../Interfaces/ITransportMessage';
+import { BufferMessage } from '../Messages/BufferMessage';
+import { StringUtils } from '../Utils/StringUtils';
+
+/**
+ * A transport implementation for handling buffer-based messages over a socket.
+ *
+ * @export
+ * @class BufferMessageTransport
+ * @implements {ITransport}
+ */
+export class BufferMessageTransport implements ITransport {
+    /**
+     * Unique identifier for this transport instance.
+     *
+     * @type {string}
+     */
+    id: string;
+
+    /**
+     * Event handler for receiving transport messages.
+     *
+     * @type {(message: ITransportMessage) => void}
+     */
+    onMessage: (message: ITransportMessage) => void = (message: BufferMessage) => { };
+
+    /**
+     * The underlying socket used for communication.
+     *
+     * @type {net.Socket}
+     */
+    constructor(public socket: net.Socket) {
+        this.id = StringUtils.newGuid();
+        this.socket.addListener("data", (buffer: Buffer) => {
+            const bm = new BufferMessage(buffer, false);
+            this.onMessage(bm);
+        });
+    }
+
+    /**
+     * The incoming HTTP request associated with the transport (if any).
+     *
+     * @type {IncomingMessage | any}
+     */
+    request: IncomingMessage | any;
+
+
+    /**
+     * Event handler for when the transport connection is closed.
+     *
+     * @type {() => void}
+     */
+    onClose: () => void = () => { };
+
+    /**
+     * Event handler for when the transport connection is opened.
+     *
+     * @type {() => void}
+     */
+    onOpen: () => void = () => { };
+
+    /**
+     * The ready state of the transport connection.
+     *
+     * @readonly
+     * @type {number}
+     */
+    get readyState() {
+        return 1; // Open
+    }
+
+    /**
+     * Sends a string message over the transport.
+     *
+     * @param {string} data - The message to send.
+     */
+    send(data: string) {
+        const bm = new BufferMessage(Buffer.from(data), false);
+        this.socket.write(bm.toBuffer());
+    }
+
+    /**
+     * Adds an event listener to the underlying socket.
+     *
+     * @param {string} name - The name of the event.
+     * @param {Function} fn - The callback function to invoke when the event occurs.
+     */
+    addEventListener(name: string, fn: any) {
+        this.socket.addListener(name, fn);
+    }
+
+    /**
+     * Sends a ping message (no-op for this transport).
+     */
+    ping() {
+        return;
+    }
+
+    /**
+     * Closes the transport connection and destroys the socket.
+     */
+    close() {
+        this.socket.destroy();
+    }
+}

package/src/Transports/PipeMessageTransport.ts

@@ -1,104 +1,112 @@
-import { ITransport } from '../Interfaces/ITransport';
-import { PipeMessage } from '../Messages/PipeMessage';
-import * as net from 'net';
-import { StringUtils } from '../Utils/StringUtils';
-import { TextMessage } from '../Messages/TextMessage';
-import { IInterceptor } from '../Interfaces/IInterceptor';
-import { IncomingMessage } from 'http';
-/**
- *
- *
- * @export
- * @class PipeMessageTransport
- * @implements {ITransport}
- */
-export class PipeMessageTransport implements ITransport {
-  
-    /**
-     *
-     *no
-     * @type {string}
-     * @memberOf PipeMessageTransport
-     */
-    id: string;
-    /**
-     *
-     *
-     *
-     * @memberOf PipeMessageTransport
-     */
-    onMessage: (message: PipeMessage) => void;
-    /**
-     *
-     *
-     * @param {*} data
-     *
-     * @memberOf PipeMessageTransport
-     */
-    send(data: any) {
-        let message = new PipeMessage(data, false);
-        this.socket.write(message.toBuffer());
-    }
-    /**
-     *
-     *
-     * @param {number} reason
-     * @param {*} message
-     *
-     * @memberOf PipeMessageTransport
-     */
-    close(reason: number, message: any) {
-        this.socket.destroy();
-    }
-    /**
-     *
-     *
-     * @param {string} name
-     * @param {Function} fn
-     *
-     * @memberOf PipeMessageTransport
-     */
-    addEventListener(name: string, fn: any) {
-        this.socket.addListener(name, fn);
-    }
-    /**
-     *
-     *
-     * @readonly
-     * @type {number}
-     * @memberOf PipeMessageTransport
-     */
-    get readyState(): number {
-        return 1;
-    }
-    /**
-     *
-     *
-     * @returns
-     *
-     * @memberOf PipeMessageTransport
-     */
-    ping() {
-        return;
-    }
-    /**
-     * Creates an instance of PipeMessageTransport.
-     *s
-     * @param {net.Socket} socket
-     *
-     * @memberOf PipeMessageTransport
-     */
-    constructor(public socket: net.Socket) {
-        this.id = StringUtils.newGuid();
-        socket.addListener("data", (buffer: Buffer) => {
-            let args = buffer.toString().split("|");
-            let message = new TextMessage(args[1], args[2], args[0]);
-            this.onMessage(new PipeMessage(message.toString(), false));
-        });
-        
-    }
-    request: any;
-    interceptors: Map<string, IInterceptor>;
-    onClose: () => void;
-    onOpen: () => void;
-}
+import * as net from 'net';
+
+import { ITransport } from '../Interfaces/ITransport';
+import { PipeMessage } from '../Messages/PipeMessage';
+import { TextMessage } from '../Messages/TextMessage';
+import { StringUtils } from '../Utils/StringUtils';
+
+/**
+ * A transport implementation for handling pipe-based messages over a socket.
+ *
+ * @export
+ * @class PipeMessageTransport
+ * @implements {ITransport}
+ */
+export class PipeMessageTransport implements ITransport {
+    /**
+     * Unique identifier for this transport instance.
+     *
+     * @type {string}
+     */
+    id: string;
+
+    /**
+     * Event handler for receiving transport messages.
+     *
+     * @type {(message: any) => void}
+     */
+    onMessage: (message: any) => void = () => { };
+
+    /**
+     * Sends data over the transport.
+     *
+     * @param {any} data - The data to send.
+     */
+    send(data: any) {
+        const message = new PipeMessage(data, false);
+        this.socket.write(message.toBuffer());
+    }
+
+    /**
+     * Closes the transport connection and destroys the socket.
+     *
+     * @param {number} reason - The reason code for closing the connection.
+     * @param {any} message - An optional message describing the closure.
+     */
+    close(reason: number, message: any) {
+        this.socket.destroy();
+    }
+
+    /**
+     * Adds an event listener to the underlying socket.
+     *
+     * @param {string} name - The name of the event.
+     * @param {Function} fn - The callback function to invoke when the event occurs.
+     */
+    addEventListener(name: string, fn: any) {
+        this.socket.addListener(name, fn);
+    }
+
+    /**
+     * The ready state of the transport connection.
+     *
+     * @readonly
+     * @type {number}
+     */
+    get readyState(): number {
+        return 1; // Open
+    }
+
+    /**
+     * Sends a ping message (no-op for this transport).
+     */
+    ping() {
+        return;
+    }
+
+    /**
+     * Creates an instance of PipeMessageTransport.
+     *
+     * @param {net.Socket} socket - The underlying socket used for communication.
+     */
+    constructor(public socket: net.Socket) {
+        this.id = StringUtils.newGuid();
+        socket.addListener("data", (buffer: Buffer) => {
+            const args = buffer.toString().split("|");
+            const message = new TextMessage(args[1], args[2], args[0]);
+            this.onMessage(new PipeMessage(message.toString(), false));
+        });
+    }
+
+    /**
+     * The incoming request associated with the transport (if any).
+     *
+     * @type {any}
+     */
+    request: any;
+
+  
+    /**
+     * Event handler for when the transport connection is closed.
+     *
+     * @type {() => void}
+     */
+    onClose: () => void = () => { };
+
+    /**
+     * Event handler for when the transport connection is opened.
+     *
+     * @type {() => void}
+     */
+    onOpen: () => void = () => { };
+}