@rebasepro/client 0.0.1-canary.eae7889 → 0.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/client",
   "type": "module",
-  "version": "0.0.1-canary.eae7889",
+  "version": "0.1.0",
   "description": "HTTP SDK client for the Rebase custom backend",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -30,8 +30,8 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@rebasepro/types": "0.0.1-canary.eae7889",
-    "@rebasepro/utils": "0.0.1-canary.eae7889"
+    "@rebasepro/types": "0.1.0",
+    "@rebasepro/utils": "0.1.0"
   },
   "devDependencies": {
     "@jest/globals": "^29.7.0",
@@ -41,7 +41,6 @@
     "jest": "^29.7.0",
     "npm-run-all": "^4.1.5",
     "ts-jest": "^29.3.1",
-    "ts-node": "^10.9.2",
     "tsd": "^0.31.2",
     "typescript": "^5.8.3",
     "vite": "^5.4.17"

package/src/auth.ts

@@ -193,19 +193,31 @@ accessToken: session.accessToken,
 refreshToken: session.refreshToken };
     }
 
-    async function signInWithGoogle(idToken: string) {
+    /**
+     * Sign in with Google.
+     *
+     * Supports two invocation styles:
+     * - `signInWithGoogle({ idToken })` — ID-token flow (One Tap / Sign In button)
+     * - `signInWithGoogle({ accessToken })` — Access-token flow (popup)
+     * - `signInWithGoogle({ code, redirectUri })` — Authorization code flow (most secure)
+     * - `signInWithGoogle(idToken)` — Legacy shorthand for ID-token flow
+     */
+    async function signInWithGoogle(
+        tokenOrPayload: string | { idToken?: string; accessToken?: string; code?: string; redirectUri?: string }
+    ) {
         const fetchFn = getFetch();
+        const body = typeof tokenOrPayload === "string"
+            ? { idToken: tokenOrPayload }
+            : tokenOrPayload;
         const res = await fetchFn(authUrl("/google"), {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ idToken })
+            body: JSON.stringify(body)
         });
