bazis 0.98.4 → 0.98.5

package/core/http/Decorators/metadata.ts

@@ -54,15 +54,24 @@ function emptyMeta(): ControllerMeta {
   return { isController: false, middleware: [], filters: [], catches: [], actions: new Map() };
 }
 
+/**
+ * Actions of a subclass whose routes are still the base class's. The first
+ * route decorator of the subclass on such a method replaces them instead of
+ * adding a second, duplicate route.
+ */
+const inheritedRoutes = new WeakSet<ActionMeta>();
+
 function cloneMeta(source: ControllerMeta): ControllerMeta {
   const actions = new Map<string | symbol, ActionMeta>();
   for (const [name, action] of source.actions) {
-    actions.set(name, {
+    const copy: ActionMeta = {
       ...action,
       routes: [...action.routes],
       middleware: [...action.middleware],
       filters: [...action.filters],
-    });
+    };
+    if (copy.routes.length > 0) inheritedRoutes.add(copy);
+    actions.set(name, copy);
   }
   return {
     ...source,
@@ -98,6 +107,17 @@ export function ownActionMeta(metadata: object, methodName: string | symbol): Ac
   return action;
 }
 
+/**
+ * Routes of an action for a route decorator to add to. Routes inherited from
+ * the base class are dropped first: a subclass that declares routes on an
+ * overriding method replaces the base method's routes. Other settings of the
+ * base method (status code, middleware, version) stay inherited.
+ */
+export function ownRoutes(action: ActionMeta): RouteDeclaration[] {
+  if (inheritedRoutes.delete(action)) action.routes = [];
+  return action.routes;
+}
+
 /** Reads controller metadata from a class (undefined if not decorated). */
 export function controllerMetaOf(ctor: object): ControllerMeta | undefined {
   const metadata = (ctor as { [key: symbol]: unknown })[Symbol.metadata as unknown as symbol] as

package/core/http/Decorators/routes.ts

@@ -1,6 +1,6 @@
 import type { HttpMiddleware } from "../Middleware/types";
 import { HttpSetupError } from "../Errors/HttpError";
-import { ownActionMeta } from "./metadata";
+import { ownActionMeta, ownRoutes } from "./metadata";
 
 type MethodDecorator = (value: (...args: never[]) => unknown, context: ClassMethodDecoratorContext) => void;
 
@@ -39,7 +39,7 @@ function route(httpMethod: string, templateOrOptions?: string | RouteOptions, ma
       throw new Error(`HTTP route decorators support public instance methods only ("${String(context.name)}").`);
     }
     const action = ownActionMeta(context.metadata, context.name);
-    action.routes.push({ httpMethod, template });
+    ownRoutes(action).push({ httpMethod, template });
     if (options) {
       // Options apply to the whole action (like attribute decorators); with
       // several route decorators scalar fields are overwritten and

package/core/http/SPEC.md

@@ -228,6 +228,26 @@ class DerivedController extends BaseController {}
 // DerivedController inherits sharedMiddleware
 ```
 
+Routes are inherited too, which is how a new API version is built on the old one:
+
+```ts
+@Controller("notes") @ApiVersion("2")
+class NotesV2Controller extends NotesV1Controller {
+  @Get(":noteId") override getById(noteId: string) { ... } // replaces GET :id of v1
+  override text(id: string) { ... }                         // keeps the v1 route
+}
+```
+
+- A method the subclass does not override keeps its routes, served by the base implementation.
+- An override without route decorators keeps the base method's routes; its own parameters are bound.
+- Route decorators on an override replace the base method's routes (since 0.98.5; before, they
+  were added to them, and startup failed with a duplicate route). Other settings of the base
+  method — status code, middleware, version — stay inherited.
+
+Codegen follows the `extends` chain, so inherited actions get argument bindings for the subclass
+(since 0.98.5; before, a subclass without own route decorators got none, and an override received
+`HttpContext` in place of its parameters).
+
 ### The equivalent through inline route options
 
 `RouteOptions.middleware` on `@Get`/`@Post` writes into the same `ActionMeta.middleware`:

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

@@ -1089,12 +1089,11 @@ function hasDecorator(node: ts.HasDecorators, name: string): boolean {
  * template, parsed like `Routing/template.ts` (`:name`, `:name(int)`, `*name`,
  * and a bare `*` named `rest`).
  */
-function routeParamNames(method: ts.MethodDeclaration): Set<string> {
+function routeParamNames(controller: ts.ClassDeclaration, method: ts.MethodDeclaration): Set<string> {
   const names = new Set<string>();
   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(controller) ?? [], (name) => name === "Controller"],
     [ts.getDecorators(method) ?? [], (name) => ROUTE_DECORATORS.has(name)],
   ];
   for (const [decorators, accepts] of sources) {
@@ -1394,23 +1393,9 @@ function collectControllerBindings(node: ts.ClassDeclaration, controllerName: st
   }
   httpControllerFiles[controllerName] = filePath;
 
-  for (const member of node.members) {
-    if (!ts.isMethodDeclaration(member) || !ts.isIdentifier(member.name)) {
-      continue;
-    }
-    const decorators = ts.getDecorators(member) ?? [];
-    const hasRoute = decorators.some((decorator) => {
-      const info = decoratorCall(decorator);
-      return info !== undefined && ROUTE_DECORATORS.has(info.name);
-    });
-    if (hasRoute) {
-      collectOpenApiOperation(controllerName, member);
-    }
-    if (!hasRoute) {
-      continue;
-    }
-
-    const routeParams = routeParamNames(member);
+  for (const { name, routes, member } of controllerActions(node)) {
+    collectOpenApiOperation(controllerName, member);
+    const routeParams = routeParamNames(node, routes);
     const specs: HttpBindingSpec[] = [];
     let bodyCount = 0;
     let failed: string | undefined;
@@ -1469,15 +1454,59 @@ function collectControllerBindings(node: ts.ClassDeclaration, controllerName: st
 
     if (failed) {
       fatalErrors.push(
-        `BAZIS_HTTP_BINDING_UNRESOLVED: controller "${controllerName}.${member.name.text}" (${filePath}): cannot infer bindings (${failed}). ` +
+        `BAZIS_HTTP_BINDING_UNRESOLVED: controller "${controllerName}.${name}" (${filePath}): cannot infer bindings (${failed}). ` +
           `Use supported parameter types; read headers or raw bodies through HttpContext, and inject services in the constructor.`,
       );
       continue;
     }
-    (httpBindings[controllerName] ??= {})[member.name.text] = specs;
+    (httpBindings[controllerName] ??= {})[name] = specs;
   }
 }
 
+interface ControllerAction {
+  readonly name: string;
+  /** Declaration whose route decorators give the routes. */
+  readonly routes: ts.MethodDeclaration;
+  /** Declaration that runs: its parameters are bound. */
+  readonly member: ts.MethodDeclaration;
+}
+
+/**
+ * Route methods of a controller, including those inherited from base classes,
+ * as the runtime sees them: the nearest declaration with route decorators
+ * gives the routes (a subclass's own decorators replace the base's), the
+ * nearest implementation gives the parameters (an override without
+ * decorators keeps the base routes with its own signature).
+ */
+function controllerActions(node: ts.ClassDeclaration): ControllerAction[] {
+  const routes = new Map<string, ts.MethodDeclaration>();
+  const members = new Map<string, ts.MethodDeclaration>();
+  const seen = new Set<ts.ClassDeclaration>();
+  for (let current: ts.ClassDeclaration | undefined = node; current && !seen.has(current); current = baseClassDeclaration(current)) {
+    seen.add(current);
+    for (const member of current.members) {
+      if (!ts.isMethodDeclaration(member) || !ts.isIdentifier(member.name)) continue;
+      const name = member.name.text;
+      if (!members.has(name) && member.body !== undefined) members.set(name, member);
+      if (!routes.has(name) && hasRouteDecorator(member)) routes.set(name, member);
+    }
+  }
+  return [...routes].map(([name, declaration]) => ({ name, routes: declaration, member: members.get(name) ?? declaration }));
+}
+
+function hasRouteDecorator(member: ts.MethodDeclaration): boolean {
+  return (ts.getDecorators(member) ?? []).some((decorator) => {
+    const info = decoratorCall(decorator);
+    return info !== undefined && ROUTE_DECORATORS.has(info.name);
+  });
+}
+
+function baseClassDeclaration(node: ts.ClassDeclaration): ts.ClassDeclaration | undefined {
+  const clause = node.heritageClauses?.find((item) => item.token === ts.SyntaxKind.ExtendsKeyword);
+  const base = clause?.types[0]?.expression;
+  return base === undefined ? undefined : classDeclarationForExpression(base);
+}
+
 /** `limit = 100` has no type annotation — infer the primitive from the default value. */
 function inferTypeFromInitializer(initializer: ts.Expression | undefined): HttpBindingSpec["type"] | undefined {
   if (!initializer) {

package/package.json

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