bazis 0.115.0 → 0.116.0

package/core/http/Results/normalize.ts

@@ -88,6 +88,12 @@ export function normalizeResult(result: unknown, ctx: HttpContext, defaults: Res
   if (status === 204 || status === 304) {
     payload = null;
   }
+  // A known length survives HEAD: the server answers it with the headers of
+  // this response and no body, and Bun would otherwise send content-length: 0.
+  const length = typeof payload === "string" ? Buffer.byteLength(payload) : payload instanceof Uint8Array || payload instanceof ArrayBuffer ? payload.byteLength : undefined;
+  if (length !== undefined && !headers.has("content-length")) {
+    headers.set("content-length", String(length));
+  }
 
   return new Response(payload, { status, headers });
 }

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.115.0" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.116.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/scripts/di-generate.ts

@@ -1173,6 +1173,32 @@ function routeParamNames(controller: ts.ClassDeclaration, method: ts.MethodDecla
   return names;
 }
 
+/** Route parameters with a constraint, `:id(int)` -> id: int, from the controller and method templates. */
+function routeParamConstraints(controller: ts.ClassDeclaration, method: ts.MethodDeclaration): Map<string, string> {
+  const constraints = new Map<string, string>();
+  for (const decorators of [ts.getDecorators(controller) ?? [], ts.getDecorators(method) ?? []]) {
+    for (const decorator of decorators) {
+      const firstArg = decoratorCall(decorator)?.call?.arguments[0];
+      if (!firstArg || !ts.isStringLiteralLike(firstArg)) continue;
+      for (const segment of firstArg.text.split("/")) {
+        const param = /^:([A-Za-z_][A-Za-z0-9_]*)\(([A-Za-z]+)\)/.exec(segment);
+        if (param) constraints.set(param[1] as string, param[2] as string);
+      }
+    }
+  }
+  return constraints;
+}
+
+/**
+ * The router converts a constrained segment before binding, so the parameter
+ * must be declared with the converted type; otherwise its TypeScript type lies.
+ */
+function constraintMismatch(paramName: string, declared: string | undefined, constraint: string | undefined): string | undefined {
+  const expected = constraint === "int" || constraint === "number" ? "number" : constraint === "bool" ? "boolean" : constraint === "uuid" || constraint === "alpha" ? "string" : undefined;
+  if (expected === undefined || declared === undefined || declared === expected) return undefined;
+  return `route parameter "${paramName}" is constrained to (${constraint}), so it arrives as a ${expected}; declare it as ${expected}`;
+}
+
 /** Reuses the request hydration graph; no reflection metadata/runtime TS imports. */
 function collectGrpcBindings(source: ts.SourceFile): void {
   const visit = (node: ts.Node): void => {
@@ -1455,6 +1481,7 @@ function collectControllerBindings(node: ts.ClassDeclaration, controllerName: st
   for (const { name, routes, member } of controllerActions(node)) {
     collectOpenApiOperation(controllerName, member);
     const routeParams = routeParamNames(node, routes);
+    const constraints = routeParamConstraints(node, routes);
     const specs: HttpBindingSpec[] = [];
     let bodyCount = 0;
     let failed: string | undefined;
@@ -1471,6 +1498,12 @@ function collectControllerBindings(node: ts.ClassDeclaration, controllerName: st
       // An explicit source: FromQuery<…>, FromHeader<…>, FromBody<…>, FromRoute<…>.
       const marker = typeNode ? sourceMarker(typeNode) : undefined;
       if (marker !== undefined) {
+        const routeName = marker.kind === "FromRoute" ? marker.name ?? paramName : undefined;
+        const mismatch = routeName === undefined ? undefined : constraintMismatch(routeName, marker.inner?.getText().trim(), constraints.get(routeName));
+        if (mismatch !== undefined) {
+          failed = mismatch;
+          break;
+        }
         const spec = markerBindingSpec(marker, paramName, optional, routeParams);
         if (typeof spec === "string") {
           failed = spec;
@@ -1494,6 +1527,11 @@ function collectControllerBindings(node: ts.ClassDeclaration, controllerName: st
         continue;
       }
       if (routeParams.has(paramName)) {
+        const mismatch = constraintMismatch(paramName, keywordType, constraints.get(paramName));
+        if (mismatch !== undefined) {
+          failed = mismatch;
+          break;
+        }
         // Constraint conversion happens in the router; add type only for plain :params.
         const type = keywordType !== undefined ? PRIMITIVE_QUERY_TYPES[keywordType] : undefined;
         specs.push({ source: "route", name: paramName, type: type === "string" ? undefined : type, optional });

package/library/orm/DbContext.ts

@@ -1,9 +1,9 @@
 import { DatabaseFacade } from "./DatabaseFacade";
 import type { DbContextOptions } from "./DbContextOptions";
-import { EntityNotMappedError } from "./errors";
+import { EntityNotMappedError, OrmError } from "./errors";
 import { DbSet } from "./Query/DbSet";
 import type { DbContextRuntime } from "./runtime";
-import { SaveExecutor } from "./Saving/SaveExecutor";
+import { hasPendingRollback, SaveExecutor } from "./Saving/SaveExecutor";
 import { ChangeTracker } from "./Tracking/ChangeTracker";
 import { EntityState } from "./Tracking/EntityState";
 import { monitorImmediateOperation, monitorWholeOperation, observedProvider, transactionScope } from "./Transactions/TransactionScopeCoordinator";
@@ -88,6 +88,20 @@ export abstract class DbContext {
     return this.changeTracker.stateOf(entity);
   }
 
+  /**
+   * Stops tracking `entity`: its changes are no longer saved and the next
+   * read returns a fresh object (`Entry(e).State = Detached` in EF Core). Use
+   * it to drop the changes a rolled-back scope left in the context; an entity
+   * saved in a scope that is still open cannot be detached, because that
+   * scope's rollback would restore it.
+   */
+  detach(entity: object): void {
+    if (hasPendingRollback(this.changeTracker, entity)) {
+      throw new OrmError(`${entity.constructor.name} was saved in a transaction scope that is still open; detach it after the scope ends.`);
+    }
+    this.changeTracker.detach(entity);
+  }
+
   /**
    * Applies all pending changes in one transaction and returns the number of
    * processed entities. DetectChanges runs before saving, and (if enabled)

package/library/orm/Providers/OwnedStoreCatalog.reader.ts

@@ -708,7 +708,7 @@ export class OwnedStoreCatalogReader {
     const output: OwnedCatalogColumnV1[] = [], relationKinds = new Map(relations.map(relation => [relation.oid, relation.kind]));
     for (let offset = 0; offset < relationOids.length; offset += 1024) {
       const batch = relationOids.slice(offset, offset + 1024), parameter = this.encodePgOidArrayParameter(batch), issuedLimit = budget.remaining + 1;
-      const result = await this.source.query(`SELECT a.attrelid::pg_catalog.text AS relation_oid,a.attnum::pg_catalog.text AS attnum,a.attname AS column_name,a.attisdropped AS dropped,a.attislocal AS local,a.attinhcount::pg_catalog.text AS inheritance_count,pg_catalog.format_type(a.atttypid,a.atttypmod) AS physical_type,a.atttypid::pg_catalog.text AS type_oid,a.attnotnull AS not_null,d.oid::pg_catalog.text AS default_object_oid,pg_catalog.pg_get_expr(d.adbin,d.adrelid) AS default_expression,a.attidentity AS identity_code,a.attgenerated AS generated_code,a.attcollation::pg_catalog.text AS collation_oid,t.typcollation::pg_catalog.text AS type_default_collation_oid,a.attstorage AS storage_code,t.typstorage AS type_default_storage_code,a.attcompression AS compression_code,a.atthasdef AS has_default FROM pg_catalog.pg_attribute AS a LEFT JOIN pg_catalog.pg_type AS t ON t.oid=a.atttypid LEFT JOIN pg_catalog.pg_attrdef AS d ON d.adrelid=a.attrelid AND d.adnum=a.attnum WHERE a.attrelid=ANY($1::pg_catalog.oid[]) AND a.attnum>0 ORDER BY a.attrelid,a.attnum LIMIT ${issuedLimit}`, [parameter], operation);
+      const result = await this.source.query(`SELECT a.attrelid::pg_catalog.text AS relation_oid,a.attnum::pg_catalog.text AS attnum,a.attname AS column_name,a.attisdropped AS dropped,a.attislocal AS local,a.attinhcount::pg_catalog.text AS inheritance_count,pg_catalog.format_type(a.atttypid,a.atttypmod) AS physical_type,a.atttypid::pg_catalog.text AS type_oid,a.attnotnull AS not_null,d.oid::pg_catalog.text AS default_object_oid,pg_catalog.pg_get_expr(d.adbin,d.adrelid) AS default_expression,a.attidentity AS identity_code,a.attgenerated AS generated_code,a.attcollation::pg_catalog.text AS collation_oid,t.typcollation::pg_catalog.text AS type_default_collation_oid,a.attstorage AS storage_code,t.typstorage AS type_default_storage_code,a.attcompression AS compression_code,a.atthasdef AS has_default FROM pg_catalog.pg_attribute AS a LEFT JOIN pg_catalog.pg_type AS t ON t.oid=a.atttypid LEFT JOIN pg_catalog.pg_attrdef AS d ON d.adrelid=a.attrelid AND d.adnum=a.attnum WHERE a.attrelid=ANY($1::pg_catalog.oid[]) AND a.attnum>0 AND NOT a.attisdropped ORDER BY a.attrelid,a.attnum LIMIT ${issuedLimit}`, [parameter], operation);
       const rows = selectOwnedStoreRows(result, [
         "relation_oid", "attnum", "column_name", "dropped", "local", "inheritance_count", "physical_type", "type_oid", "not_null", "default_object_oid", "default_expression", "identity_code", "generated_code", "collation_oid", "type_default_collation_oid", "storage_code", "type_default_storage_code", "compression_code", "has_default"
       ], issuedLimit);

package/library/orm/Saving/SaveExecutor.ts

@@ -36,6 +36,11 @@ interface RollbackToken {
 
 /** Per-tracker, per-entity save baselines. It is deliberately transient and never part of TrackedEntry. */
 const rollbackTokens = new WeakMap<ChangeTracker, WeakMap<object, RollbackToken>>();
+
+/** @internal The entity was saved in a transaction scope that has not ended yet. */
+export function hasPendingRollback(tracker: ChangeTracker, entity: object): boolean {
+  return rollbackTokens.get(tracker)?.get(entity) !== undefined;
+}
 const uncertainTrackers = new WeakSet<ChangeTracker>();
 
 export interface SaveOptions {

package/library/orm/Schema/OwnedStoreCatalog.ts

@@ -1128,13 +1128,17 @@ function verifyOwnedStoreCatalogModelsV1(snapshot: OwnedStoreCatalogSnapshotV1,
       readonly default: CanonicalDefault;
       readonly generation: "none" | "identityByDefault" | "uuidDefault";
     }>();
+    // A column added and dropped outside bazis stays in pg_attribute as a
+    // dropped attribute: it holds no reachable data and cannot be removed
+    // without rewriting the table. The reader skips such attributes, so live
+    // columns may have gaps in attnum; their order is what counts.
     const tableColumns = columns.get(relation.oid) ?? [];
     if (snapshot.columns.some((column) => !owned.has(column.relationOid) && !declaredToastRelationOids.has(column.relationOid)) || tableColumns.length !== expectedTable.columns.length)
       bad();
     const orderedColumns = [...tableColumns].sort((a, b) => Number(a.attnum) - Number(b.attnum));
     for (let index = 0; index < orderedColumns.length; index++) {
       const column = orderedColumns[index]!, modelColumn = expectedTable.columns[index]!;
-      if (column.name !== modelColumn.column || column.attnum !== String(index + 1) || column.dropped || !column.local || column.inheritanceCount !== "0" || column.typeOid === "0" || BigInt(column.typeOid) >= 12000n || !["integer", "real", "text", "boolean", "datetime", "json", "uuid"].includes(column.physicalType) || column.collationOid !== column.typeDefaultCollationOid || column.storageCode !== column.typeDefaultStorageCode || column.compressionCode !== "" || column.generation === "other")
+      if (column.name !== modelColumn.column || column.dropped || !column.local || column.inheritanceCount !== "0" || column.typeOid === "0" || BigInt(column.typeOid) >= 12000n || !["integer", "real", "text", "boolean", "datetime", "json", "uuid"].includes(column.physicalType) || column.collationOid !== column.typeDefaultCollationOid || column.storageCode !== column.typeDefaultStorageCode || column.compressionCode !== "" || column.generation === "other")
         bad();
       const expectedGeneration = modelColumn.generation;
       if (column.generation !== expectedGeneration || (column.generation === "none" && (column.identityCode !== "" || column.generatedCode !== "")) || (column.generation === "identityByDefault" && (column.identityCode !== "d" || column.generatedCode !== "")) || (column.generation === "uuidDefault" && (column.identityCode !== "" || column.generatedCode !== "")))

package/library/orm/Tracking/ChangeTracker.ts

@@ -243,6 +243,14 @@ export class ChangeTracker {
     this.entries.set(entry.entity, entry);
   }
 
+  /** Stops tracking one entity: it becomes Detached and leaves the identity map. */
+  detach(entity: object): void {
+    const entry = this.entries.get(entity);
+    if (!entry) return;
+    this.unindexByKey(entry);
+    this.entries.delete(entity);
+  }
+
   clear(): void {
     this.entries.clear();
     this.identity.clear();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bazis",
-  "version": "0.115.0",
+  "version": "0.116.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",