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

package/src/{Subscription.ts → Controller/Subscription.ts}

@@ -1,34 +1,32 @@
-/**
- *
- *
- * @export
- * @class Subscription
- */
-export class Subscription {
-    /**
-     *
-     *
-     * @type {string}
-     * @memberOf Subscription
-     */
-    public topic: string;
-    /**
-     *
-     *
-     * @type {string}
-     * @memberOf Subscription
-     */
-    public controller: string;
-    /**
-     * Creates an instance of Subscription.
-     *
-     * @param {string} topic
-     * @param {string} controller
-     *
-     * @memberOf Subscription
-     */
-    constructor(topic: string, controller: string) {
-        this.topic = topic;
-        this.controller = controller;
-    }
-}
+/**
+ * Represents a subscription to a specific topic with an associated controller.
+ *
+ * @export
+ * @class Subscription
+ */
+export class Subscription {
+    /**
+     * The topic of the subscription.
+     *
+     * @type {string}
+     */
+    public topic: string;
+
+    /**
+     * The controller associated with the subscription.
+     *
+     * @type {string}
+     */
+    public controller: string;
+
+    /**
+     * Creates an instance of Subscription.
+     *
+     * @param {string} topic - The topic of the subscription.
+     * @param {string} controller - The controller associated with the subscription.
+     */
+    constructor(topic: string, controller: string) {
+        this.topic = topic;
+        this.controller = controller;
+    }
+}

package/src/Controllers/BrokerController/BrokerController.ts

@@ -0,0 +1,121 @@
+import { Connection } from '../../Connection/Connection';
+import { ControllerBase } from '../../Controller/ControllerBase';
+import { CanInvoke } from '../../Decorators/CanInvoke';
+import { ControllerProperties } from '../../Decorators/ControllerProperties';
+import { StringUtils } from '../../Utils/StringUtils';
+import { PeerConnection } from './Models/PeerConnection';
+import { Signal } from './Models/Signal';
+
+/**
+ * BrokerController class for managing peer connections and signals.
+ */
+@ControllerProperties("contextBroker", 7500)
+export class BrokerController extends ControllerBase {
+    /**
+     * An array of peer connections.
+     */
+    public Connections: Array<PeerConnection>;
+
+    /**
+     * The current peer connection.
+     */
+    public Peer: PeerConnection;
+
+    /**
+     * The local peer ID.
+     */
+    public localPeerId: string = "";
+
+    /**
+     * Creates an instance of BrokerController.
+     * @param {Connection} connection The connection instance.
+     */
+    constructor(connection: Connection) {
+        super(connection);
+        this.Connections = [];
+        this.Peer = new PeerConnection(StringUtils.newGuid(), connection.id);
+    }
+
+    [key: string]: any;
+
+    /**
+     * Called when the connection is opened.
+     */
+    onopen() {
+        this.invoke(this.Peer, "contextCreated", this.alias);
+    }
+
+    
+    @CanInvoke(true)
+    transcribe(data: {phrase: string,sourceLanguage:string}) {
+        if(!this.generateSubtitles()) {
+            return;
+        }
+        console.log(`Transcribing ${data.phrase} from ${data.sourceLanguage} to ${this.Peer.language}`);
+    }
+
+    private generateSubtitles(): boolean{
+        return this.Peer.language != undefined
+    }
+
+    /**
+     * Sends an instant message to peers.
+     * @param {any} data The message data.
+     */
+    @CanInvoke(true)
+    instantMessage(data: any) {
+        const expression = (pre: BrokerController) => {
+            return pre.Peer!.context >= this.Peer!.context;
+        };
+        this.invokeTo<BrokerController>(expression, data, "instantMessage", this.alias);
+    }
+
+    /**
+     * Changes the context of the current peer.
+     * @param {PeerConnection} change The new peer connection context.
+     */
+    @CanInvoke(true)
+    changeContext(change: PeerConnection) {
+        this.Peer!.context = change.context;
+        this.invoke(this.Peer, "contextChanged", this.alias);
+    }
+
+    /**
+     * Sends a signal to a specific peer.
+     * @param {Signal} signal The signal data.
+     */
+    @CanInvoke(true)
+    contextSignal(signal: Signal) {
+        const expression = (pre: BrokerController) => {
+            return pre.connection.id === signal.recipient;
+        };
+        this.invokeTo(expression, signal, "contextSignal", this.alias);
+    }
+
+    /**
+     * Connects to peers in the same context.
+     */
+    @CanInvoke(true)
+    connectContext() {
+        const connections = this.getPeerConnections(this.Peer!)
+            .map((p: BrokerController) => {
+                return p.Peer;
+            });
+
+        this.invoke(connections, "connectTo", this.alias);
+    }
+
+    /**
+     * Gets peer connections in the same context.
+     * @param {PeerConnection} peerConnection The current peer connection.
+     * @returns {Array<BrokerController>} An array of matching peer controllers.
+     */
+    getPeerConnections(peerConnection: PeerConnection): Array<BrokerController> {
+        const match = this.findOn<BrokerController>(this.alias, (pre: BrokerController) => {
+            return (pre.Peer!.context === this.Peer!.context && pre.Peer!.peerId !== peerConnection.peerId);
+        }) as Array<BrokerController>;
+        return match ? match : new Array<BrokerController>();
+    }
+
+    
+}

