@machhub-dev/sdk-ts 0.0.1

package/dist/classes/tag.d.ts

@@ -0,0 +1,10 @@
+import { HTTPService } from "../services/http.service";
+import { MQTTService } from "../services/mqtt.service";
+export declare class Tag {
+    private httpService;
+    private mqttService;
+    constructor(httpService: HTTPService, mqttService: MQTTService | null);
+    getAllTags(): Promise<string[]>;
+    publish(topic: string, data: any): Promise<void>;
+    subscribe(topic: string, callback: (data: any) => void): Promise<void>;
+}

package/dist/classes/tag.js

@@ -0,0 +1,21 @@
+export class Tag {
+    constructor(httpService, mqttService) {
+        this.httpService = httpService;
+        this.mqttService = mqttService;
+    }
+    async getAllTags() {
+        return this.httpService.request.get("tag/list");
+    }
+    async publish(topic, data) {
+        if (!this.mqttService) {
+            throw new Error("MQTT service not connected");
+        }
+        this.mqttService.publish(topic, data);
+    }
+    async subscribe(topic, callback) {
+        if (!this.mqttService) {
+            throw new Error("MQTT service not connected");
+        }
+        this.mqttService.addTopicHandler(topic, callback);
+    }
+}

package/dist/client.d.ts

@@ -0,0 +1,13 @@
+import { SDKConfig } from './config';
+export declare class MachHubSDK {
+    private configManager;
+    private httpClient;
+    private wsClient;
+    constructor(config: SDKConfig);
+    configure(httpUrl: string, wsUrl: string, runtimeId?: string): void;
+    getConfig(): import("./config").RuntimeConfig;
+    get(endpoint: string, params?: Record<string, any>): Promise<any>;
+    post(endpoint: string, data?: any): Promise<any>;
+    connect(): Promise<void>;
+    disconnect(): void;
+}

package/dist/client.js

