@machhub-dev/sdk-ts 0.0.1

package/dist/sdk-ts.d.ts

@@ -0,0 +1,71 @@
+import { Collection } from "./classes/collection";
+import { Historian } from "./classes/historian";
+import { Tag } from "./classes/tag";
+import { Function } from "./classes/function";
+import { Flow } from "./classes/flow";
+import { Auth } from "./classes/auth";
+export interface SDKConfig {
+    application_id: string;
+    httpUrl?: string;
+    mqttUrl?: string;
+    natsUrl?: string;
+}
+export declare class SDK {
+    private http;
+    private mqtt;
+    private nats;
+    private _historian;
+    private _tag;
+    private _function;
+    private _flow;
+    private _auth;
+    /**
+     * Initializes the SDK with the required clients.
+     *
+     * Example usage:
+     * ```typescript
+     * import { SDK, type SDKConfig } from '@machhub-dev/sdk-ts';
+     *
+     * const config: SDKConfig = {
+     *   application_id: 'your-app-id',
+     *   httpUrl: 'http://localhost:80', // optional (default = http://localhost:80)
+     *   mqttUrl: 'ws://localhost:180',  // optional (default = ws://localhost:180)
+     *   natsUrl: 'ws://localhost:7500', // optional (default = ws://localhost:7500)
+     * };
+     *
+     * const sdk = new SDK();
+     * await sdk.Initialize(config);
+     * ```
+     *
+     * @param config {SDKConfig} The configuration object containing initialization parameters. See SDKConfig for details.
+     * @returns {Promise<boolean>} Resolves to true if initialization is successful.
+     */
+    Initialize(config: SDKConfig): Promise<boolean>;
+    /**
+     * Getter for `auth`. Ensures `auth` is accessed only after initialization.
+     */
+    get auth(): Auth;
+    /**
+     * Getter for `historian`. Ensures `historian` is accessed only after initialization.
+     */
+    get historian(): Historian;
+    /**
+     * Getter for `tag`. Ensures `tag` is accessed only after initialization.
+     */
+    get tag(): Tag;
+    /**
+     * Getter for `function`. Ensures `function` is accessed only after initialization.
+     */
+    get function(): Function;
+    /**
+     * Getter for `flow`. Ensures `flow` is accessed only after initialization.
+     */
+    get flow(): Flow;
+    /**
+     * Creates a collection instance to interact with the specified table/collection.
+     * Throws an error if the SDK is not initialized.
+     * @param collectionName {string} The collection/table name.
+     * @returns {Collection} An instance of Collection.
+     */
+    collection(collectionName: string): Collection;
+}

package/dist/sdk-ts.js

