bazis 0.105.2 → 0.106.0

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/ServiceProvider.ts

@@ -1,6 +1,7 @@
 import {
   AsyncResolutionRequiredError,
   ClassDependenciesMismatchError,
+  DiError,
   InvalidProviderError,
   NamedDependencyNotFoundError,
   ProviderNotFoundError,
@@ -44,7 +45,27 @@ import {
 import type { Token } from "./token";
 import { tokenToDebugName } from "./token";
 
+/**
+ * `ServiceProvider` as a service in a scope sees that scope, as .NET's
+ * IServiceProvider does: `resolve` returns the scope's services and
+ * `createScope()` opens a new one. The scope is disposed by whoever created it.
+ */
+class ScopeServiceProvider extends ServiceScope {
+  public constructor(provider: ConstructorParameters<typeof ServiceScope>[0], state: ResolutionScopeState, private readonly root: ServiceProvider) {
+    super(provider, state);
+  }
+
+  public createScope(): ServiceScope {
+    return this.root.createScope();
+  }
+
+  public override dispose(): Promise<void> {
+    return Promise.reject(new DiError("This ServiceProvider is the scope that resolved the service; whoever created the scope disposes it. To own a scope, call createScope() and dispose that one."));
+  }
+}
+
 export class ServiceProvider implements ServiceResolver {
+  private readonly scopeProviders = new WeakMap<ResolutionScopeState, ScopeServiceProvider>();
   private readonly registry: ServiceRegistry;
   private readonly activations = new ResolutionTracker();
   private readonly lifetime: ScopeLifecycle;
@@ -185,6 +206,17 @@ export class ServiceProvider implements ServiceResolver {
     return this.lifetime.disposeScope(scopeState);
   }
 
+  /** `ServiceProvider` asked for inside a scope: the scope itself, not the root. */
+  private providerForScope<T>(token: Token<T>, key: ServiceKey | undefined, scopeState: ResolutionScopeState): T | undefined {
+    if (token !== (ServiceProvider as unknown) || key !== undefined || scopeState.isRoot) return undefined;
+    let view = this.scopeProviders.get(scopeState);
+    if (view === undefined) {
+      view = new ScopeServiceProvider(this, scopeState, this);
+      this.scopeProviders.set(scopeState, view);
+    }
+    return view as unknown as T;
+  }
+
   private resolveSingle<T>(
     token: Token<T>,
     key: ServiceKey | undefined,
@@ -192,6 +224,8 @@ export class ServiceProvider implements ServiceResolver {
     stack: ResolutionActivation[],
     ownerLifetime: ProviderLifetime | undefined,
   ): T {
+    const scopeProvider = this.providerForScope(token, key, scopeState);
+    if (scopeProvider !== undefined) return scopeProvider;
     const registration = this.registry.find(token, key);
     if (!registration) {
       throw new ProviderNotFoundError(token, this.describeResolutionPath(stack, token));
@@ -278,6 +312,8 @@ export class ServiceProvider implements ServiceResolver {
     stack: ResolutionActivation[],
     ownerLifetime?: ProviderLifetime,
   ): Promise<T> {
+    const scopeProvider = this.providerForScope(token, key, scopeState);
+    if (scopeProvider !== undefined) return scopeProvider;
     const registration = this.registry.find(token, key);
     if (!registration) {
       throw new ProviderNotFoundError(token, this.describeResolutionPath(stack, token));
@@ -733,6 +769,8 @@ export class ServiceProvider implements ServiceResolver {
     ownerLifetime: ProviderLifetime | undefined,
   ): T | undefined {
     this.lifetime.assertLive(scopeState);
+    const scopeProvider = this.providerForScope(token, key, scopeState);
+    if (scopeProvider !== undefined) return scopeProvider;
     const registration = this.registry.find(token, key);
     if (!registration) {
       return 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.106.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/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.106.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",