@machhub-dev/sdk-ts 0.0.1

package/src/services/http.service.ts

@@ -0,0 +1,239 @@
+export class HTTPException extends Error {
+    public status: number
+    public statusText: string
+    public body: string
+
+    constructor(status: number, statusText: string, body: string) {
+        super();
+        this.status = status;
+        this.statusText = statusText;
+        this.body = body;
+    }
+    
+    public get message(): string {
+        return `(EXCEPTION) ${this.statusText} - ${this.body}`
+    }
+}
+
+export class HTTPService {
+    private url: URL;
+    private applicationID: string;
+
+    constructor(url: string, prefix?: string, applicationID?:string) {
+        if (prefix == null) prefix = "";
+        this.url = new URL(prefix, url);
+        this.applicationID = "domains:" + applicationID
+    }
+
+    public get request(): RequestParameters {
+        return new RequestParameters(this.url, this.applicationID);
+    }
+}
+
+class RequestParameters {
+    private base: URL;
+    private applicationID: string;
+    public query?: Record<string, string>;
+    public init?: RequestInit;
+    public headers?: Record<string, string>;
+
+    constructor(base: URL, applicationID:string, query?: Record<string, string>) {
+        this.base = base;
+        this.applicationID = applicationID;
+        this.query = query;
+        this.withDomain(); // Ensure withDomain() is called by default
+        this.withAccessToken(); // Ensure withAccessToken() is called by default
+    }
+
+    private withQuery(path: string, query?: Record<string, string>): URL {
+        const newPath = [this.base.pathname, path].map(pathPart => pathPart.replace(/(^\/|\/$)/g, "")).join("/");
+        const newURL = new URL(newPath, this.base);
+        
+        for (const key in query) {
+            newURL.searchParams.append(key, query[key]);
+        }
+        return newURL;
+    }
+
+    private parseInit(method?: string): RequestInit | undefined {
+        if (method == null && this.headers == null) return;
+
+        let tempInit = Object.assign({}, this.init);
+        
+        if (tempInit == null) {
+            tempInit = {} as RequestInit;
+        }
+
+        if (method != null && tempInit != null) tempInit.method = method;
+
+        if (this.headers != null && tempInit != null) {
+            tempInit.headers = Object.assign({}, this.headers);
+        }
+        
+        return tempInit;
+    }
+
+    public withBody(body: BodyInit): RequestParameters {
+        if (this.init == null) {
+            this.init = {} as RequestInit;
+        }
+        this.init.body = body;
+        return this;
+    }
+
+    public includeCredentials(): RequestParameters {
+        if (this.init == null) {
+            this.init = {} as RequestInit;
+        }
+        this.init.credentials = "include";
+        return this;
+    }
+
+    public includeSameOriginCredentials(): RequestParameters {
+        if (this.init == null) {
+            this.init = {} as RequestInit;
+        }
+        this.init.credentials = "same-origin";
+        return this;
+    }
+
+    public keepAlive(): RequestParameters {
+        if (this.init == null) {
+            this.init = {} as RequestInit;
+        }
+        this.init.keepalive = true;
+        return this;
+    }
+
+    public followRedirect(): RequestParameters {
+        if (this.init == null) {
+            this.init = {} as RequestInit;
+        }
+        this.init.redirect = "follow";
+        return this;
+    }
+
+    public errorOnRedirect(): RequestParameters {
+        if (this.init == null) {
+            this.init = {} as RequestInit;
+        }
+        this.init.redirect = "error";
+        return this;
+    }
+
+    public setHeader(key: string, value: string): RequestParameters {
+        if (this.headers == null) {
+            this.headers = {
+                key: value
+            }
+        }
+        this.headers[key] = value;
+        return this;
+    }
+
+    public setBearerToken(token: string): RequestParameters {
+        this.setHeader("Authorization", `Bearer ${token}`);
+        return this;
+    }
+
+    public withAccessToken(): RequestParameters {
+        const tkn = localStorage.getItem("x-machhub-auth-tkn");
+        this.setHeader("Authorization", `Bearer ${tkn}`);
+        return this;
+    }
+
+    public withDomain(): RequestParameters {
+        this.setHeader("Domain", this.applicationID);
+        return this;
+    }
+
+    public withContentType(mime: string): RequestParameters {
+        this.setHeader("Content-Type", mime);
+        return this;
+    }
+
+    public withJSON(body: Record<string, unknown>): RequestParameters {
+        const bd = JSON.stringify(body);
+        return this.withBody(bd).withContentType("application/json");
+    }
+
+    public async get<ReturnType>(path: string, query?: Record<string, string>): Promise<ReturnType> {
+        const response = await fetch(this.withQuery(path, query), this.parseInit());
+        
+        if (!response.ok) {
+            throw new HTTPException(
+                response.status,
+                response.statusText,
+                await response.text(),
+            );
+        }
+        return response.json() as ReturnType;
+    }
+
+    public async post<ReturnType>(path: string, query?: Record<string, string>, body?: FormData | Record<string, string>): Promise<ReturnType> {
+        const init: RequestInit = this.parseInit("POST") || {};
+    
+        if (body) {
+            if (body instanceof FormData) {
+                init.body = body;
+            } else {
+                init.body = JSON.stringify(body);
+                init.headers = {
+                    ...init.headers,
+                    'Content-Type': 'application/json'
+                };
+            }
+        }
+    
+        const response = await fetch(this.withQuery(path, query), init);
+        
+        if (!response.ok) {
+            throw new HTTPException(
+                response.status,
+                response.statusText,
+                await response.text(),
+            );
+        }
+        return response.json() as ReturnType;
+    }
+    
+
+    public async put<ReturnType>(path: string, query?: Record<string, string>): Promise<ReturnType> {
+        const response = await fetch(this.withQuery(path, query), this.parseInit("PUT"));
+        
+        if (!response.ok) {
+            throw new HTTPException(
+                response.status,
+                response.statusText,
+                await response.text(),
+            );
+        }
+        return response.json() as ReturnType;
+    }
+
+    public async delete<ReturnType>(path: string, query?: Record<string, string>): Promise<ReturnType> {
+        const response = await fetch(this.withQuery(path, query), this.parseInit("DELETE"));
+        
+        if (!response.ok) {
+            throw new HTTPException(
+                response.status,
+                response.statusText,
+                await response.text(),
+            );
+        }
+        return response.json() as ReturnType;
+    }
+
+    public async patch<ReturnType>(path: string, query?: Record<string, string>): Promise<ReturnType> {
+        const response = await fetch(this.withQuery(path, query), this.parseInit("PATCH"));
+        
+        if (!response.ok) {
+            throw new HTTPException(
+                response.status,
+                response.statusText,
+                await response.text(),
+            );
+        }
+        return response.json() as ReturnType;
+    }
+}

