@fragno-dev/db 0.1.13 → 0.1.15

package/src/query/unit-of-work.ts

@@ -1,11 +1,19 @@
 import type { AnySchema, AnyTable, Index, IdColumn, AnyColumn, Relation } from "../schema/create";
 import { FragnoId } from "../schema/create";
 import type { Condition, ConditionBuilder } from "./condition-builder";
-import type { SelectClause, TableToInsertValues, TableToUpdateValues, SelectResult } from "./query";
+import type {
+  SelectClause,
+  TableToInsertValues,
+  TableToUpdateValues,
+  SelectResult,
+  ExtractSelect,
+  ExtractJoinOut,
+} from "./query";
 import { buildCondition } from "./condition-builder";
 import type { CompiledJoin } from "./orm/orm";
 import type { CursorResult } from "./cursor";
 import { Cursor } from "./cursor";
+import type { Prettify } from "../util/types";
 
 /**
  * Builder for updateMany operations that supports both whereIndex and set chaining
@@ -143,13 +151,18 @@ export type RetrievalOperation<
 > =
   | {
       type: "find";
+      schema: TSchema;
+      namespace?: string;
       table: TTable;
       indexName: string;
       options: FindOptions<TTable, SelectClause<TTable>>;
       withCursor?: boolean;
+      withSingleResult?: boolean;
     }
   | {
       type: "count";
+      schema: TSchema;
+      namespace?: string;
       table: TTable;
       indexName: string;
       options: Pick<FindOptions<TTable>, "where" | "useIndex">;
@@ -164,6 +177,8 @@ export type MutationOperation<
 > =
   | {
       type: "update";
+      schema: TSchema;
+      namespace?: string;
       table: TTable["name"];
       id: FragnoId | string;
       checkVersion: boolean;
@@ -171,15 +186,26 @@ export type MutationOperation<
     }
   | {
       type: "create";
+      schema: TSchema;
+      namespace?: string;
       table: TTable["name"];
       values: TableToInsertValues<TTable>;
       generatedExternalId: string;
     }
   | {
       type: "delete";
+      schema: TSchema;
+      namespace?: string;
       table: TTable["name"];
       id: FragnoId | string;
       checkVersion: boolean;
+    }
+  | {
+      type: "check";
+      schema: TSchema;
+      namespace?: string;
+      table: TTable["name"];
+      id: FragnoId;
     };
 
 /**
@@ -193,21 +219,27 @@ export interface CompiledMutation<TOutput> {
    * null means don't check affected rows (e.g., for create operations).
    */
   expectedAffectedRows: number | null;
+  /**
+   * Number of rows this SELECT query must return for the transaction to succeed.
+   * Used for check operations to verify version without modifying data.
+   * null means this is not a SELECT query that needs row count validation.
+   */
+  expectedReturnedRows: number | null;
 }
 
 /**
  * Compiler interface for Unit of Work operations
  */
