bazis 0.136.0 → 0.137.0

package/core/workflow/runtime_module/model/WfInstance.model.ts

@@ -1,4 +1,4 @@
-import { Column, Entity, Index, UUID } from "../../../orm";
+import { Column, Entity, Index, UUID, Nullable } from "../../../orm";
 
 /**
  * `completed`, `cancelled` and `timedOut` are finished: retention deletes them.
@@ -23,76 +23,96 @@ export class WfInstance {
   id = "";
 
   /** The version (a Definitions row: a reference without a foreign key). */
+  @Nullable()
   @Column({ type: "text" })
   versionId = "";
 
+  @Nullable()
   @Column({ type: "text" })
   processKey = "";
 
+  @Nullable()
   @Column({ type: "integer" })
   version = 0;
 
   /** The application's scope: a space, an organization. Never interpreted. */
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   partition: string | null = null;
 
+  @Nullable()
   @Column({ type: "text" })
   status: InstanceStatus = "running";
 
+  @Nullable()
   @Column({ type: "json" })
   input: Record<string, unknown> = {};
 
+  @Nullable()
   @Column({ type: "json" })
   vars: Record<string, unknown> = {};
 
   /** The result of every passed step by node id: `$nodes.<node>.<field>`. */
+  @Nullable()
   @Column({ type: "json" })
   nodes: Record<string, unknown> = {};
 
   /** What the process gave back: its `out` variables when it completed. */
-  @Column({ type: "json", nullable: true })
+  @Nullable()
+  @Column({ type: "json" })
   output: Record<string, unknown> | null = null;
 
   /** `$event`: the data of the event that started or last continued it. */
-  @Column({ type: "json", nullable: true })
+  @Nullable()
+  @Column({ type: "json" })
   event: unknown = null;
 
   /** `$trigger`: how it was started. */
-  @Column({ type: "json", nullable: true })
+  @Nullable()
+  @Column({ type: "json" })
   trigger: Record<string, unknown> | null = null;
 
   /** A trial run (WORKFLOW-002 §5.4, stage 5). */
+  @Nullable()
   @Column({ type: "boolean" })
   test = false;
 
   /** The instance whose `callProcess` started this one, and the waiting token there. */
   @Index()
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   parentInstanceId: string | null = null;
 
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   parentTokenId: string | null = null;
 
   @Index()
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   businessKey: string | null = null;
 
+  @Nullable()
   @Column({ type: "text" })
   startedVia: StartedVia = "manual";
 
+  @Nullable()
   @Column({ type: "text" })
   startedByKind: "user" | "system" = "user";
 
+  @Nullable()
   @Column({ type: "text" })
   startedById = "";
 
   /** Why the instance failed: node, code and message. */
-  @Column({ type: "json", nullable: true })
+  @Nullable()
+  @Column({ type: "json" })
   error: { readonly node: string; readonly code: string; readonly message: string } | null = null;
 
   @Column({ type: "createdAt" })
   createdAt = new Date(0);
 
-  @Column({ type: "datetime", nullable: true })
+  @Nullable()
+  @Column({ type: "datetime" })
   endedAt: Date | null = null;
 }

package/core/workflow/runtime_module/model/WfJob.model.ts

@@ -1,4 +1,4 @@
-import { Column, Entity, ForeignKey, Index, UUID } from "../../../orm";
+import { Column, Entity, ForeignKey, Index, UUID, Nullable } from "../../../orm";
 import { WfInstance } from "./WfInstance.model";
 
 /**
@@ -24,50 +24,62 @@ export class WfJob {
   @UUID({ version: "v7" })
   id = "";
 
+  @Nullable()
   @Column({ type: "text" })
   kind: JobKind = "tool";
 
   /** `null` for `schedule`, `event` and `eventStart` jobs: the instance does not exist yet. */
   @Index()
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   instanceId: string | null = null;
 
   @Index()
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   tokenId: string | null = null;
 
   /** The version a `schedule` or `eventStart` job starts. */
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   versionId: string | null = null;
 
   @Index()
+  @Nullable()
   @Column({ type: "datetime" })
   dueAt = new Date(0);
 
   /** What a job carries besides its token: the caller to tell, the process to release. */
