@dudousxd/nestjs-codegen 0.14.2 → 0.16.0

package/CHANGELOG.md

@@ -1,5 +1,54 @@
 # @dudousxd/nestjs-codegen
 
+## 0.16.0
+
+### Minor Changes
+
+- Discover routes on mixin (factory-produced) controllers.
+
+  A `@Controller` class whose heritage clause is a factory call now contributes the
+  decorated methods of the class that factory returns:
+
+  ```ts
+  @Controller("base/util/search")
+  export class SearchUtilController extends createTableController(Util, {
+    dto: UtilDTO,
+  }) {}
+  ```
+
+  NestJS already routes inherited methods at runtime via the prototype chain; the
+  static discovery pass now follows the same link. Each such route carries a new
+  `controllerRef.mixin` binding recording the factory and its call-site class
+  arguments — the decorator arguments _inside_ a factory reference its own
+  parameters, so the concrete entity is only knowable from the call site.
+
+  That binding drives two things:
+
+  - **`filterFields`** are derived from the call-site entity, so
+    `@ApplyFilter(GeneratedFilter)` works even though the filter class is declared
+    inside the factory and its `@Filterable({ entity })` names a parameter. This is
+    also what flips these routes from mutation to query in the emitted client.
+  - **Response types** are instantiated against the derived class, so
+    `Paginated<D>` resolves to the concrete `D`. This needs the type checker, which
+    needs lib files — the discovery Project sets `skipLoadingLibFiles` for
+    cold-start speed, so mixin response types resolve through a second Project
+    built lazily on the first mixin controller.
+
+  **Behaviour change:** `joinPaths` now always emits a leading slash.
+  `@Controller('items')` + `@Post(':id')` previously produced `items/:id` while
+  `@Controller('items')` alone produced `/items` — the prefix+suffix branch was the
+  only one that did not add it. The client's `buildUrl()` normalises before
+  requesting, so no URL was ever broken by this, but the raw value reaches the
+  emitted `ROUTES` map and the OpenAPI export, where a path without a leading slash
+  is invalid.
+
+## 0.15.0
+
+### Minor Changes
+
+- 20db5c0: Emit `filterFields` as a runtime `as const` array on each filter leaf, alongside the existing type-level union, plus an `isFilterField` type guard exported from the generated `api.ts`. Previously the filterable field set existed only as a type, so a field name arriving as a plain `string` from runtime state (a saved view, a user-picked column) could not be passed to `filterQuery().where()` without a cast. Now `api.route.leaf().filterFields` is a `readonly [...] as const` value and `isFilterField(leaf.filterFields, value)` narrows an arbitrary string to the field union, so dynamic field names validate at runtime instead of being asserted with `as`. The runtime array is generated from the same discovered field list as the type-level union (single source in the emitter), so the value can never drift from the type. Purely additive — the guard is emitted only when a route carries filter fields, and leaves without a filter gain no new member.
+- 9b5298b: Add a `@QueryList()` param decorator and a `toStringList` normalizer to the `/nest` subpath for receiving array query params safely. Express (and Nest's default query parser) returns a bare `string` for a single-value query param (`?ids=a`) and a `string[]` only for two or more (`?ids=a&ids=b`), so `ParseArrayPipe` 400s the common single-select case. `@QueryList('ids')` normalizes `string | string[] | comma-joined string | undefined` into a clean `string[]` (`['a']`, `['a','b']`, `[]`), and `toStringList` is exported for the equivalent `class-transformer` `@Transform` on a DTO field. Pairs with the client's `arrayFormat` option: once the client sends `arrayFormat: 'repeat'`, the comma-split becomes a no-op fallback that still covers hand-rolled and `curl` callers. Documented under a new "Receiving array query params" docs page.
+
 ## 0.14.2
 
 ### Patch Changes

package/dist/cli/main.cjs

@@ -775,6 +775,9 @@ function buildErrorType(c) {
   }
   return c.contractSource.error ?? "unknown";
 }