package/src/services/mqtt.service.ts

@@ -0,0 +1,114 @@
+import mqtt from 'mqtt';
+
+interface SubscribedTopic {
+    topic: string;
+    handler: (message: unknown) => void;
+}
+
+export class MQTTService {
+    private url!: string;
+    public client!: mqtt.MqttClient;
+    private static instance: MQTTService | undefined;
+    private subscribedTopics: SubscribedTopic[] = [];
+
+    constructor(url: string) {
+        this.url = url;
+    }
+
+    static async getInstance(url: string = "ws://localhost:180"): Promise<MQTTService> {
+        if (!this.instance || !this.instance.client) {
+            this.instance = new MQTTService(url);
+
+            // Ensure the URL is set correctly
+            this.instance.url = url;
+
+            // Initialize the MQTT client
+            this.instance.client = mqtt.connect(this.instance.url, { protocolVersion: 5 });
+            this.instance.attachMessageListener();
+            // console.log("MQTT Client initialized with URL:", this.instance.url);
+        }
+        return this.instance;
+    }
+
+    // Method to reset the instance
+    public static resetInstance(): void {
+        if (this.instance) {
+            this.instance.client.end(); 
+            this.instance = undefined;
+        }
+    }
+
+    // addTopicHandler Adds a topic and handler to the subscribed list
+    public addTopicHandler(topic: string, handler: (message: unknown) => void): void {
+        try {
+            this.subscribedTopics.push({ topic, handler });
+            if (topic == "") return;
+            console.log("New Subscription Handler:", topic);
+            this.client.subscribe(topic, { qos: 2 }, (err?: unknown) => {
+                if (err) {
+                    console.error(`Failed to subscribe to topic ${topic}:`, err);
+                }
+            });
+        } catch (e) {
+            console.error(`Failed to subscribe to topic ${topic}:`, e);
+        }
+    }
+
+    // clearTopics clears all the topics subscribed to
+    public clearTopics(): void {
+        this.subscribedTopics = [];
+    }
+
+    // Publishes a message to a specific topic
+    public publish(topic: string, message: unknown): boolean {
+        try {
+            const payload = JSON.stringify(message);
+            console.log("Publishing to", topic, "with payload:", payload);
+
+            this.client.publish(topic, payload, {
+                qos: 2,
+                retain: true,
+                properties: {
+                    contentType: "json",
+                },
+            }, (err?: Error) => {
+                if (err) {
+                    console.error(`Failed to publish message to ${topic}:`, err);
+                }
+            });
+        } catch (e) {
+            console.error(`Failed to publish to topic ${topic}:`, e);
+            throw e;
+        }
+        return true;
+    }
+
+    private attachMessageListener(): void {
+        this.client.on('connect', () => {
+            console.log("MQTT connected to", this.url);
+        });
+
+        this.client.on('error', (error: Error) => {
+            console.error("MQTT connection error:", error);
+        });
+
+        this.client.on('message', (topic: string, message: Buffer) => {
+            for (const subscribedTopic of this.subscribedTopics) {
+                if (topic === subscribedTopic.topic) {
+                    const parsedMessage = this.parseMessage(message);
+                    subscribedTopic.handler(parsedMessage);
+                    break;
+                }
+            }
+        });
+    }
+
+    private parseMessage(message: Buffer): unknown {
+        try {
+            return JSON.parse(message.toString());
+        } catch (error) {
+            console.error("Error parsing message:", error);
+            return null;
+        }
+    }
+}

