@rebasepro/client 0.2.1 → 0.2.4

package/dist/query_builder.d.ts

@@ -1,53 +1 @@
-import { FindResponse } from "@rebasepro/types";
-import { CollectionClient } from "./collection";
-export type FilterOperator = "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "nin" | "cs" | "csa" | "==" | "!=" | ">" | ">=" | "<" | "<=" | "array-contains" | "array-contains-any" | "not-in";
-export declare class QueryBuilder<M extends Record<string, unknown> = Record<string, unknown>> {
-    private collection;
-    private params;
-    constructor(collection: CollectionClient<M>);
-    /**
-     * Add a filter condition to your query.
-     * @example
-     * client.collection('users').where('age', '>=', 18).find()
-     */
-    where(column: keyof M & string, operator: FilterOperator, value: unknown): this;
-    /**
-     * Order the results by a specific column.
-     * @example
-     * client.collection('users').orderBy('createdAt', 'desc').find()
-     */
-    orderBy(column: keyof M & string, ascending?: "asc" | "desc"): this;
-    /**
-     * Limit the number of results returned.
-     */
-    limit(count: number): this;
-    /**
-     * Skip the first N results.
-     */
-    offset(count: number): this;
-    /**
-     * Set a free-text search string if supported by the backend.
-     */
-    search(searchString: string): 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: string[]): this;
-    /**
-     * Execute the find query and return the results.
-     */
-    find(): Promise<FindResponse<M>>;
-    /**
-     * Listen to realtime updates matching this query.
-     */
-    listen(onUpdate: (data: FindResponse<M>) => void, onError?: (error: Error) => void): () => void;
-}
+export { QueryBuilder } from "@rebasepro/common";

package/package.json

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

package/src/admin.ts

@@ -16,7 +16,6 @@ export interface RebaseRole {
     name: string;
     isAdmin: boolean;
     defaultPermissions: Record<string, unknown> | null;
-    config: Record<string, unknown> | null;
 }
 
 export interface CreateAdminOptions {
@@ -76,14 +75,14 @@ export function createAdmin(transport: Transport, options?: CreateAdminOptions)
         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>, config?: Record<string, unknown> }) {
+    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>, config?: Record<string, unknown> }) {
+    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)

package/src/auth.ts

@@ -29,7 +29,9 @@ export type AuthChangeEvent = "SIGNED_IN" | "SIGNED_OUT" | "TOKEN_REFRESHED" | "
 export interface AuthConfig {
     needsSetup: boolean;
     registrationEnabled: boolean;
-    emailServiceEnabled: boolean;
+    emailServiceEnabled?: boolean;
+    passwordReset?: boolean;
+    emailVerification?: boolean;
     enabledProviders: string[];
 }
 

package/src/collection.ts

@@ -1,8 +1,8 @@
 import { Transport, FindParams, buildQueryString } from "./transport";
 import { RebaseWebSocketClient } from "./websocket";
-import { Entity, FilterValues, WhereFilterOp, CollectionAccessor, WhereFieldValue, FindResponse } from "@rebasepro/types";
+import { Entity, FilterValues, WhereFilterOp, CollectionAccessor, WhereFieldValue, FindResponse, FilterOperator } from "@rebasepro/types";
 