+function filterFieldLiterals(fields) {
+  return fields?.length ? fields.map((f) => JSON.stringify(f)) : [];
+}
 function emitRouterTypeBlock(tree, indent, outDir, serialization) {
   const pad = " ".repeat(indent);
   const lines = [];
@@ -801,7 +804,8 @@ function emitRouterTypeBlock(tree, indent, outDir, serialization) {
       const params = buildParamsType(c.params);
       const safeMethod = JSON.stringify(method);
       const safeUrl = JSON.stringify(c.path);
-      const filterFields = c.contractSource.filterFields?.length ? c.contractSource.filterFields.map((f) => JSON.stringify(f)).join(" | ") : "never";
+      const filterLiterals = filterFieldLiterals(c.contractSource.filterFields);
+      const filterFields = filterLiterals.length ? filterLiterals.join(" | ") : "never";
       const stream = c.contractSource.stream ? "true" : "false";
       const binary = c.contractSource.binaryResponse ? "true" : "false";
       lines.push(
@@ -841,6 +845,7 @@ function buildRequestModel(c) {
   const TA = buildRouterTypeAccess(c.name);
   const withParams = hasPathParams(c.params);
   const { isGet, isQuery, hasBody, hasQuery } = requestShape(c.route);
+  const filterLiterals = filterFieldLiterals(c.contractSource.filterFields);
   const fields = [];
   if (withParams) fields.push(`params: ${TA}['params']`);
   if (hasQuery) fields.push(`query?: ${TA}['query']`);
@@ -870,7 +875,12 @@ function buildRequestModel(c) {
     // (`[name]` rather than `[name, undefined]`) so the bare `.queryKey()` is a
     // clean prefix that partial-matches every parametrized variant — making it
     // directly usable for `invalidateQueries`.
-    queryKeyExpr: `(input === undefined ? [${flat}] as const : [${flat}, input] as const)`
+    queryKeyExpr: `(input === undefined ? [${flat}] as const : [${flat}, input] as const)`,
+    // Runtime counterpart to the type-level `filterFields` union: the same
+    // discovered field list, emitted as a literal `[...] as const` so apps can
+    // validate a dynamic/user-supplied field string with `isFilterField(...)`
+    // instead of casting. Omitted for routes with no filter.
+    ...filterLiterals.length ? { filterFieldsExpr: `[${filterLiterals.join(", ")}] as const` } : {}
   };
 }
 function renderFetcherRequest(req, binaryResponse) {
@@ -905,9 +915,24 @@ function emitReqHelper() {
     ""
   ];
 }
+function emitFilterFieldGuard() {
+  return [
+    "/** Runtime guard: narrows `value` to one of the leaf's `filterFields` (a `readonly K[] as const`), so a dynamic field string can be passed to `.where()` without a cast. */",
+    "export function isFilterField<const K extends string>(",
+    "  fields: readonly K[],",
+    "  value: string,",
+    "): value is K {",
+    "  return (fields as readonly string[]).includes(value);",
+    "}",
+    ""
+  ];
+}
 function renderLeaf(pad, objKey, req, requestExpr, members, streamExpr) {
   const lines = [`${pad}${objKey}: (input?: ${req.inputType}) => ({`];
   lines.push(`${pad}  ...__req<${req.responseType}>(() => ${requestExpr}),`);
+  if (req.filterFieldsExpr) {
+    lines.push(`${pad}  filterFields: ${req.filterFieldsExpr},`);
+  }
   if (streamExpr) {
     lines.push(`${pad}  stream: () => ${streamExpr},`);
   }
@@ -1179,6 +1204,9 @@ function buildApiFile(routes, outDir, opts = {}) {
   lines.push("};");
   lines.push("");
   lines.push(...emitReqHelper());
+  if (contracted.some((r) => r.contract?.contractSource.filterFields?.length)) {
+    lines.push(...emitFilterFieldGuard());
+  }
   lines.push("export function createApi(fetcher: Fetcher) {");
   lines.push("  return {");
   lines.push(
@@ -2414,7 +2442,7 @@ var import_chokidar = __toESM(require("chokidar"), 1);
 // src/discovery/contracts-fast.ts
 var import_node_path15 = require("path");
 var import_fast_glob3 = __toESM(require("fast-glob"), 1);
-var import_ts_morph9 = require("ts-morph");
+var import_ts_morph10 = require("ts-morph");
 
 // src/discovery/dto-type-resolver.ts
 var import_ts_morph7 = require("ts-morph");
@@ -3393,6 +3421,12 @@ function toFilterFieldType(name, r) {
 }
 
 // src/discovery/filter-for.ts
+function resolveMixinEntityClass(mixin, project) {
+  const entityArg = mixin?.classArgs[0];
+  if (!entityArg) return void 0;
+  const file = project.getSourceFile(entityArg.filePath) ?? project.addSourceFileAtPathIfExists(entityArg.filePath);
+  return file?.getClass(entityArg.name);
+}
 function classifyFilterForHint(typeInit) {
   if (import_ts_morph6.Node.isStringLiteral(typeInit)) {
     switch (typeInit.getLiteralValue()) {
@@ -3466,7 +3500,9 @@ function extractFilterForHints(classDecl, project) {
   }
   return hints;
 }
-function extractApplyFilterInfo(method, sourceFile, project) {
+function extractApplyFilterInfo(method, sourceFile, project, mixin) {
+  const declFile = method.getSourceFile();
+  const mixinEntity = resolveMixinEntityClass(mixin, project);
   for (const param of method.getParameters()) {
     const filterDecorator = param.getDecorators().find((d) => d.getName() === "ApplyFilter");
     if (!filterDecorator) continue;
@@ -3486,12 +3522,12 @@ function extractApplyFilterInfo(method, sourceFile, project) {
       }
     }
     const filterClassName = filterClassArg.getText();
-    const resolved = findType(filterClassName, sourceFile, project);
-    if (resolved && resolved.kind === "class") {
-      const classDecl = resolved.decl;
+    const resolved = findType(filterClassName, declFile, project);
+    const classDecl = resolved?.kind === "class" ? resolved.decl : resolveLocalClassDeclaration(filterClassArg);
+    if (classDecl) {
       let fieldTypes = extractClassPropertyTypes(classDecl, project);
       if (fieldTypes.length === 0) {
-        fieldTypes = extractFilterableEntityFields(classDecl, project);
+        fieldTypes = extractFilterableEntityFields(classDecl, project, mixinEntity);
       }
       const filterForHints = extractFilterForHints(classDecl, project);
       if (filterForHints.size > 0) {
@@ -3576,22 +3612,29 @@ function extractClassPropertyTypes(classDecl, project) {
   }
   return fields;
 }
-function extractFilterableEntityFields(filterClass, project) {
+function resolveLocalClassDeclaration(identifier) {
+  if (!import_ts_morph6.Node.isIdentifier(identifier)) return void 0;
+  return identifier.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => n !== void 0 && import_ts_morph6.Node.isClassDeclaration(n));
+}
+function resolveDeclaredEntity(optionsArg, filterClass, project) {
+  if (!import_ts_morph6.Node.isObjectLiteralExpression(optionsArg)) return void 0;
+  const entityProp = optionsArg.getProperty("entity");
+  if (!entityProp || !import_ts_morph6.Node.isPropertyAssignment(entityProp)) return void 0;
+  const entityInit = entityProp.getInitializer();
+  if (!entityInit || !import_ts_morph6.Node.isIdentifier(entityInit)) return void 0;
+  const resolved = findType(entityInit.getText(), filterClass.getSourceFile(), project);
+  if (!resolved || resolved.kind !== "class") return void 0;
+  return resolved.decl;
+}
+function extractFilterableEntityFields(filterClass, project, entityOverride) {
   const filterableDecorator = filterClass.getDecorators().find((d) => d.getName() === "Filterable");
   if (!filterableDecorator) return [];
   const args = filterableDecorator.getArguments();
   if (args.length === 0) return [];
   const optionsArg = args[0];
   if (!import_ts_morph6.Node.isObjectLiteralExpression(optionsArg)) return [];
-  const entityProp = optionsArg.getProperty("entity");
-  if (!entityProp || !import_ts_morph6.Node.isPropertyAssignment(entityProp)) return [];
-  const entityInit = entityProp.getInitializer();
-  if (!entityInit || !import_ts_morph6.Node.isIdentifier(entityInit)) return [];
-  const entityName = entityInit.getText();
-  const filterSourceFile = filterClass.getSourceFile();
-  const resolvedEntity = findType(entityName, filterSourceFile, project);
-  if (!resolvedEntity || resolvedEntity.kind !== "class") return [];
-  const entityDecl = resolvedEntity.decl;
+  const entityDecl = entityOverride ?? resolveDeclaredEntity(optionsArg, filterClass, project);
+  if (!entityDecl) return [];
   const fields = collectEntityFields(
     entityDecl,
     entityDecl.getSourceFile(),
@@ -4016,9 +4059,9 @@ function unwrapNamedContainer(node, names) {
   }
   return node;
 }
-function extractDtoContract(method, sourceFile, project) {
+function extractDtoContract(method, sourceFile, project, mixin) {
   let body = extractBodyType(method, sourceFile, project);
-  const filterInfo = extractApplyFilterInfo(method, sourceFile, project);
+  const filterInfo = extractApplyFilterInfo(method, sourceFile, project, mixin);
   const query = extractQueryType(method, sourceFile, project);
   const uploads = extractUploadedFiles(method);
   const multipartBody = uploads.fields ? `{ ${uploads.fields} }` : null;
@@ -4128,12 +4171,94 @@ function resolveParamClass(method, decoratorName, sourceFile, project) {
   return null;
 }
 
-// src/discovery/zod-ast-to-ts.ts
+// src/discovery/heritage.ts
 var import_ts_morph8 = require("ts-morph");
+function unwrapExpression(node) {
+  let current = node;
+  while (import_ts_morph8.Node.isAsExpression(current) || import_ts_morph8.Node.isSatisfiesExpression(current) || import_ts_morph8.Node.isParenthesizedExpression(current) || import_ts_morph8.Node.isTypeAssertion(current)) {
+    current = current.getExpression();
+  }
+  return current;
+}
+function resolveReturnedClass(factoryDecl) {
+  const body = factoryDecl.getBody();
+  if (!body) return void 0;
+  const returns = body.getDescendants().filter((n) => import_ts_morph8.Node.isReturnStatement(n));
+  for (const ret of returns) {
+    const expr = ret.getExpression();
+    if (!expr) continue;
+    const inner = unwrapExpression(expr);
+    if (import_ts_morph8.Node.isClassExpression(inner)) {
+      return inner;
+    }
+    if (import_ts_morph8.Node.isIdentifier(inner)) {
+      const name = inner.getText();
+      const decl = body.getDescendants().find((n) => import_ts_morph8.Node.isClassDeclaration(n) && n.getName() === name);
+      if (decl) return decl;
+    }
+  }
+  return void 0;
+}
+function resolveInheritedMethods(cls) {
+  const expr = cls.getExtends()?.getExpression();
+  if (!expr || !import_ts_morph8.Node.isCallExpression(expr)) return void 0;
+  const callee = expr.getExpression();
+  if (!import_ts_morph8.Node.isIdentifier(callee)) return void 0;
+  const factoryDecl = callee.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => import_ts_morph8.Node.isFunctionDeclaration(n));
+  if (!factoryDecl) return void 0;
+  const returnedClass = resolveReturnedClass(factoryDecl);
+  if (!returnedClass) return void 0;
+  const classArgs = [];
+  for (const arg of expr.getArguments()) {
+    if (!import_ts_morph8.Node.isIdentifier(arg)) continue;
+    const decl = arg.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => import_ts_morph8.Node.isClassDeclaration(n));
+    if (decl) {
+      classArgs.push({
+        name: decl.getName() ?? arg.getText(),
+        filePath: decl.getSourceFile().getFilePath()
+      });
+    }
+  }
+  return {
+    methods: returnedClass.getMethods(),
+    factoryName: callee.getText(),
+    factoryFilePath: factoryDecl.getSourceFile().getFilePath(),
+    classArgs
+  };
+}
+var mixinTypeProject;
+function getMixinTypeProject() {
+  mixinTypeProject ??= new import_ts_morph8.Project({
+    skipAddingFilesFromTsConfig: true,
+    compilerOptions: { strict: true }
+  });
+  return mixinTypeProject;
+}
+function clearMixinTypeProject() {
+  mixinTypeProject = void 0;
+}
+function resolveInstantiatedReturnType(cls, methodName) {
+  const filePath = cls.getSourceFile().getFilePath();
+  const className = cls.getName();
+  if (!className) return void 0;
+  const project = getMixinTypeProject();
+  const sourceFile = project.getSourceFile(filePath) ?? project.addSourceFileAtPathIfExists(filePath);
+  const typedCls = sourceFile?.getClass(className);
+  if (!typedCls) return void 0;
+  const prop = typedCls.getType().getProperty(methodName);
+  if (!prop) return void 0;
+  const returnType = prop.getTypeAtLocation(typedCls).getCallSignatures()[0]?.getReturnType();
+  if (!returnType) return void 0;
+  const unwrapped = returnType.getSymbol()?.getName() === "Promise" ? returnType.getTypeArguments()[0] ?? returnType : returnType;
+  return unwrapped.getText(typedCls);
+}
+
+// src/discovery/zod-ast-to-ts.ts
+var import_ts_morph9 = require("ts-morph");
 function zodAstToTs(node) {
-  if (!import_ts_morph8.Node.isCallExpression(node)) return "unknown";
+  if (!import_ts_morph9.Node.isCallExpression(node)) return "unknown";
   const expr = node.getExpression();
-  if (import_ts_morph8.Node.isPropertyAccessExpression(expr)) {
+  if (import_ts_morph9.Node.isPropertyAccessExpression(expr)) {
     const methodName = expr.getName();
     const receiver = expr.getExpression();
     if (methodName === "optional") {
@@ -4157,17 +4282,17 @@ function zodAstToTs(node) {
       case "literal": {
         const lit = args[0];
         if (!lit) return "unknown";
-        if (import_ts_morph8.Node.isStringLiteral(lit)) return JSON.stringify(lit.getLiteralValue());
-        if (import_ts_morph8.Node.isNumericLiteral(lit)) return lit.getLiteralValue().toString();
-        if (lit.getKind() === import_ts_morph8.SyntaxKind.TrueKeyword) return "true";
-        if (lit.getKind() === import_ts_morph8.SyntaxKind.FalseKeyword) return "false";
+        if (import_ts_morph9.Node.isStringLiteral(lit)) return JSON.stringify(lit.getLiteralValue());
+        if (import_ts_morph9.Node.isNumericLiteral(lit)) return lit.getLiteralValue().toString();
+        if (lit.getKind() === import_ts_morph9.SyntaxKind.TrueKeyword) return "true";
+        if (lit.getKind() === import_ts_morph9.SyntaxKind.FalseKeyword) return "false";
         return "unknown";
       }
       case "enum": {
         const arrArg = args[0];
-        if (!arrArg || !import_ts_morph8.Node.isArrayLiteralExpression(arrArg)) return "unknown";
+        if (!arrArg || !import_ts_morph9.Node.isArrayLiteralExpression(arrArg)) return "unknown";
         const members = arrArg.getElements().map(
-          (el) => import_ts_morph8.Node.isStringLiteral(el) ? JSON.stringify(el.getLiteralValue()) : "unknown"
+          (el) => import_ts_morph9.Node.isStringLiteral(el) ? JSON.stringify(el.getLiteralValue()) : "unknown"
         );
         return members.join(" | ");
       }
@@ -4178,10 +4303,10 @@ function zodAstToTs(node) {
       }
       case "object": {
         const objArg = args[0];
-        if (!objArg || !import_ts_morph8.Node.isObjectLiteralExpression(objArg)) return "unknown";
+        if (!objArg || !import_ts_morph9.Node.isObjectLiteralExpression(objArg)) return "unknown";
         const lines = [];
         for (const prop of objArg.getProperties()) {
-          if (!import_ts_morph8.Node.isPropertyAssignment(prop)) continue;
+          if (!import_ts_morph9.Node.isPropertyAssignment(prop)) continue;
           const key = prop.getName();
           const valNode = prop.getInitializer();
           if (!valNode) continue;
@@ -4193,7 +4318,7 @@ function zodAstToTs(node) {
       }
       case "union": {
         const arrArg = args[0];
-        if (!arrArg || !import_ts_morph8.Node.isArrayLiteralExpression(arrArg)) return "unknown";
+        if (!arrArg || !import_ts_morph9.Node.isArrayLiteralExpression(arrArg)) return "unknown";
         return arrArg.getElements().map(zodAstToTs).join(" | ");
       }
       case "record": {
@@ -4203,7 +4328,7 @@ function zodAstToTs(node) {
       }
       case "tuple": {
         const arrArg = args[0];
-        if (!arrArg || !import_ts_morph8.Node.isArrayLiteralExpression(arrArg)) return "unknown";
+        if (!arrArg || !import_ts_morph9.Node.isArrayLiteralExpression(arrArg)) return "unknown";
         return `[${arrArg.getElements().map(zodAstToTs).join(", ")}]`;
       }
       default:
@@ -4213,18 +4338,18 @@ function zodAstToTs(node) {
   return "unknown";
 }
 function isOptionalChain(node) {
-  if (!import_ts_morph8.Node.isCallExpression(node)) return false;
+  if (!import_ts_morph9.Node.isCallExpression(node)) return false;
   const expr = node.getExpression();
-  return import_ts_morph8.Node.isPropertyAccessExpression(expr) && expr.getName() === "optional";
+  return import_ts_morph9.Node.isPropertyAccessExpression(expr) && expr.getName() === "optional";
 }
 function parseDefineContractCall(callExpr) {
-  if (!import_ts_morph8.Node.isCallExpression(callExpr)) return null;
+  if (!import_ts_morph9.Node.isCallExpression(callExpr)) return null;
   const callee = callExpr.getExpression();
-  const calleeName = import_ts_morph8.Node.isIdentifier(callee) ? callee.getText() : import_ts_morph8.Node.isPropertyAccessExpression(callee) ? callee.getName() : "";
+  const calleeName = import_ts_morph9.Node.isIdentifier(callee) ? callee.getText() : import_ts_morph9.Node.isPropertyAccessExpression(callee) ? callee.getName() : "";
   if (calleeName !== "defineContract") return null;
   const args = callExpr.getArguments();
   const optsArg = args[0];
-  if (!optsArg || !import_ts_morph8.Node.isObjectLiteralExpression(optsArg)) return null;
+  if (!optsArg || !import_ts_morph9.Node.isObjectLiteralExpression(optsArg)) return null;
   let query = null;
   let body = null;
   let response = "unknown";
@@ -4232,7 +4357,7 @@ function parseDefineContractCall(callExpr) {
   let bodyZodText = null;
   let queryZodText = null;
   for (const prop of optsArg.getProperties()) {
-    if (!import_ts_morph8.Node.isPropertyAssignment(prop)) continue;
+    if (!import_ts_morph9.Node.isPropertyAssignment(prop)) continue;
     const propName = prop.getName();
     const val = prop.getInitializer();
     if (!val) continue;
@@ -4261,6 +4386,7 @@ async function discoverContractsFast(opts) {
     project.addSourceFileAtPath(f);
   }
   bindDiscoveryContext(project, cwd, tsconfigPath);
+  clearMixinTypeProject();
   return extractAllRoutes(project);
 }
 function resolveTsconfigPath(cwd, tsconfig) {
@@ -4268,14 +4394,14 @@ function resolveTsconfigPath(cwd, tsconfig) {
 }
 function createDiscoveryProject(tsconfigPath) {
   try {
-    return new import_ts_morph9.Project({
+    return new import_ts_morph10.Project({
       tsConfigFilePath: tsconfigPath,
       skipAddingFilesFromTsConfig: true,
       skipLoadingLibFiles: true,
       skipFileDependencyResolution: true
     });
   } catch {
-    return new import_ts_morph9.Project({
+    return new import_ts_morph10.Project({
       skipAddingFilesFromTsConfig: true,
       skipLoadingLibFiles: true,
       skipFileDependencyResolution: true,
@@ -4382,15 +4508,16 @@ var PersistentDiscovery = class _PersistentDiscovery {
   runExtraction() {
     clearTypeResolutionCaches(this.project);
     clearEnumCache(this.project);
+    clearMixinTypeProject();
     return extractRoutesFrom(this.project, this.controllerPaths);
   }
 };
 function decoratorStringArg(decoratorExpr) {
   if (!decoratorExpr) return void 0;
-  if (import_ts_morph9.Node.isStringLiteral(decoratorExpr)) return decoratorExpr.getLiteralValue();
-  if (import_ts_morph9.Node.isArrayLiteralExpression(decoratorExpr)) {
+  if (import_ts_morph10.Node.isStringLiteral(decoratorExpr)) return decoratorExpr.getLiteralValue();
+  if (import_ts_morph10.Node.isArrayLiteralExpression(decoratorExpr)) {
     const first = decoratorExpr.getElements()[0];
-    if (first && import_ts_morph9.Node.isStringLiteral(first)) return first.getLiteralValue();
+    if (first && import_ts_morph10.Node.isStringLiteral(first)) return first.getLiteralValue();
   }
   return void 0;
 }
@@ -4412,7 +4539,8 @@ function joinPaths(prefix, suffix) {
   if (!prefix && !suffix) return "/";
   if (!prefix) return suffix.startsWith("/") ? suffix : `/${suffix}`;
   if (!suffix) return prefix.startsWith("/") ? prefix : `/${prefix}`;
-  const p = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+  const withLeadingSlash = prefix.startsWith("/") ? prefix : `/${prefix}`;
+  const p = withLeadingSlash.endsWith("/") ? withLeadingSlash.slice(0, -1) : withLeadingSlash;
   const s = suffix.startsWith("/") ? suffix : `/${suffix}`;
   const combined = p + s;
   return combined === "" ? "/" : combined;
@@ -4466,7 +4594,8 @@ function buildRoute(args) {
     methodAs,
     sourceFile,
     seenNames,
-    contractSource
+    contractSource,
+    mixin
   } = args;
   const routeName = resolveRouteName(className, methodName, classAs, methodAs);
   const qualifiedRef = `${className}.${methodName}`;
@@ -4482,7 +4611,12 @@ function buildRoute(args) {
     path: combinedPath,
     name: routeName,
     params: extractParams(combinedPath),
-    controllerRef: { className, methodName, filePath: sourceFile.getFilePath() },
+    controllerRef: {
+      className,
+      methodName,
+      filePath: sourceFile.getFilePath(),
+      ...mixin ? { mixin } : {}
+    },
     contract: { contractSource }
   };
 }
@@ -4496,16 +4630,17 @@ function extractContractRoute(args) {
     className,
     sourceFile,
     project,
-    seenNames
+    seenNames,
+    mixin
   } = args;
   const firstDecoratorArg = applyContractDecorator.getArguments()[0];
   if (!firstDecoratorArg) return null;
   let contractDef = null;
   let bodyZodRef = null;
   let queryZodRef = null;
-  if (import_ts_morph9.Node.isCallExpression(firstDecoratorArg)) {
+  if (import_ts_morph10.Node.isCallExpression(firstDecoratorArg)) {
     contractDef = parseDefineContractCall(firstDecoratorArg);
-  } else if (import_ts_morph9.Node.isIdentifier(firstDecoratorArg)) {
+  } else if (import_ts_morph10.Node.isIdentifier(firstDecoratorArg)) {
     const identName = firstDecoratorArg.getText();
     const resolvedVar = resolveImportedVariable(identName, sourceFile, project);
     if (!resolvedVar) {
@@ -4548,6 +4683,7 @@ function extractContractRoute(args) {
     methodAs,
     sourceFile,
     seenNames,
+    mixin,
     contractSource: {
       query: contractDef.query,
       body: contractDef.body,
@@ -4564,13 +4700,14 @@ function extractContractRoute(args) {
   });
 }
 function extractDtoRoute(args) {
-  const { cls, method, verb, prefix, className, sourceFile, project, seenNames } = args;
+  const { cls, method, verb, prefix, className, sourceFile, project, seenNames, mixin } = args;
   if (!verb) return null;
   const combined = joinPaths(prefix, verb.handlerPath);
   const methodName = method.getName();
   const classAs = readAsDecorator(cls, `class ${className}`);
   const methodAs = readAsDecorator(method, `${className}.${methodName}`);
-  const dtoContract = extractDtoContract(method, sourceFile, project);
+  const dtoContract = extractDtoContract(method, sourceFile, project, mixin);
+  const mixinResponse = mixin ? resolveInstantiatedReturnType(cls, methodName) : void 0;
   return buildRoute({
     className,
     methodName,
@@ -4580,10 +4717,11 @@ function extractDtoRoute(args) {
     methodAs,
     sourceFile,
     seenNames,
+    mixin,
     contractSource: {
       query: dtoContract?.query ?? null,
       body: dtoContract?.body ?? null,
-      response: dtoContract?.response ?? "unknown",
+      response: mixinResponse ?? dtoContract?.response ?? "unknown",
       error: dtoContract?.error ?? null,
       queryRef: dtoContract?.queryRef ?? null,
       bodyRef: dtoContract?.bodyRef ?? null,
@@ -4612,7 +4750,17 @@ function extractFromSourceFile(sourceFile, project) {
     const firstArg2 = controllerDecorator.getArguments()[0];
     const prefix = decoratorStringArg(firstArg2) ?? "";
     const className = cls.getName() ?? "Unknown";
-    for (const method of cls.getMethods()) {
+    const inherited = resolveInheritedMethods(cls);
+    const mixinBinding = inherited ? {
+      factoryName: inherited.factoryName,
+      factoryFilePath: inherited.factoryFilePath,
+      classArgs: inherited.classArgs
+    } : void 0;
+    const methods = [
+      ...cls.getMethods().map((method) => ({ method })),
+      ...(inherited?.methods ?? []).map((method) => ({ method, mixin: mixinBinding }))
+    ];
+    for (const { method, mixin } of methods) {
       const verb = resolveVerb(method);
       const applyContractDecorator = method.getDecorator("ApplyContract");
       const route = applyContractDecorator ? extractContractRoute({
@@ -4624,7 +4772,8 @@ function extractFromSourceFile(sourceFile, project) {
         className,
         sourceFile,
         project,
-        seenNames
+        seenNames,
+        mixin
       }) : extractDtoRoute({
         cls,
         method,
@@ -4633,7 +4782,8 @@ function extractFromSourceFile(sourceFile, project) {
         className,
         sourceFile,
         project,
-        seenNames
+        seenNames,
+        mixin
       });
       if (route) routes.push(route);
     }
@@ -4834,7 +4984,7 @@ async function watch(config, onChange, options = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.14.2";
+var VERSION = "0.16.0";
 
 // src/cli/codegen.ts
 async function runCodegen(opts = {}) {