-  @Column({ type: "json", nullable: true })
+  @Nullable()
+  @Column({ type: "json" })
   payload: unknown = null;
 
   /** Jobs with one key merge into the last: `debounce` of an event start. */
   @Index()
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   dedupeKey: string | null = null;
 
   /** The partition and the start node of a `schedule` or `eventStart` job. */
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   partition: string | null = null;
 
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   nodeId: string | null = null;
 
+  @Nullable()
   @Column({ type: "integer" })
   attempts = 0;
 
   /** The worker holds the job until then; if it dies, the job becomes free again. */
-  @Column({ type: "datetime", nullable: true })
+  @Nullable()
+  @Column({ type: "datetime" })
   lockedUntil: Date | null = null;
 
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   lastError: string | null = null;
 
   @Column({ type: "createdAt" })

package/core/workflow/runtime_module/model/WfSubscription.model.ts

@@ -1,4 +1,4 @@
-import { Column, Entity, ForeignKey, Index, UUID } from "../../../orm";
+import { Column, Entity, ForeignKey, Index, UUID, Nullable } from "../../../orm";
 import { WfInstance } from "./WfInstance.model";
 
 /** A token waiting for an event: `eventWait` or `boundaryEvent`. Matched by key and correlation. */
@@ -9,20 +9,25 @@ export class WfSubscription {
   @UUID({ version: "v7" })
   id = "";
 
+  @Nullable()
   @Column({ type: "text" })
   instanceId = "";
 
   @Index()
+  @Nullable()
   @Column({ type: "text" })
   tokenId = "";
 
+  @Nullable()
   @Column({ type: "text" })
   eventKey = "";
 
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   correlation: string | null = null;
 
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   partition: string | null = null;
 
   @Column({ type: "createdAt" })

package/core/workflow/runtime_module/model/WfToken.model.ts

@@ -1,4 +1,4 @@
-import { Column, Entity, ForeignKey, Index, UUID } from "../../../orm";
+import { Column, Entity, ForeignKey, Index, UUID, Nullable } from "../../../orm";
 import { WfInstance } from "./WfInstance.model";
 
 /**
@@ -16,36 +16,45 @@ export class WfToken {
   @UUID({ version: "v7" })
   id = "";
 
+  @Nullable()
   @Column({ type: "text" })
   instanceId = "";
 
+  @Nullable()
   @Column({ type: "text" })
   nodeId = "";
 
   /** The flow the token came by; `null` on a start node. */
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   viaFlowId: string | null = null;
 
+  @Nullable()
   @Column({ type: "text" })
   status: TokenStatus = "active";
 
   /** A step's result; a loop keeps its progress here while it runs. */
-  @Column({ type: "json", nullable: true })
+  @Nullable()
+  @Column({ type: "json" })
   output: unknown = null;
 
   /** The loop token this one runs inside, with its iteration and what only the body sees: `Locals` of the engine. */
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   parentTokenId: string | null = null;
 
-  @Column({ type: "integer", nullable: true })
+  @Nullable()
+  @Column({ type: "integer" })
   iteration: number | null = null;
 
-  @Column({ type: "json", nullable: true })
+  @Nullable()
+  @Column({ type: "json" })
   locals: Record<string, unknown> | null = null;
 
   @Column({ type: "createdAt" })
   createdAt = new Date(0);
 
-  @Column({ type: "datetime", nullable: true })
+  @Nullable()
+  @Column({ type: "datetime" })
   endedAt: Date | null = null;
 }

package/core/workflow/tasks_module/model/WfTask.model.ts

@@ -1,4 +1,4 @@
-import { Column, Entity, Index, UUID } from "../../../orm";
+import { Column, Entity, Index, UUID, Nullable } from "../../../orm";
 import type { FormSpec, LocalizedText } from "../../../../library/workflow";
 
 /** `open` waits for someone, `claimed` is taken by one person, `completed` and `cancelled` are done. */
