@machhub-dev/sdk-ts 0.0.1

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@machhub-dev/sdk-ts",
+  "version": "0.0.1",
+  "description": "MACHHUB TYPESCRIPT SDK",
+  "keywords": [
+    "machhub",
+    "intellogic technology"
+  ],
+  "license": "MIT",
+  "author": "Intellogic Technology Sdn Bhd",
+  "types": "dist/types.d.ts",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/index.js",
+  "exports": {
+    "import": "./dist/index.js",
+    "require": "./dist/cjs/index.cjs"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "npx tsc && npx tsc --module CommonJS --outDir dist/cjs"
+  },
+  "dependencies": {
+    "mqtt": "^5.10.4",
+    "safe-buffer": "^5.2.1",
+    "typescript": "^5.8.3",
+    "undici-types": "^7.4.0"
+  },
+  "devDependencies": {
+    "@nats-io/nats-core": "^3.0.2",
+    "@nats-io/transport-node": "^3.0.2",
+    "@types/node": "^22.13.5"
+  }
+}

package/src/classes/auth.ts

@@ -0,0 +1,103 @@
+import { HTTPService } from "../services/http.service";
+import { Action, ActionResponse, Feature, Group, LoginResponse, User, ValidateJWTResponse } from "../types/auth.models";
+
+export class Auth {
+  private httpService: HTTPService;
+
+  constructor(httpService: HTTPService) {
+    this.httpService = httpService;
+  }
+
+  public async login(username: string, password: string): Promise<LoginResponse | undefined> {
+    let res: LoginResponse
+    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: unknown) {
+      if ((e as Error).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 as Error).message);
+    }
+  }
+
+  public async validateJWT(token: string): Promise<ValidateJWTResponse>{
+    let res:ValidateJWTResponse = await this.httpService.request.withJSON({ token }).post("/auth/jwt/validate");
+    return res
+  }
+
+  public async logout() {
+    localStorage.removeItem("x-machhub-auth-tkn"); // Remove User JWT
+  }
+
+  public async checkAction(feature: string, scope: string): Promise<ActionResponse> {
+    try {
+      const res: ActionResponse = await this.httpService.request.get(`/auth/permission/action/feature/${feature}/scope/${scope}`);
+      return res
+    }
+    catch (e: unknown) {
+      throw new Error("failed to checkAction : " + (e as Error).message);
+    }
+  }
+
+  public async checkPermission(feature: string, scope: string, action: Action): Promise<ActionResponse> {
+    try {
+      const res: ActionResponse = await this.httpService.request.get(`/auth/permission/check/feature/${feature}/scope/${scope}/action/${action}`);
+      return res
+    }
+    catch (e: unknown) {
+      throw new Error("failed to checkPermission : " + (e as Error).message);
+    }
+  }
+
+  public async getUsers(): Promise<User[]> {
+    return await this.httpService.request.get("/auth/user");
+  }
+
+  public async getUserById(userId: string): Promise<User> {
+    return await this.httpService.request.get(`/auth/user/${userId}`);
+  }
+
+  public async createUser(firstName: string, lastName: string, username: string, email: string, password: string, number: string, userImage: string): Promise<User> {
+    return await this.httpService.request.withJSON({
+      firstName: firstName,
+      lastName: lastName,
+      username: username,
+      email: email,
+      password: password,
+      number: number,
+      userImage: userImage
+    }).post("/auth/user");
+  }
+
+  public async getGroups(): Promise<Group[]> {
+    return await this.httpService.request.get("/auth/group");
+  }
+
+  public async createGroup(name: string, features: Feature[]): Promise<Group> {
+    return await this.httpService.request.withJSON({
+      name: name,
+      features: features
+    }).post("/auth/group");
+  }
+
+  public async addUserToGroup(userId: string, groupId: string): Promise<ActionResponse> {
+    return await this.httpService.request.post(`/auth/group/${groupId}/user/${userId}`);
+  }
+
+  public async addPermissionsToGroup(group_id: string, permissions: Feature[]): Promise<ActionResponse> {
+    return await this.httpService.request.withJSON({
+      group_id, permissions
+    }).post("/auth/permission");
+  }
+}

package/src/classes/collection.ts

@@ -0,0 +1,55 @@
+import { HTTPService } from "../services/http.service";
+import { MQTTService } from "../services/mqtt.service";
+
+export 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) {
+    this.httpService = httpService;
+    this.mqttService = mqttService;
+    this.collectionName = collectionName;
+  }
+
+  filter(fieldName: string, operator: "=" | ">" | "<" | "<=" | ">=" | "!=", value: any): Collection {
+    this.queryParams[`filter[${fieldName}][${operator}][${typeof value}]`] = value;
+    return this;
+  }
+
+  sort(field: string, direction: "asc" | "desc" = "asc"): Collection {
+    this.queryParams.sort = `[${field}][${direction}]`;
+    return this;
+  }
+
+  limit(limit: number): Collection {
+    this.queryParams.limit = limit;
+    return this;
+  }
+
+  offset(offset: number): Collection {
+    this.queryParams.offset = offset;
+    return this;
+  }
+
+  async getAll(): Promise<any[]> {
+    return this.httpService.request.get(this.collectionName + "/all", this.queryParams);
+  }
+
+  async getOne(id: string): Promise<any> {
+    return this.httpService.request.get(id);
+  }
+
+  async create(data: Record<string, any>): Promise<any> {
+    return this.httpService.request.withJSON(data).post(this.collectionName);
+  }
+
+  async update(id: string, data: Record<string, any>): Promise<any> {
+    return this.httpService.request.withJSON(data).put(id);
+  }
+
+  async delete(id: string): Promise<any> {
+    return this.httpService.request.delete(id);
+  }
+}

