bazis 0.98.12 → 0.98.14

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.12" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.98.14" }, 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/orm/OrmLifecycle.ts

@@ -65,7 +65,10 @@ export class OrmLifecycle implements HostedService {
     const database = new DatabaseFacade(this.options.provider, this.options.model);
     try {
       if (this.ensureCreated) {
-        await database.ensureCreated();
+        const result = await database.ensureCreated();
+        for (const warning of result.warnings) {
+          console.warn(`[orm:schema] ${warning}`);
+        }
       }
       if (this.migrateOnStart) {
         const result = await database.migrate();

package/library/orm/DatabaseFacade.ts

@@ -4,7 +4,7 @@ import type { DatabaseProvider, DbExecutor, ExecuteResult, ForeignKeyConstraint,
 import { Migrator, type MigrationResult } from "./Schema/Migrator";
 import { MigrationRunner, type Migration, type VersionedMigrationResult } from "./Schema/MigrationRunner";
 import { SchemaDiffer } from "./Schema/SchemaDiffer";
-import { SchemaAdmissionEngine } from "./Schema/SchemaAdmission";
+import { SchemaAdmissionEngine, type EnsureCreatedResult } from "./Schema/SchemaAdmission";
 import { SchemaAdmissionError } from "./errors";
 import { physicalColumnTypes } from "./Schema/physicalColumnTypes";
 import { bindResolvedForeignKey } from "./Providers/resolvedForeignKey";
@@ -26,10 +26,9 @@ export class DatabaseFacade {
    * whole tables, then exact-verifies again before commit. Existing tables are
    * never altered or repaired.
    */
-  async ensureCreated(): Promise<void> {
+  async ensureCreated(): Promise<EnsureCreatedResult> {
     if (this.provider.name === "postgres") {
-      await new SchemaAdmissionEngine(this.provider, this.models).ensureCreated();
-      return;
+      return new SchemaAdmissionEngine(this.provider, this.models).ensureCreated();
     }
     // The physical default contract belongs exclusively to exact PostgreSQL
     // admission. Other providers must reject it rather than silently ignore it.
@@ -45,6 +44,7 @@ export class DatabaseFacade {
         await this.provider.execute(indexSql, []);
       }
     }
+    return { warnings: [] };
   }
 
   /**

package/library/orm/Metadata/ModelBuilder.ts

@@ -38,8 +38,10 @@ export class ModelBuilder {
     const indexes: IndexModel[] = [];
     const foreignKeys: ForeignKeyModel[] = [];
     let explicitKey: PropertyModel | undefined;
+    const sample = ModelBuilder.sampleOf(ctor);
 
     for (const rawProp of raw.properties.values()) {
+      ModelBuilder.assertTypeMatchesInitializer(ctor.name, rawProp, sample);
       const property = ModelBuilder.buildProperty(ctor.name, rawProp);
       properties.push(property);
       if (property.isKey) {
@@ -184,6 +186,43 @@ export class ModelBuilder {
     return model;
   }
 
+  /** A fresh instance shows the initial values; an entity whose constructor throws skips the check. */
+  private static sampleOf(ctor: new () => object): Record<string, unknown> | undefined {
+    try {
+      return new ctor() as Record<string, unknown>;
+    } catch {
+      return undefined;
+    }
+  }
+
+  /**
+   * A column without an explicit type maps to `text` (a key to an integer
+   * identity). When the initial value says otherwise (`pages = 0`,
+   * `code = ""` on a key), the mapping would silently change the value's type
+   * or drop it, so the model refuses to build and names the type to set.
+   */
+  private static assertTypeMatchesInitializer(entityName: string, raw: RawProperty, sample: Record<string, unknown> | undefined): void {
+    if (sample === undefined || raw.type !== undefined || raw.convention !== undefined || raw.converter !== undefined) return;
+    const initial = sample[raw.propertyName];
+    if (initial === undefined || initial === null) return;
+    const kind = initial instanceof Date ? "Date" : Array.isArray(initial) ? "array" : typeof initial;
+    if (raw.isKey === true) {
+      if (kind === "number" || kind === "bigint") return;
+      throw new ModelBuildError(
+        `Entity "${entityName}": key "${raw.propertyName}" has no column type and maps to an integer identity, but its initial value is a ${kind}. `
+          + `For a text key add @Column({ type: "text" }) next to @Key(); for a UUID key use @UUID().`,
+      );
+    }
+    if (kind === "string") return;
+    const suggestion = kind === "number" || kind === "bigint" ? `@Column({ type: "integer" }) or @Column({ type: "real" })`
+      : kind === "boolean" ? `@Column({ type: "boolean" })`
+      : kind === "Date" ? `@Column({ type: "datetime" })`
+      : `@Column({ type: "json" })`;
+    throw new ModelBuildError(
+      `Entity "${entityName}": property "${raw.propertyName}" has no column type and maps to text, but its initial value is a ${kind}. Set the type: ${suggestion}.`,
+    );
+  }
+
   private static buildProperty(entityName: string, raw: RawProperty): PropertyModel {
     const isKey = raw.isKey === true;
     const resolved = resolveColumnType(raw.type, isKey);

package/library/orm/Schema/SchemaAdmission.ts

@@ -2,7 +2,7 @@ import type { DatabaseProvider, SchemaAdmissionScope } from "../Providers/types"
 import { SchemaAdmissionError, SchemaMigrationRequiredError, SchemaVerificationError } from "../errors";
 import type { OrmModel } from "../Metadata/OrmModel";
 import { compileExpectedSchema, type OrmExpectedSchema } from "./ExpectedSchema";
-import { ExactSchemaVerifier } from "./ExactSchemaVerifier";
+import { ExactSchemaVerifier, type SchemaVerificationResult } from "./ExactSchemaVerifier";
 import { classifySafeAdditive, renderSafeAdditivePostgres } from "./SafeAdditiveSchema";
 
 /** PostgreSQL-private trace boundary; deliberately absent from public capability types. */
@@ -10,10 +10,15 @@ type TraceableSchemaAdmissionScope = SchemaAdmissionScope & {
   readonly executeSchemaAdmission?: (sql: string, operation: string) => ReturnType<SchemaAdmissionScope["execute"]>;
 };
 
+/** Result of `ensureCreated`: tolerated differences the application should know about. */
+export interface EnsureCreatedResult {
+  readonly warnings: readonly string[];
+}
+
 /** PostgreSQL-only create-missing-whole-tables and exact admission. */
 export class SchemaAdmissionEngine {
   constructor(private readonly provider: DatabaseProvider, private readonly models: OrmModel) {}
-  async ensureCreated(): Promise<void> {
+  async ensureCreated(): Promise<EnsureCreatedResult> {
     let expected: OrmExpectedSchema;
     try {
       expected = compileExpectedSchema(this.models);
@@ -25,16 +30,18 @@ export class SchemaAdmissionEngine {
     if (capability.version !== 1 || !capability.distributedLock || !capability.transactionalDdl || !capability.exactIntrospection) {
       throw new SchemaAdmissionError("ORM_SCHEMA_ATOMICITY_UNAVAILABLE", "PostgreSQL schema admission cannot guarantee atomic exact verification.");
     }
+    let warnings: readonly string[] = [];
     try {
-      await capability.withSchemaAdmission([...new Set(expected.tables.map((table) => table.schema))], async (scope) => this.admit(scope, expected));
+      await capability.withSchemaAdmission([...new Set(expected.tables.map((table) => table.schema))], async (scope) => { warnings = await this.admit(scope, expected); });
     } catch (error) {
       if (error instanceof SchemaAdmissionError) throw error;
       throw new SchemaAdmissionError("ORM_SCHEMA_ATOMICITY_UNAVAILABLE", "PostgreSQL schema admission could not complete safely.");
     }
+    return { warnings };
   }
-  private async admit(scope: SchemaAdmissionScope, expected: OrmExpectedSchema): Promise<void> {
+  private async admit(scope: SchemaAdmissionScope, expected: OrmExpectedSchema): Promise<readonly string[]> {
     const before = await scope.introspectExpected(expected);
-    const initial = new ExactSchemaVerifier().verify(expected, before, true);
+    const { verification: initial, warnings } = tolerateNameDrift(new ExactSchemaVerifier().verify(expected, before, true));
     const preflight = classifySafeAdditive(expected, before, initial);
     if (preflight.hardDifferences.length) {
       if (preflight.hardDifferences.some((difference) => difference.code === "catalog.unsupported")) throw new SchemaAdmissionError("ORM_SCHEMA_CATALOG_UNSUPPORTED", "PostgreSQL catalog contains a schema form unsupported by exact admission.");
@@ -49,8 +56,9 @@ export class SchemaAdmissionEngine {
       }
       catch (error) { throw this.mapDdlError(operation.kind, error); }
     }
-    const final = new ExactSchemaVerifier().verify(expected, await scope.introspectExpected(expected));
+    const { verification: final } = tolerateNameDrift(new ExactSchemaVerifier().verify(expected, await scope.introspectExpected(expected)));
     if (!final.compatible) throw new SchemaVerificationError(final);
+    return warnings;
   }
   private mapDdlError(kind: string, error: unknown): SchemaAdmissionError {
     const sqlState = typeof error === "object" && error !== null
@@ -60,3 +68,24 @@ export class SchemaAdmissionEngine {
     return new SchemaAdmissionError(kind === "createSchema" || kind === "createTable" ? "ORM_SCHEMA_CREATE_FAILED" : "ORM_SCHEMA_ADDITIVE_DDL_FAILED", "PostgreSQL additive schema admission failed.");
   }
 }
+
+/**
+ * A primary key that differs only by name (`tasks_pkey` from an older schema vs
+ * the model's `pk_tasks`) enforces the same thing, and queries never reference
+ * the name (`ON CONFLICT` names columns). It is reported, not refused; the same
+ * table passes `migrateOnStart`. Every other difference stays exact.
+ */
+function tolerateNameDrift(verification: SchemaVerificationResult): { readonly verification: SchemaVerificationResult; readonly warnings: readonly string[] } {
+  const tolerated = verification.differences.filter((difference) => difference.code === "primaryKey.name");
+  if (tolerated.length === 0) return { verification, warnings: [] };
+  const differences = verification.differences.filter((difference) => difference.code !== "primaryKey.name");
+  const quote = (name: string) => `"${name.replaceAll('"', '""')}"`;
+  const warnings = tolerated.map((difference) => {
+    const table = `${quote(difference.schema)}.${quote(difference.table)}`;
+    const actual = difference.actual?.value ?? "";
+    const expected = difference.expected?.value ?? difference.objectName ?? "";
+    return `table ${table}: primary key is named ${quote(actual)}, the model expects ${quote(expected)}. `
+      + `It works as is; to align the name run: ALTER TABLE ${table} RENAME CONSTRAINT ${quote(actual)} TO ${quote(expected)};`;
+  });
+  return { verification: { compatible: differences.length === 0, differences }, warnings };
+}

package/library/orm/index.ts

@@ -131,6 +131,7 @@ export type {
   IntrospectedCheck,
 } from "./Schema/introspection";
 export type { SchemaDifferenceCode, SafeSchemaDescriptor, SchemaDifference, SchemaVerificationResult } from "./Schema/ExactSchemaVerifier";
+export type { EnsureCreatedResult } from "./Schema/SchemaAdmission";
 export { SchemaAdmissionError, SchemaMigrationRequiredError, SchemaVerificationError } from "./errors";
 export type { SchemaAdmissionErrorCode } from "./errors";
 export { compileCheck, renderCheck } from "./Schema/CheckExpression";

package/package.json

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