bazis 0.98.11 → 0.98.12

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.98.11" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.98.12" }, 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/defineConfig.ts

@@ -154,18 +154,22 @@ export function defineConfig(prefixOrSchema: string | ConfigSchema<Defaults>, ma
     const values = new Map<string, ConfigValueType>();
     const inspection: ConfigInspection[] = [];
     const issues: string[] = [];
+    // A wrong value names what came and where to change it: the variable that
+    // supplied it, or the variables that can override the value from the code.
+    const got = (raw: unknown) => raw === undefined ? "" : `, got ${JSON.stringify(String(raw)).slice(0, 80)}`;
+    const source = (key: string, selected: { readonly name: string } | undefined) => ` (${selected ? selected.name : names.get(key)!.join(", ")})`;
     for (const key of keys) {
       const base = schema.default[key]!;
       const override = schema[environment]?.[key];
       const cell = override ?? base;
       const type = isSecret(base) ? "secret" : isEnum(base) ? typeof base.default : typeof base;
-      const candidates: { raw: string; source: string; priority: number }[] = [];
+      const candidates: { raw: string; source: string; priority: number; name: string }[] = [];
       for (const name of names.get(key)!) {
         const sourceKey = name.slice(ENV_PREFIX.length).toLowerCase().replaceAll("__", ".");
         const raw = configuration.get(sourceKey);
         if (raw === undefined) continue;
         const origin = configuration.origin(sourceKey);
-        candidates.push({ raw, ...origin });
+        candidates.push({ raw, ...origin, name });
       }
       const priority = Math.max(...candidates.map(candidate => candidate.priority));
       const winners = candidates.filter(candidate => candidate.priority === priority);
@@ -178,17 +182,17 @@ export function defineConfig(prefixOrSchema: string | ConfigSchema<Defaults>, ma
         else value = new Secret(raw);
       } else if (type === "number") {
         const parsed = Number(raw);
-        if (raw === undefined || (typeof raw === "string" && !raw.trim()) || !Number.isFinite(parsed)) issues.push(`${fullKey(key)} — expected a finite number`);
+        if (raw === undefined || (typeof raw === "string" && !raw.trim()) || !Number.isFinite(parsed)) issues.push(`${fullKey(key)} — expected a finite number${got(raw)}${source(key, selected)}`);
         else value = parsed;
       } else if (type === "boolean") {
         const normalized = String(raw).toLowerCase();
         if (normalized === "true" || normalized === "1") value = true;
         else if (normalized === "false" || normalized === "0") value = false;
-        else issues.push(`${fullKey(key)} — expected a boolean`);
+        else issues.push(`${fullKey(key)} — expected a boolean (true, false, 1, 0)${got(raw)}${source(key, selected)}`);
       } else if (typeof raw === "string") value = raw;
       else issues.push(`${fullKey(key)} — expected a string`);
       if (value === undefined) continue;
-      if (isEnum(base) && !base.values.includes(value as string | number)) issues.push(`${fullKey(key)} — value is not one of the declared enum values`);
+      if (isEnum(base) && !base.values.includes(value as string | number)) issues.push(`${fullKey(key)} — ${JSON.stringify(value)} is not allowed, use one of: ${base.values.join(", ")}${source(key, selected)}`);
       try {
         const issue = validators[key]?.(value);
         if (issue) issues.push(`${fullKey(key)} — ${issue}`);

package/core/orm/databaseConnector.ts

@@ -1,4 +1,4 @@
-import { InfraError, reader, requireValue, postgresConnectionOptions, type InfraConnector, type PostgresConfigShape } from "../infra";
+import { errorMessage, InfraError, reader, requireValue, postgresConnectionOptions, type InfraConnector, type PostgresConfigShape } from "../infra";
 import type { AppConfig, ConfigRegistry } from "../kernel";
 import { postgres, type DatabaseProvider, type PostgresServerTimeouts } from "../../library/orm";
 import { DATABASE_PROVIDER } from "./DATABASE_PROVIDER";
@@ -86,16 +86,26 @@ export function ormBazisConnect<T extends PostgresOrmConfigShape>(config: AppCon
 export function ormBazisConnect(
   config: AppConfig<PostgresOrmConfigShape>,
 ): InfraConnector<DatabaseProvider> {
+  // Where the connection goes, for the startup error; never the password.
+  let target = "PostgreSQL";
   return {
     token: DATABASE_PROVIDER,
     config,
     phase: DATABASE_PHASE,
     create(configs) {
+      const c = reader(config, configs);
+      target = `PostgreSQL at ${String(c.get("host"))}:${String(c.get("port"))} (database "${String(c.get("database"))}", user "${String(c.get("username"))}")`;
       return buildPostgresProvider(config, configs);
     },
     async connect(provider, signal) {
-      if (!(await provider.ping(signal))) {
-        throw new InfraError('Infra connector "database": postgres is not reachable.');
+      if (provider.probe === undefined) {
+        if (!(await provider.ping(signal))) throw new InfraError(`Infra connector "database": cannot connect to ${target}.`);
+        return;
+      }
+      try {
+        await provider.probe(signal);
+      } catch (error) {
+        throw new InfraError(`Infra connector "database": cannot connect to ${target}: ${connectionFailure(error)}`);
       }
     },
     async dispose(provider) {
@@ -106,3 +116,12 @@ export function ormBazisConnect(
     },
   };
 }
+
+/** The driver's reason with its code: `password authentication failed for user "app" (28P01)`. */
+function connectionFailure(error: unknown): string {
+  const details = error as { errno?: unknown; code?: unknown };
+  const code = typeof details.errno === "string" && details.errno ? details.errno
+    : typeof details.code === "string" && details.code ? details.code : undefined;
+  const message = errorMessage(error);
+  return code === undefined || message.includes(code) ? message : `${message} (${code})`;
+}

package/library/orm/Providers/PostgresProvider.ts

@@ -409,13 +409,17 @@ export class PostgresProvider implements DatabaseProvider {
 
   async ping(signal?: AbortSignal): Promise<boolean> {
     try {
-      await withPostgresScopeOptions({ signal }, () => this.pooledOperation((session) => this.runQuery(session, "SELECT 1", [])));
+      await this.probe(signal);
       return true;
     } catch {
       return false;
     }
   }
 
+  async probe(signal?: AbortSignal): Promise<void> {
+    await withPostgresScopeOptions({ signal }, () => this.pooledOperation((session) => this.runQuery(session, "SELECT 1", [])));
+  }
+
   async introspect(): Promise<IntrospectedSchema> {
     const tableRows = await this.query(
       `SELECT table_schema, table_name

package/library/orm/Providers/ormTransactionRuntime.ts

@@ -96,6 +96,7 @@ export function createObservedProvider(provider: DatabaseProvider, observe: Tran
     afterCommit: provider.afterCommit?.bind(provider),
     afterRollback: provider.afterRollback?.bind(provider),
     ping: (signal?: AbortSignal): Promise<boolean> => observe(() => provider.ping(signal)),
+    probe: provider.probe ? (signal?: AbortSignal): Promise<void> => observe(() => provider.probe!(signal)) : undefined,
     introspect: () => observe(() => provider.introspect()),
     schemaAdmissionCapability: schema ? {
       version: schema.version,

package/library/orm/Providers/types.ts

@@ -178,6 +178,11 @@ export interface DatabaseProvider {
   afterRollback?(callback: TransactionCallback): void;
   /** Connection check for the health check. */
   ping(signal?: AbortSignal): Promise<boolean>;
+  /**
+   * Connection check that rejects with the driver's error instead of `false`,
+   * so a startup failure can say why (wrong password, missing database, …).
+   */
+  probe?(signal?: AbortSignal): Promise<void>;
   /** Introspection of the actual database schema (for the auto-migration). */
   introspect(): Promise<IntrospectedSchema>;
   /**

package/library/orm/Saving/ExecutionStrategy.ts

@@ -103,6 +103,7 @@ export function withRetry(provider: DatabaseProvider, options?: ExecutionStrateg
     afterCommit: provider.afterCommit ? (callback) => provider.afterCommit!(callback) : undefined,
     afterRollback: provider.afterRollback ? (callback) => provider.afterRollback!(callback) : undefined,
     ping: (signal) => provider.ping(signal),
+    probe: provider.probe ? (signal) => provider.probe!(signal) : undefined,
     introspect: () => provider.introspect(),
     schemaAdmissionCapability: provider.schemaAdmissionCapability,
     withMigrationLock: provider.withMigrationLock ? (work) => provider.withMigrationLock!(work) : undefined,

package/package.json

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