bazis 0.101.0 → 0.103.0

package/core/app/messages.ts

@@ -7,7 +7,7 @@ export type AppLanguage = "en" | "ru";
 
 /**
  * Own texts for framework messages, by key: HTTP texts (`notFound`,
- * `missingParameter`, …), validation codes (`required`, `minLength`, …),
+ * `malformedJson`, …), validation codes (`required`, `minLength`, …),
  * `validationFailed`, `unknownField` and type names (`typeName.number`).
  * Placeholders: `{property}`, `{min}`, `{name}`, … as in the built-in texts.
  */

package/core/http/Binding/ParameterBinder.ts

@@ -1,9 +1,10 @@
 import { ListQueryError, parseListQuery } from "../../../library/jsonapi";
 import { bindSourceModel } from "./sourceModelBinder";
-import { UnsupportedMediaTypeError, frameworkBadRequest } from "../Errors/HttpError";
+import { ModelValidationError, UnsupportedMediaTypeError, frameworkBadRequest } from "../Errors/HttpError";
 import type { HttpContext } from "../HttpContext/HttpContext";
 import type { ParameterBinding } from "./bindings";
-import { convertOr400 } from "./convert";
+import { INVALID, tryConvert, type ValueType } from "./convert";
+import type { ModelValidationIssue } from "./modelValidator";
 import { bindModelAsync } from "./modelBinder";
 
 /** Per-action constraints affecting binding (from decorators). */
@@ -26,7 +27,40 @@ export function assertConsumes(ctx: HttpContext, consumes: string | undefined):
   }
 }
 
