@rebasepro/client 0.0.1-canary.f81da60 → 0.1.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/client",
   "type": "module",
-  "version": "0.0.1-canary.f81da60",
+  "version": "0.1.2",
   "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.f81da60",
-    "@rebasepro/utils": "0.0.1-canary.f81da60"
+    "@rebasepro/types": "0.1.2",
+    "@rebasepro/utils": "0.1.2"
   },
   "devDependencies": {
     "@jest/globals": "^29.7.0",

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/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

@@ -195,11 +195,13 @@ export class RebaseWebSocketClient {
                 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);
             });
         }
     }
@@ -244,7 +246,9 @@ export class RebaseWebSocketClient {
                             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);
                     }
                 }