-export interface UOWCompiler<TSchema extends AnySchema, TOutput> {
+export interface UOWCompiler<TOutput> {
   /**
    * Compile a retrieval operation to the adapter's query format
    */
-  compileRetrievalOperation(op: RetrievalOperation<TSchema>): TOutput | null;
+  compileRetrievalOperation(op: RetrievalOperation<AnySchema>): TOutput | null;
 
   /**
    * Compile a mutation operation to the adapter's query format
    */
-  compileMutationOperation(op: MutationOperation<TSchema>): CompiledMutation<TOutput> | null;
+  compileMutationOperation(op: MutationOperation<AnySchema>): CompiledMutation<TOutput> | null;
 }
 
 export type MutationResult =
@@ -237,7 +269,7 @@ export interface UOWExecutor<TOutput, TRawResult = unknown> {
  * Transforms raw database results into application format (e.g., converting raw columns
  * into FragnoId objects with external ID, internal ID, and version).
  */
-export interface UOWDecoder<TSchema extends AnySchema, TRawInput = unknown> {
+export interface UOWDecoder<TRawInput = unknown> {
   /**
    * Decode raw database results from the retrieval phase
    *
@@ -245,7 +277,7 @@ export interface UOWDecoder<TSchema extends AnySchema, TRawInput = unknown> {
    * @param operations - Array of retrieval operations that produced these results
    * @returns Decoded results in application format
    */
-  (rawResults: TRawInput[], operations: RetrievalOperation<TSchema>[]): unknown[];
+  (rawResults: TRawInput[], operations: RetrievalOperation<AnySchema>[]): unknown[];
 }
 
 /**
@@ -843,27 +875,259 @@ export function buildJoinIndexed<TTable extends AnyTable, TJoinOut>(
   return compiled;
 }
 
-export function createUnitOfWork<
-  const TSchema extends AnySchema,
-  const TRetrievalResults extends unknown[] = [],
-  const TRawInput = unknown,
->(
-  schema: TSchema,
-  compiler: UOWCompiler<TSchema, unknown>,
-  executor: UOWExecutor<unknown, TRawInput>,
-  decoder: UOWDecoder<TSchema, TRawInput>,
+/**
+ * Full Unit of Work interface with all operations including execution.
+ * This allows UOW instances to be passed between different contexts that use different schemas.
+ */
+export interface IUnitOfWork {
+  // Getters (schema-agnostic)
+  readonly state: UOWState;
+  readonly name: string | undefined;
+  readonly nonce: string;
+  readonly retrievalPhase: Promise<unknown[]>;
+  readonly mutationPhase: Promise<void>;
+
+  // Execution (schema-agnostic)
+  executeRetrieve(): Promise<unknown[]>;
+  executeMutations(): Promise<{ success: boolean }>;
+
+  // Inspection (schema-agnostic)
+  getRetrievalOperations(): ReadonlyArray<RetrievalOperation<AnySchema>>;
+  getMutationOperations(): ReadonlyArray<MutationOperation<AnySchema>>;
+  getCreatedIds(): FragnoId[];
+
+  // Parent-child relationships
+  restrict(): IUnitOfWork;
+
+  // Reset for retry support
+  reset(): void;
+
+  // Schema-specific view (for cross-schema operations)
+  forSchema<TOtherSchema extends AnySchema>(
+    schema: TOtherSchema,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ): TypedUnitOfWork<TOtherSchema, [], any>;
+}
+
+/**
+ * Restricted UOW interface without execute methods.
+ * Useful when you want to allow building operations but not executing them,
+ * to prevent deadlocks or enforce execution control at a higher level.
+ *
+ * Note: This is just a marker interface. Restriction is enforced by the UnitOfWork class itself.
+ */
+export interface IUnitOfWorkRestricted
+  extends Omit<IUnitOfWork, "executeRetrieve" | "executeMutations"> {}
+
+export function createUnitOfWork(
+  compiler: UOWCompiler<unknown>,
+  executor: UOWExecutor<unknown, unknown>,
+  decoder: UOWDecoder<unknown>,
+  schemaNamespaceMap?: WeakMap<AnySchema, string>,
   name?: string,
-): UnitOfWork<TSchema, TRetrievalResults, TRawInput> {
-  return new UnitOfWork(schema, compiler, executor, decoder, name) as UnitOfWork<
-    TSchema,
-    TRetrievalResults,
-    TRawInput
-  >;
+): UnitOfWork {
+  return new UnitOfWork(compiler, executor, decoder, name, undefined, schemaNamespaceMap);
 }
 
 export interface UnitOfWorkConfig {
   dryRun?: boolean;
   onQuery?: (query: unknown) => void;
+  nonce?: string;
+}
+
+/**
+ * Encapsulates a promise with its resolver/rejecter functions.
+ * Simplifies management of deferred promises with built-in error handling.
+ */
+class DeferredPromise<T> {
+  #resolve?: (value: T) => void;
+  #reject?: (error: Error) => void;
+  #promise: Promise<T>;
+
+  constructor() {
+    const { promise, resolve, reject } = Promise.withResolvers<T>();
+    this.#promise = promise;
+    this.#resolve = resolve;
+    this.#reject = reject;
+    // Attach no-op error handler to prevent unhandled rejection warnings
+    this.#promise.catch(() => {});
+  }
+
+  get promise(): Promise<T> {
+    return this.#promise;
+  }
+
+  resolve(value: T): void {
+    this.#resolve?.(value);
+  }
+
+  reject(error: Error): void {
+    this.#reject?.(error);
+  }
+
+  /**
+   * Reset to a new promise
+   */
+  reset(): void {
+    const { promise, resolve, reject } = Promise.withResolvers<T>();
+    this.#promise = promise;
+    this.#resolve = resolve;
+    this.#reject = reject;
+    // Attach no-op error handler to prevent unhandled rejection warnings
+    this.#promise.catch(() => {});
+  }
+}
+
+/**
+ * Tracks readiness signals from a group of children.
+ * Maintains a promise that resolves when all registered children have signaled.
+ */
+class ReadinessTracker {
+  #expectedCount = 0;
+  #signalCount = 0;
+  #resolve?: () => void;
+  #promise: Promise<void> = Promise.resolve();
+
+  get promise(): Promise<void> {
+    return this.#promise;
+  }
+
+  /**
+   * Register that we're expecting a signal from a child
+   */
+  registerChild(): void {
+    if (this.#expectedCount === 0) {
+      // First child - create new promise
+      const { promise, resolve } = Promise.withResolvers<void>();
+      this.#promise = promise;
+      this.#resolve = resolve;
+    }
+    this.#expectedCount++;
+  }
+
+  /**
+   * Signal that one child is ready
+   */
+  signal(): void {
+    this.#signalCount++;
+    if (this.#signalCount >= this.#expectedCount && this.#resolve) {
+      this.#resolve();
+    }
+  }
+
+  /**
+   * Reset to initial state
+   */
+  reset(): void {
+    this.#expectedCount = 0;
+    this.#signalCount = 0;
+    this.#resolve = undefined;
+    this.#promise = Promise.resolve();
+  }
+}
+
+/**
+ * Manages parent-child relationships and readiness coordination for Unit of Work instances.
+ * This allows parent UOWs to wait for all child UOWs to signal readiness before executing phases.
+ */
+class UOWChildCoordinator<TRawInput> {
+  #parent: UnitOfWork<TRawInput> | null = null;
+  #parentCoordinator: UOWChildCoordinator<TRawInput> | null = null;
+  #children: Set<UnitOfWork<TRawInput>> = new Set();
+  #isRestricted = false;
+
+  #retrievalTracker = new ReadinessTracker();
+  #mutationTracker = new ReadinessTracker();
+
+  get isRestricted(): boolean {
+    return this.#isRestricted;
+  }
+
+  get parent(): UnitOfWork<TRawInput> | null {
+    return this.#parent;
+  }
+
+  get children(): ReadonlySet<UnitOfWork<TRawInput>> {
+    return this.#children;
+  }
+
+  get retrievalReadinessPromise(): Promise<void> {
+    return this.#retrievalTracker.promise;
+  }
+
+  get mutationReadinessPromise(): Promise<void> {
+    return this.#mutationTracker.promise;
+  }
+
+  /**
+   * Mark this UOW as a restricted child of the given parent
+   */
+  setAsRestricted(
+    parent: UnitOfWork<TRawInput>,
+    parentCoordinator: UOWChildCoordinator<TRawInput>,
+  ): void {
+    this.#parent = parent;
+    this.#parentCoordinator = parentCoordinator;
+    this.#isRestricted = true;
+  }
+
+  /**
+   * Register a child UOW
+   */
+  addChild(child: UnitOfWork<TRawInput>): void {
+    this.#children.add(child);
+    this.#retrievalTracker.registerChild();
+    this.#mutationTracker.registerChild();
+  }
+
+  /**
+   * Signal that this child is ready for retrieval phase execution.
+   * Only valid for restricted (child) UOWs.
+   */
+  signalReadyForRetrieval(): void {
+    if (!this.#parentCoordinator) {
+      throw new Error("signalReadyForRetrieval() can only be called on restricted child UOWs");
+    }
+
+    this.#parentCoordinator.notifyChildReadyForRetrieval();
+  }
+
+  /**
+   * Signal that this child is ready for mutation phase execution.
+   * Only valid for restricted (child) UOWs.
+   */
+  signalReadyForMutation(): void {
+    if (!this.#parentCoordinator) {
+      throw new Error("signalReadyForMutation() can only be called on restricted child UOWs");
+    }
+
+    this.#parentCoordinator.notifyChildReadyForMutation();
+  }
+
+  /**
+   * Notify this coordinator that a child is ready for retrieval (internal use).
+   * Called by child UOWs when they signal readiness.
+   */
+  notifyChildReadyForRetrieval(): void {
+    this.#retrievalTracker.signal();
+  }
+
+  /**
+   * Notify this coordinator that a child is ready for mutation (internal use).
+   * Called by child UOWs when they signal readiness.
+   */
+  notifyChildReadyForMutation(): void {
+    this.#mutationTracker.signal();
+  }
+
+  /**
+   * Reset coordination state for retry support
+   */
+  reset(): void {
+    this.#children.clear();
+    this.#retrievalTracker.reset();
+    this.#mutationTracker.reset();
+  }
 }
 
 /**
@@ -873,19 +1137,22 @@ export interface UnitOfWorkConfig {
  * 1. Retrieval phase: Read operations to fetch entities with their versions
  * 2. Mutation phase: Write operations that check versions before committing
  *
+ * This is the untyped base storage. Use TypedUnitOfWork for type-safe operations.
+ *
  * @example
  * ```ts
  * const uow = queryEngine.createUnitOfWork("update-user-balance");
+ * const typedUow = uow.forSchema(mySchema);
  *
  * // Retrieval phase
- * uow.find("users", (b) => b.where("primary", (eb) => eb("id", "=", userId)));
+ * typedUow.find("users", (b) => b.whereIndex("primary", (eb) => eb("id", "=", userId)));
  *
  * // Execute retrieval and transition to mutation phase
  * const [users] = await uow.executeRetrieve();
  *
  * // Mutation phase with version check
  * const user = users[0];
- * uow.update("users", user.id, (b) => b.set({ balance: newBalance }).check());
+ * typedUow.update("users", user.id, (b) => b.set({ balance: newBalance }).check());
  *
  * // Execute mutations
  * const { success } = await uow.executeMutations();
@@ -894,46 +1161,146 @@ export interface UnitOfWorkConfig {
  * }
  * ```
  */
-export class UnitOfWork<
-  const TSchema extends AnySchema,
-  const TRetrievalResults extends unknown[] = [],
-  const TRawInput = unknown,
-> {
-  #schema: TSchema;
-
+export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
   #name?: string;
   #config?: UnitOfWorkConfig;
+  #nonce: string;
 
   #state: UOWState = "building-retrieval";
 
-  #retrievalOps: RetrievalOperation<TSchema>[] = [];
-  #mutationOps: MutationOperation<TSchema>[] = [];
+  // Operations can come from any schema
+  #retrievalOps: RetrievalOperation<AnySchema>[] = [];
+  #mutationOps: MutationOperation<AnySchema>[] = [];
 
-  #compiler: UOWCompiler<TSchema, unknown>;
+  #compiler: UOWCompiler<unknown>;
   #executor: UOWExecutor<unknown, TRawInput>;
-  #decoder: UOWDecoder<TSchema, TRawInput>;
+  #decoder: UOWDecoder<TRawInput>;
+  #schemaNamespaceMap?: WeakMap<AnySchema, string>;
 
-  #retrievalResults?: TRetrievalResults;
+  #retrievalResults?: unknown[];
   #createdInternalIds: (bigint | null)[] = [];
 
+  // Phase coordination promises
+  #retrievalPhaseDeferred = new DeferredPromise<unknown[]>();
+  #mutationPhaseDeferred = new DeferredPromise<void>();
+
+  // Error tracking
+  #retrievalError: Error | null = null;
+  #mutationError: Error | null = null;
+
+  // Child coordination
+  #coordinator: UOWChildCoordinator<TRawInput> = new UOWChildCoordinator();
+
   constructor(
-    schema: TSchema,
-    compiler: UOWCompiler<TSchema, unknown>,
+    compiler: UOWCompiler<unknown>,
     executor: UOWExecutor<unknown, TRawInput>,
-    decoder: UOWDecoder<TSchema, TRawInput>,
+    decoder: UOWDecoder<TRawInput>,
     name?: string,
     config?: UnitOfWorkConfig,
+    schemaNamespaceMap?: WeakMap<AnySchema, string>,
   ) {
-    this.#schema = schema;
     this.#compiler = compiler;
     this.#executor = executor;
     this.#decoder = decoder;
+    this.#schemaNamespaceMap = schemaNamespaceMap;
     this.#name = name;
     this.#config = config;
+    this.#nonce = config?.nonce ?? crypto.randomUUID();
   }
 
-  get schema(): TSchema {
-    return this.#schema;
+  /**
+   * Get a schema-specific typed view of this UOW for type-safe operations.
+   * Returns a wrapper that provides typed operations for the given schema.
+   * The namespace is automatically resolved from the schema-namespace map.
+   */
+  forSchema<TOtherSchema extends AnySchema, TRawInput>(
+    schema: TOtherSchema,
+  ): TypedUnitOfWork<TOtherSchema, [], TRawInput> {
+    // Look up namespace from map
+    const resolvedNamespace = this.#schemaNamespaceMap?.get(schema);
+
+    return new TypedUnitOfWork(schema, resolvedNamespace, this as unknown as UnitOfWork<TRawInput>);
+  }
+
+  /**
+   * Create a restricted child UOW that cannot execute phases.
+   * The child shares the same operation storage but must signal readiness
+   * before the parent can execute each phase.
+   */
+  restrict(): UnitOfWork<TRawInput> {
+    const child = new UnitOfWork(
+      this.#compiler,
+      this.#executor,
+      this.#decoder,
+      this.#name,
+      { ...this.#config, nonce: this.#nonce },
+      this.#schemaNamespaceMap,
+    );
+    child.#coordinator.setAsRestricted(this, this.#coordinator);
+
+    // Share state with parent
+    child.#state = this.#state;
+    child.#retrievalOps = this.#retrievalOps;
+    child.#mutationOps = this.#mutationOps;
+    child.#retrievalResults = this.#retrievalResults;
+    child.#createdInternalIds = this.#createdInternalIds;
+    child.#retrievalPhaseDeferred = this.#retrievalPhaseDeferred;
+    child.#mutationPhaseDeferred = this.#mutationPhaseDeferred;
+    child.#retrievalError = this.#retrievalError;
+    child.#mutationError = this.#mutationError;
+
+    this.#coordinator.addChild(child);
+
+    // For synchronous usage (the common case), immediately signal readiness
+    // This allows services called directly from handlers to work without explicit signaling
+    child.signalReadyForRetrieval();
+    child.signalReadyForMutation();
+
+    return child;
+  }
+
+  /**
+   * Signal that this child is ready for retrieval phase execution.
+   * Only valid for restricted (child) UOWs.
+   */
+  signalReadyForRetrieval(): void {
+    this.#coordinator.signalReadyForRetrieval();
+  }
+
+  /**
+   * Signal that this child is ready for mutation phase execution.
+   * Only valid for restricted (child) UOWs.
+   */
+  signalReadyForMutation(): void {
+    this.#coordinator.signalReadyForMutation();
+  }
+
+  /**
+   * Reset the UOW to initial state for retry support.
+   * Clears operations, resets state, and resets phase promises.
+   */
+  reset(): void {
+    if (this.#coordinator.isRestricted) {
+      throw new Error("reset() cannot be called on restricted child UOWs");
+    }
+
+    // Clear operations
+    this.#retrievalOps = [];
+    this.#mutationOps = [];
+    this.#retrievalResults = undefined;
+    this.#createdInternalIds = [];
+
+    // Reset state
+    this.#state = "building-retrieval";
+    this.#retrievalError = null;
+    this.#mutationError = null;
+
+    // Reset phase promises
+    this.#retrievalPhaseDeferred.reset();
+    this.#mutationPhaseDeferred.reset();
+
+    // Reset child coordination
+    this.#coordinator.reset();
   }
 
   get state(): UOWState {
@@ -944,13 +1311,33 @@ export class UnitOfWork<
     return this.#name;
   }
 
+  get nonce(): string {
+    return this.#nonce;
+  }
+
+  /**
+   * Promise that resolves when the retrieval phase is executed
+   * Service methods can await this to coordinate multi-phase logic
+   */
+  get retrievalPhase(): Promise<unknown[]> {
+    return this.#retrievalPhaseDeferred.promise;
+  }
+
+  /**
+   * Promise that resolves when the mutation phase is executed
+   * Service methods can await this to coordinate multi-phase logic
+   */
+  get mutationPhase(): Promise<void> {
+    return this.#mutationPhaseDeferred.promise;
+  }
+
   /**
    * Execute the retrieval phase and transition to mutation phase
    * Returns all results from find operations
    */
-  async executeRetrieve(): Promise<TRetrievalResults> {
-    if (this.#retrievalOps.length === 0) {
-      return [] as unknown as TRetrievalResults;
+  async executeRetrieve(): Promise<unknown[]> {
+    if (this.#coordinator.isRestricted) {
+      throw new Error("executeRetrieve() cannot be called on restricted child UOWs");
     }
 
     if (this.#state !== "building-retrieval") {
@@ -959,169 +1346,529 @@ export class UnitOfWork<
       );
     }
 
-    // Compile retrieval operations
-    const retrievalBatch: unknown[] = [];
-    for (const op of this.#retrievalOps) {
-      const compiled = this.#compiler.compileRetrievalOperation(op);
-      if (compiled !== null) {
-        this.#config?.onQuery?.(compiled);
+    try {
+      // Wait for all children to signal readiness
+      await this.#coordinator.retrievalReadinessPromise;
 
-        retrievalBatch.push(compiled);
+      if (this.#retrievalOps.length === 0) {
+        this.#state = "building-mutation";
+        const emptyResults: unknown[] = [];
+        this.#retrievalPhaseDeferred.resolve(emptyResults);
+        return emptyResults;
       }
-    }
 
-    if (this.#config?.dryRun) {
-      this.#state = "executed";
-      return [] as unknown as TRetrievalResults;
-    }
+      // Compile retrieval operations using single compiler
+      const retrievalBatch: unknown[] = [];
+      for (const op of this.#retrievalOps) {
+        const compiled = this.#compiler.compileRetrievalOperation(op);
+        if (compiled !== null) {
+          this.#config?.onQuery?.(compiled);
+          retrievalBatch.push(compiled);
+        }
+      }
 
-    const results = this.#decoder(
-      await this.#executor.executeRetrievalPhase(retrievalBatch),
-      this.#retrievalOps,
-    );
+      if (this.#config?.dryRun) {
+        this.#state = "executed";
+        const emptyResults: unknown[] = [];
+        this.#retrievalPhaseDeferred.resolve(emptyResults);
+        return emptyResults;
+      }
 
-    // Store results and transition to mutation phase
-    this.#retrievalResults = results as TRetrievalResults;
-    this.#state = "building-mutation";
+      const rawResults = await this.#executor.executeRetrievalPhase(retrievalBatch);
 
-    return this.#retrievalResults;
+      const results = this.#decoder(rawResults, this.#retrievalOps);
+
+      // Store results and transition to mutation phase
+      this.#retrievalResults = results;
+      this.#state = "building-mutation";
+
+      this.#retrievalPhaseDeferred.resolve(this.#retrievalResults);
+
+      return this.#retrievalResults;
+    } catch (error) {
+      this.#retrievalError = error instanceof Error ? error : new Error(String(error));
+      throw error;
+    }
   }
 
   /**
-   * Add a find operation using a builder callback (retrieval phase only)
+   * Execute the mutation phase
+   * Returns success flag indicating if mutations completed without conflicts
    */
-  find<
-    TTableName extends keyof TSchema["tables"] & string,
-    TSelect extends SelectClause<TSchema["tables"][TTableName]> = true,
-    TJoinOut = {},
-  >(
-    tableName: TTableName,
-    builderFn?: (
-      // We omit "build" because we don't want to expose it to the user
-      builder: Omit<FindBuilder<TSchema["tables"][TTableName]>, "build">,
-    ) => Omit<FindBuilder<TSchema["tables"][TTableName], TSelect, TJoinOut>, "build"> | void,
-  ): UnitOfWork<
-    TSchema,
-    [...TRetrievalResults, SelectResult<TSchema["tables"][TTableName], TJoinOut, TSelect>[]],
-    TRawInput
-  > {
-    if (this.#state !== "building-retrieval") {
-      throw new Error(
-        `find() can only be called during retrieval phase. Current state: ${this.#state}`,
-      );
+  async executeMutations(): Promise<{ success: boolean }> {
+    if (this.#coordinator.isRestricted) {
+      throw new Error("executeMutations() cannot be called on restricted child UOWs");
     }
 
-    const table = this.#schema.tables[tableName];
-    if (!table) {
-      throw new Error(`Table ${tableName} not found in schema`);
+    if (this.#state === "executed") {
+      throw new Error(`Cannot execute mutations from state ${this.#state}.`);
     }
 
-    // Create builder, pass to callback (or use default), then extract configuration
-    const builder = new FindBuilder(tableName, table as TSchema["tables"][TTableName]);
-    if (builderFn) {
-      builderFn(builder);
-    } else {
-      // Default to primary index with no filter
-      builder.whereIndex("primary");
+    try {
+      // Wait for all children to signal readiness
+      await this.#coordinator.mutationReadinessPromise;
+
+      // Compile mutation operations using single compiler
+      const mutationBatch: CompiledMutation<unknown>[] = [];
+      for (const op of this.#mutationOps) {
+        const compiled = this.#compiler.compileMutationOperation(op);
+        if (compiled !== null) {
+          this.#config?.onQuery?.(compiled);
+          mutationBatch.push(compiled);
+        }
+      }
+
+      if (this.#config?.dryRun) {
+        this.#state = "executed";
+        this.#mutationPhaseDeferred.resolve();
+        return {
+          success: true,
+        };
+      }
+
+      // Execute mutation phase
+      const result = await this.#executor.executeMutationPhase(mutationBatch);
+      this.#state = "executed";
+
+      if (result.success) {
+        this.#createdInternalIds = result.createdInternalIds;
+      }
+
+      // Resolve the mutation phase promise to unblock waiting service methods
+      this.#mutationPhaseDeferred.resolve();
+
+      return {
+        success: result.success,
+      };
+    } catch (error) {
+      this.#mutationError = error instanceof Error ? error : new Error(String(error));
+      throw error;
     }
-    const { indexName, options, type } = builder.build();
+  }
 
-    this.#retrievalOps.push({
-      type,
-      // Safe: we know the table is part of the schema from the find() method
-      table: table as TSchema["tables"][TTableName],
-      indexName,
-      // Safe: we're storing the options for later compilation
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      options: options as any,
-    });
+  /**
+   * Get the retrieval operations (for inspection/debugging)
+   */
+  getRetrievalOperations(): ReadonlyArray<RetrievalOperation<AnySchema>> {
+    return this.#retrievalOps;
+  }
 
-    return this as unknown as UnitOfWork<
-      TSchema,
-      [...TRetrievalResults, SelectResult<TSchema["tables"][TTableName], TJoinOut, TSelect>[]],
-      TRawInput
-    >;
+  /**
+   * Get the mutation operations (for inspection/debugging)
+   */
+  getMutationOperations(): ReadonlyArray<MutationOperation<AnySchema>> {
+    return this.#mutationOps;
   }
 
   /**
-   * Add a find operation with cursor metadata (retrieval phase only)
+   * @internal
+   * Add a retrieval operation (used by TypedUnitOfWork)
    */
-  findWithCursor<
-    TTableName extends keyof TSchema["tables"] & string,
-    TSelect extends SelectClause<TSchema["tables"][TTableName]> = true,
-    TJoinOut = {},
-  >(
-    tableName: TTableName,
-    builderFn: (
-      // We omit "build" because we don't want to expose it to the user
-      builder: Omit<FindBuilder<TSchema["tables"][TTableName]>, "build">,
-    ) => Omit<FindBuilder<TSchema["tables"][TTableName], TSelect, TJoinOut>, "build"> | void,
-  ): UnitOfWork<
-    TSchema,
-    [
-      ...TRetrievalResults,
-      CursorResult<SelectResult<TSchema["tables"][TTableName], TJoinOut, TSelect>>,
-    ],
-    TRawInput
-  > {
+  addRetrievalOperation(op: RetrievalOperation<AnySchema>): number {
     if (this.#state !== "building-retrieval") {
       throw new Error(
-        `findWithCursor() can only be called during retrieval phase. Current state: ${this.#state}`,
+        `Cannot add retrieval operation in state ${this.#state}. Must be in building-retrieval state.`,
       );
     }
-
-    const table = this.#schema.tables[tableName];
-    if (!table) {
-      throw new Error(`Table ${tableName} not found in schema`);
-    }
-
-    // Create builder and pass to callback
-    const builder = new FindBuilder(tableName, table as TSchema["tables"][TTableName]);
-    builderFn(builder);
-    const { indexName, options, type } = builder.build();
-
-    this.#retrievalOps.push({
-      type,
-      // Safe: we know the table is part of the schema from the findWithCursor() method
-      table: table as TSchema["tables"][TTableName],
-      indexName,
-      // Safe: we're storing the options for later compilation
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      options: options as any,
-      withCursor: true,
-    });
-
-    return this as unknown as UnitOfWork<
-      TSchema,
-      [
-        ...TRetrievalResults,
-        CursorResult<SelectResult<TSchema["tables"][TTableName], TJoinOut, TSelect>>,
-      ],
-      TRawInput
-    >;
+    this.#retrievalOps.push(op);
+    return this.#retrievalOps.length - 1;
   }
 
   /**
-   * Add a create operation (mutation phase only)
-   * Returns a FragnoId with the external ID that can be used immediately in subsequent operations
+   * @internal
+   * Add a mutation operation (used by TypedUnitOfWork)
    */
-  create<TableName extends keyof TSchema["tables"] & string>(
-    table: TableName,
-    values: TableToInsertValues<TSchema["tables"][TableName]>,
-  ): FragnoId {
+  addMutationOperation(op: MutationOperation<AnySchema>): void {
     if (this.#state === "executed") {
-      throw new Error(`create() can only be called during mutation phase.`);
+      throw new Error(`Cannot add mutation operation in executed state.`);
     }
+    this.#mutationOps.push(op);
+  }
+
+  /**
+   * Get the IDs of created entities after executeMutations() has been called.
+   * Returns FragnoId objects with external IDs (always available) and internal IDs
+   * (available when database supports RETURNING).
+   *
+   * @throws Error if called before executeMutations()
+   * @returns Array of FragnoIds in the same order as create() calls
+   */
+  getCreatedIds(): FragnoId[] {
+    if (this.#state !== "executed") {
+      throw new Error(
+        `getCreatedIds() can only be called after executeMutations(). Current state: ${this.#state}`,
+      );
+    }
+
+    const createdIds: FragnoId[] = [];
+    let createIndex = 0;
+
+    for (const op of this.#mutationOps) {
+      if (op.type === "create") {
+        const internalId = this.#createdInternalIds[createIndex] ?? undefined;
+        createdIds.push(
+          new FragnoId({
+            externalId: op.generatedExternalId,
+            internalId,
+            version: 0, // New records always start at version 0
+          }),
+        );
+        createIndex++;
+      }
+    }
+
+    return createdIds;
+  }
+
+  /**
+   * @internal
+   * Compile the unit of work to executable queries for testing
+   */
+  compile<TOutput>(compiler: UOWCompiler<TOutput>): {
+    name?: string;
+    retrievalBatch: TOutput[];
+    mutationBatch: CompiledMutation<TOutput>[];
+  } {
+    const retrievalBatch: TOutput[] = [];
+    for (const op of this.#retrievalOps) {
+      const compiled = compiler.compileRetrievalOperation(op);
+      if (compiled !== null) {
+        retrievalBatch.push(compiled);
+      }
+    }
+
+    const mutationBatch: CompiledMutation<TOutput>[] = [];
+    for (const op of this.#mutationOps) {
+      const compiled = compiler.compileMutationOperation(op);
+      if (compiled !== null) {
+        mutationBatch.push(compiled);
+      }
+    }
+
+    return {
+      name: this.#name,
+      retrievalBatch,
+      mutationBatch,
+    };
+  }
+}
+
+/**
+ * A typed facade around a UnitOfWork that provides type-safe operations for a specific schema.
+ * All operations are stored in the underlying UOW, but this facade ensures type safety and
+ * filters retrieval results to only include operations added through this facade.
+ */
+export class TypedUnitOfWork<
+  const TSchema extends AnySchema,
+  const TRetrievalResults extends unknown[] = [],
+  const TRawInput = unknown,
+> implements IUnitOfWork
+{
+  #schema: TSchema;
+  #namespace?: string;
+  #uow: UnitOfWork<TRawInput>;
+  #operationIndices: number[] = [];
+  #cachedRetrievalPhase?: Promise<TRetrievalResults>;
+
+  constructor(schema: TSchema, namespace: string | undefined, uow: UnitOfWork<TRawInput>) {
+    this.#schema = schema;
+    this.#namespace = namespace;
+    this.#uow = uow;
+  }
+
+  get $results(): Prettify<TRetrievalResults> {
+    throw new Error("type only");
+  }
+
+  get schema(): TSchema {
+    return this.#schema;
+  }
+
+  get name(): string | undefined {
+    return this.#uow.name;
+  }
+
+  get nonce(): string {
+    return this.#uow.nonce;
+  }
+
+  get state() {
+    return this.#uow.state;
+  }
+
+  get retrievalPhase(): Promise<TRetrievalResults> {
+    // Cache the filtered promise to avoid recreating it on every access
+    if (!this.#cachedRetrievalPhase) {
+      this.#cachedRetrievalPhase = this.#uow.retrievalPhase.then((allResults) => {
+        const allOperations = this.#uow.getRetrievalOperations();
+        const filteredResults = this.#operationIndices.map((opIndex) => {
+          const result = allResults[opIndex];
+          const operation = allOperations[opIndex];
+          // Transform array to single item for findFirst operations
+          if (operation?.type === "find" && operation.withSingleResult) {
+            return Array.isArray(result) ? (result[0] ?? null) : result;
+          }
+          return result;
+        });
+        return filteredResults as TRetrievalResults;
+      });
+    }
+    return this.#cachedRetrievalPhase;
+  }
+
+  get mutationPhase(): Promise<void> {
+    return this.#uow.mutationPhase;
+  }
+
+  getRetrievalOperations() {
+    return this.#uow.getRetrievalOperations();
+  }
+
+  getMutationOperations() {
+    return this.#uow.getMutationOperations();
+  }
+
+  getCreatedIds() {
+    return this.#uow.getCreatedIds();
+  }
+
+  async executeRetrieve(): Promise<TRetrievalResults> {
+    return this.#uow.executeRetrieve() as Promise<TRetrievalResults>;
+  }
+
+  async executeMutations(): Promise<{ success: boolean }> {
+    return this.#uow.executeMutations();
+  }
+
+  restrict(): IUnitOfWork {
+    return this.#uow.restrict();
+  }
+
+  reset(): void {
+    return this.#uow.reset();
+  }
+
+  forSchema<TOtherSchema extends AnySchema>(
+    schema: TOtherSchema,
+  ): TypedUnitOfWork<TOtherSchema, [], TRawInput> {
+    return this.#uow.forSchema(schema);
+  }
+
+  compile<TOutput>(compiler: UOWCompiler<TOutput>): {
+    name?: string;
+    retrievalBatch: TOutput[];
+    mutationBatch: CompiledMutation<TOutput>[];
+  } {
+    return this.#uow.compile(compiler);
+  }
+
+  find<TTableName extends keyof TSchema["tables"] & string, const TBuilderResult>(
+    tableName: TTableName,
+    builderFn: (
+      builder: Omit<FindBuilder<TSchema["tables"][TTableName]>, "build">,
+    ) => TBuilderResult,
+  ): TypedUnitOfWork<
+    TSchema,
+    [
+      ...TRetrievalResults,
+      SelectResult<
+        TSchema["tables"][TTableName],
+        ExtractJoinOut<TBuilderResult>,
+        Extract<ExtractSelect<TBuilderResult>, SelectClause<TSchema["tables"][TTableName]>>
+      >[],
+    ],
+    TRawInput
+  >;
+  find<TTableName extends keyof TSchema["tables"] & string>(
+    tableName: TTableName,
+  ): TypedUnitOfWork<
+    TSchema,
+    [...TRetrievalResults, SelectResult<TSchema["tables"][TTableName], {}, true>[]],
+    TRawInput
+  >;
+  find<TTableName extends keyof TSchema["tables"] & string, const TBuilderResult>(
+    tableName: TTableName,
+    builderFn?: (
+      builder: Omit<FindBuilder<TSchema["tables"][TTableName]>, "build">,
+    ) => TBuilderResult,
+  ): TypedUnitOfWork<
+    TSchema,
+    [
+      ...TRetrievalResults,
+      SelectResult<
+        TSchema["tables"][TTableName],
+        ExtractJoinOut<TBuilderResult>,
+        Extract<ExtractSelect<TBuilderResult>, SelectClause<TSchema["tables"][TTableName]>>
+      >[],
+    ],
+    TRawInput
+  > {
+    const table = this.#schema.tables[tableName];
+    if (!table) {
+      throw new Error(`Table ${tableName} not found in schema`);
+    }
+
+    const builder = new FindBuilder(tableName, table as TSchema["tables"][TTableName]);
+    if (builderFn) {
+      builderFn(builder);
+    } else {
+      builder.whereIndex("primary");
+    }
+    const { indexName, options, type } = builder.build();
+
+    const operationIndex = this.#uow.addRetrievalOperation({
+      type,
+      schema: this.#schema,
+      namespace: this.#namespace,
+      table: table as TSchema["tables"][TTableName],
+      indexName,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      options: options as any,
+    });
+
+    // Track which operation index belongs to this view
+    this.#operationIndices.push(operationIndex);
+
+    // Safe: return type is correctly specified in the method signature
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return this as any;
+  }
+
+  findFirst<TTableName extends keyof TSchema["tables"] & string, const TBuilderResult>(
+    tableName: TTableName,
+    builderFn: (
+      builder: Omit<FindBuilder<TSchema["tables"][TTableName]>, "build">,
+    ) => TBuilderResult,
+  ): TypedUnitOfWork<
+    TSchema,
+    [
+      ...TRetrievalResults,
+      SelectResult<
+        TSchema["tables"][TTableName],
+        ExtractJoinOut<TBuilderResult>,
+        Extract<ExtractSelect<TBuilderResult>, SelectClause<TSchema["tables"][TTableName]>>
+      > | null,
+    ],
+    TRawInput
+  >;
+  findFirst<TTableName extends keyof TSchema["tables"] & string>(
+    tableName: TTableName,
+  ): TypedUnitOfWork<
+    TSchema,
+    [...TRetrievalResults, SelectResult<TSchema["tables"][TTableName], {}, true> | null],
+    TRawInput
+  >;
+  findFirst<TTableName extends keyof TSchema["tables"] & string, const TBuilderResult>(
+    tableName: TTableName,
+    builderFn?: (
+      builder: Omit<FindBuilder<TSchema["tables"][TTableName]>, "build">,
+    ) => TBuilderResult,
+  ): TypedUnitOfWork<
+    TSchema,
+    [
+      ...TRetrievalResults,
+      SelectResult<
+        TSchema["tables"][TTableName],
+        ExtractJoinOut<TBuilderResult>,
+        Extract<ExtractSelect<TBuilderResult>, SelectClause<TSchema["tables"][TTableName]>>
+      > | null,
+    ],
+    TRawInput
+  > {
+    const table = this.#schema.tables[tableName];
+    if (!table) {
+      throw new Error(`Table ${tableName} not found in schema`);
+    }
+
+    const builder = new FindBuilder(tableName, table as TSchema["tables"][TTableName]);
+    if (builderFn) {
+      builderFn(builder);
+    } else {
+      builder.whereIndex("primary");
+    }
+    // Automatically set pageSize to 1 for findFirst
+    builder.pageSize(1);
+    const { indexName, options, type } = builder.build();
+
+    const operationIndex = this.#uow.addRetrievalOperation({
+      type,
+      schema: this.#schema,
+      namespace: this.#namespace,
+      table: table as TSchema["tables"][TTableName],
+      indexName,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      options: options as any,
+      withSingleResult: true,
+    });
+
+    // Track which operation index belongs to this view
+    this.#operationIndices.push(operationIndex);
+
+    // Safe: return type is correctly specified in the method signature
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return this as any;
+  }
+
+  findWithCursor<TTableName extends keyof TSchema["tables"] & string, const TBuilderResult>(
+    tableName: TTableName,
+    builderFn: (
+      builder: Omit<FindBuilder<TSchema["tables"][TTableName]>, "build">,
+    ) => TBuilderResult,
+  ): TypedUnitOfWork<
+    TSchema,
+    [
+      ...TRetrievalResults,
+      CursorResult<
+        SelectResult<
+          TSchema["tables"][TTableName],
+          ExtractJoinOut<TBuilderResult>,
+          Extract<ExtractSelect<TBuilderResult>, SelectClause<TSchema["tables"][TTableName]>>
+        >
+      >,
+    ],
+    TRawInput
+  > {
+    const table = this.#schema.tables[tableName];
+    if (!table) {
+      throw new Error(`Table ${tableName} not found in schema`);
+    }
+
+    const builder = new FindBuilder(tableName, table as TSchema["tables"][TTableName]);
+    builderFn(builder);
+    const { indexName, options, type } = builder.build();
+
+    const operationIndex = this.#uow.addRetrievalOperation({
+      type,
+      schema: this.#schema,
+      namespace: this.#namespace,
+      table: table as TSchema["tables"][TTableName],
+      indexName,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      options: options as any,
+      withCursor: true,
+    });
+
+    // Track which operation index belongs to this view
+    this.#operationIndices.push(operationIndex);
+
+    // Safe: return type is correctly specified in the method signature
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return this as any;
+  }
+
+  create<TableName extends keyof TSchema["tables"] & string>(
+    tableName: TableName,
+    values: TableToInsertValues<TSchema["tables"][TableName]>,
+  ): FragnoId {
+    const tableSchema = this.#schema.tables[tableName];
+    if (!tableSchema) {
+      throw new Error(`Table ${tableName} not found in schema`);
+    }
+
+    const idColumn = tableSchema.getIdColumn();
+    let externalId: string;
+    let updatedValues = values;
 
-    const tableSchema = this.#schema.tables[table];
-    if (!tableSchema) {
-      throw new Error(`Table ${table} not found in schema`);
-    }
-
-    const idColumn = tableSchema.getIdColumn();
-    let externalId: string;
-    let updatedValues = values;
-
     // Check if ID value is provided in values
     const providedIdValue = (values as Record<string, unknown>)[idColumn.ormName];
 
@@ -1153,9 +1900,11 @@ export class UnitOfWork<
       } as TableToInsertValues<TSchema["tables"][TableName]>;
     }
 
