@rebasepro/client 0.0.1-canary.eae7889 → 0.1.0

package/dist/auth.d.ts

@@ -50,7 +50,12 @@ export declare function createAuth(transport: Transport, options?: CreateAuthOpt
         accessToken: string;
         refreshToken: string;
     }>;
-    signInWithGoogle: (idToken: string) => Promise<{
+    signInWithGoogle: (tokenOrPayload: string | {
+        idToken?: string;
+        accessToken?: string;
+        code?: string;
+        redirectUri?: string;
+    }) => Promise<{
         user: RebaseUser;
         accessToken: string;
         refreshToken: string;

package/dist/collection.d.ts

@@ -1,4 +1,4 @@
-import { Transport } from "./transport";
+import { Transport, FindParams } from "./transport";
 import { RebaseWebSocketClient } from "./websocket";
 import { CollectionAccessor } from "@rebasepro/types";
 import { FilterOperator, QueryBuilder } from "./query_builder";
@@ -15,5 +15,6 @@ 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 declare function createCollectionClient<M extends Record<string, unknown> = Record<string, unknown>>(transport: Transport, slug: string, ws?: RebaseWebSocketClient): CollectionClient<M>;

package/dist/collection.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/functions.d.ts

@@ -0,0 +1,49 @@
+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 declare function createFunctionsClient(transport: Transport): FunctionsClient;

package/dist/index.d.ts

@@ -3,6 +3,7 @@ import { createAuth, CreateAuthOptions } from "./auth";
 import { createAdmin, CreateAdminOptions } from "./admin";
 import { createCron, CreateCronOptions } from "./cron";
 import { CollectionClient } from "./collection";
+import type { FunctionsClient } from "./functions";
 export * from "./transport";
 export * from "./auth";
 export * from "./admin";
@@ -11,6 +12,7 @@ export * from "./collection";
 export * from "./websocket";
 export * from "./storage";
 export * from "./reviver";
+export * from "./functions";
 export interface CreateRebaseClientOptions extends RebaseClientConfig {
     auth?: CreateAuthOptions;
     admin?: CreateAdminOptions;
@@ -26,6 +28,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>;

package/dist/index.es.js

@@ -381,21 +381,18 @@ function createAuth(transport, options) {
       refreshToken: session.refreshToken
     };
   }
-  async function signInWithGoogle(idToken) {
+  async function signInWithGoogle(tokenOrPayload) {
     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, redirectUri) {
     const fetchFn = getFetch();
@@ -1077,6 +1074,12 @@ function createCollectionClient(transport, slug, ws) {
         method: "DELETE"
       });
     },
+    async count(params) {
+      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);
@@ -1143,6 +1146,23 @@ function createCollectionClient(transport, slug, ws) {
   }
   return client;
 }
+function createFunctionsClient(transport) {
+  return {
+    async invoke(name, payload, options) {
+      const method = options?.method ?? "POST";
+      const subPath = options?.path ? `/${options.path.replace(/^\//, "")}` : "";
+      const routePath = `/functions/${encodeURIComponent(name)}${subPath}`;
+      const init = { method };
+      if (payload !== void 0 && method !== "GET") {
+        init.body = JSON.stringify(payload);
+      }
+      if (options?.headers) {
+        init.headers = options.headers;
+      }
+      return transport.request(routePath, init);
+    }
+  };
+}
 function rehydrateEntity(entity) {
   return entity;
 }
@@ -1249,16 +1269,16 @@ class RebaseWebSocketClient {
   setAuthTokenGetter(getAuthToken) {
     this.getAuthToken = getAuthToken;
     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;
         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);
+        if (this.ws) console.debug("WebSocket auto-auth skipped:", e?.message || e);
       });
     }
   }
@@ -1285,7 +1305,7 @@ class RebaseWebSocketClient {
     try {
       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;
@@ -1294,10 +1314,10 @@ 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);
+            console.debug("WebSocket connected without auth:", error?.message || error);
           }
         }
         this.emit(wasReconnect ? "reconnect" : "connect");
@@ -1315,7 +1335,7 @@ 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;
@@ -1357,7 +1377,7 @@ class RebaseWebSocketClient {
     }
     this.reconnectAttempts++;
     const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 3e4);
-    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);
     }
@@ -1527,7 +1547,7 @@ 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;
       } catch (error) {
         this.authPromise = null;
@@ -1546,7 +1566,7 @@ class RebaseWebSocketClient {
         }
         if (attempt < retryCount - 1) {
           const delay = Math.min(1e3 * (attempt + 1), 3e3);
-          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));
         }
       }
@@ -1563,7 +1583,7 @@ 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;
@@ -1821,7 +1841,7 @@ class RebaseWebSocketClient {
               };
             }
           }
-          console.log(`[RebaseWS] Row ${incomingEntity.id} refetch mismatch:
+          console.debug(`[RebaseWS] Row ${incomingEntity.id} refetch mismatch:
 `, JSON.stringify(mismatches, null, 2));
         }
       }
@@ -1981,7 +2001,7 @@ class RebaseWebSocketClient {
    * we need to re-register everything to resume receiving updates.
    */
   resubscribeAll() {
-    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)`);
     for (const [key, sub] of this.collectionSubscriptions.entries()) {
       const oldBackendId = sub.backendSubscriptionId;
       const newBackendId = `collection_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
@@ -2182,6 +2202,7 @@ function createRebaseClient(options) {
   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);
   let ws;
   if (resolvedWsUrl) {
@@ -2238,6 +2259,7 @@ function createRebaseClient(options) {
     auth,
     admin,
     cron,
+    functions,
     storage,
     ws,
     setToken: transport.setToken,
@@ -2268,6 +2290,7 @@ export {
   createAuth,
   createCollectionClient,
   createCron,
+  createFunctionsClient,
   createMemoryStorage,
   createRebaseClient,
   createStorage,