bazis 0.116.0 → 0.117.1

package/core/http/HttpContext/responseLifetime.ts

@@ -31,7 +31,9 @@ export function holdResponseScope(
     if (signal.aborted && !body.locked) void body.cancel(signal.reason).catch(() => undefined);
     void Promise.resolve().then(dispose).then(complete, reject);
   };
-  cleanup = finished(body, { signal }, finish);
+  // Types only: with the DOM lib (TypeScript's default) Response.body is the
+  // DOM ReadableStream, which node:stream's typings do not list.
+  cleanup = finished(body as unknown as Parameters<typeof finished>[0], { signal }, finish);
 
   // Qualified Bun 1.4 consumes native Blob/file bodies directly: bodyUsed is
   // true, but no JS reader is acquired and its stream never emits finished.

package/core/infra/connectors/codex/CodexAppServerClient.ts

@@ -232,7 +232,7 @@ export class CodexAppServerClient implements CodexClient {
         if (method === "account/updated") this.modelCache = undefined;
       }, () => { this.clearLogin(); this.modelCache = undefined; });
       const initialized = await client.request("initialize", {
-        clientInfo: { name: "bazis", title: "Bazis", version: "0.116.0" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.117.1" }, capabilities: { experimentalApi: true },
       }, 15_000, signal);
       if (resolve(text(initialized.codexHome, 4096)) !== this.paths.home) throw new CodexError("PROTOCOL_ERROR");
       client.notify("initialized");

package/core/kernel/startupFailure.ts

@@ -5,6 +5,8 @@ import { ShutdownTimeoutError, StartupFailuresError, StartupTimeoutError } from
 const MAX_CAUSES = 5;
 /** Properties already printed in the header, the frames or the cause chain. */
 const SHOWN = new Set(["name", "message", "stack", "cause", "code", "errno", "errors", "failures"]);
+/** Where in PostgreSQL's own sources the error was raised: nothing to act on. Hint, detail and the object names stay. */
+const POSTGRES_INTERNALS = new Set(["file", "line", "routine", "severity", "severity_local"]);
 const INSPECT = { depth: null, colors: false, customInspect: false, getters: false, maxArrayLength: null, maxStringLength: null } as const;
 
 /**
@@ -34,7 +36,8 @@ export function formatStartupFailure(error: unknown): string {
     if (!(current instanceof StartupFailuresError)) lines.push(...(current.stack ?? "").split("\n").filter((line) => /^\s+at /.test(line)));
     // Timeouts already say their limit and what was pending in the message.
     const restated = current instanceof StartupTimeoutError || current instanceof ShutdownTimeoutError;
-    const details = restated ? {} : Object.fromEntries(Object.entries(current).filter(([name]) => !SHOWN.has(name)));
+    const internals = current.name === "PostgresError" ? POSTGRES_INTERNALS : undefined;
+    const details = restated ? {} : Object.fromEntries(Object.entries(current).filter(([name]) => !SHOWN.has(name) && !internals?.has(name)));
     if (Object.keys(details).length > 0) lines.push(inspect(redactSensitive(details), INSPECT));
     current = current.cause;
   }

package/core/orm/ownedStoreContributions.ts

@@ -58,6 +58,8 @@ function snapshot<TContext extends DbContext>(context: ContextClass<TContext>, e
   const expected = compileExpectedSchema(new OrmModel(entities));
   if (expected.tables.length === 0 || expected.tables.length > 512) fail("ORM_OWNED_STORE_IDENTITY_MISMATCH", `${storeName(definition)} needs 1 to 512 entities, got ${expected.tables.length}`);
   for (const table of expected.tables) {
+    const decimal = table.columns.find((column) => column.physicalType.startsWith("decimal"));
+    if (decimal) fail("ORM_OWNED_STORE_IDENTITY_MISMATCH", `${storeName(definition)}: column "${decimal.column}" of "${table.table}" is decimal; owned stores do not support decimal columns`);
     const partial = table.indexes.find((index) => index.predicate !== undefined);
     if (partial) fail("ORM_OWNED_STORE_IDENTITY_MISMATCH", `${storeName(definition)}: index "${partial.name}" on "${table.table}" has a where condition; owned stores do not support partial indexes`);
   }

package/library/orm/DatabaseFacade.ts

@@ -5,7 +5,7 @@ import { Migrator, type MigrationResult } from "./Schema/Migrator";
 import { MigrationRunner, type Migration, type VersionedMigrationResult } from "./Schema/MigrationRunner";
 import { SchemaDiffer } from "./Schema/SchemaDiffer";
 import { SchemaAdmissionEngine, type EnsureCreatedResult } from "./Schema/SchemaAdmission";
-import { entityStorageKey } from "./Schema/tableKey";
+import { entityStorageKey, foreignKeyName } from "./Schema/tableKey";
 
 /** Result of `ensureCreated` together with versioned migrations. */
 export interface EnsureCreatedWithMigrationsResult extends EnsureCreatedResult {
@@ -166,7 +166,7 @@ export class DatabaseFacade {
       const constraint: ForeignKeyConstraint = {
         column: columns[0]!.columnName,
         columns: columns.map((column) => column!.columnName),
-        name: fk.name,
+        name: foreignKeyName(model, fk),
         referencedTable: this.referencedTableName(target),
         referencedColumn: target.key[0].columnName,
         referencedColumns: target.key.map((property) => property.columnName),

package/library/orm/Metadata/DynamicModelBuilder.ts

@@ -118,7 +118,7 @@ const LOGICAL_TO_STORAGE: Record<ScalarLogicalFieldType, StorageColumnType> = {
   string: "text",
   int: "integer",
   bigint: "integer",
-  decimal: "real",
+  decimal: "decimal",
   bool: "boolean",
   datetime: "datetime",
   uuid: "text",

package/library/orm/Metadata/ModelBuilder.ts

@@ -9,6 +9,7 @@ import type {
   CheckModel,
   KeyGeneration,
   PropertyModel,
+  StorageColumnType,
   RelationModel,
 } from "./types";
 import type { CanonicalDefault } from "../Schema/introspection";
@@ -261,6 +262,7 @@ export class ModelBuilder {
       raw.nullable === false ||
       resolved.impliedRequired === true;
     const databaseDefault = ModelBuilder.defaultFor(entityName, raw, storageType, isKey, generated, convention, required);
+    const digits = ModelBuilder.decimalDigits(entityName, raw, storageType);
     return {
       propertyName: raw.propertyName,
       columnName: raw.columnName ?? raw.propertyName,
@@ -272,9 +274,24 @@ export class ModelBuilder {
       convention,
       uuidVersion: raw.uuidVersion,
       databaseDefault,
+      ...digits,
     };
   }
 
+  /** `precision`/`scale` belong to `decimal`: 1–1000 digits, scale 0–precision, scale needs precision. */
+  private static decimalDigits(entityName: string, raw: RawProperty, type: StorageColumnType): { precision?: number; scale?: number } {
+    if (type === "decimal" && raw.isKey === true) throw new ModelBuildError(`Entity "${entityName}": key "${raw.propertyName}" cannot be decimal; use an integer, text or UUID key.`);
+    const { precision, scale } = raw;
+    if (precision === undefined && scale === undefined) return {};
+    const where = `Entity "${entityName}": property "${raw.propertyName}"`;
+    if (type !== "decimal") throw new ModelBuildError(`${where}: precision and scale need @Column({ type: "decimal" }).`);
+    if (precision === undefined) throw new ModelBuildError(`${where}: scale needs precision, for example { precision: 12, scale: 2 }.`);
+    if (!Number.isSafeInteger(precision) || precision < 1 || precision > 1000) throw new ModelBuildError(`${where}: precision must be an integer from 1 to 1000.`);
+    const digitsAfter = scale ?? 0;
+    if (!Number.isSafeInteger(digitsAfter) || digitsAfter < 0 || digitsAfter > precision) throw new ModelBuildError(`${where}: scale must be an integer from 0 to precision (${precision}).`);
+    return { precision, scale: digitsAfter };
+  }
+
   private static primaryKeyFor(
     ctor: new () => object,
     raw: NonNullable<ReturnType<typeof readRawEntity>>,

package/library/orm/Metadata/decorators.ts

@@ -34,6 +34,13 @@ export interface ColumnOptions {
   readonly nullable?: boolean;
   /** Closed physical PostgreSQL default. It is not an application initializer or SQL fragment. */
   readonly default?: ColumnDefaultValue;
+  /**
+   * `type: "decimal"` only: the exact `numeric(precision, scale)` column. The
+   * value is a string (`"19.90"`); a value with more digits than declared is
+   * refused instead of being rounded by the database.
+   */
+  readonly precision?: number;
+  readonly scale?: number;
 }
 export type ColumnDefaultValue = null | boolean | number | string;
 
@@ -95,6 +102,8 @@ export interface RawProperty {
   required?: boolean;
   nullable?: boolean;
   default?: ColumnDefaultValue;
+  precision?: number;
+  scale?: number;
   index?: { unique: boolean; name?: string; where?: import("../Schema/CheckExpression").CheckAst };
   /** `@ForeignKey(() => Principal)` on a scalar column, for the DDL FK. */
   fkTarget?: () => EntityClass;
@@ -286,6 +295,8 @@ export function Column(options: ColumnOptions = {}) {
     prop.columnName = options.name;
     prop.type = options.type;
     prop.default = options.default;
+    prop.precision = options.precision;
+    prop.scale = options.scale;
     if (options.nullable !== undefined) {
       prop.nullable = options.nullable;
     }

package/library/orm/Metadata/types.ts

@@ -7,7 +7,7 @@ import type { CanonicalDefault } from "../Schema/introspection";
  * Physical column type in the database (DDL, encode/decode). The provider
  * dialect maps it to the types of a concrete DBMS (`SqlDialect.columnType`).
  */
-export type StorageColumnType = "integer" | "real" | "text" | "boolean" | "datetime" | "json";
+export type StorageColumnType = "integer" | "real" | "decimal" | "text" | "boolean" | "datetime" | "json";
 
 /**
  * Semantic `@Column({ type })` types with automatic behavior on `SaveChanges`.
@@ -63,6 +63,9 @@ export interface PropertyModel {
   readonly convention?: PropertyConvention;
   /** UUID version for `@UUID` (default v4). */
   readonly uuidVersion?: "v4" | "v7";
+  /** `decimal`: total digits and digits after the point (`numeric(precision, scale)`); absent for plain `numeric`. */
+  readonly precision?: number;
+  readonly scale?: number;
   /** Closed physical database default; it never affects entity initialization. */
   readonly databaseDefault: CanonicalDefault;
 }

package/library/orm/Providers/PostgresDialect.ts

@@ -2,7 +2,8 @@ import type { ColumnType, EntityModel, IndexModel, PropertyModel } from "../Meta
 import type { ForeignKeyConstraint, RowLockMode, SqlDialect, SqlParam } from "./types";
 import { projectCheckAstIdentifiers, renderCheck } from "../Schema/CheckExpression";
 import { resolvedForeignKey } from "./resolvedForeignKey";
-import { physicalTableIdentity } from "../Schema/tableKey";
+import { physicalTableIdentity, primaryKeyName } from "../Schema/tableKey";
+import { decimalParameter } from "./decimalValue";
 
 const jsonScalarParameters = new WeakSet<object>();
 
@@ -55,6 +56,8 @@ export class PostgresDialect implements SqlDialect {
       case "integer":
       case "real":
         return typeof value === "bigint" ? value : Number(value);
+      case "decimal":
+        return decimalParameter(value);
       case "text":
         return typeof value === "string" ? value : String(value);
     }
@@ -78,6 +81,9 @@ export class PostgresDialect implements SqlDialect {
         return typeof value === "bigint" ? value : Number(value);
       case "real":
         return Number(value);
+      case "decimal":
+        // Exact: PostgreSQL numeric stays a string, never a float.
+        return typeof value === "string" ? value : String(value);
       case "text":
         return typeof value === "string" ? value : String(value);
     }
@@ -106,12 +112,14 @@ export class PostgresDialect implements SqlDialect {
     return `$${index + 1}`;
   }
 
-  columnType(type: ColumnType): string {
+  columnType(type: ColumnType, property?: PropertyModel): string {
     switch (type) {
       case "integer":
         return "bigint";
       case "real":
         return "double precision";
+      case "decimal":
+        return property?.precision === undefined ? "numeric" : `numeric(${property.precision}, ${property.scale ?? 0})`;
       case "boolean":
         return "boolean";
       case "datetime":
@@ -124,27 +132,29 @@ export class PostgresDialect implements SqlDialect {
   }
 
   createTableSql(model: EntityModel, foreignKeys: readonly ForeignKeyConstraint[]): string {
+    // The same name ensureCreated expects, not PostgreSQL's "<table>_pkey".
+    const primaryKey = `CONSTRAINT ${this.quoteId(primaryKeyName(model))} PRIMARY KEY`;
     const columns = model.properties.map((property) => {
       if (model.key.length === 1 && property.isKey && property.generation === "identity") {
         // BY DEFAULT allows inserting an explicit key when needed.
-        return `${this.quoteId(property.columnName)} bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY`;
+        return `${this.quoteId(property.columnName)} bigint GENERATED BY DEFAULT AS IDENTITY ${primaryKey}`;
       }
       if (model.key.length === 1 && property.isKey && property.generation === "uuid") {
-        return `${this.quoteId(property.columnName)} uuid NOT NULL DEFAULT gen_random_uuid() PRIMARY KEY`;
+        return `${this.quoteId(property.columnName)} uuid NOT NULL DEFAULT gen_random_uuid() ${primaryKey}`;
       }
       if (model.key.length === 1 && property.isKey && property.generation === "uuidV7") {
         // The ORM assigns the v7 value before INSERT, so the column has no default.
-        return `${this.quoteId(property.columnName)} uuid NOT NULL PRIMARY KEY`;
+        return `${this.quoteId(property.columnName)} uuid NOT NULL ${primaryKey}`;
       }
       const foreignKey = foreignKeys.find((candidate) => (candidate.columns ?? [candidate.column]).includes(property.columnName));
-      const parts = [this.quoteId(property.columnName), this.ddlColumnType(this.foreignKeyColumnType(foreignKey, property))];
+      const parts = [this.quoteId(property.columnName), this.ddlColumnType(this.foreignKeyColumnType(foreignKey, property), property)];
       if (property.required) {
         parts.push("NOT NULL");
       }
       return parts.join(" ");
     });
     if (model.key.length > 1 || model.key[0].generation === "none") {
-      columns.push(`PRIMARY KEY (${model.key.map((key) => this.quoteId(key.columnName)).join(", ")})`);
+      columns.push(`${primaryKey} (${model.key.map((key) => this.quoteId(key.columnName)).join(", ")})`);
     }
     for (const check of model.checks) columns.push(`CONSTRAINT ${this.quoteId(check.name)} CHECK (${renderCheck(projectCheckAstIdentifiers(check.expression, (name) => model.propertyByName(name)!.columnName), (name) => this.quoteId(name))})`);
     for (const fk of foreignKeys) {
@@ -175,7 +185,7 @@ export class PostgresDialect implements SqlDialect {
     const parts = [
       `ALTER TABLE ${this.qualifyTable(model)} ADD COLUMN IF NOT EXISTS`,
       this.quoteId(property.columnName),
-      this.ddlColumnType(this.foreignKeyColumnType(foreignKey, property)),
+      this.ddlColumnType(this.foreignKeyColumnType(foreignKey, property), property),
     ];
     if (property.required) {
       // An invented FK value (0/empty UUID) cannot safely backfill existing rows.
@@ -197,6 +207,7 @@ export class PostgresDialect implements SqlDialect {
     switch (type) {
       case "integer":
       case "real":
+      case "decimal":
         return "0";
       case "boolean":
         return "false";
@@ -209,8 +220,8 @@ export class PostgresDialect implements SqlDialect {
     }
   }
 
-  private ddlColumnType(type: ColumnType | "uuid"): string {
-    return type === "uuid" ? "uuid" : this.columnType(type);
+  private ddlColumnType(type: ColumnType | "uuid", property?: PropertyModel): string {
+    return type === "uuid" ? "uuid" : this.columnType(type, property);
   }
 
   private foreignKeyColumnType(fk: ForeignKeyConstraint | undefined, property: PropertyModel): ColumnType | "uuid" {
@@ -233,3 +244,4 @@ export function renderPostgresSkipLocked(dialect: SqlDialect): string {
   }
   return " SKIP LOCKED";
 }
+

package/library/orm/Providers/PostgresSchema.decoder.ts

@@ -9,10 +9,12 @@ export function canonicalPostgresColumn(type: string, defaultExpression: string
   return { physicalType, default: defaultValue.value, generation, unsupported: physicalType === "unknown" || defaultValue.unsupported || (identity !== "" && identity !== "d") };
 }
 
-export function canonicalPostgresType(type: string): "integer" | "real" | "text" | "boolean" | "datetime" | "json" | "uuid" | "unknown" {
+export function canonicalPostgresType(type: string): "integer" | "real" | "text" | "boolean" | "datetime" | "json" | "uuid" | "decimal" | `decimal(${number},${number})` | "unknown" {
+  const numeric = type.trim().toLowerCase().match(/^numeric(?:\((\d+),\s*(\d+)\))?$/u);
+  if (numeric) return numeric[1] === undefined ? "decimal" : `decimal(${Number(numeric[1])},${Number(numeric[2])})`;
   switch (type.trim().toLowerCase()) {
     case "smallint": case "integer": case "bigint": return "integer";
-    case "real": case "double precision": case "numeric": return "real";
+    case "real": case "double precision": return "real";
     case "text": case "character varying": case "character": return "text";
     case "boolean": return "boolean";
     case "timestamp with time zone": return "datetime";
@@ -25,6 +27,8 @@ export function canonicalPostgresType(type: string): "integer" | "real" | "text"
 /** Exact admission accepts only the physical spellings rendered by PostgresDialect. */
 export function exactPostgresType(type: string, canonical: IntrospectedColumn["physicalType"]): IntrospectedColumn["physicalType"] {
   const raw = type.trim().toLowerCase();
+  // numeric and numeric(p,s) are the spellings PostgresDialect renders for decimal.
+  if (/^numeric(?:\(\d+,\s*\d+\))?$/u.test(raw)) return canonical;
   switch (raw) {
     case "bigint": case "double precision": case "text": case "boolean": case "timestamp with time zone": case "jsonb": case "uuid": return canonical;
     default: return `${canonical ?? "unknown"}:${raw}`;

package/library/orm/Providers/decimalValue.ts

@@ -0,0 +1,37 @@
+import { OrmError } from "../errors";
+import type { PropertyModel } from "../Metadata/types";
+
+const DECIMAL_TEXT = /^([+-]?)(\d+)(?:\.(\d+))?$/u;
+
+/**
+ * A decimal is written as text so no digit is lost: a string such as "19.90"
+ * or "-0.5", a bigint, or a safe integer. A float like 0.1 is refused because
+ * it is already inexact.
+ */
+export function decimalText(value: unknown): string | undefined {
+  if (typeof value === "bigint" || (typeof value === "number" && Number.isSafeInteger(value))) return String(value);
+  return typeof value === "string" && DECIMAL_TEXT.test(value) ? value : undefined;
+}
+
+/** The parameter for a decimal column; anything that is not an exact decimal is refused. */
+export function decimalParameter(value: unknown): string {
+  const text = decimalText(value);
+  if (text !== undefined) return text;
+  throw new OrmError(`A decimal value must be a string such as "19.90" (or an integer), got ${typeof value === "string" ? JSON.stringify(value.slice(0, 40)) : typeof value}.`);
+}
+
+/**
+ * Before a write: a value with more digits than `numeric(precision, scale)`
+ * allows is refused, because PostgreSQL would round the fraction silently.
+ * Trailing zeros after the point do not count ("1.500" fits scale 2).
+ */
+export function assertDecimalFits(owner: string, property: PropertyModel, value: unknown): void {
+  if (property.type !== "decimal" || property.precision === undefined || value === null || value === undefined) return;
+  const match = decimalParameter(value).match(DECIMAL_TEXT)!;
+  const whole = match[2]!.replace(/^0+(?=\d)/u, "");
+  const fraction = (match[3] ?? "").replace(/0+$/u, "");
+  const scale = property.scale ?? 0;
+  const where = `${owner}.${property.propertyName}`;
+  if (fraction.length > scale) throw new OrmError(`${where}: "${value}" has ${fraction.length} digits after the point; numeric(${property.precision}, ${scale}) keeps ${scale}. Round it in the code.`);
+  if ((whole === "0" ? 0 : whole.length) > property.precision - scale) throw new OrmError(`${where}: "${value}" does not fit numeric(${property.precision}, ${scale}): at most ${property.precision - scale} digits before the point.`);
+}

package/library/orm/Providers/types.ts

@@ -91,7 +91,7 @@ export interface SqlDialect {
   /** PostgreSQL parameter placeholder by index (0-based): `$1`, `$2`, …. */
   parameter(index: number): string;
   /** Column type in DDL. */
-  columnType(type: ColumnType): string;
+  columnType(type: ColumnType, property?: PropertyModel): string;
   /** Whether `INSERT ... RETURNING` is supported. */
   readonly supportsReturning: boolean;
   /** Encodes a property value into a query parameter for this DBMS. */

package/library/orm/Query/ImmediateMutations.ts

@@ -2,6 +2,7 @@ import { types } from "node:util";
 import { OrmError, OrmTrackedMutationConflictError, OrmUndeclaredConflictTargetError, OrmUnsafeImmediateMutationError } from "../errors";
 import { isDatabaseGenerated, type EntityModel, type PropertyModel } from "../Metadata/types";
 import { convertsValue } from "../Providers/propertyConversion";
+import { assertDecimalFits, decimalText } from "../Providers/decimalValue";
 import type { DbContextRuntime } from "../runtime";
 import { hasTrackedEntriesForModel } from "../Tracking/ChangeTracker";
 import { isPostgresJsonScalarParameter } from "../Providers/PostgresDialect";
@@ -19,7 +20,7 @@ export type OrmUniqueKeySelectorV1<T extends object> = (entity: FieldSelector<T>
 export function executeImmediateUpdate<T extends object>(model: EntityModel, runtime: DbContextRuntime, plan: QueryPlan, values: OrmUpdateValuesV1<T>): Promise<OrmMutationResultV1> {
   return runtime.runImmediateOperation(async () => {
     guard(model, runtime); const admittedPlan = admitPlan(plan, "executeUpdate");
-    const conditions = effectiveConditions(model, admittedPlan, runtime); const assignments = encodeAssignments(runtime, admitUpdateValues(model, values));
+    const conditions = effectiveConditions(model, admittedPlan, runtime); const assignments = encodeAssignments(runtime, model, admitUpdateValues(model, values));
     const compiled = new SqlTranslator(model, runtime.provider.dialect).immediateUpdate(assignments, conditions, (property, value) => encode(runtime, property, snapshot(value), true));
     Object.freeze(compiled.params);
     guard(model, runtime);
@@ -42,7 +43,7 @@ export function executeImmediateDelete(model: EntityModel, runtime: DbContextRun
 export function insertIfAbsent<T extends object>(model: EntityModel, runtime: DbContextRuntime, entity: T, options: { readonly conflictBy: OrmUniqueKeySelectorV1<T> }): Promise<OrmInsertIfAbsentResultV1> {
   return runtime.runImmediateOperation(async () => {
     guard(model, runtime); if (runtime.provider.dialect.name !== "postgres") unsafe();
-    const admitted = admitInsertValues(model, entity); const columns = conflictTarget(model, options); const values = encodeAssignments(runtime, admitted);
+    const admitted = admitInsertValues(model, entity); const columns = conflictTarget(model, options); const values = encodeAssignments(runtime, model, admitted);
     const compiled = new SqlTranslator(model, runtime.provider.dialect).immediateInsert(values, columns);
     Object.freeze(compiled.params);
     guard(model, runtime);
@@ -136,7 +137,8 @@ function admitInsertValues<T extends object>(model: EntityModel, entity: T): rea
   return Object.freeze(out.map((value) => Object.freeze(value)));
 }
 function unsetKey(value: unknown): boolean { return value === undefined || value === null || value === "" || value === 0; }
-function encodeAssignments(runtime: DbContextRuntime, assignments: readonly AdmittedAssignment[]): readonly { readonly property: PropertyModel; readonly value: SqlParam }[] {
+function encodeAssignments(runtime: DbContextRuntime, model: EntityModel, assignments: readonly AdmittedAssignment[]): readonly { readonly property: PropertyModel; readonly value: SqlParam }[] {
+  for (const { property, value } of assignments) if (!property.converter && decimalText(value) !== undefined) assertDecimalFits(model.name, property, value);
   return Object.freeze(assignments.map(({ property, value }) => Object.freeze({ property, value: value === null && !convertsValue(property, null) ? null : encode(runtime, property, value) })));
 }
 function encode(runtime: DbContextRuntime, property: PropertyModel, input: unknown, allowNull = false): SqlParam {
@@ -248,6 +250,7 @@ function storageValue(value: unknown, type: PropertyModel["type"], allowNull = f
   if (type === "boolean" && typeof safe !== "boolean") unsafe();
   if (type === "integer" && !(typeof safe === "bigint" ? safe >= -9223372036854775808n && safe <= 9223372036854775807n : typeof safe === "number" && Number.isSafeInteger(safe))) unsafe();
   if (type === "real" && !(typeof safe === "number" && Number.isFinite(safe))) unsafe();
+  if (type === "decimal" && decimalText(safe) === undefined) unsafe();
   if (type === "datetime" && (typeof safe !== "object" || safe === null || Object.getPrototypeOf(safe) !== capturedDatePrototype)) unsafe();
   if (type === "json" && !jsonValue(safe)) unsafe();
   return safe as SqlParam;

package/library/orm/Saving/CommandBuilder.ts

@@ -1,6 +1,7 @@
 import { isDatabaseGenerated, type EntityModel, type PropertyModel } from "../Metadata/types";
 import type { SqlDialect, SqlParam } from "../Providers/types";
 import { encodeProperty } from "../Providers/propertyConversion";
+import { assertDecimalFits } from "../Providers/decimalValue";
 import { EntityState } from "../Tracking/EntityState";
 import type { TrackedEntry } from "../Tracking/ChangeTracker";
 
@@ -56,7 +57,7 @@ export class CommandBuilder {
     const tuples = entities.map((entity) => {
       const placeholders = columns.map((property) => {
         const placeholder = this.dialect.parameter(params.length);
-        params.push(encodeProperty(property, entity[property.propertyName], this.dialect));
+        params.push(this.written(model, property, entity[property.propertyName]));
         return placeholder;
       });
       return `(${placeholders.join(", ")})`;
@@ -99,7 +100,7 @@ export class CommandBuilder {
     const params: SqlParam[] = [];
     const assignments = columns.map((property) => {
       const placeholder = this.dialect.parameter(params.length);
-      params.push(encodeProperty(property, entity[property.propertyName], this.dialect));
+      params.push(this.written(model, property, entity[property.propertyName]));
       return `${this.dialect.quoteId(property.columnName)} = ${placeholder}`;
     });
     const where = this.keyPredicate(model, entity, params);
@@ -109,6 +110,12 @@ export class CommandBuilder {
     return { sql, params };
   }
 
+  /** A written value; a decimal that would lose digits is refused before SQL. */
+  private written(model: EntityModel, property: PropertyModel, value: unknown): SqlParam {
+    if (!property.converter) assertDecimalFits(model.name, property, value);
+    return encodeProperty(property, value, this.dialect);
+  }
+
   private delete(entity: Record<string, unknown>, model: EntityModel): DbCommand {
     const params: SqlParam[] = [];
     const sql = `DELETE FROM ${this.dialect.qualifyTable(model)} WHERE ${this.keyPredicate(model, entity, params)}`;

package/library/orm/Schema/ExpectedSchema.ts

@@ -1,10 +1,10 @@
-import type { EntityModel } from "../Metadata/types";
+import type { EntityModel, PropertyModel } from "../Metadata/types";
 import type { OrmModel } from "../Metadata/OrmModel";
 import type { CanonicalDefault, GenerationStrategy } from "./introspection";
 import { projectCheckAstIdentifiers, type CheckAst } from "./CheckExpression";
 import { crossUnitForeignKey, physicalColumnTypes } from "./physicalColumnTypes";
 import { SchemaAdmissionError } from "../errors";
-import { physicalTableIdentity } from "./tableKey";
+import { foreignKeyName, physicalTableIdentity, primaryKeyName } from "./tableKey";
 
 export interface ExpectedColumn { readonly property: string; readonly column: string; readonly physicalType: string; readonly nullable: boolean; readonly default: CanonicalDefault; readonly generation: GenerationStrategy }
 export interface ExpectedTable { readonly schema: string; readonly table: string; readonly columns: readonly ExpectedColumn[]; readonly primaryKey: { readonly name: string; readonly columns: readonly string[] }; readonly indexes: readonly { readonly name: string; readonly columns: readonly string[]; readonly unique: boolean; readonly method: "btree"; readonly predicate?: CheckAst }[]; readonly foreignKeys: readonly { readonly name: string; readonly columns: readonly string[]; readonly target: { readonly schema: string; readonly table: string }; readonly targetColumns: readonly string[]; readonly onDelete: string; readonly onUpdate: string }[]; readonly checks: readonly { readonly name: string; readonly expression: unknown }[] }
@@ -31,7 +31,7 @@ function compileTable(model: EntityModel, byCtor: ReadonlyMap<EntityModel["ctor"
   const columns = model.properties.map((property) => ({
     property: property.propertyName,
     column: property.columnName,
-    physicalType: types.get(property)!,
+    physicalType: property.type === "decimal" ? decimalPhysicalType(property) : types.get(property)!,
     nullable: !property.required,
     default: property.databaseDefault,
     generation: property.generation === "identity" ? "identityByDefault" as const : property.generation === "uuid" ? "uuidDefault" as const : "none" as const,
@@ -39,7 +39,12 @@ function compileTable(model: EntityModel, byCtor: ReadonlyMap<EntityModel["ctor"
   const foreignKeys = model.foreignKeys.map((foreignKey) => {
     const target = byCtor.get(foreignKey.target());
     if (!target) throw crossUnitForeignKey(model, foreignKey.properties, foreignKey.target());
-    return { name: foreignKey.name ?? `fk_${table}_${foreignKey.properties.join("_")}`, columns: foreignKey.properties.map((name) => model.propertyByName(name)!.columnName), target: { schema: schemaOf(target), table: physicalTableIdentity(target).table }, targetColumns: target.key.map((property) => property.columnName), onDelete: foreignKey.onDelete, onUpdate: foreignKey.onUpdate };
+    return { name: foreignKeyName(model, foreignKey), columns: foreignKey.properties.map((name) => model.propertyByName(name)!.columnName), target: { schema: schemaOf(target), table: physicalTableIdentity(target).table }, targetColumns: target.key.map((property) => property.columnName), onDelete: foreignKey.onDelete, onUpdate: foreignKey.onUpdate };
   });
-  return Object.freeze({ schema, table, columns: Object.freeze(columns), primaryKey: Object.freeze({ name: model.keyName ?? `pk_${table}`, columns: Object.freeze(model.key.map((property) => property.columnName)) }), indexes: Object.freeze(model.indexes.map((index) => Object.freeze({ name: index.name, columns: Object.freeze([...index.columns]), unique: index.unique, method: "btree" as const, ...(index.where === undefined ? {} : { predicate: projectCheckAstIdentifiers(index.where, (name) => model.propertyByName(name)!.columnName) }) }))), foreignKeys: Object.freeze(foreignKeys), checks: Object.freeze(model.checks.map((check) => Object.freeze({ name: check.name, expression: projectCheckAstIdentifiers(check.expression, (name) => model.propertyByName(name)!.columnName) }))) });
+  return Object.freeze({ schema, table, columns: Object.freeze(columns), primaryKey: Object.freeze({ name: primaryKeyName(model), columns: Object.freeze(model.key.map((property) => property.columnName)) }), indexes: Object.freeze(model.indexes.map((index) => Object.freeze({ name: index.name, columns: Object.freeze([...index.columns]), unique: index.unique, method: "btree" as const, ...(index.where === undefined ? {} : { predicate: projectCheckAstIdentifiers(index.where, (name) => model.propertyByName(name)!.columnName) }) }))), foreignKeys: Object.freeze(foreignKeys), checks: Object.freeze(model.checks.map((check) => Object.freeze({ name: check.name, expression: projectCheckAstIdentifiers(check.expression, (name) => model.propertyByName(name)!.columnName) }))) });
+}
+
+/** `decimal(12,2)` for numeric(12, 2), `decimal` for an unbounded numeric: the catalog reports the same label. */
+export function decimalPhysicalType(property: Pick<PropertyModel, "precision" | "scale">): string {
+  return property.precision === undefined ? "decimal" : `decimal(${property.precision},${property.scale ?? 0})`;
 }

package/library/orm/Schema/SafeAdditiveSchema.ts

@@ -94,7 +94,11 @@ function literal(value: ExpectedColumn["default"], physicalType: string): string
   }
   switch (value.kind) { case "null": return "NULL"; case "boolean": return value.value ? "TRUE" : "FALSE"; case "number": return String(value.value); case "string": return `'${value.value.replaceAll("'", "''")}'`; case "uuidV4": return "gen_random_uuid()"; default: throw new Error("Unrenderable PostgreSQL schema default."); }
 }
-function type(value: string): string { return value === "integer" ? "bigint" : value === "real" ? "double precision" : value === "datetime" ? "timestamptz" : value === "json" ? "jsonb" : value; }
+function type(value: string): string {
+  const decimal = value.match(/^decimal(?:\((\d+),(\d+)\))?$/u);
+  if (decimal) return decimal[1] === undefined ? "numeric" : `numeric(${decimal[1]}, ${decimal[2]})`;
+  return value === "integer" ? "bigint" : value === "real" ? "double precision" : value === "datetime" ? "timestamptz" : value === "json" ? "jsonb" : value;
+}
 function q(value: string): string { return `"${value.replaceAll('"', '""')}"`; }
 function tableName(table: Pick<ExpectedTable, "schema" | "table">): string { return `${q(table.schema)}.${q(table.table)}`; }
 function action(value: string): string { return value === "noAction" ? "NO ACTION" : value === "setNull" ? "SET NULL" : value.toUpperCase(); }

package/library/orm/Schema/tableKey.ts

@@ -24,3 +24,13 @@ export function entityStorageKey(model: EntityModel): string {
 export function introspectedTableKey(schema: string, table: string): string {
   return schema === "public" ? table : `${schema}.${table}`;
 }
+
+/** `pk_<table>` unless the key is named; ensureCreated and migrate() name the primary key the same way. */
+export function primaryKeyName(model: EntityModel): string {
+  return model.keyName ?? `pk_${physicalTableIdentity(model).table}`;
+}
+
+/** `fk_<table>_<properties>` unless the foreign key is named, for every way a table is created. */
+export function foreignKeyName(model: EntityModel, foreignKey: { readonly name?: string; readonly properties: readonly string[] }): string {
+  return foreignKey.name ?? `fk_${physicalTableIdentity(model).table}_${foreignKey.properties.join("_")}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bazis",
-  "version": "0.116.0",
+  "version": "0.117.1",
   "description": "Modular backend framework for Bun in TypeScript: DI wired by codegen, HTTP, a PostgreSQL ORM, JWT, WebSocket, agents and a CLI.",
   "license": "MIT",
   "author": "Alexander Alenin",