@machhub-dev/sdk-ts 0.0.6 → 0.0.8

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

@@ -1,5 +1,11 @@
 import { HTTPService } from "../services/http.service.js";
 import { MQTTService } from "../services/mqtt.service.js";
+export declare class CollectionError extends Error {
+    operation: string;
+    collectionName: string;
+    originalError: Error;
+    constructor(operation: string, collectionName: string, originalError: Error);
+}
 export declare class Collection {
     protected httpService: HTTPService;
     protected mqttService: MQTTService | null;

package/dist/cjs/classes/collection.js

@@ -1,6 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Collection = void 0;
+exports.Collection = exports.CollectionError = void 0;
+class CollectionError extends Error {
+    constructor(operation, collectionName, originalError) {
+        super(`Collection operation '${operation}' failed on '${collectionName}': ${originalError.message}`);
+        this.name = 'CollectionError';
+        this.operation = operation;
+        this.collectionName = collectionName;
+        this.originalError = originalError;
+    }
+}
+exports.CollectionError = CollectionError;
 class Collection {
     constructor(httpService, mqttService, collectionName) {
         this.queryParams = {};
@@ -25,28 +35,63 @@ class Collection {
         return this;
     }
     async getAll() {
-        return this.httpService.request.get(this.collectionName + "/all", this.queryParams);
+        try {
+            return await this.httpService.request.get(this.collectionName + "/all", this.queryParams);
+        }
+        catch (error) {
+            throw new CollectionError('getAll', this.collectionName, error);
+        }
     }
     async getOne(id) {
         if (!id) {
             throw new Error("ID must be provided");
         }
-        return this.httpService.request.get(id);
+        try {
+            return await this.httpService.request.get(id);
+        }
+        catch (error) {
+            throw new CollectionError('getOne', this.collectionName, error);
+        }
     }
     async create(data) {
-        return this.httpService.request.withJSON(data).post(this.collectionName);
+        try {
+            const formData = new FormData();
+            for (const [key, value] of Object.entries(data)) {
+                if (value instanceof File) {
+                    formData.append(key, value, value.name);
+                    data[key] = value.name;
+                }
+            }
+            formData.append("record", JSON.stringify(data));
+            return await this.httpService.request
+                .withBody(formData)
+                .post(this.collectionName);
+        }
+        catch (error) {
+            throw new CollectionError("create", this.collectionName, error);
+        }
     }
     async update(id, data) {
         if (!id) {
             throw new Error("ID must be provided");
         }
-        return this.httpService.request.withJSON(data).put(id);
+        try {
+            return await this.httpService.request.withJSON(data).put(id);
+        }
+        catch (error) {
+            throw new CollectionError('update', this.collectionName, error);
+        }
     }
     async delete(id) {
         if (!id) {
             throw new Error("ID must be provided");
         }
-        return this.httpService.request.delete(id);
+        try {
+            return await this.httpService.request.delete(id);
+        }
+        catch (error) {
+            throw new CollectionError('delete', this.collectionName, error);
+        }
     }
 }
 exports.Collection = Collection;

package/dist/cjs/sdk-ts.js

@@ -18,8 +18,8 @@ class HTTPClient {
      * @param applicationID The ID for your application (required)
      * @param httpUrl The base URL for HTTP connection (default = http://localhost:6188)
      */
-    constructor(applicationID, httpUrl, developerKey) {
-        this.httpService = new http_service_js_1.HTTPService(httpUrl, MACHHUB_SDK_PATH, applicationID, developerKey);
+    constructor(applicationID, httpUrl, developerKey, runtimeID) {
+        this.httpService = new http_service_js_1.HTTPService(httpUrl, MACHHUB_SDK_PATH, applicationID, developerKey, runtimeID);
     }
     /**
      * Gets server info
@@ -147,20 +147,20 @@ class SDK {
             if (!config.application_id)
                 config = { application_id: "" };
             // console.log("Using application_id:", config.application_id);
-            const PORT = await getEnvPort();
-            // console.log("Using port:", PORT);
+            const { port, runtimeID } = await getEnvConfig();
+            console.log("Port:", port);
             if (!config.httpUrl) {
-                config.httpUrl = "http://localhost:" + PORT;
+                config.httpUrl = "http://localhost:" + port;
             }
             if (!config.mqttUrl) {
-                config.mqttUrl = "ws://localhost:" + PORT + "/mqtt";
+                config.mqttUrl = "ws://localhost:" + port + "/mqtt";
             }
             if (!config.natsUrl) {
-                config.natsUrl = "ws://localhost:" + PORT + "/nats";
+                config.natsUrl = "ws://localhost:" + port + "/nats";
             }
             const { application_id, httpUrl, mqttUrl, natsUrl } = config;
-            // console.log("Final config:", { application_id, httpUrl, mqttUrl, natsUrl });
-            this.http = new HTTPClient(application_id, httpUrl, config.developer_key);
+            console.log("SDK Config:", { application_id, httpUrl, mqttUrl, natsUrl, developer_key: config.developer_key?.split('').map((_, i) => i < config.developer_key.length - 4 ? '*' : config.developer_key[i]).join('') });
+            this.http = new HTTPClient(application_id, httpUrl, config.developer_key, runtimeID);
             this.mqtt = await MQTTClient.getInstance(application_id, mqttUrl, config.developer_key);
             this.nats = await NATSClient.getInstance(application_id, natsUrl);
             this._historian = new historian_js_1.Historian(this.http["httpService"], this.mqtt["mqttService"]);
@@ -234,27 +234,106 @@ class SDK {
     }
 }
 exports.SDK = SDK;
-async function getEnvPort() {
+async function getEnvConfig() {
     try {
-        const response = await fetchData(window.location.origin + "/_cfg");
+        // Try to find the configuration endpoint by testing different base paths
+        const configUrl = await findConfigEndpoint();
+        const response = await fetchData(configUrl);
         // console.log('Response:', response);
         // console.log('runtimeID: ', response.runtimeID);
         // console.log('applicationID: ', response.runtimeID.split('XmchX')[0]);
-        return response.port;
+        return { port: response.port, runtimeID: response.runtimeID };
     }
     catch (error) {
         // console.log('No configured runtime ID:', error);
         // TODO: Use DevPort from SDK Config or default to 61888
-        return "61888";
+        return { port: "61888", runtimeID: "" };
     }
 }
-async function fetchData(url) {
+/**
+ * Attempts to find the correct configuration endpoint by trying different base paths
+ * Handles both port-based hosting (direct) and path-based hosting (reverse proxy)
+ */
+async function findConfigEndpoint() {
+    const origin = window.location.origin;
+    const pathname = window.location.pathname;
+    // List of potential base paths to try, ordered by likelihood
+    const basePaths = [
+        // 1. Try origin directly (for port-based hosting like localhost:6190)
+        origin,
+        // 2. Try current path segments for path-based hosting
+        ...generatePathCandidates(pathname),
+        // 3. Try common root paths as fallback
+        origin,
+    ];
+    // Remove duplicates while preserving order
+    const uniqueBasePaths = [...new Set(basePaths)];
+    for (const basePath of uniqueBasePaths) {
+        try {
+            const configUrl = `${basePath}/_cfg`;
+            // Test if this endpoint returns valid JSON config by making a GET request
+            const testResponse = await fetch(configUrl, {
+                method: 'GET',
+                headers: {
+                    'Accept': 'application/json',
+                },
+                signal: AbortSignal.timeout(2000) // 2 second timeout
+            });
+            if (testResponse.ok) {
+                // Validate that the response is JSON and contains the expected 'port' field
+                const contentType = testResponse.headers.get('content-type');
+                if (contentType && contentType.includes('application/json')) {
+                    try {
+                        const testData = await testResponse.json();
+                        // Check if the response has the expected structure with a 'port' field
+                        if (testData && typeof testData === 'object' && 'port' in testData) {
+                            // console.log(`Found config endpoint at: ${configUrl}`);
+                            return configUrl;
+                        }
+                    }
+                    catch (jsonError) {
+                        // Not valid JSON, continue to next candidate
+                        continue;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Continue to next candidate
+            continue;
+        }
+    }
+    // If all attempts fail, default to origin + /_cfg
+    console.warn('Could not find config endpoint, using default origin');
+    return `${origin}/_cfg`;
+}
+/**
+ * Generates potential base path candidates from the current pathname
+ * For example, /demo2/homepage/settings would generate:
+ * - http://localhost/demo2/homepage
+ * - http://localhost/demo2
+ * - http://localhost
+ */
+function generatePathCandidates(pathname) {
+    const origin = window.location.origin;
+    const pathSegments = pathname.split('/').filter(segment => segment.length > 0);
+    const candidates = [];
+    // Generate paths by progressively removing segments from the end
+    for (let i = pathSegments.length; i > 0; i--) {
+        const path = '/' + pathSegments.slice(0, i).join('/');
+        candidates.push(origin + path);
+    }
+    return candidates;
+}
+async function fetchData(url, options) {
     try {
         const response = await fetch(url, {
             method: 'GET',
             headers: {
                 'Accept': 'application/json',
             },
+            signal: AbortSignal.timeout(5000), // 5 second timeout
+            ...options
         });
         if (!response.ok) {
             throw new Error(`HTTP error! status: ${response.status}`);

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

@@ -9,19 +9,19 @@ export declare class HTTPService {
     private url;
     private applicationID;
     private developerKey?;
-    constructor(url: string, prefix: string, applicationID: string, developerKey?: string);
+    private runtimeID?;
+    constructor(url: string, prefix: string, applicationID: string, developerKey?: string, runtimeID?: string);
     get request(): RequestParameters;
-    private addRuntimeHeaders;
-    private getCookie;
 }
 declare class RequestParameters {
     private base;
     private applicationID;
     private developerKey?;
+    private runtimeID?;
     query?: Record<string, string>;
     init?: RequestInit;
     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>);
     private withQuery;
     private parseInit;
     withBody(body: BodyInit): RequestParameters;
@@ -33,6 +33,7 @@ declare class RequestParameters {
     setHeader(key: string, value: string): RequestParameters;
     setBearerToken(token: string): RequestParameters;
     withAccessToken(): RequestParameters;
+    withRuntimeID(): RequestParameters;
     withDomain(): RequestParameters;
     withDeveloperKey(): RequestParameters;
     withContentType(mime: string): RequestParameters;

package/dist/cjs/services/http.service.js

@@ -14,47 +14,30 @@ class HTTPException extends Error {
 }
 exports.HTTPException = HTTPException;
 class HTTPService {
-    constructor(url, prefix, applicationID, developerKey) {
+    constructor(url, prefix, applicationID, developerKey, runtimeID) {
         if (prefix == null)
             prefix = "";
         this.url = new URL(prefix, url);
         this.applicationID = "domains:" + applicationID;
         this.developerKey = developerKey;
+        this.runtimeID = runtimeID;
     }
     get request() {
-        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;
+        return new RequestParameters(this.url, this.applicationID, this.developerKey, this.runtimeID);
     }
 }
 exports.HTTPService = HTTPService;
 class RequestParameters {
-    constructor(base, applicationID, developerKey, query) {
+    constructor(base, applicationID, developerKey, runtimeID, query) {
         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
     }
     withQuery(path, query) {
         const newPath = [this.base.pathname, path].map(pathPart => pathPart.replace(/(^\/|\/$)/g, "")).join("/");
@@ -138,6 +121,10 @@ class RequestParameters {
         this.setHeader("Authorization", `Bearer ${tkn}`);
         return this;
     }
+    withRuntimeID() {
+        this.setHeader("X-Machhub-Runtime-Id", this.runtimeID ?? "");
+        return this;
+    }
     withDomain() {
         this.setHeader("Domain", this.applicationID);
         return this;
@@ -168,6 +155,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;
+                    delete headers['Content-Type'];
+                    delete headers['content-type'];
+                }
             }
             else {
                 init.body = JSON.stringify(body);

package/dist/cjs/services/mqtt.service.js

@@ -42,7 +42,7 @@ class MQTTService {
             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) => {
                 if (err) {
                     console.error(`Failed to subscribe to topic ${topic}:`, err);
@@ -61,7 +61,7 @@ class MQTTService {
     publish(topic, message) {
         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,
                 retain: true,

package/dist/cjs/services/nats.service.d.ts

@@ -66,9 +66,9 @@ export declare class NATSService {
      */
     printFunctions(): void;
     /**
-     * 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;
     /**

package/dist/cjs/services/nats.service.js

@@ -107,20 +107,31 @@ class NATSService {
                     console.error("Error handling message:", err);
                     return;
                 }
-                const data = JSON.parse(msg.data.toString());
-                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);
+                    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) => {
+                        console.log("Error executing function '" + functionName + "': ", e);
+                        msg.respond(JSON.stringify({ status: "failed", error: e.message }));
+                    });
+                }
+                catch (parseError) {
+                    console.error("Error parsing function execution message:", parseError);
+                    msg.respond(JSON.stringify({
+                        status: "failed",
+                        error: `Failed to parse message: ${parseError.message}`
+                    }));
                 }
-                const functionName = subjectParts[3];
-                this.executeFunction(functionName, data)
-                    .then((result) => {
-                    msg.respond(JSON.stringify(result));
-                })
-                    .catch((e) => {
-                    msg.respond(JSON.stringify({ status: "failed", error: e.message }));
-                });
             },
         });
         if (sub)
@@ -195,17 +206,34 @@ class NATSService {
         NATSService.log("Available functions: ", Object.keys(this.functions).join(", "));
     }
     /**
-     * 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.
      */
     parseMessage(message) {
         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;
         }
     }
     /**

package/dist/classes/collection.d.ts

@@ -1,5 +1,11 @@
 import { HTTPService } from "../services/http.service.js";
 import { MQTTService } from "../services/mqtt.service.js";
+export declare class CollectionError extends Error {
+    operation: string;
+    collectionName: string;
+    originalError: Error;
+    constructor(operation: string, collectionName: string, originalError: Error);
+}
 export declare class Collection {
     protected httpService: HTTPService;
     protected mqttService: MQTTService | null;

package/dist/classes/collection.js

@@ -1,3 +1,12 @@
+export class CollectionError extends Error {
+    constructor(operation, collectionName, originalError) {
+        super(`Collection operation '${operation}' failed on '${collectionName}': ${originalError.message}`);
+        this.name = 'CollectionError';
+        this.operation = operation;
+        this.collectionName = collectionName;
+        this.originalError = originalError;
+    }
+}
 export class Collection {
     constructor(httpService, mqttService, collectionName) {
         this.queryParams = {};
@@ -22,27 +31,62 @@ export class Collection {
         return this;
     }
     async getAll() {
-        return this.httpService.request.get(this.collectionName + "/all", this.queryParams);
+        try {
+            return await this.httpService.request.get(this.collectionName + "/all", this.queryParams);
+        }
+        catch (error) {
+            throw new CollectionError('getAll', this.collectionName, error);
+        }
     }
     async getOne(id) {
         if (!id) {
             throw new Error("ID must be provided");
         }
-        return this.httpService.request.get(id);
+        try {
+            return await this.httpService.request.get(id);
+        }
+        catch (error) {
+            throw new CollectionError('getOne', this.collectionName, error);
+        }
     }
     async create(data) {
-        return this.httpService.request.withJSON(data).post(this.collectionName);
+        try {
+            const formData = new FormData();
+            for (const [key, value] of Object.entries(data)) {
+                if (value instanceof File) {
+                    formData.append(key, value, value.name);
+                    data[key] = value.name;
+                }
+            }
+            formData.append("record", JSON.stringify(data));
+            return await this.httpService.request
+                .withBody(formData)
+                .post(this.collectionName);
+        }
+        catch (error) {
+            throw new CollectionError("create", this.collectionName, error);
+        }
     }
     async update(id, data) {
         if (!id) {
             throw new Error("ID must be provided");
         }
-        return this.httpService.request.withJSON(data).put(id);
+        try {
+            return await this.httpService.request.withJSON(data).put(id);
+        }
+        catch (error) {
+            throw new CollectionError('update', this.collectionName, error);
+        }
     }
     async delete(id) {
         if (!id) {
             throw new Error("ID must be provided");
         }
-        return this.httpService.request.delete(id);
+        try {
+            return await this.httpService.request.delete(id);
+        }
+        catch (error) {
+            throw new CollectionError('delete', this.collectionName, error);
+        }
     }
 }