@rebasepro/client 0.0.1-canary.09e5ec5

package/dist/index.umd.js

@@ -0,0 +1,2279 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("@rebasepro/types"), require("@rebasepro/utils")) : typeof define === "function" && define.amd ? define(["exports", "@rebasepro/types", "@rebasepro/utils"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["Rebase Client"] = {}, global.types, global.utils));
+})(this, function(exports2, types, utils) {
+  "use strict";
+  function rebaseReviver(_key, value) {
+    if (value && typeof value === "object" && "__type" in value) {
+      const record = value;
+      switch (record.__type) {
+        case "date":
+        case "Date": {
+          if (typeof record.value !== "string") {
+            return value;
+          }
+          const date = new Date(record.value);
+          return isNaN(date.getTime()) ? null : date;
+        }
+        case "reference":
+        case "EntityReference":
+          return new types.EntityReference({
+            id: String(record.id),
+            path: record.path,
+            driver: record.driver,
+            databaseId: record.databaseId
+          });
+        case "relation":
+        case "EntityRelation":
+          return new types.EntityRelation(
+            record.id,
+            record.path,
+            record.data
+          );
+        case "GeoPoint":
+          return new types.GeoPoint(record.latitude, record.longitude);
+        case "Vector":
+          return new types.Vector(record.value);
+        default:
+          return value;
+      }
+    }
+    return value;
+  }
+  class RebaseApiError extends Error {
+    status;
+    code;
+    details;
+    constructor(status, message, code, details) {
+      super(message);
+      this.name = "RebaseApiError";
+      this.status = status;
+      this.code = code;
+      this.details = details;
+    }
+  }
+  const OP_MAP = {
+    "==": "eq",
+    "!=": "neq",
+    ">": "gt",
+    ">=": "gte",
+    "<": "lt",
+    "<=": "lte",
+    "not-in": "nin",
+    "array-contains": "cs",
+    "array-contains-any": "csa"
+  };
+  function normalizeWhereValue(value) {
+    if (value === null) return "eq.null";
+    if (typeof value === "boolean") return `eq.${value}`;
+    if (typeof value === "number") return String(value);
+    if (Array.isArray(value) && value.length === 2) {
+      const [rawOp, val] = value;
+      const op = OP_MAP[rawOp] ?? rawOp;
+      if (val === null) return `${op}.null`;
+      if (Array.isArray(val)) return `${op}.(${val.join(",")})`;
+      return `${op}.${val}`;
+    }
+    return String(value);
+  }
+  function buildQueryString(params) {
+    if (!params) return "";
+    const parts = [];
+    if (params.limit != null) parts.push(`limit=${params.limit}`);
+    if (params.offset != null) parts.push(`offset=${params.offset}`);
+    if (params.page != null) parts.push(`page=${params.page}`);
+    if (params.orderBy) {
+      parts.push(`orderBy=${encodeURIComponent(params.orderBy)}`);
+    }
+    if (params.searchString) {
+      parts.push(`searchString=${encodeURIComponent(params.searchString)}`);
+    }
+    if (params.include && params.include.length > 0) {
+      parts.push(`include=${encodeURIComponent(params.include.join(","))}`);
+    }
+    if (params.where) {
+      for (const [field, value] of Object.entries(params.where)) {
+        const normalized = normalizeWhereValue(value);
+        parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(normalized)}`);
+      }
+    }
+    return parts.length > 0 ? "?" + parts.join("&") : "";
+  }
+  function createTransport(config) {
+    const fetchFn = config.fetch || globalThis.fetch;
+    const apiPath = config.apiPath || "/api";
+    let token = config.token;
+    let tokenGetter;
+    let onUnauthorizedHandler = config.onUnauthorized;
+    function getHeaders(activeToken, init) {
+      return {
+        "Content-Type": "application/json",
+        ...activeToken ? { Authorization: `Bearer ${activeToken}` } : {},
+        ...init?.headers || {}
+      };
+    }
+    async function request(path, init) {
+      const base = config.baseUrl ? config.baseUrl.replace(/\/$/, "") : "";
+      const url = base + apiPath + path;
+      let activeToken = token;
+      if (tokenGetter) {
+        try {
+          const fetched = await tokenGetter();
+          if (fetched !== null && fetched !== void 0) {
+            activeToken = fetched;
+          }
+        } catch (e) {
+        }
+      }
+      const headers = getHeaders(activeToken, init);
+      if (init?.body instanceof FormData) {
+        delete headers["Content-Type"];
+      }
+      const res = await fetchFn(url, {
+        ...init,
+        headers
+      });
+      if (res.status === 204) return void 0;
+      const text = await res.text().catch(() => "");
+      let body = {};
+      if (text) {
+        try {
+          body = JSON.parse(text, rebaseReviver);
+        } catch (e) {
+        }
+      }
+      if (res.status === 401 && onUnauthorizedHandler) {
+        const retried = await onUnauthorizedHandler();
+        if (retried) {
+          let retryToken = token;
+          if (tokenGetter) {
+            try {
+              const fetched = await tokenGetter();
+              if (fetched !== null && fetched !== void 0) {
+                retryToken = fetched;
+              }
+            } catch (e) {
+            }
+          }
+          const retryHeaders = getHeaders(retryToken, init);
+          const retryRes = await fetchFn(url, {
+            ...init,
+            headers: retryHeaders
+          });
+          if (retryRes.status === 204) return void 0;
+          const retryText = await retryRes.text().catch(() => "");
+          let retryBody = {};
+          if (retryText) {
+            try {
+              retryBody = JSON.parse(retryText, rebaseReviver);
+            } catch (e) {
+            }
+          }
+          if (!retryRes.ok) {
+            let fallbackMessage = retryRes.statusText;
+            if (retryRes.status === 404 && !fallbackMessage) {
+              const method = init?.method || "GET";
+              fallbackMessage = `Endpoint not found (${method} ${path}). This usually means the collection is not registered on the backend, or the frontend API URL configuration (e.g. VITE_API_URL) is missing or pointing to the wrong host.`;
+            }
+            throw new RebaseApiError(
+              retryRes.status,
+              retryBody?.error?.message || retryBody?.message || fallbackMessage || `Request failed with status ${retryRes.status}`,
+              retryBody?.error?.code || retryBody?.code,
+              retryBody?.error?.details || retryBody?.details
+            );
+          }
+          return retryBody;
+        }
+      }
+      if (!res.ok) {
+        let fallbackMessage = res.statusText;
+        if (res.status === 404 && !fallbackMessage) {
+          const method = init?.method || "GET";
+          fallbackMessage = `Endpoint not found (${method} ${path}). This usually means the collection is not registered on the backend, or the frontend API URL configuration (e.g. VITE_API_URL) is missing or pointing to the wrong host.`;
+        }
+        throw new RebaseApiError(
+          res.status,
+          body?.error?.message || body?.message || fallbackMessage || `Request failed with status ${res.status}`,
+          body?.error?.code || body?.code,
+          body?.error?.details || body?.details
+        );
+      }
+      return body;
+    }
+    return {
+      request,
+      setToken(newToken) {
+        token = newToken || void 0;
+      },
+      setAuthTokenGetter(getter) {
+        tokenGetter = getter;
+      },
+      setOnUnauthorized(handler) {
+        onUnauthorizedHandler = handler;
+      },
+      get baseUrl() {
+        return config.baseUrl ? config.baseUrl.replace(/\/$/, "") : "";
+      },
+      get apiPath() {
+        return apiPath;
+      },
+      get fetchFn() {
+        return fetchFn;
+      },
+      getHeaders: (init) => getHeaders(token, init),
+      resolveToken: async () => {
+        if (tokenGetter) {
+          try {
+            const fetched = await tokenGetter();
+            if (fetched !== null && fetched !== void 0) {
+              return fetched;
+            }
+          } catch (e) {
+          }
+        }
+        return token || null;
+      }
+    };
+  }
+  function createMemoryStorage() {
+    const store = {};
+    return {
+      getItem(key) {
+        return store[key] ?? null;
+      },
+      setItem(key, value) {
+        store[key] = value;
+      },
+      removeItem(key) {
+        delete store[key];
+      }
+    };
+  }
+  function detectStorage() {
+    try {
+      if (typeof localStorage !== "undefined") {
+        localStorage.setItem("__rebase_test__", "1");
+        localStorage.removeItem("__rebase_test__");
+        return localStorage;
+      }
+    } catch (e) {
+    }
+    return createMemoryStorage();
+  }
+  function createAuth(transport, options) {
+    const opts = options || {};
+    const storage = opts.storage || detectStorage();
+    const authPath = opts.authPath || "/auth";
+    const autoRefresh = opts.autoRefresh !== false;
+    const persistSession = opts.persistSession !== false;
+    const STORAGE_KEY = "rebase_auth";
+    const REFRESH_BUFFER_MS = 12e4;
+    let currentSession = null;
+    const listeners = /* @__PURE__ */ new Set();
+    let refreshTimeout = null;
+    function authUrl(endpoint) {
+      return transport.baseUrl + transport.apiPath + authPath + endpoint;
+    }
+    function getFetch() {
+      return transport.fetchFn || globalThis.fetch;
+    }
+    function throwApiError(status, body, statusText) {
+      throw new RebaseApiError(
+        status,
+        body?.error?.message || body?.message || statusText,
+        body?.error?.code || body?.code,
+        body?.error?.details || body?.details
+      );
+    }
+    function emit(event, session) {
+      for (const fn of listeners) {
+        try {
+          fn(event, session);
+        } catch (e) {
+        }
+      }
+    }
+    function saveSession(session) {
+      if (!persistSession) return;
+      try {
+        storage.setItem(STORAGE_KEY, JSON.stringify(session));
+      } catch (e) {
+      }
+    }
+    function clearStoredSession() {
+      try {
+        storage.removeItem(STORAGE_KEY);
+      } catch (e) {
+      }
+    }
+    function loadStoredSession() {
+      try {
+        const raw = storage.getItem(STORAGE_KEY);
+        if (raw) return JSON.parse(raw);
+      } catch (e) {
+      }
+      return null;
+    }
+    function scheduleRefresh(expiresAt) {
+      if (refreshTimeout) clearTimeout(refreshTimeout);
+      if (!autoRefresh) return;
+      const delay = expiresAt - REFRESH_BUFFER_MS - Date.now();
+      if (delay <= 0) {
+        refreshSession().catch(() => signOut());
+        return;
+      }
+      refreshTimeout = setTimeout(async () => {
+        try {
+          await refreshSession();
+        } catch (e) {
+          signOut();
+        }
+      }, delay);
+    }
+    function handleAuthResponse(data, event) {
+      const session = {
+        accessToken: data.tokens.accessToken,
+        refreshToken: data.tokens.refreshToken,
+        expiresAt: data.tokens.accessTokenExpiresAt,
+        user: data.user
+      };
+      currentSession = session;
+      saveSession(session);
+      transport.setToken(session.accessToken);
+      scheduleRefresh(session.expiresAt);
+      emit(event, session);
+      return session;
+    }
+    async function signInWithEmail(email, password) {
+      const fetchFn = getFetch();
+      const res = await fetchFn(authUrl("/login"), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          email,
+          password
+        })
+      });
+      const body = await res.json().catch(() => ({}));
+      if (!res.ok) throwApiError(res.status, body, res.statusText);
+      const session = handleAuthResponse(body, "SIGNED_IN");
+      return {
+        user: session.user,
+        accessToken: session.accessToken,
+        refreshToken: session.refreshToken
+      };
+    }
+    async function signUp(email, password, displayName) {
+      const fetchFn = getFetch();
+      const payload = {
+        email,
+        password
+      };
+      if (displayName !== void 0) payload.displayName = displayName;
+      const res = await fetchFn(authUrl("/register"), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload)
+      });
+      const body = await res.json().catch(() => ({}));
+      if (!res.ok) throwApiError(res.status, body, res.statusText);
+      const session = handleAuthResponse(body, "SIGNED_IN");
+      return {
+        user: session.user,
+        accessToken: session.accessToken,
+        refreshToken: session.refreshToken
+      };
+    }
+    async function signInWithGoogle(idToken) {
+      const fetchFn = getFetch();
+      const res = await fetchFn(authUrl("/google"), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ idToken })
+      });
+      const body = await res.json().catch(() => ({}));
+      if (!res.ok) throwApiError(res.status, body, res.statusText);
+      const session = handleAuthResponse(body, "SIGNED_IN");
+      return {
+        user: session.user,
+        accessToken: session.accessToken,
+        refreshToken: session.refreshToken
+      };
+    }
+    async function signInWithLinkedin(code, redirectUri) {
+      const fetchFn = getFetch();
+      const res = await fetchFn(authUrl("/linkedin"), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          code,
+          redirectUri
+        })
+      });
+      const body = await res.json().catch(() => ({}));
+      if (!res.ok) throwApiError(res.status, body, res.statusText);
+      const session = handleAuthResponse(body, "SIGNED_IN");
+      return {
+        user: session.user,
+        accessToken: session.accessToken,
+        refreshToken: session.refreshToken
+      };
+    }
+    async function signInWithOAuth(providerId, payload) {
+      const fetchFn = getFetch();
+      const res = await fetchFn(authUrl(`/${providerId}`), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload)
+      });
+      const body = await res.json().catch(() => ({}));
+      if (!res.ok) throwApiError(res.status, body, res.statusText);
+      const session = handleAuthResponse(body, "SIGNED_IN");
+      return {
+        user: session.user,
+        accessToken: session.accessToken,
+        refreshToken: session.refreshToken
+      };
+    }
+    async function signInWithGitHub(code, redirectUri) {
+      return signInWithOAuth("github", {
+        code,
+        redirectUri
+      });
+    }
+    async function signInWithMicrosoft(code, redirectUri) {
+      return signInWithOAuth("microsoft", {
+        code,
+        redirectUri
+      });
+    }
+    async function signInWithApple(code, redirectUri, user) {
+      return signInWithOAuth("apple", {
+        code,
+        redirectUri,
+        user
+      });
+    }
+    async function signInWithFacebook(code, redirectUri) {
+      return signInWithOAuth("facebook", {
+        code,
+        redirectUri
+      });
+    }
+    async function signInWithTwitter(code, redirectUri, codeVerifier) {
+      return signInWithOAuth("twitter", {
+        code,
+        redirectUri,
+        codeVerifier
+      });
+    }
+    async function signInWithDiscord(code, redirectUri) {
+      return signInWithOAuth("discord", {
+        code,
+        redirectUri
+      });
+    }
+    async function signInWithGitLab(code, redirectUri) {
+      return signInWithOAuth("gitlab", {
+        code,
+        redirectUri
+      });
+    }
+    async function signInWithBitbucket(code, redirectUri) {
+      return signInWithOAuth("bitbucket", {
+        code,
+        redirectUri
+      });
+    }
+    async function signInWithSlack(code, redirectUri) {
+      return signInWithOAuth("slack", {
+        code,
+        redirectUri
+      });
+    }
+    async function signInWithSpotify(code, redirectUri) {
+      return signInWithOAuth("spotify", {
+        code,
+        redirectUri
+      });
+    }
+    async function signOut() {
+      const fetchFn = getFetch();
+      try {
+        if (currentSession?.refreshToken) {
+          await fetchFn(authUrl("/logout"), {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ refreshToken: currentSession.refreshToken })
+          });
+        }
+      } catch (e) {
+      }
+      currentSession = null;
+      clearStoredSession();
+      if (refreshTimeout) {
+        clearTimeout(refreshTimeout);
+        refreshTimeout = null;
+      }
+      transport.setToken(null);
+      emit("SIGNED_OUT", null);
+    }
+    async function refreshSession() {
+      if (!currentSession?.refreshToken) {
+        throw new Error("No active session to refresh");
+      }
+      const fetchFn = getFetch();
+      const res = await fetchFn(authUrl("/refresh"), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ refreshToken: currentSession.refreshToken })
+      });
+      const body = await res.json().catch(() => ({}));
+      if (!res.ok) throwApiError(res.status, body, res.statusText);
+      const session = {
+        accessToken: body.tokens.accessToken,
+        refreshToken: body.tokens.refreshToken,
+        expiresAt: body.tokens.accessTokenExpiresAt,
+        user: currentSession.user
+      };
+      currentSession = session;
+      saveSession(session);
+      transport.setToken(session.accessToken);
+      scheduleRefresh(session.expiresAt);
+      emit("TOKEN_REFRESHED", session);
+      return session;
+    }
+    async function getUser() {
+      const data = await transport.request(authPath + "/me", { method: "GET" });
+      return data.user;
+    }
+    async function updateUser(updates) {
+      const data = await transport.request(authPath + "/me", {
+        method: "PATCH",
+        body: JSON.stringify(updates)
+      });
+      if (currentSession) {
+        currentSession = {
+          ...currentSession,
+          user: data.user
+        };
+        saveSession(currentSession);
+        emit("USER_UPDATED", currentSession);
+      }
+      return data.user;
+    }
+    async function resetPasswordForEmail(email) {
+      const fetchFn = getFetch();
+      const res = await fetchFn(authUrl("/forgot-password"), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ email })
+      });
+      const body = await res.json().catch(() => ({}));
+      if (!res.ok) throwApiError(res.status, body, res.statusText);
+      return body;
+    }
+    async function resetPassword(token, password) {
+      const fetchFn = getFetch();
+      const res = await fetchFn(authUrl("/reset-password"), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          token,
+          password
+        })
+      });
+      const body = await res.json().catch(() => ({}));
+      if (!res.ok) throwApiError(res.status, body, res.statusText);
+      return body;
+    }
+    async function changePassword(oldPassword, newPassword) {
+      return transport.request(authPath + "/change-password", {
+        method: "POST",
+        body: JSON.stringify({
+          oldPassword,
+          newPassword
+        })
+      });
+    }
+    async function sendVerificationEmail() {
+      return transport.request(authPath + "/send-verification", {
+        method: "POST"
+      });
+    }
+    async function verifyEmail(token) {
+      const fetchFn = getFetch();
+      const res = await fetchFn(authUrl("/verify-email?token=" + encodeURIComponent(token)), {
+        method: "GET",
+        headers: { "Content-Type": "application/json" }
+      });
+      const body = await res.json().catch(() => ({}));
+      if (!res.ok) throwApiError(res.status, body, res.statusText);
+      return body;
+    }
+    async function getSessions() {
+      const data = await transport.request(authPath + "/sessions", { method: "GET" });
+      return data.sessions;
+    }
+    async function revokeSession(sessionId) {
+      return transport.request(authPath + "/sessions/" + encodeURIComponent(sessionId), {
+        method: "DELETE"
+      });
+    }
+    async function revokeAllSessions() {
+      const result = await transport.request(authPath + "/sessions", {
+        method: "DELETE"
+      });
+      currentSession = null;
+      clearStoredSession();
+      if (refreshTimeout) {
+        clearTimeout(refreshTimeout);
+        refreshTimeout = null;
+      }
+      transport.setToken(null);
+      emit("SIGNED_OUT", null);
+      return result;
+    }
+    async function getAuthConfig() {
+      const fetchFn = getFetch();
+      const res = await fetchFn(authUrl("/config"), {
+        method: "GET",
+        headers: { "Content-Type": "application/json" }
+      });
+      const body = await res.json().catch(() => ({}));
+      if (!res.ok) throwApiError(res.status, body, res.statusText);
+      return body;
+    }
+    function getSession() {
+      return currentSession;
+    }
+    function onAuthStateChange(callback) {
+      listeners.add(callback);
+      return () => listeners.delete(callback);
+    }
+    if (persistSession) {
+      const stored = loadStoredSession();
+      if (stored && stored.accessToken && stored.refreshToken) {
+        if (stored.expiresAt > Date.now()) {
+          currentSession = stored;
+          transport.setToken(stored.accessToken);
+          scheduleRefresh(stored.expiresAt);
+        } else if (stored.refreshToken) {
+          currentSession = stored;
+          refreshSession().catch(() => {
+            currentSession = null;
+            clearStoredSession();
+            transport.setToken(null);
+          });
+        }
+      }
+    }
+    return {
+      signInWithEmail,
+      signUp,
+      signInWithGoogle,
+      signInWithLinkedin,
+      signInWithOAuth,
+      signInWithGitHub,
+      signInWithMicrosoft,
+      signInWithApple,
+      signInWithFacebook,
+      signInWithTwitter,
+      signInWithDiscord,
+      signInWithGitLab,
+      signInWithBitbucket,
+      signInWithSlack,
+      signInWithSpotify,
+      signOut,
+      refreshSession,
+      getUser,
+      updateUser,
+      resetPasswordForEmail,
+      resetPassword,
+      changePassword,
+      sendVerificationEmail,
+      verifyEmail,
+      getSessions,
+      revokeSession,
+      revokeAllSessions,
+      getAuthConfig,
+      getSession,
+      onAuthStateChange
+    };
+  }
+  function createAdmin(transport, options) {
+    const opts = options || {};
+    const adminPath = opts.adminPath || "/admin";
+    async function listUsers() {
+      return transport.request(adminPath + "/users", { method: "GET" });
+    }
+    async function listUsersPaginated(options2) {
+      const params = new URLSearchParams();
+      if (options2?.limit !== void 0) params.set("limit", String(options2.limit));
+      if (options2?.offset !== void 0) params.set("offset", String(options2.offset));
+      if (options2?.search) params.set("search", options2.search);
+      if (options2?.orderBy) params.set("orderBy", options2.orderBy);
+      if (options2?.orderDir) params.set("orderDir", options2.orderDir);
+      const qs = params.toString();
+      return transport.request(
+        adminPath + "/users" + (qs ? "?" + qs : ""),
+        { method: "GET" }
+      );
+    }
+    async function getUser(userId) {
+      return transport.request(adminPath + "/users/" + encodeURIComponent(userId), { method: "GET" });
+    }
+    async function createUser(data) {
+      return transport.request(adminPath + "/users", {
+        method: "POST",
+        body: JSON.stringify(data)
+      });
+    }
+    async function updateUser(userId, data) {
+      return transport.request(adminPath + "/users/" + encodeURIComponent(userId), {
+        method: "PUT",
+        body: JSON.stringify(data)
+      });
+    }
+    async function deleteUser(userId) {
+      return transport.request(adminPath + "/users/" + encodeURIComponent(userId), {
+        method: "DELETE"
+      });
+    }
+    async function listRoles() {
+      return transport.request(adminPath + "/roles", { method: "GET" });
+    }
+    async function getRole(roleId) {
+      return transport.request(adminPath + "/roles/" + encodeURIComponent(roleId), { method: "GET" });
+    }
+    async function createRole(data) {
+      return transport.request(adminPath + "/roles", {
+        method: "POST",
+        body: JSON.stringify(data)
+      });
+    }
+    async function updateRole(roleId, data) {
+      return transport.request(adminPath + "/roles/" + encodeURIComponent(roleId), {
+        method: "PUT",
+        body: JSON.stringify(data)
+      });
+    }
+    async function deleteRole(roleId) {
+      return transport.request(adminPath + "/roles/" + encodeURIComponent(roleId), {
+        method: "DELETE"
+      });
+    }
+    async function bootstrap() {
+      return transport.request(adminPath + "/bootstrap", {
+        method: "POST"
+      });
+    }
+    return {
+      listUsers,
+      listUsersPaginated,
+      getUser,
+      createUser,
+      updateUser,
+      deleteUser,
+      listRoles,
+      getRole,
+      createRole,
+      updateRole,
+      deleteRole,
+      bootstrap
+    };
+  }
+  function createCron(transport, options) {
+    const cronPath = options?.cronPath || "/cron";
+    async function listJobs() {
+      return transport.request(cronPath, { method: "GET" });
+    }
+    async function getJob(jobId) {
+      return transport.request(
+        cronPath + "/" + encodeURIComponent(jobId),
+        { method: "GET" }
+      );
+    }
+    async function triggerJob(jobId) {
+      return transport.request(
+        cronPath + "/" + encodeURIComponent(jobId) + "/trigger",
+        { method: "POST" }
+      );
+    }
+    async function getJobLogs(jobId, options2) {
+      const params = new URLSearchParams();
+      if (options2?.limit !== void 0) params.set("limit", String(options2.limit));
+      const qs = params.toString();
+      return transport.request(
+        cronPath + "/" + encodeURIComponent(jobId) + "/logs" + (qs ? "?" + qs : ""),
+        { method: "GET" }
+      );
+    }
+    async function toggleJob(jobId, enabled) {
+      return transport.request(
+        cronPath + "/" + encodeURIComponent(jobId),
+        {
+          method: "PUT",
+          body: JSON.stringify({ enabled })
+        }
+      );
+    }
+    return {
+      listJobs,
+      getJob,
+      triggerJob,
+      getJobLogs,
+      toggleJob
+    };
+  }
+  function mapOperator(op) {
+    switch (op) {
+      case "==":
+        return "eq";
+      case "!=":
+        return "neq";
+      case ">":
+        return "gt";
+      case ">=":
+        return "gte";
+      case "<":
+        return "lt";
+      case "<=":
+        return "lte";
+      case "array-contains":
+        return "cs";
+      case "array-contains-any":
+        return "csa";
+      case "not-in":
+        return "nin";
+      default:
+        return op;
+    }
+  }
+  class QueryBuilder {
+    constructor(collection) {
+      this.collection = collection;
+    }
+    params = { where: {} };
+    /**
+     * Add a filter condition to your query.
+     * @example
+     * client.collection('users').where('age', '>=', 18).find()
+     */
+    where(column, operator, value) {
+      if (!this.params.where) {
+        this.params.where = {};
+      }
+      const mappedOp = mapOperator(operator);
+      let formattedValue = value;
+      if (Array.isArray(value) && ["in", "nin", "cs", "csa"].includes(mappedOp)) {
+        formattedValue = `(${value.join(",")})`;
+      } else if (value === null) {
+        formattedValue = "null";
+      }
+      this.params.where[column] = mappedOp === "eq" ? String(formattedValue) : `${mappedOp}.${formattedValue}`;
+      return this;
+    }
+    /**
+     * Order the results by a specific column.
+     * @example
+     * client.collection('users').orderBy('createdAt', 'desc').find()
+     */
+    orderBy(column, ascending = "asc") {
+      this.params.orderBy = `${column}:${ascending}`;
+      return this;
+    }
+    /**
+     * Limit the number of results returned.
+     */
+    limit(count) {
+      this.params.limit = count;
+      return this;
+    }
+    /**
+     * Skip the first N results.
+     */
+    offset(count) {
+      this.params.offset = count;
+      return this;
+    }
+    /**
+     * Set a free-text search string if supported by the backend.
+     */
+    search(searchString) {
+      this.params.searchString = searchString;
+      return this;
+    }
+    /**
+     * Include related entities in the response.
+     * Relations will be populated with full entity data instead of just IDs.
+     *
+     * @param relations - Relation names to include, or "*" for all.
+     * @example
+     * // Include specific relations
+     * client.data.posts.include("tags", "author").find()
+     *
+     * // Include all relations
+     * client.data.posts.include("*").find()
+     */
+    include(...relations) {
+      this.params.include = relations;
+      return this;
+    }
+    /**
+     * Execute the find query and return the results.
+     */
+    async find() {
+      return this.collection.find(this.params);
+    }
+    /**
+     * Listen to realtime updates matching this query.
+     */
+    listen(onUpdate, onError) {
+      if (!this.collection.listen) {
+        throw new Error("Listen is only available when RebaseClient is configured with a websocketUrl.");
+      }
+      return this.collection.listen(this.params, onUpdate, onError);
+    }
+  }
+  function parseWhereFilter(where) {
+    if (!where) return void 0;
+    const filters = {};
+    for (const [key, rawValue] of Object.entries(where)) {
+      if (rawValue === null) {
+        filters[key] = ["==", null];
+        continue;
+      }
+      if (typeof rawValue === "boolean") {
+        filters[key] = ["==", rawValue];
+        continue;
+      }
+      if (typeof rawValue === "number") {
+        filters[key] = ["==", rawValue];
+        continue;
+      }
+      if (Array.isArray(rawValue) && rawValue.length === 2) {
+        const [rawOp, val] = rawValue;
+        const OP_TO_FILTER = {
+          "eq": "==",
+          "neq": "!=",
+          "gt": ">",
+          "gte": ">=",
+          "lt": "<",
+          "lte": "<=",
+          "==": "==",
+          "!=": "!=",
+          ">": ">",
+          ">=": ">=",
+          "<": "<",
+          "<=": "<=",
+          "in": "in",
+          "nin": "not-in",
+          "not-in": "not-in",
+          "cs": "array-contains",
+          "csa": "array-contains-any",
+          "array-contains": "array-contains",
+          "array-contains-any": "array-contains-any"
+        };
+        filters[key] = [OP_TO_FILTER[rawOp] ?? "==", val];
+        continue;
+      }
+      const value = String(rawValue);
+      const dotIndex = value.indexOf(".");
+      if (dotIndex > 0) {
+        const opStr = value.substring(0, dotIndex);
+        const valStr = value.substring(dotIndex + 1);
+        let op = "==";
+        let val = valStr;
+        switch (opStr) {
+          case "eq":
+            op = "==";
+            break;
+          case "neq":
+            op = "!=";
+            break;
+          case "gt":
+            op = ">";
+            break;
+          case "gte":
+            op = ">=";
+            break;
+          case "lt":
+            op = "<";
+            break;
+          case "lte":
+            op = "<=";
+            break;
+          case "in":
+            op = "in";
+            val = valStr.startsWith("(") && valStr.endsWith(")") ? valStr.slice(1, -1).split(",").map((v) => v.trim()) : valStr.split(",");
+            break;
+          case "nin":
+            op = "not-in";
+            val = valStr.startsWith("(") && valStr.endsWith(")") ? valStr.slice(1, -1).split(",").map((v) => v.trim()) : valStr.split(",");
+            break;
+          case "cs":
+            op = "array-contains";
+            break;
+          case "csa":
+            op = "array-contains-any";
+            val = valStr.startsWith("(") && valStr.endsWith(")") ? valStr.slice(1, -1).split(",").map((v) => v.trim()) : valStr.split(",");
+            break;
+          default:
+            op = "==";
+            val = value;
+        }
+        if (val === "true") val = true;
+        else if (val === "false") val = false;
+        else if (val === "null") val = null;
+        else if (typeof val === "string" && /^[0-9]+(\.[0-9]+)?$/.test(val) && key !== "id" && !key.endsWith("_id")) val = Number(val);
+        filters[key] = [op, val];
+      } else {
+        filters[key] = ["==", value];
+      }
+    }
+    return filters;
+  }
+  function rowToEntity(row, slug) {
+    return {
+      id: row.id,
+      path: slug,
+      values: row
+    };
+  }
+  function createCollectionClient(transport, slug, ws) {
+    const basePath = `/data/${slug}`;
+    const client = {
+      async find(params) {
+        const qs = buildQueryString(params);
+        const raw = await transport.request(basePath + qs, { method: "GET" });
+        return {
+          data: (raw.data || []).map((row) => rowToEntity(row, slug)),
+          meta: raw.meta
+        };
+      },
+      async findById(id) {
+        const raw = await transport.request(`${basePath}/${encodeURIComponent(String(id))}`, { method: "GET" });
+        if (!raw) return void 0;
+        return rowToEntity(raw, slug);
+      },
+      async create(data, id) {
+        const body = { ...data };
+        if (id !== void 0) {
+          body.id = id;
+        }
+        const raw = await transport.request(basePath, {
+          method: "POST",
+          body: JSON.stringify(body)
+        });
+        return rowToEntity(raw, slug);
+      },
+      async update(id, data) {
+        const raw = await transport.request(`${basePath}/${encodeURIComponent(String(id))}`, {
+          method: "PUT",
+          body: JSON.stringify(data)
+        });
+        return rowToEntity(raw, slug);
+      },
+      async delete(id) {
+        return transport.request(`${basePath}/${encodeURIComponent(String(id))}`, {
+          method: "DELETE"
+        });
+      },
+      // Fluent builder instantiation
+      where(column, operator, value) {
+        return new QueryBuilder(client).where(column, operator, value);
+      },
+      orderBy(column, ascending) {
+        return new QueryBuilder(client).orderBy(column, ascending);
+      },
+      limit(count) {
+        return new QueryBuilder(client).limit(count);
+      },
+      offset(count) {
+        return new QueryBuilder(client).offset(count);
+      },
+      search(searchString) {
+        return new QueryBuilder(client).search(searchString);
+      },
+      include(...relations) {
+        return new QueryBuilder(client).include(...relations);
+      }
+    };
+    if (ws) {
+      client.listen = (params, onUpdate, onError) => {
+        return ws.listenCollection(
+          {
+            path: slug,
+            filter: parseWhereFilter(params?.where),
+            limit: params?.limit,
+            startAfter: params?.offset ? String(params.offset) : void 0,
+            orderBy: params?.orderBy?.split(":")[0],
+            order: params?.orderBy?.split(":")[1],
+            searchString: params?.searchString
+          },
+          (entities) => {
+            const requestedLimit = params?.limit || 20;
+            onUpdate({
+              data: entities,
+              meta: {
+                total: entities.length,
+                limit: requestedLimit,
+                offset: params?.offset || 0,
+                hasMore: entities.length >= requestedLimit
+              }
+            });
+          },
+          onError
+        );
+      };
+      client.listenById = (id, onUpdate, onError) => {
+        return ws.listenEntity(
+          {
+            path: slug,
+            entityId: String(id)
+          },
+          (entity) => {
+            if (entity) {
+              onUpdate(entity);
+            } else {
+              onUpdate(void 0);
+            }
+          },
+          onError
+        );
+      };
+    }
+    return client;
+  }
+  function rehydrateEntity(entity) {
+    return entity;
+  }
+  function extractMessageError(message) {
+    const payload = message.payload;
+    const errPayload = payload?.error;
+    const errorMessage = typeof errPayload === "object" ? errPayload.message : payload?.message || (typeof errPayload === "string" ? errPayload : void 0) || message.error || "Unknown error";
+    const errorCode = typeof errPayload === "object" ? errPayload.code : payload?.code;
+    return {
+      errorMessage,
+      errorCode
+    };
+  }
+  class ApiError extends Error {
+    code;
+    error;
+    constructor(message, error, code) {
+      super(message);
+      this.name = "ApiError";
+      this.code = code;
+      this.error = error;
+    }
+  }
+  class RebaseWebSocketClient {
+    websocketUrl;
+    ws = null;
+    getAuthToken;
+    subscriptions = /* @__PURE__ */ new Map();
+    listeners = /* @__PURE__ */ new Map();
+    on(event, cb) {
+      if (!this.listeners.has(event)) {
+        this.listeners.set(event, /* @__PURE__ */ new Set());
+      }
+      this.listeners.get(event).add(cb);
+      return () => this.listeners.get(event).delete(cb);
+    }
+    emit(event, ...args) {
+      if (this.listeners.has(event)) {
+        this.listeners.get(event).forEach((cb) => cb(...args));
+      }
+    }
+    // New: Subscription deduplication management with optimizations
+    collectionSubscriptions = /* @__PURE__ */ new Map();
+    entitySubscriptions = /* @__PURE__ */ new Map();
+    // Maps to quickly find subscription by backend subscription ID
+    backendToCollectionKey = /* @__PURE__ */ new Map();
+    backendToEntityKey = /* @__PURE__ */ new Map();
+    pendingRequests = /* @__PURE__ */ new Map();
+    reconnectAttempts = 0;
+    maxReconnectAttempts = 5;
+    isConnected = false;
+    messageQueue = [];
+    reconnectTimeout = null;
+    isAuthenticated = false;
+    authPromise = null;
+    WebSocketConstructor;
+    constructor(config) {
+      this.websocketUrl = config.websocketUrl;
+      this.getAuthToken = config.getAuthToken;
+      this.WebSocketConstructor = config.WebSocket || (typeof WebSocket !== "undefined" ? WebSocket : void 0);
+      if (!this.WebSocketConstructor) {
+        console.warn("WebSocket is not defined in this environment. Realtime subscriptions will not work unless you provide a WebSocket implementation in the config.");
+      } else {
+        this.initWebSocket();
+      }
+    }
+    /**
+     * Authenticate the WebSocket connection
+     */
+    async authenticate(token) {
+      return new Promise((resolve, reject) => {
+        const requestId = `auth_${Date.now()}`;
+        const timeout = setTimeout(() => {
+          this.pendingRequests.delete(requestId);
+          this.authPromise = null;
+          reject(new Error("Authentication timeout"));
+        }, 3e4);
+        this.pendingRequests.set(requestId, {
+          resolve: () => {
+            clearTimeout(timeout);
+            this.isAuthenticated = true;
+            resolve();
+          },
+          reject: (error) => {
+            clearTimeout(timeout);
+            reject(error);
+          }
+        });
+        const message = {
+          type: "AUTHENTICATE",
+          requestId,
+          payload: { token }
+        };
+        if (!this.isConnected || !this.ws) {
+          this.messageQueue.unshift(message);
+        } else {
+          this.ws.send(JSON.stringify(message));
+        }
+      });
+    }
+    /**
+     * Set the auth token getter function
+     */
+    setAuthTokenGetter(getAuthToken) {
+      this.getAuthToken = getAuthToken;
+      if (this.isConnected && !this.isAuthenticated && !this.authPromise) {
+        console.log("WebSocket auto-authenticating after token getter set");
+        this.getAuthToken().then((token) => {
+          if (!this.ws) return;
+          if (token) {
+            this.authenticate(token).catch((e) => {
+              if (this.ws) console.warn("WebSocket auto-auth failed:", e);
+            });
+          }
+        }).catch((e) => {
+          if (this.ws) console.warn("WebSocket auto-auth failed:", e);
+        });
+      }
+    }
+    disconnect() {
+      this.isAuthenticated = false;
+      this.authPromise = null;
+      if (this.reconnectTimeout) {
+        clearTimeout(this.reconnectTimeout);
+        this.reconnectTimeout = null;
+      }
+      if (this.ws) {
+        this.ws.onclose = null;
+        this.ws.onerror = null;
+        this.ws.onopen = null;
+        this.ws.onmessage = null;
+        this.ws.close();
+        this.ws = null;
+      }
+    }
+    // Initialize WebSocket connection
+    initWebSocket() {
+      if (!this.WebSocketConstructor) return;
+      if (this.ws?.readyState === this.WebSocketConstructor.OPEN) return;
+      try {
+        this.ws = new this.WebSocketConstructor(this.websocketUrl);
+        this.ws.onopen = async () => {
+          console.log("Connected to PostgreSQL backend");
+          const wasReconnect = this.reconnectAttempts > 0;
+          this.isConnected = true;
+          this.reconnectAttempts = 0;
+          if (this.getAuthToken && !this.isAuthenticated) {
+            try {
+              const token = await this.getAuthToken();
+              if (token) {
+                await this.authenticate(token);
+                console.log("WebSocket auto-authenticated");
+              }
+            } catch (error) {
+              console.warn("WebSocket auto-auth failed, requests may fail:", error);
+            }
+          }
+          this.emit(wasReconnect ? "reconnect" : "connect");
+          this.processMessageQueue();
+          if (wasReconnect) {
+            this.resubscribeAll();
+          }
+        };
+        this.ws.onmessage = (event) => {
+          try {
+            const message = JSON.parse(event.data, rebaseReviver);
+            this.handleWebSocketMessage(message);
+          } catch (error) {
+            console.error("Error parsing WebSocket message:", error);
+          }
+        };
+        this.ws.onclose = () => {
+          console.log("Disconnected from PostgreSQL backend");
+          this.isConnected = false;
+          this.isAuthenticated = false;
+          this.authPromise = null;
+          this.emit("disconnect");
+          for (const [reqId, request] of this.pendingRequests.entries()) {
+            if (reqId.startsWith("auth_")) {
+              request.reject(new Error("Connection closed during authentication"));
+            } else if (request.message) {
+              request.message._queuedResolve = request.resolve;
+              request.message._queuedReject = request.reject;
+              this.messageQueue.push(request.message);
+            } else {
+              request.reject(new ApiError("Connection closed", "Connection closed"));
+            }
+            this.pendingRequests.delete(reqId);
+          }
+          this.attemptReconnect();
+        };
+        this.ws.onerror = (error) => {
+          console.error("WebSocket error:", error);
+          this.isConnected = false;
+          this.emit("error", error);
+        };
+      } catch (error) {
+        console.error("Failed to initialize WebSocket:", error);
+        this.attemptReconnect();
+      }
+    }
+    processMessageQueue() {
+      while (this.messageQueue.length > 0 && this.isConnected) {
+        const message = this.messageQueue.shift();
+        if (message) this.sendMessage(message);
+      }
+    }
+    attemptReconnect() {
+      if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+        console.error("Max reconnection attempts reached");
+        return;
+      }
+      this.reconnectAttempts++;
+      const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 3e4);
+      console.log(`Attempting to reconnect in ${delay}ms (attempt ${this.reconnectAttempts})`);
+      if (this.reconnectTimeout) {
+        clearTimeout(this.reconnectTimeout);
+      }
+      this.reconnectTimeout = setTimeout(() => {
+        this.reconnectTimeout = null;
+        this.initWebSocket();
+      }, delay);
+    }
+    handleWebSocketMessage(message) {
+      const {
+        type,
+        requestId,
+        subscriptionId
+      } = message;
+      if (requestId && this.pendingRequests.has(requestId)) {
+        const {
+          resolve,
+          reject
+        } = this.pendingRequests.get(requestId);
+        this.pendingRequests.delete(requestId);
+        if (type === "ERROR" || type === "AUTH_ERROR" || message.error) {
+          const { errorMessage, errorCode } = extractMessageError(message);
+          reject(new ApiError(errorMessage, errorMessage, errorCode));
+        } else {
+          resolve(message.payload || message);
+        }
+        return;
+      }
+      if (subscriptionId && type === "collection_update") {
+        const subscriptionKey = this.backendToCollectionKey.get(subscriptionId);
+        if (subscriptionKey) {
+          const collectionSub = this.collectionSubscriptions.get(subscriptionKey);
+          if (collectionSub) {
+            const incomingEntities = (message.entities || []).map((e) => rehydrateEntity(e));
+            const entities = this.mergeEntities(collectionSub.latestData, incomingEntities);
+            collectionSub.latestData = entities;
+            collectionSub.lastUpdated = Date.now();
+            collectionSub.isInitialDataReceived = true;
+            collectionSub.callbacks.forEach((callback) => {
+              try {
+                callback.onUpdate(entities);
+              } catch (error) {
+                console.error("Error in collection subscription callback:", error);
+                if (callback.onError) {
+                  callback.onError(error instanceof Error ? error : new Error(String(error)));
+                }
+              }
+            });
+            return;
+          }
+        }
+      }
+      if (subscriptionId && type === "collection_entity_patch") {
+        const subscriptionKey = this.backendToCollectionKey.get(subscriptionId);
+        if (subscriptionKey) {
+          const collectionSub = this.collectionSubscriptions.get(subscriptionKey);
+          if (collectionSub && collectionSub.isInitialDataReceived && collectionSub.latestData) {
+            const patchEntity = message.entity ? rehydrateEntity(message.entity) : message.entity;
+            const patchEntityId = message.entityId;
+            let updated;
+            if (patchEntity === null || patchEntity === void 0) {
+              updated = collectionSub.latestData.filter((e) => String(e.id) !== String(patchEntityId));
+            } else {
+              const idx = collectionSub.latestData.findIndex((e) => String(e.id) === String(patchEntity.id));
+              if (idx >= 0) {
+                updated = [...collectionSub.latestData];
+                updated[idx] = patchEntity;
+              } else {
+                updated = [patchEntity, ...collectionSub.latestData];
+              }
+            }
+            collectionSub.latestData = updated;
+            collectionSub.lastUpdated = Date.now();
+            collectionSub.callbacks.forEach((callback) => {
+              try {
+                callback.onUpdate(updated);
+              } catch (error) {
+                console.error("Error in collection patch callback:", error);
+                if (callback.onError) {
+                  callback.onError(error instanceof Error ? error : new Error(String(error)));
+                }
+              }
+            });
+            return;
+          }
+        }
+      }
+      if (subscriptionId && type === "entity_update") {
+        const subscriptionKey = this.backendToEntityKey.get(subscriptionId);
+        if (subscriptionKey) {
+          const entitySub = this.entitySubscriptions.get(subscriptionKey);
+          if (entitySub) {
+            const entity = message.entity ? rehydrateEntity(message.entity) : null;
+            entitySub.latestData = entity;
+            entitySub.lastUpdated = Date.now();
+            entitySub.isInitialDataReceived = true;
+            entitySub.callbacks.forEach((callback) => {
+              try {
+                callback.onUpdate(entity);
+              } catch (error) {
+                console.error("Error in entity subscription callback:", error);
+                if (callback.onError) {
+                  callback.onError(error instanceof Error ? error : new Error(String(error)));
+                }
+              }
+            });
+            return;
+          }
+        }
+      }
+      if (subscriptionId && (type === "ERROR" || message.error)) {
+        const collectionKey = this.backendToCollectionKey.get(subscriptionId);
+        if (collectionKey) {
+          const collectionSub = this.collectionSubscriptions.get(collectionKey);
+          if (collectionSub) {
+            const { errorMessage, errorCode } = extractMessageError(message);
+            const error = new ApiError(errorMessage, errorMessage, errorCode);
+            collectionSub.callbacks.forEach((callback) => {
+              if (callback.onError) {
+                callback.onError(error);
+              }
+            });
+            return;
+          }
+        }
+        const entityKey = this.backendToEntityKey.get(subscriptionId);
+        if (entityKey) {
+          const entitySub = this.entitySubscriptions.get(entityKey);
+          if (entitySub) {
+            const { errorMessage, errorCode } = extractMessageError(message);
+            const error = new ApiError(errorMessage, errorMessage, errorCode);
+            entitySub.callbacks.forEach((callback) => {
+              if (callback.onError) {
+                callback.onError(error);
+              }
+            });
+            return;
+          }
+        }
+      }
+      if (subscriptionId && this.subscriptions.has(subscriptionId)) {
+        const callback = this.subscriptions.get(subscriptionId);
+        if (!callback) {
+          throw new Error(`Subscription callback not found for subscriptionId: ${subscriptionId}`);
+        }
+        if (message.type === "ERROR" || message.error) {
+          if (callback.onError) {
+            const { errorMessage, errorCode } = extractMessageError(message);
+            callback.onError(new ApiError(errorMessage, errorMessage, errorCode));
+          }
+        } else {
+          callback.onUpdate(message);
+        }
+      }
+    }
+    async ensureAuthenticated(retryCount = 3) {
+      if (this.isAuthenticated || !this.getAuthToken) return;
+      if (this.authPromise) {
+        await this.authPromise;
+        return;
+      }
+      let lastError = null;
+      for (let attempt = 0; attempt < retryCount; attempt++) {
+        try {
+          const token = await this.getAuthToken();
+          if (!token) throw new Error("user not logged in");
+          this.authPromise = this.authenticate(token);
+          await this.authPromise;
+          this.authPromise = null;
+          console.log("WebSocket authenticated on demand");
+          return;
+        } catch (error) {
+          this.authPromise = null;
+          lastError = error;
+          const errMsg = error instanceof Error ? error.message : String(error);
+          if (errMsg.includes("not logged in") || errMsg.includes("Session expired")) {
+            console.warn("WebSocket auth failed: user not logged in");
+            throw error;
+          }
+          if (errMsg.includes("still loading")) {
+            if (attempt < retryCount - 1) {
+              const delay = Math.min(500 * (attempt + 1), 2e3);
+              await new Promise((resolve) => setTimeout(resolve, delay));
+              continue;
+            }
+          }
+          if (attempt < retryCount - 1) {
+            const delay = Math.min(1e3 * (attempt + 1), 3e3);
+            console.log(`WebSocket auth attempt ${attempt + 1} failed, retrying in ${delay}ms...`);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+          }
+        }
+      }
+      console.warn("WebSocket on-demand auth failed after retries:", lastError);
+      throw lastError;
+    }
+    /**
+     * Force re-authentication (call after token refresh)
+     */
+    async reauthenticate() {
+      if (!this.getAuthToken) return;
+      this.isAuthenticated = false;
+      try {
+        const token = await this.getAuthToken();
+        await this.authenticate(token);
+        console.log("WebSocket reauthenticated successfully");
+      } catch (error) {
+        console.error("WebSocket reauthentication failed:", error);
+        throw error;
+      }
+    }
+    sendMessage(message) {
+      const queuedMsg = message;
+      if (queuedMsg._queuedResolve && queuedMsg._queuedReject) {
+        return this.doSendMessage(message, queuedMsg._queuedResolve, queuedMsg._queuedReject);
+      }
+      if (!this.isConnected || !this.ws) {
+        return new Promise((resolve, reject) => {
+          const queueable = message;
+          queueable._queuedResolve = resolve;
+          queueable._queuedReject = reject;
+          this.messageQueue.push(message);
+        });
+      }
+      return new Promise((resolve, reject) => {
+        this.doSendMessage(message, resolve, reject);
+      });
+    }
+    async doSendMessage(message, resolve, reject) {
+      if (message.type !== "AUTHENTICATE" && this.getAuthToken && !this.isAuthenticated) {
+        try {
+          await this.ensureAuthenticated();
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Authentication required";
+          reject(new ApiError(errorMessage, errorMessage));
+          return;
+        }
+      }
+      const requestId = message.requestId || `req_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+      message.requestId = requestId;
+      if (!this.pendingRequests.has(requestId)) {
+        this.pendingRequests.set(requestId, {
+          resolve,
+          reject,
+          message
+        });
+      }
+      try {
+        this.ws.send(JSON.stringify(message));
+      } catch (error) {
+        this.pendingRequests.delete(requestId);
+        reject(new ApiError("Failed to send message", error instanceof Error ? error.message : "Unknown error"));
+      }
+    }
+    // Data source methods
+    async fetchCollection(props) {
+      const response = await this.sendMessage({
+        type: "FETCH_COLLECTION",
+        payload: props
+      });
+      return (response.entities || []).map((e) => rehydrateEntity(e));
+    }
+    async fetchEntity(props) {
+      const response = await this.sendMessage({
+        type: "FETCH_ENTITY",
+        payload: props
+      });
+      return response.entity ? rehydrateEntity(response.entity) : void 0;
+    }
+    async saveEntity(props) {
+      const response = await this.sendMessage({
+        type: "SAVE_ENTITY",
+        payload: props
+      });
+      return rehydrateEntity(response.entity);
+    }
+    async deleteEntity(props) {
+      await this.sendMessage({
+        type: "DELETE_ENTITY",
+        payload: props
+      });
+    }
+    async executeSql(sql, options) {
+      const response = await this.sendMessage({
+        type: "EXECUTE_SQL",
+        payload: {
+          sql,
+          options
+        }
+      });
+      return response.result || [];
+    }
+    async fetchAvailableDatabases() {
+      const response = await this.sendMessage({
+        type: "FETCH_DATABASES",
+        payload: {}
+      });
+      return response.databases || [];
+    }
+    async fetchAvailableRoles() {
+      const response = await this.sendMessage({
+        type: "FETCH_ROLES"
+      });
+      return response.roles || [];
+    }
+    async fetchCurrentDatabase() {
+      const response = await this.sendMessage({
+        type: "FETCH_CURRENT_DATABASE"
+      });
+      return response.database;
+    }
+    async checkUniqueField(path, name, value, entityId, collection) {
+      const response = await this.sendMessage({
+        type: "CHECK_UNIQUE_FIELD",
+        payload: {
+          path,
+          name,
+          value,
+          entityId,
+          collection
+        }
+      });
+      return response.isUnique;
+    }
+    async countEntities(props) {
+      const response = await this.sendMessage({
+        type: "COUNT_ENTITIES",
+        payload: props
+      });
+      return response.count;
+    }
+    async fetchUnmappedTables(mappedPaths) {
+      const response = await this.sendMessage({
+        type: "FETCH_UNMAPPED_TABLES",
+        payload: { mappedPaths }
+      });
+      return response.tables || [];
+    }
+    async fetchTableMetadata(tableName) {
+      const response = await this.sendMessage({
+        type: "FETCH_TABLE_METADATA",
+        payload: { tableName }
+      });
+      return response.metadata || {
+        columns: [],
+        foreignKeys: [],
+        junctions: [],
+        policies: []
+      };
+    }
+    async createBranch(name, options) {
+      const response = await this.sendMessage({
+        type: "CREATE_BRANCH",
+        payload: {
+          name,
+          options
+        }
+      });
+      return response.branch;
+    }
+    async deleteBranch(name) {
+      await this.sendMessage({
+        type: "DELETE_BRANCH",
+        payload: { name }
+      });
+    }
+    async listBranches() {
+      const response = await this.sendMessage({
+        type: "LIST_BRANCHES",
+        payload: {}
+      });
+      return response.branches || [];
+    }
+    /**
+     * Recursively compare two values for structural equality.
+     * Handles primitives, null, undefined, Date, RegExp, arrays, and plain objects.
+     */
+    deepEqual(a, b) {
+      if (a === b) return true;
+      if (a === null || b === null || a === void 0 || b === void 0) return false;
+      if (typeof a !== typeof b) return false;
+      if (typeof a !== "object") return false;
+      if (a instanceof Date && b instanceof Date) {
+        return a.getTime() === b.getTime();
+      }
+      if (a instanceof Date || b instanceof Date) return false;
+      if (a instanceof RegExp && b instanceof RegExp) {
+        return a.source === b.source && a.flags === b.flags;
+      }
+      if (a instanceof RegExp || b instanceof RegExp) return false;
+      const aIsArray = Array.isArray(a);
+      const bIsArray = Array.isArray(b);
+      if (aIsArray !== bIsArray) return false;
+      if (aIsArray && bIsArray) {
+        if (a.length !== b.length) return false;
+        for (let i = 0; i < a.length; i++) {
+          if (!this.deepEqual(a[i], b[i])) return false;
+        }
+        return true;
+      }
+      const aObj = a;
+      const bObj = b;
+      const aKeys = Object.keys(aObj);
+      const bKeys = Object.keys(bObj);
+      if (aKeys.length !== bKeys.length) return false;
+      for (const key of aKeys) {
+        if (!Object.prototype.hasOwnProperty.call(bObj, key)) return false;
+        if (!this.deepEqual(aObj[key], bObj[key])) return false;
+      }
+      return true;
+    }
+    normalizeForComparison(val) {
+      if (!val) return val;
+      if (Array.isArray(val)) {
+        return val.map((item) => this.normalizeForComparison(item));
+      }
+      if (typeof val === "object") {
+        if (val instanceof Date) return val;
+        if (val instanceof RegExp) return val;
+        const obj = val;
+        if (obj.__type === "relation") {
+          const { data, ...rest } = obj;
+          return rest;
+        }
+        const result = {};
+        for (const [k, v] of Object.entries(obj)) {
+          result[k] = this.normalizeForComparison(v);
+        }
+        return result;
+      }
+      return val;
+    }
+    /**
+     * Merge incoming entities with cached data, preserving cached references
+     * for entities whose values haven't changed. This avoids unnecessary
+     * React re-renders when the server refetches all entities but most
+     * haven't actually changed.
+     */
+    mergeEntities(cached, incoming) {
+      if (!cached || cached.length === 0) return incoming;
+      const cachedById = /* @__PURE__ */ new Map();
+      for (const entity of cached) {
+        cachedById.set(entity.id, entity);
+      }
+      return incoming.map((incomingEntity) => {
+        const cachedEntity = cachedById.get(incomingEntity.id);
+        if (!cachedEntity) return incomingEntity;
+        if (cachedEntity.path === incomingEntity.path) {
+          const normCached = this.normalizeForComparison(cachedEntity.values);
+          const normIncoming = this.normalizeForComparison(incomingEntity.values);
+          if (this.deepEqual(normCached, normIncoming)) {
+            return cachedEntity;
+          } else {
+            const mismatches = {};
+            const allKeys = /* @__PURE__ */ new Set([...Object.keys(normCached), ...Object.keys(normIncoming)]);
+            for (const key of allKeys) {
+              if (!this.deepEqual(normCached[key], normIncoming[key])) {
+                mismatches[key] = {
+                  cached: normCached[key],
+                  incoming: normIncoming[key]
+                };
+              }
+            }
+            console.log(`[RebaseWS] Row ${incomingEntity.id} refetch mismatch:
+`, JSON.stringify(mismatches, null, 2));
+          }
+        }
+        return incomingEntity;
+      });
+    }
+    // Subscription methods
+    listenCollection(props, onUpdate, onError) {
+      const subscriptionKey = this.createCollectionSubscriptionKey(props);
+      const callbackId = `callback_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+      const existingSubscription = this.collectionSubscriptions.get(subscriptionKey);
+      if (existingSubscription) {
+        const callbackMap2 = existingSubscription.callbacks;
+        callbackMap2.set(callbackId, {
+          onUpdate,
+          onError
+        });
+        if (existingSubscription.latestData !== void 0 && existingSubscription.isInitialDataReceived) {
+          try {
+            onUpdate(existingSubscription.latestData);
+          } catch (error) {
+            console.error("Error in collection subscription callback:", error);
+            if (onError) {
+              onError(error instanceof Error ? error : new Error(String(error)));
+            }
+          }
+        }
+        return () => {
+          callbackMap2.delete(callbackId);
+          if (callbackMap2.size === 0) {
+            this.collectionSubscriptions.delete(subscriptionKey);
+            this.backendToCollectionKey.delete(existingSubscription.backendSubscriptionId);
+            if (this.isConnected && this.ws) {
+              this.sendMessage({
+                type: "unsubscribe",
+                payload: { subscriptionId: existingSubscription.backendSubscriptionId }
+              }).catch(console.error);
+            }
+          }
+        };
+      }
+      const backendSubscriptionId = `collection_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+      const callbackMap = /* @__PURE__ */ new Map();
+      callbackMap.set(callbackId, {
+        onUpdate,
+        onError
+      });
+      this.collectionSubscriptions.set(subscriptionKey, {
+        backendSubscriptionId,
+        callbacks: callbackMap,
+        props
+      });
+      this.backendToCollectionKey.set(backendSubscriptionId, subscriptionKey);
+      this.sendMessage({
+        type: "subscribe_collection",
+        payload: {
+          ...props,
+          subscriptionId: backendSubscriptionId
+        }
+      }).catch((error) => {
+        if (onError) onError(error);
+      });
+      return () => {
+        const subscription = this.collectionSubscriptions.get(subscriptionKey);
+        if (subscription) {
+          const callbacks = subscription.callbacks;
+          callbacks.delete(callbackId);
+          if (callbacks.size === 0) {
+            this.collectionSubscriptions.delete(subscriptionKey);
+            this.backendToCollectionKey.delete(subscription.backendSubscriptionId);
+            if (this.isConnected && this.ws) {
+              this.sendMessage({
+                type: "unsubscribe",
+                payload: { subscriptionId: subscription.backendSubscriptionId }
+              }).catch(console.error);
+            }
+          }
+        }
+      };
+    }
+    listenEntity(props, onUpdate, onError) {
+      const subscriptionKey = this.createEntitySubscriptionKey(props);
+      const callbackId = `callback_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+      const existingSubscription = this.entitySubscriptions.get(subscriptionKey);
+      if (existingSubscription) {
+        const callbackMap2 = existingSubscription.callbacks;
+        callbackMap2.set(callbackId, {
+          onUpdate,
+          onError
+        });
+        if (existingSubscription.latestData !== void 0 && existingSubscription.isInitialDataReceived) {
+          try {
+            onUpdate(existingSubscription.latestData);
+          } catch (error) {
+            console.error("Error in entity subscription callback:", error);
+            if (onError) {
+              onError(error instanceof Error ? error : new Error(String(error)));
+            }
+          }
+        }
+        return () => {
+          callbackMap2.delete(callbackId);
+          if (callbackMap2.size === 0) {
+            this.entitySubscriptions.delete(subscriptionKey);
+            this.backendToEntityKey.delete(existingSubscription.backendSubscriptionId);
+            if (this.isConnected && this.ws) {
+              this.sendMessage({
+                type: "unsubscribe",
+                payload: { subscriptionId: existingSubscription.backendSubscriptionId }
+              }).catch(console.error);
+            }
+          }
+        };
+      }
+      const backendSubscriptionId = `entity_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+      const callbackMap = /* @__PURE__ */ new Map();
+      callbackMap.set(callbackId, {
+        onUpdate,
+        onError
+      });
+      this.entitySubscriptions.set(subscriptionKey, {
+        backendSubscriptionId,
+        callbacks: callbackMap,
+        props
+      });
+      this.backendToEntityKey.set(backendSubscriptionId, subscriptionKey);
+      this.sendMessage({
+        type: "subscribe_entity",
+        payload: {
+          ...props,
+          subscriptionId: backendSubscriptionId
+        }
+      }).catch((error) => {
+        if (onError) onError(error);
+      });
+      return () => {
+        const subscription = this.entitySubscriptions.get(subscriptionKey);
+        if (subscription) {
+          const callbacks = subscription.callbacks;
+          callbacks.delete(callbackId);
+          if (callbacks.size === 0) {
+            this.entitySubscriptions.delete(subscriptionKey);
+            this.backendToEntityKey.delete(subscription.backendSubscriptionId);
+            if (this.isConnected && this.ws) {
+              this.sendMessage({
+                type: "unsubscribe",
+                payload: { subscriptionId: subscription.backendSubscriptionId }
+              }).catch(console.error);
+            }
+          }
+        }
+      };
+    }
+    /**
+     * Re-send all active subscriptions to the backend after a reconnect.
+     * The server wipes subscription state when a client disconnects, so
+     * we need to re-register everything to resume receiving updates.
+     */
+    resubscribeAll() {
+      console.log(`[WS] Re-subscribing: ${this.collectionSubscriptions.size} collection(s), ${this.entitySubscriptions.size} entity(ies)`);
+      for (const [key, sub] of this.collectionSubscriptions.entries()) {
+        const oldBackendId = sub.backendSubscriptionId;
+        const newBackendId = `collection_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+        sub.backendSubscriptionId = newBackendId;
+        this.backendToCollectionKey.delete(oldBackendId);
+        this.backendToCollectionKey.set(newBackendId, key);
+        this.sendMessage({
+          type: "subscribe_collection",
+          payload: {
+            ...sub.props,
+            subscriptionId: newBackendId
+          }
+        }).catch((error) => {
+          console.error("[WS] Failed to re-subscribe collection:", key, error);
+        });
+      }
+      for (const [key, sub] of this.entitySubscriptions.entries()) {
+        const oldBackendId = sub.backendSubscriptionId;
+        const newBackendId = `entity_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+        sub.backendSubscriptionId = newBackendId;
+        this.backendToEntityKey.delete(oldBackendId);
+        this.backendToEntityKey.set(newBackendId, key);
+        this.sendMessage({
+          type: "subscribe_entity",
+          payload: {
+            ...sub.props,
+            subscriptionId: newBackendId
+          }
+        }).catch((error) => {
+          console.error("[WS] Failed to re-subscribe entity:", key, error);
+        });
+      }
+    }
+    createCollectionSubscriptionKey(props) {
+      const key = {
+        path: props.path,
+        filter: props.filter,
+        limit: props.limit,
+        startAfter: props.startAfter,
+        orderBy: props.orderBy,
+        order: props.order,
+        searchString: props.searchString,
+        collection: props.collection?.name
+      };
+      return JSON.stringify(key, (_, value) => {
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+          return Object.keys(value).sort().reduce((sorted, k) => {
+            sorted[k] = value[k];
+            return sorted;
+          }, {});
+        }
+        return value;
+      });
+    }
+    createEntitySubscriptionKey(props) {
+      return `${props.path}|${props.entityId}`;
+    }
+  }
+  function createStorage(transport) {
+    const urlsCache = /* @__PURE__ */ new Map();
+    async function putObject({
+      file,
+      key,
+      metadata,
+      bucket
+    }) {
+      const formData = new FormData();
+      formData.append("file", file);
+      if (key) formData.append("key", key);
+      if (bucket) formData.append("bucket", bucket);
+      if (metadata) {
+        for (const [key2, value] of Object.entries(metadata)) {
+          if (value !== void 0 && value !== null) {
+            formData.append(
+              `metadata_${key2}`,
+              typeof value === "string" ? value : JSON.stringify(value)
+            );
+          }
+        }
+      }
+      const result = await transport.request("/storage/upload", {
+        method: "POST",
+        body: formData,
+        headers: {
+          // transport.request merges headers, so to prevent it setting application/json we can delete it
+          // in transport if body is FormData, or we can explicitly set it to an empty string.
+          // Let's rely on standard behaviour for now and adjust transport if it fails.
+        }
+      });
+      return result.data;
+    }
+    async function getSignedUrl(keyOrUrl, bucket) {
+      const cacheKey = bucket ? `${bucket}/${keyOrUrl}` : keyOrUrl;
+      const cached = urlsCache.get(cacheKey);
+      if (cached) return cached;
+      let filePath = keyOrUrl;
+      if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://"))) {
+        filePath = filePath.substring(filePath.indexOf("://") + 3);
+      }
+      if (bucket && filePath && !filePath.startsWith(bucket)) {
+        filePath = `${bucket}/${filePath}`;
+      }
+      if (!filePath || filePath.trim() === "" || filePath === "/") {
+        return {
+          url: null,
+          fileNotFound: true
+        };
+      }
+      try {
+        const result = await transport.request(`/storage/metadata/${filePath}`);
+        const activeToken = await transport.resolveToken();
+        const tokenQuery = activeToken ? `?token=${activeToken}` : "";
+        const downloadConfig = {
+          url: `${transport.baseUrl}${transport.apiPath}/storage/file/${filePath}${tokenQuery}`,
+          metadata: result.data
+        };
+        urlsCache.set(cacheKey, downloadConfig);
+        return downloadConfig;
+      } catch (e) {
+        if (e instanceof Error && "status" in e && e.status === 404) {
+          return {
+            url: null,
+            fileNotFound: true
+          };
+        }
+        throw e;
+      }
+    }
+    async function getObject(key, bucket) {
+      let filePath = key;
+      if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://"))) {
+        filePath = filePath.substring(filePath.indexOf("://") + 3);
+      }
+      if (bucket && filePath && !filePath.startsWith(bucket)) {
+        filePath = `${bucket}/${filePath}`;
+      }
+      if (!filePath || filePath.trim() === "" || filePath === "/") {
+        return null;
+      }
+      const url = `${transport.baseUrl}${transport.apiPath}/storage/file/${filePath}`;
+      const response = await transport.fetchFn(url, {
+        headers: transport.getHeaders ? transport.getHeaders() : {}
+      });
+      if (response.status === 404) return null;
+      if (!response.ok) throw new Error("Failed to get file");
+      const blob = await response.blob();
+      const fileName = filePath.split("/").pop() || "file";
+      return new File([blob], fileName, { type: blob.type });
+    }
+    async function deleteObject(key, bucket) {
+      let filePath = key;
+      if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://"))) {
+        filePath = filePath.substring(filePath.indexOf("://") + 3);
+      }
+      if (bucket && filePath && !filePath.startsWith(bucket)) {
+        filePath = `${bucket}/${filePath}`;
+      }
+      if (!filePath || filePath.trim() === "" || filePath === "/") {
+        return;
+      }
+      try {
+        await transport.request(`/storage/file/${filePath}`, { method: "DELETE" });
+      } catch (e) {
+        if (!(e instanceof Error && "status" in e && e.status === 404)) throw e;
+      }
+      urlsCache.delete(bucket ? `${bucket}/${key}` : key);
+    }
+    async function listObjects(prefix, options) {
+      const params = new URLSearchParams();
+      if (prefix) params.set("prefix", prefix);
+      if (options?.bucket) params.set("bucket", options.bucket);
+      if (options?.maxResults) params.set("maxResults", String(options.maxResults));
+      if (options?.pageToken) params.set("pageToken", options.pageToken);
+      const result = await transport.request(`/storage/list?${params.toString()}`);
+      return result.data;
+    }
+    return {
+      putObject,
+      getSignedUrl,
+      getObject,
+      deleteObject,
+      listObjects
+    };
+  }
+  function deriveWebSocketUrl(baseUrl) {
+    if (!baseUrl) {
+      if (typeof window !== "undefined") {
+        const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+        return `${protocol}//${window.location.host}`;
+      }
+      return "";
+    }
+    return baseUrl.replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://").replace(/\/$/, "");
+  }
+  function createRebaseClient(options) {
+    const transport = createTransport(options);
+    const auth = createAuth(transport, options.auth);
+    const admin = createAdmin(transport, options.admin);
+    const cron = createCron(transport, options.cron);
+    const storage = createStorage(transport);
+    const resolvedWsUrl = options.websocketUrl ?? deriveWebSocketUrl(options.baseUrl);
+    let ws;
+    if (resolvedWsUrl) {
+      ws = new RebaseWebSocketClient({
+        websocketUrl: resolvedWsUrl,
+        getAuthToken: async () => {
+          const session = await auth.getSession();
+          return session?.accessToken || options.token || "";
+        }
+      });
+      auth.onAuthStateChange((event, session) => {
+        if (!ws) return;
+        if (event === "SIGNED_OUT") {
+          ws.disconnect();
+        } else if (event === "SIGNED_IN" || event === "TOKEN_REFRESHED") {
+          if (session?.accessToken) {
+            ws.authenticate(session.accessToken).catch(console.warn);
+          }
+        }
+      });
+    }
+    if (!options.onUnauthorized) {
+      transport.setOnUnauthorized(async () => {
+        try {
+          await auth.refreshSession();
+          return true;
+        } catch (e) {
+          return false;
+        }
+      });
+    }
+    const collectionClients = /* @__PURE__ */ new Map();
+    function collection(slug) {
+      if (!collectionClients.has(slug)) {
+        collectionClients.set(slug, createCollectionClient(transport, slug, ws));
+      }
+      return collectionClients.get(slug);
+    }
+    const dataTarget = { collection };
+    const dataProxy = new Proxy(dataTarget, {
+      get(_target, prop) {
+        if (prop === "collection") {
+          return collection;
+        }
+        if (typeof prop === "symbol") return void 0;
+        if (typeof prop === "string" && prop !== "then" && prop !== "toJSON" && prop !== "$$typeof") {
+          const slug = utils.toSnakeCase(prop);
+          return collection(slug);
+        }
+        return void 0;
+      }
+    });
+    const target = {
+      auth,
+      admin,
+      cron,
+      storage,
+      ws,
+      setToken: transport.setToken,
+      setAuthTokenGetter: transport.setAuthTokenGetter,
+      setOnUnauthorized: transport.setOnUnauthorized,
+      resolveToken: transport.resolveToken,
+      baseUrl: transport.baseUrl,
+      collection,
+      call: async (endpoint, payload) => {
+        const prefix = endpoint.startsWith("/") ? "" : "/";
+        const res = await transport.request(`${prefix}${endpoint}`, {
+          method: "POST",
+          body: payload ? JSON.stringify(payload) : void 0
+        });
+        return res.data ?? res;
+      },
+      data: dataProxy,
+      email: void 0
+    };
+    return target;
+  }
+  exports2.ApiError = ApiError;
+  exports2.RebaseApiError = RebaseApiError;
+  exports2.RebaseWebSocketClient = RebaseWebSocketClient;
+  exports2.buildQueryString = buildQueryString;
+  exports2.createAdmin = createAdmin;
+  exports2.createAuth = createAuth;
+  exports2.createCollectionClient = createCollectionClient;
+  exports2.createCron = createCron;
+  exports2.createMemoryStorage = createMemoryStorage;
+  exports2.createRebaseClient = createRebaseClient;
+  exports2.createStorage = createStorage;
+  exports2.createTransport = createTransport;
+  exports2.rebaseReviver = rebaseReviver;
+  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+});
+//# sourceMappingURL=index.umd.js.map