@rebasepro/client 0.2.5 → 0.4.0

package/dist/auth.d.ts

@@ -168,3 +168,11 @@ export declare function createAuth(transport: Transport, options?: CreateAuthOpt
     getSession: () => RebaseSession | null;
     onAuthStateChange: (callback: (event: AuthChangeEvent, session: RebaseSession | null) => void) => () => boolean;
 };
+export interface CookieStorageOptions {
+    path?: string;
+    domain?: string;
+    secure?: boolean;
+    sameSite?: "Lax" | "Strict" | "None";
+    maxAge?: number;
+}
+export declare function createCookieStorage(options?: CookieStorageOptions): AuthStorage;

package/dist/collection.d.ts

@@ -1,6 +1,6 @@
-import { Transport, FindParams } from "./transport";
+import { FindParams, Transport } from "./transport";
 import { RebaseWebSocketClient } from "./websocket";
-import { CollectionAccessor, FilterOperator } from "@rebasepro/types";
+import { CollectionAccessor, FilterOperator, LogicalCondition, WhereValue } from "@rebasepro/types";
 import { QueryBuilder } from "./query_builder";
 /**
  * CollectionClient extends `CollectionAccessor` from `@rebasepro/types` so that
@@ -9,7 +9,8 @@ import { QueryBuilder } from "./query_builder";
  * Additionally it exposes fluent query builder methods like `.where()`, `.orderBy()`.
  */
 export interface CollectionClient<M extends Record<string, unknown> = Record<string, unknown>> extends CollectionAccessor<M> {
-    where(column: keyof M & string, operator: FilterOperator, value: unknown): QueryBuilder<M>;
+    where<K extends keyof M & string>(column: K, operator: FilterOperator, value: WhereValue<M[K]>): QueryBuilder<M>;
+    where(logicalCondition: LogicalCondition): QueryBuilder<M>;
     orderBy(column: keyof M & string, ascending?: "asc" | "desc"): QueryBuilder<M>;
     limit(count: number): QueryBuilder<M>;
     offset(count: number): QueryBuilder<M>;

package/dist/index.es.js

@@ -1,6 +1,6 @@
 import { Vector, GeoPoint, EntityRelation, EntityReference } from "@rebasepro/types";
 import { QueryBuilder } from "@rebasepro/common";
-import { QueryBuilder as QueryBuilder2 } from "@rebasepro/common";
+import { QueryBuilder as QueryBuilder2, and, cond, or } from "@rebasepro/common";
 import { toSnakeCase } from "@rebasepro/utils";
 function rebaseReviver(_key, value) {
   if (value && typeof value === "object" && "__type" in value) {
@@ -66,15 +66,33 @@ 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}`;
+  if (Array.isArray(value)) {
+    const conditions = Array.isArray(value[0]) ? value : [value];
+    const [rawOp, val] = conditions[0] || [];
+    if (rawOp) {
+      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 serializeLogicalCondition(cond2) {
+  if ("type" in cond2) {
+    const sub = cond2.conditions.map(serializeLogicalCondition).join(",");
+    return `${cond2.type}(${sub})`;
+  } else {
+    const op = OP_MAP[cond2.operator] ?? cond2.operator;
+    let formattedValue = cond2.value;
+    if (Array.isArray(cond2.value)) {
+      formattedValue = `(${cond2.value.join(",")})`;
+    } else if (cond2.value === null) {
+      formattedValue = "null";
+    }
+    return `${cond2.column}.${op}.${formattedValue}`;
+  }
+}
 function buildQueryString(params) {
   if (!params) return "";
   const parts = [];
@@ -90,10 +108,22 @@ function buildQueryString(params) {
   if (params.include && params.include.length > 0) {
     parts.push(`include=${encodeURIComponent(params.include.join(","))}`);
   }
+  if (params.logical) {
+    const root = params.logical;
+    const serialized = root.conditions.map(serializeLogicalCondition).join(",");
+    parts.push(`${root.type}=${encodeURIComponent(`(${serialized})`)}`);
+  }
   if (params.where) {
     for (const [field, value] of Object.entries(params.where)) {
-      const normalized = normalizeWhereValue(value);
-      parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(normalized)}`);
+      if (Array.isArray(value) && value.length > 0 && Array.isArray(value[0])) {
+        for (const subVal of value) {
+          const normalized = normalizeWhereValue(subVal);
+          parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(normalized)}`);
+        }
+      } else {
+        const normalized = normalizeWhereValue(value);
+        parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(normalized)}`);
+      }
     }
   }
   return parts.length > 0 ? "?" + parts.join("&") : "";
