thor-io.vnext 2.0.6 → 3.1.0-beta.1

package/build/src/Interfaces/ITransport.d.ts

@@ -0,0 +1,94 @@
+import { IncomingMessage } from 'http';
+import { ITransportMessage } from './ITransportMessage';
+/**
+ * Represents a transport interface for handling communication over various protocols.
+ * This could be used for WebSocket, HTTP, or any other transport mechanism.
+ *
+ * @export
+ * @interface ITransport
+ */
+export interface ITransport {
+    /**
+     * A unique identifier for the transport instance.
+     *
+     * @type {string}
+     * @memberOf ITransport
+     */
+    id: string;
+    /**
+     * The underlying socket or connection object used for communication.
+     *
+     * @type {*}
+     * @memberOf ITransport
+     */
+    socket: any;
+    /**
+     * The current state of the connection (e.g., open, closed, etc.).
+     * This is commonly used in WebSockets but can be adapted for other transport mechanisms.
+     *
+     * @readonly
+     * @type {number}
+     * @memberOf ITransport
+     */
+    readyState: number;
+    /**
+     * Sends data over the transport connection.
+     *
+     * @param {any} data The data to send. It can be any type, depending on the transport.
+     * @memberOf ITransport
+     */
+    send(data: any): void;
+    /**
+     * Closes the connection with a specified reason and optional message.
+     *
+     * @param {number} reason The reason code for closing the connection.
+     * @param {any} message An optional message to include with the close operation.
+     * @memberOf ITransport
+     */
+    close(reason: number, message: any): void;
+    /**
+     * Adds an event listener to the transport, e.g., for handling incoming messages or state changes.
+     *
+     * @param {string} topic The event name or topic to listen for.
+     * @param {Function} fn The callback function to invoke when the event occurs.
+     * @memberOf ITransport
+     */
+    addEventListener(topic: string, fn: Function): void;
+    /**
+     * Sends a ping message to keep the connection alive or check its status.
+     *
+     * @memberOf ITransport
+     */
+    ping(): void;
+    /**
+     * Callback function that is invoked when a message is received.
+     * This function is optional and can be defined by the implementing class.
+     *
+     * @type {(message: ITransportMessage) => void}
+     * @memberOf ITransport
+     */
+    onMessage?: (message: ITransportMessage) => void;
+    /**
+     * Callback function that is invoked when the connection is closed.
+     * This function is optional and can be defined by the implementing class.
+     *
+     * @type {(e: any) => void}
+     * @memberOf ITransport
+     */
+    onClose?: (e: any) => void;
+    /**
+     * Callback function that is invoked when the connection is established or opened.
+     * This function is optional and can be defined by the implementing class.
+     *
+     * @type {(e: any) => void}
+     * @memberOf ITransport
+     */
+    onOpen?: (e: any) => void;
+    /**
+     * The initial HTTP request (if applicable) associated with the transport connection.
+     *
+     * @type {IncomingMessage | any}
+     * @memberOf ITransport
+     */
+    request: IncomingMessage | any;
+}

package/build/src/Interfaces/ITransportMessage.d.ts

@@ -0,0 +1,41 @@
+import { TextMessage } from '../Messages/TextMessage';
+/**
+ * Represents a message that can be transported and converted to/from different formats.
+ *
+ * @export
+ * @interface ITransportMessage
+ */
+export interface ITransportMessage {
+    /**
+     * Converts the transport message into a `TextMessage` instance.
+     *
+     * @returns {TextMessage} The corresponding `TextMessage` object.
+     * @memberOf ITransportMessage
+     */
+    toMessage(): TextMessage;
+    /**
+     * Serializes the message into a `Buffer` format. Optionally accepts a `TextMessage`
+     * if the conversion needs to be done on a different message.
+     *
+     * @param {TextMessage} [message] The `TextMessage` to convert into a `Buffer`.
+     *                                 If not provided, defaults to the current `data`.
+     * @returns {Buffer} A `Buffer` containing the serialized message data.
+     * @memberOf ITransportMessage
+     */
+    toBuffer(message?: TextMessage): Buffer;
+    /**
+     * A flag indicating whether the message contains binary data.
+     *
+     * @type {boolean}
+     * @memberOf ITransportMessage
+     */
+    isBinary: boolean;
+    /**
+     * The raw data associated with the transport message. This can be in various formats
+     * such as strings, buffers, etc.
+     *
+     * @type {*}
+     * @memberOf ITransportMessage
+     */
+    data: any;
+}