@@ -0,0 +1,223 @@
+import { HTTPService } from "./services/http.service";
+import { MQTTService } from "./services/mqtt.service";
+import { NATSService } from "./services/nats.service";
+import { getAppConfig } from "./utils/appConfig";
+import { Collection } from "./classes/collection";
+import { Historian } from "./classes/historian";
+import { Tag } from "./classes/tag";
+import { Function } from "./classes/function";
+import { Flow } from "./classes/flow";
+import { Auth } from "./classes/auth";
+const MACHHUB_SDK_PATH = "machhub";
+// Core HTTP client class
+class HTTPClient {
+    /**
+     * Creates a new HTTPClient instance
+     * @param applicationID The ID for your application (required)
+     * @param httpUrl The base URL for HTTP connection (default = http://localhost:80)
+     */
+    constructor(applicationID, httpUrl = "http://localhost:80") {
+        if (!applicationID) {
+            const config = getAppConfig();
+            if (config != undefined) {
+                applicationID = config.application_id;
+            }
+            else {
+                throw new Error("Failed to get Configuration.");
+            }
+            if (!applicationID) {
+                throw new Error("Application ID is required. Set it via the APP_ID environment variable or pass it as a parameter.");
+            }
+        }
+        this.httpService = new HTTPService(httpUrl, MACHHUB_SDK_PATH, applicationID);
+    }
+    /**
+     * Gets server info
+     */
+    async getInfo() {
+        return this.httpService.request.get("info");
+    }
+}
+// Core MQTT client class
+class MQTTClient {
+    constructor(mqttService) {
+        this.mqttService = mqttService;
+    }
+    /**
+     * Creates a new MQTTClient instance
+     * @param applicationID The ID for your application
+     * @param mqttUrl The base URL for MQTT connection (default = ws://localhost:180)
+     */
+    static async getInstance(applicationID, mqttUrl = "ws://localhost:180") {
+        // if (!applicationID) {
+        //   applicationID = process.env.APP_ID;
+        //   if (!applicationID) {
+        //     throw new Error("Application ID is required. Set it via the APP_ID environment variable or pass it as a parameter.");
+        //   }
+        // }
+        if (!this.instance) {
+            const mqttService = await MQTTService.getInstance(mqttUrl);
+            this.instance = new MQTTClient(mqttService); // Use the constructor to initialize the instance
+        }
+        return this.instance;
+    }
+    /**
+     * Subscribes to live tag data updates
+     * @param topic The tag topic
+     * @param callback The callback function for data updates
+     */
+    async subscribeLiveData(topic, callback) {
+        return this.mqttService.addTopicHandler(topic, callback);
+    }
+    /**
+     * Publishes a message to a specific topic
+     * @param topic The topic to publish to
+     * @param data The data to publish
+     */
+    async publish(topic, data) {
+        return this.mqttService.publish(topic, data);
+    }
+}
+// Core NATS client class
+class NATSClient {
+    constructor(natsService) {
+        this.natsService = natsService;
+    }
+    /**
+     * Creates a new NATSClient instance
+     * @param applicationID The ID for your application
+     * @param natsUrl The base URL for NATS connection (default = ws://localhost:7500)
+     */
+    static async getInstance(applicationID, natsUrl = "ws://localhost:7500") {
+        if (!this.instance) {
+            const natsService = await NATSService.getInstance(natsUrl);
+            this.instance = new NATSClient(natsService);
+        }
+        return this.instance;
+    }
+    /**
+     * Subscribes to subject updates
+     * @param subject The subject to subscribe to
+     * @param callback The callback function for data updates
+     */
+    async subscribe(subject, callback) {
+        return this.natsService.addSubjectHandler(subject, callback);
+    }
+    /**
+     * Publishes a message to a specific subject
+     * @param subject The subject to publish to
+     * @param data The data to publish
+     */
+    async publish(subject, data) {
+        return this.natsService.publish(subject, data);
+    }
+}
+// SDK Class
+export class SDK {
+    constructor() {
+        this.http = null;
+        this.mqtt = null;
+        this.nats = null;
+        this._historian = null;
+        this._tag = null;
+        this._function = null;
+        this._flow = null;
+        this._auth = null;
+    }
+    /**
+     * Initializes the SDK with the required clients.
+     *
+     * Example usage:
+     * ```typescript
+     * import { SDK, type SDKConfig } from '@machhub-dev/sdk-ts';
+     *
+     * const config: SDKConfig = {
+     *   application_id: 'your-app-id',
+     *   httpUrl: 'http://localhost:80', // optional (default = http://localhost:80)
+     *   mqttUrl: 'ws://localhost:180',  // optional (default = ws://localhost:180)
+     *   natsUrl: 'ws://localhost:7500', // optional (default = ws://localhost:7500)
+     * };
+     *
+     * const sdk = new SDK();
+     * await sdk.Initialize(config);
+     * ```
+     *
+     * @param config {SDKConfig} The configuration object containing initialization parameters. See SDKConfig for details.
+     * @returns {Promise<boolean>} Resolves to true if initialization is successful.
+     */
+    async Initialize(config) {
+        try {
+            const { application_id, httpUrl, mqttUrl, natsUrl } = config;
+            this.http = new HTTPClient(application_id, httpUrl);
+            this.mqtt = await MQTTClient.getInstance(application_id, mqttUrl);
+            this.nats = await NATSClient.getInstance(application_id, natsUrl);
+            this._historian = new Historian(this.http["httpService"], this.mqtt["mqttService"]);
+            this._tag = new Tag(this.http["httpService"], this.mqtt["mqttService"]);
+            this._function = new Function(this.http["httpService"], this.nats["natsService"]);
+            this._flow = new Flow(this.http["httpService"]);
+            this._auth = new Auth(this.http["httpService"]);
+        }
+        catch (error) {
+            console.error("Failed to initialize:", error);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Getter for `auth`. Ensures `auth` is accessed only after initialization.
+     */
+    get auth() {
+        if (!this._auth) {
+            throw new Error("SDK is not initialized. Call `Initialize` before accessing `auth`.");
+        }
+        return this._auth;
+    }
+    /**
+     * Getter for `historian`. Ensures `historian` is accessed only after initialization.
+     */
+    get historian() {
+        if (!this._historian) {
+            throw new Error("SDK is not initialized. Call `Initialize` before accessing `historian`.");
+        }
+        return this._historian;
+    }
+    /**
+     * Getter for `tag`. Ensures `tag` is accessed only after initialization.
+     */
+    get tag() {
+        if (!this._tag) {
+            throw new Error("SDK is not initialized. Call `Initialize` before accessing `tag`.");
+        }
+        return this._tag;
+    }
+    /**
+     * Getter for `function`. Ensures `function` is accessed only after initialization.
+     */
+    get function() {
+        if (!this._function) {
+            throw new Error("SDK is not initialized. Call `Initialize` before accessing `function`.");
+        }
+        return this._function;
+    }
+    /**
+     * Getter for `flow`. Ensures `flow` is accessed only after initialization.
+     */
+    get flow() {
+        if (!this._flow) {
+            throw new Error("SDK is not initialized. Call `Initialize` before accessing `flow`.");
+        }
+        return this._flow;
+    }
+    /**
+     * Creates a collection instance to interact with the specified table/collection.
+     * Throws an error if the SDK is not initialized.
+     * @param collectionName {string} The collection/table name.
+     * @returns {Collection} An instance of Collection.
+     */
+    collection(collectionName) {
+        if (!this.http) {
+            throw new Error("SDK is not initialized. Call `Initialize` before accessing collection.");
+        }
+        return new Collection(this.http["httpService"], this.mqtt ? this.mqtt["mqttService"] : null, collectionName);
+    }
+}

package/dist/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/services/http.service.js

@@ -0,0 +1,173 @@
+export 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}`;
+    }
+}
+export 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);
+    }
+}
+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/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/services/mqtt.service.js

@@ -0,0 +1,96 @@
+import mqtt from 'mqtt';
+export 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.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;
+        }
+    }
+}