@rebasepro/client 0.23.0 → 0.24.1-canary.g19596ef

package/dist/index.d.ts

@@ -3,41 +3,43 @@ import { createAuth, CreateAuthOptions } from "./auth.js";
 import { createAdmin, CreateAdminOptions } from "./admin.js";
 import { createCron, CreateCronOptions } from "./cron.js";
 import { createBackups } from "./backups.js";
-import { createApiKeys, CreateApiKeysOptions } from "./api-keys.js";
+import { createApiKeys, CreateApiKeysOptions, createPersonalKeys, CreatePersonalKeysOptions } from "./api-keys.js";
 import { CollectionClient } from "./collection.js";
 import { createFunctionsClient } from "./functions.js";
 import { RebaseWebSocketClient } from "./websocket.js";
 import { RebaseRealtimeChannel, type ChannelOptions } from "./realtime-channel.js";
-import { type OfflineApi, type OfflineConfig } from "./offline.js";
-import { type BatchOperation, type BatchResult, InsertOf, RebaseClient, RebaseSdkData, RowOf, StorageSource, StorageSourceDefinition, StorageSourceRegistry, UpdateOf, type WriteOptions } from "@rebasepro/types";
+import type { OfflineApi, OfflineConfig } from "./offline.js";
+import { type BatchOperation, type BatchResult, type IncludeOf, InsertOf, RebaseClient, RebaseSdkData, RowOf, StorageSource, StorageSourceDefinition, StorageSourceRegistry, UpdateOf, type WriteOptions } from "@rebasepro/types";
 export { RebaseApiError } from "./transport.js";
 export { RebaseClientError } from "./errors.js";
 export type { RebaseErrorCode } from "@rebasepro/types";
 export type { RebaseClientConfig, FindParams, FindResponse } from "./transport.js";
-export type { CollectionClient } from "./collection.js";
+export type { CollectionClient, RestoreOptions, TrashClient } from "./collection.js";
 export type { FindResult, SDKCollectionClient, SDKQueryBuilderInterface, PaginationMeta } from "@rebasepro/types";
 export type { IterateParams, FindAllParams, PageWalkOptions, CursorSpec } from "@rebasepro/types";
 export { RebasePaginationError } from "@rebasepro/common";
 export type { PaginationErrorCode } from "@rebasepro/common";
-export { QueryBuilder, or, and, not, cond } from "@rebasepro/common";
+export { or, and, not, cond } from "@rebasepro/common";
+export { resolveStorageReferences, storageReference, parseStorageReference, isStorageReference, STORAGE_REFERENCE_SCHEME, storageTargetOfDownloadUrl, storageReferencesForDownloadUrls, storageTargetsInText } from "@rebasepro/types";
+export type { StorageReferenceTarget, StorageReferenceResolver } from "@rebasepro/types";
 export { createCookieStorage, createMemoryStorage } from "./auth.js";
-export type { AuthConfig, AuthStorage, CookieStorageOptions, CreateAuthOptions } from "./auth.js";
+export type { AuthConfig, AuthStorage, CookieStorageOptions, CreateAuthOptions, SessionRestoreOutcome } from "./auth.js";
 export type { User, RebaseSession, AuthTokens, AuthChangeEvent, DeviceSession } from "@rebasepro/types";
 export type { CreateAdminOptions, ListUsersOptions } from "./admin.js";
 export type { AdminUser } from "./admin.js";
 export type { CreateCronOptions } from "./cron.js";
-export { createBackups } from "./backups.js";
-export type { CreateBackupsOptions } from "./backups.js";
-export type { ApiKeyMasked, ApiKeyPermission, ApiKeyWithSecret, CreateApiKeyRequest, CreateApiKeysOptions, UpdateApiKeyRequest } from "./api-keys.js";
+export type { BackupStream } from "./backups.js";
+export type { ApiKeyKind, ApiKeyMasked, ApiKeyWithSecret, CreateApiKeyRequest, CreateApiKeysOptions, CreatePersonalKeyRequest, CreatePersonalKeysOptions, UpdateApiKeyRequest } from "./api-keys.js";
 export type { FunctionInvokeOptions, FunctionsClient } from "./functions.js";
 export { RebaseWebSocketClient } from "./websocket.js";
 export { RebaseRealtimeChannel } from "./realtime-channel.js";
 export type { PresenceState, PresenceDiff, BroadcastEvent, ChannelTransport, ChannelOptions, ChannelHistoryEntry, ChannelHistoryResult } from "./realtime-channel.js";