-    this.#mutationOps.push({
+    this.#uow.addMutationOperation({
       type: "create",
-      table,
+      schema: this.#schema,
+      namespace: this.#namespace,
+      table: tableName,
       values: updatedValues,
       generatedExternalId: externalId,
     });
@@ -1163,180 +1912,73 @@ export class UnitOfWork<
     return FragnoId.fromExternal(externalId, 0);
   }
 
-  /**
-   * Add an update operation using a builder callback (mutation phase only)
-   */
   update<TableName extends keyof TSchema["tables"] & string>(
-    table: TableName,
+    tableName: TableName,
     id: FragnoId | string,
     builderFn: (
-      // We omit "build" because we don't want to expose it to the user
       builder: Omit<UpdateBuilder<TSchema["tables"][TableName]>, "build">,
     ) => Omit<UpdateBuilder<TSchema["tables"][TableName]>, "build"> | void,
   ): void {
-    if (this.#state === "executed") {
-      throw new Error(`update() can only be called during mutation phase.`);
-    }
-
-    // Create builder, pass to callback, then extract configuration
-    const builder = new UpdateBuilder<TSchema["tables"][TableName]>(table, id);
+    const builder = new UpdateBuilder<TSchema["tables"][TableName]>(tableName, id);
     builderFn(builder);
     const { id: opId, checkVersion, set } = builder.build();
 
-    this.#mutationOps.push({
+    this.#uow.addMutationOperation({
       type: "update",
-      table,
+      schema: this.#schema,
+      namespace: this.#namespace,
+      table: tableName,
       id: opId,
       checkVersion,
       set,
     });
   }
 
