@dudousxd/nestjs-codegen 0.15.0 → 0.17.0

package/dist/cli/main.js

@@ -514,9 +514,10 @@ function inferExpressionType(node) {
 
 // src/emit/emit-api.ts
 import { mkdir, writeFile } from "fs/promises";
-import { isAbsolute as isAbsolute2, join as join4, relative as relative3 } from "path";
+import { isAbsolute as isAbsolute2, join as join4, relative as relative4 } from "path";
 
 // src/extension/registry.ts
+import { relative as relative3, resolve as resolve2 } from "path";
 import { Project as Project2 } from "ts-morph";
 function resolveApiSlots(extensions) {
   let layer;
@@ -549,7 +550,7 @@ function mergeExclusive(target, incoming, {
     target.set(key, { value, owner });
   }
 }
-function createExtensionContext(config, getRoutes) {
+function createExtensionContext(config, getRoutes, trackedInputs) {
   let project;
   return {
     cwd: config.codegen.cwd,
@@ -558,6 +559,13 @@ function createExtensionContext(config, getRoutes) {
     get routes() {
       return getRoutes();
     },
+    trackInput(...paths) {
+      if (!trackedInputs) return;
+      for (const path of paths) {
+        if (!path) continue;
+        trackedInputs.add(relative3(config.codegen.cwd, resolve2(config.codegen.cwd, path)));
+      }
+    },
     project() {
       if (!project) {
         project = new Project2({
@@ -725,7 +733,7 @@ function rawResponseType(c, outDir) {
     return c.contractSource.response;
   }
   if (c.controllerRef) {
-    let relPath = relative3(outDir, c.controllerRef.filePath).replace(/\.ts$/, "");
+    let relPath = relative4(outDir, c.controllerRef.filePath).replace(/\.ts$/, "");
     if (!relPath.startsWith(".")) relPath = `./${relPath}`;
     return `Awaited<ReturnType<import('${relPath}').${c.controllerRef.className}['${c.controllerRef.methodName}']>>`;
   }
@@ -1051,6 +1059,11 @@ function buildApiFile(routes, outDir, opts = {}) {
     config: {},
     project: () => {
       throw new Error("ExtensionContext.project() is unavailable in standalone emitApi.");
+    },
+    // No manifest is written on the standalone path, so there is nothing for
+    // tracked dependencies to be recorded into — accept and discard them
+    // rather than making every caller supply a sink.
+    trackInput: () => {
     }
   };
   const importsByFile = /* @__PURE__ */ new Map();
@@ -1107,7 +1120,7 @@ function buildApiFile(routes, outDir, opts = {}) {
     for (const [filePath, names] of importsByFile) {
       let relPath;
       if (isAbsolute2(filePath)) {
-        relPath = relative3(outDir, filePath).replace(/\.ts$/, "");
+        relPath = relative4(outDir, filePath).replace(/\.ts$/, "");
         if (!relPath.startsWith(".")) relPath = `./${relPath}`;
       } else {
         relPath = filePath;
@@ -1221,7 +1234,7 @@ async function emitCache(pages, outDir) {
 
 // src/emit/emit-forms.ts
 import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
-import { join as join6, relative as relative4 } from "path";
+import { join as join6, relative as relative5 } from "path";
 async function emitForms(routes, outDir, config, adapter) {
   if (config && config.enabled === false) return false;
   const content = buildFormsFileWithAdapter(routes, outDir, adapter, config);
@@ -1240,7 +1253,7 @@ function deriveBaseName(routeName) {
   return { method, full };
 }
 function relImport(outDir, filePath) {
-  let relPath = relative4(outDir, filePath).replace(/\.ts$/, "");
+  let relPath = relative5(outDir, filePath).replace(/\.ts$/, "");
   if (!relPath.startsWith(".")) relPath = `./${relPath}`;
   return relPath;
 }
@@ -1988,7 +2001,7 @@ async function emitOpenApi(routes, outDir, opts = {}) {
 
 // src/emit/emit-pages.ts
 import { mkdir as mkdir7, writeFile as writeFile7 } from "fs/promises";
-import { join as join10, relative as relative5 } from "path";
+import { join as join10, relative as relative6 } from "path";
 async function emitPages(pages, outDir, _options = {}) {
   await mkdir7(outDir, { recursive: true });
   const pageNameUnion = pages.length > 0 ? pages.map((p) => JSON.stringify(p.name)).join(" | ") : "never";
@@ -2028,7 +2041,7 @@ ${propsBody}
 `;
 }
 function buildAugmentationType(page, outDir) {
-  let importPath = relative5(outDir, page.absolutePath).replace(/\.(tsx?|vue|svelte)$/, "");
+  let importPath = relative6(outDir, page.absolutePath).replace(/\.(tsx?|vue|svelte)$/, "");
   if (!importPath.startsWith(".")) {
     importPath = `./${importPath}`;
   }
@@ -2159,7 +2172,7 @@ function buildEmpty() {
 // src/generate-manifest.ts
 import { createHash } from "crypto";
 import { readFile as readFile2, readdir, writeFile as writeFile9 } from "fs/promises";
-import { join as join12, relative as relative6 } from "path";
+import { join as join12, relative as relative7 } from "path";
 import fg2 from "fast-glob";
 var MANIFEST_FILE = ".codegen-manifest.json";
 var LOCK_FILE = ".watcher.lock";
@@ -2182,6 +2195,9 @@ function isManifestShape(value) {
   if (candidate.configKeyHashes !== void 0 && !isStringRecord(candidate.configKeyHashes)) {
     return false;
   }
+  if (candidate.extraInputs !== void 0 && (!Array.isArray(candidate.extraInputs) || !candidate.extraInputs.every((entry) => typeof entry === "string"))) {
+    return false;
+  }
   if (!Array.isArray(candidate.files)) return false;
   return candidate.files.every((entry) => typeof entry === "string");
 }
@@ -2221,21 +2237,30 @@ async function discoverInputFiles(config) {
   const matched = await fg2(globs, { cwd, absolute: true, onlyFiles: true });
   return [...new Set(matched)].sort();
 }
-async function computeInputsHash(config) {
+async function computeInputsHash(config, extraInputs = []) {
   const hash = createHash("sha256");
   hash.update(`version:${VERSION}
 `);
   hash.update(`config:${serializeConfig(config)}
 `);
-  const inputFiles = await discoverInputFiles(config);
   const cwd = config.codegen.cwd;
-  for (const file of inputFiles) {
+  const globbed = await discoverInputFiles(config);
+  const globbedRelative = new Set(globbed.map((file) => relative7(cwd, file)));
+  const extra = [...new Set(extraInputs)].filter((file) => !globbedRelative.has(file)).sort();
+  for (const file of globbed) {
     const contents = await readFile2(file, "utf8");
-    hash.update(`file:${relative6(cwd, file)}
+    hash.update(`file:${relative7(cwd, file)}
 `);
     hash.update(contents);
     hash.update("\n");
   }
+  for (const file of extra) {
+    const contents = await readFile2(join12(cwd, file), "utf8").catch(() => null);
+    hash.update(`extra:${file}
+`);
+    hash.update(contents ?? "\0missing");
+    hash.update("\n");
+  }
   return hash.digest("hex");
 }
 async function readManifest(outDir) {
@@ -2249,6 +2274,7 @@ async function readManifest(outDir) {
       ...parsed.entryPoint ? { entryPoint: parsed.entryPoint } : {},
       ...parsed.configHash ? { configHash: parsed.configHash } : {},
       ...parsed.configKeyHashes ? { configKeyHashes: parsed.configKeyHashes } : {},
+      ...parsed.extraInputs ? { extraInputs: parsed.extraInputs } : {},
       files: parsed.files
     };
   } catch {
@@ -2271,7 +2297,7 @@ async function listOutputFiles(outDir) {
       if (entry.isDirectory()) {
         await walk(abs);
       } else if (entry.isFile()) {
-        const rel = relative6(outDir, abs);
+        const rel = relative7(outDir, abs);
         if (rel === MANIFEST_FILE || rel === LOCK_FILE) continue;
         found.push(rel);
       }
@@ -2308,8 +2334,8 @@ function driftGuardMessage(outDir, previousEntryPoint, currentEntryPoint, differ
 }
 async function generate(config, inputRoutes = [], entryPoint = "cli") {
   setCodegenDebug(config.debug);
-  const inputsHash = await computeInputsHash(config);
   const manifest = await readManifest(config.codegen.outDir);
+  const inputsHash = await computeInputsHash(config, manifest?.extraInputs ?? []);
   if (await isManifestFresh(config.codegen.outDir, manifest, inputsHash)) {
     console.log(`[nestjs-codegen] ${config.codegen.outDir} up to date, skipped`);
     return;
@@ -2330,7 +2356,8 @@ async function generate(config, inputRoutes = [], entryPoint = "cli") {
   }
   const extensions = config.extensions ?? [];
   let routes = inputRoutes;
-  const ctx = createExtensionContext(config, () => routes);
+  const trackedInputs = /* @__PURE__ */ new Set();
+  const ctx = createExtensionContext(config, () => routes, trackedInputs);
   if (extensions.length > 0) {
     routes = await applyTransformRoutes(routes, extensions, ctx);
   }
@@ -2390,13 +2417,16 @@ async function generate(config, inputRoutes = [], entryPoint = "cli") {
     }
   }
   const outputFiles = await listOutputFiles(config.codegen.outDir);
+  const extraInputs = [...trackedInputs].sort();
+  const recordedHash = extraInputs.length > 0 ? await computeInputsHash(config, extraInputs) : inputsHash;
   await writeManifest(config.codegen.outDir, {
     version: VERSION,
-    hash: inputsHash,
+    hash: recordedHash,
     entryPoint,
     configHash,
     configKeyHashes,
-    files: outputFiles
+    files: outputFiles,
+    ...extraInputs.length > 0 ? { extraInputs } : {}
   });
 }
 
@@ -2406,11 +2436,11 @@ import { join as join16 } from "path";
 import chokidar from "chokidar";
 
 // src/discovery/contracts-fast.ts
-import { join as join14, resolve as resolve3 } from "path";
+import { join as join14, resolve as resolve4 } from "path";
 import fg3 from "fast-glob";
 import {
-  Node as Node8,
-  Project as Project3
+  Node as Node9,
+  Project as Project4
 } from "ts-morph";
 
 // src/discovery/dto-type-resolver.ts
@@ -2426,7 +2456,7 @@ import {
 
 // src/discovery/type-ref-resolution.ts
 import { readFileSync } from "fs";
-import { dirname as dirname3, resolve as resolve2 } from "path";
+import { dirname as dirname3, resolve as resolve3 } from "path";
 import {
   Node as Node2
 } from "ts-morph";
@@ -2483,9 +2513,9 @@ function resolveModuleSpecifier(moduleSpecifier, sourceFile, project) {
     const dir = dirname3(sourceFile.getFilePath());
     const noExt = moduleSpecifier.replace(/\.(js|ts)$/, "");
     return [
-      resolve2(dir, `${noExt}.ts`),
-      resolve2(dir, `${moduleSpecifier}.ts`),
-      resolve2(dir, moduleSpecifier, "index.ts")
+      resolve3(dir, `${noExt}.ts`),
+      resolve3(dir, `${moduleSpecifier}.ts`),
+      resolve3(dir, moduleSpecifier, "index.ts")
     ];
   }
   const ctx = _ctxFor(project);
@@ -2506,8 +2536,8 @@ function resolveModuleSpecifier(moduleSpecifier, sourceFile, project) {
         const rest = moduleSpecifier.slice(prefix.length);
         const candidates = [];
         for (const mapping of mappings) {
-          const resolved = resolve2(baseUrl, mapping.replace("*", rest));
-          candidates.push(`${resolved}.ts`, resolve2(resolved, "index.ts"));
+          const resolved = resolve3(baseUrl, mapping.replace("*", rest));
+          candidates.push(`${resolved}.ts`, resolve3(resolved, "index.ts"));
         }
         dbg("  resolved candidates:", candidates);
         return candidates;
@@ -3402,6 +3432,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 (Node5.isStringLiteral(typeInit)) {
     switch (typeInit.getLiteralValue()) {
@@ -3475,7 +3511,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;
@@ -3495,12 +3533,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) {
@@ -3585,22 +3623,29 @@ function extractClassPropertyTypes(classDecl, project) {
   }
   return fields;
 }
-function extractFilterableEntityFields(filterClass, project) {
+function resolveLocalClassDeclaration(identifier) {
+  if (!Node5.isIdentifier(identifier)) return void 0;
+  return identifier.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => n !== void 0 && Node5.isClassDeclaration(n));
+}
+function resolveDeclaredEntity(optionsArg, filterClass, project) {
+  if (!Node5.isObjectLiteralExpression(optionsArg)) return void 0;
+  const entityProp = optionsArg.getProperty("entity");
+  if (!entityProp || !Node5.isPropertyAssignment(entityProp)) return void 0;
+  const entityInit = entityProp.getInitializer();
+  if (!entityInit || !Node5.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 (!Node5.isObjectLiteralExpression(optionsArg)) return [];
-  const entityProp = optionsArg.getProperty("entity");
-  if (!entityProp || !Node5.isPropertyAssignment(entityProp)) return [];
-  const entityInit = entityProp.getInitializer();
-  if (!entityInit || !Node5.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(),
@@ -4025,9 +4070,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;
@@ -4137,12 +4182,94 @@ function resolveParamClass(method, decoratorName, sourceFile, project) {
   return null;
 }
 
+// src/discovery/heritage.ts
+import { Node as Node7, Project as Project3 } from "ts-morph";
+function unwrapExpression(node) {
+  let current = node;
+  while (Node7.isAsExpression(current) || Node7.isSatisfiesExpression(current) || Node7.isParenthesizedExpression(current) || Node7.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) => Node7.isReturnStatement(n));
+  for (const ret of returns) {
+    const expr = ret.getExpression();
+    if (!expr) continue;
+    const inner = unwrapExpression(expr);
+    if (Node7.isClassExpression(inner)) {
+      return inner;
+    }
+    if (Node7.isIdentifier(inner)) {
+      const name = inner.getText();
+      const decl = body.getDescendants().find((n) => Node7.isClassDeclaration(n) && n.getName() === name);
+      if (decl) return decl;
+    }
+  }
+  return void 0;
+}
+function resolveInheritedMethods(cls) {
+  const expr = cls.getExtends()?.getExpression();
+  if (!expr || !Node7.isCallExpression(expr)) return void 0;
+  const callee = expr.getExpression();
+  if (!Node7.isIdentifier(callee)) return void 0;
+  const factoryDecl = callee.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => Node7.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 (!Node7.isIdentifier(arg)) continue;
+    const decl = arg.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => Node7.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 Project3({
+    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
-import { Node as Node7, SyntaxKind as SyntaxKind4 } from "ts-morph";
+import { Node as Node8, SyntaxKind as SyntaxKind4 } from "ts-morph";
 function zodAstToTs(node) {
-  if (!Node7.isCallExpression(node)) return "unknown";
+  if (!Node8.isCallExpression(node)) return "unknown";
   const expr = node.getExpression();
-  if (Node7.isPropertyAccessExpression(expr)) {
+  if (Node8.isPropertyAccessExpression(expr)) {
     const methodName = expr.getName();
     const receiver = expr.getExpression();
     if (methodName === "optional") {
@@ -4166,17 +4293,17 @@ function zodAstToTs(node) {
       case "literal": {
         const lit = args[0];
         if (!lit) return "unknown";
-        if (Node7.isStringLiteral(lit)) return JSON.stringify(lit.getLiteralValue());
-        if (Node7.isNumericLiteral(lit)) return lit.getLiteralValue().toString();
+        if (Node8.isStringLiteral(lit)) return JSON.stringify(lit.getLiteralValue());
+        if (Node8.isNumericLiteral(lit)) return lit.getLiteralValue().toString();
         if (lit.getKind() === SyntaxKind4.TrueKeyword) return "true";
         if (lit.getKind() === SyntaxKind4.FalseKeyword) return "false";
         return "unknown";
       }
       case "enum": {
         const arrArg = args[0];
-        if (!arrArg || !Node7.isArrayLiteralExpression(arrArg)) return "unknown";
+        if (!arrArg || !Node8.isArrayLiteralExpression(arrArg)) return "unknown";
         const members = arrArg.getElements().map(
-          (el) => Node7.isStringLiteral(el) ? JSON.stringify(el.getLiteralValue()) : "unknown"
+          (el) => Node8.isStringLiteral(el) ? JSON.stringify(el.getLiteralValue()) : "unknown"
         );
         return members.join(" | ");
       }
@@ -4187,10 +4314,10 @@ function zodAstToTs(node) {
       }
       case "object": {
         const objArg = args[0];
-        if (!objArg || !Node7.isObjectLiteralExpression(objArg)) return "unknown";
+        if (!objArg || !Node8.isObjectLiteralExpression(objArg)) return "unknown";
         const lines = [];
         for (const prop of objArg.getProperties()) {
-          if (!Node7.isPropertyAssignment(prop)) continue;
+          if (!Node8.isPropertyAssignment(prop)) continue;
           const key = prop.getName();
           const valNode = prop.getInitializer();
           if (!valNode) continue;
@@ -4202,7 +4329,7 @@ function zodAstToTs(node) {
       }
       case "union": {
         const arrArg = args[0];
-        if (!arrArg || !Node7.isArrayLiteralExpression(arrArg)) return "unknown";
+        if (!arrArg || !Node8.isArrayLiteralExpression(arrArg)) return "unknown";
         return arrArg.getElements().map(zodAstToTs).join(" | ");
       }
       case "record": {
@@ -4212,7 +4339,7 @@ function zodAstToTs(node) {
       }
       case "tuple": {
         const arrArg = args[0];
-        if (!arrArg || !Node7.isArrayLiteralExpression(arrArg)) return "unknown";
+        if (!arrArg || !Node8.isArrayLiteralExpression(arrArg)) return "unknown";
         return `[${arrArg.getElements().map(zodAstToTs).join(", ")}]`;
       }
       default:
@@ -4222,18 +4349,18 @@ function zodAstToTs(node) {
   return "unknown";
 }
 function isOptionalChain(node) {
-  if (!Node7.isCallExpression(node)) return false;
+  if (!Node8.isCallExpression(node)) return false;
   const expr = node.getExpression();
-  return Node7.isPropertyAccessExpression(expr) && expr.getName() === "optional";
+  return Node8.isPropertyAccessExpression(expr) && expr.getName() === "optional";
 }
 function parseDefineContractCall(callExpr) {
-  if (!Node7.isCallExpression(callExpr)) return null;
+  if (!Node8.isCallExpression(callExpr)) return null;
   const callee = callExpr.getExpression();
-  const calleeName = Node7.isIdentifier(callee) ? callee.getText() : Node7.isPropertyAccessExpression(callee) ? callee.getName() : "";
+  const calleeName = Node8.isIdentifier(callee) ? callee.getText() : Node8.isPropertyAccessExpression(callee) ? callee.getName() : "";
   if (calleeName !== "defineContract") return null;
   const args = callExpr.getArguments();
   const optsArg = args[0];
-  if (!optsArg || !Node7.isObjectLiteralExpression(optsArg)) return null;
+  if (!optsArg || !Node8.isObjectLiteralExpression(optsArg)) return null;
   let query = null;
   let body = null;
   let response = "unknown";
@@ -4241,7 +4368,7 @@ function parseDefineContractCall(callExpr) {
   let bodyZodText = null;
   let queryZodText = null;
   for (const prop of optsArg.getProperties()) {
-    if (!Node7.isPropertyAssignment(prop)) continue;
+    if (!Node8.isPropertyAssignment(prop)) continue;
     const propName = prop.getName();
     const val = prop.getInitializer();
     if (!val) continue;
@@ -4270,21 +4397,22 @@ async function discoverContractsFast(opts) {
     project.addSourceFileAtPath(f);
   }
   bindDiscoveryContext(project, cwd, tsconfigPath);
+  clearMixinTypeProject();
   return extractAllRoutes(project);
 }
 function resolveTsconfigPath(cwd, tsconfig) {
-  return tsconfig ? resolve3(tsconfig) : join14(cwd, "tsconfig.json");
+  return tsconfig ? resolve4(tsconfig) : join14(cwd, "tsconfig.json");
 }
 function createDiscoveryProject(tsconfigPath) {
   try {
-    return new Project3({
+    return new Project4({
       tsConfigFilePath: tsconfigPath,
       skipAddingFilesFromTsConfig: true,
       skipLoadingLibFiles: true,
       skipFileDependencyResolution: true
     });
   } catch {
-    return new Project3({
+    return new Project4({
       skipAddingFilesFromTsConfig: true,
       skipLoadingLibFiles: true,
       skipFileDependencyResolution: true,
@@ -4359,7 +4487,7 @@ var PersistentDiscovery = class _PersistentDiscovery {
   async rediscover(changedPaths) {
     if (changedPaths) {
       for (const p of changedPaths) {
-        const abs = resolve3(p);
+        const abs = resolve4(p);
         const sf = this.project.getSourceFile(abs);
         if (sf) {
           await sf.refreshFromFileSystem();
@@ -4391,15 +4519,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 (Node8.isStringLiteral(decoratorExpr)) return decoratorExpr.getLiteralValue();
-  if (Node8.isArrayLiteralExpression(decoratorExpr)) {
+  if (Node9.isStringLiteral(decoratorExpr)) return decoratorExpr.getLiteralValue();
+  if (Node9.isArrayLiteralExpression(decoratorExpr)) {
     const first = decoratorExpr.getElements()[0];
-    if (first && Node8.isStringLiteral(first)) return first.getLiteralValue();
+    if (first && Node9.isStringLiteral(first)) return first.getLiteralValue();
   }
   return void 0;
 }
@@ -4421,7 +4550,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;
@@ -4475,7 +4605,8 @@ function buildRoute(args) {
     methodAs,
     sourceFile,
     seenNames,
-    contractSource
+    contractSource,
+    mixin
   } = args;
   const routeName = resolveRouteName(className, methodName, classAs, methodAs);
   const qualifiedRef = `${className}.${methodName}`;
@@ -4491,7 +4622,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 }
   };
 }
@@ -4505,16 +4641,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 (Node8.isCallExpression(firstDecoratorArg)) {
+  if (Node9.isCallExpression(firstDecoratorArg)) {
     contractDef = parseDefineContractCall(firstDecoratorArg);
-  } else if (Node8.isIdentifier(firstDecoratorArg)) {
+  } else if (Node9.isIdentifier(firstDecoratorArg)) {
     const identName = firstDecoratorArg.getText();
     const resolvedVar = resolveImportedVariable(identName, sourceFile, project);
     if (!resolvedVar) {
@@ -4557,6 +4694,7 @@ function extractContractRoute(args) {
     methodAs,
     sourceFile,
     seenNames,
+    mixin,
     contractSource: {
       query: contractDef.query,
       body: contractDef.body,
@@ -4573,13 +4711,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,
@@ -4589,10 +4728,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,
@@ -4621,7 +4761,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({
@@ -4633,7 +4783,8 @@ function extractFromSourceFile(sourceFile, project) {
         className,
         sourceFile,
         project,
-        seenNames
+        seenNames,
+        mixin
       }) : extractDtoRoute({
         cls,
         method,
@@ -4642,7 +4793,8 @@ function extractFromSourceFile(sourceFile, project) {
         className,
         sourceFile,
         project,
-        seenNames
+        seenNames,
+        mixin
       });
       if (route) routes.push(route);
     }
@@ -4843,7 +4995,7 @@ async function watch(config, onChange, options = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.15.0";
+var VERSION = "0.17.0";
 
 // src/cli/codegen.ts
 async function runCodegen(opts = {}) {
@@ -4851,9 +5003,9 @@ async function runCodegen(opts = {}) {
   const config = await loadConfig(cwd);
   if (opts.watch) {
     const watcher = await watch(config, void 0, { entryPoint: "cli" });
-    await new Promise((resolve4) => {
+    await new Promise((resolve5) => {
       function onSignal() {
-        watcher.close().then(resolve4).catch(resolve4);
+        watcher.close().then(resolve5).catch(resolve5);
       }
       process.once("SIGINT", onSignal);
       process.once("SIGTERM", onSignal);
@@ -4983,16 +5135,16 @@ async function detectPackageManager(cwd) {
 }
 async function promptFramework() {
   if (!process.stdin.isTTY) return "react";
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const rl = createInterface({ input: process.stdin, output: process.stdout });
     rl.question(
       "[nestjs-codegen] Which frontend framework? (react/vue/svelte) [react]: ",
       (answer) => {
         rl.close();
         const trimmed = answer.trim().toLowerCase();
-        if (trimmed === "vue") resolve4("vue");
-        else if (trimmed === "svelte") resolve4("svelte");
-        else resolve4("react");
+        if (trimmed === "vue") resolve5("vue");
+        else if (trimmed === "svelte") resolve5("svelte");
+        else resolve5("react");
       }
     );
   });