bazis 0.117.0 → 0.118.0

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.118.0" }, 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/config/Secret.ts

@@ -1,3 +1,5 @@
+import { rememberSecretValue } from "../../../library/redaction";
+
 const REDACTED = "***";
 
 /**
@@ -9,6 +11,8 @@ export class Secret {
 
   public constructor(value: string) {
     this.#value = value;
+    // Logs and errors drop the value even where it was pasted as plain text.
+    rememberSecretValue(value);
   }
 
   public reveal(): string {

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/OwnedStoreCatalog.ts

@@ -607,7 +607,7 @@ function row(v: unknown): OwnedStoreRegistryRowV1 {
     bad();
   return Object.freeze(out as OwnedStoreRegistryRowV1);
 }
-export function validateOwnedStoreRegistryV1(rows: unknown, defs: readonly OrmOwnedStoreDefinitionV1[]): readonly OwnedStoreRegistryRowV1[] {
+export function validateOwnedStoreRegistryV1(rows: unknown, _defs: readonly OrmOwnedStoreDefinitionV1[]): readonly OwnedStoreRegistryRowV1[] {
   const out = dense(rows, row, 4096);
   const keys = new Set<string>();
   for (const x of out) {
@@ -619,9 +619,9 @@ export function validateOwnedStoreRegistryV1(rows: unknown, defs: readonly OrmOw
     if (keys.has(x.storeKey))
       throw failure("ORM_OWNED_STORE_OWNERSHIP_CONFLICT");
     keys.add(x.storeKey);
-    const d = defs.find(y => y.storeKey === x.storeKey);
-    if (d && (x.formatVersion !== String(d.formatVersion) || x.ownedSchema !== d.ownedScope.schema || x.tablePrefix !== d.ownedScope.tablePrefix))
-      throw failure("ORM_OWNED_STORE_IDENTITY_MISMATCH");
+    // A row that differs from the code (format version, scope) is refused by
+    // admission's assertCurrent, after the row is recorded for the explainer,
+    // so the message can name what changed.
   }
   for (let i = 0; i < out.length; i++)
     for (let j = i + 1; j < out.length; j++) {

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/library/redaction/index.ts

@@ -47,6 +47,42 @@ export function redactTraceValues<T>(values: readonly T[], options: SensitiveRed
   return values.map(() => replacement);
 }
 
+/** Values shorter than this are not remembered: masking them would hide ordinary words ("postgres"). */
+export const MIN_REMEMBERED_SECRET_LENGTH = 10;
+const rememberedSecrets = new Set<string>();
+let longestFirst: readonly string[] = [];
+
+/**
+ * Remembers a secret value: from now on every redaction removes it wherever it
+ * appears, also in plain text without a marker such as `password=`. `Secret`
+ * calls it for every configuration secret. Process-wide; values shorter than
+ * {@link MIN_REMEMBERED_SECRET_LENGTH} are recognised only by their shape.
+ */
+export function rememberSecretValue(value: string): void {
+  // A connection URL keeps naming its server: only its password is the secret,
+  // and the userinfo pattern already hides user:password@ in the URL itself.
+  const password = urlPassword(value);
+  if (password !== undefined) {
+    if (password !== "") rememberSecretValue(password);
+    return;
+  }
+  if (value.length < MIN_REMEMBERED_SECRET_LENGTH || rememberedSecrets.has(value)) return;
+  rememberedSecrets.add(value);
+  // A longer value first, so a secret that contains another one goes whole.
+  longestFirst = [...rememberedSecrets].sort((left, right) => right.length - left.length);
+}
+
+/** The decoded password of a URL with userinfo (`""` for user only), or undefined for other values. */
+function urlPassword(value: string): string | undefined {
+  if (!/^[a-z][a-z0-9+.-]*:\/\/[^\s/?#@]+@/i.test(value)) return undefined;
+  try {
+    const url = new URL(value);
+    return decodeURIComponent(url.password);
+  } catch {
+    return undefined;
+  }
+}
+
 export function isSensitiveKey(key: string, options: SensitiveRedactionOptions = {}): boolean {
   return keyIsSensitive(key, normalizeOptions(options));
 }
@@ -177,7 +213,9 @@ function normalizeKey(key: string): string {
 }
 
 function redactText(value: string, replacement: string): string {
-  return value
+  let text = value;
+  for (const secret of longestFirst) if (text.includes(secret)) text = text.replaceAll(secret, replacement);
+  return text
     .replace(SECRET_TEXT_PATTERN, (_match, name: string, separator: string) => `${name}${separator}${replacement}`)
     .replace(BEARER_TEXT_PATTERN, (_match, scheme: string) => `${scheme} ${replacement}`)
     .replace(URL_USERINFO_PATTERN, (_match, scheme: string, userinfo: string) =>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bazis",
-  "version": "0.117.0",
+  "version": "0.118.0",
   "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",