@objectstack/client 4.0.2 → 4.0.4

package/dist/index.mjs

@@ -2,6 +2,135 @@
 import { isFilterAST } from "@objectstack/spec/data";
 import { createLogger } from "@objectstack/core";
 
+// src/realtime-api.ts
+var RealtimeAPI = class {
+  constructor(baseUrl, token) {
+    this.subscriptions = /* @__PURE__ */ new Map();
+    this.eventBuffer = [];
+    this._baseUrl = baseUrl;
+    this._token = token;
+  }
+  /**
+   * Subscribe to metadata events
+   * Returns an unsubscribe function
+   */
+  subscribeMetadata(type, callback, options) {
+    const subscriptionId = `metadata-${type}-${Date.now()}`;
+    this.subscriptions.set(subscriptionId, {
+      filter: {
+        type,
+        packageId: options?.packageId,
+        eventTypes: [
+          `metadata.${type}.created`,
+          `metadata.${type}.updated`,
+          `metadata.${type}.deleted`
+        ]
+      },
+      handler: (event) => {
+        if (event.type.startsWith("metadata.")) {
+          callback(event);
+        }
+      }
+    });
+    this.startPolling();
+    return () => {
+      this.subscriptions.delete(subscriptionId);
+      if (this.subscriptions.size === 0) {
+        this.stopPolling();
+      }
+    };
+  }
+  /**
+   * Subscribe to data record events
+   * Returns an unsubscribe function
+   */
+  subscribeData(object, callback, options) {
+    const subscriptionId = `data-${object}-${Date.now()}`;
+    this.subscriptions.set(subscriptionId, {
+      filter: {
+        type: object,
+        recordId: options?.recordId,
+        eventTypes: [
+          "data.record.created",
+          "data.record.updated",
+          "data.record.deleted"
+        ]
+      },
+      handler: (event) => {
+        if (event.type.startsWith("data.") && event.object === object) {
+          if (!options?.recordId || event.payload?.recordId === options.recordId) {
+            callback(event);
+          }
+        }
+      }
+    });
+    this.startPolling();
+    return () => {
+      this.subscriptions.delete(subscriptionId);
+      if (this.subscriptions.size === 0) {
+        this.stopPolling();
+      }
+    };
+  }
+  /**
+   * Emit an event to all matching subscriptions (client-side only)
+   * This is used for in-process event delivery
+   */
+  emitEvent(event) {
+    for (const sub of this.subscriptions.values()) {
+      const matchesType = !sub.filter.type || event.type.includes(sub.filter.type) || event.object === sub.filter.type;
+      const matchesEventType = !sub.filter.eventTypes?.length || sub.filter.eventTypes.includes(event.type);
+      const matchesPackage = !sub.filter.packageId || event.payload?.packageId === sub.filter.packageId;
+      if (matchesType && matchesEventType && matchesPackage) {
+        try {
+          sub.handler(event);
+        } catch (error) {
+          console.error("Error in realtime event handler:", error);
+        }
+      }
+    }
+  }
+  /**
+   * Start polling for events (fallback mechanism)
+   * In production, this would be replaced with WebSocket/SSE
+   */
+  startPolling() {
+    if (this.pollInterval) return;
+    this.pollInterval = setInterval(() => {
+      while (this.eventBuffer.length > 0) {
+        const event = this.eventBuffer.shift();
+        if (event) {
+          this.emitEvent(event);
+        }
+      }
+    }, 2e3);
+  }
+  /**
+   * Stop polling for events
+   */
+  stopPolling() {
+    if (this.pollInterval) {
+      clearInterval(this.pollInterval);
+      this.pollInterval = void 0;
+    }
+  }
+  /**
+   * Internal method to buffer events from server
+   * This would be called by WebSocket/SSE handlers in production
+   */
+  _bufferEvent(event) {
+    this.eventBuffer.push(event);
+  }
+  /**
+   * Disconnect and clean up all subscriptions
+   */
+  disconnect() {
+    this.stopPolling();
+    this.subscriptions.clear();
+    this.eventBuffer = [];
+  }
+};
+
 // src/query-builder.ts
 var FilterBuilder = class {
   constructor() {
@@ -506,6 +635,15 @@ var ObjectStackClient = class {
      * Authentication Services
      */
     this.auth = {
+      /**
+       * Get authentication configuration
+       * Returns available auth providers and features
+       */
+      getConfig: async () => {
+        const route = this.getRoute("auth");
+        const res = await this.fetch(`${this.baseUrl}${route}/config`);
+        return this.unwrapResponse(res);
+      },
       /**
        * Login with email and password
        * Uses better-auth endpoint: POST /sign-in/email
@@ -1472,6 +1610,7 @@ var ObjectStackClient = class {
       level: config.debug ? "debug" : "info",
       format: "pretty"
     });
+    this.realtimeAPI = new RealtimeAPI(this.baseUrl, this.token);
     this.logger.debug("ObjectStack client created", { baseUrl: this.baseUrl });
   }
   /**
@@ -1482,6 +1621,18 @@ var ObjectStackClient = class {
     try {
       let data;
       try {
+        const discoveryUrl = `${this.baseUrl}/api/v1/discovery`;
+        this.logger.debug("Probing protocol-standard discovery endpoint", { url: discoveryUrl });
+        const res = await this.fetchImpl(discoveryUrl);
+        if (res.ok) {
+          const body = await res.json();
+          data = body.data || body;
+          this.logger.debug("Discovered via /api/v1/discovery");
+        }
+      } catch (e) {
+        this.logger.debug("Protocol-standard discovery probe failed", { error: e.message });
+      }
+      if (!data) {
         let wellKnownUrl;
         try {
           const url = new URL(this.baseUrl);
@@ -1489,22 +1640,10 @@ var ObjectStackClient = class {
         } catch {
           wellKnownUrl = "/.well-known/objectstack";
         }
-        this.logger.debug("Probing .well-known discovery", { url: wellKnownUrl });
+        this.logger.debug("Falling back to .well-known discovery", { url: wellKnownUrl });
         const res = await this.fetchImpl(wellKnownUrl);
-        if (res.ok) {
-          const body = await res.json();
-          data = body.data || body;
-          this.logger.debug("Discovered via .well-known");
-        }
-      } catch (e) {
-        this.logger.debug("Standard discovery probe failed", { error: e.message });
-      }
-      if (!data) {
-        const fallbackUrl = `${this.baseUrl}/api/v1/discovery`;
-        this.logger.debug("Falling back to standard discovery endpoint", { url: fallbackUrl });
-        const res = await this.fetchImpl(fallbackUrl);
         if (!res.ok) {
-          throw new Error(`Failed to connect to ${fallbackUrl}: ${res.statusText}`);
+          throw new Error(`Failed to connect to ${wellKnownUrl}: ${res.statusText}`);
         }
         const body = await res.json();
         data = body.data || body;
@@ -1542,6 +1681,13 @@ var ObjectStackClient = class {
     }
     return result;
   }
+  /**
+   * Event Subscription API
+   * Provides real-time event subscriptions for metadata and data changes
+   */
+  get events() {
+    return this.realtimeAPI;
+  }
   /**
    * Private Helpers
    */
@@ -1645,6 +1791,7 @@ export {
   FilterBuilder,
   ObjectStackClient,
   QueryBuilder,
+  RealtimeAPI,
   createFilter,
   createQuery
 };