@rebasepro/client 0.19.1 → 0.19.2-canary.g08eed46

package/dist/collection.d.ts

@@ -1,6 +1,22 @@
 import { FindParams, Transport } from "./transport.js";
 import { RebaseWebSocketClient } from "./websocket.js";
 import { FindResult, SDKCollectionClient } from "@rebasepro/types";
+/**
+ * The version of a row, when it came straight from a read that reported one.
+ *
+ * ```ts
+ * const post = await client.data.posts.get(1);
+ * await client.data.posts.update(1, { title: "New" }, { ifMatch: etagOf(post) });
+ * ```
+ *
+ * `undefined` for a row from `find()` (a list response carries one ETag at
+ * most, and it would not be this row's), from the offline cache, or from a
+ * server that does not send them. Passing `undefined` as `ifMatch` sends no
+ * precondition, so the call above degrades to an ordinary update rather than
+ * failing — which is the right default, and the reason to read this at the call
+ * site where the choice is visible.
+ */
+export declare function etagOf(row: unknown): string | undefined;
 /**
  * A live query result: a normal {@link FindResult} plus what an interface
  * needs to decide whether to show a "saving…" or "offline" affordance over it.

package/dist/index.d.ts

@@ -9,7 +9,7 @@ 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 { InsertOf, RebaseClient, RebaseSdkData, RowOf, StorageSource, StorageSourceDefinition, StorageSourceRegistry, UpdateOf } from "@rebasepro/types";
+import { type BatchOperation, type BatchResult, 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";
@@ -19,7 +19,7 @@ export type { FindResult, SDKCollectionClient, SDKQueryBuilderInterface, Paginat
 export type { IterateParams, FindAllParams, PageWalkOptions, CursorSpec } from "@rebasepro/types";
 export { RebasePaginationError } from "@rebasepro/common";
 export type { PaginationErrorCode } from "@rebasepro/common";
-export { QueryBuilder, or, and, cond } from "@rebasepro/common";
+export { QueryBuilder, or, and, not, cond } from "@rebasepro/common";
 export { createCookieStorage, createMemoryStorage } from "./auth.js";
 export type { AuthConfig, AuthStorage, CookieStorageOptions, CreateAuthOptions } from "./auth.js";
 export type { User, RebaseSession, AuthTokens, AuthChangeEvent, DeviceSession } from "@rebasepro/types";
@@ -36,6 +36,8 @@ export type { PresenceState, PresenceDiff, BroadcastEvent, ChannelTransport, Cha
 export type { OfflineApi, OfflineConfig, OfflineStatus } from "./offline.js";
 export { isOfflineError } from "./offline.js";
 export type { LiveResult, ObserveOptions, RowSnapshotMeta } from "./collection.js";
+export { etagOf } from "./collection.js";
+export type { BatchOperation, BatchRef, BatchResult, FieldOperation, UpdateValues, UpsertOptions } 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 {
@@ -146,6 +148,39 @@ export type CreateRebaseClientResult<DB = Record<string, unknown>> = Omit<Rebase
      */
     call: <T = unknown>(endpoint: string, payload?: unknown) => Promise<T>;
     collection: <M extends Record<string, unknown> = Record<string, unknown>>(slug: string) => CollectionClient<M>;
+    /**
+     * Write across collections in one transaction.
+     *
+     * `createMany` and friends are one collection at a time, which is the wrong
+     * shape for the writes that most need to be atomic: an order and its line
+     * items, a user and their membership row, a document and its audit entry.
+     * Sent as separate calls those can half-succeed, and the recovery — read
+     * back, work out which half landed, undo it — is code nobody writes.
+     *
+     * Operations run in order, each through the pipeline its single-row
+     * equivalent uses: the same validation, callbacks and row-level security,
+     * as the same user. All of them land or none do.
+     *
+     * Name an operation with `ref` and a later one can stand
+     * `{ $ref: "<name>.<field>" }` wherever a value goes — which is the only
+     * way to express "insert the parent, then point the children at it" in a
+     * single request, since the parent's id does not exist until the server
+     * assigns it. Only backward references resolve.
+     *
+     * `data` is aligned to `operations`: the written row for a create, upsert
+     * or update, and `null` for a delete.
+     *
+     * @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: "update", collection: "stock", id: "A-1", values: { count: { $inc: -1 } } }
+     * ]);
+     * ```
+     */
+    batch: (operations: BatchOperation<DB>[], options?: WriteOptions) => Promise<BatchResult>;
     data: TypedDataLayer<DB>;
     /** Present only when the client was created with `offline` enabled. */
     offline?: OfflineApi;