bazis 0.117.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.117.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/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/Providers/PostgresDialect.ts

@@ -2,7 +2,7 @@ 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>();
@@ -132,17 +132,19 @@ 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), property)];
@@ -152,7 +154,7 @@ export class PostgresDialect implements SqlDialect {
       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) {

package/library/orm/Schema/ExpectedSchema.ts

@@ -4,7 +4,7 @@ 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 }[] }
@@ -39,9 +39,9 @@ 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. */

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.117.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",