@fragno-dev/db 0.2.2 → 0.4.1

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

@@ -1,3 +1,4 @@
+import type { TriggeredHook, TriggerHookOptions, HooksMap, HookPayload } from "../../hooks/hooks";
 import type {
   AnySchema,
   AnyTable,
@@ -8,7 +9,13 @@ import type {
 } from "../../schema/create";
 import { FragnoId } from "../../schema/create";
 import { generateId } from "../../schema/generate-id";
+import type { Prettify } from "../../util/types";
 import type { Condition, ConditionBuilder } from "../condition-builder";
+import { buildCondition } from "../condition-builder";
+import type { CursorResult } from "../cursor";
+import { Cursor } from "../cursor";
+import { dbInterval, dbNow, type DbInterval, type DbIntervalInput, type DbNow } from "../db-now";
+import type { CompiledJoin } from "../orm/orm";
 import type {
   SelectClause,
   TableToInsertValues,
@@ -17,12 +24,6 @@ import type {
   ExtractSelect,
   ExtractJoinOut,
 } from "../simple-query-interface";
-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";
-import type { TriggeredHook, TriggerHookOptions, HooksMap, HookPayload } from "../../hooks/hooks";
 
 /**
  * Builder for updateMany operations that supports both whereIndex and set chaining
@@ -33,6 +34,8 @@ export interface UpdateManyBuilder<TTable extends AnyTable> {
     condition?: (eb: IndexSpecificConditionBuilder<TTable, TIndexName>) => Condition | boolean,
   ): this;
   set(values: TableToUpdateValues<TTable>): this;
+  now(): DbNow;
+  interval(input: DbIntervalInput): DbInterval;
 }
 
 /**
@@ -42,6 +45,12 @@ export type IndexColumns<TIndex extends Index> = TIndex["columnNames"][number];
 
 type RemoveEmptyObject<T> = T extends object ? (keyof T extends never ? never : T) : never;
 
+type ExtractJoinBuilderSelect<T> =
+  T extends JoinFindBuilder<infer _Table, infer TSelect, infer _JoinOut> ? TSelect : true;
+
+type ExtractJoinBuilderOut<T> =
+  T extends JoinFindBuilder<infer _Table, infer _Select, infer TJoinOut> ? TJoinOut : {};
+
 /**
  * Extract all indexed column names from a table's indexes
  */
@@ -161,17 +170,18 @@ export type RetrievalOperation<
   | {
       type: "find";
       schema: TSchema;
-      namespace?: string;
+      namespace?: string | null;
       table: TTable;
       indexName: string;
       options: FindOptions<TTable, SelectClause<TTable>>;
       withCursor?: boolean;
       withSingleResult?: boolean;
+      readTracking?: boolean;
     }
   | {
       type: "count";
       schema: TSchema;
-      namespace?: string;
+      namespace?: string | null;
       table: TTable;
       indexName: string;
       options: Pick<FindOptions<TTable>, "where" | "useIndex">;
@@ -187,7 +197,7 @@ export type MutationOperation<
   | {
       type: "update";
       schema: TSchema;
-      namespace?: string;
+      namespace?: string | null;
       table: TTable["name"];
       id: FragnoId | string;
       checkVersion: boolean;
@@ -196,7 +206,7 @@ export type MutationOperation<
   | {
       type: "create";
       schema: TSchema;
-      namespace?: string;
+      namespace?: string | null;
       table: TTable["name"];
       values: TableToInsertValues<TTable>;
       generatedExternalId: string;
@@ -204,7 +214,7 @@ export type MutationOperation<
   | {
       type: "delete";
       schema: TSchema;
-      namespace?: string;
+      namespace?: string | null;
       table: TTable["name"];
       id: FragnoId | string;
       checkVersion: boolean;
@@ -212,7 +222,7 @@ export type MutationOperation<
   | {
       type: "check";
       schema: TSchema;
-      namespace?: string;
+      namespace?: string | null;
       table: TTable["name"];
       id: FragnoId;
     };
@@ -222,6 +232,14 @@ export type MutationOperation<
  */
 export interface CompiledMutation<TOutput> {
   query: TOutput;
+  /**
+   * Original mutation operation for execution metadata (e.g., outbox payloads).
+   */
+  operation?: MutationOperation<AnySchema>;
+  /**
+   * Idempotency key for the Unit of Work that produced this mutation.
+   */
+  uowId?: string;
   /**
    * The type of mutation operation (create, update, delete, or check).
    */
@@ -358,6 +376,7 @@ export class FindBuilder<
           `Use either select() or selectCount(), not both.`,
       );
     }
+    // prettier-ignore
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     (this as any).#selectClause = columns;
     return this as unknown as FindBuilder<TTable, TNewSelect, TJoinOut>;
@@ -567,6 +586,17 @@ export class UpdateBuilder<TTable extends AnyTable> {
     return this;
   }
 
+  /**
+   * Database timestamp helper for mutation values.
+   */
+  now(): DbNow {
+    return dbNow();
+  }
+
+  interval(input: DbIntervalInput): DbInterval {
+    return dbInterval(input);
+  }
+
   /**
    * Enable version checking for optimistic concurrency control
    * @throws Error if the ID is just a string (no version available)
@@ -703,6 +733,7 @@ export class JoinFindBuilder<
   select<const TNewSelect extends SelectClause<TTable>>(
     columns: TNewSelect,
   ): JoinFindBuilder<TTable, TNewSelect, TJoinOut> {
+    // prettier-ignore
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     (this as any).#selectClause = columns;
     return this as unknown as JoinFindBuilder<TTable, TNewSelect, TJoinOut>;
@@ -801,15 +832,22 @@ export type IndexedJoinBuilder<TTable extends AnyTable, TJoinOut> = {
     infer TRelationType,
     infer TTargetTable
   >
-    ? <TSelect extends SelectClause<TTable["relations"][K]["table"]> = true, TNestedJoinOut = {}>(
-        builderFn?: (
-          builder: JoinFindBuilder<TTable["relations"][K]["table"]>,
-        ) => JoinFindBuilder<TTable["relations"][K]["table"], TSelect, TNestedJoinOut>,
+    ? <
+        TBuilderFn extends (builder: JoinFindBuilder<TTable["relations"][K]["table"]>) => unknown =
+          (
+            builder: JoinFindBuilder<TTable["relations"][K]["table"]>,
+          ) => JoinFindBuilder<TTable["relations"][K]["table"]>,
+      >(
+        builderFn?: TBuilderFn,
       ) => IndexedJoinBuilder<
         TTable,
         TJoinOut & {
           [P in K]: MapRelationType<
-            SelectResult<TTargetTable, TNestedJoinOut, TSelect>
+            SelectResult<
+              TTargetTable,
+              ExtractJoinBuilderOut<ReturnType<TBuilderFn>>,
+              ExtractJoinBuilderSelect<ReturnType<TBuilderFn>>
+            >
           >[TRelationType];
         }
       >
@@ -832,7 +870,7 @@ export function buildJoinIndexed<TTable extends AnyTable, TJoinOut>(
 
     builder[name] = (builderFn?: (b: JoinFindBuilder<AnyTable>) => JoinFindBuilder<AnyTable>) => {
       // Create join builder for this relation's table
-      const joinBuilder = new JoinFindBuilder(relation.table.ormName, relation.table);
+      const joinBuilder = new JoinFindBuilder(relation.table.name, relation.table);
       if (builderFn) {
         builderFn(joinBuilder);
       }
@@ -933,10 +971,16 @@ export interface IUnitOfWork {
   ): TypedUnitOfWork<TOtherSchema, [], any, TOtherHooks>;
 
   // Schema registration (for cross-fragment operations like hooks)
-  registerSchema(schema: AnySchema, namespace: string): void;
-
-  // Hook triggering (schema-agnostic, string-based hook names)
-  triggerHook(hookName: string, payload: unknown, options?: TriggerHookOptions): void;
+  registerSchema(schema: AnySchema, namespace: string | null): void;
+
+  // Hook triggering (schema-agnostic, string-based hook names).
+  // Namespace identifies which fragment/dispatcher owns this hook.
+  triggerHook(
+    namespace: string,
+    hookName: string,
+    payload: unknown,
+    options?: TriggerHookOptions,
+  ): void;
 
   getTriggeredHooks(): readonly TriggeredHook[];
 }
@@ -948,14 +992,55 @@ export interface IUnitOfWork {
  *
  * Note: This is just a marker interface. Restriction is enforced by the UnitOfWork class itself.
  */
-export interface IUnitOfWorkRestricted
-  extends Omit<IUnitOfWork, "executeRetrieve" | "executeMutations"> {}
+export interface IUnitOfWorkRestricted extends Omit<
+  IUnitOfWork,
+  "executeRetrieve" | "executeMutations"
+> {}
+
+export type UOWInstrumentationPhase =
+  | "beforeRetrieve"
+  | "afterRetrieve"
+  | "beforeMutate"
+  | "afterMutate";
+
+export type UOWInstrumentationInjection =
+  | { type: "conflict"; reason?: string }
+  | { type: "error"; error: Error };
+
+export type UOWInstrumentationContext = {
+  phase: UOWInstrumentationPhase;
+  uowName?: string;
+  idempotencyKey: string;
+  retrievalOpsCount: number;
+  mutationOpsCount: number;
+  uow: IUnitOfWork;
+};
+
+export type UOWInstrumentation = {
+  beforeRetrieve?: (
+    ctx: UOWInstrumentationContext,
+  ) => void | Promise<void> | UOWInstrumentationInjection;
+  afterRetrieve?: (
+    ctx: UOWInstrumentationContext,
+  ) => void | Promise<void> | UOWInstrumentationInjection;
+  beforeMutate?: (
+    ctx: UOWInstrumentationContext,
+  ) => void | Promise<void> | UOWInstrumentationInjection;
+  afterMutate?: (
+    ctx: UOWInstrumentationContext,
+  ) => void | Promise<void> | UOWInstrumentationInjection;
+};
+
+export type UOWInstrumentationFinalizer = {
+  afterRetrieve?: (ctx: UOWInstrumentationContext) => void | Promise<void>;
+  afterMutate?: (ctx: UOWInstrumentationContext) => void | Promise<void>;
+};
 
 export function createUnitOfWork(
   compiler: UOWCompiler<unknown>,
   executor: UOWExecutor<unknown, unknown>,
   decoder: UOWDecoder<unknown>,
-  schemaNamespaceMap?: WeakMap<AnySchema, string>,
+  schemaNamespaceMap?: WeakMap<AnySchema, string | null>,
   name?: string,
 ): UnitOfWork {
   return new UnitOfWork(compiler, executor, decoder, name, undefined, schemaNamespaceMap);
@@ -965,6 +1050,16 @@ export interface UnitOfWorkConfig {
   dryRun?: boolean;
   onQuery?: (query: unknown) => void;
   idempotencyKey?: string;
+  instrumentation?: UOWInstrumentation;
+  instrumentationFinalizer?: UOWInstrumentationFinalizer;
+}
+
+function isUowInstrumentationInjection(value: unknown): value is UOWInstrumentationInjection {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const injection = value as UOWInstrumentationInjection;
+  return injection.type === "conflict" || injection.type === "error";
 }
 
 /**
@@ -1207,10 +1302,11 @@ export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
   #compiler: UOWCompiler<unknown>;
   #executor: UOWExecutor<unknown, TRawInput>;
   #decoder: UOWDecoder<TRawInput>;
-  #schemaNamespaceMap: WeakMap<AnySchema, string>;
+  #schemaNamespaceMap: WeakMap<AnySchema, string | null>;
 
   #retrievalResults?: unknown[];
   #createdInternalIds: (bigint | null)[] = [];
+  #readTrackingEnabled = false;
 
   // Phase coordination promises
   #retrievalPhaseDeferred = new DeferredPromise<unknown[]>();
@@ -1232,7 +1328,7 @@ export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
     decoder: UOWDecoder<TRawInput>,
     name?: string,
     config?: UnitOfWorkConfig,
-    schemaNamespaceMap?: WeakMap<AnySchema, string>,
+    schemaNamespaceMap?: WeakMap<AnySchema, string | null>,
   ) {
     this.#compiler = compiler;
     this.#executor = executor;
@@ -1243,12 +1339,67 @@ export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
     this.#idempotencyKey = config?.idempotencyKey ?? crypto.randomUUID();
   }
 
+  #createInstrumentationContext(phase: UOWInstrumentationPhase): UOWInstrumentationContext {
+    return {
+      phase,
+      uowName: this.#name,
+      idempotencyKey: this.#idempotencyKey,
+      retrievalOpsCount: this.#retrievalOps.length,
+      mutationOpsCount: this.#mutationOps.length,
+      uow: this,
+    };
+  }
+
+  async #runInstrumentation(
+    phase: UOWInstrumentationPhase,
+  ): Promise<UOWInstrumentationInjection | null> {
+    const hook = this.#config?.instrumentation?.[phase];
+    if (!hook) {
+      return null;
+    }
+
+    const result = await hook(this.#createInstrumentationContext(phase));
+    if (isUowInstrumentationInjection(result)) {
+      return result;
+    }
+
+    return null;
+  }
+
+  async #runInstrumentationFinalizer(phase: "afterRetrieve" | "afterMutate"): Promise<void> {
+    const hook = this.#config?.instrumentationFinalizer?.[phase];
+    if (!hook) {
+      return;
+    }
+
+    await hook(this.#createInstrumentationContext(phase));
+  }
+
+  #handleRetrieveInjection(injection: UOWInstrumentationInjection): never {
+    if (injection.type === "error") {
+      throw injection.error;
+    }
+
+    throw new Error(injection.reason ?? "Injected conflict");
+  }
+
+  #handleMutationInjection(injection: UOWInstrumentationInjection): { success: false } | never {
+    if (injection.type === "error") {
+      throw injection.error;
+    }
+
+    this.#state = "executed";
+    this.#createdInternalIds.length = 0;
+    this.#mutationPhaseDeferred.resolve();
+    return { success: false };
+  }
+
   /**
    * Register a schema with its namespace for cross-fragment operations.
    * This is used for internal fragments like hooks that need to create
    * records in a different schema during the same transaction.
    */
-  registerSchema(schema: AnySchema, namespace: string): void {
+  registerSchema(schema: AnySchema, namespace: string | null): void {
     this.#schemaNamespaceMap.set(schema, namespace);
   }
 
@@ -1299,6 +1450,7 @@ export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
     child.#mutationOps = this.#mutationOps;
     child.#retrievalResults = this.#retrievalResults;
     child.#createdInternalIds = this.#createdInternalIds;
+    child.#readTrackingEnabled = this.#readTrackingEnabled;
     child.#retrievalPhaseDeferred = this.#retrievalPhaseDeferred;
     child.#mutationPhaseDeferred = this.#mutationPhaseDeferred;
     child.#retrievalError = this.#retrievalError;
@@ -1348,6 +1500,7 @@ export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
     this.#mutationOps = [];
     this.#retrievalResults = undefined;
     this.#createdInternalIds = [];
+    this.#readTrackingEnabled = false;
 
     // Reset state
     this.#state = "building-retrieval";
@@ -1368,8 +1521,14 @@ export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
   /**
    * Trigger a hook to be executed after the transaction commits.
    */
-  triggerHook(hookName: string, payload: unknown, options?: TriggerHookOptions): void {
+  triggerHook(
+    namespace: string,
+    hookName: string,
+    payload: unknown,
+    options?: TriggerHookOptions,
+  ): void {
     this.#triggeredHooks.push({
+      namespace,
       hookName,
       payload,
       options,
@@ -1387,6 +1546,14 @@ export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
     return this.#coordinator.parent?.state ?? this.#state;
   }
 
+  enableReadTracking(): void {
+    this.#readTrackingEnabled = true;
+  }
+
+  get readTrackingEnabled(): boolean {
+    return this.#readTrackingEnabled;
+  }
+
   get name(): string | undefined {
     return this.#name;
   }
@@ -1426,13 +1593,25 @@ export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
       );
     }
 
+    let afterRan = false;
+    let failed = false;
     try {
       // Wait for all children to signal readiness
       await this.#coordinator.retrievalReadinessPromise;
 
+      const beforeInjection = await this.#runInstrumentation("beforeRetrieve");
+      if (beforeInjection) {
+        return this.#handleRetrieveInjection(beforeInjection);
+      }
+
       if (this.#retrievalOps.length === 0) {
         this.#state = "building-mutation";
         const emptyResults: unknown[] = [];
+        afterRan = true;
+        const afterInjection = await this.#runInstrumentation("afterRetrieve");
+        if (afterInjection) {
+          return this.#handleRetrieveInjection(afterInjection);
+        }
         this.#retrievalPhaseDeferred.resolve(emptyResults);
         return emptyResults;
       }
@@ -1450,6 +1629,11 @@ export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
       if (this.#config?.dryRun) {
         this.#state = "executed";
         const emptyResults: unknown[] = [];
+        afterRan = true;
+        const afterInjection = await this.#runInstrumentation("afterRetrieve");
+        if (afterInjection) {
+          return this.#handleRetrieveInjection(afterInjection);
+        }
         this.#retrievalPhaseDeferred.resolve(emptyResults);
         return emptyResults;
       }
@@ -1462,12 +1646,33 @@ export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
       this.#retrievalResults = results;
       this.#state = "building-mutation";
 
+      afterRan = true;
+      const afterInjection = await this.#runInstrumentation("afterRetrieve");
+      if (afterInjection) {
+        return this.#handleRetrieveInjection(afterInjection);
+      }
+
       this.#retrievalPhaseDeferred.resolve(this.#retrievalResults);
 
       return this.#retrievalResults;
     } catch (error) {
       this.#retrievalError = error instanceof Error ? error : new Error(String(error));
+      failed = true;
       throw error;
+    } finally {
+      try {
+        await this.#runInstrumentationFinalizer("afterRetrieve");
+      } catch {
+        // Ignore finalizer errors when unwinding failures.
+      }
+
+      if (!afterRan && failed) {
+        try {
+          await this.#runInstrumentation("afterRetrieve");
+        } catch {
+          // Ignore after-retrieve hook errors when unwinding failures.
+        }
+      }
     }
   }
 
@@ -1484,15 +1689,23 @@ export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
       throw new Error(`Cannot execute mutations from state ${this.#state}.`);
     }
 
+    let afterRan = false;
+    let failed = false;
     try {
       // Wait for all children to signal readiness
       await this.#coordinator.mutationReadinessPromise;
 
+      const beforeInjection = await this.#runInstrumentation("beforeMutate");
+      if (beforeInjection) {
+        return this.#handleMutationInjection(beforeInjection);
+      }
+
       // 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) {
+          compiled.uowId = this.#idempotencyKey;
           this.#config?.onQuery?.(compiled);
           mutationBatch.push(compiled);
         }
@@ -1500,6 +1713,11 @@ export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
 
       if (this.#config?.dryRun) {
         this.#state = "executed";
+        afterRan = true;
+        const afterInjection = await this.#runInstrumentation("afterMutate");
+        if (afterInjection) {
+          return this.#handleMutationInjection(afterInjection);
+        }
         this.#mutationPhaseDeferred.resolve();
         return {
           success: true,
@@ -1516,6 +1734,12 @@ export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
         this.#createdInternalIds.push(...result.createdInternalIds);
       }
 
+      afterRan = true;
+      const afterInjection = await this.#runInstrumentation("afterMutate");
+      if (afterInjection) {
+        return this.#handleMutationInjection(afterInjection);
+      }
+
       // Resolve the mutation phase promise to unblock waiting service methods
       this.#mutationPhaseDeferred.resolve();
 
@@ -1524,7 +1748,22 @@ export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
       };
     } catch (error) {
       this.#mutationError = error instanceof Error ? error : new Error(String(error));
+      failed = true;
       throw error;
+    } finally {
+      try {
+        await this.#runInstrumentationFinalizer("afterMutate");
+      } catch {
+        // Ignore finalizer errors when unwinding failures.
+      }
+
+      if (!afterRan && failed) {
+        try {
+          await this.#runInstrumentation("afterMutate");
+        } catch {
+          // Ignore after-mutate hook errors when unwinding failures.
+        }
+      }
     }
   }
 
@@ -1623,6 +1862,7 @@ export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
     for (const op of this.#mutationOps) {
       const compiled = compiler.compileMutationOperation(op);
       if (compiled !== null) {
+        compiled.uowId = this.#idempotencyKey;
         mutationBatch.push(compiled);
       }
     }
@@ -1645,20 +1885,22 @@ export class TypedUnitOfWork<
   const TRetrievalResults extends unknown[] = [],
   const TRawInput = unknown,
   const THooks extends HooksMap = {},
-> implements IUnitOfWork
-{
+> {
   #schema: TSchema;
-  #namespace?: string;
+  #namespace?: string | null;
   #uow: UnitOfWork<TRawInput>;
   #operationIndices: number[] = [];
   #cachedRetrievalPhase?: Promise<TRetrievalResults>;
 
-  constructor(schema: TSchema, namespace: string | undefined, uow: UnitOfWork<TRawInput>) {
+  constructor(schema: TSchema, namespace: string | null | undefined, uow: UnitOfWork<TRawInput>) {
     this.#schema = schema;
     this.#namespace = namespace;
     this.#uow = uow;
   }
 
+  /**
+   * Type-only access to retrieval results for this typed UOW.
+   */
   get $results(): Prettify<TRetrievalResults> {
     throw new Error("type only");
   }
@@ -1746,7 +1988,21 @@ export class TypedUnitOfWork<
     return this.#uow.forSchema<TOtherSchema, TOtherHooks>(schema, hooks);
   }
 
-  registerSchema(schema: AnySchema, namespace: string): void {
+  /**
+   * Database timestamp helper for inserts.
+   */
+  now(): DbNow {
+    return dbNow();
+  }
+
+  /**
+   * Build a database interval for use with now().plus(...).
+   */
+  interval(input: DbIntervalInput): DbInterval {
+    return dbInterval(input);
+  }
+
+  registerSchema(schema: AnySchema, namespace: string | null): void {
     this.#uow.registerSchema(schema, namespace);
   }
 
@@ -1823,6 +2079,7 @@ export class TypedUnitOfWork<
       indexName,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       options: options as any,
+      readTracking: this.#uow.readTrackingEnabled,
     });
 
     // Track which operation index belongs to this view
@@ -1901,6 +2158,7 @@ export class TypedUnitOfWork<
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       options: options as any,
       withSingleResult: true,
+      readTracking: this.#uow.readTrackingEnabled,
     });
 
     // Track which operation index belongs to this view
@@ -1949,6 +2207,7 @@ export class TypedUnitOfWork<
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       options: options as any,
       withCursor: true,
+      readTracking: this.#uow.readTrackingEnabled,
     });
 
     // Track which operation index belongs to this view