-        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 };
+        const responseBody = await res.json().catch(() => ({}));
+        if (!res.ok) throwApiError(res.status, responseBody, res.statusText);
+        const session = handleAuthResponse(responseBody, "SIGNED_IN");
+        return { user: session.user, accessToken: session.accessToken, refreshToken: session.refreshToken };
     }
 
     async function signInWithLinkedin(code: string, redirectUri: string) {

package/src/collection.test.ts

@@ -0,0 +1,159 @@
+import { jest } from '@jest/globals';
+import { createCollectionClient } from "./collection";
+import type { Transport } from "./transport";
+
+function createMockTransport(): Transport {
+    return {
+        request: jest.fn<any>().mockResolvedValue({}),
+        setToken: jest.fn(),
+        setAuthTokenGetter: jest.fn(),
+        setOnUnauthorized: jest.fn(),
+        baseUrl: "http://localhost:3000",
+        apiPath: "/api",
+        fetchFn: globalThis.fetch,
+        getHeaders: () => ({}),
+        resolveToken: jest.fn<any>().mockResolvedValue(null),
+    };
+}
+
+describe("createCollectionClient", () => {
+    let transport: Transport;
+
+    beforeEach(() => {
+        transport = createMockTransport();
+    });
+
+    describe("count()", () => {
+        it("should call the /count endpoint and return the count", async () => {
+            (transport.request as ReturnType<typeof jest.fn>).mockResolvedValue({ count: 42 });
+
+            const client = createCollectionClient(transport, "products");
+            const result = await client.count();
+
+            expect(transport.request).toHaveBeenCalledWith(
+                "/data/products/count",
+                { method: "GET" }
+            );
+            expect(result).toBe(42);
+        });
+
+        it("should forward where filters to the count endpoint", async () => {
+            (transport.request as ReturnType<typeof jest.fn>).mockResolvedValue({ count: 7 });
+
+            const client = createCollectionClient(transport, "products");
+            const result = await client.count({
+                where: { status: "eq.published" }
+            });
+
+            expect(transport.request).toHaveBeenCalledWith(
+                expect.stringContaining("/data/products/count?"),
+                { method: "GET" }
+            );
+            // Verify the query string includes the filter
+            const calledUrl = (transport.request as ReturnType<typeof jest.fn>).mock.calls[0][0] as string;
+            expect(calledUrl).toContain("status=");
+            expect(result).toBe(7);
+        });
+
+        it("should forward orderBy to the count endpoint", async () => {
+            (transport.request as ReturnType<typeof jest.fn>).mockResolvedValue({ count: 15 });
+
+            const client = createCollectionClient(transport, "items");
+            const result = await client.count({
+                orderBy: "created_at:desc"
+            });
+
+            const calledUrl = (transport.request as ReturnType<typeof jest.fn>).mock.calls[0][0] as string;
+            expect(calledUrl).toContain("/data/items/count?");
+            expect(calledUrl).toContain("orderBy=");
+            expect(result).toBe(15);
+        });
+
+        it("should NOT include limit or offset in the count request", async () => {
+            (transport.request as ReturnType<typeof jest.fn>).mockResolvedValue({ count: 100 });
+
+            const client = createCollectionClient(transport, "users");
+            // Even if the caller passes limit/offset in params, they should be stripped
+            await client.count({ limit: 50, offset: 10 });
+
+            const calledUrl = (transport.request as ReturnType<typeof jest.fn>).mock.calls[0][0] as string;
+            expect(calledUrl).not.toContain("limit=");
+            expect(calledUrl).not.toContain("offset=");
+        });
+
+        it("should return 0 when meta.count is missing", async () => {
+            (transport.request as ReturnType<typeof jest.fn>).mockResolvedValue({});
+
+            const client = createCollectionClient(transport, "empty");
+            const result = await client.count();
+
+            expect(result).toBe(0);
+        });
+
+        it("should forward searchString to the count endpoint", async () => {
+            (transport.request as ReturnType<typeof jest.fn>).mockResolvedValue({ count: 3 });
+
+            const client = createCollectionClient(transport, "articles");
+            const result = await client.count({
+                searchString: "hello world"
+            });
+
+            const calledUrl = (transport.request as ReturnType<typeof jest.fn>).mock.calls[0][0] as string;
+            expect(calledUrl).toContain("searchString=");
+            expect(calledUrl).toContain("hello");
+            expect(result).toBe(3);
+        });
+
+        it("should forward multiple where filters correctly", async () => {
+            (transport.request as ReturnType<typeof jest.fn>).mockResolvedValue({ count: 5 });
+
+            const client = createCollectionClient(transport, "orders");
+            await client.count({
+                where: {
+                    status: "eq.active",
+                    total: [">=", 100],
+                }
+            });
+
+            const calledUrl = (transport.request as ReturnType<typeof jest.fn>).mock.calls[0][0] as string;
+            expect(calledUrl).toContain("status=");
+            expect(calledUrl).toContain("total=");
+        });
+    });
+
+    describe("find()", () => {
+        it("should call the list endpoint and return entities", async () => {
+            (transport.request as ReturnType<typeof jest.fn>).mockResolvedValue({
+                data: [{ id: "1", name: "Product A" }],
+                meta: { total: 1, limit: 20, offset: 0, hasMore: false }
+            });
+
+            const client = createCollectionClient(transport, "products");
+            const result = await client.find();
+
+            expect(transport.request).toHaveBeenCalledWith(
+                "/data/products",
+                { method: "GET" }
+            );
+            expect(result.data).toHaveLength(1);
+            expect(result.data[0].id).toBe("1");
+            expect(result.data[0].path).toBe("products");
+            expect(result.meta.total).toBe(1);
+        });
+    });
+
+    describe("count() is defined", () => {
+        it("should have count as a defined function on the accessor", () => {
+            const client = createCollectionClient(transport, "products");
+            expect(typeof client.count).toBe("function");
+            expect(client.count).toBeDefined();
+        });
+
+        it("should pass the accessor.count truthiness check (used by EntitiesCount component)", () => {
+            const client = createCollectionClient(transport, "products");
+            // The EntitiesCount component does `if (accessor.count) { ... }`
+            // This verifies that check would pass
+            expect(!!client.count).toBe(true);
+        });
+    });
+});

package/src/collection.ts

@@ -133,6 +133,7 @@ export interface CollectionClient<M extends Record<string, unknown> = Record<str
     offset(count: number): QueryBuilder<M>;
     search(searchString: string): QueryBuilder<M>;
     include(...relations: string[]): QueryBuilder<M>;
+    count(params?: FindParams): Promise<number>;
 }
 
 export function createCollectionClient<M extends Record<string, unknown> = Record<string, unknown>>(transport: Transport, slug: string, ws?: RebaseWebSocketClient): CollectionClient<M> {
@@ -180,6 +181,13 @@ export function createCollectionClient<M extends Record<string, unknown> = Recor
             });
         },
 
+        async count(params?: FindParams): Promise<number> {
+            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);

package/src/functions.ts

