@machhub-dev/sdk-ts 0.0.1

package/dist/cjs/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/cjs/types/auth.models.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.machhubPermissions = machhubPermissions;
+;
+;
+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/cjs/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/cjs/types/recordID.models.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringToRecordID = StringToRecordID;
+exports.RecordIDToString = RecordIDToString;
+exports.emptyRecordID = emptyRecordID;
+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]
+    };
+}
+function RecordIDToString(recordID) {
+    if (recordID != undefined) {
+        return recordID.Table + ":" + recordID.ID;
+    }
+    else {
+        return "";
+    }
+}
+function emptyRecordID() {
+    return {
+        Table: "",
+        ID: "",
+    };
+}
+// Helper function to check if a string contains spaces
+function containsSpace(s) {
+    return s.includes(" ");
+}

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

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

package/dist/cjs/types/response.models.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/dist/cjs/types/tag.models.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/utils/appConfig.d.ts

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

package/dist/cjs/utils/appConfig.js

@@ -0,0 +1,62 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAppConfig = getAppConfig;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+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/cjs/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/cjs/websocket-client.js

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

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

@@ -0,0 +1,86 @@
+export 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");
+    }
+}

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

@@ -0,0 +1,39 @@
+export 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);
+    }
+}

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

@@ -0,0 +1,8 @@
+export class Flow {
+    constructor(httpService) {
+        this.httpService = httpService;
+    }
+    async executeFlow(name, payload) {
+        return await this.httpService.request.withJSON(payload).post("flow/execute/name/" + name);
+    }
+}

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

@@ -0,0 +1,25 @@
+export 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();
+    }
+}

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

@@ -0,0 +1,36 @@
+export 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");
+    }
+}