bazis 0.105.2 → 0.105.3

package/core/app/runApp.ts

@@ -21,6 +21,7 @@ import {
 } from "../../library/ui";
 import { modelValidatorAdapter } from "../../library/validation";
 import { createLocalize, type AppLanguage, type AppMessages } from "./messages";
+import { useCodexLanguage } from "../infra/connectors/codex/contracts";
 import {
   type RunAppUiOptions,
   type RunAppUiSurfaceOptions,
@@ -290,6 +291,7 @@ export async function runApp(root: BazisModuleRef, options: RunAppOptions = {}):
 export function composeApp(root: BazisModuleRef, options: RunAppOptions = {}): BazisModuleRef {
   // Checked even without HTTP: an unknown language is a startup error.
   const localize = createLocalize(options.language, options.messages);
+  useCodexLanguage(options.language ?? "en");
   // Infrastructure and cache are global modules; add them to the graph next to the feature root.
   const globals: BazisModuleRef[] = [];
   if (options.infra !== undefined) {

package/core/di/internal/GraphValidator.ts

@@ -1,6 +1,6 @@
 import { ServiceValidationError } from "../errors";
 import { missingNamedDependencyIssue } from "../errors/NamedDependencyNotFoundError";
-import { isLazyDependency, isNamedDependency, isOptionalDependency } from "../provider";
+import { isClassProvider, isLazyDependency, isNamedDependency, isOptionalDependency } from "../provider";
 import type {
   KeyedDependency,
   NamedDependency,
@@ -99,7 +99,7 @@ export class GraphValidator {
         const inner = isLazy || isOptional ? dependency.inner : dependency;
         // An optional dependency on a name nothing registered is simply absent.
         if (isNamedDependency(inner) && !this.context.hasName(inner.name)) {
-          if (!isOptional) issues.add(missingNamedDependencyIssue(inner.name, tokenToDebugName(registration.token)));
+          if (!isOptional) issues.add(missingNamedDependencyIssue(inner.name, serviceName(registration)));
           continue;
         }
         const descriptor = this.context.describeDependency(inner);
@@ -109,15 +109,15 @@ export class GraphValidator {
         }
         if (!depRegistration) {
           issues.add(
-            `Missing dependency "${tokenToDebugName(descriptor.token)}" for "${tokenToDebugName(registration.token)}"`,
+            `Missing dependency "${tokenToDebugName(descriptor.token)}" for "${serviceName(registration)}"`,
           );
           continue;
         }
 
         if (this.context.validateScopes && rootLifetime === "singleton" && depRegistration.lifetime === "scoped") {
           issues.add(
-            `Singleton "${tokenToDebugName(registration.token)}" depends on scoped "${tokenToDebugName(descriptor.token)}". `
-              + `A scoped service lives for one request or scope: make "${tokenToDebugName(registration.token)}" scoped too, `
+            `Singleton "${serviceName(registration)}" depends on scoped "${tokenToDebugName(descriptor.token)}". `
+              + `A scoped service lives for one request or scope: make "${className(registration) ?? tokenToDebugName(registration.token)}" scoped too, `
               + `or inject ServiceProvider and resolve "${tokenToDebugName(descriptor.token)}" in a scope you create (provider.createScope()).`,
           );
         }
@@ -136,3 +136,17 @@ export class GraphValidator {
     }
   }
 }
+
+/** The class behind a token registration, when it is not the token itself: `singleton(LIFECYCLE_HOOK, WarmUp)`. */
+function className(registration: ServiceRegistration): string | undefined {
+  if (!isClassProvider(registration.provider)) return undefined;
+  const name = registration.provider.useClass.name;
+  return name && name !== tokenToDebugName(registration.token) ? name : undefined;
+}
+
+/** `WarmUp (as BazisLifecycleHook)` for a class under a token, else the token. */
+function serviceName(registration: ServiceRegistration): string {
+  const token = tokenToDebugName(registration.token);
+  const name = className(registration);
+  return name ? `${name} (as ${token})` : token;
+}

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.105.2" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.105.3" }, 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/contracts.ts

@@ -52,7 +52,7 @@ const EN_CODEX_MESSAGES: Readonly<Record<CodexErrorCode, string>> = Object.freez
   LOGIN_EXPIRED: "The sign-in window expired. Start signing in again.",
 });
 
-/** Russian texts for every code: `CodexError.useMessages(RU_CODEX_MESSAGES)` at startup. */
+/** Russian texts for every code; `runApp({ language: "ru" })` turns them on. */
 export const RU_CODEX_MESSAGES: Readonly<Record<CodexErrorCode, string>> = Object.freeze({
   NOT_CONFIGURED: "Подключение ChatGPT не настроено на сервере.",
   UNAVAILABLE: "Codex App Server недоступен. Проверьте его установку и настройки.",
@@ -67,15 +67,31 @@ export const RU_CODEX_MESSAGES: Readonly<Record<CodexErrorCode, string>> = Objec
   LOGIN_EXPIRED: "Время для входа истекло. Начните вход заново.",
 });
 
+const CODEX_LANGUAGES = { en: EN_CODEX_MESSAGES, ru: RU_CODEX_MESSAGES } as const;
+let language: Readonly<Record<CodexErrorCode, string>> = EN_CODEX_MESSAGES;
+let own: Partial<Record<CodexErrorCode, string>> = {};
 let messages: Readonly<Record<CodexErrorCode, string>> = EN_CODEX_MESSAGES;
 
-/** `message` is user-facing text for `code`; switch its language with `useMessages`. */
+/**
+ * @internal `runApp({ language })` sets the language of the texts. It is
+ * process-wide, like the texts themselves: the last started application wins.
+ */
+export function useCodexLanguage(name: keyof typeof CODEX_LANGUAGES): void {
+  language = CODEX_LANGUAGES[name];
+  messages = Object.freeze({ ...language, ...own });
+}
+
+/** `message` is user-facing text for `code`, in the language of `runApp({ language })`. */
 export class CodexError extends Error {
   constructor(readonly code: CodexErrorCode) { super(messages[code]); this.name = "CodexError"; }
 
-  /** Replace texts for some or all codes (process-wide); missing codes keep English. */
+  /**
+   * Own texts for some or all codes (process-wide), on top of the application
+   * language; missing codes keep it. `useMessages({})` drops own texts.
+   */
   static useMessages(overrides: Partial<Record<CodexErrorCode, string>>): void {
-    messages = Object.freeze({ ...EN_CODEX_MESSAGES, ...overrides });
+    own = { ...overrides };
+    messages = Object.freeze({ ...language, ...own });
   }
 }
 export const CODEX_MODEL_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,120}$/;

package/package.json

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