package/src/Controllers/BrokerController/Models/PeerConnection.ts

@@ -1,34 +1,12 @@
-/**
- *
- *
- * @export
- * @class PeerConnection
- */
-export class PeerConnection {
-    /**
-     *
-     *
-     * @type {string}
-     * @memberOf PeerConnection
-     */
-    context: string;
-    /**
-     *
-     *
-     * @type {string}
-     * @memberOf PeerConnection
-     */
-    peerId: string;
-    /**
-     * Creates an instance of PeerConnection.
-     *
-     * @param {string} [context]
-     * @param {string} [peerId]
-     *
-     * @memberOf PeerConnection
-     */
-    constructor(context?: string, peerId?: string) {
-        this.context = context;
-        this.peerId = peerId;
-    }
-}
+export class PeerConnection {
+    context: string;  // The context for the peer connection (e.g., a session or room).
+    peerId: string = ""; // The unique identifier for the peer. Defaults to an empty string.
+    language: string | undefined;
+    constructor(context: string, peerId: string) {
+        this.context = context;  // Initializes the context of the connection.
+        this.peerId = peerId;    // Initializes the peer's unique identifier.
+    }
+    setLanguage(language: string) {
+        this.language = language;
+    }
+}

package/src/Controllers/BrokerController/Models/Signal.ts

@@ -1,43 +1,11 @@
-/**
- *
- *
- * @export
- * @class Signal
- */
-export class Signal {
-    /**
-     *
-     *
-     * @type {string}
-     * @memberOf Signal
-     */
-    recipient: string;
-    /**
-     *
-     *
-     * @type {string}
-     * @memberOf Signal
-     */
-    sender: string;
-    /**
-     *
-     *
-     * @type {string}
-     * @memberOf Signal
-     */
-    message: string;
-    /**
-     * Creates an instance of Signal.
-     *
-     * @param {string} recipient
-     * @param {string} sender
-     * @param {string} message
-     *
-     * @memberOf Signal
-     */
-    constructor(recipient: string, sender: string, message: string) {
-        this.recipient = recipient;
-        this.sender = sender;
-        this.message = message;
-    }
-}
+export class Signal {
+    recipient: string;  // The recipient of the signal
+    sender: string;     // The sender of the signal
+    message: string;    // The content of the signal/message
+
+    constructor(recipient: string, sender: string, message: string) {
+        this.recipient = recipient;  // Initializes the recipient
+        this.sender = sender;        // Initializes the sender
+        this.message = message;      // Initializes the message
+    }
+}

package/src/Decorators/CanInvoke.ts

@@ -1,13 +1,21 @@
-import 'reflect-metadata';
-/**
- *
- *
- * @export
- * @param {boolean} state
- * @returns
- */
-export function CanInvoke(state: boolean, alias?: string) {
-    return function (target, propertyKey: string, descriptor: PropertyDescriptor) {
-        Reflect.defineMetadata("canInvokeOrSet", state, target, propertyKey);
-    };
-}
+import 'reflect-metadata';
+
+/**
+ * A decorator to define whether a method can be invoked, with optional alias support.
+ *
+ * @param state Boolean indicating whether the method can be invoked.
+ * @param alias Optional alias for the method.
+ *
+ * @returns A function that adds metadata to the method.
+ */
+export function CanInvoke(state: boolean, alias?: string) {
+  return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+    // Define metadata for whether the method can be invoked
+    Reflect.defineMetadata("canInvoke", state, target, propertyKey);
+    
+    // Optionally add an alias if provided
+    if (alias) {
+      Reflect.defineMetadata("alias", alias, target, propertyKey);
+    }
+  };
+}