@@ -0,0 +1,31 @@
+import { ConfigManager } from './config';
+import { HttpClient } from './http-client';
+import { WebSocketClient } from './websocket-client';
+export class MachHubSDK {
+    constructor(config) {
+        this.configManager = new ConfigManager(config);
+        this.httpClient = new HttpClient(this.configManager);
+        this.wsClient = new WebSocketClient(this.configManager);
+    }
+    configure(httpUrl, wsUrl, runtimeId) {
+        this.configManager.updateUrls(httpUrl, wsUrl, runtimeId);
+        this.httpClient.updateConfig();
+        this.wsClient.updateConfig();
+    }
+    getConfig() {
+        return this.configManager.getConfig();
+    }
+    // Existing methods...
+    async get(endpoint, params) {
+        return this.httpClient.get(endpoint, params);
+    }
+    async post(endpoint, data) {
+        return this.httpClient.post(endpoint, data);
+    }
+    connect() {
+        return this.wsClient.connect();
+    }
+    disconnect() {
+        return this.wsClient.disconnect();
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,21 @@
+export interface SDKConfig {
+    apiKey: string;
+    httpUrl?: string;
+    wsUrl?: string;
+    timeout?: number;
+    retryAttempts?: number;
+    environment?: 'development' | 'staging' | 'production';
+}
+export interface RuntimeConfig extends SDKConfig {
+    runtimeId?: string;
+    proxyEnabled?: boolean;
+    originalHttpUrl?: string;
+    originalWsUrl?: string;
+}
+export declare class ConfigManager {
+    private config;
+    constructor(initialConfig: SDKConfig);
+    getConfig(): RuntimeConfig;
+    updateUrls(httpUrl: string, wsUrl: string, runtimeId?: string): void;
+    resetUrls(): void;
+}

package/dist/config.js

@@ -0,0 +1,33 @@
+export class ConfigManager {
+    constructor(initialConfig) {
+        this.config = {
+            ...initialConfig,
+            httpUrl: initialConfig.httpUrl || 'https://api.machhub.com',
+            wsUrl: initialConfig.wsUrl || 'wss://ws.machhub.com',
+            timeout: initialConfig.timeout || 30000,
+            retryAttempts: initialConfig.retryAttempts || 3,
+            environment: initialConfig.environment || 'production'
+        };
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    updateUrls(httpUrl, wsUrl, runtimeId) {
+        if (!this.config.originalHttpUrl) {
+            this.config.originalHttpUrl = this.config.httpUrl;
+            this.config.originalWsUrl = this.config.wsUrl;
+        }
+        this.config.httpUrl = httpUrl;
+        this.config.wsUrl = wsUrl;
+        this.config.runtimeId = runtimeId;
+        this.config.proxyEnabled = true;
+    }
+    resetUrls() {
+        if (this.config.originalHttpUrl) {
+            this.config.httpUrl = this.config.originalHttpUrl;
+            this.config.wsUrl = this.config.originalWsUrl;
+            this.config.proxyEnabled = false;
+            delete this.config.runtimeId;
+        }
+    }
+}

package/dist/example/functions-file-config.js

@@ -0,0 +1 @@
+"use strict";

package/dist/example/functions.d.ts

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

package/dist/example/functions.js

@@ -0,0 +1,16 @@
+import { SDK } from "../index";
+let sdk = new SDK();
+let config = {
+    application_id: "machhub_admin",
+    natsUrl: "nats://localhost:4222",
+};
+(async () => {
+    await sdk.Initialize(config);
+    function add10(data) {
+        data.result = data.a + 10;
+        console.log("Function add executed with data:", data);
+        return data;
+    }
+    sdk.function.addFunction("add", add10);
+    await sdk.function.initializeFunctions();
+})();

package/dist/http-client.d.ts

@@ -0,0 +1,10 @@
+import { ConfigManager } from './config';
+export declare class HttpClient {
+    private configManager;
+    constructor(configManager: ConfigManager);
+    updateConfig(): void;
+    get(endpoint: string, params?: Record<string, any>): Promise<any>;
+    post(endpoint: string, data?: any): Promise<any>;
+    private getHeaders;
+    private makeRequest;
+}

package/dist/http-client.js

@@ -0,0 +1,58 @@
+export class HttpClient {
+    constructor(configManager) {
+        this.configManager = configManager;
+    }
+    updateConfig() {
+        // Trigger any necessary updates when config changes
+    }
+    async get(endpoint, params) {
+        const config = this.configManager.getConfig();
+        const url = new URL(endpoint, config.httpUrl);
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                url.searchParams.append(key, String(value));
+            });
+        }
+        return this.makeRequest(url.toString(), {
+            method: 'GET',
+            headers: this.getHeaders(),
+        });
+    }
+    async post(endpoint, data) {
+        const config = this.configManager.getConfig();
+        const url = new URL(endpoint, config.httpUrl).toString();
+        return this.makeRequest(url, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: data ? JSON.stringify(data) : undefined,
+        });
+    }
+    getHeaders() {
+        const config = this.configManager.getConfig();
+        const headers = {
+            'Authorization': `Bearer ${config.apiKey}`,
+            'Content-Type': 'application/json',
+        };
+        if (config.runtimeId) {
+            headers['X-Runtime-ID'] = config.runtimeId;
+        }
+        return headers;
+    }
+    async makeRequest(url, options) {
+        const config = this.configManager.getConfig();
+        try {
+            const response = await fetch(url, {
+                ...options,
+                signal: AbortSignal.timeout(config.timeout || 30000),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            console.error('Request failed:', error);
+            throw error;
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { SDK, type SDKConfig } from './sdk-ts';
+export { getAppConfig } from './utils/appConfig';
+export type { LoginResponse, PermissionResponse, User, Group, Feature, Permission, ActionResponse, Action, Scope } from './types/auth.models';
+export type { BaseResponse } from './types/response.models';
+export type { RecordID } from './types/recordID.models';
+export type { HistorizedData } from './types/tag.models';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { SDK } from './sdk-ts';
+export { getAppConfig } from './utils/appConfig';

package/dist/sdk-ts-clean.d.ts

@@ -0,0 +1,108 @@
+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.
+     *
+     * You can initialize the SDK in the following ways:
+     *
+     * **1. Environment Variables (Recommended - works in both Node.js and Browser):**
+     * ```bash
+     * # For Vite/SPA projects (prefix with VITE_):
+     * VITE_MACHHUB_APPLICATION_ID=your-app-id
+     * VITE_MACHHUB_HTTP_URL=http://localhost:80
+     * VITE_MACHHUB_MQTT_URL=ws://localhost:180
+     * VITE_MACHHUB_NATS_URL=ws://localhost:7500
+     *
+     * # For Node.js projects:
+     * MACHHUB_APPLICATION_ID=your-app-id
+     * MACHHUB_HTTP_URL=http://localhost:80
+     * MACHHUB_MQTT_URL=ws://localhost:180
+     * MACHHUB_NATS_URL=ws://localhost:7500
+     * ```
+     *
+     * ```typescript
+     * import { SDK } from '@machhub-dev/sdk-ts';
+     *
+     * const sdk = new SDK();
+     * await sdk.Initialize(); // Automatically reads from environment variables
+     * ```
+     *
+     * **2. Programmatic Configuration:**
+     * ```typescript
+     * import { SDK, type SDKConfig } from '@machhub-dev/sdk-ts';
+     *
+     * const config: SDKConfig = {
+     *   application_id: 'your-app-id',
+     *   httpUrl: 'http://localhost:80', // optional
+     *   mqttUrl: 'ws://localhost:180',  // optional
+     *   natsUrl: 'ws://localhost:7500', // optional
+     * };
+     *
+     * const sdk = new SDK();
+     * await sdk.Initialize(config);
+     * ```
+     *
+     * **3. machhub.sdk.env File (Node.js only):**
+     * ```typescript
+     * // Create machhub.sdk.env in your project root:
+     * // MACHHUB_APPLICATION_ID=your-app-id
+     * // MACHHUB_HTTP_URL=http://localhost:80
+     * // MACHHUB_MQTT_URL=ws://localhost:180
+     * // MACHHUB_NATS_URL=ws://localhost:7500
+     *
+     * const sdk = new SDK();
+     * await sdk.Initialize(); // Reads from machhub.sdk.env if no env vars
+     * ```
+     *
+     * @param config {SDKConfig} Optional configuration object. If not provided, will try environment variables first, then machhub.sdk.env file.
+     * @param envFilePath {string} Optional path to env file. Only works in Node.js environments. Defaults to 'machhub.sdk.env' in project root.
+     * @returns {Promise<boolean>} Resolves to true if initialization is successful.
+     */
+    Initialize(config?: SDKConfig | null, envFilePath?: string): 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-clean.js

@@ -0,0 +1,290 @@
+import { HTTPService } from "./services/http.service";
+import { MQTTService } from "./services/mqtt.service";
+import { NATSService } from "./services/nats.service";
+import { loadSDKConfig } 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) {
+            throw new Error("Application ID is required.");
+        }
+        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 (!this.instance) {
+            const mqttService = await MQTTService.getInstance(mqttUrl);
+            this.instance = new MQTTClient(mqttService);
+        }
+        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.
+     *
+     * You can initialize the SDK in the following ways:
+     *
+     * **1. Environment Variables (Recommended - works in both Node.js and Browser):**
+     * ```bash
+     * # For Vite/SPA projects (prefix with VITE_):
+     * VITE_MACHHUB_APPLICATION_ID=your-app-id
+     * VITE_MACHHUB_HTTP_URL=http://localhost:80
+     * VITE_MACHHUB_MQTT_URL=ws://localhost:180
+     * VITE_MACHHUB_NATS_URL=ws://localhost:7500
+     *
+     * # For Node.js projects:
+     * MACHHUB_APPLICATION_ID=your-app-id
+     * MACHHUB_HTTP_URL=http://localhost:80
+     * MACHHUB_MQTT_URL=ws://localhost:180
+     * MACHHUB_NATS_URL=ws://localhost:7500
+     * ```
+     *
+     * ```typescript
+     * import { SDK } from '@machhub-dev/sdk-ts';
+     *
+     * const sdk = new SDK();
+     * await sdk.Initialize(); // Automatically reads from environment variables
+     * ```
+     *
+     * **2. Programmatic Configuration:**
+     * ```typescript
+     * import { SDK, type SDKConfig } from '@machhub-dev/sdk-ts';
+     *
+     * const config: SDKConfig = {
+     *   application_id: 'your-app-id',
+     *   httpUrl: 'http://localhost:80', // optional
+     *   mqttUrl: 'ws://localhost:180',  // optional
+     *   natsUrl: 'ws://localhost:7500', // optional
+     * };
+     *
+     * const sdk = new SDK();
+     * await sdk.Initialize(config);
+     * ```
+     *
+     * **3. machhub.sdk.env File (Node.js only):**
+     * ```typescript
+     * // Create machhub.sdk.env in your project root:
+     * // MACHHUB_APPLICATION_ID=your-app-id
+     * // MACHHUB_HTTP_URL=http://localhost:80
+     * // MACHHUB_MQTT_URL=ws://localhost:180
+     * // MACHHUB_NATS_URL=ws://localhost:7500
+     *
+     * const sdk = new SDK();
+     * await sdk.Initialize(); // Reads from machhub.sdk.env if no env vars
+     * ```
+     *
+     * @param config {SDKConfig} Optional configuration object. If not provided, will try environment variables first, then machhub.sdk.env file.
+     * @param envFilePath {string} Optional path to env file. Only works in Node.js environments. Defaults to 'machhub.sdk.env' in project root.
+     * @returns {Promise<boolean>} Resolves to true if initialization is successful.
+     */
+    async Initialize(config, envFilePath) {
+        try {
+            let finalConfig;
+            if (config) {
+                // Use provided config
+                finalConfig = config;
+                console.log("Using programmatic configuration");
+            }
+            else {
+                // Try to load configuration automatically
+                const autoConfig = loadSDKConfig(envFilePath);
+                if (!autoConfig) {
+                    const isBrowser = typeof window !== 'undefined';
+                    if (isBrowser) {
+                        throw new Error(`No configuration found. For browser environments, either:
+
+1. Set environment variables (recommended):
+   VITE_MACHHUB_APPLICATION_ID=your-app-id
+   VITE_MACHHUB_HTTP_URL=http://localhost:80
+   VITE_MACHHUB_MQTT_URL=ws://localhost:180
+   VITE_MACHHUB_NATS_URL=ws://localhost:7500
+
+2. Pass a config object:
+   await sdk.Initialize({application_id: 'your-id', ...})`);
+                    }
+                    else {
+                        const defaultPath = envFilePath || 'machhub.sdk.env (in project root)';
+                        throw new Error(`No configuration found. Either:
+
+1. Set environment variables:
+   MACHHUB_APPLICATION_ID=your-app-id
+   MACHHUB_HTTP_URL=http://localhost:80
+   MACHHUB_MQTT_URL=ws://localhost:180
+   MACHHUB_NATS_URL=ws://localhost:7500
+
+2. Create a '${defaultPath}' file with your configuration
+
+3. Pass a config object:
+   await sdk.Initialize({application_id: 'your-id', ...})`);
+                    }
+                }
+                finalConfig = autoConfig;
+            }
+            const { application_id, httpUrl, mqttUrl, natsUrl } = finalConfig;
+            if (!application_id) {
+                throw new Error("application_id is required in the configuration.");
+            }
+            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"]);
+            console.log("SDK initialized successfully!");
+        }
+        catch (error) {
+            console.error("Failed to initialize SDK:", error.message || 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);
+    }
+}