@machhub-dev/sdk-ts 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Intellogic Technology
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cjs/classes/auth.d.ts

@@ -0,0 +1,18 @@
+import { HTTPService } from "../services/http.service";
+import { Action, ActionResponse, Feature, Group, LoginResponse, User, ValidateJWTResponse } from "../types/auth.models";
+export declare class Auth {
+    private httpService;
+    constructor(httpService: HTTPService);
+    login(username: string, password: string): Promise<LoginResponse | undefined>;
+    validateJWT(token: string): Promise<ValidateJWTResponse>;
+    logout(): Promise<void>;
+    checkAction(feature: string, scope: string): Promise<ActionResponse>;
+    checkPermission(feature: string, scope: string, action: Action): Promise<ActionResponse>;
+    getUsers(): Promise<User[]>;
+    getUserById(userId: string): Promise<User>;
+    createUser(firstName: string, lastName: string, username: string, email: string, password: string, number: string, userImage: string): Promise<User>;
+    getGroups(): Promise<Group[]>;
+    createGroup(name: string, features: Feature[]): Promise<Group>;
+    addUserToGroup(userId: string, groupId: string): Promise<ActionResponse>;
+    addPermissionsToGroup(group_id: string, permissions: Feature[]): Promise<ActionResponse>;
+}

package/dist/cjs/classes/auth.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Auth = void 0;
+class Auth {
+    constructor(httpService) {
+        this.httpService = httpService;
+    }
+    async login(username, password) {
+        let res;
+        try {
+            res = await this.httpService.request.withJSON({
+                username: username,
+                password: password,
+            }).post("/auth/login");
+            if (localStorage) {
+                localStorage.setItem("x-machhub-auth-tkn", res.tkn); // Set User JWT
+            }
+            else {
+                console.error("localStorage is not available. The program needs to be in a browser environment.");
+            }
+            return res;
+        }
+        catch (e) {
+            if (e.message == "localStorage is not defined") {
+                throw new Error("Login failed: localStorage is not available. The program needs to be in a browser environment.");
+            }
+            throw new Error("Login failed: " + e.message);
+        }
+    }
+    async validateJWT(token) {
+        let res = await this.httpService.request.withJSON({ token }).post("/auth/jwt/validate");
+        return res;
+    }
+    async logout() {
+        localStorage.removeItem("x-machhub-auth-tkn"); // Remove User JWT
+    }
+    async checkAction(feature, scope) {
+        try {
+            const res = await this.httpService.request.get(`/auth/permission/action/feature/${feature}/scope/${scope}`);
+            return res;
+        }
+        catch (e) {
+            throw new Error("failed to checkAction : " + e.message);
+        }
+    }
+    async checkPermission(feature, scope, action) {
+        try {
+            const res = await this.httpService.request.get(`/auth/permission/check/feature/${feature}/scope/${scope}/action/${action}`);
+            return res;
+        }
+        catch (e) {
+            throw new Error("failed to checkPermission : " + e.message);
+        }
+    }
+    async getUsers() {
+        return await this.httpService.request.get("/auth/user");
+    }
+    async getUserById(userId) {
+        return await this.httpService.request.get(`/auth/user/${userId}`);
+    }
+    async createUser(firstName, lastName, username, email, password, number, userImage) {
+        return await this.httpService.request.withJSON({
+            firstName: firstName,
+            lastName: lastName,
+            username: username,
+            email: email,
+            password: password,
+            number: number,
+            userImage: userImage
+        }).post("/auth/user");
+    }
+    async getGroups() {
+        return await this.httpService.request.get("/auth/group");
+    }
+    async createGroup(name, features) {
+        return await this.httpService.request.withJSON({
+            name: name,
+            features: features
+        }).post("/auth/group");
+    }
+    async addUserToGroup(userId, groupId) {
+        return await this.httpService.request.post(`/auth/group/${groupId}/user/${userId}`);
+    }
+    async addPermissionsToGroup(group_id, permissions) {
+        return await this.httpService.request.withJSON({
+            group_id, permissions
+        }).post("/auth/permission");
+    }
+}
+exports.Auth = Auth;