-  /**
-   * Add a delete operation using a builder callback (mutation phase only)
-   */
   delete<TableName extends keyof TSchema["tables"] & string>(
-    table: TableName,
+    tableName: TableName,
     id: FragnoId | string,
-    builderFn?: (
-      // We omit "build" because we don't want to expose it to the user
-      builder: Omit<DeleteBuilder, "build">,
-    ) => Omit<DeleteBuilder, "build"> | void,
+    builderFn?: (builder: Omit<DeleteBuilder, "build">) => Omit<DeleteBuilder, "build"> | void,
   ): void {
-    if (this.#state === "executed") {
-      throw new Error(`delete() can only be called during mutation phase.`);
-    }
-
-    // Create builder, optionally pass to callback, then extract configuration
-    const builder = new DeleteBuilder(table, id);
+    const builder = new DeleteBuilder(tableName, id);
     builderFn?.(builder);
     const { id: opId, checkVersion } = builder.build();
 
-    this.#mutationOps.push({
+    this.#uow.addMutationOperation({
       type: "delete",
-      table,
+      schema: this.#schema,
+      namespace: this.#namespace,
+      table: tableName,
       id: opId,
       checkVersion,
     });
   }
 
   /**
-   * Execute the mutation phase
-   * Returns success flag indicating if mutations completed without conflicts
-   */
-  async executeMutations(): Promise<{ success: boolean }> {
-    if (this.#state === "executed") {
-      throw new Error(`Cannot execute mutations from state ${this.#state}.`);
-    }
-
-    // Compile mutation operations
-    const mutationBatch: CompiledMutation<unknown>[] = [];
-    for (const op of this.#mutationOps) {
-      const compiled = this.#compiler.compileMutationOperation(op);
-      if (compiled !== null) {
-        this.#config?.onQuery?.(compiled);
-        mutationBatch.push(compiled);
-      }
-    }
-
-    if (this.#config?.dryRun) {
-      this.#state = "executed";
-      return {
-        success: true,
-      };
-    }
-
-    // Execute mutation phase
-    const result = await this.#executor.executeMutationPhase(mutationBatch);
-    this.#state = "executed";
-
-    if (result.success) {
-      this.#createdInternalIds = result.createdInternalIds;
-    }
-
-    return {
-      success: result.success,
-    };
-  }
-
-  /**
-   * Get the retrieval operations (for inspection/debugging)
-   */
-  getRetrievalOperations(): ReadonlyArray<RetrievalOperation<TSchema>> {
-    return this.#retrievalOps;
-  }
-
-  /**
-   * Get the mutation operations (for inspection/debugging)
-   */
-  getMutationOperations(): ReadonlyArray<MutationOperation<TSchema>> {
-    return this.#mutationOps;
-  }
-
-  /**
-   * Get the IDs of created entities after executeMutations() has been called.
-   * Returns FragnoId objects with external IDs (always available) and internal IDs
-   * (available when database supports RETURNING).
+   * Check that a record's version hasn't changed since retrieval.
+   * This is useful for ensuring related records remain unchanged during a transaction.
    *
-   * @throws Error if called before executeMutations()
-   * @returns Array of FragnoIds in the same order as create() calls
-   */
-  getCreatedIds(): FragnoId[] {
-    if (this.#state !== "executed") {
-      throw new Error(
-        `getCreatedIds() can only be called after executeMutations(). Current state: ${this.#state}`,
-      );
-    }
-
-    const createdIds: FragnoId[] = [];
-    let createIndex = 0;
-
-    for (const op of this.#mutationOps) {
-      if (op.type === "create") {
-        const internalId = this.#createdInternalIds[createIndex] ?? undefined;
-        createdIds.push(
-          new FragnoId({
-            externalId: op.generatedExternalId,
-            internalId,
-            version: 0, // New records always start at version 0
-          }),
-        );
-        createIndex++;
-      }
-    }
-
-    return createdIds;
-  }
-
-  /**
-   * @internal
-   * Compile the unit of work to executable queries for testing
+   * @param tableName - The table name
+   * @param id - The FragnoId with version information (string IDs are not allowed)
+   * @throws Error if the ID is a string without version information
+   *
+   * @example
+   * ```ts
+   * // Ensure both accounts haven't changed before creating a transfer
+   * uow.check("accounts", fromAccount.id);
+   * uow.check("accounts", toAccount.id);
+   * uow.create("transactions", { fromAccountId, toAccountId, amount });
+   * ```
    */
-  compile<TOutput>(compiler: UOWCompiler<TSchema, TOutput>): {
-    name?: string;
-    retrievalBatch: TOutput[];
-    mutationBatch: CompiledMutation<TOutput>[];
-  } {
-    const retrievalBatch: TOutput[] = [];
-    for (const op of this.#retrievalOps) {
-      const compiled = compiler.compileRetrievalOperation(op);
-      if (compiled !== null) {
-        retrievalBatch.push(compiled);
-      }
-    }
-
-    const mutationBatch: CompiledMutation<TOutput>[] = [];
-    for (const op of this.#mutationOps) {
-      const compiled = compiler.compileMutationOperation(op);
-      if (compiled !== null) {
-        mutationBatch.push(compiled);
-      }
-    }
-
-    return {
-      name: this.#name,
-      retrievalBatch,
-      mutationBatch,
-    };
+  check<TableName extends keyof TSchema["tables"] & string>(
+    tableName: TableName,
+    id: FragnoId,
+  ): void {
+    this.#uow.addMutationOperation({
+      type: "check",
+      schema: this.#schema,
+      namespace: this.#namespace,
+      table: tableName,
+      id,
+    });
   }
 }