@@ -1989,7 +2248,7 @@ export class TypedUnitOfWork<
     let updatedValues = values;
 
     // Check if ID value is provided in values
-    const providedIdValue = (values as Record<string, unknown>)[idColumn.ormName];
+    const providedIdValue = (values as Record<string, unknown>)[idColumn.name];
 
     if (providedIdValue !== undefined) {
       // Extract string from FragnoId or use string directly
@@ -2007,7 +2266,7 @@ export class TypedUnitOfWork<
       const generated = idColumn.generateDefaultValue();
       if (generated === undefined) {
         throw new Error(
-          `No ID value provided and ID column ${idColumn.ormName} has no default generator`,
+          `No ID value provided and ID column ${idColumn.name} has no default generator`,
         );
       }
       externalId = generated as string;
@@ -2015,7 +2274,7 @@ export class TypedUnitOfWork<
       // Add the generated ID to values so it's used in the insert
       updatedValues = {
         ...values,
-        [idColumn.ormName]: externalId,
+        [idColumn.name]: externalId,
       } as TableToInsertValues<TSchema["tables"][TableName]>;
     }
 
@@ -2105,15 +2364,27 @@ export class TypedUnitOfWork<
     throw new Error("type only");
   }
 
+  get namespace(): string | null | undefined {
+    return this.#namespace;
+  }
+
   /**
    * Trigger a hook to be executed after the transaction commits.
+   * The namespace is automatically injected from this typed view's schema registration.
    */
   triggerHook<K extends keyof THooks & string>(
     hookName: K,
     payload: HookPayload<THooks[K]>,
     options?: TriggerHookOptions,
   ): void {
-    this.#uow.triggerHook(hookName, payload, options);
+    if (this.#namespace === undefined) {
+      throw new Error(
+        "Cannot trigger hook: schema has no registered namespace. " +
+          "Ensure the schema is registered with a namespace via registerSchema().",
+      );
+    }
+    const hookNamespace = this.#namespace ?? this.#schema.name;
+    this.#uow.triggerHook(hookNamespace, hookName, payload, options);
   }
 
   getTriggeredHooks(): ReadonlyArray<TriggeredHook> {