package/src/classes/flow.ts

@@ -0,0 +1,13 @@
+import { HTTPService } from "../services/http.service";
+
+export class Flow {
+  private httpService: HTTPService;
+
+  constructor(httpService: HTTPService) {
+    this.httpService = httpService;
+  }
+
+  public async executeFlow(name: string, payload: any): Promise<any> {
+    return await this.httpService.request.withJSON(payload).post("flow/execute/name/" + name);
+  }
+}

package/src/classes/function.ts

@@ -0,0 +1,34 @@
+import { HTTPService } from "../services/http.service";
+import { NATSService } from "../services/nats.service";
+
+export class Function {
+  private httpService: HTTPService;
+  private natsService: NATSService | null;
+
+  constructor(httpService: HTTPService, natsService: NATSService) {
+    this.httpService = httpService;
+    this.natsService = natsService;
+  }
+
+  public async executeFunction(function_type: string, function_name: string, payload: any): Promise<any> {
+    return await this.httpService.request.withJSON({
+      function_type: function_type,
+      function_name: function_name,
+      payload: payload,
+    }).post("function/execute");
+  }
+
+  public async addFunction(name: string, func: (data: Record<string,any>) => Record<string,any>): Promise<any> {
+    if (!this.natsService) {
+      throw new Error("NATS service not connected");
+    }
+    return this.natsService.addFunction(name, func);
+  }
+
+  public async initializeFunctions(): Promise<any> {
+    if (!this.natsService) {
+      throw new Error("NATS service not connected");
+    }
+    return this.natsService.initializeFunctions();
+  }
+}

package/src/classes/historian.ts

@@ -0,0 +1,49 @@
+import { HTTPService } from "../services/http.service";
+import { MQTTService } from "../services/mqtt.service";
+import { HistorizedData } from "../types/tag.models";
+
+export class Historian {
+  private httpService: HTTPService;
+  private mqttService: MQTTService | null;
+
+  constructor(httpService: HTTPService, mqttService: MQTTService | null) {
+    this.httpService = httpService;
+    this.mqttService = mqttService;
+  }
+
+  async getAllHistorizedTags(): Promise<string[]> {
+    return this.httpService.request.get("historian/list");
+  }
+
+  async getHistoricalData(topic: string, start_time: Date, range?: string): Promise<HistorizedData[]> {
+    let isoStartTime = start_time.toISOString();
+    return this.httpService.request.withJSON({
+      topic: topic,
+      start_time: isoStartTime,
+      range: range,
+    }).patch("historian");
+  }
+
+  async subscribeLiveData(topic: string, callback: (data: any) => void): Promise<any> {
+    if (!this.mqttService) {
+      throw new Error("MQTT service not connected");
+    }
+    this.mqttService.addTopicHandler(topic, callback);
+  }
+
+  async getLastNValues(topic: string, n: number): Promise<HistorizedData[]> {
+    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");
+  }
+}

package/src/classes/tag.ts

@@ -0,0 +1,30 @@
+import { HTTPService } from "../services/http.service";
+import { MQTTService } from "../services/mqtt.service";
+
+export class Tag {
+  private httpService: HTTPService;
+  private mqttService: MQTTService | null;
+
+  constructor(httpService: HTTPService, mqttService: MQTTService | null) {
+    this.httpService = httpService;
+    this.mqttService = mqttService;
+  }
+
+  async getAllTags(): Promise<string[]> {
+    return this.httpService.request.get("tag/list");
+  }
+
+  async publish(topic: string, data: any): Promise<void> {
+    if (!this.mqttService) {
+      throw new Error("MQTT service not connected");
+    }
+    this.mqttService.publish(topic, data);
+  }
+
+  async subscribe(topic: string, callback: (data: any) => void): Promise<void> {
+    if (!this.mqttService) {
+      throw new Error("MQTT service not connected");
+    }
+    this.mqttService.addTopicHandler(topic, callback);
+  }
+}

package/src/example/functions.ts

@@ -0,0 +1,21 @@
+import { SDK, SDKConfig } from "../index";
+
+let sdk = new SDK();
+let config: SDKConfig = {
+  application_id: "machhub_admin",
+  natsUrl: "nats://localhost:4222",
+};
+
+(async () => {
+  await sdk.Initialize(config);
+
+  function add10(data: Record<string,any>): Record<string,any>{
+      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/src/index.ts

@@ -0,0 +1,8 @@
+export { SDK, type SDKConfig } from './sdk-ts';
+export { getAppConfig } from './utils/appConfig';
+
+// Export individual types
+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/src/sdk-ts.ts

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