package/dist/cjs/classes/collection.d.ts

@@ -0,0 +1,18 @@
+import { HTTPService } from "../services/http.service";
+import { MQTTService } from "../services/mqtt.service";
+export declare class Collection {
+    protected httpService: HTTPService;
+    protected mqttService: MQTTService | null;
+    protected collectionName: string;
+    protected queryParams: Record<string, any>;
+    constructor(httpService: HTTPService, mqttService: MQTTService | null, collectionName: string);
+    filter(fieldName: string, operator: "=" | ">" | "<" | "<=" | ">=" | "!=", value: any): Collection;
+    sort(field: string, direction?: "asc" | "desc"): Collection;
+    limit(limit: number): Collection;
+    offset(offset: number): Collection;
+    getAll(): Promise<any[]>;
+    getOne(id: string): Promise<any>;
+    create(data: Record<string, any>): Promise<any>;
+    update(id: string, data: Record<string, any>): Promise<any>;
+    delete(id: string): Promise<any>;
+}

package/dist/cjs/classes/collection.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collection = void 0;
+class Collection {
+    constructor(httpService, mqttService, collectionName) {
+        this.queryParams = {};
+        this.httpService = httpService;
+        this.mqttService = mqttService;
+        this.collectionName = collectionName;
+    }
+    filter(fieldName, operator, value) {
+        this.queryParams[`filter[${fieldName}][${operator}][${typeof value}]`] = value;
+        return this;
+    }
+    sort(field, direction = "asc") {
+        this.queryParams.sort = `[${field}][${direction}]`;
+        return this;
+    }
+    limit(limit) {
+        this.queryParams.limit = limit;
+        return this;
+    }
+    offset(offset) {
+        this.queryParams.offset = offset;
+        return this;
+    }
+    async getAll() {
+        return this.httpService.request.get(this.collectionName + "/all", this.queryParams);
+    }
+    async getOne(id) {
+        return this.httpService.request.get(id);
+    }
+    async create(data) {
+        return this.httpService.request.withJSON(data).post(this.collectionName);
+    }
+    async update(id, data) {
+        return this.httpService.request.withJSON(data).put(id);
+    }
+    async delete(id) {
+        return this.httpService.request.delete(id);
+    }
+}
+exports.Collection = Collection;

package/dist/cjs/classes/flow.d.ts

@@ -0,0 +1,6 @@
+import { HTTPService } from "../services/http.service";
+export declare class Flow {
+    private httpService;
+    constructor(httpService: HTTPService);
+    executeFlow(name: string, payload: any): Promise<any>;
+}

package/dist/cjs/classes/flow.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flow = void 0;
+class Flow {
+    constructor(httpService) {
+        this.httpService = httpService;
+    }
+    async executeFlow(name, payload) {
+        return await this.httpService.request.withJSON(payload).post("flow/execute/name/" + name);
+    }
+}
+exports.Flow = Flow;

package/dist/cjs/classes/function.d.ts

@@ -0,0 +1,10 @@
+import { HTTPService } from "../services/http.service";
+import { NATSService } from "../services/nats.service";
+export declare class Function {
+    private httpService;
+    private natsService;
+    constructor(httpService: HTTPService, natsService: NATSService);
+    executeFunction(function_type: string, function_name: string, payload: any): Promise<any>;
+    addFunction(name: string, func: (data: Record<string, any>) => Record<string, any>): Promise<any>;
+    initializeFunctions(): Promise<any>;
+}

