@machhub-dev/sdk-ts 0.0.6 → 0.0.8

package/src/services/http.service.ts

@@ -19,39 +19,18 @@ export class HTTPService {
     private url: URL;
     private applicationID: string;
     private developerKey?: string;
+    private runtimeID?: string;
 
-    constructor(url: string, prefix: string, applicationID: string, developerKey?: string) {
+    constructor(url: string, prefix: string, applicationID: string, developerKey?: string, runtimeID?: string) {
         if (prefix == null) prefix = "";
         this.url = new URL(prefix, url);
         this.applicationID = "domains:" + applicationID
         this.developerKey = developerKey
+        this.runtimeID = runtimeID
     }
 
     public get request(): RequestParameters {
-        return new RequestParameters(this.url, this.applicationID, this.developerKey);
-    }
-
-    private addRuntimeHeaders(headers: Record<string, string> = {}): Record<string, string> {
-        // 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;
-    }
-
-    private getCookie(name: string): string | null {
-        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;
+        return new RequestParameters(this.url, this.applicationID, this.developerKey, this.runtimeID);
     }
 }
 
@@ -59,18 +38,21 @@ class RequestParameters {
     private base: URL;
     private applicationID: string;
     private developerKey?: string;
+    private runtimeID?: string;
     public query?: Record<string, string>;
     public init?: RequestInit;
     public headers?: Record<string, string>;
 
-    constructor(base: URL, applicationID: string, developerKey?:string, query?: Record<string, string>) {
+    constructor(base: URL, applicationID: string, developerKey?: string, runtimeID?: string, query?: Record<string, string>) {
         this.base = base;
         this.applicationID = applicationID;
         this.developerKey = developerKey;
+        this.runtimeID = runtimeID;
         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
+        this.withRuntimeID(); // Ensure withRuntimeID() is called by default
     }
 
     private withQuery(path: string, query?: Record<string, string>): URL {
@@ -170,6 +152,11 @@ class RequestParameters {
         return this;
     }
 
+    public withRuntimeID(): RequestParameters {
+        this.setHeader("X-Machhub-Runtime-Id", this.runtimeID ?? "");
+        return this;
+    }
+
     public withDomain(): RequestParameters {
         this.setHeader("Domain", this.applicationID);
         return this;
@@ -211,6 +198,12 @@ class RequestParameters {
         if (body) {
             if (body instanceof FormData) {
                 init.body = body;
+                // Remove Content-Type header if it exists, let browser set it for FormData
+                if (init.headers && typeof init.headers === 'object') {
+                    const headers = init.headers as Record<string, string>;
+                    delete headers['Content-Type'];
+                    delete headers['content-type'];
+                }
             } else {
                 init.body = JSON.stringify(body);
                 init.headers = {

package/src/services/mqtt.service.ts

@@ -50,7 +50,7 @@ export class MQTTService {
         try {
             this.subscribedTopics.push({ topic, handler });
             if (topic == "") return;
-            console.log("New Subscription Handler:", topic);
+            // console.log("New Subscription Handler:", topic);
             this.client.subscribe(topic, { qos: 2 }, (err?: unknown) => {
                 if (err) {
                     console.error(`Failed to subscribe to topic ${topic}:`, err);
@@ -70,7 +70,7 @@ export class MQTTService {
     public publish(topic: string, message: unknown): boolean {
         try {
             const payload = JSON.stringify(message);
-            console.log("Publishing to", topic, "with payload:", payload);
+            // console.log("Publishing to", topic, "with payload:", payload);
 
             this.client.publish(topic, payload, {
                 qos: 2,

package/src/services/nats.service.ts

@@ -119,21 +119,31 @@ export class NATSService {
                     return;
                 }
 
-                const data = JSON.parse(msg.data.toString()) as Record<string, any>;
-                const subjectParts = msg.subject.split(".");
-                if (subjectParts.length !== 4) {
-                    msg.respond(JSON.stringify({ error: "Invalid subject format" }));
-                    return;
-                }
+                try {
+                    const dataStr = Buffer.from(msg.data).toString('utf-8');
+                    const data = JSON.parse(dataStr) as Record<string, any>;
+                    const subjectParts = msg.subject.split(".");
+                    if (subjectParts.length !== 4) {
+                        msg.respond(JSON.stringify({ error: "Invalid subject format" }));
+                        return;
+                    }
 
-                const functionName = subjectParts[3];
-                this.executeFunction(functionName, data)
-                    .then((result) => {
-                        msg.respond(JSON.stringify(result));
-                    })
-                    .catch((e: any) => {
-                        msg.respond(JSON.stringify({ status: "failed", error: e.message }));
-                    });
+                    const functionName = subjectParts[3];
+                    this.executeFunction(functionName, data)
+                        .then((result) => {
+                            msg.respond(JSON.stringify(result));
+                        })
+                        .catch((e: any) => {
+                            console.log("Error executing function '" + functionName + "': ", e);
+                            msg.respond(JSON.stringify({ status: "failed", error: e.message }));
+                        });
+                } catch (parseError: any) {
+                    console.error("Error parsing function execution message:", parseError);
+                    msg.respond(JSON.stringify({ 
+                        status: "failed", 
+                        error: `Failed to parse message: ${parseError.message}` 
+                    }));
+                }
             },
         });
         if (sub) this.subscriptions.push(sub);
@@ -223,16 +233,37 @@ export class NATSService {
     }
 
     /**
-     * Parses a message buffer into a JSON object.
+     * Parses a message buffer into a JSON object or returns raw data.
      * @param message {Uint8Array} The message buffer.
-     * @returns {unknown} The parsed message.
+     * @returns {unknown} The parsed message (JSON object) or the raw string if parsing fails.
      */
     private parseMessage(message: Uint8Array): unknown {
         try {
-            return JSON.parse(Buffer.from(message).toString());
+            const messageStr = Buffer.from(message).toString('utf-8');
+            // Check if the message is empty
+            if (!messageStr || messageStr.trim().length === 0) {
+                NATSService.log("Received empty message");
+                return null;
+            }
+            
+            // Try to parse as JSON
+            return JSON.parse(messageStr);
         } catch (error) {
+            // If JSON parsing fails, check if it's binary data or non-JSON content
+            const messageStr = Buffer.from(message).toString('utf-8');
+            
+            // Check if it looks like binary data (contains non-printable characters)
+            const isBinary = message.some(byte => byte < 32 && byte !== 9 && byte !== 10 && byte !== 13);
+            
+            if (isBinary) {
+                NATSService.log("Received binary data, returning as Uint8Array");
+                return message; // Return raw binary data
+            }
+            
+            // If it's a plain string (not JSON), return as is
+            NATSService.log("Failed to parse message as JSON, returning as string:", messageStr.substring(0, 100));
             console.error("Error parsing message:", error);
-            return null;
+            return messageStr;
         }
     }