@machhub-dev/sdk-ts 0.0.2 → 0.0.4

package/dist/sdk-ts.js

@@ -1,35 +1,22 @@
-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";
+import { HTTPService } from "./services/http.service.js";
+import { MQTTService } from "./services/mqtt.service.js";
+import { NATSService } from "./services/nats.service.js";
+import { Collection } from "./classes/collection.js";
+import { Historian } from "./classes/historian.js";
+import { Tag } from "./classes/tag.js";
+import { Function } from "./classes/function.js";
+import { Flow } from "./classes/flow.js";
+import { Auth } from "./classes/auth.js";
 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)
+     * @param httpUrl The base URL for HTTP connection (default = http://localhost:6188)
      */
-    constructor(applicationID, httpUrl = "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);
+    constructor(applicationID, httpUrl, developerKey) {
+        this.httpService = new HTTPService(httpUrl, MACHHUB_SDK_PATH, applicationID, developerKey);
     }
     /**
      * Gets server info
@@ -48,7 +35,7 @@ class MQTTClient {
      * @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") {
+    static async getInstance(applicationID, mqttUrl = "ws://localhost:180", developerKey) {
         // if (!applicationID) {
         //   applicationID = process.env.APP_ID;
         //   if (!applicationID) {
@@ -56,7 +43,7 @@ class MQTTClient {
         //   }
         // }
         if (!this.instance) {
-            const mqttService = await MQTTService.getInstance(mqttUrl);
+            const mqttService = await MQTTService.getInstance(mqttUrl, developerKey);
             this.instance = new MQTTClient(mqttService); // Use the constructor to initialize the instance
         }
         return this.instance;
@@ -133,7 +120,7 @@ export class SDK {
      *
      * const config: SDKConfig = {
      *   application_id: 'your-app-id',
-     *   httpUrl: 'http://localhost:80', // optional (default = http://localhost:80)
+     *   httpUrl: 'http://localhost:6188', // optional (default = http://localhost:6188)
      *   mqttUrl: 'ws://localhost:180',  // optional (default = ws://localhost:180)
      *   natsUrl: 'ws://localhost:7500', // optional (default = ws://localhost:7500)
      * };
@@ -147,9 +134,31 @@ export class SDK {
      */
     async Initialize(config) {
         try {
+            console.log("Initializing SDK with config:", config);
+            // Methods to initialize config 
+            // 1. Via application_id + URLs + developer key passed in config parameter
+            // 2. Via development server - Set via Extension/ 
+            //          API to get Config (All SDK URLs default to localhost with port from querying current window or 61888)
+            if (config === undefined)
+                config = { application_id: "" };
+            if (!config.application_id)
+                config = { application_id: "" };
+            console.log("Using application_id:", config.application_id);
+            const PORT = await getEnvPort();
+            console.log("Using port:", PORT);
+            if (!config.httpUrl) {
+                config.httpUrl = "http://localhost:" + PORT;
+            }
+            if (!config.mqttUrl) {
+                config.mqttUrl = "ws://localhost:" + PORT + "/mqtt";
+            }
+            if (!config.natsUrl) {
+                config.natsUrl = "ws://localhost:" + PORT + "/nats";
+            }
             const { application_id, httpUrl, mqttUrl, natsUrl } = config;
-            this.http = new HTTPClient(application_id, httpUrl);
-            this.mqtt = await MQTTClient.getInstance(application_id, mqttUrl);
+            console.log("Final config:", { application_id, httpUrl, mqttUrl, natsUrl });
+            this.http = new HTTPClient(application_id, httpUrl, config.developer_key);
+            this.mqtt = await MQTTClient.getInstance(application_id, mqttUrl, config.developer_key);
             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"]);
@@ -221,3 +230,36 @@ export class SDK {
         return new Collection(this.http["httpService"], this.mqtt ? this.mqtt["mqttService"] : null, collectionName);
     }
 }
+async function getEnvPort() {
+    console.log(window.location.origin);
+    try {
+        const response = await fetchData(window.location.origin + "/_cfg");
+        // console.log('Response:', response);
+        // console.log('runtimeID: ', response.runtimeID);
+        // console.log('applicationID: ', response.runtimeID.split('XmchX')[0]);
+        return response.port;
+    }
+    catch (error) {
+        // console.log('No configured runtime ID:', error);
+        // TODO: Use DevPort from SDK Config or default to 61888
+        return "61888";
+    }
+}
+async function fetchData(url) {
+    try {
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: {
+                'Accept': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const data = await response.json();
+        return data;
+    }
+    catch (error) {
+        throw error;
+    }
+}

package/dist/services/http.service.d.ts

@@ -8,16 +8,20 @@ export declare class HTTPException extends Error {
 export declare class HTTPService {
     private url;
     private applicationID;
-    constructor(url: string, prefix?: string, applicationID?: string);
+    private developerKey?;
+    constructor(url: string, prefix: string, applicationID: string, developerKey?: string);
     get request(): RequestParameters;
+    private addRuntimeHeaders;
+    private getCookie;
 }
 declare class RequestParameters {
     private base;
     private applicationID;
+    private developerKey?;
     query?: Record<string, string>;
     init?: RequestInit;
     headers?: Record<string, string>;
-    constructor(base: URL, applicationID: string, query?: Record<string, string>);
+    constructor(base: URL, applicationID: string, developerKey?: string, query?: Record<string, string>);
     private withQuery;
     private parseInit;
     withBody(body: BodyInit): RequestParameters;
@@ -30,6 +34,7 @@ declare class RequestParameters {
     setBearerToken(token: string): RequestParameters;
     withAccessToken(): RequestParameters;
     withDomain(): RequestParameters;
+    withDeveloperKey(): RequestParameters;
     withContentType(mime: string): RequestParameters;
     withJSON(body: Record<string, unknown>): RequestParameters;
     get<ReturnType>(path: string, query?: Record<string, string>): Promise<ReturnType>;

package/dist/services/http.service.js

@@ -10,23 +10,46 @@ export class HTTPException extends Error {
     }
 }
 export class HTTPService {
-    constructor(url, prefix, applicationID) {
+    constructor(url, prefix, applicationID, developerKey) {
         if (prefix == null)
             prefix = "";
         this.url = new URL(prefix, url);
         this.applicationID = "domains:" + applicationID;
+        this.developerKey = developerKey;
     }
     get request() {
-        return new RequestParameters(this.url, this.applicationID);
+        return new RequestParameters(this.url, this.applicationID, this.developerKey);
+    }
+    addRuntimeHeaders(headers = {}) {
+        // Add runtime ID from cookie if available (for hosted applications)
+        if (typeof document !== 'undefined') {
+            const runtimeID = this.getCookie('machhub_runtime_id');
+            if (runtimeID) {
+                headers['X-MachHub-Runtime-ID'] = runtimeID;
+            }
+        }
+        return headers;
+    }
+    getCookie(name) {
+        if (typeof document === 'undefined')
+            return null;
+        const value = `; ${document.cookie}`;
+        const parts = value.split(`; ${name}=`);
+        if (parts.length === 2) {
+            return parts.pop()?.split(';').shift() || null;
+        }
+        return null;
     }
 }
 class RequestParameters {
-    constructor(base, applicationID, query) {
+    constructor(base, applicationID, developerKey, query) {
         this.base = base;
         this.applicationID = applicationID;
+        this.developerKey = developerKey;
         this.query = query;
         this.withDomain(); // Ensure withDomain() is called by default
         this.withAccessToken(); // Ensure withAccessToken() is called by default
+        this.withDeveloperKey(); // Ensure withDeveloperKey() is called by default
     }
     withQuery(path, query) {
         const newPath = [this.base.pathname, path].map(pathPart => pathPart.replace(/(^\/|\/$)/g, "")).join("/");
@@ -114,6 +137,12 @@ class RequestParameters {
         this.setHeader("Domain", this.applicationID);
         return this;
     }
+    withDeveloperKey() {
+        if (!this.developerKey)
+            return this;
+        this.setHeader("X-Machhub-Api-Key", this.developerKey);
+        return this;
+    }
     withContentType(mime) {
         this.setHeader("Content-Type", mime);
         return this;

package/dist/services/mqtt.service.d.ts

@@ -5,7 +5,7 @@ export declare class MQTTService {
     private static instance;
     private subscribedTopics;
     constructor(url: string);
-    static getInstance(url?: string): Promise<MQTTService>;
+    static getInstance(url?: string, developerKey?: string): Promise<MQTTService>;
     static resetInstance(): void;
     addTopicHandler(topic: string, handler: (message: unknown) => void): void;
     clearTopics(): void;

package/dist/services/mqtt.service.js

@@ -4,13 +4,20 @@ export class MQTTService {
         this.subscribedTopics = [];
         this.url = url;
     }
-    static async getInstance(url = "ws://localhost:180") {
+    static async getInstance(url = "ws://localhost:180", developerKey) {
         if (!this.instance || !this.instance.client) {
             this.instance = new MQTTService(url);
             // Ensure the URL is set correctly
             this.instance.url = url;
             // Initialize the MQTT client
-            this.instance.client = mqtt.connect(this.instance.url, { protocolVersion: 5 });
+            const connectOptions = {
+                protocolVersion: 5,
+                ...(developerKey && {
+                    username: "mch_developer_key",
+                    password: developerKey,
+                })
+            };
+            this.instance.client = mqtt.connect(this.instance.url, connectOptions);
             this.instance.attachMessageListener();
             // console.log("MQTT Client initialized with URL:", this.instance.url);
         }

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

@@ -1,5 +1,5 @@
-import { RecordID } from "./recordID.models";
-import { BaseResponse } from "./response.models";
+import { RecordID } from "./recordID.models.js";
+import { BaseResponse } from "./response.models.js";
 export interface LoginResponse extends BaseResponse {
     tkn: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@machhub-dev/sdk-ts",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "MACHHUB TYPESCRIPT SDK",
   "keywords": [
     "machhub",

package/src/classes/auth.ts

@@ -1,5 +1,5 @@
-import { HTTPService } from "../services/http.service";
-import { Action, ActionResponse, Feature, Group, LoginResponse, User, ValidateJWTResponse } from "../types/auth.models";
+import { HTTPService } from "../services/http.service.js";
+import { Action, ActionResponse, Feature, Group, LoginResponse, User, ValidateJWTResponse } from "../types/auth.models.js";
 
 export class Auth {
   private httpService: HTTPService;

package/src/classes/collection.ts

@@ -1,5 +1,5 @@
-import { HTTPService } from "../services/http.service";
-import { MQTTService } from "../services/mqtt.service";
+import { HTTPService } from "../services/http.service.js";
+import { MQTTService } from "../services/mqtt.service.js";
 
 export class Collection {
   protected httpService: HTTPService;
@@ -38,6 +38,9 @@ export class Collection {
   }
 
   async getOne(id: string): Promise<any> {
+    if (!id) {
+      throw new Error("ID must be provided");
+    }
     return this.httpService.request.get(id);
   }
 
@@ -46,10 +49,16 @@ export class Collection {
   }
 
   async update(id: string, data: Record<string, any>): Promise<any> {
+    if (!id) {
+      throw new Error("ID must be provided");
+    }
     return this.httpService.request.withJSON(data).put(id);
   }
 
   async delete(id: string): Promise<any> {
+    if (!id) {
+      throw new Error("ID must be provided");
+    }
     return this.httpService.request.delete(id);
   }
 }

package/src/classes/flow.ts

@@ -1,4 +1,4 @@
-import { HTTPService } from "../services/http.service";
+import { HTTPService } from "../services/http.service.js";
 
 export class Flow {
   private httpService: HTTPService;

package/src/classes/function.ts

@@ -1,5 +1,5 @@
-import { HTTPService } from "../services/http.service";
-import { NATSService } from "../services/nats.service";
+import { HTTPService } from "../services/http.service.js";
+import { NATSService } from "../services/nats.service.js";
 
 export class Function {
   private httpService: HTTPService;

package/src/classes/historian.ts

@@ -1,6 +1,6 @@
-import { HTTPService } from "../services/http.service";
-import { MQTTService } from "../services/mqtt.service";
-import { HistorizedData } from "../types/tag.models";
+import { HTTPService } from "../services/http.service.js";
+import { MQTTService } from "../services/mqtt.service.js";
+import { HistorizedData } from "../types/tag.models.js";
 
 export class Historian {
   private httpService: HTTPService;

package/src/classes/tag.ts

@@ -1,5 +1,5 @@
-import { HTTPService } from "../services/http.service";
-import { MQTTService } from "../services/mqtt.service";
+import { HTTPService } from "../services/http.service.js";
+import { MQTTService } from "../services/mqtt.service.js";
 
 export class Tag {
   private httpService: HTTPService;

package/src/example/functions.ts

@@ -1,4 +1,4 @@
-import { SDK, SDKConfig } from "../index";
+import { SDK, SDKConfig } from "../index.js";
 
 let sdk = new SDK();
 let config: SDKConfig = {

package/src/sdk-ts.ts

@@ -1,13 +1,12 @@
-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";
+import { HTTPService } from "./services/http.service.js";
+import { MQTTService } from "./services/mqtt.service.js";
+import { NATSService } from "./services/nats.service.js";
+import { Collection } from "./classes/collection.js";
+import { Historian } from "./classes/historian.js";
+import { Tag } from "./classes/tag.js";
+import { Function } from "./classes/function.js";
+import { Flow } from "./classes/flow.js";
+import { Auth } from "./classes/auth.js";
 
 const MACHHUB_SDK_PATH = "machhub";
 
@@ -18,21 +17,10 @@ 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)
+   * @param httpUrl The base URL for HTTP connection (default = http://localhost:6188)
    */
-  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);
+  constructor(applicationID: string, httpUrl:string, developerKey?: string) {
+    this.httpService = new HTTPService(httpUrl, MACHHUB_SDK_PATH, applicationID, developerKey);
   }
 
   /**
@@ -57,7 +45,7 @@ class MQTTClient {
    * @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> {
+  static async getInstance(applicationID?: string, mqttUrl: string = "ws://localhost:180", developerKey? :string): Promise<MQTTClient> {
     // if (!applicationID) {
     //   applicationID = process.env.APP_ID;
     //   if (!applicationID) {
@@ -65,7 +53,7 @@ class MQTTClient {
     //   }
     // }
     if (!this.instance) {
-      const mqttService = await MQTTService.getInstance(mqttUrl);
+      const mqttService = await MQTTService.getInstance(mqttUrl, developerKey);
       this.instance = new MQTTClient(mqttService); // Use the constructor to initialize the instance
     }
     return this.instance;
@@ -133,6 +121,7 @@ class NATSClient {
 
 export interface SDKConfig {
   application_id: string;
+  developer_key?: string;
   httpUrl?: string;
   mqttUrl?: string;
   natsUrl?: string;
@@ -158,7 +147,7 @@ export class SDK {
    *
    * const config: SDKConfig = {
    *   application_id: 'your-app-id',
-   *   httpUrl: 'http://localhost:80', // optional (default = http://localhost:80)
+   *   httpUrl: 'http://localhost:6188', // optional (default = http://localhost:6188)
    *   mqttUrl: 'ws://localhost:180',  // optional (default = ws://localhost:180)
    *   natsUrl: 'ws://localhost:7500', // optional (default = ws://localhost:7500)
    * };
@@ -170,13 +159,44 @@ export class SDK {
    * @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> {
+  public async Initialize(config?: SDKConfig): Promise<boolean> {
     try {
+      console.log("Initializing SDK with config:", config)
+
+      // Methods to initialize config 
+      // 1. Via application_id + URLs + developer key passed in config parameter
+      // 2. Via development server - Set via Extension/ 
+      //          API to get Config (All SDK URLs default to localhost with port from querying current window or 61888)
+
+      if (config === undefined) config = { application_id: "" }
+      if (!config.application_id) config = { application_id: "" }
+      console.log("Using application_id:", config.application_id);
+
+
+      const PORT = await getEnvPort();
+      console.log("Using port:", PORT);
+
+      if (!config.httpUrl) {
+        config.httpUrl = "http://localhost:" + PORT;
+      }
+
+      if (!config.mqttUrl) {
+        config.mqttUrl = "ws://localhost:" + PORT + "/mqtt";
+      }
+
+      if (!config.natsUrl) {
+        config.natsUrl = "ws://localhost:" + PORT + "/nats";
+      }
+
       const { application_id, httpUrl, mqttUrl, natsUrl } = config;
 
-      this.http = new HTTPClient(application_id, httpUrl);
-      this.mqtt = await MQTTClient.getInstance(application_id, mqttUrl);
+      console.log("Final config:", { application_id, httpUrl, mqttUrl, natsUrl });
+
+
+      this.http = new HTTPClient(application_id, httpUrl, config.developer_key);
+      this.mqtt = await MQTTClient.getInstance(application_id, mqttUrl, config.developer_key);
       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"]);
@@ -252,4 +272,40 @@ export class SDK {
     }
     return new Collection(this.http["httpService"], this.mqtt ? this.mqtt["mqttService"] : null, collectionName);
   }
-}
+}
+
+async function getEnvPort(): Promise<string> {
+  console.log(window.location.origin)
+  try {
+    const response = await fetchData<{runtimeID:string, port:string}>(window.location.origin + "/_cfg");
+    // console.log('Response:', response);
+    // console.log('runtimeID: ', response.runtimeID);
+    // console.log('applicationID: ', response.runtimeID.split('XmchX')[0]);
+    return response.port;
+  } catch (error) {
+    // console.log('No configured runtime ID:', error);
+    // TODO: Use DevPort from SDK Config or default to 61888
+    return "61888";
+  }
+}
+
+
+async function fetchData<T>(url: string): Promise<T> {
+  try {
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: {
+        'Accept': 'application/json',
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    const data: T = await response.json();
+    return data;
+  } catch (error) {
+    throw error;
+  }
+}