@@ -0,0 +1,80 @@
+import type { Transport } from "./transport";
+
+/**
+ * Client interface for invoking custom backend functions.
+ *
+ * Custom functions are Hono route files auto-mounted by the Rebase backend
+ * at `/api/functions/{name}`.  The `FunctionsClient` wraps the shared
+ * transport so callers never need to manually construct URLs or inject
+ * auth tokens.
+ *
+ * @example
+ * ```ts
+ * const result = await client.functions.invoke<{ job: Job }>('extract-job', {
+ *     url: 'https://example.com/posting',
+ *     html: htmlContent,
+ * });
+ * ```
+ */
+export interface FunctionsClient {
+    /**
+     * Invoke a custom backend function by name.
+     *
+     * @typeParam T - Expected shape of the response payload.
+     * @param name    - Function name (the filename without extension, e.g. `"extract-job"`).
+     * @param payload - Optional JSON-serialisable body sent as `POST`.
+     * @param options - Optional overrides (HTTP method, sub-path, extra headers).
+     * @returns The parsed JSON response from the function.
+     */
+    invoke<T = unknown>(
+        name: string,
+        payload?: unknown,
+        options?: FunctionInvokeOptions,
+    ): Promise<T>;
+}
+
+export interface FunctionInvokeOptions {
+    /** HTTP method — defaults to `"POST"`. */
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    /** Sub-path appended after the function name, e.g. `"status/123"`. */
+    path?: string;
+    /** Extra headers merged into the request (auth is still injected automatically). */
+    headers?: Record<string, string>;
+}
+
+/**
+ * Create a `FunctionsClient` backed by the given transport.
+ *
+ * The transport already handles:
+ * - Base URL resolution
+ * - JWT injection via `Authorization: Bearer`
+ * - 401 retry / `onUnauthorized` flow
+ * - Consistent error throwing via `RebaseApiError`
+ *
+ * @internal
+ */
+export function createFunctionsClient(transport: Transport): FunctionsClient {
+    return {
+        async invoke<T = unknown>(
+            name: string,
+            payload?: unknown,
+            options?: FunctionInvokeOptions,
+        ): Promise<T> {
+            const method = options?.method ?? "POST";
+            const subPath = options?.path ? `/${options.path.replace(/^\//, "")}` : "";
+            const routePath = `/functions/${encodeURIComponent(name)}${subPath}`;
+
+            const init: RequestInit = { method };
+
+            if (payload !== undefined && method !== "GET") {
+                init.body = JSON.stringify(payload);
+            }
+
+            if (options?.headers) {
+                init.headers = options.headers;
+            }
+
+            return transport.request<T>(routePath, init);
+        },
+    };
+}

package/src/index.ts

@@ -3,6 +3,8 @@ import { createAuth, CreateAuthOptions } from "./auth";
 import { createAdmin, CreateAdminOptions } from "./admin";
 import { createCron, CreateCronOptions } from "./cron";
 import { createCollectionClient, CollectionClient } from "./collection";
+import { createFunctionsClient } from "./functions";
+import type { FunctionsClient } from "./functions";
 
 export * from "./transport";
 export * from "./auth";
@@ -12,6 +14,7 @@ export * from "./collection";
 export * from "./websocket";
 export * from "./storage";
 export * from "./reviver";
