@rindle/client 0.3.1 → 0.4.3

package/src/ssr.ts

@@ -111,6 +111,27 @@ export class ServerStore<S extends ColsMap> {
   dehydrate(): DehydratedState {
     return this.store.dehydrate();
   }
+
+  /**
+   * Loader-phase convenience over {@link preload} + {@link dehydrate}: preload EVERY query (reads run
+   * concurrently) and return the dehydrated first-paint cache. Composition keeps this to one read per
+   * composed root query — no request waterfall (SSR-DESIGN.md §6.2).
+   *
+   * A failed read degrades to NO seed for that one query — `onError` fires and the browser's live
+   * engine fills it in right after hydration — rather than rejecting the whole batch (which would trip
+   * the route's error boundary). The seed is a first-paint optimization; the live `subscribe` is the
+   * source of truth, so a missing seed never affects correctness. Without `onError` a failed read is
+   * swallowed silently — pass one to log.
+   */
+  async preloadAll(
+    queries: Array<Query<any, any, any>>,
+    opts: { onError?: (query: Query<any, any, any>, err: unknown) => void } = {},
+  ): Promise<DehydratedState> {
+    await Promise.all(
+      queries.map((query) => this.preload(query).catch((err) => opts.onError?.(query, err))),
+    );
+    return this.dehydrate();
+  }
 }
 
 /** Construct a {@link ServerStore} — the one-shot REST Store for server-side rendering. */

package/src/store.ts

@@ -10,7 +10,7 @@
 import type { Ast } from "./ast.ts";
 import { stableKey } from "./key.ts";
 import { queries, type Query, type QueryRoot } from "./query.ts";
-import type { ColsMap, RowOf, Schema } from "./schema.ts";
+import type { ColsMap, InsertOf, RowOf, Schema } from "./schema.ts";
 import type { Backend, ChangeEvent, ColType, FlatChange, Mutation, QueryId, RemoteQuery, ResultType, WireSchema, WireValue } from "./types.ts";
 import { type ArrayView, FlatArrayView, type SingularArrayView, SingularView, type ViewTypes } from "./view.ts";
 
@@ -36,9 +36,13 @@ export interface AssembledNode {
 }
 
 /** The write transaction handed to `store.write(tx => …)`. Rows are objects keyed by column;
- *  the Store positionalizes them (and stringifies json columns) before the backend sees them. */
+ *  the Store positionalizes them (and stringifies json columns) before the backend sees them.
+ *
+ *  `add` takes an {@link InsertOf} row — a nullable column may be omitted (it is filled with `null`,
+ *  design 206 §7). `remove`/`edit` take a full {@link RowOf} row: they identify an EXISTING row, so
+ *  every column (nullable ones as their actual `T | null` value) must be present. */
 export interface WriteTx<S extends ColsMap> {
-  add<N extends keyof S & string>(table: N, row: RowOf<S[N]>): void;
+  add<N extends keyof S & string>(table: N, row: InsertOf<S[N]>): void;
   remove<N extends keyof S & string>(table: N, row: RowOf<S[N]>): void;
   edit<N extends keyof S & string>(table: N, oldRow: RowOf<S[N]>, newRow: RowOf<S[N]>): void;
 }