@rebasepro/client 0.3.0 → 0.5.0

package/dist/query_builder.d.ts

@@ -1 +1 @@
-export { QueryBuilder } from "@rebasepro/common";
+export { QueryBuilder, or, and, cond } from "@rebasepro/common";

package/dist/websocket.d.ts

@@ -5,6 +5,8 @@ export interface RebaseWebSocketConfig {
     getAuthToken?: () => Promise<string>;
     /** Optional WebSocket constructor to override globalThis.WebSocket (e.g. for Node environments) */
     WebSocket?: typeof WebSocket;
+    /** Callback to handle unauthorized requests or token expiration (refreshes auth session) */
+    onUnauthorized?: () => Promise<boolean>;
 }
 export declare class ApiError extends Error {
     code?: string;
@@ -32,6 +34,8 @@ export declare class RebaseWebSocketClient {
     private isAuthenticated;
     private authPromise;
     private WebSocketConstructor;
+    onUnauthorized?: () => Promise<boolean>;
+    private refreshInProgress;
     constructor(config: RebaseWebSocketConfig);
     /**
      * Authenticate the WebSocket connection
@@ -45,6 +49,8 @@ export declare class RebaseWebSocketClient {
     private initWebSocket;
     private processMessageQueue;
     private attemptReconnect;
+    private isAuthError;
+    private handleAuthFailure;
     private handleWebSocketMessage;
     private ensureAuthenticated;
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/client",
   "type": "module",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "HTTP SDK client for the Rebase custom backend",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -30,9 +30,9 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@rebasepro/common": "0.3.0",
-    "@rebasepro/types": "0.3.0",
-    "@rebasepro/utils": "0.3.0"
+    "@rebasepro/types": "0.5.0",
+    "@rebasepro/common": "0.5.0",
+    "@rebasepro/utils": "0.5.0"
   },
   "devDependencies": {
     "@jest/globals": "^29.7.0",

package/src/admin.ts

@@ -1,4 +1,4 @@
-import { Transport } from "./transport";
+import type { Transport } from "./transport";
 
 export interface AdminUser {
     uid: string;
@@ -11,13 +11,6 @@ export interface AdminUser {
     updatedAt: string;
 }
 
-export interface RebaseRole {
-    id: string;
-    name: string;
-    isAdmin: boolean;
-    defaultPermissions: Record<string, unknown> | null;
-}
-
 export interface CreateAdminOptions {
     adminPath?: string;
 }
@@ -67,34 +60,6 @@ export function createAdmin(transport: Transport, options?: CreateAdminOptions)
         });
     }
 
-    async function listRoles() {
-        return transport.request<{ roles: RebaseRole[] }>(adminPath + "/roles", { method: "GET" });
-    }
-
-    async function getRole(roleId: string) {
-        return transport.request<{ role: RebaseRole }>(adminPath + "/roles/" + encodeURIComponent(roleId), { method: "GET" });
-    }
-
-    async function createRole(data: { id: string, name: string, isAdmin?: boolean, defaultPermissions?: Record<string, unknown> }) {
-        return transport.request<{ role: RebaseRole }>(adminPath + "/roles", {
-            method: "POST",
-            body: JSON.stringify(data)
-        });
-    }
-
-    async function updateRole(roleId: string, data: { name?: string, isAdmin?: boolean, defaultPermissions?: Record<string, unknown> }) {
-        return transport.request<{ role: RebaseRole }>(adminPath + "/roles/" + encodeURIComponent(roleId), {
-            method: "PUT",
-            body: JSON.stringify(data)
-        });
-    }
-
-    async function deleteRole(roleId: string) {
-        return transport.request<{ success: boolean }>(adminPath + "/roles/" + encodeURIComponent(roleId), {
-            method: "DELETE"
-        });
-    }
-
     async function bootstrap() {
         return transport.request<{ success: boolean; message: string; user: { uid: string; roles: string[] } }>(adminPath + "/bootstrap", {
             method: "POST"
@@ -108,11 +73,6 @@ export function createAdmin(transport: Transport, options?: CreateAdminOptions)
         createUser,
         updateUser,
         deleteUser,
-        listRoles,
-        getRole,
-        createRole,
-        updateRole,
-        deleteRole,
         bootstrap
     };
 }

package/src/auth.ts

@@ -520,3 +520,67 @@ newPassword })
         onAuthStateChange
     };
 }
+
+export interface CookieStorageOptions {
+    path?: string;
+    domain?: string;
+    secure?: boolean;
+    sameSite?: "Lax" | "Strict" | "None";
+    maxAge?: number;
+}
+
+export function createCookieStorage(options: CookieStorageOptions = {}): AuthStorage {
+    const defaultOptions = {
+        path: "/",
+        sameSite: "Lax" as const,
+        ...options
+    };
+
+    return {
+        getItem(key: string): string | null {
+            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: string, value: string): void {
+            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 !== undefined) {
+                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: string): void {
+            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;
+        }
+    };
+}

package/src/collection.ts

@@ -1,60 +1,55 @@
-import { Transport, FindParams, buildQueryString } from "./transport";
+import { buildQueryString, FindParams, RebaseApiError, Transport } from "./transport";
 import { RebaseWebSocketClient } from "./websocket";
-import { Entity, FilterValues, WhereFilterOp, CollectionAccessor, WhereFieldValue, FindResponse, FilterOperator } from "@rebasepro/types";
+import {
+    CollectionAccessor,
+    Entity,
+    FilterOperator,
+    FilterValues,
+    FindResponse,
+    WhereFieldValue,
+    WhereFilterOp,
+    LogicalCondition,
+    WhereValue
+} from "@rebasepro/types";
 
 import { QueryBuilder } from "./query_builder";
 
 function parseWhereFilter(where?: Record<string, WhereFieldValue>): FilterValues<string> | undefined {
     if (!where) return undefined;
-    const filters: Record<string, [WhereFilterOp, unknown]> = {};
-    for (const [key, rawValue] of Object.entries(where)) {
-        // Handle null → equality
-        if (rawValue === null) {
-            filters[key] = ["==", null];
-            continue;
-        }
+    const filters: Record<string, any> = {};
 
-        // Handle boolean → equality
-        if (typeof rawValue === "boolean") {
-            filters[key] = ["==", rawValue];
-            continue;
-        }
+    const OP_TO_FILTER: Record<string, WhereFilterOp> = {
+        "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"
+    };
 
-        // Handle number → equality
-        if (typeof rawValue === "number") {
-            filters[key] = ["==", rawValue];
-            continue;
-        }
+    const parseSingle = (rawValue: any, fieldKey: string): [WhereFilterOp, unknown] => {
+        if (rawValue === null) return ["==", null];
+        if (typeof rawValue === "boolean") return ["==", rawValue];
+        if (typeof rawValue === "number") return ["==", rawValue];
 
-        // Handle tuple: [operator, value]
-        if (Array.isArray(rawValue) && rawValue.length === 2) {
+        if (Array.isArray(rawValue) && rawValue.length === 2 && typeof rawValue[0] === "string") {
             const [rawOp, val] = rawValue;
-            const OP_TO_FILTER: Record<string, WhereFilterOp> = {
-                "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];
         }
 
-        // Handle string (original PostgREST format)
         const value = String(rawValue);
         const dotIndex = value.indexOf(".");
         if (dotIndex > 0) {
@@ -64,12 +59,24 @@ function parseWhereFilter(where?: Record<string, WhereFieldValue>): FilterValues
             let val: string | number | boolean | null | string[] = 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 "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(")")
@@ -82,24 +89,35 @@ function parseWhereFilter(where?: Record<string, WhereFieldValue>): FilterValues
                         ? valStr.slice(1, -1).split(",").map(v => v.trim())
                         : valStr.split(",");
                     break;
-                case "cs": op = "array-contains"; 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;
+                default:
+                    op = "==";
+                    val = value;
             }
-            // Simple type inference for parsing from URL-like strings
             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);
+            else if (typeof val === "string" && /^[0-9]+(\.[0-9]+)?$/.test(val) && fieldKey !== "id" && !fieldKey.endsWith("_id")) val = Number(val);
 
-            filters[key] = [op, 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;
@@ -126,13 +144,19 @@ function rowToEntity<M extends Record<string, unknown>>(row: Record<string, unkn
  * Additionally it exposes fluent query builder methods like `.where()`, `.orderBy()`.
  */
 export interface CollectionClient<M extends Record<string, unknown> = Record<string, unknown>> extends CollectionAccessor<M> {
-    // Fluent Query Builder
-    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>;
+
     search(searchString: string): QueryBuilder<M>;
+
     include(...relations: string[]): QueryBuilder<M>;
+
     count(params?: FindParams): Promise<number>;
 }
 
@@ -142,7 +166,10 @@ export function createCollectionClient<M extends Record<string, unknown> = Recor
     const client: CollectionClient<M> = {
         async find(params?: FindParams): Promise<FindResponse<M>> {
             const qs = buildQueryString(params);
-            const raw = await transport.request<{ data: Record<string, unknown>[]; meta: FindResponse<M>["meta"] }>(basePath + qs, { method: "GET" });
+            const raw = await transport.request<{
+                data: Record<string, unknown>[];
+                meta: FindResponse<M>["meta"]
+            }>(basePath + qs, { method: "GET" });
             return {
                 data: (raw.data || []).map((row: Record<string, unknown>) => rowToEntity<M>(row, slug)),
                 meta: raw.meta
@@ -150,9 +177,16 @@ export function createCollectionClient<M extends Record<string, unknown> = Recor
         },
 
         async findById(id: string | number) {
-            const raw = await transport.request<Record<string, unknown>>(`${basePath}/${encodeURIComponent(String(id))}`, { method: "GET" });
-            if (!raw) return undefined;
-            return rowToEntity<M>(raw, slug);
+            try {
+                const raw = await transport.request<Record<string, unknown>>(`${basePath}/${encodeURIComponent(String(id))}`, { method: "GET" });
+                if (!raw) return undefined;
+                return rowToEntity<M>(raw, slug);
+            } catch (err) {
+                if (err instanceof RebaseApiError && err.status === 404) {
+                    return undefined;
+                }
+                throw err;
+            }
         },
 
         async create(data: Partial<M>, id?: string | number) {
@@ -182,15 +216,23 @@ export function createCollectionClient<M extends Record<string, unknown> = Recor
         },
 
         async count(params?: FindParams): Promise<number> {
-            const countParams: FindParams = { ...params, limit: undefined, offset: undefined };
+            const countParams: FindParams = {
+                ...params,
+                limit: undefined,
+                offset: undefined
+            };
             const qs = buildQueryString(countParams);
             const raw = await transport.request<{ count: number }>(basePath + "/count" + qs, { method: "GET" });
             return raw.count ?? 0;
         },
 
         // Fluent builder instantiation
-        where(column: keyof M & string, operator: FilterOperator, value: unknown) {
-            return new QueryBuilder<M>(client).where(column, operator, value);
+        where(columnOrCondition: string | LogicalCondition, operator?: FilterOperator, value?: unknown) {
+            const builder = new QueryBuilder<M>(client as unknown as CollectionAccessor<M>);
+            if (typeof columnOrCondition === "object") {
+                return builder.where(columnOrCondition);
+            }
+            return builder.where(columnOrCondition as keyof M & string, operator!, value as WhereValue<M[keyof M & string]>);
         },
         orderBy(column: keyof M & string, ascending?: "asc" | "desc") {
             return new QueryBuilder<M>(client).orderBy(column, ascending);
@@ -239,8 +281,10 @@ export function createCollectionClient<M extends Record<string, unknown> = Recor
 
         client.listenById = (id: string | number, onUpdate: (data: Entity<M> | undefined) => void, onError?: (error: Error) => void) => {
             return ws.listenEntity(
-                { path: slug,
-entityId: String(id) },
+                {
+                    path: slug,
+                    entityId: String(id)
+                },
                 (entity: Entity | null) => {
                     if (entity) {
                         onUpdate(entity as Entity<M>);

package/src/index.ts

@@ -65,17 +65,32 @@ import { createStorage } from "./storage";
  * `http://` → `ws://`, `https://` → `wss://`.
  */
 function deriveWebSocketUrl(baseUrl?: string): string {
-    if (!baseUrl) {
-        // If no baseUrl is provided, we can try to derive it from the window object if in browser
-        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(/^https?:\/\//i, (match) => match.toLowerCase() === "https://" ? "wss://" : "ws://")
         .replace(/\/$/, "");
 }
 
@@ -91,12 +106,27 @@ export function createRebaseClient<DB = Record<string, unknown>>(options: Create
 
     let ws: RebaseWebSocketClient | undefined;
     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() + 10000) {
+                    try {
+                        session = await auth.refreshSession();
+                    } catch (e) { /* ignore */ }
+                }
                 return session?.accessToken || options.token || "";
-            }
+            },
+            onUnauthorized: wsOnUnauthorized
         });
 
         auth.onAuthStateChange((event, session) => {

package/src/query_builder.ts

@@ -1 +1 @@
-export { QueryBuilder } from "@rebasepro/common";
+export { QueryBuilder, or, and, cond } from "@rebasepro/common";

package/src/transport.ts

@@ -1,4 +1,4 @@
-import { FindParams as TypesFindParams, FindResponse as TypesFindResponse, WhereFieldValue } from "@rebasepro/types";
+import { FindParams as TypesFindParams, FindResponse as TypesFindResponse, WhereFieldValue, WhereFilterOpShort } from "@rebasepro/types";
 import { rebaseReviver } from "./reviver";
 
 export interface RebaseClientConfig {
@@ -70,19 +70,40 @@ function normalizeWhereValue(value: WhereFieldValue): string {
     if (typeof value === "number") return String(value);
 
     // Tuple: [operator, val]
-    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: [WhereFilterOpShort, any][] = Array.isArray(value[0])
+            ? (value as [WhereFilterOpShort, any][])
+            : [value as [WhereFilterOpShort, any]];
+
+        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}`;
+        }
     }
 
     // String — pass through (either plain equality value or PostgREST syntax)
     return String(value);
 }
 
+function serializeLogicalCondition(cond: any): string {
+    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}`;
+    }
+}
+
 export function buildQueryString(params?: FindParams): string {
     if (!params) return "";
     const parts: string[] = [];
@@ -103,10 +124,23 @@ export function buildQueryString(params?: FindParams): string {
         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 as WhereFieldValue);
-            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 as WhereFieldValue);
+                    parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(normalized)}`);
+                }
+            } else {
+                const normalized = normalizeWhereValue(value as WhereFieldValue);
+                parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(normalized)}`);
+            }
         }
     }