@dudousxd/nestjs-inertia-codegen 1.0.7 → 1.3.0

package/CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog — @dudousxd/nestjs-inertia-codegen
 
+## 2.0.0
+
+### Minor Changes
+
+- feat(codegen): ReturnType<import(...)> for response types, queryKey helper, TanStack helpers, type ref imports, path alias resolution, debug mode
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @dudousxd/nestjs-inertia@2.0.0
+
+## 3.0.0
+
+### Minor Changes
+
+- feat(codegen): import type references from source instead of inline expansion — eliminates unknown fields from depth limits
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @dudousxd/nestjs-inertia@3.0.0
+
+## 2.0.1
+
+### Patch Changes
+
+- fix(codegen): remove @tanstack/query-core dependency — generated api.ts uses plain object literals
+
+- Updated dependencies []:
+  - @dudousxd/nestjs-inertia@2.0.1
+
+## 2.0.0
+
+### Minor Changes
+
+- feat(codegen): add queryKey() helper for typed cache invalidation — api.crew.getCrew.queryKey()
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @dudousxd/nestjs-inertia@2.0.0
+
 ## 1.0.7
 
 ### Patch Changes

package/dist/cli/main.cjs

@@ -222,7 +222,7 @@ async function emitApi(routes, outDir) {
   await (0, import_promises3.mkdir)(outDir, {
     recursive: true
   });
-  const content = buildApiFile(routes);
+  const content = buildApiFile(routes, outDir);
   await (0, import_promises3.writeFile)((0, import_node_path3.join)(outDir, "api.ts"), content, "utf8");
 }
 __name(emitApi, "emitApi");
@@ -287,7 +287,20 @@ function insertIntoTree(tree, segments, leaf, fullName) {
   }
 }
 __name(insertIntoTree, "insertIntoTree");