@@ -703,6 +733,58 @@ function createAuth(transport, options) {
     onAuthStateChange
   };
 }
+function createCookieStorage(options = {}) {
+  const defaultOptions = {
+    path: "/",
+    sameSite: "Lax",
+    ...options
+  };
+  return {
+    getItem(key) {
+      if (typeof document === "undefined") return null;
+      const nameEQ = encodeURIComponent(key) + "=";
+      const ca = document.cookie.split(";");
+      for (let i = 0; i < ca.length; i++) {
+        let c = ca[i];
+        while (c.charAt(0) === " ") c = c.substring(1, c.length);
+        if (c.indexOf(nameEQ) === 0) {
+          return decodeURIComponent(c.substring(nameEQ.length, c.length));
+        }
+      }
+      return null;
+    },
+    setItem(key, value) {
+      if (typeof document === "undefined") return;
+      let cookieStr = `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+      if (defaultOptions.path) {
+        cookieStr += `; path=${defaultOptions.path}`;
+      }
+      if (defaultOptions.domain) {
+        cookieStr += `; domain=${defaultOptions.domain}`;
+      }
+      if (defaultOptions.maxAge !== void 0) {
+        cookieStr += `; max-age=${defaultOptions.maxAge}`;
+      } else {
+        cookieStr += `; max-age=${365 * 24 * 60 * 60}`;
+      }
+      if (defaultOptions.secure) {
+        cookieStr += "; secure";
+      }
+      if (defaultOptions.sameSite) {
+        cookieStr += `; samesite=${defaultOptions.sameSite}`;
+      }
+      document.cookie = cookieStr;
+    },
+    removeItem(key) {
+      if (typeof document === "undefined") return;
+      let cookieStr = `${encodeURIComponent(key)}=; path=${defaultOptions.path || "/"}; max-age=-1`;
+      if (defaultOptions.domain) {
+        cookieStr += `; domain=${defaultOptions.domain}`;
+      }
+      document.cookie = cookieStr;
+    }
+  };
+}
 function createAdmin(transport, options) {
   const opts = options || {};
   const adminPath = opts.adminPath || "/admin";
@@ -803,44 +885,34 @@ function createCron(transport, options) {
 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 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"
+  };
+  const parseSingle = (rawValue, fieldKey) => {
+    if (rawValue === null) return ["==", null];
+    if (typeof rawValue === "boolean") return ["==", rawValue];
+    if (typeof rawValue === "number") return ["==", rawValue];
+    if (Array.isArray(rawValue) && rawValue.length === 2 && typeof rawValue[0] === "string") {
       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;
+      return [OP_TO_FILTER[rawOp] ?? "==", val];
     }
     const value = String(rawValue);
     const dotIndex = value.indexOf(".");
@@ -890,10 +962,17 @@ function parseWhereFilter(where) {
       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 if (typeof val === "string" && /^[0-9]+(\.[0-9]+)?$/.test(val) && fieldKey !== "id" && !fieldKey.endsWith("_id")) val = Number(val);
+      return [op, val];
+    } else {
+      return ["==", value];
+    }
+  };
+  for (const [key, rawValue] of Object.entries(where)) {
+    if (Array.isArray(rawValue) && rawValue.length > 0 && Array.isArray(rawValue[0])) {
+      filters[key] = rawValue.map((r) => parseSingle(r, key));
     } else {
-      filters[key] = ["==", value];
+      filters[key] = parseSingle(rawValue, key);
     }
   }
   return filters;
@@ -917,9 +996,16 @@ function createCollectionClient(transport, slug, ws) {
       };
     },
     async findById(id) {
-      const raw = await transport.request(`${basePath}/${encodeURIComponent(String(id))}`, { method: "GET" });
-      if (!raw) return void 0;
-      return rowToEntity(raw, slug);
+      try {
+        const raw = await transport.request(`${basePath}/${encodeURIComponent(String(id))}`, { method: "GET" });
+        if (!raw) return void 0;
+        return rowToEntity(raw, slug);
+      } catch (err) {
+        if (err instanceof RebaseApiError && err.status === 404) {
+          return void 0;
+        }
+        throw err;
+      }
     },
     async create(data, id) {
       const body = { ...data };
@@ -945,14 +1031,22 @@ function createCollectionClient(transport, slug, ws) {
       });
     },
     async count(params) {
-      const countParams = { ...params, limit: void 0, offset: void 0 };
+      const countParams = {
+        ...params,
+        limit: void 0,
+        offset: void 0
+      };
       const qs = buildQueryString(countParams);
       const raw = await transport.request(basePath + "/count" + qs, { method: "GET" });
       return raw.count ?? 0;
     },
     // Fluent builder instantiation
-    where(column, operator, value) {
-      return new QueryBuilder(client).where(column, operator, value);
+    where(columnOrCondition, operator, value) {
+      const builder = new QueryBuilder(client);
+      if (typeof columnOrCondition === "object") {
+        return builder.where(columnOrCondition);
+      }
+      return builder.where(columnOrCondition, operator, value);
     },
     orderBy(column, ascending) {
       return new QueryBuilder(client).orderBy(column, ascending);
@@ -1089,9 +1183,12 @@ class RebaseWebSocketClient {
   isAuthenticated = false;
   authPromise = null;
   WebSocketConstructor;
+  onUnauthorized;
+  refreshInProgress = null;
   constructor(config) {
     this.websocketUrl = config.websocketUrl;
     this.getAuthToken = config.getAuthToken;
+    this.onUnauthorized = config.onUnauthorized;
     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.");
@@ -1256,6 +1353,42 @@ class RebaseWebSocketClient {
       this.initWebSocket();
     }, delay);
   }
+  isAuthError(message) {
+    if (message.type === "AUTH_ERROR") return true;
+    const { errorMessage, errorCode } = extractMessageError(message);
+    if (errorCode === "UNAUTHORIZED" || errorCode === "JWT_EXPIRED" || errorCode === "AUTH_ERROR") return true;
+    const lowerMessage = errorMessage.toLowerCase();
+    return lowerMessage.includes("unauthorized") || lowerMessage.includes("token expired") || lowerMessage.includes("token is expired") || lowerMessage.includes("invalid token") || lowerMessage.includes("session expired") || lowerMessage.includes("auth error");
+  }
+  async handleAuthFailure() {
+    if (this.refreshInProgress) {
+      return this.refreshInProgress;
+    }
+    this.refreshInProgress = (async () => {
+      this.isAuthenticated = false;
+      this.authPromise = null;
+      if (this.onUnauthorized) {
+        try {
+          const refreshed = await this.onUnauthorized();
+          if (refreshed && this.getAuthToken) {
+            const token = await this.getAuthToken();
+            if (token) {
+              await this.authenticate(token);
+              return true;
+            }
+          }
+        } catch (error) {
+          console.error("WebSocket auth refresh failed:", error);
+        }
+      }
+      return false;
+    })();
+    try {
+      return await this.refreshInProgress;
+    } finally {
+      this.refreshInProgress = null;
+    }
+  }
   handleWebSocketMessage(message) {
     const {
       type,
@@ -1263,16 +1396,28 @@ class RebaseWebSocketClient {
       subscriptionId
     } = message;
     if (requestId && this.pendingRequests.has(requestId)) {
-      const {
-        resolve,
-        reject
-      } = this.pendingRequests.get(requestId);
-      this.pendingRequests.delete(requestId);
+      const pendingReq = this.pendingRequests.get(requestId);
       if (type === "ERROR" || type === "AUTH_ERROR" || message.error) {
-        const { errorMessage, errorCode } = extractMessageError(message);
-        reject(new ApiError(errorMessage, errorMessage, errorCode));
+        if (this.isAuthError(message)) {
+          this.pendingRequests.delete(requestId);
+          this.handleAuthFailure().then((refreshed) => {
+            if (refreshed && pendingReq.message) {
+              this.doSendMessage(pendingReq.message, pendingReq.resolve, pendingReq.reject).catch(pendingReq.reject);
+            } else {
+              const { errorMessage, errorCode } = extractMessageError(message);
+              pendingReq.reject(new ApiError(errorMessage, errorMessage, errorCode));
+            }
+          }).catch((err) => {
+            pendingReq.reject(err);
+          });
+        } else {
+          this.pendingRequests.delete(requestId);
+          const { errorMessage, errorCode } = extractMessageError(message);
+          pendingReq.reject(new ApiError(errorMessage, errorMessage, errorCode));
+        }
       } else {
-        resolve(message.payload || message);
+        this.pendingRequests.delete(requestId);
+        pendingReq.resolve(message.payload || message);
       }
       return;
     }
@@ -1363,6 +1508,40 @@ class RebaseWebSocketClient {
       if (collectionKey) {
         const collectionSub = this.collectionSubscriptions.get(collectionKey);
         if (collectionSub) {
+          if (this.isAuthError(message)) {
+            this.handleAuthFailure().then((refreshed) => {
+              if (refreshed) {
+                const oldBackendId = collectionSub.backendSubscriptionId;
+                const newBackendId = `collection_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+                collectionSub.backendSubscriptionId = newBackendId;
+                this.backendToCollectionKey.delete(oldBackendId);
+                this.backendToCollectionKey.set(newBackendId, collectionKey);
+                this.sendMessage({
+                  type: "subscribe_collection",
+                  payload: {
+                    ...collectionSub.props,
+                    subscriptionId: newBackendId
+                  }
+                }).catch((error2) => {
+                  console.error("[WS] Failed to re-subscribe collection after auth refresh:", collectionKey, error2);
+                  collectionSub.callbacks.forEach((callback) => {
+                    if (callback.onError) callback.onError(error2);
+                  });
+                });
+              } else {
+                const { errorMessage: errorMessage2, errorCode: errorCode2 } = extractMessageError(message);
+                const error2 = new ApiError(errorMessage2, errorMessage2, errorCode2);
+                collectionSub.callbacks.forEach((callback) => {
+                  if (callback.onError) callback.onError(error2);
+                });
+              }
+            }).catch((err) => {
+              collectionSub.callbacks.forEach((callback) => {
+                if (callback.onError) callback.onError(err);
+              });
+            });
+            return;
+          }
           const { errorMessage, errorCode } = extractMessageError(message);
           const error = new ApiError(errorMessage, errorMessage, errorCode);
           collectionSub.callbacks.forEach((callback) => {
@@ -1377,6 +1556,40 @@ class RebaseWebSocketClient {
       if (entityKey) {
         const entitySub = this.entitySubscriptions.get(entityKey);
         if (entitySub) {
+          if (this.isAuthError(message)) {
+            this.handleAuthFailure().then((refreshed) => {
+              if (refreshed) {
+                const oldBackendId = entitySub.backendSubscriptionId;
+                const newBackendId = `entity_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+                entitySub.backendSubscriptionId = newBackendId;
+                this.backendToEntityKey.delete(oldBackendId);
+                this.backendToEntityKey.set(newBackendId, entityKey);
+                this.sendMessage({
+                  type: "subscribe_entity",
+                  payload: {
+                    ...entitySub.props,
+                    subscriptionId: newBackendId
+                  }
+                }).catch((error2) => {
+                  console.error("[WS] Failed to re-subscribe entity after auth refresh:", entityKey, error2);
+                  entitySub.callbacks.forEach((callback) => {
+                    if (callback.onError) callback.onError(error2);
+                  });
+                });
+              } else {
+                const { errorMessage: errorMessage2, errorCode: errorCode2 } = extractMessageError(message);
+                const error2 = new ApiError(errorMessage2, errorMessage2, errorCode2);
+                entitySub.callbacks.forEach((callback) => {
+                  if (callback.onError) callback.onError(error2);
+                });
+              }
+            }).catch((err) => {
+              entitySub.callbacks.forEach((callback) => {
+                if (callback.onError) callback.onError(err);
+              });
+            });
+            return;
+          }
           const { errorMessage, errorCode } = extractMessageError(message);
           const error = new ApiError(errorMessage, errorMessage, errorCode);
           entitySub.callbacks.forEach((callback) => {
@@ -2057,14 +2270,27 @@ function createStorage(transport) {
   };
 }
 function deriveWebSocketUrl(baseUrl) {
-  if (!baseUrl) {
-    if (typeof window !== "undefined") {
-      const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
-      return `${protocol}//${window.location.host}`;
+  if (typeof window !== "undefined") {
+    let absoluteUrl = "";
+    if (!baseUrl) {
+      absoluteUrl = window.location.origin;
+    } else if (/^https?:\/\//i.test(baseUrl) || /^wss?:\/\//i.test(baseUrl)) {
+      absoluteUrl = baseUrl;
+    } else {
+      try {
+        absoluteUrl = new URL(baseUrl, window.location.href).origin;
+      } catch {
+        absoluteUrl = window.location.origin;
+      }
     }
+    const protocol = absoluteUrl.startsWith("https:") || absoluteUrl.startsWith("wss:") ? "wss:" : "ws:";
+    return absoluteUrl.replace(/^https?:\/\//i, `${protocol}//`).replace(/^wss?:\/\//i, `${protocol}//`).replace(/\/$/, "");
+  }
+  if (!baseUrl) return "";
+  if (!/^https?:\/\//i.test(baseUrl) && !/^wss?:\/\//i.test(baseUrl)) {
     return "";
   }
-  return baseUrl.replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://").replace(/\/$/, "");
+  return baseUrl.replace(/^https?:\/\//i, (match) => match.toLowerCase() === "https://" ? "wss://" : "ws://").replace(/\/$/, "");
 }
 function createRebaseClient(options) {
   const transport = createTransport(options);
@@ -2076,12 +2302,27 @@ function createRebaseClient(options) {
   const resolvedWsUrl = options.websocketUrl ?? deriveWebSocketUrl(options.baseUrl);
   let ws;
   if (resolvedWsUrl) {
+    const wsOnUnauthorized = options.onUnauthorized || (async () => {
+      try {
+        await auth.refreshSession();
+        return true;
+      } catch (e) {
+        return false;
+      }
+    });
     ws = new RebaseWebSocketClient({
       websocketUrl: resolvedWsUrl,
       getAuthToken: async () => {
-        const session = await auth.getSession();
+        let session = auth.getSession();
+        if (session && session.expiresAt <= Date.now() + 1e4) {
+          try {
+            session = await auth.refreshSession();
+          } catch (e) {
+          }
+        }
         return session?.accessToken || options.token || "";
-      }
+      },
+      onUnauthorized: wsOnUnauthorized
     });
     auth.onAuthStateChange((event, session) => {
       if (!ws) return;
@@ -2156,16 +2397,20 @@ export {
   QueryBuilder2 as QueryBuilder,
   RebaseApiError,
   RebaseWebSocketClient,
+  and,
   buildQueryString,
+  cond,
   createAdmin,
   createAuth,
   createCollectionClient,
+  createCookieStorage,
   createCron,
   createFunctionsClient,
   createMemoryStorage,
   createRebaseClient,
   createStorage,
   createTransport,
+  or,
   rebaseReviver
 };
 //# sourceMappingURL=index.es.js.map