@rebasepro/client 0.9.0 → 0.9.1-canary.0de22e0

package/README.md

@@ -161,4 +161,4 @@ const unsubscribe = client.data.products.listen(
 - [`@rebasepro/common`](../common) — `QueryBuilder`, `buildRebaseData`, shared utilities
 - [`@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
+- [`@rebasepro/app`](../auth) — React hook adapter that wraps `client.auth` for CMS integration

package/dist/admin.d.ts

@@ -48,6 +48,7 @@ export declare function createAdmin(transport: Transport, options?: CreateAdminO
         user: AdminUser;
         temporaryPassword?: string;
         invitationSent?: boolean;
+        emailDeliveryFailed?: boolean;
     }>;
     listRoles: () => Promise<{
         roles: Array<{

package/dist/auth.d.ts

@@ -147,6 +147,11 @@ export declare function createAuth(transport: Transport, options?: CreateAuthOpt
         success: boolean;
         message: string;
     }>;
+    linkProvider: (providerId: string, payload: Record<string, unknown>) => Promise<{
+        success: boolean;
+        provider: string;
+        alreadyLinked: boolean;
+    }>;
     sendVerificationEmail: () => Promise<{
         success: boolean;
         message: string;

package/dist/backups.d.ts

@@ -0,0 +1,13 @@
+import { Transport } from "./transport";
+import type { BackupInfo, BackupDestinationKind } from "@rebasepro/types";
+export interface CreateBackupsOptions {
+    backupsPath?: string;
+}
+export declare function createBackups(transport: Transport, options?: CreateBackupsOptions): {
+    list: () => Promise<{
+        backups: BackupInfo[];
+        destinationKind: BackupDestinationKind;
+        configured: boolean;
+    }>;
+    download: (key: string) => Promise<Blob>;
+};

package/dist/index.d.ts

@@ -2,10 +2,12 @@ import { RebaseClientConfig } from "./transport";
 import { createAuth, CreateAuthOptions } from "./auth";
 import { createAdmin, CreateAdminOptions } from "./admin";
 import { createCron, CreateCronOptions } from "./cron";
+import { createBackups } from "./backups";
 import { createApiKeys, CreateApiKeysOptions } from "./api-keys";
 import { CollectionClient } from "./collection";
 import { createFunctionsClient } from "./functions";
 import { RebaseWebSocketClient } from "./websocket";
+import { RebaseRealtimeChannel, type ChannelOptions } from "./realtime-channel";
 import { InsertOf, RebaseClient, RebaseSdkData, RowOf, StorageSource, StorageSourceDefinition, StorageSourceRegistry, UpdateOf } from "@rebasepro/types";
 export { RebaseApiError } from "./transport";
 export { RebaseClientError } from "./errors";
@@ -21,9 +23,13 @@ export type { RebaseUser, RebaseTokens } from "./auth";
 export type { CreateAdminOptions } from "./admin";
 export type { AdminUser } from "./admin";
 export type { CreateCronOptions } from "./cron";
+export { createBackups } from "./backups";
+export type { CreateBackupsOptions } from "./backups";
 export type { ApiKeyMasked, ApiKeyPermission, ApiKeyWithSecret, CreateApiKeyRequest, CreateApiKeysOptions, UpdateApiKeyRequest } from "./api-keys";
 export type { FunctionInvokeOptions, FunctionsClient } from "./functions";
 export { RebaseWebSocketClient } from "./websocket";
+export { RebaseRealtimeChannel } from "./realtime-channel";
+export type { PresenceState, PresenceDiff, BroadcastEvent, ChannelTransport, ChannelOptions, ChannelHistoryEntry, ChannelHistoryResult } from "./realtime-channel";
 export interface CreateRebaseClientOptions extends RebaseClientConfig {
     auth?: CreateAuthOptions;
     admin?: CreateAdminOptions;
@@ -67,14 +73,42 @@ export type CreateRebaseClientResult<DB = Record<string, unknown>> = Omit<Rebase
     auth: ReturnType<typeof createAuth>;
     admin: ReturnType<typeof createAdmin>;
     cron: ReturnType<typeof createCron>;
+    backups: ReturnType<typeof createBackups>;
     apiKeys: ReturnType<typeof createApiKeys>;
     functions: ReturnType<typeof createFunctionsClient>;
     ws?: RebaseWebSocketClient;
+    /**
+     * Broadcast and presence channels.
+     *
+     * Was missing from this type while present on the returned object, which
+     * made `client.realtime.channel(...)` a type error and forced every adopter
+     * to cast around the feature before they could reach it.
+     */
+    realtime: {
+        /**
+         * Join a broadcast/presence channel. Repeated calls with the same name
+         * return the same channel object. Throws only when the client was
+         * created with `realtime: false`.
+         *
+         * Pass `{ history: true }` to have the channel replay what it missed on
+         * join and on every reconnect, for channels the server retains.
+         */
+        channel: (name: string, options?: ChannelOptions) => RebaseRealtimeChannel;
+    };
+    /**
+     * Release the realtime socket and its reconnect timer.
+     *
+     * An open socket keeps the Node event loop alive, so a script that does not
+     * call this will not exit on its own. Safe when realtime was never started
+     * (`realtime: false`), and safe to call twice.
+     */
+    close: () => void;
     storage: StorageSource;
     storageRegistry: StorageSourceRegistry;
     createStorageSource: (storageId: string) => StorageSource;
     fetchStorageSources: () => Promise<StorageSourceDefinition[]>;
     call: <T = unknown>(endpoint: string, payload?: unknown) => Promise<T>;
+    collection: <M extends Record<string, unknown> = Record<string, unknown>>(slug: string) => CollectionClient<M>;
     data: TypedDataLayer<DB>;
 };
 export declare function createRebaseClient<DB = Record<string, unknown>>(options: CreateRebaseClientOptions): CreateRebaseClientResult<DB>;