@machhub-dev/sdk-ts 0.0.1

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

@@ -0,0 +1,233 @@
+import { wsconnect } from "@nats-io/nats-core";
+import { connect } from "@nats-io/transport-node";
+const HEALTH_SUBJECT = "runtime.typescript.health";
+export 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 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) {
+                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.");
+    }
+}

package/dist/types/auth.models.d.ts

@@ -0,0 +1,52 @@
+import { RecordID } from "./recordID.models";
+import { BaseResponse } from "./response.models";
+export interface LoginResponse extends BaseResponse {
+    tkn: string;
+}
+export interface PermissionResponse extends BaseResponse {
+    permission: boolean;
+}
+export interface ValidateJWTResponse extends BaseResponse {
+    valid: boolean;
+}
+export interface User {
+    id?: RecordID;
+    firstName: string;
+    lastName: string;
+    username: string;
+    email: string;
+    password: string;
+    number: string;
+    createdDt?: string;
+    userImage: string | ArrayBuffer | null;
+    group_ids?: string[];
+}
+export interface Group {
+    id?: RecordID;
+    features?: {
+        name: string;
+        action: string;
+        domain: string;
+        scope: string;
+    }[];
+    name: string;
+    user_ids: RecordID[];
+}
+export interface Feature {
+    name: string;
+    action: string;
+    scope: Scope;
+}
+export interface Permission {
+    displayName: string;
+    description: string;
+    name: string;
+    action: string;
+    scope: string;
+}
+export declare function machhubPermissions(): Permission[];
+export interface ActionResponse extends BaseResponse {
+    action: "read" | "read-write" | "";
+}
+export type Action = "read" | "read-write";
+export type Scope = "self" | "domain" | "all" | "nil";

package/dist/types/auth.models.js

@@ -0,0 +1,97 @@
+;
+;
+export function machhubPermissions() {
+    return [
+        {
+            displayName: 'Applications',
+            description: 'View or manage applications all applications in MACHHUB',
+            name: 'applications',
+            action: 'nil',
+            scope: 'all'
+        },
+        {
+            displayName: 'Users',
+            description: 'View or manage user accounts in this domain',
+            name: 'users',
+            action: 'nil',
+            scope: 'domain'
+        },
+        {
+            displayName: 'Groups',
+            description: 'View or manage user groups in this domain',
+            name: 'groups',
+            action: 'nil',
+            scope: 'domain'
+        },
+        {
+            displayName: 'Manage Own API Keys',
+            description: 'View or manage API keys for own account',
+            name: 'api_keys',
+            action: 'nil',
+            scope: 'self'
+        },
+        {
+            displayName: 'Manage All API Keys',
+            description: 'View or manage all API keys in MACHHUB',
+            name: 'api_keys',
+            action: 'nil',
+            scope: 'all'
+        },
+        {
+            displayName: 'Upstreams',
+            description: 'View or manage all upstream configurations in MACHHUB',
+            name: 'upstreams',
+            action: 'nil',
+            scope: 'domain'
+        },
+        {
+            displayName: 'Manage Namespace',
+            description: 'View or manage namespaces in this domain',
+            name: 'namespace',
+            action: 'nil',
+            scope: 'domain'
+        },
+        {
+            displayName: 'Historian',
+            description: 'View or manage historian data in this domain',
+            name: 'historian',
+            action: 'nil',
+            scope: 'domain'
+        },
+        {
+            displayName: 'Collections',
+            description: 'View or manage collections in this domain',
+            name: 'collections',
+            action: 'nil',
+            scope: 'domain'
+        },
+        {
+            displayName: 'Logs',
+            description: 'View or manage system logs',
+            name: 'logs',
+            action: 'nil',
+            scope: 'all'
+        },
+        {
+            displayName: 'General Settings',
+            description: 'View or manage general system settings',
+            name: 'general_settings',
+            action: 'nil',
+            scope: 'all'
+        },
+        {
+            displayName: 'Gateway Settings',
+            description: 'View or manage gateway settings',
+            name: 'gateway',
+            action: 'nil',
+            scope: 'all'
+        },
+        {
+            displayName: 'License',
+            description: 'View or manage MACHHUB licensing details',
+            name: 'license',
+            action: 'nil',
+            scope: 'all'
+        }
+    ];
+}

package/dist/types/recordID.models.d.ts

@@ -0,0 +1,7 @@
+export interface RecordID {
+    Table: string;
+    ID: string;
+}
+export declare function StringToRecordID(id: string): RecordID;
+export declare function RecordIDToString(recordID: RecordID | undefined): string;
+export declare function emptyRecordID(): RecordID;

package/dist/types/recordID.models.js

