@rebasepro/client 0.3.0 → 0.4.0

package/dist/index.umd.js

@@ -66,15 +66,33 @@
     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(cond) {
+    if ("type" in cond) {
+      const sub = cond.conditions.map(serializeLogicalCondition).join(",");
+      return `${cond.type}(${sub})`;
+    } else {
+      const op = OP_MAP[cond.operator] ?? cond.operator;
+      let formattedValue = cond.value;
+      if (Array.isArray(cond.value)) {
+        formattedValue = `(${cond.value.join(",")})`;
+      } else if (cond.value === null) {
+        formattedValue = "null";
+      }
+      return `${cond.column}.${op}.${formattedValue}`;
+    }
+  }
   function buildQueryString(params) {
     if (!params) return "";
     const parts = [];
@@ -90,10 +108,22 @@
     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 @@
       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";
@@ -742,29 +824,6 @@
         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"
@@ -777,11 +836,6 @@
       createUser,
       updateUser,
       deleteUser,
-      listRoles,
-      getRole,
-      createRole,
-      updateRole,
-      deleteRole,
       bootstrap
     };
   }
@@ -831,44 +885,34 @@
   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(".");
@@ -918,10 +962,17 @@
         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 {
-        filters[key] = ["==", value];
+        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] = parseSingle(rawValue, key);
       }
     }
     return filters;
@@ -945,9 +996,16 @@
         };
       },
       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 };
@@ -973,14 +1031,22 @@
         });
       },
       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 common.QueryBuilder(client).where(column, operator, value);
+      where(columnOrCondition, operator, value) {
+        const builder = new common.QueryBuilder(client);
+        if (typeof columnOrCondition === "object") {
+          return builder.where(columnOrCondition);
+        }
+        return builder.where(columnOrCondition, operator, value);
       },
       orderBy(column, ascending) {
         return new common.QueryBuilder(client).orderBy(column, ascending);
@@ -1117,9 +1183,12 @@
     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.");
@@ -1284,6 +1353,42 @@
         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,
@@ -1291,16 +1396,28 @@
         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;
       }
@@ -1391,6 +1508,40 @@
         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) => {
@@ -1405,6 +1556,40 @@
         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) => {
@@ -2085,14 +2270,27 @@
     };
   }
   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);
@@ -2104,12 +2302,27 @@
     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;
@@ -2183,6 +2396,18 @@
     enumerable: true,
     get: () => common.QueryBuilder
   });
+  Object.defineProperty(exports2, "and", {
+    enumerable: true,
+    get: () => common.and
+  });
+  Object.defineProperty(exports2, "cond", {
+    enumerable: true,
+    get: () => common.cond
+  });
+  Object.defineProperty(exports2, "or", {
+    enumerable: true,
+    get: () => common.or
+  });
   exports2.ApiError = ApiError;
   exports2.RebaseApiError = RebaseApiError;
   exports2.RebaseWebSocketClient = RebaseWebSocketClient;
@@ -2190,6 +2415,7 @@
   exports2.createAdmin = createAdmin;
   exports2.createAuth = createAuth;
   exports2.createCollectionClient = createCollectionClient;
+  exports2.createCookieStorage = createCookieStorage;
   exports2.createCron = createCron;
   exports2.createFunctionsClient = createFunctionsClient;
   exports2.createMemoryStorage = createMemoryStorage;