@@ -17,55 +17,71 @@ export class WfTask {
 
   /** The waiting token: one task per token. */
   @Index({ unique: true })
+  @Nullable()
   @Column({ type: "text" })
   tokenId = "";
 
   @Index()
+  @Nullable()
   @Column({ type: "text" })
   instanceId = "";
 
+  @Nullable()
   @Column({ type: "text" })
   processKey = "";
 
+  @Nullable()
   @Column({ type: "text" })
   nodeId = "";
 
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   partition: string | null = null;
 
+  @Nullable()
   @Column({ type: "json" })
   title: LocalizedText = "";
 
   /** The task of a trial run (WORKFLOW-002 §5.4, stage 5). */
+  @Nullable()
   @Column({ type: "boolean" })
   test = false;
 
   /** `role:<code>` or `user:<id>`. */
+  @Nullable()
   @Column({ type: "text" })
   assignee = "";
 
-  @Column({ type: "json", nullable: true })
+  @Nullable()
+  @Column({ type: "json" })
   form: FormSpec | null = null;
 
-  @Column({ type: "datetime", nullable: true })
+  @Nullable()
+  @Column({ type: "datetime" })
   dueAt: Date | null = null;
 
+  @Nullable()
   @Column({ type: "text" })
   status: TaskStatus = "open";
 
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   claimedById: string | null = null;
 
-  @Column({ type: "datetime", nullable: true })
+  @Nullable()
+  @Column({ type: "datetime" })
   claimedAt: Date | null = null;
 
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   completedById: string | null = null;
 
-  @Column({ type: "datetime", nullable: true })
+  @Nullable()
+  @Column({ type: "datetime" })
   completedAt: Date | null = null;
 
-  @Column({ type: "json", nullable: true })
+  @Nullable()
+  @Column({ type: "json" })
   output: Record<string, unknown> | null = null;
 
   @Column({ type: "createdAt" })

package/library/openapi/codegen.ts

@@ -47,7 +47,7 @@ const ERROR_HELPER_STATUS: Readonly<Record<string, number>> = {
   BadRequest: 400, Unauthorized: 401, Forbidden: 403, NotFound: 404, Conflict: 409,
 };
 const ERROR_CLASS_STATUS: Readonly<Record<string, number>> = {
-  BadRequestError: 400, UnauthorizedError: 401, ForbiddenError: 403, NotFoundError: 404,
+  BadRequestError: 400, UnauthorizedError: 401, ForbiddenError: 403, NotFoundError: 404, ConflictError: 409,
   PayloadTooLargeError: 413, UnsupportedMediaTypeError: 415, TooManyRequestsError: 429,
 };
 const OPENAPI_EMPTY_TYPE_NAMES = new Set(["HttpResult", "Response", "Blob", "ReadableStream", "Uint8Array"]);
@@ -333,7 +333,7 @@ export function createOpenApiCodegenAnalyzer(input: OpenApiCodegenAnalyzerInput)
           return schemaFromOptionalExpression(unwrapped.arguments[0]);
         }
         if (CREATED_RESULT_HELPERS.has(name)) {
-          return schemaFromOptionalExpression(unwrapped.arguments[1]);
+          return schemaFromOptionalExpression(unwrapped.arguments[0]);
         }
         if (name === "StatusCode") {
           return schemaFromStatusCodeCall(unwrapped);

package/library/orm/DbContext.ts

@@ -11,6 +11,9 @@ import { OrmTransaction, type OrmTransactionScopeOptions } from "./Transactions/
 
 type EntityClass<T extends object> = new () => T;
 
+/** While a context is constructed only to read its sets: {@link DbContext.entitiesOf}. */
+let discovered: Set<EntityClass<object>> | undefined;
+
 /**
  * Base class of a database context (a scoped DI service). A subclass declares the sets:
  *
@@ -32,10 +35,39 @@ export abstract class DbContext {
   readonly #options: DbContextOptions;
   readonly #runtime: DbContextRuntime;
 
+  /**
+   * The entities a context declares with `this.set(...)`, in the order of its
+   * fields. The class is constructed once without a database and without its
+   * own constructor dependencies only to read the sets: a constructor that needs
+   * them fails here, and the entities are then listed by hand.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static entitiesOf(context: new (options: DbContextOptions, ...dependencies: any[]) => DbContext): readonly EntityClass<object>[] {
+    const previous = discovered;
+    const found = new Set<EntityClass<object>>();
+    discovered = found;
+    try {
+      new context(undefined as unknown as DbContextOptions);
+    } catch (error) {
+      throw new OrmError(`The entities of ${context.name} cannot be read from its sets: its constructor failed without its dependencies (${error instanceof Error ? error.message : String(error)}). List them: entities: [...].`);
+    } finally {
+      discovered = previous;
+    }
+    return [...found];
+  }
+
   constructor(options: DbContextOptions) {
+    if (discovered !== undefined) {
+      // Only the sets are read: nothing of the context works, and it is thrown away.
+      this.#options = options;
+      this.changeTracker = undefined as unknown as ChangeTracker;
+      this.#runtime = undefined as unknown as DbContextRuntime;
+      this.database = undefined as unknown as DatabaseFacade;
+      return;
+    }
     this.#options = options;
     this.changeTracker = new ChangeTracker();
-    const provider = observedProvider(this, options.provider);
+    const provider = observedProvider(this, options.provider, options.model);
     this.#runtime = { context: this, provider, models: options.model, tracker: this.changeTracker, runImmediateOperation: (operation) => monitorImmediateOperation(this, operation) };
     this.database = new DatabaseFacade(provider, options.model);
   }
@@ -47,6 +79,10 @@ export abstract class DbContext {
 
   /** Public access to a `DbSet` by entity class (for `Repository<T>` and generic scenarios). */
   setOf<T extends object>(entity: EntityClass<T>): DbSet<T> {
+    if (discovered !== undefined) {
+      discovered.add(entity);
+      return undefined as unknown as DbSet<T>;
+    }
     return new DbSet<T>(this.#options.model.requireByCtor(entity), this.#runtime);
   }
 

package/library/orm/Metadata/ModelBuilder.ts

@@ -59,6 +59,7 @@ export class ModelBuilder {
           columns: [property.columnName],
           unique: rawProp.index.unique,
           ...(rawProp.index.where === undefined ? {} : { where: rawProp.index.where }),
+          ...conflictOf(ctor.name, rawProp.index),
         });
       }
       if (rawProp.fkTarget) {
@@ -179,7 +180,7 @@ export class ModelBuilder {
         return property.columnName;
       });
       if (new Set(columns).size !== columns.length) throw new ModelBuildError(`Entity "${ctor.name}": index contains duplicate properties.`);
