bazis 0.98.20 → 0.98.21

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.20" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.98.21" }, 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/OrmHostedPlan.validator.ts

@@ -50,7 +50,7 @@ function validateOrmHostedPlan(services: readonly HostedService[]): void {
       const owner = (service as { __bazisSchemaOwner?: { context: string; mode: string } }).__bazisSchemaOwner;
       return owner ? `${owner.context} uses ${owner.mode}` : "a module uses migrateOnStart or migrations";
     };
-    throw new SchemaAdmissionError("ORM_SCHEMA_HOSTED_PHASE_CONFLICT", `Schema admission and legacy ORM schema authority cannot be composed together: ${[...strict, ...legacy].map(describe).join(", ")}. Use one schema mode in the application: ensureCreated in every module, or migrateOnStart/migrations in every module.`);
+    throw new SchemaAdmissionError("ORM_SCHEMA_HOSTED_PHASE_CONFLICT", `Schema admission and legacy ORM schema authority cannot be composed together: ${[...strict, ...legacy].map(describe).join(", ")}. Use one schema mode in the application: ensureCreated (with or without migrations) in every module, or migrateOnStart/migrations without ensureCreated in every module.`);
   }
   for (const service of services) {
     const framework = isOrmProviderLifecycle(service)

package/core/orm/OrmLifecycle.ts

@@ -1,6 +1,6 @@
 import { ormHostedPlanValidator } from "./OrmHostedPlan.validator";
 import type { HostedService } from "../di";
-import { DatabaseFacade, type DbContextOptions, type Migration } from "../../library/orm";
+import { DatabaseFacade, type DbContextOptions, type EnsureCreatedWithMigrationsResult, type Migration } from "../../library/orm";
 import { compileExpectedSchema } from "../../library/orm/Schema/ExpectedSchema";
 
 /**
@@ -29,6 +29,8 @@ export class OrmLifecycle implements HostedService {
   };
   /** Internal hosted-plan marker: the context and its startup schema mode, for readable plan errors. */
   readonly __bazisSchemaOwner: { readonly context: string; readonly mode: string };
+  /** `ensureCreated` owns the versioned migrations of this context (run or baselined before the check). */
+  private readonly withMigrations: boolean;
   private connectionClosed = false;
   private closePromise?: Promise<void>;
 
@@ -48,6 +50,7 @@ export class OrmLifecycle implements HostedService {
     contextName = "DbContext",
   ) {
     const modes = [ensureCreated && "ensureCreated", migrateOnStart && "migrateOnStart", runMigrationsOnStart && migrations.length > 0 && "migrations"].filter(Boolean);
+    this.withMigrations = ensureCreated && runMigrationsOnStart && migrations.length > 0;
     this.__bazisSchemaOwner = Object.freeze({ context: contextName, mode: modes.join(" + ") || "none" });
     this.phase = ensureCreated && options.provider.name === "postgres" ? -105 : -100;
     this.__bazisLegacySchemaAuthority = this.phase === -100 && (ensureCreated || migrateOnStart || (runMigrationsOnStart && migrations.length > 0));
@@ -72,10 +75,17 @@ export class OrmLifecycle implements HostedService {
     const database = new DatabaseFacade(this.options.provider, this.options.model);
     try {
       if (this.ensureCreated) {
-        const result = await database.ensureCreated();
+        const result: Partial<EnsureCreatedWithMigrationsResult> & Pick<EnsureCreatedWithMigrationsResult, "warnings"> = this.withMigrations ? await database.ensureCreatedWithMigrations(this.migrations) : await database.ensureCreated();
+        // Logged in execution order: migrations, schema changes, then the baseline record.
+        if (result.migrated && result.migrated.length > 0) {
+          console.info(`[orm:migrations] applied: ${result.migrated.join(", ")}`);
+        }
         if (result.applied && result.applied.length > 0) {
           console.info(`[orm:schema] applied ${result.applied.length} operation(s): ${result.applied.join(", ")}`);
         }
+        if (result.baselined && result.baselined.length > 0) {
+          console.info(`[orm:migrations] baseline: the schema was created from the model, recorded as applied without running: ${result.baselined.join(", ")}`);
+        }
         for (const warning of result.warnings) {
           console.warn(`[orm:schema] ${warning}`);
         }
@@ -89,7 +99,7 @@ export class OrmLifecycle implements HostedService {
           console.warn(`[orm:migrate] ${warning}`);
         }
       }
-      if (this.runMigrationsOnStart && this.migrations.length > 0) {
+      if (this.runMigrationsOnStart && this.migrations.length > 0 && !this.withMigrations) {
         const result = await database.migrateVersioned(this.migrations);
         if (result.applied.length > 0) {
           console.info(`[orm:migrations] applied: ${result.applied.join(", ")}`);

package/core/orm/ormModule.ts

@@ -121,7 +121,7 @@ export function ormModule<TContext extends DbContext>(config: OrmModuleConfig<TC
     attachOwnedStoreRegistration(module, buildConfig.context, buildConfig.entities ?? [], config.ownedStore);
     return module;
   }
-  if (config.ensureCreated && (config.migrateOnStart || config.runMigrationsOnStart || (config.migrations?.length ?? 0) > 0)) throw new OrmError("ensureCreated is mutually exclusive with ORM migration startup options.");
+  if (config.ensureCreated && config.migrateOnStart) throw new OrmError("ensureCreated and migrateOnStart are mutually exclusive: ensureCreated already adds the safe changes. Put other changes into migrations with runMigrationsOnStart: true.");
   if (config.ensureCreated && config.provider?.name === "postgres" && config.context) throw new OrmError("PostgreSQL ensureCreated requires the shared DATABASE_PROVIDER from @Infra.");
   // "Connection" mode: a provider only, no context.
   if (!config.context) {

package/library/orm/DatabaseFacade.ts

@@ -5,6 +5,15 @@ 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";
+
+/** Result of `ensureCreated` together with versioned migrations. */
+export interface EnsureCreatedWithMigrationsResult extends EnsureCreatedResult {
+  /** Migrations run before the schema check. */
+  readonly migrated: readonly string[];
+  /** Migrations recorded as applied without running, because the schema was created from the model. */
+  readonly baselined: readonly string[];
+}
 import { SchemaAdmissionError } from "./errors";
 import { physicalColumnTypes } from "./Schema/physicalColumnTypes";
 import { bindResolvedForeignKey } from "./Providers/resolvedForeignKey";
@@ -47,6 +56,32 @@ export class DatabaseFacade {
     return { warnings: [] };
   }
 
+  /**
+   * `ensureCreated` with versioned migrations, under the migration lock so that
+   * starting instances do not race:
+   *
+   * - none of the context tables exist yet: `ensureCreated` creates the current
+   *   model and the migrations are recorded as applied without running (a
+   *   baseline: the model already contains their result, so a seed `INSERT` in
+   *   a migration is skipped here too);
+   * - otherwise pending migrations run first (`ALTER`, renames, data moves),
+   *   then `ensureCreated` adds what is still missing and verifies the result.
+   */
+  async ensureCreatedWithMigrations(migrations: readonly Migration[]): Promise<EnsureCreatedWithMigrationsResult> {
+    const work = async (): Promise<EnsureCreatedWithMigrationsResult> => {
+      const runner = new MigrationRunner(this.provider, migrations);
+      const existing = await this.provider.introspect();
+      const fresh = this.models.entities.every((model) => !existing.tables.has(entityStorageKey(model)) && !existing.tables.has(model.tableName));
+      if (fresh) {
+        const created = await this.ensureCreated();
+        return { ...created, migrated: [], baselined: await runner.baseline() };
+      }
+      const { applied } = await runner.migrate();
+      return { ...(await this.ensureCreated()), migrated: applied, baselined: [] };
+    };
+    return this.provider.withMigrationLock ? this.provider.withMigrationLock(work) : work();
+  }
+
   /**
    * Additive auto-migration of the schema for all context entities (enabled in
    * the module: `ormBazis: { migrateOnStart: true }`): introspects the database,

package/library/orm/Schema/MigrationRunner.ts

@@ -61,6 +61,27 @@ export class MigrationRunner {
     return { applied, rolledBack: [] };
   }
 
+  /**
+   * Records pending migrations as applied without running them. Used when the
+   * schema was just created from the current model, which already contains
+   * their result.
+   */
+  async baseline(): Promise<readonly string[]> {
+    return this.withMigrationLock(async () => {
+      await this.ensureHistory();
+      const appliedSet = await this.loadApplied();
+      const recorded: string[] = [];
+      for (const migration of this.migrations.filter((item) => !appliedSet.has(item.id))) {
+        await this.provider.execute(
+          `INSERT INTO ${this.quote(HISTORY_TABLE)} (${this.quote("MigrationId")}, ${this.quote("AppliedAt")}) VALUES (${this.param(0)}, ${this.param(1)})`,
+          [migration.id, new Date().toISOString()],
+        );
+        recorded.push(migration.id);
+      }
+      return recorded;
+    });
+  }
+
   /** Rolls back the last `steps` migrations (requires `down`). */
   async rollback(steps = 1): Promise<VersionedMigrationResult> {
     if (!Number.isSafeInteger(steps) || steps < 0) {

package/library/orm/errors.ts

@@ -33,7 +33,7 @@ export class SchemaMigrationRequiredError extends SchemaAdmissionError {
 
 function schemaVerificationMessage(summary: string, verification: SchemaVerificationResult): string {
   return [summary, formatSchemaDifferences(verification),
-    "Check the application version and target database. Align the ORM model and database schema; apply an explicit migration if a database change is intended.",
+    "Check the application version and target database. Align the ORM model and database schema; apply an explicit migration if a database change is intended (with ensureCreated: add it to the module's migrations with runMigrationsOnStart: true).",
   ].filter(Boolean).join("\n");
 }
 

package/library/orm/index.ts

@@ -132,6 +132,7 @@ export type {
 } from "./Schema/introspection";
 export type { SchemaDifferenceCode, SafeSchemaDescriptor, SchemaDifference, SchemaVerificationResult } from "./Schema/ExactSchemaVerifier";
 export type { EnsureCreatedResult } from "./Schema/SchemaAdmission";
+export type { EnsureCreatedWithMigrationsResult } from "./DatabaseFacade";
 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.20",
+  "version": "0.98.21",
   "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",