package/dist/cjs/classes/function.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Function = void 0;
+class Function {
+    constructor(httpService, natsService) {
+        this.httpService = httpService;
+        this.natsService = natsService;
+    }
+    async executeFunction(function_type, function_name, payload) {
+        return await this.httpService.request.withJSON({
+            function_type: function_type,
+            function_name: function_name,
+            payload: payload,
+        }).post("function/execute");
+    }
+    async addFunction(name, func) {
+        if (!this.natsService) {
+            throw new Error("NATS service not connected");
+        }
+        return this.natsService.addFunction(name, func);
+    }
+    async initializeFunctions() {
+        if (!this.natsService) {
+            throw new Error("NATS service not connected");
+        }
+        return this.natsService.initializeFunctions();
+    }
+}
+exports.Function = Function;

package/dist/cjs/classes/historian.d.ts

@@ -0,0 +1,12 @@
+import { HTTPService } from "../services/http.service";
+import { MQTTService } from "../services/mqtt.service";
+import { HistorizedData } from "../types/tag.models";
+export declare class Historian {
+    private httpService;
+    private mqttService;
+    constructor(httpService: HTTPService, mqttService: MQTTService | null);
+    getAllHistorizedTags(): Promise<string[]>;
+    getHistoricalData(topic: string, start_time: Date, range?: string): Promise<HistorizedData[]>;
+    subscribeLiveData(topic: string, callback: (data: any) => void): Promise<any>;
+    getLastNValues(topic: string, n: number): Promise<HistorizedData[]>;
+}

package/dist/cjs/classes/historian.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Historian = void 0;
+class Historian {
+    constructor(httpService, mqttService) {
+        this.httpService = httpService;
+        this.mqttService = mqttService;
+    }
+    async getAllHistorizedTags() {
+        return this.httpService.request.get("historian/list");
+    }
+    async getHistoricalData(topic, start_time, range) {
+        let isoStartTime = start_time.toISOString();
+        return this.httpService.request.withJSON({
+            topic: topic,
+            start_time: isoStartTime,
+            range: range,
+        }).patch("historian");
+    }
+    async subscribeLiveData(topic, callback) {
+        if (!this.mqttService) {
+            throw new Error("MQTT service not connected");
+        }
+        this.mqttService.addTopicHandler(topic, callback);
+    }
+    async getLastNValues(topic, n) {
+        if (n <= 0) {
+            throw new Error("The number of values to fetch must be greater than 0.");
+        }
+        if (n > 100) {
+            throw new Error("The number of values to fetch must be less than 100.");
+        }
+        return this.httpService.request.withJSON({
+            topic: topic,
+            limit: n,
+            sort: "desc", // Fetch the latest values
+        }).patch("historian/last");
+    }
+}
+exports.Historian = Historian;

package/dist/cjs/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/cjs/classes/tag.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tag = void 0;
+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);
+    }
+}
+exports.Tag = Tag;

package/dist/cjs/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/cjs/client.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MachHubSDK = void 0;
+const config_1 = require("./config");
+const http_client_1 = require("./http-client");
+const websocket_client_1 = require("./websocket-client");
+class MachHubSDK {
+    constructor(config) {
+        this.configManager = new config_1.ConfigManager(config);
+        this.httpClient = new http_client_1.HttpClient(this.configManager);
+        this.wsClient = new websocket_client_1.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();
+    }
+}
+exports.MachHubSDK = MachHubSDK;

package/dist/cjs/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/cjs/config.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigManager = void 0;
+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;
+        }
+    }
+}
+exports.ConfigManager = ConfigManager;

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

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

package/dist/cjs/example/functions.d.ts

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

package/dist/cjs/example/functions.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+let sdk = new index_1.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/cjs/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/cjs/http-client.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+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;
+        }
+    }
+}
+exports.HttpClient = HttpClient;

package/dist/cjs/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/cjs/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAppConfig = exports.SDK = void 0;
+var sdk_ts_1 = require("./sdk-ts");
+Object.defineProperty(exports, "SDK", { enumerable: true, get: function () { return sdk_ts_1.SDK; } });
+var appConfig_1 = require("./utils/appConfig");
+Object.defineProperty(exports, "getAppConfig", { enumerable: true, get: function () { return appConfig_1.getAppConfig; } });