-function emitRouterTypeBlock(tree, indent) {
+function buildResponseType(c, outDir) {
+  if (c.controllerRef) {
+    let relPath = (0, import_node_path3.relative)(outDir, c.controllerRef.filePath).replace(/\.ts$/, "");
+    if (!relPath.startsWith(".")) relPath = `./${relPath}`;
+    return `Awaited<ReturnType<import('${relPath}').${c.controllerRef.className}['${c.controllerRef.methodName}']>>`;
+  }
+  const respRef = c.contractSource.responseRef;
+  if (respRef) {
+    return respRef.isArray ? `Array<${respRef.name}>` : respRef.name;
+  }
+  return c.contractSource.response;
+}
+__name(buildResponseType, "buildResponseType");
+function emitRouterTypeBlock(tree, indent, outDir) {
   const pad = " ".repeat(indent);
   const lines = [];
   for (const [key, node] of tree) {
@@ -295,15 +308,17 @@ function emitRouterTypeBlock(tree, indent) {
     if (node.kind === "leaf") {
       const c = node;
       const method = c.method.toUpperCase();
-      const query = c.contractSource.query ?? "never";
-      const body = method === "GET" ? "never" : c.contractSource.body ?? "never";
-      const response = c.contractSource.response;
+      const queryRef = c.contractSource.queryRef;
+      const query = queryRef ? queryRef.isArray ? `Array<${queryRef.name}>` : queryRef.name : c.contractSource.query ?? "never";
+      const bodyRef = c.contractSource.bodyRef;
+      const body = method === "GET" ? "never" : bodyRef ? bodyRef.isArray ? `Array<${bodyRef.name}>` : bodyRef.name : c.contractSource.body ?? "never";
+      const response = buildResponseType(c, outDir);
       const safeMethod = JSON.stringify(method);
       const safeUrl = JSON.stringify(c.path);
       lines.push(`${pad}${objKey}: { method: ${safeMethod}; url: ${safeUrl}; query: ${query}; body: ${body}; response: ${response} };`);
     } else {
       lines.push(`${pad}${objKey}: {`);
-      lines.push(...emitRouterTypeBlock(node.children, indent + 2));
+      lines.push(...emitRouterTypeBlock(node.children, indent + 2, outDir));
       lines.push(`${pad}};`);
     }
   }
@@ -324,18 +339,21 @@ function emitApiObjectBlock(tree, indent) {
       if (method === "GET") {
         const typeAccess = buildRouterTypeAccess(c.name);
         lines.push(`${pad}${objKey}: {`);
+        lines.push(`${pad}  queryKey: (query?: ${typeAccess}['query']) => query !== undefined ? [${flatName}, query] as const : [${flatName}] as const,`);
         lines.push(`${pad}  queryOptions: (query?: ${typeAccess}['query']) =>`);
-        lines.push(`${pad}    queryOptions({`);
-        lines.push(`${pad}      queryKey: [${flatName}, query],`);
+        lines.push(`${pad}    _queryOptions({`);
+        lines.push(`${pad}      queryKey: query !== undefined ? [${flatName}, query] as const : [${flatName}] as const,`);
         lines.push(`${pad}      queryFn: () => fetcher.get<${typeAccess}['response']>(route(${flatName} as never) || ${safePath}, { query }),`);
         lines.push(`${pad}    }),`);
         lines.push(`${pad}},`);
       } else {
         const typeAccess = buildRouterTypeAccess(c.name);
         lines.push(`${pad}${objKey}: {`);
-        lines.push(`${pad}  mutationOptions: () => ({`);
-        lines.push(`${pad}    mutationFn: (body: ${typeAccess}['body']) => fetcher.${fetcherMethod}<${typeAccess}['response']>(route(${flatName} as never) || ${safePath}, { body }),`);
-        lines.push(`${pad}  }),`);
+        lines.push(`${pad}  queryKey: () => [${flatName}] as const,`);
+        lines.push(`${pad}  mutationOptions: () =>`);
+        lines.push(`${pad}    _mutationOptions({`);
+        lines.push(`${pad}      mutationFn: (body: ${typeAccess}['body']) => fetcher.${fetcherMethod}<${typeAccess}['response']>(route(${flatName} as never) || ${safePath}, { body }),`);
+        lines.push(`${pad}    }),`);
         lines.push(`${pad}},`);
       }
     } else {
@@ -352,18 +370,55 @@ function buildRouterTypeAccess(name) {
   return `ApiRouter${segments.map((s) => `[${JSON.stringify(s)}]`).join("")}`;
 }
 __name(buildRouterTypeAccess, "buildRouterTypeAccess");
-function buildApiFile(routes) {
+function buildApiFile(routes, outDir) {
   const contracted = routes.filter((r) => r.contract);
+  const importsByFile = /* @__PURE__ */ new Map();
+  for (const r of contracted) {
+    const cs = r.contract?.contractSource;
+    if (!cs) continue;
+    const refs = r.controllerRef ? [
+      cs.queryRef,
+      cs.bodyRef
+    ] : [
+      cs.queryRef,
+      cs.bodyRef,
+      cs.responseRef
+    ];
+    for (const ref of refs) {
+      if (!ref) continue;
+      let names = importsByFile.get(ref.filePath);
+      if (!names) {
+        names = /* @__PURE__ */ new Set();
+        importsByFile.set(ref.filePath, names);
+      }
+      names.add(ref.name);
+    }
+  }
   const hasGetRoutes = contracted.some((r) => r.method === "GET");
+  const hasMutationRoutes = contracted.some((r) => r.method !== "GET");
   const lines = [
     "// Generated by @dudousxd/nestjs-inertia-codegen. Do not edit.",
     ""
   ];
-  if (hasGetRoutes) {
-    lines.push("import { queryOptions } from '@tanstack/query-core';");
+  const tqImports = [];
+  if (hasGetRoutes) tqImports.push("queryOptions as _queryOptions");
+  if (hasMutationRoutes) tqImports.push("mutationOptions as _mutationOptions");
+  if (tqImports.length > 0) {
+    lines.push(`import { ${tqImports.join(", ")} } from '@tanstack/react-query';`);
   }
   lines.push("import { route } from './routes.js';");
   lines.push("import { createFetcher } from '@dudousxd/nestjs-inertia-client';");
+  if (importsByFile.size > 0 && outDir) {
+    lines.push("");
+    for (const [filePath, names] of importsByFile) {
+      let relPath = (0, import_node_path3.relative)(outDir, filePath).replace(/\.ts$/, "");
+      if (!relPath.startsWith(".")) relPath = `./${relPath}`;
+      const sortedNames = [
+        ...names
+      ].sort();
+      lines.push(`import type { ${sortedNames.join(", ")} } from '${relPath}';`);
+    }
+  }
   lines.push("");
   lines.push("export const fetcher = createFetcher();");
   lines.push("");
@@ -404,13 +459,14 @@ function buildApiFile(routes) {
       method: r.method,
       name,
       path: r.path,
+      controllerRef: r.controllerRef,
       contractSource: c.contractSource
     };
     insertIntoTree(tree, segments, leaf, name);
   }
   void detectCollisions;
   lines.push("export type ApiRouter = {");
-  lines.push(...emitRouterTypeBlock(tree, 2));
+  lines.push(...emitRouterTypeBlock(tree, 2, outDir ?? ""));
   lines.push("};");
   lines.push("");
   lines.push("export const api = {");
@@ -680,9 +736,28 @@ var import_node_path10 = require("path");
 var import_chokidar = __toESM(require("chokidar"), 1);
 
 // src/discovery/contracts-fast.ts
+var import_node_fs = require("fs");
 var import_node_path8 = require("path");
 var import_fast_glob2 = __toESM(require("fast-glob"), 1);
 var import_ts_morph = require("ts-morph");
+var _projectRoot = "";
+var _tsconfigPaths = null;
+var _debug = process.env.NESTJS_INERTIA_DEBUG === "1";
+function dbg(...args) {
+  if (_debug) console.log("[codegen:debug]", ...args);
+}
+__name(dbg, "dbg");
+function loadTsconfigPaths(tsconfigPath) {
+  try {
+    const raw = (0, import_node_fs.readFileSync)(tsconfigPath, "utf8");
+    const stripped = raw.replace(/\/\/.*$/gm, "");
+    const parsed = JSON.parse(stripped);
+    return parsed.compilerOptions?.paths ?? null;
+  } catch {
+    return null;
+  }
+}
+__name(loadTsconfigPaths, "loadTsconfigPaths");
 async function discoverContractsFast(opts) {
   const { cwd, glob, tsconfig } = opts;
   const tsconfigPath = tsconfig ? (0, import_node_path8.resolve)(tsconfig) : (0, import_node_path8.join)(cwd, "tsconfig.json");
@@ -715,6 +790,8 @@ async function discoverContractsFast(opts) {
     project.addSourceFileAtPath(f);
   }
   const routes = [];
+  _projectRoot = cwd;
+  _tsconfigPaths = loadTsconfigPaths(tsconfigPath);
   for (const sourceFile of project.getSourceFiles()) {
     routes.push(...extractFromSourceFile(sourceFile, project));
   }
@@ -916,17 +993,41 @@ function findTypeInFile(name, file) {
   return null;
 }
 __name(findTypeInFile, "findTypeInFile");
+function resolveModuleSpecifier(moduleSpecifier, sourceFile, project) {
+  if (moduleSpecifier.startsWith(".")) {
+    const dir = (0, import_node_path8.dirname)(sourceFile.getFilePath());
+    return [
+      (0, import_node_path8.resolve)(dir, `${moduleSpecifier}.ts`),
+      (0, import_node_path8.resolve)(dir, moduleSpecifier, "index.ts")
+    ];
+  }
+  const baseUrl = _projectRoot;
+  dbg("resolveModuleSpecifier", moduleSpecifier, "paths:", JSON.stringify(_tsconfigPaths), "baseUrl:", baseUrl);
+  if (_tsconfigPaths) {
+    for (const [pattern, mappings] of Object.entries(_tsconfigPaths)) {
+      const prefix = pattern.replace("*", "");
+      if (moduleSpecifier.startsWith(prefix)) {
+        const rest = moduleSpecifier.slice(prefix.length);
+        const candidates = [];
+        for (const mapping of mappings) {
+          const resolved = (0, import_node_path8.resolve)(baseUrl, mapping.replace("*", rest));
+          candidates.push(`${resolved}.ts`, (0, import_node_path8.resolve)(resolved, "index.ts"));
+        }
+        dbg("  resolved candidates:", candidates);
+        return candidates;
+      }
+    }
+  }
+  return [];
+}
+__name(resolveModuleSpecifier, "resolveModuleSpecifier");
 function resolveImportedType(name, sourceFile, project) {
   for (const importDecl of sourceFile.getImportDeclarations()) {
     const namedImport = importDecl.getNamedImports().find((n) => n.getName() === name);
     if (!namedImport) continue;
     const moduleSpecifier = importDecl.getModuleSpecifierValue();
-    if (!moduleSpecifier.startsWith(".")) return null;
-    const dir = (0, import_node_path8.dirname)(sourceFile.getFilePath());
-    const candidates = [
-      (0, import_node_path8.resolve)(dir, `${moduleSpecifier}.ts`),
-      (0, import_node_path8.resolve)(dir, moduleSpecifier, "index.ts")
-    ];
+    const candidates = resolveModuleSpecifier(moduleSpecifier, sourceFile, project);
+    if (candidates.length === 0) continue;
     for (const candidate of candidates) {
       let importedFile = project.getSourceFile(candidate);
       if (!importedFile) {
@@ -960,7 +1061,8 @@ function resolveTypeNodeToString(typeNode, sourceFile, project, depth) {
     const name = import_ts_morph.Node.isIdentifier(typeName) ? typeName.getText() : typeNode.getText();
     if (name === "string" || name === "number" || name === "boolean") return name;
     if (name === "Date") return "string";
-    if (name === "unknown" || name === "any") return "unknown";
+    if (name === "unknown" || name === "any" || name === "void") return "unknown";
+    if (name === "StreamableFile" || name === "Observable" || name === "ReadableStream") return "unknown";
     if (name === "Array") {
       const typeArgs = typeNode.getTypeArguments();
       const firstTypeArg = typeArgs[0];
@@ -969,6 +1071,18 @@ function resolveTypeNodeToString(typeNode, sourceFile, project, depth) {
       }
       return "Array<unknown>";
     }
+    if ([
+      "Record",
+      "Omit",
+      "Pick",
+      "Partial",
+      "Required",
+      "Readonly",
+      "Map",
+      "Set"
+    ].includes(name)) {
+      return typeNode.getText();
+    }
     if (name === "Promise") {
       const typeArgs = typeNode.getTypeArguments();
       const firstTypeArg = typeArgs[0];
@@ -981,7 +1095,8 @@ function resolveTypeNodeToString(typeNode, sourceFile, project, depth) {
     if (resolved) {
       return expandTypeDecl(resolved, project, depth - 1);
     }
-    return name;
+    dbg("unresolvable type:", name, "in", sourceFile.getFilePath());
+    return "unknown";
   }
   const kind = typeNode.getKind();
   if (kind === import_ts_morph.SyntaxKind.StringKeyword) return "string";
@@ -1108,6 +1223,68 @@ function resolveIdentifierToClassType(node, sourceFile, project, depth) {
   return name;
 }
 __name(resolveIdentifierToClassType, "resolveIdentifierToClassType");
+function tryResolveTypeRef(typeNode, sourceFile, project) {
+  if (import_ts_morph.Node.isTypeReference(typeNode)) {
+    const typeName = typeNode.getTypeName();
+    const name = import_ts_morph.Node.isIdentifier(typeName) ? typeName.getText() : null;
+    if (!name) return null;
+    if (name === "Promise") {
+      const typeArgs = typeNode.getTypeArguments();
+      const first = typeArgs[0];
+      if (first) return tryResolveTypeRef(first, sourceFile, project);
+      return null;
+    }
+    if (name === "Array") {
+      const typeArgs = typeNode.getTypeArguments();
+      const first = typeArgs[0];
+      if (first) {
+        const inner = tryResolveTypeRef(first, sourceFile, project);
+        if (inner) return {
+          ...inner,
+          isArray: true
+        };
+      }
+      return null;
+    }
+    if ([
+      "string",
+      "number",
+      "boolean",
+      "void",
+      "unknown",
+      "any",
+      "Date"
+    ].includes(name)) {
+      return null;
+    }
+    const localDecl = sourceFile.getInterface(name) || sourceFile.getClass(name) || sourceFile.getTypeAlias(name);
+    if (localDecl?.isExported()) {
+      return {
+        name,
+        filePath: sourceFile.getFilePath()
+      };
+    }
+    const resolved = resolveImportedType(name, sourceFile, project);
+    if (resolved && (resolved.kind === "class" || resolved.kind === "interface")) {
+      const decl = resolved.decl;
+      if (decl.isExported()) {
+        return {
+          name,
+          filePath: resolved.file.getFilePath()
+        };
+      }
+    }
+  }
+  if (import_ts_morph.Node.isArrayTypeNode(typeNode)) {
+    const inner = tryResolveTypeRef(typeNode.getElementTypeNode(), sourceFile, project);
+    if (inner) return {
+      ...inner,
+      isArray: true
+    };
+  }
+  return null;
+}
+__name(tryResolveTypeRef, "tryResolveTypeRef");
 function extractDtoContract(method, sourceFile, project) {
   const body = extractBodyType(method, sourceFile, project);
   const query = extractQueryType(method, sourceFile, project);
@@ -1116,11 +1293,61 @@ function extractDtoContract(method, sourceFile, project) {
   if (body === null && query === null && paramsType === null && response === "unknown") {
     return null;
   }
+  let bodyRef = null;
+  let queryRef = null;
+  let responseRef = null;
+  for (const param of method.getParameters()) {
+    if (param.getDecorators().some((d) => d.getName() === "Body") && param.getTypeNode()) {
+      bodyRef = tryResolveTypeRef(param.getTypeNode(), sourceFile, project);
+    }
+    if (param.getDecorators().some((d) => d.getName() === "Query") && param.getTypeNode()) {
+      queryRef = tryResolveTypeRef(param.getTypeNode(), sourceFile, project);
+    }
+  }
+  const returnTypeNode = method.getReturnTypeNode();
+  if (returnTypeNode) {
+    responseRef = tryResolveTypeRef(returnTypeNode, sourceFile, project);
+  }
+  if (!responseRef) {
+    const apiResp = method.getDecorator("ApiResponse");
+    if (apiResp) {
+      const args = apiResp.getArguments();
+      const optsArg = args[0];
+      if (optsArg && import_ts_morph.Node.isObjectLiteralExpression(optsArg)) {
+        for (const prop of optsArg.getProperties()) {
+          if (import_ts_morph.Node.isPropertyAssignment(prop) && prop.getName() === "type") {
+            const val = prop.getInitializer();
+            if (val && import_ts_morph.Node.isIdentifier(val)) {
+              const name = val.getText();
+              const localDecl = sourceFile.getInterface(name) || sourceFile.getClass(name) || sourceFile.getTypeAlias(name);
+              if (localDecl?.isExported()) {
+                responseRef = {
+                  name,
+                  filePath: sourceFile.getFilePath()
+                };
+              } else {
+                const resolved = resolveImportedType(name, sourceFile, project);
+                if (resolved && (resolved.kind === "class" || resolved.kind === "interface") && resolved.decl.isExported()) {
+                  responseRef = {
+                    name,
+                    filePath: resolved.file.getFilePath()
+                  };
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
   return {
     query,
     body,
     response,
-    params: paramsType
+    params: paramsType,
+    queryRef,
+    bodyRef,
+    responseRef
   };
 }
 __name(extractDtoContract, "extractDtoContract");
@@ -1219,6 +1446,11 @@ function extractFromSourceFile(sourceFile, project) {
           path: combined,
           name: routeName,
           params,
+          controllerRef: {
+            className,
+            methodName,
+            filePath: sourceFile.getFilePath()
+          },
           contract: {
             contractSource: {
               query: contractDef.query,
@@ -1253,13 +1485,20 @@ function extractFromSourceFile(sourceFile, project) {
           path: combined,
           name: routeName,
           params,
-          // Attach contract if DTO extraction produced useful type info
+          controllerRef: {
+            className,
+            methodName,
+            filePath: sourceFile.getFilePath()
+          },
           ...dtoContract ? {
             contract: {
               contractSource: {
                 query: dtoContract.query,
                 body: dtoContract.body,
-                response: dtoContract.response
+                response: dtoContract.response,
+                queryRef: dtoContract.queryRef,
+                bodyRef: dtoContract.bodyRef,
+                responseRef: dtoContract.responseRef
               }
             }
           } : {}
@@ -1432,7 +1671,7 @@ async function watch(config, onChange) {
 __name(watch, "watch");
 
 // src/index.ts
-var VERSION = "1.0.7";
+var VERSION = "1.3.0";
 
 // src/cli/codegen.ts
 async function runCodegen(opts = {}) {
@@ -1464,7 +1703,7 @@ __name(runCodegen, "runCodegen");
 
 // src/cli/init.ts
 var import_node_child_process = require("child_process");
-var import_node_fs = require("fs");
+var import_node_fs2 = require("fs");
 var import_promises10 = require("fs/promises");
 var import_node_path11 = require("path");
 var import_node_readline = require("readline");
@@ -1688,7 +1927,7 @@ __name(findAfterLastImport, "findAfterLastImport");
 function patchAppModule(filePath, rootView) {
   let content;
   try {
-    content = (0, import_node_fs.readFileSync)(filePath, "utf8");
+    content = (0, import_node_fs2.readFileSync)(filePath, "utf8");
   } catch {
     return "skipped";
   }
@@ -1726,14 +1965,14 @@ ${indent}HomeController,${content.slice(bracketPos)}`;
     }
   }
   if (!changed) return "already";
-  (0, import_node_fs.writeFileSync)(filePath, content, "utf8");
+  (0, import_node_fs2.writeFileSync)(filePath, content, "utf8");
   return "patched";
 }
 __name(patchAppModule, "patchAppModule");
 function patchMainTs(filePath) {
   let content;
   try {
-    content = (0, import_node_fs.readFileSync)(filePath, "utf8");
+    content = (0, import_node_fs2.readFileSync)(filePath, "utf8");
   } catch {
     return "skipped";
   }
@@ -1757,7 +1996,7 @@ ${content.slice(insertAt)}`;
   });`;
   content = `${content.slice(0, insertAfterPos)}
 ${viteSetup}${content.slice(insertAfterPos)}`;
-  (0, import_node_fs.writeFileSync)(filePath, content, "utf8");
+  (0, import_node_fs2.writeFileSync)(filePath, content, "utf8");
   return "patched";
 }
 __name(patchMainTs, "patchMainTs");
@@ -1806,11 +2045,19 @@ function htmlShellTemplate(framework, _engine) {
 __name(htmlShellTemplate, "htmlShellTemplate");
 function viteConfigTemplate(framework) {
   const pluginOption = `{ ${framework}: true }`;
-  return `import { defineConfig } from 'vite';
+  return `import { resolve } from 'node:path';
+import { defineConfig } from 'vite';
 import nestInertia from '@dudousxd/nestjs-inertia-vite/plugin';
 
 export default defineConfig({
   plugins: [nestInertia(${pluginOption})],
+  resolve: {
+    alias: {
+      '@': resolve(__dirname, 'src'),
+      '~': resolve(__dirname, 'inertia'),
+      '~codegen': resolve(__dirname, '.nestjs-inertia'),
+    },
+  },
 });
 `;
 }