-import { FilterOperator, QueryBuilder } from "./query_builder";
+import { QueryBuilder } from "./query_builder";
 
 function parseWhereFilter(where?: Record<string, WhereFieldValue>): FilterValues<string> | undefined {
     if (!where) return undefined;

package/src/index.ts

@@ -11,6 +11,7 @@ export * from "./auth";
 export * from "./admin";
 export * from "./cron";
 export * from "./collection";
+export * from "./query_builder";
 export * from "./websocket";
 export * from "./storage";
 export * from "./reviver";
@@ -24,9 +25,15 @@ export interface CreateRebaseClientOptions extends RebaseClientConfig {
 
 import { RebaseWebSocketClient } from "./websocket";
 import { RebaseClient as BaseRebaseClient, RebaseData, CollectionAccessor, StorageSource } from "@rebasepro/types";
+export type { Entity, FindResponse } from "@rebasepro/types";
 import { toSnakeCase } from "@rebasepro/utils";
 
-export type RebaseClient<DB = Record<string, unknown>> = BaseRebaseClient<DB> & {
+type KebabToCamelCase<S extends string> =
+  S extends `${infer T}-${infer U}`
+    ? `${T}${Capitalize<KebabToCamelCase<U>>}`
+    : S;
+
+export type RebaseClient<DB = Record<string, unknown>> = Omit<BaseRebaseClient<DB>, "data"> & {
     setToken: (token: string | null) => void;
     setAuthTokenGetter: (getter: () => Promise<string | null>) => void;
     setOnUnauthorized: (handler: () => Promise<boolean>) => void;
@@ -38,15 +45,17 @@ export type RebaseClient<DB = Record<string, unknown>> = BaseRebaseClient<DB> &
     ws?: RebaseWebSocketClient;
     storage?: StorageSource;
     call: <T = unknown>(endpoint: string, payload?: unknown) => Promise<T>;
-    data: RebaseData & {
-        collection<K extends keyof DB>(slug: Extract<K, string>): CollectionClient<
-            DB[K] extends { Row: infer R extends Record<string, unknown> } ? R : Record<string, unknown>
+    data: {
+        collection<S extends string>(slug: S): CollectionClient<
+            KebabToCamelCase<S> extends keyof DB
+                ? (DB[KebabToCamelCase<S>] extends { Row: infer R extends Record<string, unknown> } ? R : Record<string, unknown>)
+                : Record<string, unknown>
         >;
     } & {
         [K in keyof DB]: CollectionClient<
             DB[K] extends { Row: infer R extends Record<string, unknown> } ? R : Record<string, unknown>
         >;
-    };
+    } & RebaseData;
 };
 
 import { createStorage } from "./storage";

package/src/query_builder.ts

@@ -1,125 +1 @@
-import { FindParams, Entity, FindResponse } from "@rebasepro/types";
-import { CollectionClient } from "./collection";
-
-export type FilterOperator =
-    | "eq" | "neq" | "gt" | "gte" | "lt" | "lte"
-    | "in" | "nin" | "cs" | "csa"
-    | "==" | "!=" | ">" | ">=" | "<" | "<="
-    | "array-contains" | "array-contains-any"
-    | "not-in";
-
-/**
- * Maps standard operators to Rebase backend's string-based operators
- */
-function mapOperator(op: FilterOperator): string {
-    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;
-    }
-}
-
-export class QueryBuilder<M extends Record<string, unknown> = Record<string, unknown>> {
-    private params: FindParams = { where: {} };
-
-    constructor(private collection: CollectionClient<M>) {}
-
-    /**
-     * Add a filter condition to your query.
-     * @example
-     * client.collection('users').where('age', '>=', 18).find()
-     */
-    where(column: keyof M & string, operator: FilterOperator, value: unknown): this {
-        if (!this.params.where) {
-            this.params.where = {};
-        }
-
-        const mappedOp = mapOperator(operator);
-        let formattedValue = value;
-
-        // Handle arrays for in, nin, cs, csa
-        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: keyof M & string, ascending: "asc" | "desc" = "asc"): this {
-        this.params.orderBy = `${column}:${ascending}`;
-        return this;
-    }
-
-    /**
-     * Limit the number of results returned.
-     */
-    limit(count: number): this {
-        this.params.limit = count;
-        return this;
-    }
-
-    /**
-     * Skip the first N results.
-     */
-    offset(count: number): this {
-        this.params.offset = count;
-        return this;
-    }
-
-    /**
-     * Set a free-text search string if supported by the backend.
-     */
-    search(searchString: string): this {
-        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: string[]): this {
-        this.params.include = relations;
-        return this;
-    }
-
-    /**
-     * Execute the find query and return the results.
-     */
-    async find(): Promise<FindResponse<M>> {
-        return this.collection.find(this.params) as Promise<FindResponse<M>>;
-    }
-
-    /**
-     * Listen to realtime updates matching this query.
-     */
-    listen(onUpdate: (data: FindResponse<M>) => void, onError?: (error: Error) => void): () => void {
-        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);
-    }
-}
+export { QueryBuilder } from "@rebasepro/common";

package/src/transport.ts

@@ -169,15 +169,23 @@ headers });
         if (res.status === 204) return undefined as T; // SAFETY: HTTP 204 No Content has no body
 
         const text = await res.text().catch(() => "");
-        let body: any = {};
+        let body: Record<string, unknown> = {};
         if (text) {
             try {
-                body = JSON.parse(text, rebaseReviver);
+                body = JSON.parse(text, rebaseReviver) as Record<string, unknown>;
             } catch (e) {
                 // If not valid JSON, fallback
             }
         }
 
+        const getErrorField = (obj: Record<string, unknown>, field: string): unknown => {
+            const err = obj?.error;
+            if (err && typeof err === "object" && err !== null && field in (err as Record<string, unknown>)) {
+                return (err as Record<string, unknown>)[field];
+            }
+            return obj?.[field];
+        };
+
         if (res.status === 401 && onUnauthorizedHandler) {
             const retried = await onUnauthorizedHandler();
             if (retried) {
@@ -195,7 +203,7 @@ headers });
 headers: retryHeaders });
                 if (retryRes.status === 204) return undefined as T; // SAFETY: HTTP 204 No Content has no body
                 const retryText = await retryRes.text().catch(() => "");
-                let retryBody: any = {};
+                let retryBody: Record<string, unknown> = {};
                 if (retryText) {
                     try {
                         retryBody = JSON.parse(retryText, rebaseReviver);
@@ -209,9 +217,9 @@ headers: retryHeaders });
                     }
                     throw new RebaseApiError(
                         retryRes.status,
-                        retryBody?.error?.message || retryBody?.message || fallbackMessage || `Request failed with status ${retryRes.status}`,
-                        retryBody?.error?.code || retryBody?.code,
-                        retryBody?.error?.details || retryBody?.details
+                        String(getErrorField(retryBody, "message") || fallbackMessage || `Request failed with status ${retryRes.status}`),
+                        getErrorField(retryBody, "code") as string | undefined,
+                        getErrorField(retryBody, "details")
                     );
                 }
                 return retryBody as T;
@@ -226,9 +234,9 @@ headers: retryHeaders });
             }
             throw new RebaseApiError(
                 res.status,
-                body?.error?.message || body?.message || fallbackMessage || `Request failed with status ${res.status}`,
-                body?.error?.code || body?.code,
-                body?.error?.details || body?.details
+                String(getErrorField(body, "message") || fallbackMessage || `Request failed with status ${res.status}`),
+                getErrorField(body, "code") as string | undefined,
+                getErrorField(body, "details")
             );
         }