@@ -0,0 +1,27 @@
+export function StringToRecordID(id) {
+    const splitID = id.split(":");
+    if (splitID.length != 2)
+        return emptyRecordID();
+    return {
+        Table: containsSpace(splitID[0]) ? `(${splitID[0]})` : splitID[0],
+        ID: splitID[1]
+    };
+}
+export function RecordIDToString(recordID) {
+    if (recordID != undefined) {
+        return recordID.Table + ":" + recordID.ID;
+    }
+    else {
+        return "";
+    }
+}
+export function emptyRecordID() {
+    return {
+        Table: "",
+        ID: "",
+    };
+}
+// Helper function to check if a string contains spaces
+function containsSpace(s) {
+    return s.includes(" ");
+}

package/dist/types/response.models.d.ts

@@ -0,0 +1,4 @@
+export interface BaseResponse {
+    success: boolean;
+    message: boolean;
+}

package/dist/types/response.models.js

@@ -0,0 +1 @@
+export {};

package/dist/types/tag.models.d.ts

@@ -0,0 +1,4 @@
+export interface HistorizedData {
+    timestamp: string;
+    value: unknown;
+}

package/dist/types/tag.models.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/appConfig.d.ts

@@ -0,0 +1,5 @@
+interface AppConfig {
+    application_id: string;
+}
+export declare function getAppConfig(): AppConfig;
+export {};

package/dist/utils/appConfig.js

@@ -0,0 +1,26 @@
+import * as fs from 'fs';
+import * as path from 'path';
+export function getAppConfig() {
+    console.log("getAppConfig");
+    if (typeof process !== 'undefined' && process.env && process.env.APP_CONFIG_PATH) {
+        // Node.js environment
+        console.log(process.env);
+        console.log(process.env.APP_CONFIG_PATH);
+        const configPath = process.env.APP_CONFIG_PATH || path.resolve(__dirname, '../../../sdk.config.json');
+        const rawData = fs.readFileSync(configPath, 'utf-8');
+        return JSON.parse(rawData);
+    }
+    else {
+        try {
+            const configPath = path.resolve('../../../sdk.config.json');
+            console.log(configPath);
+            const rawData = fs.readFileSync(configPath, 'utf-8');
+            console.log("TEST");
+            console.log(rawData);
+            return JSON.parse(rawData);
+        }
+        catch (e) {
+            throw new Error("Configuration not found. Set it via the APP_CONFIG_PATH environment variable : " + e);
+        }
+    }
+}

package/dist/websocket-client.d.ts

@@ -0,0 +1,15 @@
+import { ConfigManager } from './config';
+export declare class WebSocketClient {
+    private configManager;
+    private ws;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    constructor(configManager: ConfigManager);
+    updateConfig(): void;
+    connect(): Promise<void>;
+    disconnect(): void;
+    send(data: any): void;
+    private handleMessage;
+    private handleReconnect;
+}

package/dist/websocket-client.js

@@ -0,0 +1,92 @@
+export class WebSocketClient {
+    constructor(configManager) {
+        this.ws = null;
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 5;
+        this.reconnectDelay = 1000;
+        this.configManager = configManager;
+    }
+    updateConfig() {
+        // If connected, reconnect with new config
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.disconnect();
+            this.connect();
+        }
+    }
+    connect() {
+        return new Promise((resolve, reject) => {
+            const config = this.configManager.getConfig();
+            const wsUrl = config.wsUrl;
+            if (!wsUrl) {
+                reject(new Error('WebSocket URL not configured'));
+                return;
+            }
+            try {
+                this.ws = new WebSocket(wsUrl);
+                this.ws.onopen = () => {
+                    console.log('WebSocket connected');
+                    this.reconnectAttempts = 0;
+                    // Send runtime ID if available
+                    if (config.runtimeId) {
+                        this.send({ type: 'auth', runtimeId: config.runtimeId });
+                    }
+                    resolve();
+                };
+                this.ws.onmessage = (event) => {
+                    try {
+                        const data = JSON.parse(event.data);
+                        this.handleMessage(data);
+                    }
+                    catch (error) {
+                        console.error('Failed to parse WebSocket message:', error);
+                    }
+                };
+                this.ws.onclose = (event) => {
+                    console.log('WebSocket disconnected:', event.code, event.reason);
+                    this.handleReconnect();
+                };
+                this.ws.onerror = (error) => {
+                    console.error('WebSocket error:', error);
+                    reject(error);
+                };
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    disconnect() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.reconnectAttempts = 0;
+    }
+    send(data) {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(data));
+        }
+        else {
+            console.warn('WebSocket not connected, cannot send message');
+        }
+    }
+    handleMessage(data) {
+        // Handle incoming messages
+        console.log('WebSocket message received:', data);
+    }
+    handleReconnect() {
+        if (this.reconnectAttempts < this.maxReconnectAttempts) {
+            this.reconnectAttempts++;
+            const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+            console.log(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
+            setTimeout(() => {
+                this.connect().catch(error => {
+                    console.error('Reconnection failed:', error);
+                });
+            }, delay);
+        }
+        else {
+            console.error('Max reconnection attempts reached');
+        }
+    }
+}