@mitway/sdk 0.2.1 → 0.2.3

package/dist/index.cjs

@@ -26,6 +26,7 @@ __export(index_exports, {
   Logger: () => Logger,
   MitwayBaasClient: () => MitwayBaasClient,
   MitwayBaasError: () => MitwayBaasError,
+  Realtime: () => Realtime,
   TokenManager: () => TokenManager,
   createClient: () => createClient,
   default: () => index_default
@@ -258,6 +259,30 @@ var TokenManager = class {
   }
 };
 
+// src/lib/auth-envelope.ts
+function normalizeAuthPayload(raw) {
+  if (!raw || typeof raw !== "object") return raw;
+  const src = raw;
+  const out = { ...src };
+  let mutated = false;
+  if ("access_token" in src && !("accessToken" in src)) {
+    out.accessToken = src.access_token;
+    delete out.access_token;
+    mutated = true;
+  }
+  if ("csrf_token" in src && !("csrfToken" in src)) {
+    out.csrfToken = src.csrf_token;
+    delete out.csrf_token;
+    mutated = true;
+  }
+  if ("refresh_token" in src && !("refreshToken" in src)) {
+    out.refreshToken = src.refresh_token;
+    delete out.refresh_token;
+    mutated = true;
+  }
+  return mutated ? out : raw;
+}
+
 // src/lib/http-client.ts
 var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([500, 502, 503, 504]);
 var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "PUT", "DELETE", "OPTIONS"]);
@@ -453,17 +478,14 @@ var HttpClient = class {
             Date.now() - startTime,
             data
           );
