bazis 0.98.16 → 0.98.17

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.16" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.98.17" }, capabilities: { experimentalApi: true },
       }, 15_000, signal);
       if (resolve(text(initialized.codexHome, 4096)) !== this.paths.home) throw new CodexError("PROTOCOL_ERROR");
       client.notify("initialized");

package/library/orm/Saving/SaveExecutor.ts

@@ -7,7 +7,8 @@ import type { DatabaseProvider, DbExecutor } from "../Providers/types";
 import { isUnknownTransactionOutcome, registerTransactionUncertainty, TransactionOutcomeUnknownError } from "../Providers/transactionOutcome";
 import { registerPostCommitFinalizer } from "../Providers/transactionCallbacks";
 import { EntityState } from "../Tracking/EntityState";
-import { assertUniqueTrackedKeys, holdDeletedIdentity, type ChangeTracker, type TrackedEntry } from "../Tracking/ChangeTracker";
+import { assertUniqueTrackedKeys, holdDeletedIdentity, trackedEntriesOf, type ChangeTracker, type TrackedEntry } from "../Tracking/ChangeTracker";
+import { NavigationFixup } from "./navigationFixup";
 import { CommandBuilder } from "./CommandBuilder";
 import { applyConventions } from "./applyConventions";
 import { ExecutionStrategy, type ExecutionStrategyOptions } from "./ExecutionStrategy";
@@ -78,6 +79,10 @@ export class SaveExecutor {
 
   private async saveCore(): Promise<number> {
     if (uncertainTrackers.has(this.tracker)) throw new TransactionOutcomeUnknownError();
+    // Foreign keys from navigations first, so a changed navigation on an
+    // Unchanged entity is detected as a Modified foreign key.
+    const fixup = new NavigationFixup(trackedEntriesOf(this.tracker));
+    fixup.applyAll();
     this.tracker.detectChanges();
     const pending = this.tracker.entriesToProcess();
     if (pending.length === 0) {
@@ -127,9 +132,14 @@ export class SaveExecutor {
               group.push(ordered[i]!);
               i += 1;
             }
+            // Parents are inserted first: their generated keys are known now.
+            for (const added of group) fixup.apply(added);
             await this.insertBatch(tx, entry.model, group);
             continue;
           }
+          if (entry.state === EntityState.Modified) {
+            for (const name of fixup.apply(entry)) entry.modifiedProperties.add(name);
+          }
           await this.execute(tx, entry);
           i += 1;
         }

package/library/orm/Saving/navigationFixup.ts

@@ -0,0 +1,80 @@
+import { EntityState } from "../Tracking/EntityState";
+import type { TrackedEntry } from "../Tracking/ChangeTracker";
+
+type Values = Record<string, unknown>;
+
+/**
+ * Foreign keys from navigations, as EF Core's relationship fix-up does:
+ * `article.author = bob` (a `@ManyToOne`) or `bob.articles.push(article)`
+ * (a `@OneToMany`) set `article.authorId` from `bob`'s key. Only navigations to
+ * entities tracked by the same context are followed; the navigation wins over
+ * a different value in the foreign key property.
+ */
+export class NavigationFixup {
+  /** child entity -> the parents whose collection holds it. */
+  private readonly parents = new Map<object, { readonly parent: TrackedEntry; readonly foreignKey: readonly string[] }[]>();
+
+  constructor(private readonly entries: ReadonlyMap<object, TrackedEntry>) {
+    for (const entry of entries.values()) {
+      for (const relation of entry.model.relations) {
+        if (relation.kind !== "collection") continue;
+        const children = (entry.entity as Values)[relation.navigationName];
+        if (!Array.isArray(children)) continue;
+        for (const child of children) {
+          if (child === null || typeof child !== "object" || !entries.has(child)) continue;
+          const list = this.parents.get(child) ?? [];
+          list.push({ parent: entry, foreignKey: toArray(relation.foreignKey) });
+          this.parents.set(child, list);
+        }
+      }
+    }
+  }
+
+  /** Applies the fix-up to every tracked entry (before change detection). */
+  applyAll(): void {
+    for (const entry of this.entries.values()) {
+      if (entry.state !== EntityState.Deleted) this.apply(entry);
+    }
+  }
+
+  /**
+   * Applies the fix-up to one entry and returns the foreign key properties it
+   * changed. Called again right before the entry's SQL, when the keys the
+   * database generated for its parents are known.
+   */
+  apply(entry: TrackedEntry): readonly string[] {
+    const changed: string[] = [];
+    const entity = entry.entity as Values;
+    for (const relation of entry.model.relations) {
+      if (relation.kind !== "reference") continue;
+      const target = entity[relation.navigationName];
+      if (target === null || typeof target !== "object") continue;
+      const targetEntry = this.entries.get(target);
+      if (targetEntry === undefined) continue;
+      this.copyKey(entity, toArray(relation.foreignKey), targetEntry, changed);
+    }
+    for (const { parent, foreignKey } of this.parents.get(entry.entity) ?? []) {
+      if (parent.state === EntityState.Deleted) continue;
+      this.copyKey(entity, foreignKey, parent, changed);
+    }
+    return changed;
+  }
+
+  private copyKey(entity: Values, foreignKey: readonly string[], target: TrackedEntry, changed: string[]): void {
+    const key = target.model.key;
+    if (key.length !== foreignKey.length) return;
+    const source = target.entity as Values;
+    key.forEach((property, index) => {
+      const name = foreignKey[index]!;
+      const value = source[property.propertyName];
+      if (entity[name] !== value) {
+        entity[name] = value;
+        changed.push(name);
+      }
+    });
+  }
+}
+
+function toArray(value: string | readonly string[]): readonly string[] {
+  return typeof value === "string" ? [value] : value;
+}

package/library/orm/Tracking/ChangeTracker.ts

@@ -342,6 +342,11 @@ export class ChangeTracker {
   }
 }
 
+/** Non-barrel access to every tracked entry, for the save-time navigation fix-up. */
+export function trackedEntriesOf(tracker: ChangeTracker): ReadonlyMap<object, TrackedEntry> {
+  return trackerEntries.get(tracker) ?? new Map();
+}
+
 /** Non-barrel helper used only by immediate DML admission. */
 export function hasTrackedEntriesForModel(tracker: ChangeTracker, model: EntityModel): boolean {
   return [...(trackerEntries.get(tracker)?.values() ?? [])].some((entry) => entry.model === model);

package/package.json

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