@rebasepro/client 0.8.0 → 0.9.0

package/README.md

@@ -16,7 +16,7 @@ pnpm add @rebasepro/client
 - **Authentication** — email/password, Google, 10+ OAuth providers, session management, password reset
 - **Admin** — user CRUD for admins
 - **Storage** — file upload, download, delete, list
-- **Realtime** — WebSocket subscriptions for collection and entity changes
+- **Realtime** — WebSocket subscriptions for collection and snapshot changes
 - **Cron** — list, trigger, and manage cron jobs
 - **Custom functions** — invoke server-side Hono route functions
 - **Type-safe data proxy** — `client.data.products` auto-maps to the `products` collection
@@ -49,18 +49,18 @@ pnpm add @rebasepro/client
 | Method | Description |
 |---|---|
 | `find(params?)` | Query with pagination. Returns `FindResponse<M>` (`{ data, meta }`) |
-| `findById(id)` | Fetch a single entity. Returns `Entity<M> \| undefined` |
-| `create(data, id?)` | Create entity. Returns `Entity<M>` |
-| `update(id, data)` | Update entity. Returns `Entity<M>` |
-| `delete(id)` | Delete entity |
-| `count(params?)` | Count matching entities |
+| `findById(id)` | Fetch a single snapshot. Returns `Snapshot<M> \| undefined` |
+| `create(data, id?)` | Create snapshot. Returns `Snapshot<M>` |
+| `update(id, data)` | Update snapshot. Returns `Snapshot<M>` |
+| `delete(id)` | Delete snapshot |
+| `count(params?)` | Count matching snapshots |
 | `where(col, op, val)` | Start a fluent query — returns `QueryBuilder` |
 | `orderBy(col, dir?)` | Order results — returns `QueryBuilder` |
 | `limit(n)` / `offset(n)` | Pagination — returns `QueryBuilder` |
 | `search(str)` | Full-text search — returns `QueryBuilder` |
-| `include(...rels)` | Include related entities — returns `QueryBuilder` |
+| `include(...rels)` | Include related snapshots — returns `QueryBuilder` |
 | `listen(params, onUpdate, onError?)` | Realtime subscription (requires WebSocket) |
-| `listenById(id, onUpdate, onError?)` | Realtime single-entity subscription |
+| `listenById(id, onUpdate, onError?)` | Realtime single-snapshot subscription |
 
 ### Auth Module (`client.auth`)
 
@@ -119,7 +119,7 @@ pnpm add @rebasepro/client
 | `createCookieStorage(options?)` | Cookie-based auth storage adapter |
 | `createMemoryStorage()` | In-memory auth storage adapter |
 | `QueryBuilder` | Fluent query builder (also re-exported from `@rebasepro/common`) |
-| `Entity`, `FindResponse` | Re-exported from `@rebasepro/types` |
+| `Snapshot`, `FindResponse` | Re-exported from `@rebasepro/types` |
 
 ## Quick Start
 
