@machhub-dev/sdk-ts 0.0.1

package/dist/cjs/services/http.service.d.ts

@@ -0,0 +1,41 @@
+export declare class HTTPException extends Error {
+    status: number;
+    statusText: string;
+    body: string;
+    constructor(status: number, statusText: string, body: string);
+    get message(): string;
+}
+export declare class HTTPService {
+    private url;
+    private applicationID;
+    constructor(url: string, prefix?: string, applicationID?: string);
+    get request(): RequestParameters;
+}
+declare class RequestParameters {
+    private base;
+    private applicationID;
+    query?: Record<string, string>;
+    init?: RequestInit;
+    headers?: Record<string, string>;
+    constructor(base: URL, applicationID: string, query?: Record<string, string>);
+    private withQuery;
+    private parseInit;
+    withBody(body: BodyInit): RequestParameters;
+    includeCredentials(): RequestParameters;
+    includeSameOriginCredentials(): RequestParameters;
+    keepAlive(): RequestParameters;
+    followRedirect(): RequestParameters;
+    errorOnRedirect(): RequestParameters;
+    setHeader(key: string, value: string): RequestParameters;
+    setBearerToken(token: string): RequestParameters;
+    withAccessToken(): RequestParameters;
+    withDomain(): RequestParameters;
+    withContentType(mime: string): RequestParameters;
+    withJSON(body: Record<string, unknown>): RequestParameters;
+    get<ReturnType>(path: string, query?: Record<string, string>): Promise<ReturnType>;
+    post<ReturnType>(path: string, query?: Record<string, string>, body?: FormData | Record<string, string>): Promise<ReturnType>;
+    put<ReturnType>(path: string, query?: Record<string, string>): Promise<ReturnType>;
+    delete<ReturnType>(path: string, query?: Record<string, string>): Promise<ReturnType>;
+    patch<ReturnType>(path: string, query?: Record<string, string>): Promise<ReturnType>;
+}
+export {};

package/dist/cjs/services/http.service.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTPService = exports.HTTPException = void 0;
+class HTTPException extends Error {
+    constructor(status, statusText, body) {
+        super();
+        this.status = status;
+        this.statusText = statusText;
+        this.body = body;
+    }
+    get message() {
+        return `(EXCEPTION) ${this.statusText} - ${this.body}`;
+    }
+}
+exports.HTTPException = HTTPException;
+class HTTPService {
+    constructor(url, prefix, applicationID) {
+        if (prefix == null)
+            prefix = "";
+        this.url = new URL(prefix, url);
+        this.applicationID = "domains:" + applicationID;
+    }
+    get request() {
+        return new RequestParameters(this.url, this.applicationID);
+    }
+}
+exports.HTTPService = HTTPService;
+class RequestParameters {
+    constructor(base, applicationID, query) {
+        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
+    }
+    withQuery(path, query) {
+        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;
+    }
+    parseInit(method) {
+        if (method == null && this.headers == null)
+            return;
+        let tempInit = Object.assign({}, this.init);
+        if (tempInit == null) {
+            tempInit = {};
+        }
+        if (method != null && tempInit != null)
+            tempInit.method = method;
+        if (this.headers != null && tempInit != null) {
+            tempInit.headers = Object.assign({}, this.headers);
+        }
+        return tempInit;
+    }
+    withBody(body) {
+        if (this.init == null) {
+            this.init = {};
+        }
+        this.init.body = body;
+        return this;
+    }
+    includeCredentials() {
+        if (this.init == null) {
+            this.init = {};
+        }
+        this.init.credentials = "include";
+        return this;
+    }
+    includeSameOriginCredentials() {
+        if (this.init == null) {
+            this.init = {};
+        }
+        this.init.credentials = "same-origin";
+        return this;
+    }
+    keepAlive() {
+        if (this.init == null) {
+            this.init = {};
+        }
+        this.init.keepalive = true;
+        return this;
+    }
+    followRedirect() {
+        if (this.init == null) {
+            this.init = {};
+        }
+        this.init.redirect = "follow";
+        return this;
+    }
+    errorOnRedirect() {
+        if (this.init == null) {
+            this.init = {};
+        }
+        this.init.redirect = "error";
+        return this;
+    }
+    setHeader(key, value) {
+        if (this.headers == null) {
+            this.headers = {
+                key: value
+            };
+        }
+        this.headers[key] = value;
+        return this;
+    }
+    setBearerToken(token) {
+        this.setHeader("Authorization", `Bearer ${token}`);
+        return this;
+    }
+    withAccessToken() {
+        const tkn = localStorage.getItem("x-machhub-auth-tkn");
+        this.setHeader("Authorization", `Bearer ${tkn}`);
+        return this;
+    }
+    withDomain() {
+        this.setHeader("Domain", this.applicationID);
+        return this;
+    }
+    withContentType(mime) {
+        this.setHeader("Content-Type", mime);
+        return this;
+    }
+    withJSON(body) {
+        const bd = JSON.stringify(body);
+        return this.withBody(bd).withContentType("application/json");
+    }
+    async get(path, query) {
+        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();
+    }
+    async post(path, query, body) {
+        const init = 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();
+    }
+    async put(path, query) {
+        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();
+    }
+    async delete(path, query) {
+        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();
+    }
+    async patch(path, query) {
+        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();
+    }
+}