-export type { OfflineApi, OfflineConfig, OfflineStatus } from "./offline.js";
-export { isOfflineError } from "./offline.js";
-export type { LiveResult, ObserveOptions, RowSnapshotMeta } from "./collection.js";
+export type { ConflictResolution, OfflineApi, OfflineConfig, OfflineQueueOptions, OfflineStatus } from "./offline.js";
+export { isOfflineError } from "./offline-errors.js";
+export type { LiveResult, ObserveByIdOptions, ObserveOptions, RowSnapshotMeta } from "./collection.js";
 export { etagOf } from "./collection.js";
 export type { BatchOperation, BatchRef, BatchResult, FieldOperation, UpdateValues, UpsertOptions } from "@rebasepro/types";
+export type { WriteOptions, WhereFilterOp, WhereFor, WhereConditionFor, WhereValueFor, FilterValues, FieldPath, OrderBySpec, LogicalCondition, LogicalConditionFor, FilterCondition, FilterConditionFor, AggregateParams, AggregateSelect, AggregateRow, AggregateResult, AggregateMeta, IncludeSpec, IncludeOptions, QueryComputedFields, RowOf, InsertOf, UpdateOf, StorageSource } from "@rebasepro/types";
 export type { OfflineStore, OfflineCacheEntry, OfflineCacheRecord, PendingMutation, MutationRollback } from "./offline-store.js";
 export { MemoryOfflineStore } from "./offline-store.js";
 export interface CreateRebaseClientOptions extends RebaseClientConfig {
@@ -45,6 +47,7 @@ export interface CreateRebaseClientOptions extends RebaseClientConfig {
     admin?: CreateAdminOptions;
     cron?: CreateCronOptions;
     apiKeys?: CreateApiKeysOptions;
+    personalKeys?: CreatePersonalKeysOptions;
     /**
      * Declared storage sources for multi-backend support. Server-transport
      * entries are auto-wired into `client.storageRegistry`; `direct` sources
@@ -77,12 +80,20 @@ export interface CreateRebaseClientOptions extends RebaseClientConfig {
     offline?: boolean | OfflineConfig;
 }
 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;
+/** The accessor whose generated entry declares `Slug: S`, or `never`. */
+type AccessorOfSlug<DB, S extends string> = {
+    [K in keyof DB]: DB[K] extends {
+        Slug: S;
+    } ? K : never;
+}[keyof DB];
+type DBEntry<DB, S extends string> = [
+    AccessorOfSlug<DB, S>
+] extends [never] ? (KebabToCamelCase<S> extends keyof DB ? DB[KebabToCamelCase<S>] : unknown) : DB[AccessorOfSlug<DB, S>];
 type TypedDataLayer<DB> = {
-    collection<S extends string>(slug: S): CollectionClient<RowOf<DBEntry<DB, S>>, InsertOf<DBEntry<DB, S>>, UpdateOf<DBEntry<DB, S>>>;
+    collection<S extends string>(slug: S): CollectionClient<RowOf<DBEntry<DB, S>>, InsertOf<DBEntry<DB, S>>, UpdateOf<DBEntry<DB, S>>, IncludeOf<DBEntry<DB, S>, DB>>;
 } & {
-    [K in keyof DB]: CollectionClient<RowOf<DB[K]>, InsertOf<DB[K]>, UpdateOf<DB[K]>>;
-} & RebaseSdkData;
+    [K in keyof DB]: CollectionClient<RowOf<DB[K]>, InsertOf<DB[K]>, UpdateOf<DB[K]>, IncludeOf<DB[K], DB>>;
+} & (string extends keyof DB ? RebaseSdkData : Pick<RebaseSdkData, "collection">);
 /**
  * The return type of `createRebaseClient<DB>()`.
  *
@@ -91,15 +102,42 @@ type TypedDataLayer<DB> = {
  * typed collection accessors when a `DB` schema generic is supplied.
  */
 export type CreateRebaseClientResult<DB = Record<string, unknown>> = Omit<RebaseClient<DB>, "data" | "email"> & {
+    /**
+     * Send this token from now on, over HTTP and on the realtime socket. An
+     * open socket is rebuilt to authenticate with it. A token getter, when one
+     * is installed, still comes first.
+     */
     setToken: (token: string | null) => void;
+    /**
+     * Ask `getter` for the token each time one is needed — every HTTP request
+     * and every time the realtime socket authenticates. This is how a host
+     * that signs users in with its own provider (Clerk, Firebase Auth, a
+     * session of its own) authenticates the client:
+     *
+     * ```ts
+     * client.setAuthTokenGetter(() => clerk.session?.getToken() ?? Promise.resolve(null));
+     * ```
+     *
+     * It comes before the client's own session and the `token` option, which
+     * are used when it answers `null` or throws. An open socket is rebuilt to
+     * authenticate through it.
+     */
     setAuthTokenGetter: (getter: () => Promise<string | null>) => void;
+    /**
+     * Answer a refused credential — a 401 over HTTP, an auth error on the
+     * socket — with `handler`; resolve `true` to have the request or
+     * subscription retried with the token resolved again. Replaces the
+     * client's own session refresh.
+     */
     setOnUnauthorized: (handler: () => Promise<boolean>) => void;
+    /** The token the next request would carry, resolved as it would be. */
     resolveToken: () => Promise<string | null>;
     auth: ReturnType<typeof createAuth>;
     admin: ReturnType<typeof createAdmin>;
     cron: ReturnType<typeof createCron>;
     backups: ReturnType<typeof createBackups>;
     apiKeys: ReturnType<typeof createApiKeys>;
+    personalKeys: ReturnType<typeof createPersonalKeys>;
     functions: ReturnType<typeof createFunctionsClient>;
     ws?: RebaseWebSocketClient;
     /**
@@ -147,7 +185,15 @@ export type CreateRebaseClientResult<DB = Record<string, unknown>> = Omit<Rebase
      * Neither reaches into the response for a `data` key.
      */
     call: <T = unknown>(endpoint: string, payload?: unknown) => Promise<T>;
-    collection: <M extends Record<string, unknown> = Record<string, unknown>>(slug: string) => CollectionClient<M>;
+    /**
+     * A collection by slug — the same client `data.collection(slug)` returns,
+     * typed from the generated `Database` when the slug is one of its
+     * collections, or by the row type passed explicitly.
+     */
+    collection: {
+        <S extends string>(slug: S): CollectionClient<RowOf<DBEntry<DB, S>>, InsertOf<DBEntry<DB, S>>, UpdateOf<DBEntry<DB, S>>, IncludeOf<DBEntry<DB, S>, DB>>;
+        <M extends Record<string, unknown> = Record<string, unknown>>(slug: string): CollectionClient<M>;
+    };
     /**
      * Write across collections in one transaction.
      *
@@ -170,12 +216,17 @@ export type CreateRebaseClientResult<DB = Record<string, unknown>> = Omit<Rebase
      * `data` is aligned to `operations`: the written row for a create, upsert
      * or update, and `null` for a delete.
      *
+     * `collection` is the accessor `client.data.<accessor>` takes — `orderItems`
+     * for the slug `order_items` — and is sent as the slug through the
+     * `collections` dictionary. A name that is not an accessor goes out as
+     * written, so an untyped client can still pass the slug.
+     *
      * @example
      * ```ts
      * await client.batch([
      *     { op: "create", collection: "orders", values: { total: 40 }, ref: "order" },
-     *     { op: "create", collection: "order_items",
-     *       values: { order_id: { $ref: "order.id" }, sku: "A-1" } },
+     *     { op: "create", collection: "orderItems",
+     *       values: { orderId: { $ref: "order.id" }, sku: "A-1" } },
      *     { op: "update", collection: "stock", id: "A-1", values: { count: { $inc: -1 } } }
      * ]);
      * ```