@rebasepro/client 0.0.1-canary.4d4fb3e

package/dist/index.es.js

@@ -0,0 +1,1882 @@
+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;
+  }
+}
+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.include && params.include.length > 0) {
+    parts.push(`include=${encodeURIComponent(params.include.join(","))}`);
+  }
+  if (params.where) {
+    for (const [field, value] of Object.entries(params.where)) {
+      parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(String(value))}`);
+    }
+  }
+  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 url = config.baseUrl.replace(/\/$/, "") + 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 body = await res.json().catch(() => ({}));
+    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 retryBody = await retryRes.json().catch(() => ({}));
+        if (!retryRes.ok) {
+          throw new RebaseApiError(
+            retryRes.status,
+            retryBody?.error?.message || retryBody?.message || retryRes.statusText,
+            retryBody?.error?.code || retryBody?.code,
+            retryBody?.error?.details || retryBody?.details
+          );
+        }
+        return retryBody;
+      }
+    }
+    if (!res.ok) {
+      throw new RebaseApiError(
+        res.status,
+        body?.error?.message || body?.message || res.statusText,
+        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.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 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,
+    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 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, value] of Object.entries(where)) {
+    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)) 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}`;
+  return {
+    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"
+      });
+    },
+    ...ws && {
+      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
+        );
+      },
+      listenById(id, onUpdate, onError) {
+        return ws.listenEntity(
+          { path: slug, entityId: String(id) },
+          (entity) => {
+            if (entity) {
+              onUpdate(entity);
+            } else {
+              onUpdate(void 0);
+            }
+          },
+          onError
+        );
+      }
+    },
+    // Fluent builder instantiation
+    where(column, operator, value) {
+      return new QueryBuilder(this).where(column, operator, value);
+    },
+    orderBy(column, ascending) {
+      return new QueryBuilder(this).orderBy(column, ascending);
+    },
+    limit(count) {
+      return new QueryBuilder(this).limit(count);
+    },
+    offset(count) {
+      return new QueryBuilder(this).offset(count);
+    },
+    search(searchString) {
+      return new QueryBuilder(this).search(searchString);
+    },
+    include(...relations) {
+      return new QueryBuilder(this).include(...relations);
+    }
+  };
+}
+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 = [];
+  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 (token) {
+          this.authenticate(token).catch((e) => console.warn("WebSocket auto-auth failed:", e));
+        }
+      }).catch((e) => {
+        console.warn("WebSocket auto-auth failed:", e);
+      });
+    }
+  }
+  disconnect() {
+    this.isAuthenticated = false;
+    this.authPromise = null;
+    if (this.ws) {
+      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);
+          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})`);
+    setTimeout(() => {
+      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 || [];
+          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;
+          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 ?? 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 || [];
+  }
+  async fetchEntity(props) {
+    const response = await this.sendMessage({
+      type: "FETCH_ENTITY",
+      payload: props
+    });
+    return response.entity;
+  }
+  async saveEntity(props) {
+    const response = await this.sendMessage({
+      type: "SAVE_ENTITY",
+      payload: props
+    });
+    return 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: [] };
+  }
+  /**
+   * 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 uploadFile({
+    file,
+    fileName,
+    path,
+    metadata,
+    bucket
+  }) {
+    const formData = new FormData();
+    formData.append("file", file);
+    if (fileName) formData.append("fileName", fileName);
+    if (path) formData.append("path", path);
+    if (bucket) formData.append("bucket", bucket);
+    if (metadata) {
+      for (const [key, value] of Object.entries(metadata)) {
+        if (value !== void 0 && value !== null) {
+          formData.append(
+            `metadata_${key}`,
+            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 getDownloadURL(pathOrUrl, bucket) {
+    const cacheKey = bucket ? `${bucket}/${pathOrUrl}` : pathOrUrl;
+    const cached = urlsCache.get(cacheKey);
+    if (cached) return cached;
+    let filePath = pathOrUrl;
+    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 getFile(path, bucket) {
+    let filePath = path;
+    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 deleteFile(path, bucket) {
+    let filePath = path;
+    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}/${path}` : path);
+  }
+  async function list(path, options) {
+    const params = new URLSearchParams();
+    if (path) params.set("path", path);
+    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 {
+    uploadFile,
+    getDownloadURL,
+    getFile,
+    deleteFile,
+    list
+  };
+}
+function deriveWebSocketUrl(baseUrl) {
+  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 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) {
+    options.onUnauthorized = 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") {
+        return collection(prop);
+      }
+      return void 0;
+    }
+  });
+  const target = {
+    auth,
+    admin,
+    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
+  };
+  return new Proxy(target, {
+    get(obj, prop) {
+      if (prop in obj) {
+        return obj[prop];
+      }
+      if (typeof prop === "string" && prop !== "then") {
+        return collection(prop);
+      }
+      return void 0;
+    }
+  });
+}
+export {
+  ApiError,
+  RebaseApiError,
+  RebaseWebSocketClient,
+  buildQueryString,
+  createAdmin,
+  createAuth,
+  createCollectionClient,
+  createMemoryStorage,
+  createRebaseClient,
+  createStorage,
+  createTransport
+};
+//# sourceMappingURL=index.es.js.map