+export * from "./functions";
 
 export interface CreateRebaseClientOptions extends RebaseClientConfig {
     auth?: CreateAuthOptions;
@@ -31,6 +34,7 @@ export type RebaseClient<DB = Record<string, unknown>> = BaseRebaseClient<DB> &
     auth: ReturnType<typeof createAuth>;
     admin: ReturnType<typeof createAdmin>;
     cron: ReturnType<typeof createCron>;
+    functions: FunctionsClient;
     ws?: RebaseWebSocketClient;
     storage?: StorageSource;
     call: <T = unknown>(endpoint: string, payload?: unknown) => Promise<T>;
@@ -72,6 +76,7 @@ export function createRebaseClient<DB = Record<string, unknown>>(options: Create
     const admin = createAdmin(transport, options.admin);
     const cron = createCron(transport, options.cron);
     const storage = createStorage(transport);
+    const functions = createFunctionsClient(transport);
 
     const resolvedWsUrl = options.websocketUrl ?? deriveWebSocketUrl(options.baseUrl);
 
@@ -143,6 +148,7 @@ export function createRebaseClient<DB = Record<string, unknown>>(options: Create
         auth,
         admin,
         cron,
+        functions,
         storage,
         ws,
         setToken: transport.setToken,

package/src/websocket.ts

@@ -190,16 +190,18 @@ export class RebaseWebSocketClient {
         this.getAuthToken = getAuthToken;
         // Auto-authenticate if we are already connected but didn't have the token getter yet
         if (this.isConnected && !this.isAuthenticated && !this.authPromise) {
-            console.log("WebSocket auto-authenticating after token getter set");
+            console.debug("WebSocket auto-authenticating after token getter set");
             this.getAuthToken().then(token => {
                 if (!this.ws) return; // Prevent memory leaks / actions after disconnect
                 if (token) {
                     this.authenticate(token).catch(e => {
-                        if (this.ws) console.warn("WebSocket auto-auth failed:", e);
+                        if (this.ws) console.debug("WebSocket auto-auth skipped:", e?.message || e);
                     });
                 }
             }).catch(e => {
-                if (this.ws) console.warn("WebSocket auto-auth failed:", e);
+                // User not logged in or auth still loading — this is expected,
+                // the WebSocket will authenticate on-demand when a request is made.
+                if (this.ws) console.debug("WebSocket auto-auth skipped:", e?.message || e);
             });
         }
     }
@@ -230,7 +232,7 @@ export class RebaseWebSocketClient {
             this.ws = new this.WebSocketConstructor(this.websocketUrl);
 
             this.ws!.onopen = async () => {
-                console.log("Connected to PostgreSQL backend");
+                console.debug("Connected to PostgreSQL backend");
                 const wasReconnect = this.reconnectAttempts > 0;
                 this.isConnected = true;
                 this.reconnectAttempts = 0;
@@ -241,10 +243,12 @@ export class RebaseWebSocketClient {
                         const token = await this.getAuthToken();
                         if (token) {
                             await this.authenticate(token);
-                            console.log("WebSocket auto-authenticated");
+                            console.debug("WebSocket auto-authenticated");
                         }
                     } catch (error) {
-                        console.warn("WebSocket auto-auth failed, requests may fail:", error);
+                        // User not logged in or auth still loading — this is expected.
+                        // Authentication will happen on-demand when the user logs in.
+                        console.debug("WebSocket connected without auth:", (error as Error)?.message || error);
                     }
                 }
 
@@ -269,7 +273,7 @@ export class RebaseWebSocketClient {
             };
 
             this.ws!.onclose = () => {
-                console.log("Disconnected from PostgreSQL backend");
+                console.debug("Disconnected from PostgreSQL backend");
                 this.isConnected = false;
                 this.isAuthenticated = false;
                 this.authPromise = null;
@@ -319,7 +323,7 @@ export class RebaseWebSocketClient {
         this.reconnectAttempts++;
         const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
 
-        console.log(`Attempting to reconnect in ${delay}ms (attempt ${this.reconnectAttempts})`);
+        console.debug(`Attempting to reconnect in ${delay}ms (attempt ${this.reconnectAttempts})`);
         
         if (this.reconnectTimeout) {
             clearTimeout(this.reconnectTimeout);
@@ -534,7 +538,7 @@ export class RebaseWebSocketClient {
                 this.authPromise = this.authenticate(token);
                 await this.authPromise;
                 this.authPromise = null;
-                console.log("WebSocket authenticated on demand");
+                console.debug("WebSocket authenticated on demand");
                 return; // Success
             } catch (error: unknown) {
                 this.authPromise = null;
@@ -560,7 +564,7 @@ export class RebaseWebSocketClient {
                 // For other errors, retry with backoff
                 if (attempt < retryCount - 1) {
                     const delay = Math.min(1000 * (attempt + 1), 3000);
-                    console.log(`WebSocket auth attempt ${attempt + 1} failed, retrying in ${delay}ms...`);
+                    console.debug(`WebSocket auth attempt ${attempt + 1} failed, retrying in ${delay}ms...`);
                     await new Promise(resolve => setTimeout(resolve, delay));
                 }
             }
@@ -580,7 +584,7 @@ export class RebaseWebSocketClient {
         try {
             const token = await this.getAuthToken();
             await this.authenticate(token);
-            console.log("WebSocket reauthenticated successfully");
+            console.debug("WebSocket reauthenticated successfully");
         } catch (error) {
             console.error("WebSocket reauthentication failed:", error);
             throw error;
@@ -891,7 +895,7 @@ options }
 incoming: normIncoming[key] };
                         }
                     }
-                    console.log(`[RebaseWS] Row ${incomingEntity.id} refetch mismatch:\n`, JSON.stringify(mismatches, null, 2));
+                    console.debug(`[RebaseWS] Row ${incomingEntity.id} refetch mismatch:\n`, JSON.stringify(mismatches, null, 2));
                 }
             }
             return incomingEntity;
@@ -1101,7 +1105,7 @@ onError });
      * we need to re-register everything to resume receiving updates.
      */
     private resubscribeAll(): void {
-        console.log(`[WS] Re-subscribing: ${this.collectionSubscriptions.size} collection(s), ${this.entitySubscriptions.size} entity(ies)`);
+        console.debug(`[WS] Re-subscribing: ${this.collectionSubscriptions.size} collection(s), ${this.entitySubscriptions.size} entity(ies)`);
 
         // Re-subscribe collection subscriptions
         for (const [key, sub] of this.collectionSubscriptions.entries()) {