package/build/src/Messages/BufferMessage.d.ts

@@ -0,0 +1,38 @@
+import { ITransportMessage } from '../Interfaces/ITransportMessage';
+import { TextMessage } from './TextMessage';
+/**
+ *
+ *
+ * @export
+ * @class BufferMessage
+ * @implements {ITransportMessage}
+ */
+export declare class BufferMessage implements ITransportMessage {
+    data: Buffer;
+    isBinary: boolean;
+    /**
+     * Creates an instance of BufferMessage.
+     *
+     * @param {Buffer} data
+     * @param {boolean} isBinary
+     *
+     * @memberOf BufferMessage
+     */
+    constructor(data: Buffer, isBinary: boolean);
+    /**
+     *
+     *
+     * @returns {TextMessage}
+     *
+     * @memberOf BufferMessage
+     */
+    toMessage(): TextMessage;
+    /**
+     *
+     *
+     * @returns {Buffer}
+     *
+     * @memberOf BufferMessage
+     */
+    toBuffer(): Buffer;
+}

package/{src → build/src}/Messages/BufferMessage.js

@@ -1,11 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BufferMessage = void 0;
 const TextMessage_1 = require("./TextMessage");
+/**
+ *
+ *
+ * @export
+ * @class BufferMessage
+ * @implements {ITransportMessage}
+ */
 class BufferMessage {
-    constructor(data, binary) {
+    /**
+     * Creates an instance of BufferMessage.
+     *
+     * @param {Buffer} data
+     * @param {boolean} isBinary
+     *
+     * @memberOf BufferMessage
+     */
+    constructor(data, isBinary) {
         this.data = data;
-        this.binary = binary;
+        this.isBinary = isBinary;
     }
+    /**
+     *
+     *
+     * @returns {TextMessage}
+     *
+     * @memberOf BufferMessage
+     */
     toMessage() {
         const headerLen = 3;
         const tLen = this.data.readUInt8(0);
@@ -20,6 +43,13 @@ class BufferMessage {
         let message = new TextMessage_1.TextMessage(topic, data, controller);
         return message;
     }
+    /**
+     *
+     *
+     * @returns {Buffer}
+     *
+     * @memberOf BufferMessage
+     */
     toBuffer() {
         let message = JSON.parse(this.data.toString());
         const header = 3;

package/build/src/Messages/ErrorMessage.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Represents an error message with a timestamp.
+ *
+ * @export
+ * @class ErrorMessage
+ */
+export declare class ErrorMessage {
+    /**
+     * The error message content.
+     *
+     * @type {string}
+     * @memberof ErrorMessage
+     */
+    message: string;
+    /**
+     * The timestamp when the error message was created.
+     *
+     * @type {Date}
+     * @memberof ErrorMessage
+     */
+    timestamp: Date;
+    /**
+     * Creates an instance of the ErrorMessage class.
+     *
+     * @param {string} message The error message content.
+     * @memberof ErrorMessage
+     */
+    constructor(message: string);
+}

package/build/src/Messages/ErrorMessage.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorMessage = void 0;
+/**
+ * Represents an error message with a timestamp.
+ *
+ * @export
+ * @class ErrorMessage
+ */
+class ErrorMessage {
+    /**
+     * Creates an instance of the ErrorMessage class.
+     *
+     * @param {string} message The error message content.
+     * @memberof ErrorMessage
+     */
+    constructor(message) {
+        this.message = message;
+        this.timestamp = new Date();
+    }
+}
+exports.ErrorMessage = ErrorMessage;

package/build/src/Messages/PipeMessage.d.ts

@@ -0,0 +1,46 @@
+import { ITransportMessage } from '../Interfaces/ITransportMessage';
+import { TextMessage } from './TextMessage';
+/**
+ * Represents a message transported via pipes, encapsulating a `TextMessage`.
+ *
+ * @export
+ * @class PipeMessage
+ * @implements {ITransportMessage}
+ */
+export declare class PipeMessage implements ITransportMessage {
+    data: any;
+    isBinary: boolean;
+    /**
+     * The encapsulated `TextMessage` instance.
+     *
+     * @private
+     * @type {TextMessage}
+     */
+    private message;
+    /**
+     * Array representation of the message components for serialization.
+     *
+     * @private
+     * @type {Array<string>}
+     */
+    private arr;
+    /**
+     * Creates an instance of `PipeMessage`.
+     *
+     * @param {*} data - The raw data representing the message.
+     * @param {boolean} isBinary - Indicates if the data is in binary format.
+     */
+    constructor(data: any, isBinary: boolean);
+    /**
+     * Serializes the `PipeMessage` to a `Buffer`.
+     *
+     * @returns {Buffer} A buffer containing the serialized message data.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Converts the `PipeMessage` back to a `TextMessage` instance.
+     *
+     * @returns {TextMessage} The encapsulated `TextMessage`.
+     */
+    toMessage(): TextMessage;
+}

package/build/src/Messages/PipeMessage.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipeMessage = void 0;
+/**
+ * Represents a message transported via pipes, encapsulating a `TextMessage`.
+ *
+ * @export
+ * @class PipeMessage
+ * @implements {ITransportMessage}
+ */
+class PipeMessage {
+    /**
+     * Creates an instance of `PipeMessage`.
+     *
+     * @param {*} data - The raw data representing the message.
+     * @param {boolean} isBinary - Indicates if the data is in binary format.
+     */
+    constructor(data, isBinary) {
+        this.data = data;
+        this.isBinary = isBinary;
+        this.message = JSON.parse(data);
+        this.arr = [this.message.C, this.message.T, this.message.D];
+    }
+    /**
+     * Serializes the `PipeMessage` to a `Buffer`.
+     *
+     * @returns {Buffer} A buffer containing the serialized message data.
+     */
+    toBuffer() {
+        return Buffer.from(this.arr.join("|"), 'utf-8');
+    }
+    /**
+     * Converts the `PipeMessage` back to a `TextMessage` instance.
+     *
+     * @returns {TextMessage} The encapsulated `TextMessage`.
+     */
+    toMessage() {
+        return this.message;
+    }
+}
+exports.PipeMessage = PipeMessage;

package/build/src/Messages/TextMessage.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Represents a text message with optional binary data.
+ *
+ * @export
+ * @class TextMessage
+ */
+export declare class TextMessage {
+    /**
+     * Binary data associated with the message (if any).
+     *
+     * @type {Buffer | undefined}
+     */
+    B: Buffer | undefined;
+    /**
+     * Topic of the message.
+     *
+     * @type {string}
+     */
+    T: string;
+    /**
+     * Data payload of the message.
+     *
+     * @type {any}
+     */
+    D: any;
+    /**
+     * Controller of the message.
+     *
+     * @type {string}
+     */
+    C: string;
+    /**
+     * Indicates whether the message contains binary data.
+     *
+     * @type {boolean}
+     */
+    isBinary: boolean;
+    /**
+     * Unique identifier for the message.
+     *
+     * @type {string}
+     */
+    I: string;
+    /**
+     * Indicates if this is the final message in a sequence.
+     *
+     * @type {boolean}
+     */
+    F: boolean;
+    /**
+     * Gets the JSON representation of the message.
+     *
+     * @readonly
+     * @type {any}
+     */
+    get JSON(): any;
+    /**
+     * Creates an instance of `TextMessage`.
+     *
+     * @param {string} topic - Topic of the message.
+     * @param {any} data - Data payload of the message.
+     * @param {string} controller - Controller of the message.
+     * @param {Buffer} [arrayBuffer] - Optional binary data.
+     * @param {string} [uuid] - Optional unique identifier.
+     * @param {boolean} [isFinal] - Indicates if this is the final message in a sequence.
+     */
+    constructor(topic: string, data: any, controller: string, arrayBuffer?: Buffer, uuid?: string, isFinal?: boolean);
+    /**
+     * Returns a string representation of the message.
+     *
+     * @returns {string} The JSON string representation of the message.
+     */
+    toString(): string;
+    /**
+     * Creates a `TextMessage` instance from a `Buffer`.
+     *
+     * @static
+     * @param {Buffer} buffer - The buffer containing the message data.
+     * @returns {TextMessage} The parsed `TextMessage` instance.
+     */
+    static fromArrayBuffer(buffer: Buffer): TextMessage;
+    /**
+     * Converts the `TextMessage` to a `Buffer`.
+     *
+     * @returns {Buffer} The buffer representation of the message.
+     */
+    toArrayBuffer(): Buffer;
+}

package/build/src/Messages/TextMessage.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextMessage = void 0;
+const BufferUtils_1 = require("../Utils/BufferUtils");
+const StringUtils_1 = require("../Utils/StringUtils");
+/**
+ * Represents a text message with optional binary data.
+ *
+ * @export
+ * @class TextMessage
+ */
+class TextMessage {
+    /**
+     * Gets the JSON representation of the message.
+     *
+     * @readonly
+     * @type {any}
+     */
+    get JSON() {
+        return {
+            T: this.T,
+            D: JSON.stringify(this.D),
+            C: this.C,
+            I: this.I,
+            F: this.F,
+        };
+    }
+    /**
+     * Creates an instance of `TextMessage`.
+     *
+     * @param {string} topic - Topic of the message.
+     * @param {any} data - Data payload of the message.
+     * @param {string} controller - Controller of the message.
+     * @param {Buffer} [arrayBuffer] - Optional binary data.
+     * @param {string} [uuid] - Optional unique identifier.
+     * @param {boolean} [isFinal] - Indicates if this is the final message in a sequence.
+     */
+    constructor(topic, data, controller, arrayBuffer, uuid, isFinal) {
+        /**
+         * Indicates whether the message contains binary data.
+         *
+         * @type {boolean}
+         */
+        this.isBinary = false;
+        this.D = data;
+        this.T = topic;
+        this.C = controller;
+        this.B = arrayBuffer;
+        this.I = uuid || StringUtils_1.StringUtils.newGuid();
+        this.F = isFinal !== null && isFinal !== void 0 ? isFinal : true; // Default to true if not provided
+        if (arrayBuffer) {
+            this.isBinary = true;
+        }
+    }
+    /**
+     * Returns a string representation of the message.
+     *
+     * @returns {string} The JSON string representation of the message.
+     */
+    toString() {
+        return JSON.stringify(this.JSON);
+    }
+    /**
+     * Creates a `TextMessage` instance from a `Buffer`.
+     *
+     * @static
+     * @param {Buffer} buffer - The buffer containing the message data.
+     * @returns {TextMessage} The parsed `TextMessage` instance.
+     */
+    static fromArrayBuffer(buffer) {
+        const headerLen = 8;
+        const header = buffer.slice(0, headerLen);
+        const payloadLength = BufferUtils_1.BufferUtils.arrayToLong(header);
+        const message = buffer.slice(headerLen, payloadLength + headerLen);
+        const blobOffset = headerLen + payloadLength;
+        const blob = buffer.slice(blobOffset, buffer.byteLength);
+        const data = JSON.parse(message.toString());
+        return new TextMessage(data.T, data.D, data.C, blob, data.I, data.F);
+    }
+    /**
+     * Converts the `TextMessage` to a `Buffer`.
+     *
+     * @returns {Buffer} The buffer representation of the message.
+     */
+    toArrayBuffer() {
+        const messagePayload = this.toString();
+        const payloadLength = messagePayload.length;
+        const header = Buffer.from(BufferUtils_1.BufferUtils.longToArray(payloadLength));
+        const message = Buffer.from(messagePayload, 'utf-8');
+        const blob = this.B ? Buffer.from(this.B) : Buffer.alloc(0);
+        return Buffer.concat([header, message, blob]);
+    }
+}
+exports.TextMessage = TextMessage;

package/build/src/Messages/WebSocketMessage.d.ts

@@ -0,0 +1,34 @@
+import { ITransportMessage } from '../Interfaces/ITransportMessage';
+import { TextMessage } from './TextMessage';
+/**
+ * Represents a WebSocket message, encapsulating data and its type (binary or text).
+ *
+ * @export
+ * @class WebSocketMessage
+ * @implements {ITransportMessage}
+ */
+export declare class WebSocketMessage implements ITransportMessage {
+    data: string;
+    isBinary: boolean;
+    /**
+     * Creates an instance of `WebSocketMessage`.
+     *
+     * @param {string} data - The raw message data as a string.
+     * @param {boolean} isBinary - Indicates whether the message is binary.
+     */
+    constructor(data: string, isBinary: boolean);
+    /**
+     * Converts the message to a `Buffer` object.
+     * **Note:** This method is not yet implemented.
+     *
+     * @throws {Error} Throws an error indicating that the method is not implemented.
+     * @returns {Buffer}
+     */
+    toBuffer(): Buffer;
+    /**
+     * Parses the raw string data and converts it into a `TextMessage` instance.
+     *
+     * @returns {TextMessage} The parsed `TextMessage` object.
+     */
+    toMessage(): TextMessage;
+}

package/build/src/Messages/WebSocketMessage.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketMessage = void 0;
+/**
+ * Represents a WebSocket message, encapsulating data and its type (binary or text).
+ *
+ * @export
+ * @class WebSocketMessage
+ * @implements {ITransportMessage}
+ */
+class WebSocketMessage {
+    /**
+     * Creates an instance of `WebSocketMessage`.
+     *
+     * @param {string} data - The raw message data as a string.
+     * @param {boolean} isBinary - Indicates whether the message is binary.
+     */
+    constructor(data, isBinary) {
+        this.data = data;
+        this.isBinary = isBinary;
+    }
+    /**
+     * Converts the message to a `Buffer` object.
+     * **Note:** This method is not yet implemented.
+     *
+     * @throws {Error} Throws an error indicating that the method is not implemented.
+     * @returns {Buffer}
+     */
+    toBuffer() {
+        throw new Error("toBuffer is not yet implemented");
+    }
+    /**
+     * Parses the raw string data and converts it into a `TextMessage` instance.
+     *
+     * @returns {TextMessage} The parsed `TextMessage` object.
+     */
+    toMessage() {
+        return JSON.parse(this.data);
+    }
+}
+exports.WebSocketMessage = WebSocketMessage;

package/build/src/Plugin.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Plugin = void 0;
+const StringUtils_1 = require("./Utils/StringUtils");
+/**
+ * Represents a plugin with a specific type.
+ * @template T The type of the plugin instance.
+ */
+class Plugin {
+    /**
+     * Creates an instance of Plugin.
+     * @param {T} object The plugin instance.
+     */
+    constructor(object) {
+        this.id = StringUtils_1.StringUtils.newGuid();
+        this.alias = Reflect.getMetadata("alias", object);
+        this.instance = object;
+        const metaData = Reflect.getMetadataKeys(object);
+        metaData.forEach(metaDataKey => {
+            console.info(`Controller settings  ${metaDataKey} = `, Reflect.getOwnMetadata(metaDataKey, object));
+        });
+        console.info(`Created the plugin with an id of ${this.id}`);
+    }
+    /**
+     * Gets the instance of the plugin.
+     * @returns {T} The plugin instance.
+     */
+    getInstance() {
+        return this.instance;
+    }
+}
+exports.Plugin = Plugin;

package/build/src/Server/Plugin.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Describes the structure of a plugin descriptor.
+ */
+export interface PluginDescriptor {
+    name: string;
+    methods: string[];
+    properties: string[];
+}
+/**
+ * Represents a plugin with a specific type.
+ * @template T The type of the plugin instance.
+ */
+export declare class Plugin<T extends Object> {
+    /**
+     * The alias of the plugin.
+     */
+    alias: string;
+    /**
+     * The instance of the plugin.
+     * @private
+     */
+    private instance;
+    /**
+     * The unique identifier of the plugin.
+     */
+    id: string;
+    /**
+     * Creates an instance of Plugin.
+     * @param {T} object The plugin instance.
+     */
+    constructor(object: T);
+    /**
+     * Gets the instance of the plugin.
+     * @returns {T} The plugin instance.
+     */
+    getInstance(): T;
+}