bazis 0.96.3 → 0.96.5

package/core/http/README.md

@@ -52,7 +52,7 @@ Instead there are ASP.NET-style conventions that codegen infers from the signatu
 
 | Method parameter | Binding |
 |---|---|
-| the name matches the route `:name` | the route value (converted by the constraint/type) |
+| the name matches a route parameter: `:name` in the method or `@Controller` template, or a wildcard `*name` (a bare `*` is `rest`) | the route value (converted by the constraint/type) |
 | a DTO class from the application sources | the request body + `@Validator` validation (errors -> 400) |
 | `HttpContext` / `Request` / `ResponseBuilder` | context / raw request / response builder |
 | a primitive (`string`/`number`/`boolean` or inferred from the default) | a query parameter; `?` and a default -> optional |

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.96.3" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.96.5" }, 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/kernel/config/README.md

@@ -29,8 +29,10 @@ empty or whitespace value. TypeScript forbids unsupported object types.
 
 A declaration stores no chosen environment, values or cache. `get/has/ensureValid`
 stay for standalone reading of the process env, but `ensureValid` no longer
-switches later reads. Host code gets `resolve`, a service injects
-`definition.token`, a connector gets `ConfigRegistry` as the create argument.
+switches later reads. Host code gets `resolve`, a service declares
+`ConfigView<T>` in its constructor (codegen binds it to the token of the one
+`defineConfig<T>(...)` declaration; the type argument is required) or injects
+`definition.token` explicitly, a connector gets `ConfigRegistry` as the create argument.
 All built-in connectors use this argument; a custom connector reads
 `configs?.get(config) ?? config`. A direct global get inside a service does not
 read the settings of its kernel.

package/core/scripts/di-generate.ts

@@ -162,6 +162,9 @@ let inferredDiClasses = new Set<ts.ClassDeclaration>();
 let explicitlyBoundDiClasses = new Set<ts.ClassDeclaration>();
 // Known runtime token names: createToken descriptions + class names usable as class-tokens.
 let tokenDescriptions = new Set<string>();
+// defineConfig<T>("prefix") declarations by the name of T: a ConfigView<T>
+// constructor parameter binds to the token of that declaration.
+let configPrefixesByType = new Map<string, Set<string>>();
 let knownClassNames = new Set<string>();
 let warnings: string[] = [];
 let fatalErrors: string[] = [];
