@rebasepro/client 0.0.1-canary.f81da60 → 0.1.2

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/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();
@@ -1149,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;
 }
@@ -1260,11 +1274,11 @@ class RebaseWebSocketClient {
         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);
       });
     }
   }
@@ -1303,7 +1317,7 @@ class RebaseWebSocketClient {
               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");
@@ -2188,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) {
@@ -2244,6 +2259,7 @@ function createRebaseClient(options) {
     auth,
     admin,
     cron,
+    functions,
     storage,
     ws,
     setToken: transport.setToken,
@@ -2274,6 +2290,7 @@ export {
   createAuth,
   createCollectionClient,
   createCron,
+  createFunctionsClient,
   createMemoryStorage,
   createRebaseClient,
   createStorage,