package/dist/cjs/services/mqtt.service.d.ts

@@ -0,0 +1,15 @@
+import mqtt from 'mqtt';
+export declare class MQTTService {
+    private url;
+    client: mqtt.MqttClient;
+    private static instance;
+    private subscribedTopics;
+    constructor(url: string);
+    static getInstance(url?: string): Promise<MQTTService>;
+    static resetInstance(): void;
+    addTopicHandler(topic: string, handler: (message: unknown) => void): void;
+    clearTopics(): void;
+    publish(topic: string, message: unknown): boolean;
+    private attachMessageListener;
+    private parseMessage;
+}

package/dist/cjs/services/mqtt.service.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MQTTService = void 0;
+const mqtt_1 = __importDefault(require("mqtt"));
+class MQTTService {
+    constructor(url) {
+        this.subscribedTopics = [];
+        this.url = url;
+    }
+    static async getInstance(url = "ws://localhost:180") {
+        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_1.default.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
+    static resetInstance() {
+        if (this.instance) {
+            this.instance.client.end();
+            this.instance = undefined;
+        }
+    }
+    // addTopicHandler Adds a topic and handler to the subscribed list
+    addTopicHandler(topic, handler) {
+        try {
+            this.subscribedTopics.push({ topic, handler });
+            if (topic == "")
+                return;
+            console.log("New Subscription Handler:", topic);
+            this.client.subscribe(topic, { qos: 2 }, (err) => {
+                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
+    clearTopics() {
+        this.subscribedTopics = [];
+    }
+    // Publishes a message to a specific topic
+    publish(topic, message) {
+        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) => {
+                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;
+    }
+    attachMessageListener() {
+        this.client.on('connect', () => {
+            console.log("MQTT connected to", this.url);
+        });
+        this.client.on('error', (error) => {
+            console.error("MQTT connection error:", error);
+        });
+        this.client.on('message', (topic, message) => {
+            for (const subscribedTopic of this.subscribedTopics) {
+                if (topic === subscribedTopic.topic) {
+                    const parsedMessage = this.parseMessage(message);
+                    subscribedTopic.handler(parsedMessage);
+                    break;
+                }
+            }
+        });
+    }
+    parseMessage(message) {
+        try {
+            return JSON.parse(message.toString());
+        }
+        catch (error) {
+            console.error("Error parsing message:", error);
+            return null;
+        }
+    }
+}
+exports.MQTTService = MQTTService;

package/dist/cjs/services/nats.service.d.ts

@@ -0,0 +1,78 @@
+export declare class NATSService {
+    private url;
+    private functions;
+    private connection;
+    private static instance;
+    private subscribedSubjects;
+    private subscriptions;
+    private readonly EXEC_FUNCTION_SUBJECT;
+    constructor(url: string);
+    /**
+     * Returns a singleton instance of NATSService.
+     */
+    static getInstance(url?: string): Promise<NATSService>;
+    /**
+     * Resets the singleton instance.
+     */
+    static resetInstance(): void;
+    /**
+     * Connects to the NATS broker.
+     */
+    private connect;
+    /**
+     * 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.
+     */
+    addSubjectHandler(subject: string, handler: (message: unknown) => void): void;
+    /**
+     * Subscribes to the EXEC_FUNCTION_SUBJECT and executes registered functions.
+    */
+    initializeFunctions(): boolean;
+    /**
+     * 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.
+     */
+    addFunction(functionName: string, func: (data: Record<string, any>) => Promise<Record<string, any>> | Record<string, any>): void;
+    /**
+     * 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.
+     */
+    executeFunction(functionName: string, arg: Record<string, any>): Promise<Record<string, any>>;
+    /**
+     * Clears all subscribed subjects.
+     */
+    clearSubjects(): void;
+    /**
+     * 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.
+     */
+    publish(subject: string, message: unknown): boolean;
+    /**
+     * Retrieves all registered functions.
+     * @returns {Record<string, (data: Record<string, any>) => Record<string, any>} An object containing all registered functions.
+     */
+    getAllFunctions(): Record<string, (data: Record<string, any>) => Record<string, any>>;
+    static log(message?: any, ...optionalParams: any[]): void;
+    /**
+     * Prints the names of all available functions to the console.
+     */
+    printFunctions(): void;
+    /**
+     * Parses a message buffer into a JSON object.
+     * @param message {Uint8Array} The message buffer.
+     * @returns {unknown} The parsed message.
+     */
+    private parseMessage;
+    /**
+     * Gracefully unsubscribes from all NATS subscriptions and closes the connection.
+     */
+    shutdown(): Promise<void>;
+}

package/dist/cjs/services/nats.service.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NATSService = void 0;
+const nats_core_1 = require("@nats-io/nats-core");
+const transport_node_1 = require("@nats-io/transport-node");
+const HEALTH_SUBJECT = "runtime.typescript.health";
+class NATSService {
+    constructor(url) {
+        this.functions = {};
+        this.connection = null;
+        this.subscribedSubjects = [];
+        this.subscriptions = [];
+        this.EXEC_FUNCTION_SUBJECT = "runtime.exec.typescript.*";
+        this.url = url;
+    }
+    /**
+     * Returns a singleton instance of NATSService.
+     */
+    static async getInstance(url = "ws://localhost:7500") {
+        if (!this.instance || !this.instance.connection) {
+            this.instance = new NATSService(url);
+            await this.instance.connect();
+        }
+        return this.instance;
+    }
+    /**
+     * Resets the singleton instance.
+     */
+    static resetInstance() {
+        if (this.instance) {
+            this.instance.connection?.close();
+            this.instance = undefined;
+        }
+    }
+    /**
+     * Connects to the NATS broker.
+     */
+    async connect() {
+        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 (0, transport_node_1.connect)({ servers: this.url });
+                }
+                else if (this.url.startsWith("ws")) {
+                    this.connection = await (0, nats_core_1.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) {
+                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.
+     */
+    addSubjectHandler(subject, handler) {
+        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.
+    */
+    initializeFunctions() {
+        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());
+                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) => {
+                    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.
+     */
+    addFunction(functionName, func) {
+        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.
+     */
+    async executeFunction(functionName, arg) {
+        const func = this.functions[functionName];
+        if (!func) {
+            throw new Error(`Function '${functionName}' not found`);
+        }
+        return await func(arg);
+    }
+    /**
+     * Clears all subscribed subjects.
+     */
+    clearSubjects() {
+        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.
+     */
+    publish(subject, message) {
+        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.
+     */
+    getAllFunctions() {
+        return this.functions;
+    }
+    static log(message, ...optionalParams) {
+        console.log("[TYPESCRIPT] >", message, ...optionalParams);
+    }
+    /**
+     * Prints the names of all available functions to the console.
+     */
+    printFunctions() {
+        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.
+     */
+    parseMessage(message) {
+        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.
+     */
+    async shutdown() {
+        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.");
+    }
+}
+exports.NATSService = NATSService;