package/src/services/nats.service.ts

@@ -0,0 +1,262 @@
+import { NatsConnection, Subscription, wsconnect } from "@nats-io/nats-core";
+import { connect } from "@nats-io/transport-node";
+
+const HEALTH_SUBJECT = "runtime.typescript.health";
+
+interface SubscribedSubject {
+    subject: string;
+    handler: (message: unknown) => void;
+}
+
+export class NATSService {
+    private url!: string;
+    private functions: Record<string, (data: Record<string, any>) => Promise<Record<string, any>> | Record<string, any>> = {};
+    private connection: NatsConnection | null = null;
+    private static instance: NATSService | undefined;
+    private subscribedSubjects: SubscribedSubject[] = [];
+    private subscriptions: Subscription[] = [];
+    private readonly EXEC_FUNCTION_SUBJECT = "runtime.exec.typescript.*";
+
+    constructor(url: string) {
+        this.url = url;
+    }
+
+    /**
+     * Returns a singleton instance of NATSService.
+     */
+    static async getInstance(url: string = "ws://localhost:7500"): Promise<NATSService> {
+        if (!this.instance || !this.instance.connection) {
+            this.instance = new NATSService(url);
+            await this.instance.connect();
+        }
+        return this.instance;
+    }
+
+    /**
+     * Resets the singleton instance.
+     */
+    public static resetInstance(): void {
+        if (this.instance) {
+            this.instance.connection?.close();
+            this.instance = undefined;
+        }
+    }
+
+    /**
+     * Connects to the NATS broker.
+     */
+    private async connect(): Promise<void> {
+        let retries = 0;
+        const maxRetries = 10;
+
+        while (!this.connection && retries < maxRetries) {
+            try {
+                // NATSService.log(`Connecting to NATS server (${this.url})...`);
+                if (this.url.startsWith("nats")) {
+                    this.connection = await connect({ servers: this.url });
+                } else if (this.url.startsWith("ws")) {
+                    this.connection = await wsconnect({ servers: this.url });
+                } else {
+                    NATSService.log("ERROR - Unsupported protocol : ", this.url.split("://")[0]);
+                }
+                this.connection?.publish(HEALTH_SUBJECT, JSON.stringify(true));
+                // NATSService.log(`Published message: true to ${HEALTH_SUBJECT}`);
+                // NATSService.log("Connected to NATS server");
+            } catch (err: any) {
+                NATSService.log("Caught an error during connection attempt:", err); // Debugging log
+                retries++;
+                console.error(`Failed to connect to NATS server. Retrying (${retries}/${maxRetries})...`, err);
+                if (retries >= maxRetries) {
+                    throw new Error("Max retries reached. Unable to connect to NATS server.");
+                }
+                await new Promise((resolve) => setTimeout(resolve, 5000));
+            }
+        }
+
+        if (!this.connection) {
+            throw new Error("Failed to establish a connection to the NATS server.");
+        }
+    }
+
+    /**
+     * Adds a subject and handler to the subscribed list.
+     * @param subject {string} The subject to subscribe to.
+     * @param handler {(message: unknown) => void} The handler function for incoming messages.
+     */
+    public addSubjectHandler(subject: string, handler: (message: unknown) => void): void {
+        try {
+            this.subscribedSubjects.push({ subject, handler });
+            NATSService.log("New Subscription Handler:", subject);
+
+            const sub = this.connection?.subscribe(subject, {
+                callback: (err, msg) => {
+                    if (err) {
+                        console.error(`Error handling message for subject ${subject}:`, err);
+                        return;
+                    }
+                    const parsedMessage = this.parseMessage(msg.data);
+                    handler(parsedMessage);
+                },
+            });
+            if (sub) this.subscriptions.push(sub);
+        } catch (e) {
+            console.error(`Failed to subscribe to subject ${subject}:`, e);
+        }
+    }
+
+    /**
+     * Subscribes to the EXEC_FUNCTION_SUBJECT and executes registered functions.
+    */
+    public initializeFunctions(): boolean {
+        if (!this.connection) {
+            throw new Error("No active connection. Please connect to the NATS server first.");
+        }
+
+        const sub = this.connection.subscribe(this.EXEC_FUNCTION_SUBJECT, {
+            callback: (err, msg) => {
+                if (err) {
+                    console.error("Error handling message:", err);
+                    return;
+                }
+
+                const data = JSON.parse(msg.data.toString()) as Record<string, any>;
+                const subjectParts = msg.subject.split(".");
+                if (subjectParts.length !== 4) {
+                    msg.respond(JSON.stringify({ error: "Invalid subject format" }));
+                    return;
+                }
+
+                const functionName = subjectParts[3];
+                this.executeFunction(functionName, data)
+                    .then((result) => {
+                        msg.respond(JSON.stringify(result));
+                    })
+                    .catch((e: any) => {
+                        msg.respond(JSON.stringify({ status: "failed", error: e.message }));
+                    });
+            },
+        });
+        if (sub) this.subscriptions.push(sub);
+
+        NATSService.log(`Subscribed to '${this.EXEC_FUNCTION_SUBJECT}'`);
+        return true;
+    }
+
+    /**
+     * Adds a new function to the registry.
+     * @param functionName {string} The name of the function to add.
+     * @param func {(data: Record<string, any>) => Promise<Record<string, any>> | Record<string, any>} The function implementation.
+     * @throws TypeError if the provided argument is not a function.
+     */
+    public addFunction(
+        functionName: string,
+        func: (data: Record<string, any>) => Promise<Record<string, any>> | Record<string, any>
+    ): void {
+        if (typeof func !== "function") {
+            throw new TypeError(`The provided argument '${functionName}' is not a function.`);
+        }
+        this.functions[functionName] = func;
+    }
+
+    /**
+     * Executes a registered function by name with the provided arguments.
+     * @param functionName {string} The name of the function to execute.
+     * @param arg {Record<string, any>} The arguments to pass to the function. (JSON)
+     * @returns {Promise<Record<string, any>>} The result of the function execution. (JSON)
+     * @throws Error if the function is not found.
+     */
+    public async executeFunction(
+        functionName: string,
+        arg: Record<string, any>
+    ): Promise<Record<string, any>> {
+        const func = this.functions[functionName];
+        if (!func) {
+            throw new Error(`Function '${functionName}' not found`);
+        }
+
+        return await func(arg);
+    }
+
+    /**
+     * Clears all subscribed subjects.
+     */
+    public clearSubjects(): void {
+        this.subscribedSubjects = [];
+    }
+
+    /**
+     * Publishes a message to a specific subject.
+     * @param subject {string} The subject to publish to.
+     * @param message {unknown} The message to publish.
+     * @returns {boolean} True if the message was published successfully.
+     */
+    public publish(subject: string, message: unknown): boolean {
+        try {
+            const payload = JSON.stringify(message);
+            NATSService.log("Publishing to", subject, "with payload:", payload);
+
+            this.connection?.publish(subject, payload);
+        } catch (e) {
+            console.error(`Failed to publish to subject ${subject}:`, e);
+            throw e;
+        }
+        return true;
+    }
+
+    /**
+     * Retrieves all registered functions.
+     * @returns {Record<string, (data: Record<string, any>) => Record<string, any>} An object containing all registered functions.
+     */
+    public getAllFunctions(): Record<string, (data: Record<string, any>) => Record<string, any>> {
+        return this.functions;
+    }
+
+    public static log(message?: any, ...optionalParams: any[]) {
+        console.log("[TYPESCRIPT] >", message, ...optionalParams);
+    }
+
+    /**
+     * Prints the names of all available functions to the console.
+     */
+    public printFunctions(): void {
+        NATSService.log("Available functions: ", Object.keys(this.functions).join(", "));
+    }
+
+    /**
+     * Parses a message buffer into a JSON object.
+     * @param message {Uint8Array} The message buffer.
+     * @returns {unknown} The parsed message.
+     */
+    private parseMessage(message: Uint8Array): unknown {
+        try {
+            return JSON.parse(Buffer.from(message).toString());
+        } catch (error) {
+            console.error("Error parsing message:", error);
+            return null;
+        }
+    }
+
+    /**
+     * Gracefully unsubscribes from all NATS subscriptions and closes the connection.
+     */
+    public async shutdown(): Promise<void> {
+        NATSService.log("Shutting down NATSService...");
+        for (const sub of this.subscriptions) {
+            try {
+                sub.unsubscribe();
+            } catch (e) {
+                NATSService.log("Error unsubscribing:", e);
+            }
+        }
+        this.subscriptions = [];
+        if (this.connection) {
+            try {
+                await this.connection.drain();
+                await this.connection.close();
+            } catch (e) {
+                NATSService.log("Error closing NATS connection:", e);
+            }
+        }
+        NATSService.log("NATSService shutdown complete.");
+    }
+}