-function bindValue(binding: ParameterBinding, raw: string | undefined, kind: string): unknown {
+/**
+ * One parameter that cannot be bound: an item of the single 400 that lists
+ * every binding problem of the request, like model validation errors.
+ */
+class ParameterIssue extends Error {
+  constructor(readonly issue: ModelValidationIssue) {
+    super(issue.message);
+  }
+}
+
+/** Type names in the `type` message: `int` stays, `bool` reads as `boolean`. */
+const EXPECTED: Readonly<Record<ValueType, string>> = { string: "string", int: "int", number: "number", bool: "boolean" };
+
+function issueOf(ctx: HttpContext, code: "required" | "type", params: Readonly<Record<string, unknown>>, english: string): ParameterIssue {
+  const message = ctx.modelValidator?.message?.(code, params) ?? english;
+  return new ParameterIssue({ property: params.property as string, message, code, params });
+}
+
+function missing(ctx: HttpContext, name: string): ParameterIssue {
+  return issueOf(ctx, "required", { property: name }, `Field "${name}" is required`);
+}
+
+/** Converts a raw value or reports it as a `type` issue under the parameter name. */
+function converted(ctx: HttpContext, raw: string, type: ValueType, name: string): string | number | boolean {
+  const value = tryConvert(raw, type);
+  if (value === INVALID) {
+    const expected = EXPECTED[type];
+    throw issueOf(ctx, "type", { property: name, expected, actual: "string" }, `Field "${name}" must be of type ${expected}, got: string`);
+  }
+  return value;
+}
+
+function bindValue(binding: ParameterBinding, raw: string | undefined, ctx: HttpContext): unknown {
+  const name = binding.name ?? "?";
   if (raw === undefined) {
     if (binding.defaultValue !== undefined) {
       return binding.defaultValue;
@@ -34,9 +68,9 @@ function bindValue(binding: ParameterBinding, raw: string | undefined, kind: str
     if (binding.optional) {
       return undefined;
     }
-    throw frameworkBadRequest("missingParameter", { kind, name: binding.name });
+    throw missing(ctx, name);
   }
-  return binding.type && binding.type !== "string" ? convertOr400(raw, binding.type, binding.name ?? "?") : raw;
+  return binding.type && binding.type !== "string" ? converted(ctx, raw, binding.type, name) : raw;
 }
 
 /**
@@ -50,14 +84,17 @@ function bindArray(binding: ParameterBinding, ctx: HttpContext): unknown {
     return binding.optional ? undefined : [];
   }
   return binding.type && binding.type !== "string"
-    ? raw.map((value) => convertOr400(value, binding.type!, binding.name ?? "?"))
+    ? raw.map((value) => converted(ctx, value, binding.type!, binding.name ?? "?"))
     : raw;
 }
 
 /**
  * Resolves generated binding descriptors into the action's argument list.
- * All conversions fail with 400 (never 500); body parse errors and model
- * validation are handled by the body branch.
+ * Every argument is bound even when an earlier one fails: missing or invalid
+ * route, query and header values and the validation errors of body, query and
+ * header models come together in one 400 (`Validation failed` with
+ * `details`), like ASP.NET model state. Errors of the request itself
+ * (malformed JSON, wrong media type, too large) stop at once.
  */
 export async function bindArguments(
   bindings: readonly ParameterBinding[],
@@ -65,79 +102,82 @@ export async function bindArguments(
   defaults: BindingDefaults,
 ): Promise<unknown[]> {
   const args: unknown[] = new Array(bindings.length);
+  const issues: ModelValidationIssue[] = [];
+  let title: string | undefined;
   for (let index = 0; index < bindings.length; index += 1) {
-    const binding = bindings[index]!;
-    switch (binding.source) {
-      case "route": {
-        const value = binding.name !== undefined ? ctx.params[binding.name] : undefined;
-        // Route params are already constraint-converted; re-convert only when
-        // the binding asks for a different primitive type.
-        if (value === undefined) {
-          args[index] = bindValue(binding, undefined, "route");
-        } else if (binding.type && binding.type !== "string" && typeof value === "string") {
-          args[index] = convertOr400(value, binding.type, binding.name ?? "?");
-        } else {
-          args[index] = value;
-        }
-        break;
+    try {
+      args[index] = await bindOne(bindings[index]!, ctx, defaults);
+    } catch (error) {
+      if (error instanceof ParameterIssue) {
+        issues.push(error.issue);
+      } else if (error instanceof ModelValidationError) {
+        issues.push(...error.errors);
+        title ??= error.message;
+      } else {
+        throw error;
       }
-      case "query":
-        args[index] = binding.array ? bindArray(binding, ctx) : bindValue(binding, ctx.query(binding.name ?? ""), "query");
-        break;
-      case "header":
-        args[index] = bindValue(binding, ctx.header(binding.name ?? ""), "header");
-        break;
-      case "queryModel":
-      case "headerModel":
-        args[index] = await bindSourceModel(binding, ctx);
-        break;
-      case "body": {
-        const contentType = ctx.header("content-type") ?? "";
-        if (defaults.consumes) {
-          if (!contentType.toLowerCase().startsWith(defaults.consumes.toLowerCase())) {
-            throw new UnsupportedMediaTypeError(defaults.consumes);
-          }
-        } else if (!isJsonMediaType(contentType)) {
-          // Convention-based body-model binding is a JSON boundary. Requiring
-          // a non-simple media type also prevents cross-origin text/plain POSTs
-          // from bypassing the browser's CORS preflight.
-          throw new UnsupportedMediaTypeError("application/json");
+    }
+  }
+  if (issues.length > 0) {
+    throw new ModelValidationError(issues, title ?? ctx.modelValidator?.message?.("validationFailed", {}) ?? "Validation failed");
+  }
+  return args;
+}
+
+/** One argument; a parameter problem is thrown as ParameterIssue or ModelValidationError. */
+async function bindOne(binding: ParameterBinding, ctx: HttpContext, defaults: BindingDefaults): Promise<unknown> {
+  switch (binding.source) {
+    case "route": {
+      const value = binding.name !== undefined ? ctx.params[binding.name] : undefined;
+      // Route params are already constraint-converted; re-convert only when
+      // the binding asks for a different primitive type.
+      if (value === undefined) return bindValue(binding, undefined, ctx);
+      if (binding.type && binding.type !== "string" && typeof value === "string") return converted(ctx, value, binding.type, binding.name ?? "?");
+      return value;
+    }
+    case "query":
+      return binding.array ? bindArray(binding, ctx) : bindValue(binding, ctx.query(binding.name ?? ""), ctx);
+    case "header":
+      return bindValue(binding, ctx.header(binding.name ?? ""), ctx);
+    case "queryModel":
+    case "headerModel":
+      return bindSourceModel(binding, ctx);
+    case "body": {
+      const contentType = ctx.header("content-type") ?? "";
+      if (defaults.consumes) {
+        if (!contentType.toLowerCase().startsWith(defaults.consumes.toLowerCase())) {
+          throw new UnsupportedMediaTypeError(defaults.consumes);
         }
-        const data = await ctx.json();
-        args[index] = binding.model ? await bindModelAsync(binding.model, data, ctx.modelValidator, { primitiveTypes: true }) : data;
-        break;
+      } else if (!isJsonMediaType(contentType)) {
+        // Convention-based body-model binding is a JSON boundary. Requiring
+        // a non-simple media type also prevents cross-origin text/plain POSTs
+        // from bypassing the browser's CORS preflight.
+        throw new UnsupportedMediaTypeError("application/json");
       }
-      case "request":
-        args[index] = ctx.request;
-        break;
-      case "response":
-        args[index] = ctx.res;
-        break;
-      case "context":
-        args[index] = ctx;
-        break;
-      case "list": {
-        let parsed;
-        try {
-          parsed = parseListQuery(ctx.url.searchParams, binding.listOptions);
-        } catch (error) {
-          if (error instanceof ListQueryError) {
-            throw frameworkBadRequest("invalidListQuery", undefined, error.problems);
-          }
-          throw error;
-        }
-        if (binding.model) {
-          // Class-based list request (extends ListRequest): instantiate and
-          // populate the parsed sort/filters/page so the action gets a typed object.
-          args[index] = Object.assign(new (binding.model as new () => object)(), parsed);
-        } else {
-          args[index] = parsed;
+      const data = await ctx.json();
+      return binding.model ? bindModelAsync(binding.model, data, ctx.modelValidator, { primitiveTypes: true }) : data;
+    }
+    case "request":
+      return ctx.request;
+    case "response":
+      return ctx.res;
+    case "context":
+      return ctx;
+    case "list": {
+      let parsed;
+      try {
+        parsed = parseListQuery(ctx.url.searchParams, binding.listOptions);
+      } catch (error) {
+        if (error instanceof ListQueryError) {
+          throw frameworkBadRequest("invalidListQuery", undefined, error.problems);
         }
-        break;
+        throw error;
       }
+      // Class-based list request (extends ListRequest): instantiate and
+      // populate the parsed sort/filters/page so the action gets a typed object.
+      return binding.model ? Object.assign(new (binding.model as new () => object)(), parsed) : parsed;
     }
   }
-  return args;
 }
 
 function isJsonMediaType(contentType: string): boolean {

package/core/http/Binding/convert.ts

@@ -1,4 +1,3 @@
-import { frameworkBadRequest } from "../Errors/HttpError";
 
 /** Primitive conversion targets for query/header/route values. */
 export type ValueType = "string" | "int" | "number" | "bool";
@@ -37,12 +36,3 @@ export function tryConvert(raw: string, type: ValueType): string | number | bool
       return INVALID;
   }
 }
-
-/** Converts or throws 400 with the parameter name in the message. */
-export function convertOr400(raw: string, type: ValueType, parameterName: string): string | number | boolean {
-  const value = tryConvert(raw, type);
-  if (value === INVALID) {
-    throw frameworkBadRequest("invalidParameter", { name: parameterName, type, value: raw });
-  }
-  return value;
-}

package/core/http/Errors/messages.ts

@@ -43,8 +43,6 @@ export type HttpMessageKey =
   | "bodyTooDeep"
   | "bodyTooComplex"
   | "bodyCyclic"
-  | "missingParameter"
-  | "invalidParameter"
   | "invalidListQuery";
 
 export const EN_HTTP_MESSAGES: Readonly<Record<HttpMessageKey, string>> = Object.freeze({
@@ -75,8 +73,6 @@ export const EN_HTTP_MESSAGES: Readonly<Record<HttpMessageKey, string>> = Object
   bodyTooDeep: "Request body is too deeply nested",
   bodyTooComplex: "Request body is too complex",
   bodyCyclic: "Request body must be acyclic JSON",
-  missingParameter: 'Missing required {kind} parameter "{name}"',
-  invalidParameter: 'Parameter "{name}" must be of type {type}, got: "{value}"',
   invalidListQuery: "Invalid list query",
 });
 
@@ -108,8 +104,6 @@ export const RU_HTTP_MESSAGES: Readonly<Record<HttpMessageKey, string>> = Object
   bodyTooDeep: "Слишком глубокая вложенность в теле запроса",
   bodyTooComplex: "Тело запроса слишком сложное",
   bodyCyclic: "Тело запроса не должно содержать циклов",
-  missingParameter: 'Не передан обязательный параметр "{name}"',
-  invalidParameter: 'Параметр "{name}": ожидается {type}, получено: "{value}"',
   invalidListQuery: "Некорректные параметры списка",
 });
 

package/core/http/README.md

@@ -99,6 +99,12 @@ export class TenantHeaders {
 - Misuse (`FromHeader<string[]>`, a name on a model, `FromRoute` outside the
   template, `FromBody<string>`) is `BAZIS_HTTP_BINDING_UNRESOLVED`.
 
+Every argument is bound even when another one fails: missing or invalid
+route, query and header values and the validation errors of all models come
+in one `400 Validation failed` with `details` (`code` `required`, `type`,
+`duplicate`, rule codes), like ASP.NET model state. Errors of the request
+itself (malformed JSON, media type, size) stop at once with their own text.
+
 Checking allowed values belongs to the Validator or the service.
 
 A `ctx: HttpContext` parameter stays a regular supported input. For older manual

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.101.0" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.103.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/infra/connectors/codex.ts

@@ -5,12 +5,18 @@ import { reader, requireValue } from "../connectorConfig";
 import { CodexAppServerClient } from "./codex/CodexAppServerClient";
 import type { CodexClient, CodexConfigShape } from "./codex/contracts";
 
-export const CODEX_APP_SERVER: InjectionToken<CodexClient> = createToken<CodexClient>("CodexClient");
+/**
+ * Codex App Server client of the `codexAppServerConnect()` connector,
+ * injected by type like the other infra clients:
+ * `constructor(private readonly codex: ICodex)`.
+ */
+export interface ICodex extends CodexClient {}
+export const ICodex = createToken<ICodex>("ICodex") as InjectionToken<CodexClient>;
 
 /** App Server is a full executor; it does not implement the raw AgentModelProvider port. */
 export function codexAppServerConnect(config: AppConfig<CodexConfigShape>): InfraConnector<CodexClient> {
   return {
-    token: CODEX_APP_SERVER, config, phase: 0,
+    token: ICodex, config, phase: 0,
     create(configs) {
       const view = reader(config, configs);
       return new CodexAppServerClient({

package/core/infra/index.ts

@@ -7,7 +7,7 @@ export { Infra, infraModule, type InfraManifest } from "./Infra";
 export { InfraError, errorMessage, type ConnectionDescription, type InfraConnector } from "./InfraConnector";
 export { InfraLifecycle } from "./InfraLifecycle";
 export { reader, requireValue, settingNames, type ConfigReader } from "./connectorConfig";
-export { codexAppServerConnect, CODEX_APP_SERVER } from "./connectors/codex";
+export { codexAppServerConnect, ICodex } from "./connectors/codex";
 export { CodexError, RU_CODEX_MESSAGES, type CodexErrorCode, CODEX_MODEL_ID, CODEX_REASONING_EFFORT, type CodexClient, type CodexConfigShape, type CodexLogin, type CodexLoginMethod, type CodexModel, type CodexStatus, type CodexRunInput, type CodexChatMessage, type CodexTool, type CodexToolCall, type CodexToolResult } from "./connectors/codex/contracts";
 
 export { postgres, IPostgres, postgresConnectionOptions, type PostgresConfigShape, type PostgresSslMode, type PostgresConnectorOptions } from "./connectors/postgres";

package/package.json

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