@machhub-dev/sdk-ts 0.0.6 → 0.0.8

package/dist/sdk-ts.js

@@ -15,8 +15,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 HTTPService(httpUrl, MACHHUB_SDK_PATH, applicationID, developerKey);
+    constructor(applicationID, httpUrl, developerKey, runtimeID) {
+        this.httpService = new HTTPService(httpUrl, MACHHUB_SDK_PATH, applicationID, developerKey, runtimeID);
     }
     /**
      * Gets server info
@@ -144,20 +144,20 @@ export 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(this.http["httpService"], this.mqtt["mqttService"]);
@@ -230,27 +230,106 @@ export class SDK {
         return new Collection(this.http["httpService"], this.mqtt ? this.mqtt["mqttService"] : null, collectionName);
     }
 }
-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/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/services/http.service.js

@@ -10,46 +10,29 @@ export class HTTPException extends Error {
     }
 }
 export 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);
     }
 }
 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("/");
@@ -133,6 +116,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;
@@ -163,6 +150,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/services/mqtt.service.js

@@ -36,7 +36,7 @@ export 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);
@@ -55,7 +55,7 @@ export 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/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/services/nats.service.js

@@ -104,20 +104,31 @@ export 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)
@@ -192,17 +203,34 @@ export 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@machhub-dev/sdk-ts",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "MACHHUB TYPESCRIPT SDK",
   "keywords": [
     "machhub",
@@ -20,14 +20,14 @@
     "build": "npx tsc && npx tsc --module CommonJS --outDir dist/cjs"
   },
   "dependencies": {
+    "@nats-io/nats-core": "^3.0.2",
+    "@nats-io/transport-node": "^3.0.2",
     "mqtt": "^5.10.4",
     "safe-buffer": "^5.2.1",
     "typescript": "^5.8.3",
-    "undici-types": "^7.4.0",
-    "@nats-io/nats-core": "^3.0.2",
-    "@nats-io/transport-node": "^3.0.2"
+    "undici-types": "^7.4.0"
   },
   "devDependencies": {
     "@types/node": "^22.13.5"
   }
-}
+}

package/src/classes/collection.ts

@@ -1,6 +1,20 @@
 import { HTTPService } from "../services/http.service.js";
 import { MQTTService } from "../services/mqtt.service.js";
 
+export class CollectionError extends Error {
+  public operation: string;
+  public collectionName: string;
+  public originalError: Error;
+
+  constructor(operation: string, collectionName: string, originalError: Error) {
+    super(`Collection operation '${operation}' failed on '${collectionName}': ${originalError.message}`);
+    this.name = 'CollectionError';
+    this.operation = operation;
+    this.collectionName = collectionName;
+    this.originalError = originalError;
+  }
+}
+
 export class Collection {
   protected httpService: HTTPService;
   protected mqttService: MQTTService | null;
@@ -13,6 +27,7 @@ export class Collection {
     this.collectionName = collectionName;
   }
 
+
   filter(fieldName: string, operator: "=" | ">" | "<" | "<=" | ">=" | "!=", value: any): Collection {
     this.queryParams[`filter[${fieldName}][${operator}][${typeof value}]`] = value;
     return this;
@@ -34,31 +49,62 @@ export class Collection {
   }
 
   async getAll(): Promise<any[]> {
-    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 as Error);
+    }
   }
 
   async getOne(id: string): Promise<any> {
     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 as Error);
+    }
   }
 
   async create(data: Record<string, any>): Promise<any> {
-    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 as Error);
+    }
   }
 
   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);
+    try {
+      return await this.httpService.request.withJSON(data).put(id);
+    } catch (error) {
+      throw new CollectionError('update', this.collectionName, error as Error);
+    }
   }
 
   async delete(id: string): Promise<any> {
     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 as Error);
+    }
   }
 }

package/src/sdk-ts.ts

@@ -19,8 +19,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: string, httpUrl:string, developerKey?: string) {
-    this.httpService = new HTTPService(httpUrl, MACHHUB_SDK_PATH, applicationID, developerKey);
+  constructor(applicationID: string, httpUrl:string, developerKey?: string, runtimeID?: string) {
+    this.httpService = new HTTPService(httpUrl, MACHHUB_SDK_PATH, applicationID, developerKey, runtimeID);
   }
 
   /**
@@ -173,26 +173,26 @@ export class SDK {
       // 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 });
+      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);
+      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);
       
@@ -273,28 +273,117 @@ export class SDK {
   }
 }
 
-async function getEnvPort(): Promise<string> {
+async function getEnvConfig(): Promise<{port:string, runtimeID:string}> {
   try {
-    const response = await fetchData<{runtimeID:string, port:string}>(window.location.origin + "/_cfg");
+    // Try to find the configuration endpoint by testing different base paths
+    const configUrl = await findConfigEndpoint();
+    const response = await fetchData<{port:string, runtimeID:string}>(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: ""};
   }
 }
 
+/**
+ * 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(): Promise<string> {
+  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: string): string[] {
+  const origin = window.location.origin;
+  const pathSegments = pathname.split('/').filter(segment => segment.length > 0);
+  const candidates: string[] = [];
+
+  // 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<T>(url: string): Promise<T> {
+async function fetchData<T>(url: string, options?: RequestInit): Promise<T> {
   try {
     const response = await fetch(url, {
       method: 'GET',
       headers: {
         'Accept': 'application/json',
       },
+      signal: AbortSignal.timeout(5000), // 5 second timeout
+      ...options
     });
 
     if (!response.ok) {