@@ -159,6 +159,6 @@ const unsubscribe = client.data.products.listen(
 ## Related Packages
 
 - [`@rebasepro/common`](../common) — `QueryBuilder`, `buildRebaseData`, shared utilities
-- [`@rebasepro/types`](../types) — `Entity`, `FindResponse`, `CollectionAccessor`, etc.
+- [`@rebasepro/types`](../types) — `Snapshot`, `FindResponse`, `CollectionAccessor`, etc.
 - [`@rebasepro/utils`](../utils) — `toSnakeCase` and other helpers
 - [`@rebasepro/auth`](../auth) — React hook adapter that wraps `client.auth` for CMS integration

package/dist/auth.d.ts

@@ -1,27 +1,16 @@
 import { Transport } from "./transport";
-import { AuthChangeEvent } from "@rebasepro/types";
-export interface RebaseUser {
+import type { AuthChangeEvent, RebaseSession, AuthTokens, DeviceSession, User } from "@rebasepro/types";
+export type { RebaseSession, AuthTokens, AuthChangeEvent, DeviceSession } from "@rebasepro/types";
+/** @deprecated Use `User` from `@rebasepro/types` instead. */
+export type RebaseUser = User;
+/** @deprecated Use `AuthTokens` from `@rebasepro/types` instead. */
+export type RebaseTokens = AuthTokens;
+/** Minimal, non-sensitive user profile returned by {@link findUserByEmail}. */
+export interface PublicUserProfile {
     uid: string;
-    email: string | null;
     displayName: string | null;
     photoURL: string | null;
-    emailVerified?: boolean;
-    roles?: string[];
-    providerId: string;
-    isAnonymous: boolean;
 }
-export interface RebaseTokens {
-    accessToken: string;
-    refreshToken: string;
-    accessTokenExpiresAt: number;
-}
-export interface RebaseSession {
-    accessToken: string;
-    refreshToken: string;
-    expiresAt: number;
-    user: RebaseUser;
-}
-export type { AuthChangeEvent };
 export interface AuthConfig {
     needsSetup: boolean;
     registrationEnabled: boolean;
@@ -42,15 +31,21 @@ export interface CreateAuthOptions {
     authPath?: string;
     autoRefresh?: boolean;
     persistSession?: boolean;
+    /**
+     * Authentication flow mode.
+     * - 'json' (default): Tokens are sent/received in JSON bodies. Refresh token is stored in local storage.
+     * - 'cookie': Refresh token is sent/received via httpOnly cookies. Access token remains in memory.
+     */
+    authFlowMode?: "json" | "cookie";
 }
 export declare function createAuth(transport: Transport, options?: CreateAuthOptions): {
     signInWithEmail: (email: string, password: string) => Promise<{
-        user: RebaseUser;
+        user: User;
         accessToken: string;
         refreshToken: string;
     }>;
     signUp: (email: string, password: string, displayName?: string) => Promise<{
-        user: RebaseUser;
+        user: User;
         accessToken: string;
         refreshToken: string;
     }>;
@@ -62,27 +57,27 @@ export declare function createAuth(transport: Transport, options?: CreateAuthOpt
         code: string;
         redirectUri: string;
     }) => Promise<{
-        user: RebaseUser;
+        user: User;
         accessToken: string;
         refreshToken: string;
     }>;
     signInWithLinkedin: (code: string, redirectUri: string) => Promise<{
-        user: RebaseUser;
+        user: User;
         accessToken: string;
         refreshToken: string;
     }>;
     signInWithOAuth: (providerId: string, payload: Record<string, unknown>) => Promise<{
-        user: RebaseUser;
+        user: User;
         accessToken: string;
         refreshToken: string;
     }>;
     signInWithGitHub: (code: string, redirectUri: string) => Promise<{
-        user: RebaseUser;
+        user: User;
         accessToken: string;
         refreshToken: string;
     }>;
     signInWithMicrosoft: (code: string, redirectUri: string) => Promise<{
-        user: RebaseUser;
+        user: User;
         accessToken: string;
         refreshToken: string;
     }>;
@@ -93,52 +88,53 @@ export declare function createAuth(transport: Transport, options?: CreateAuthOpt
         };
         email?: string;
     }) => Promise<{
-        user: RebaseUser;
+        user: User;
         accessToken: string;
         refreshToken: string;
     }>;
     signInWithFacebook: (code: string, redirectUri: string) => Promise<{
-        user: RebaseUser;
+        user: User;
         accessToken: string;
         refreshToken: string;
     }>;
     signInWithTwitter: (code: string, redirectUri: string, codeVerifier: string) => Promise<{
-        user: RebaseUser;
+        user: User;
         accessToken: string;
         refreshToken: string;
     }>;
     signInWithDiscord: (code: string, redirectUri: string) => Promise<{
-        user: RebaseUser;
+        user: User;
         accessToken: string;
         refreshToken: string;
     }>;
     signInWithGitLab: (code: string, redirectUri: string) => Promise<{
-        user: RebaseUser;
+        user: User;
         accessToken: string;
         refreshToken: string;
     }>;
     signInWithBitbucket: (code: string, redirectUri: string) => Promise<{
-        user: RebaseUser;
+        user: User;
         accessToken: string;
         refreshToken: string;
     }>;
     signInWithSlack: (code: string, redirectUri: string) => Promise<{
-        user: RebaseUser;
+        user: User;
         accessToken: string;
         refreshToken: string;
     }>;
     signInWithSpotify: (code: string, redirectUri: string) => Promise<{
-        user: RebaseUser;
+        user: User;
         accessToken: string;
         refreshToken: string;
     }>;
     signOut: () => Promise<void>;
     refreshSession: () => Promise<RebaseSession>;
-    getUser: () => Promise<RebaseUser>;
+    getUser: () => Promise<User>;
+    findUserByEmail: (email: string) => Promise<PublicUserProfile | null>;
     updateUser: (updates: {
         displayName?: string;
         photoURL?: string;
-    }) => Promise<RebaseUser>;
+    }) => Promise<User>;
     resetPasswordForEmail: (email: string) => Promise<{
         success: boolean;
         message: string;
@@ -164,11 +160,11 @@ export declare function createAuth(transport: Transport, options?: CreateAuthOpt
         message: string;
     }>;
     verifyMagicLink: (token: string) => Promise<{
-        user: RebaseUser;
+        user: User;
         accessToken: string;
         refreshToken: string;
     }>;
-    getSessions: () => Promise<Record<string, unknown>[]>;
+    getSessions: () => Promise<DeviceSession[]>;
     revokeSession: (sessionId: string) => Promise<{
         success: boolean;
     }>;
@@ -178,6 +174,7 @@ export declare function createAuth(transport: Transport, options?: CreateAuthOpt
     getAuthConfig: () => Promise<AuthConfig>;
     getSession: () => RebaseSession | null;
     onAuthStateChange: (callback: (event: AuthChangeEvent, session: RebaseSession | null) => void) => () => boolean;
+    isInitialized: () => Promise<void>;
 };
 export interface CookieStorageOptions {
     path?: string;

package/dist/collection.d.ts

@@ -1,21 +1,17 @@
 import { FindParams, Transport } from "./transport";
 import { RebaseWebSocketClient } from "./websocket";
-import { CollectionAccessor, LogicalCondition, WhereFilterOp, WhereValue } from "@rebasepro/types";
-import { QueryBuilder } from "./query_builder";
+import { SDKCollectionClient } from "@rebasepro/types";
 /**
- * CollectionClient extends `CollectionAccessor` from `@rebasepro/types` so that
- * `client.data` can be passed directly to the core Rebase component.
+ * The concrete, HTTP-backed implementation of the public
+ * {@link SDKCollectionClient} contract — flat rows (no Entity wrapper), plus
+ * fluent query-builder methods (`.where()`, `.orderBy()`, …).
  *
- * Additionally it exposes fluent query builder methods like `.where()`, `.orderBy()`.
+ * This is what `createRebaseClient().data.<collection>` returns. It is not a
+ * separate API from {@link SDKCollectionClient}; it only widens it with
+ * `count()`. Program against {@link SDKCollectionClient} when you want a
+ * transport-agnostic type.
  */
-export interface CollectionClient<M extends Record<string, unknown> = Record<string, unknown>> extends CollectionAccessor<M> {
-    where<K extends keyof M & string>(column: K, operator: WhereFilterOp, value: WhereValue<M[K]>): QueryBuilder<M>;
-    where(logicalCondition: LogicalCondition): QueryBuilder<M>;
-    orderBy(column: keyof M & string, direction?: "asc" | "desc"): QueryBuilder<M>;
-    limit(count: number): QueryBuilder<M>;
-    offset(count: number): QueryBuilder<M>;
-    search(searchString: string): QueryBuilder<M>;
-    include(...relations: string[]): QueryBuilder<M>;
+export interface CollectionClient<M extends Record<string, unknown> = Record<string, unknown>, I = Partial<M>, U = Partial<M>> extends SDKCollectionClient<M, I, U> {
     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/data-proxy.test.d.ts

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

package/dist/errors.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Client-side logic error (e.g. accessing an unknown collection when a typed
+ * dictionary is available). A subclass of {@link RebaseApiError}, so a single
+ * `catch (e) { if (e instanceof RebaseApiError) ... }` covers it too.
+ *
+ * The canonical definition now lives in `@rebasepro/types`; re-exported here to
+ * preserve the historical `import { RebaseClientError } from ".../errors"` path.
+ */
+export { RebaseClientError } from "@rebasepro/types";

package/dist/index.d.ts

@@ -6,20 +6,24 @@ import { createApiKeys, CreateApiKeysOptions } from "./api-keys";
 import { CollectionClient } from "./collection";
 import { createFunctionsClient } from "./functions";
 import { RebaseWebSocketClient } from "./websocket";
-import { RebaseClient, RebaseData, StorageSource, StorageSourceDefinition, StorageSourceRegistry } from "@rebasepro/types";
-export * from "./transport";
-export * from "./auth";
-export * from "./admin";
-export * from "./cron";
-export * from "./api-keys";
-export * from "./collection";
-export * from "./query_builder";
-export * from "./websocket";
-export * from "./storage";
-export * from "./storage-registry";
-export * from "./reviver";
-export * from "./functions";
-export type { Entity, FindResponse } from "@rebasepro/types";
+import { InsertOf, RebaseClient, RebaseSdkData, RowOf, StorageSource, StorageSourceDefinition, StorageSourceRegistry, UpdateOf } from "@rebasepro/types";
+export { RebaseApiError } from "./transport";
+export { RebaseClientError } from "./errors";
+export type { RebaseClientConfig, FindParams, FindResponse } from "./transport";
+export type { CollectionClient } from "./collection";
+export type { FindResult, SDKCollectionClient, SDKQueryBuilderInterface, PaginationMeta } from "@rebasepro/types";
+export { QueryBuilder, or, and, cond } from "@rebasepro/common";
+export { createCookieStorage, createMemoryStorage } from "./auth";
+export type { AuthConfig, AuthStorage, CookieStorageOptions, CreateAuthOptions } from "./auth";
+export type { RebaseSession, AuthTokens, AuthChangeEvent, DeviceSession } from "@rebasepro/types";
+/** @deprecated Import `User` / `AuthTokens` from `@rebasepro/types` instead. */
+export type { RebaseUser, RebaseTokens } from "./auth";
+export type { CreateAdminOptions } from "./admin";
+export type { AdminUser } from "./admin";
+export type { CreateCronOptions } from "./cron";
+export type { ApiKeyMasked, ApiKeyPermission, ApiKeyWithSecret, CreateApiKeyRequest, CreateApiKeysOptions, UpdateApiKeyRequest } from "./api-keys";
+export type { FunctionInvokeOptions, FunctionsClient } from "./functions";
+export { RebaseWebSocketClient } from "./websocket";
 export interface CreateRebaseClientOptions extends RebaseClientConfig {
     auth?: CreateAuthOptions;
     admin?: CreateAdminOptions;
@@ -42,15 +46,12 @@ export interface CreateRebaseClientOptions extends RebaseClientConfig {
     collections?: Record<string, string>;
 }
 type KebabToCamelCase<S extends string> = S extends `${infer T}-${infer U}` ? `${T}${Capitalize<KebabToCamelCase<U>>}` : S;
+type DBEntry<DB, S extends string> = KebabToCamelCase<S> extends keyof DB ? DB[KebabToCamelCase<S>] : unknown;
 type TypedDataLayer<DB> = {
-    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>>;
+    collection<S extends string>(slug: S): CollectionClient<RowOf<DBEntry<DB, S>>, InsertOf<DBEntry<DB, S>>, UpdateOf<DBEntry<DB, S>>>;
 } & {
-    [K in keyof DB]: CollectionClient<DB[K] extends {
-        Row: infer R extends Record<string, unknown>;
-    } ? R : Record<string, unknown>>;
-} & RebaseData;
+    [K in keyof DB]: CollectionClient<RowOf<DB[K]>, InsertOf<DB[K]>, UpdateOf<DB[K]>>;
+} & RebaseSdkData;
 /**
  * The return type of `createRebaseClient<DB>()`.
  *
@@ -58,7 +59,7 @@ type TypedDataLayer<DB> = {
  * capabilities populated and the `data` layer narrowed to provide
  * typed collection accessors when a `DB` schema generic is supplied.
  */
-export type CreateRebaseClientResult<DB = Record<string, unknown>> = Omit<RebaseClient, "data"> & {
+export type CreateRebaseClientResult<DB = Record<string, unknown>> = Omit<RebaseClient<DB>, "data" | "email"> & {
     setToken: (token: string | null) => void;
     setAuthTokenGetter: (getter: () => Promise<string | null>) => void;
     setOnUnauthorized: (handler: () => Promise<boolean>) => void;