package/src/Decorators/CanSet.ts

@@ -1,12 +1,19 @@
-/**
- *
- *
- * @export
- * @param {boolean} state
- * @returns
- */
-export function CanSet(state: boolean) {
-    return function (target: Object, propertyKey: string) {
-        Reflect.defineMetadata("canInvokeOrSet", state, target, propertyKey);
-    };
-}
+import 'reflect-metadata';
+
+/**
+ * A decorator that attaches metadata to a property indicating whether it can be set or get.
+ *
+ * @param canSet Boolean indicating if the property can be set.
+ * @param canGet Optional boolean indicating if the property can be gotten (defaults to `canSet` if not provided).
+ *
+ * @returns A function that adds metadata to the property.
+ */
+export function CanSetGet(canSet: boolean, canGet?: boolean) {
+    return function (target: Object, propertyKey: string) {
+        // Attach 'canSet' metadata
+        Reflect.defineMetadata("canSet", canSet, target, propertyKey);
+        
+        // Attach 'canGet' metadata, defaulting to 'canSet' if not provided
+        Reflect.defineMetadata("canGet", canGet ?? canSet, target, propertyKey);
+    };
+}

package/src/Decorators/ControllerProperties.ts

@@ -1,16 +1,19 @@
-/**
- *
- *
- * @export
- * @param {string} alias
- * @param {boolean} [seald]
- * @param {number} [heartbeatInterval]
- * @returns
- */
-export function ControllerProperties(alias: string, seald?: boolean, heartbeatInterval?: number) {
-    return function (target: Function) {
-        Reflect.defineMetadata("seald", seald || false, target);
-        Reflect.defineMetadata("alias", alias, target);
-        Reflect.defineMetadata("heartbeatInterval", heartbeatInterval || -1, target);
-    };
-}
+import 'reflect-metadata';
+
+/**
+ * A decorator to attach custom metadata to a controller class.
+ *
+ * @param alias The alias for the controller (used for routing or identification).
+ * @param heartbeatInterval Optional interval in milliseconds for the heartbeat. Defaults to -1.
+ *
+ * @returns A function that adds metadata to the target class.
+ */
+export function ControllerProperties(alias: string, heartbeatInterval?: number) {
+    return function (target: Function) {
+        // Attach alias to the class
+        Reflect.defineMetadata("alias", alias, target);
+        
+        // Attach heartbeat interval to the class (default to -1 if not provided)
+        Reflect.defineMetadata("heartbeatInterval", heartbeatInterval ?? -1, target);
+    };
+}

package/src/Interfaces/ITransport.ts

@@ -1,23 +1,107 @@
-import { ITransportMessage } from "./ITransportMessage";
-import { IInterceptor } from "./IInterceptor";
-import { IncomingMessage } from 'http';
-/**
- *
- *
- * @export
- * @interface ITransport
- */
-export interface ITransport {
-    id: string;
-    socket: any;
-    readyState: number;
-    send(data: any):void;
-    close(reason: number, message: any):void;
-    addEventListener(topic: string, fn: Function):void;
-    ping():void;
-    onMessage: (message: ITransportMessage) => void;
-    onClose: (e: any) => void;
-    onOpen: (e: any) => void;
-    interceptors: Map<string,IInterceptor>;
-    request:IncomingMessage | any ;
-}
+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/src/Interfaces/ITransportMessage.ts

@@ -1,41 +1,45 @@
-import { TextMessage } from "../Messages/TextMessage";
-
-/**
- *
- *
- * @export
- * @interface ITransportMessage
- */
-export interface ITransportMessage {
-    /**
-     *
-     *
-     * @returns {TextMessage}
-     *
-     * @memberOf ITransportMessage
-     */
-    toMessage(): TextMessage;
-    /**
-     *
-     *
-     * @param {TextMessage} [message]
-     * @returns {Buffer}
-     *
-     * @memberOf ITransportMessage
-     */
-    toBuffer(message?: TextMessage): Buffer;
-    /**
-     *
-     *
-     * @type {boolean}
-     * @memberOf ITransportMessage
-     */
-    binary: boolean;
-    /**
-     *
-     *
-     * @type {*}
-     * @memberOf ITransportMessage
-     */
-    data: any;
-}
+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;
+}