-          if (data && typeof data === "object" && "error" in data) {
-            if (!data.statusCode && !data.status) {
-              data.statusCode = response.status;
-            }
-            const error = MitwayBaasError.fromApiError(data);
-            Object.keys(data).forEach((key) => {
-              if (key !== "error" && key !== "message" && key !== "statusCode") {
-                error[key] = data[key];
-              }
-            });
-            throw error;
+          if (data && typeof data === "object" && "error" in data && data.error !== null && typeof data.error === "object") {
+            const envErr = data.error;
+            throw new MitwayBaasError(
+              envErr.message || response.statusText || "Request failed",
+              envErr.statusCode || response.status,
+              envErr.code || envErr.error || "REQUEST_FAILED",
+              envErr.nextActions
+            );
           }
           throw new MitwayBaasError(
             `Request failed: ${response.statusText}`,
@@ -478,6 +500,9 @@ var HttpClient = class {
           Date.now() - startTime,
           data
         );
+        if (data && typeof data === "object" && "data" in data && "error" in data && data.error === null) {
+          return data.data;
+        }
         return data;
       } catch (err) {
         if (timer !== void 0) clearTimeout(timer);
@@ -590,7 +615,7 @@ var HttpClient = class {
             credentials: "include"
           }
         );
-        return response;
+        return normalizeAuthPayload(response);
       } finally {
         this.isRefreshing = false;
         this.refreshPromise = null;
@@ -649,11 +674,12 @@ var Auth = class {
    */
   async signUp(request) {
     try {
-      const response = await this.http.post(
+      const raw = await this.http.post(
         "/api/auth/register",
         request,
         { credentials: "include" }
       );
+      const response = normalizeAuthPayload(raw);
       if (response?.accessToken && response.user) {
         this.saveSessionFromResponse(response);
       }
@@ -667,11 +693,12 @@ var Auth = class {
    */
   async signInWithPassword(request) {
     try {
-      const response = await this.http.post(
+      const raw = await this.http.post(
         "/api/auth/login",
         request,
         { credentials: "include" }
       );
+      const response = normalizeAuthPayload(raw);
       if (response?.accessToken && response.user) {
         this.saveSessionFromResponse(response);
       }
@@ -862,18 +889,239 @@ var Database = class {
   }
 };
 
+// src/modules/realtime.ts
+var import_socket = require("socket.io-client");
+var DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
+var Realtime = class {
+  socket = null;
+  baseUrl;
+  options;
+  anonKey;
+  tokenManager;
+  listeners = /* @__PURE__ */ new Map();
+  reserved = {
+    connect: /* @__PURE__ */ new Set(),
+    disconnect: /* @__PURE__ */ new Set(),
+    connect_error: /* @__PURE__ */ new Set(),
+    error: /* @__PURE__ */ new Set()
+  };
+  connecting = null;
+  subscribedChannels = /* @__PURE__ */ new Set();
+  constructor(baseUrl, tokenManager, anonKey, options = {}) {
+    this.baseUrl = baseUrl;
+    this.tokenManager = tokenManager;
+    this.anonKey = anonKey;
+    this.options = options;
+  }
+  // -----------------------------------------------------------------
+  // Connection lifecycle
+  // -----------------------------------------------------------------
+  get isConnected() {
+    return this.socket?.connected === true;
+  }
+  get socketId() {
+    return this.socket?.id;
+  }
+  /** Explicitly open the connection. Safe to call multiple times; only
+   *  opens one socket per instance. Subsequent calls during connection
+   *  return the same in-flight promise. */
+  connect() {
+    if (this.isConnected) {
+      return Promise.resolve();
+    }
+    if (this.connecting) {
+      return this.connecting;
+    }
+    this.connecting = this.openSocket();
+    return this.connecting;
+  }
+  openSocket() {
+    const token = this.tokenManager.getAccessToken() ?? this.anonKey;
+    if (!token) {
+      const err = new MitwayBaasError(
+        "Realtime requires an access token or anonKey",
+        401,
+        "AUTH_INVALID_API_KEY"
+      );
+      this.connecting = null;
+      return Promise.reject(err);
+    }
+    const timeoutMs = this.options.timeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+    const socket = (0, import_socket.io)(this.baseUrl, {
+      path: this.options.path,
+      transports: this.options.transports ?? ["websocket"],
+      auth: { token, ...this.options.extraAuth ?? {} },
+      reconnection: true,
+      timeout: timeoutMs
+    });
+    this.socket = socket;
+    socket.onAny((event, ...args) => this.dispatch(event, args));
+    socket.on("connect", () => this.emitReserved("connect"));
+    socket.on("disconnect", (reason) => this.emitReserved("disconnect", reason));
+    socket.on("connect_error", (err) => this.emitReserved("connect_error", err));
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        socket.off("connect", onConnect);
+        socket.off("connect_error", onConnectError);
+        reject(
+          new MitwayBaasError(
+            `Realtime connection timeout after ${timeoutMs}ms`,
+            408,
+            "CONNECTION_TIMEOUT"
+          )
+        );
+        this.connecting = null;
+      }, timeoutMs);
+      const clear = () => {
+        clearTimeout(timer);
+        socket.off("connect", onConnect);
+        socket.off("connect_error", onConnectError);
+      };
+      const onConnect = () => {
+        clear();
+        this.connecting = null;
+        resolve();
+      };
+      const onConnectError = (err) => {
+        clear();
+        this.connecting = null;
+        reject(
+          new MitwayBaasError(err.message, 0, "CONNECTION_FAILED")
+        );
+      };
+      socket.once("connect", onConnect);
+      socket.once("connect_error", onConnectError);
+    });
+  }
+  /** Close the socket and clear in-memory subscription state. Reserved
+   *  listeners survive so callers can reconnect later via `connect()`. */
+  disconnect() {
+    if (!this.socket) {
+      return;
+    }
+    this.socket.disconnect();
+    this.socket = null;
+    this.subscribedChannels.clear();
+  }
+  // -----------------------------------------------------------------
+  // Subscribe / Unsubscribe / Publish
+  // -----------------------------------------------------------------
+  async subscribe(channel) {
+    await this.connect();
+    const socket = this.socket;
+    if (!socket) {
+      return {
+        ok: false,
+        channel,
+        error: { code: "NOT_CONNECTED", message: "Socket is not connected" }
+      };
+    }
+    const result = await new Promise((resolve) => {
+      socket.emit("realtime:subscribe", { channel }, (ack) => {
+        resolve(ack);
+      });
+    });
+    if (result.ok) {
+      this.subscribedChannels.add(channel);
+    }
+    return result;
+  }
+  /** Fire-and-forget. No ack from the server. */
+  unsubscribe(channel) {
+    this.subscribedChannels.delete(channel);
+    this.socket?.emit("realtime:unsubscribe", { channel });
+  }
+  /** Publish via the Socket.IO transport. Subject to RLS INSERT policy
+   *  on `realtime.messages` (disabled by default — the developer must
+   *  add a policy before clients can publish). Returns immediately; any
+   *  server rejection comes through the `error` reserved event. */
+  publish(channel, event, payload) {
+    this.socket?.emit("realtime:publish", { channel, event, payload });
+  }
+  // TypeScript overload impl signature must be assignable from every
+  // public overload. The public overloads take arg lists of different
+  // shapes (ConnectionListener: 0 args, DisconnectListener: 1 string
+  // arg, RealtimeListener: 2 args), so the implementation uses the
+  // widest possible signature. This matches the pattern in socket.io
+  // itself and is the standard TypeScript overload idiom.
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  on(event, cb) {
+    if (isReserved(event)) {
+      this.reserved[event].add(cb);
+      return;
+    }
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(cb);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  off(event, cb) {
+    if (isReserved(event)) {
+      this.reserved[event].delete(cb);
+      return;
+    }
+    this.listeners.get(event)?.delete(cb);
+  }
+  // -----------------------------------------------------------------
+  // Internals
+  // -----------------------------------------------------------------
+  dispatch(event, args) {
+    if (isReserved(event)) {
+      return;
+    }
+    if (event === "realtime:error") {
+      const err = args[0] ?? {};
+      this.reserved.error.forEach(
+        (cb) => cb(err, {
+          message_id: "",
+          sender_type: "system",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+      return;
+    }
+    const set = this.listeners.get(event);
+    if (!set || set.size === 0) {
+      return;
+    }
+    const envelope = args[0] ?? {};
+    const { meta, ...payload } = envelope;
+    const metaOrStub = meta ?? {
+      message_id: "",
+      sender_type: "system",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    set.forEach((cb) => cb(payload, metaOrStub));
+  }
+  emitReserved(event, ...args) {
+    const set = this.reserved[event];
+    set.forEach((cb) => cb(...args));
+  }
+};
+function isReserved(event) {
+  return event === "connect" || event === "disconnect" || event === "connect_error" || event === "error";
+}
+
 // src/client.ts
 var MitwayBaasClient = class {
   http;
   tokenManager;
   auth;
   database;
+  realtime;
   constructor(config = {}) {
     const logger = new Logger(config.debug);
     this.tokenManager = new TokenManager();
     this.http = new HttpClient(config, this.tokenManager, logger);
     this.auth = new Auth(this.http, this.tokenManager);
     this.database = new Database(this.http, this.tokenManager, config.anonKey);
+    this.realtime = new Realtime(
+      this.http.baseUrl,
+      this.tokenManager,
+      config.anonKey,
+      config.realtime
+    );
   }
   /**
    * Escape hatch for callers that need to make custom requests against the
@@ -897,6 +1145,7 @@ var index_default = MitwayBaasClient;
   Logger,
   MitwayBaasClient,
   MitwayBaasError,
+  Realtime,
   TokenManager,
   createClient
 });