-      indexes.push({ name: declared.name ?? `ix_${(raw.table ?? defaultTableName(ctor.name)).toLowerCase()}_${columns.join("_")}`, columns, unique: declared.unique, ...(declared.where === undefined ? {} : { where: declared.where }) });
+      indexes.push({ name: declared.name ?? `ix_${(raw.table ?? defaultTableName(ctor.name)).toLowerCase()}_${columns.join("_")}`, columns, unique: declared.unique, ...(declared.where === undefined ? {} : { where: declared.where }), ...conflictOf(ctor.name, declared) });
     }
     const indexNames = new Set<string>();
     for (const index of indexes) {
@@ -255,12 +256,19 @@ export class ModelBuilder {
         `Entity "${entityName}": key "${raw.propertyName}" has keyGenerated=true but is not an integer identity key.`,
       );
     }
-    // The key and semantic timestamp fields are always NOT NULL.
-    const required =
-      isKey ||
-      raw.required === true ||
-      raw.nullable === false ||
-      resolved.impliedRequired === true;
+    // The key and semantic timestamp fields are always NOT NULL. Every other
+    // column says it itself: silence would be read as either by different readers.
+    const always = isKey || resolved.impliedRequired === true;
+    if (raw.required === true && raw.nullable === true) {
+      throw new ModelBuildError(`Entity "${entityName}": property "${raw.propertyName}" is marked both @Required() and @Nullable(). Keep one.`);
+    }
+    if (always && raw.nullable === true) {
+      throw new ModelBuildError(`Entity "${entityName}": property "${raw.propertyName}" is ${isKey ? "a key" : "a creation or change timestamp"} and cannot be @Nullable().`);
+    }
+    if (!always && raw.required !== true && raw.nullable !== true) {
+      throw new ModelBuildError(`Entity "${entityName}": property "${raw.propertyName}" does not say whether it may be empty. Mark it @Required() (NOT NULL) or @Nullable().`);
+    }
+    const required = always || raw.required === true;
     const databaseDefault = ModelBuilder.defaultFor(entityName, raw, storageType, isKey, generated, convention, required);
     const digits = ModelBuilder.decimalDigits(entityName, raw, storageType);
     return {
@@ -371,6 +379,14 @@ function isCanonicalRfc3339(value: string): boolean {
  * refused: PostgreSQL stores it in its own time zone form, so the declared
  * and the stored conditions could never be compared.
  */
+/** The text of a unique index for a rejected value; on any other index it would never be used. */
+function conflictOf(entity: string, index: { readonly unique: boolean; readonly conflict?: string }): { readonly conflict?: string } {
+  if (index.conflict === undefined) return {};
+  if (!index.unique) throw new ModelBuildError(`Entity "${entity}": conflict is the text of a unique index; this index is not unique.`);
+  if (typeof index.conflict !== "string" || index.conflict.trim() === "") throw new ModelBuildError(`Entity "${entity}": conflict of an index must be a non-empty text.`);
+  return { conflict: index.conflict };
+}
+
 function validateIndexCondition(entity: string, index: string, where: CheckAst, properties: readonly PropertyModel[]): void {
   validateCheckAst(where, properties, `Entity "${entity}": index "${index}" condition`);
   const byName = new Map(properties.map((property) => [property.propertyName, property]));

package/library/orm/Metadata/decorators.ts

@@ -30,8 +30,6 @@ export interface ColumnOptions {
   readonly name?: string;
   /** Type: physical (`text`, `datetime`, …) or semantic (`uuid`, `createdAt`, `updatedAt`). */
   readonly type?: ColumnOptionsType;
-  /** Allow NULL (default true; `@Required` sets false). */
-  readonly nullable?: boolean;
   /** Closed physical PostgreSQL default. It is not an application initializer or SQL fragment. */
   readonly default?: ColumnDefaultValue;
   /**
@@ -81,6 +79,12 @@ export interface IndexOptions<T extends object = any> {
    * The condition uses the same operators as `@Check`.
    */
   readonly where?: CheckPredicate<T>;
+  /**
+   * For a unique index: what to tell the client when a value is taken. Without it
+   * the answer is the standard text of 409. The names of the properties go to the
+   * details either way.
+   */
+  readonly conflict?: string;
 }
 export interface CompositeKeyOptions { readonly name?: string }
 export type ReferentialAction = "noAction" | "restrict" | "cascade" | "setNull";
@@ -104,7 +108,7 @@ export interface RawProperty {
   default?: ColumnDefaultValue;
   precision?: number;
   scale?: number;
-  index?: { unique: boolean; name?: string; where?: import("../Schema/CheckExpression").CheckAst };
+  index?: { unique: boolean; name?: string; where?: import("../Schema/CheckExpression").CheckAst; conflict?: string };
   /** `@ForeignKey(() => Principal)` on a scalar column, for the DDL FK. */
   fkTarget?: () => EntityClass;
   /** `@HasConversion(...)`: conversion before/after the dialect. */
@@ -136,7 +140,7 @@ export interface RawEntity {
   /** Soft-delete property name (see `@SoftDelete` / `@Entity({ softDelete })`). */
   softDeleteProperty?: string;
   keyDeclaration?: { properties: readonly string[]; name?: string; anchor: string; composite: boolean };
-  indexes?: Array<{ properties: readonly string[]; unique: boolean; name?: string; where?: import("../Schema/CheckExpression").CheckAst }>;
+  indexes?: Array<{ properties: readonly string[]; unique: boolean; name?: string; where?: import("../Schema/CheckExpression").CheckAst; conflict?: string }>;
   foreignKeys?: Array<{ properties: readonly string[]; target: () => EntityClass; name?: string; onDelete?: ReferentialAction; onUpdate?: ReferentialAction }>;
   checks?: Array<{ name: string; expression: import("../Schema/CheckExpression").CheckAst }>;
 }
@@ -297,19 +301,28 @@ export function Column(options: ColumnOptions = {}) {
     prop.default = options.default;
     prop.precision = options.precision;
     prop.scale = options.scale;
-    if (options.nullable !== undefined) {
-      prop.nullable = options.nullable;
-    }
   };
 }
 
-/** NOT NULL. */
+/**
+ * The column is NOT NULL. Every column says whether it may be empty, with this
+ * or with {@link Nullable}: a reader sees it on the column, and a column that
+ * says neither stops the start. Keys and the creation and change timestamps
+ * need no mark: they are always NOT NULL.
+ */
 export function Required() {
   return (_value: undefined, context: ClassFieldDecoratorContext): void => {
     ownProperty(context.metadata, fieldName(context)).required = true;
   };
 }
 
+/** The column allows NULL: the other of the two marks, see {@link Required}. */
+export function Nullable() {
+  return (_value: undefined, context: ClassFieldDecoratorContext): void => {
+    ownProperty(context.metadata, fieldName(context)).nullable = true;
+  };
+}
+
 /** Index on the property's column. */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function Index<T extends object = any>(options?: IndexOptions<T>): (value: undefined, context: ClassFieldDecoratorContext) => void;
@@ -319,13 +332,13 @@ export function Index(first: IndexOptions | readonly [string, ...string[]] = {},
   if (Array.isArray(first)) {
     const where = options.where === undefined ? undefined : compileCheck(options.where);
     return (_value: abstract new (...args: never[]) => unknown, context: ClassDecoratorContext): void => {
-      (ownRaw(context.metadata).indexes ??= []).push({ properties: [...first], unique: options.unique === true, name: options.name, ...(where === undefined ? {} : { where }) });
+      (ownRaw(context.metadata).indexes ??= []).push({ properties: [...first], unique: options.unique === true, name: options.name, ...(where === undefined ? {} : { where }), ...(options.conflict === undefined ? {} : { conflict: options.conflict }) });
     };
   }
   const propertyOptions = first as IndexOptions;
   const where = propertyOptions.where === undefined ? undefined : compileCheck(propertyOptions.where);
   return (_value: undefined, context: ClassFieldDecoratorContext): void => {
-    ownProperty(context.metadata, fieldName(context)).index = { unique: propertyOptions.unique === true, name: propertyOptions.name, ...(where === undefined ? {} : { where }) };
+    ownProperty(context.metadata, fieldName(context)).index = { unique: propertyOptions.unique === true, name: propertyOptions.name, ...(where === undefined ? {} : { where }), ...(propertyOptions.conflict === undefined ? {} : { conflict: propertyOptions.conflict }) };
   };
 }
 

package/library/orm/Metadata/types.ts

@@ -77,6 +77,8 @@ export interface IndexModel {
   readonly unique: boolean;
   /** Partial index condition over property names (`@Index({ where })`). */
   readonly where?: CheckAst;
+  /** What to tell the client when a unique index rejects a value (`@Index({ conflict })`). */
+  readonly conflict?: string;
 }
 export interface CheckModel { readonly name: string; readonly expression: CheckAst }
 

package/library/orm/Transactions/TransactionScopeCoordinator.ts

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import type { DbContext } from "../DbContext";
-import { ConcurrentTransactionScopeError, differentProviderMessage, OrmDatabaseTimeError, OrmProviderIdentityMismatchError, OrmTransactionScopeError, translateDatabaseError } from "../errors";
+import { ConcurrentTransactionScopeError, differentProviderMessage, OrmDatabaseTimeError, OrmProviderIdentityMismatchError, OrmTransactionScopeError, describeViolation, translateDatabaseError, type ViolationModels } from "../errors";
 import { baseProvider, withPostgresScopeOptions, createObservedProvider, postgresTransactionCapability, rootAuthority, withProviderDispatchObserver, withoutProviderDispatchObserver, type CancellableProviderDispatch } from "../Providers/ormTransactionRuntime";
 import type { DatabaseProvider } from "../Providers/types";
 import { OrmTransaction, type OrmDatabaseTimeV1, type OrmTransactionScopeOptions } from "./OrmTransaction";
@@ -84,7 +84,7 @@ export function contextToken(context: object): object {
   return token;
 }
 
-export function observedProvider(context: object, provider: DatabaseProvider): DatabaseProvider {
+export function observedProvider(context: object, provider: DatabaseProvider, models?: ViolationModels): DatabaseProvider {
   contextProviders.set(context, provider);
   const token = contextToken(context);
   const authority = rootAuthority(provider);
@@ -92,7 +92,7 @@ export function observedProvider(context: object, provider: DatabaseProvider): D
     if (uncertainContexts.has(token)) return Promise.reject(new TransactionOutcomeUnknownError());
     // Known SQLSTATEs (unique, foreign key, check, not null, lock timeout)
     // reach the context's caller as ORM errors; the outcome check sees the raw one.
-    const guarded = () => operation().catch((error) => { if (postgresTransactionCapability(provider)?.isOutcomeUncertain?.(error)) uncertainContexts.add(token); throw translateDatabaseError(error); });
+    const guarded = () => operation().catch((error) => { if (postgresTransactionCapability(provider)?.isOutcomeUncertain?.(error)) uncertainContexts.add(token); const translated = translateDatabaseError(error); throw models === undefined ? translated : describeViolation(translated, models); });
     if (!view) return guarded();
     const frame = view.frame;
     if (frame.authority !== authority || !view.enrolled.has(token) || frame.state !== "active" || frame.activeChild !== undefined) {