@@ -446,7 +449,7 @@ function collectDynamicImportDiagnostics(source: ts.SourceFile, target: string,
 function resetTargetAnalysis(files: Set<string>, generatedDir: string): void {
   activeGeneratedDir = generatedDir;
   classDeps = new Map(); inferredDiClasses = new Set(); explicitlyBoundDiClasses = new Set();
-  tokenDescriptions = new Set(); knownClassNames = new Set(); warnings = []; fatalErrors = [];
+  tokenDescriptions = new Set(); configPrefixesByType = new Map(); knownClassNames = new Set(); warnings = []; fatalErrors = [];
   httpBindings = {}; httpControllerFiles = {}; openApiSchemas = {}; openApiOperations = {};
   grpcBindings = new Map();
   uiProfileResponseModels = new Map(); openApiSchemaModels = new Map(); requestModelClassNames = new Set(); listRequestClassNames = new Set();
@@ -476,6 +479,7 @@ async function generateTarget(name: string, reachable: Set<string>, production:
     }
     collectHttpBindings(source); collectOpenApiSchemas(source); collectUiProfileResponseModels(source);
   }
+  resolveConfigViewDeps();
   validateDepsAgainstKnownTokens();
   const requestModelImports = resolveRequestModelImports();
   const requestModelHydration = resolveRequestModelHydration(requestModelImports);
@@ -711,6 +715,13 @@ function collectTokenDescriptions(source: ts.SourceFile): void {
         if (node.expression.text === "createToken" || node.expression.text === "createOpenGenericTokenFamily") {
           tokenDescriptions.add(firstArg.text);
         }
+        if (node.expression.text === "defineConfig") {
+          // The same description defineConfig gives its token.
+          const prefix = firstArg.text || "default";
+          tokenDescriptions.add(`Config:${prefix}`);
+          const typeName = node.typeArguments?.[0] && getDependencyTypeName(node.typeArguments[0]);
+          if (typeName) configPrefixesByType.set(typeName, (configPrefixesByType.get(typeName) ?? new Set()).add(prefix));
+        }
       }
     }
     if (ts.isClassDeclaration(node) && node.name) {
@@ -722,6 +733,39 @@ function collectTokenDescriptions(source: ts.SourceFile): void {
   ts.forEachChild(source, visit);
 }
 
+/**
+ * Replaces each `ConfigView<T>` placeholder with the token of the one
+ * `defineConfig<T>(...)` declaration. Runs after every source was read, because
+ * a service may come before the file that declares its configuration.
+ */
+function resolveConfigViewDeps(): void {
+  for (const [declaration, deps] of classDeps) {
+    let changed = false;
+    const resolved: CollectedDependency[] = [];
+    for (const [index, dep] of deps.entries()) {
+      const typeName = /^ConfigView<(.+)>$/.exec(dep.name)?.[1];
+      if (typeName === undefined) {
+        resolved.push(dep);
+        continue;
+      }
+      const prefixes = [...(configPrefixesByType.get(typeName) ?? [])];
+      if (prefixes.length !== 1) {
+        classDeps.delete(declaration);
+        if (needsInferredDiDeps(declaration)) {
+          fatalErrors.push(prefixes.length === 0
+            ? `BAZIS_DI_CONFIG_UNKNOWN: ${sourceLocation(declaration)}: constructor parameter ${index + 1} of "${declaration.name?.text}" has type "ConfigView<${typeName}>", but no defineConfig<${typeName}>(...) declaration was found. Declare the configuration with an explicit type argument, for example defineConfig<${typeName}>("name", { default: {...} }).`
+            : `BAZIS_DI_CONFIG_AMBIGUOUS: ${sourceLocation(declaration)}: constructor parameter ${index + 1} of "${declaration.name?.text}" has type "ConfigView<${typeName}>", which matches several declarations: ${prefixes.map((prefix) => `"${prefix}"`).join(", ")}. Give each declaration its own type, or pass the token explicitly: scoped(Service, Service, [config.token]).`);
+        }
+        changed = false;
+        break;
+      }
+      resolved.push({ name: `Config:${prefixes[0]}` });
+      changed = true;
+    }
+    if (changed && classDeps.has(declaration)) classDeps.set(declaration, resolved);
+  }
+}
+
 function validateDepsAgainstKnownTokens(): void {
   for (const [declaration, deps] of classDeps) {
     for (let index = 0; index < deps.length; index += 1) {
@@ -910,6 +954,11 @@ function dependencyFromType(type: ts.Type): CollectedDependency | undefined {
   const name = declaration?.name?.text ?? type.aliasSymbol?.name ?? symbol?.name;
   if (!name || BUILTIN_DEPENDENCY_NAMES.has(name)) return undefined;
   const arguments_ = type.flags & ts.TypeFlags.Object ? checker.getTypeArguments(type as ts.TypeReference) : [];
+  if (name === "ConfigView") {
+    const configType = arguments_[0];
+    const configTypeName = configType && (configType.aliasSymbol?.name ?? configType.getSymbol()?.name);
+    return configTypeName ? { name: `ConfigView<${configTypeName}>` } : undefined;
+  }
   if (name === "Lazy" || name === "IRepository") {
     const inner = arguments_[0] && dependencyFromType(arguments_[0]);
     if (!inner) return undefined;
@@ -950,6 +999,15 @@ function readConstructorTypeNames(node: ts.ClassDeclaration): ConstructorDepende
       continue;
     }
 
+    if (refName === "ConfigView" && paramType && ts.isTypeReferenceNode(paramType)) {
+      const configType = paramType.typeArguments?.[0];
+      const configTypeName = configType ? getDependencyTypeName(configType) : undefined;
+      if (configTypeName) {
+        deps.push({ name: `ConfigView<${configTypeName}>` });
+        continue;
+      }
+    }
+
     if (refName === "IRepository" && paramType && ts.isTypeReferenceNode(paramType)) {
       const entityType = paramType.typeArguments?.[0];
       const entityName = entityType ? getDependencyTypeName(entityType) : undefined;
@@ -1009,22 +1067,31 @@ function hasDecorator(node: ts.HasDecorators, name: string): boolean {
 }
 
 /** Route parameter names from all route decorators of a method (":id(int)" -> "id"). */
+/**
+ * Route parameter names of an action: the `@Controller` prefix and the method
+ * template, parsed like `Routing/template.ts` (`:name`, `:name(int)`, `*name`,
+ * and a bare `*` named `rest`).
+ */
 function routeParamNames(method: ts.MethodDeclaration): Set<string> {
   const names = new Set<string>();
-  for (const decorator of ts.getDecorators(method) ?? []) {
-    const info = decoratorCall(decorator);
-    if (!info?.call || !ROUTE_DECORATORS.has(info.name)) {
-      continue;
-    }
-    const firstArg = info.call.arguments[0];
-    if (!firstArg || !ts.isStringLiteralLike(firstArg)) {
-      continue;
+  const templates: string[] = [];
+  const owner = method.parent;
+  const sources: readonly [readonly ts.Decorator[], (name: string) => boolean][] = [
+    [ts.isClassDeclaration(owner) ? ts.getDecorators(owner) ?? [] : [], (name) => name === "Controller"],
+    [ts.getDecorators(method) ?? [], (name) => ROUTE_DECORATORS.has(name)],
+  ];
+  for (const [decorators, accepts] of sources) {
+    for (const decorator of decorators) {
+      const info = decoratorCall(decorator);
+      const firstArg = info?.call?.arguments[0];
+      if (info && accepts(info.name) && firstArg && ts.isStringLiteralLike(firstArg)) templates.push(firstArg.text);
     }
-    for (const segment of firstArg.text.split("/")) {
-      const match = /^:([A-Za-z_][A-Za-z0-9_]*)/.exec(segment);
-      if (match) {
-        names.add(match[1] as string);
-      }
+  }
+  for (const template of templates) {
+    for (const segment of template.split("/")) {
+      const param = /^:([A-Za-z_][A-Za-z0-9_]*)/.exec(segment);
+      if (param) names.add(param[1] as string);
+      else if (segment.startsWith("*")) names.add(segment.length > 1 ? segment.slice(1) : "rest");
     }
   }
   return names;

package/package.json

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