@dudousxd/nestjs-codegen 0.25.1 → 0.26.0

package/dist/cli/main.js

@@ -518,22 +518,22 @@ import { isAbsolute as isAbsolute2, join as join5, relative as relative4 } from
 
 // src/extension/registry.ts
 import { relative as relative3, resolve as resolve4 } from "path";
-import { Project as Project4 } from "ts-morph";
+import { Project as Project5 } from "ts-morph";
 
 // src/discovery/contracts-fast.ts
 import { existsSync } from "fs";
 import { dirname as dirname2, join as join4, resolve as resolve3 } from "path";
 import fg2 from "fast-glob";
 import {
-  Node as Node9,
-  Project as Project3,
-  ts
+  Node as Node11,
+  Project as Project4,
+  ts as ts3
 } from "ts-morph";
 
 // src/discovery/dto-type-resolver.ts
 import {
-  Node as Node7,
-  SyntaxKind as SyntaxKind3
+  Node as Node10,
+  SyntaxKind as SyntaxKind4
 } from "ts-morph";
 
 // src/discovery/dto-to-ir.ts
@@ -2071,6 +2071,674 @@ function extractFilterableEntityFields(filterClass, project, entityOverride, pre
   return fields;
 }
 
+// src/discovery/pipe-schema.ts
+import { Node as Node9 } from "ts-morph";
+
+// src/discovery/schema-type-inference.ts
+import {
+  ts as ts2
+} from "ts-morph";
+
+// src/discovery/schema-type-program.ts
+import { Node as Node7, Project as Project3, ts } from "ts-morph";
+var PARAM_DECORATORS = /* @__PURE__ */ new Set(["Body", "Query", "Param"]);
+var SchemaTypeProgram = class {
+  constructor(discovery) {
+    this.discovery = discovery;
+    const base = discovery.getCompilerOptions();
+    this.options = {
+      ...base,
+      // A tsconfig-less consumer gets ES5 by default, whose lib has no `Map`/`Set`/
+      // `Promise` for the schema libraries' declarations to lean on.
+      target: base.target ?? ts.ScriptTarget.ES2022,
+      // With neither set, resolve the way a bundler does: package `exports`
+      // (`zod/v4`) and extensionless or `.js` relative imports all resolve.
+      ...base.module === void 0 && base.moduleResolution === void 0 ? { module: ts.ModuleKind.ESNext, moduleResolution: ts.ModuleResolutionKind.Bundler } : {},
+      // Without it `.nullable()` and `.optional()` would erase to the bare type.
+      strictNullChecks: true,
+      // No ambient `@types/*` (a tsconfig's `types: ['node']`): a schema does not
+      // need them, and they are a hundred-odd files of program to build.
+      types: [],
+      noEmit: true
+    };
+    this.project = new Project3({
+      skipAddingFilesFromTsConfig: true,
+      compilerOptions: this.options
+    });
+    for (const sf of discovery.getSourceFiles()) this.request(sf.getFilePath(), { schema: true });
+    this.flush();
+  }
+  project;
+  options;
+  /** Parses a file that is not in discovery's Project, without adding it there. */
+  scratch = new Project3({
+    skipAddingFilesFromTsConfig: true,
+    skipLoadingLibFiles: true,
+    skipFileDependencyResolution: true
+  });
+  needs = /* @__PURE__ */ new Map();
+  /** Pruned text per file, as last written into {@link project}. */
+  written = /* @__PURE__ */ new Map();
+  /**
+   * The typed copy of a discovery file, with its schema positions kept. Adding one
+   * that was not there yet (a contract file discovery reached lazily) rebuilds the
+   * program once.
+   */
+  sourceFileFor(sf) {
+    this.request(sf.getFilePath(), { schema: true });
+    this.flush();
+    return this.project.getSourceFile(sf.getFilePath());
+  }
+  // -------------------------------------------------------------------------
+  queue = [];
+  request(path, want) {
+    let needs = this.needs.get(path);
+    const isNew = !needs;
+    needs ??= { schema: false, all: false, names: /* @__PURE__ */ new Set() };
+    let grew = isNew;
+    if (want.schema && !needs.schema) {
+      needs.schema = true;
+      grew = true;
+    }
+    if (want.all && !needs.all) {
+      needs.all = true;
+      grew = true;
+    }
+    for (const name of want.names ?? []) {
+      if (!needs.names.has(name)) {
+        needs.names.add(name);
+        grew = true;
+      }
+    }
+    this.needs.set(path, needs);
+    if (grew) this.queue.push(path);
+  }
+  /** Run the worklist to a fixpoint, then write every changed file into the program. */
+  flush() {
+    const changed = /* @__PURE__ */ new Map();
+    while (this.queue.length > 0) {
+      const path = this.queue.pop();
+      const original = this.original(path);
+      if (!original) continue;
+      const needs = this.needs.get(path);
+      const text = this.prune(original, needs);
+      if (this.written.get(path) !== text) changed.set(path, text);
+    }
+    for (const [path, text] of changed) {
+      this.project.createSourceFile(path, text, { overwrite: true });
+      this.written.set(path, text);
+    }
+  }
+  /** The file as discovery sees it (its in-memory text), else as it is on disk. */
+  original(path) {
+    return this.discovery.getSourceFile(path) ?? this.scratch.getSourceFile(path) ?? this.scratch.addSourceFileAtPathIfExists(path);
+  }
+  /**
+   * `sf`'s text with every import/re-export nothing in `needs` references blanked,
+   * requesting from each kept one's target the names it brings in.
+   */
+  prune(sf, needs) {
+    const locals = topLevelDeclarations(sf);
+    const roots = [];
+    if (needs.all) roots.push(...sf.getStatements());
+    if (needs.schema) roots.push(...schemaPositions(sf));
+    const reexported = /* @__PURE__ */ new Map();
+    for (const exp of sf.getExportDeclarations()) {
+      const spec = exp.getModuleSpecifierValue();
+      if (spec === void 0) {
+        for (const named of exp.getNamedExports()) {
+          const exposed = (named.getAliasNode() ?? named.getNameNode()).getText();
+          if (needs.all || needs.names.has(exposed)) roots.push(named.getNameNode());
+        }
+        continue;
+      }
+      if (exp.isNamespaceExport() || exp.getNamedExports().length === 0) continue;
+      for (const named of exp.getNamedExports()) {
+        const exposed = (named.getAliasNode() ?? named.getNameNode()).getText();
+        const list = reexported.get(exposed) ?? [];
+        list.push({ from: spec, name: named.getNameNode().getText() });
+        reexported.set(exposed, list);
+      }
+    }
+    const unresolvedNames = [];
+    for (const name of needs.names) {
+      const decls = name === "default" ? defaultExport(sf) : locals.get(name) ?? [];
+      if (decls.length > 0) roots.push(...decls);
+      else if (!reexported.has(name)) unresolvedNames.push(name);
+    }
+    const referenced = /* @__PURE__ */ new Set();
+    const queue = [...roots];
+    const seen = new Set(queue);
+    while (queue.length > 0) {
+      const node = queue.pop();
+      const ids = Node7.isIdentifier(node) ? [node] : node.getDescendantsOfKind(ts.SyntaxKind.Identifier);
+      for (const id of ids) {
+        const name = id.getText();
+        if (referenced.has(name)) continue;
+        referenced.add(name);
+        for (const local of locals.get(name) ?? []) {
+          if (seen.has(local)) continue;
+          seen.add(local);
+          queue.push(local);
+        }
+      }
+    }
+    const chars = sf.getFullText().split("");
+    const blank = (node) => {
+      for (let i = node.getStart(); i < node.getEnd(); i++) {
+        if (chars[i] !== "\n" && chars[i] !== "\r") chars[i] = " ";
+      }
+    };
+    for (const decl of sf.getImportDeclarations()) {
+      const target = this.resolve(decl.getModuleSpecifierValue(), sf);
+      const namespace = decl.getNamespaceImport()?.getText();
+      const def = decl.getDefaultImport()?.getText();
+      const named = decl.getNamedImports().map((n) => ({
+        local: (n.getAliasNode() ?? n.getNameNode()).getText(),
+        imported: n.getName()
+      })).filter((n) => referenced.has(n.local));
+      const wantsNamespace = namespace !== void 0 && referenced.has(namespace);
+      const wantsDefault = def !== void 0 && referenced.has(def);
+      if (!wantsNamespace && !wantsDefault && named.length === 0) {
+        blank(decl);
+        continue;
+      }
+      if (target) {
+        this.request(target, {
+          all: wantsNamespace,
+          names: [...wantsDefault ? ["default"] : [], ...named.map((n) => n.imported)]
+        });
+      }
+    }
+    for (const exp of sf.getExportDeclarations()) {
+      const spec = exp.getModuleSpecifierValue();
+      if (spec === void 0) continue;
+      const target = this.resolve(spec, sf);
+      if (exp.isNamespaceExport() || exp.getNamedExports().length === 0) {
+        if (!needs.all && unresolvedNames.length === 0) {
+          blank(exp);
+        } else if (target) {
+          this.request(target, { all: needs.all, names: unresolvedNames });
+        }
+        continue;
+      }
+      const wanted = exp.getNamedExports().filter(
+        (n) => needs.all || needs.names.has((n.getAliasNode() ?? n.getNameNode()).getText())
+      ).map((n) => n.getNameNode().getText());
+      if (wanted.length === 0) blank(exp);
+      else if (target) this.request(target, { names: wanted });
+    }
+    return chars.join("");
+  }
+  /**
+   * The project source file a module specifier resolves to, or undefined for a
+   * package (read unpruned by the program itself) or an unresolvable one.
+   */
+  resolve(specifier, from) {
+    const resolved = ts.resolveModuleName(
+      specifier,
+      from.getFilePath(),
+      this.options,
+      ts.sys
+    ).resolvedModule;
+    if (!resolved || resolved.isExternalLibraryImport) return void 0;
+    const file = resolved.resolvedFileName;
+    if (file.endsWith(".d.ts") || !/\.(m|c)?tsx?$/.test(file)) return void 0;
+    return file;
+  }
+};
+function schemaPositions(sf) {
+  const roots = [];
+  sf.forEachDescendant((node) => {
+    if (Node7.isDecorator(node)) {
+      const name = node.getName();
+      if (name === "ApplyContract") {
+        roots.push(...node.getArguments());
+      } else if (PARAM_DECORATORS.has(name)) {
+        for (const arg of node.getArguments()) {
+          if (Node7.isNewExpression(arg) || Node7.isCallExpression(arg)) {
+            roots.push(...arg.getArguments());
+          }
+        }
+      }
+    } else if (Node7.isCallExpression(node)) {
+      const callee = node.getExpression();
+      const name = Node7.isIdentifier(callee) ? callee.getText() : Node7.isPropertyAccessExpression(callee) ? callee.getName() : void 0;
+      if (name === "defineContract") roots.push(...node.getArguments());
+    }
+  });
+  return roots;
+}
+function topLevelDeclarations(sf) {
+  const byName = /* @__PURE__ */ new Map();
+  const add = (name, node) => {
+    if (!name) return;
+    const list = byName.get(name);
+    if (list) list.push(node);
+    else byName.set(name, [node]);
+  };
+  for (const decl of sf.getVariableDeclarations()) add(decl.getName(), decl);
+  for (const decl of sf.getFunctions()) add(decl.getName(), decl);
+  for (const decl of sf.getClasses()) add(decl.getName(), decl);
+  for (const decl of sf.getEnums()) add(decl.getName(), decl);
+  for (const decl of sf.getInterfaces()) add(decl.getName(), decl);
+  for (const decl of sf.getTypeAliases()) add(decl.getName(), decl);
+  for (const decl of sf.getModules()) add(decl.getName(), decl);
+  return byName;
+}
+function defaultExport(sf) {
+  const nodes = [];
+  for (const assignment of sf.getExportAssignments()) nodes.push(assignment);
+  for (const fn of sf.getFunctions()) if (fn.isDefaultExport()) nodes.push(fn);
+  for (const cls of sf.getClasses()) if (cls.isDefaultExport()) nodes.push(cls);
+  return nodes;
+}
+
+// src/discovery/schema-type-inference.ts
+var programs = /* @__PURE__ */ new WeakMap();
+function programFor(discovery) {
+  let program = programs.get(discovery);
+  if (!program) {
+    program = new SchemaTypeProgram(discovery);
+    programs.set(discovery, program);
+  }
+  return program;
+}
+function clearSchemaTypeProject(discovery) {
+  programs.delete(discovery);
+}
+function counterpart(typedSf, node) {
+  const start = node.getStart();
+  const end = node.getEnd();
+  const kind = node.getKind();
+  let candidate = typedSf.getDescendantAtPos(start);
+  while (candidate) {
+    if (candidate.getStart() === start && candidate.getEnd() === end && candidate.getKind() === kind) {
+      return candidate;
+    }
+    if (candidate.getStart() < start || candidate.getEnd() > end) return void 0;
+    candidate = candidate.getParent();
+  }
+  return void 0;
+}
+function propType(type, name, at) {
+  return type.getProperty(name)?.getTypeAtLocation(at);
+}
+function isAnyOrUnknown(type) {
+  return type.isAny() || type.isUnknown();
+}
+function inferSchema(expr, discovery) {
+  try {
+    const typedSf = programFor(discovery).sourceFileFor(expr.getSourceFile());
+    const at = typedSf && counterpart(typedSf, expr);
+    if (!at) return { kind: "unresolved" };
+    const schemaType = at.getType();
+    if (isAnyOrUnknown(schemaType)) return { kind: "unresolved" };
+    const standard = propType(schemaType, "~standard", at);
+    const stdTypes = standard ? propType(standard, "types", at)?.getNonNullableType() : void 0;
+    const stdInput = stdTypes ? propType(stdTypes, "input", at) : void 0;
+    const stdOutput = stdTypes ? propType(stdTypes, "output", at) : void 0;
+    if (stdInput && stdOutput) {
+      return { kind: "schema", types: { input: stdInput, output: stdOutput, at } };
+    }
+    const zodInput = propType(schemaType, "_input", at);
+    const zodOutput = propType(schemaType, "_output", at);
+    if (zodInput && zodOutput) {
+      return { kind: "schema", types: { input: zodInput, output: zodOutput, at } };
+    }
+    return { kind: "not-schema" };
+  } catch (err) {
+    dbg("schema inference failed:", err);
+    return { kind: "unresolved" };
+  }
+}
+var GLOBAL_NAMED_TYPES = /* @__PURE__ */ new Set([
+  "Date",
+  "File",
+  "Blob",
+  "FormData",
+  "URL",
+  "RegExp",
+  "Map",
+  "Set",
+  "ArrayBuffer",
+  "Uint8Array"
+]);
+var MAX_DEPTH = 12;
+function objectKey(name) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
+}
+function isOptionalSymbol(sym) {
+  return (sym.getFlags() & ts2.SymbolFlags.Optional) !== 0;
+}
+function isSymbolKeyed(sym) {
+  return sym.getName().startsWith("__@");
+}
+function orderedProperties(type) {
+  const position = (sym) => {
+    const decl = sym.getDeclarations()[0];
+    return decl ? [decl.getSourceFile().getFilePath(), decl.getStart()] : void 0;
+  };
+  return type.getProperties().map((sym, index) => ({ sym, index, at: position(sym) })).sort((a, b) => {
+    if (a.at && b.at) {
+      if (a.at[0] !== b.at[0]) return a.at[0] < b.at[0] ? -1 : 1;
+      if (a.at[1] !== b.at[1]) return a.at[1] - b.at[1];
+    } else if (a.at || b.at) {
+      return a.at ? -1 : 1;
+    }
+    return a.index - b.index;
+  }).map((entry) => entry.sym);
+}
+function isFromDeclarationFile(sym) {
+  const decl = sym?.getDeclarations()[0];
+  return !!decl && decl.getSourceFile().isDeclarationFile();
+}
+function render(type, state, paired) {
+  if (state.depth > MAX_DEPTH) return "unknown";
+  if (isAnyOrUnknown(type)) {
+    return paired && !isAnyOrUnknown(paired) ? render(paired, state) : "unknown";
+  }
+  if (type.isNever()) return "never";
+  if (type.isString() || type.isTemplateLiteral()) return "string";
+  if (type.isNumber()) return "number";
+  if (type.isBoolean()) return "boolean";
+  if (type.isBigInt()) return "bigint";
+  if (type.isNull()) return "null";
+  if (type.isUndefined() || type.isVoid()) return "undefined";
+  if (type.isBooleanLiteral()) return type.getText();
+  if (type.isStringLiteral() || type.isNumberLiteral() || type.isEnumLiteral()) {
+    const value = type.getLiteralValue();
+    return typeof value === "string" ? JSON.stringify(value) : String(value);
+  }
+  if (type.isBigIntLiteral()) return type.getText();
+  if (type.isTypeParameter()) return "unknown";
+  if (type.isUnion()) return renderUnion(type, state, paired);
+  if (type.isIntersection()) return renderIntersection(type, state);
+  const next = { ...state, depth: state.depth + 1 };
+  if (type.isArray() || type.isReadonlyArray()) {
+    const element = type.getArrayElementType() ?? type.getTypeArguments()[0];
+    const pairedElement = paired?.getArrayElementType() ?? paired?.getTypeArguments()[0];
+    return element ? `Array<${render(element, next, pairedElement)}>` : "Array<unknown>";
+  }
+  if (type.isTuple()) {
+    const elements = type.getTupleElements();
+    const pairedElements = paired?.isTuple() ? paired.getTupleElements() : [];
+    return `[${elements.map((e, i) => render(e, next, pairedElements[i])).join(", ")}]`;
+  }
+  if (type.isObject()) return renderObject(type, next, paired);
+  return "unknown";
+}
+function renderUnion(type, state, paired) {
+  const members = type.getUnionTypes();
+  const hasTrue = members.some((m) => m.isBooleanLiteral() && m.getText() === "true");
+  const hasFalse = members.some((m) => m.isBooleanLiteral() && m.getText() === "false");
+  const pairedNonNull = paired?.getNonNullableType();
+  const arms = [];
+  let sawBoolean = false;
+  let hasNull = false;
+  let hasUndefined = false;
+  for (const member of members) {
+    if (member.isNull()) {
+      hasNull = true;
+      continue;
+    }
+    if (member.isUndefined()) {
+      hasUndefined = true;
+      continue;
+    }
+    if (member.isBooleanLiteral() && hasTrue && hasFalse) {
+      if (!sawBoolean) arms.push("boolean");
+      sawBoolean = true;
+      continue;
+    }
+    arms.push(render(member, state, members.length === 1 ? paired : pairedNonNull));
+  }
+  if (hasNull) arms.push("null");
+  if (hasUndefined) arms.push("undefined");
+  const unique = [...new Set(arms)];
+  if (unique.includes("unknown")) return "unknown";
+  return unique.join(" | ");
+}
+function renderIntersection(type, state) {
+  const members = type.getIntersectionTypes();
+  const primitive = members.find((m) => !m.isObject());
+  if (primitive) return render(primitive, state);
+  return renderObject(type, { ...state, depth: state.depth + 1 }, void 0);
+}
+function renderObject(type, state, paired) {
+  const symbol = type.getSymbol() ?? type.getAliasSymbol();
+  const name = symbol?.getName();
+  if (name && GLOBAL_NAMED_TYPES.has(name) && isFromDeclarationFile(symbol)) {
+    const args = type.getTypeArguments();
+    return args.length ? `${name}<${args.map((a) => render(a, state)).join(", ")}>` : name;
+  }
+  if (type.getCallSignatures().length > 0 || type.getConstructSignatures().length > 0) {
+    return "unknown";
+  }
+  if (type.isClassOrInterface() && isFromDeclarationFile(symbol)) return "unknown";
+  if (state.stack.has(type.compilerType)) return "unknown";
+  const stack = new Set(state.stack).add(type.compilerType);
+  const inner = { ...state, stack };
+  const fields = [];
+  for (const prop of orderedProperties(type)) {
+    if (isSymbolKeyed(prop)) continue;
+    const propName = prop.getName();
+    const propT = prop.getTypeAtLocation(state.at);
+    if (propT.getCallSignatures().length > 0 && !propT.isUnion()) continue;
+    const pairedProp = paired?.getProperty(propName)?.getTypeAtLocation(state.at);
+    const optional = isOptionalSymbol(prop) ? "?" : "";
+    fields.push(`${objectKey(propName)}${optional}: ${render(propT, inner, pairedProp)}`);
+  }
+  const stringIndex = type.getStringIndexType();
+  if (stringIndex) {
+    const pairedIndex = paired?.getStringIndexType();
+    const value = render(stringIndex, inner, pairedIndex);
+    if (fields.length === 0) return `Record<string, ${value}>`;
+    fields.push(`[key: string]: ${value}`);
+  }
+  return fields.length ? `{ ${fields.join("; ")} }` : "{}";
+}
+function stateAt(at) {
+  return { at, stack: /* @__PURE__ */ new Set(), depth: 0 };
+}
+function requestTypeOf(types) {
+  return render(types.input, stateAt(types.at), types.output);
+}
+function responseTypeOf(types) {
+  return render(types.output, stateAt(types.at));
+}
+function requestFieldsOf(types) {
+  const { input, output, at } = types;
+  const objectInput = input.getNonNullableType();
+  if (!objectInput.isObject() || objectInput.isArray() || objectInput.isTuple()) return null;
+  const state = stateAt(at);
+  return orderedProperties(objectInput).filter((prop) => !isSymbolKeyed(prop)).map((prop) => ({
+    name: prop.getName(),
+    type: render(
+      prop.getTypeAtLocation(at),
+      state,
+      output.getProperty(prop.getName())?.getTypeAtLocation(at)
+    ),
+    optional: isOptionalSymbol(prop)
+  }));
+}
+function acceptsUndefined(types) {
+  const { input, output } = types;
+  const accepted = isAnyOrUnknown(input) ? output : input;
+  if (isAnyOrUnknown(accepted) || accepted.isUndefined()) return true;
+  return accepted.isUnion() && accepted.getUnionTypes().some((t) => t.isUndefined());
+}
+
+// src/discovery/zod-ast-to-ts.ts
+import { Node as Node8, SyntaxKind as SyntaxKind3 } from "ts-morph";
+function zodAstToTs(node) {
+  if (!Node8.isCallExpression(node)) return "unknown";
+  const expr = node.getExpression();
+  if (Node8.isPropertyAccessExpression(expr)) {
+    const methodName = expr.getName();
+    const receiver = expr.getExpression();
+    if (methodName === "optional") {
+      return `${zodAstToTs(receiver)} | undefined`;
+    }
+    if (methodName === "nullable") {
+      return `${zodAstToTs(receiver)} | null`;
+    }
+    const args = node.getArguments();
+    switch (methodName) {
+      case "string":
+        return "string";
+      case "number":
+        return "number";
+      case "boolean":
+        return "boolean";
+      case "unknown":
+        return "unknown";
+      case "any":
+        return "unknown";
+      case "literal": {
+        const lit = args[0];
+        if (!lit) return "unknown";
+        if (Node8.isStringLiteral(lit)) return JSON.stringify(lit.getLiteralValue());
+        if (Node8.isNumericLiteral(lit)) return lit.getLiteralValue().toString();
+        if (lit.getKind() === SyntaxKind3.TrueKeyword) return "true";
+        if (lit.getKind() === SyntaxKind3.FalseKeyword) return "false";
+        return "unknown";
+      }
+      case "enum": {
+        const arrArg = args[0];
+        if (!arrArg || !Node8.isArrayLiteralExpression(arrArg)) return "unknown";
+        const members = arrArg.getElements().map(
+          (el) => Node8.isStringLiteral(el) ? JSON.stringify(el.getLiteralValue()) : "unknown"
+        );
+        return members.join(" | ");
+      }
+      case "array": {
+        const inner = args[0];
+        if (!inner) return "unknown";
+        return `Array<${zodAstToTs(inner)}>`;
+      }
+      case "object": {
+        const objArg = args[0];
+        if (!objArg || !Node8.isObjectLiteralExpression(objArg)) return "unknown";
+        const lines = [];
+        for (const prop of objArg.getProperties()) {
+          if (!Node8.isPropertyAssignment(prop)) continue;
+          const key = prop.getName();
+          const valNode = prop.getInitializer();
+          if (!valNode) continue;
+          const tsType = zodAstToTs(valNode);
+          const isOpt = isOptionalChain(valNode);
+          lines.push(`${key}${isOpt ? "?" : ""}: ${tsType}`);
+        }
+        return `{ ${lines.join("; ")} }`;
+      }
+      case "union": {
+        const arrArg = args[0];
+        if (!arrArg || !Node8.isArrayLiteralExpression(arrArg)) return "unknown";
+        return arrArg.getElements().map(zodAstToTs).join(" | ");
+      }
+      case "record": {
+        const valArg = args.length === 1 ? args[0] : args[1];
+        if (!valArg) return "unknown";
+        return `Record<string, ${zodAstToTs(valArg)}>`;
+      }
+      case "tuple": {
+        const arrArg = args[0];
+        if (!arrArg || !Node8.isArrayLiteralExpression(arrArg)) return "unknown";
+        return `[${arrArg.getElements().map(zodAstToTs).join(", ")}]`;
+      }
+      default:
+        return "unknown";
+    }
+  }
+  return "unknown";
+}
+function isOptionalChain(node) {
+  if (!Node8.isCallExpression(node)) return false;
+  const expr = node.getExpression();
+  return Node8.isPropertyAccessExpression(expr) && expr.getName() === "optional";
+}
+function memberType(val, position, project) {
+  if (project) {
+    const inferred = inferSchema(val, project);
+    if (inferred.kind === "schema") {
+      return position === "request" ? requestTypeOf(inferred.types) : responseTypeOf(inferred.types);
+    }
+  }
+  return zodAstToTs(val);
+}
+function parseDefineContractCall(callExpr, project) {
+  if (!Node8.isCallExpression(callExpr)) return null;
+  const callee = callExpr.getExpression();
+  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 || !Node8.isObjectLiteralExpression(optsArg)) return null;
+  let query = null;
+  let body = null;
+  let response = "unknown";
+  let error = null;
+  let bodyZodText = null;
+  let queryZodText = null;
+  for (const prop of optsArg.getProperties()) {
+    if (!Node8.isPropertyAssignment(prop)) continue;
+    const propName = prop.getName();
+    const val = prop.getInitializer();
+    if (!val) continue;
+    if (propName === "query") {
+      query = memberType(val, "request", project);
+      queryZodText = val.getText();
+    } else if (propName === "body") {
+      body = memberType(val, "request", project);
+      bodyZodText = val.getText();
+    } else if (propName === "response") {
+      response = memberType(val, "response", project);
+    } else if (propName === "error") {
+      error = memberType(val, "response", project);
+    }
+  }
+  return { query, body, response, error, bodyZodText, queryZodText };
+}
+
+// src/discovery/pipe-schema.ts
+function pipeSchemaOf(decorator, project) {
+  for (const pipe of decorator.getArguments()) {
+    if (!Node9.isNewExpression(pipe) && !Node9.isCallExpression(pipe)) continue;
+    for (const arg of pipe.getArguments()) {
+      if (!couldBeSchema(arg)) continue;
+      const inferred = inferSchema(arg, project);
+      if (inferred.kind === "schema") {
+        return {
+          type: requestTypeOf(inferred.types),
+          optional: acceptsUndefined(inferred.types),
+          fields: requestFieldsOf(inferred.types)
+        };
+      }
+      if (inferred.kind === "unresolved") {
+        const fallback = syntacticZodType(arg, project);
+        if (fallback) {
+          return { type: fallback, optional: fallback.endsWith("| undefined"), fields: null };
+        }
+      }
+    }
+  }
+  return null;
+}
+function couldBeSchema(arg) {
+  return Node9.isIdentifier(arg) || Node9.isPropertyAccessExpression(arg) || Node9.isCallExpression(arg) || Node9.isAsExpression(arg) || Node9.isSatisfiesExpression(arg) || Node9.isParenthesizedExpression(arg);
+}
+function syntacticZodType(arg, project) {
+  let expr = arg;
+  if (Node9.isIdentifier(arg)) {
+    const resolved = resolveImportedVariable(arg.getText(), arg.getSourceFile(), project);
+    expr = resolved?.decl.getInitializer();
+  }
+  if (!expr || !Node9.isCallExpression(expr)) return null;
+  const type = zodAstToTs(expr);
+  return type === "unknown" ? null : type;
+}
+
 // src/discovery/dto-type-resolver.ts
 var WRAPPER_TYPES = {
   // MikroORM Ref/Reference/LoadedReference/IdentifiedReference are server-side
@@ -2102,22 +2770,22 @@ var PASSTHROUGH_UTILITY = /* @__PURE__ */ new Set([
 ]);
 function resolveTypeNodeToString(typeNode, sourceFile, project, depth, subst = /* @__PURE__ */ new Map()) {
   if (depth <= 0) return "unknown";
-  if (Node7.isArrayTypeNode(typeNode)) {
+  if (Node10.isArrayTypeNode(typeNode)) {
     const elementType = typeNode.getElementTypeNode();
     return `Array<${resolveTypeNodeToString(elementType, sourceFile, project, depth, subst)}>`;
   }
-  if (Node7.isUnionTypeNode(typeNode)) {
+  if (Node10.isUnionTypeNode(typeNode)) {
     return typeNode.getTypeNodes().map((t) => resolveTypeNodeToString(t, sourceFile, project, depth, subst)).join(" | ");
   }
-  if (Node7.isIntersectionTypeNode(typeNode)) {
+  if (Node10.isIntersectionTypeNode(typeNode)) {
     return typeNode.getTypeNodes().map((t) => resolveTypeNodeToString(t, sourceFile, project, depth, subst)).join(" & ");
   }
-  if (Node7.isParenthesizedTypeNode(typeNode)) {
+  if (Node10.isParenthesizedTypeNode(typeNode)) {
     return `(${resolveTypeNodeToString(typeNode.getTypeNode(), sourceFile, project, depth, subst)})`;
   }
-  if (Node7.isTypeReference(typeNode)) {
+  if (Node10.isTypeReference(typeNode)) {
     const typeName = typeNode.getTypeName();
-    const name = Node7.isIdentifier(typeName) ? typeName.getText() : typeNode.getText();
+    const name = Node10.isIdentifier(typeName) ? typeName.getText() : typeNode.getText();
     const bound = subst.get(name);
     if (bound !== void 0) return bound;
     if (name === "string" || name === "number" || name === "boolean") return name;
@@ -2140,13 +2808,13 @@ function resolveTypeNodeToString(typeNode, sourceFile, project, depth, subst = /
     dbg("unresolvable type:", name, "in", sourceFile.getFilePath());
     return "unknown";
   }
-  if (Node7.isTypeLiteral(typeNode)) {
+  if (Node10.isTypeLiteral(typeNode)) {
     const members = [];
     for (const member of typeNode.getMembers()) {
-      if (Node7.isPropertySignature(member)) {
+      if (Node10.isPropertySignature(member)) {
         const memberTypeNode = member.getTypeNode();
-        const memberType = memberTypeNode ? resolveTypeNodeToString(memberTypeNode, sourceFile, project, depth, subst) : "unknown";
-        members.push(`${member.getName()}${member.hasQuestionToken() ? "?" : ""}: ${memberType}`);
+        const memberType2 = memberTypeNode ? resolveTypeNodeToString(memberTypeNode, sourceFile, project, depth, subst) : "unknown";
+        members.push(`${member.getName()}${member.hasQuestionToken() ? "?" : ""}: ${memberType2}`);
       } else {
         members.push(member.getText());
       }
@@ -2154,11 +2822,11 @@ function resolveTypeNodeToString(typeNode, sourceFile, project, depth, subst = /
     return members.length > 0 ? `{ ${members.join("; ")} }` : "{}";
   }
   const kind = typeNode.getKind();
-  if (kind === SyntaxKind3.StringKeyword) return "string";
-  if (kind === SyntaxKind3.NumberKeyword) return "number";
-  if (kind === SyntaxKind3.BooleanKeyword) return "boolean";
-  if (kind === SyntaxKind3.UnknownKeyword) return "unknown";
-  if (kind === SyntaxKind3.AnyKeyword) return "unknown";
+  if (kind === SyntaxKind4.StringKeyword) return "string";
+  if (kind === SyntaxKind4.NumberKeyword) return "number";
+  if (kind === SyntaxKind4.BooleanKeyword) return "boolean";
+  if (kind === SyntaxKind4.UnknownKeyword) return "unknown";
+  if (kind === SyntaxKind4.AnyKeyword) return "unknown";
   return typeNode.getText();
 }
 function unwrapFirstTypeArg(typeNode, sourceFile, project, depth, mode, subst = /* @__PURE__ */ new Map()) {
@@ -2206,20 +2874,24 @@ function resolvePropertied(decl, sourceFile, project, depth, subst = /* @__PURE_
     const propName = prop.getName();
     const isOptional = prop.hasQuestionToken();
     const propTypeNode = prop.getTypeNode();
-    let propType = "unknown";
+    let propType2 = "unknown";
     if (propTypeNode) {
-      propType = resolveTypeNodeToString(propTypeNode, sourceFile, project, depth, subst);
+      propType2 = resolveTypeNodeToString(propTypeNode, sourceFile, project, depth, subst);
     }
-    lines.push(`${propName}${isOptional ? "?" : ""}: ${propType}`);
+    lines.push(`${propName}${isOptional ? "?" : ""}: ${propType2}`);
   }
   return `{ ${lines.join("; ")} }`;
 }
+function namedField(decorator) {
+  const first = decorator.getArguments()[0];
+  return first && Node10.isStringLiteral(first) ? first.getLiteralValue() : null;
+}
 function extractBodyType(method, sourceFile, project) {
   for (const param of method.getParameters()) {
     const bodyDecorator = param.getDecorators().find((d) => d.getName() === "Body");
-    if (!bodyDecorator) continue;
-    const bodyArgs = bodyDecorator.getArguments();
-    if (bodyArgs.length > 0) continue;
+    if (!bodyDecorator || namedField(bodyDecorator) !== null) continue;
+    const piped = pipeSchemaOf(bodyDecorator, project);
+    if (piped) return piped.type;
     const typeNode = param.getTypeNode();
     if (typeNode) {
       return resolveTypeNodeToString(typeNode, sourceFile, project, 3);
@@ -2227,11 +2899,16 @@ function extractBodyType(method, sourceFile, project) {
   }
   return null;
 }
+function hasPipeSchema(param, decoratorName, project) {
+  const decorator = param.getDecorators().find((d) => d.getName() === decoratorName);
+  return !!decorator && pipeSchemaOf(decorator, project) !== null;
+}
 function extractQueryType(method, sourceFile, project) {
   for (const param of method.getParameters()) {
     const queryDecorator = param.getDecorators().find((d) => d.getName() === "Query");
-    if (!queryDecorator) continue;
-    if (queryDecorator.getArguments().length > 0) continue;
+    if (!queryDecorator || namedField(queryDecorator) !== null) continue;
+    const piped = pipeSchemaOf(queryDecorator, project);
+    if (piped) return piped.type;
     const typeNode = param.getTypeNode();
     if (typeNode) {
       return resolveTypeNodeToString(typeNode, sourceFile, project, 3);
@@ -2241,10 +2918,13 @@ function extractQueryType(method, sourceFile, project) {
   for (const param of method.getParameters()) {
     const queryDecorator = param.getDecorators().find((d) => d.getName() === "Query");
     if (!queryDecorator) continue;
-    const queryArgs = queryDecorator.getArguments();
-    const nameArg = queryArgs[0];
-    if (!nameArg || !Node7.isStringLiteral(nameArg)) continue;
-    const queryName = nameArg.getLiteralValue();
+    const queryName = namedField(queryDecorator);
+    if (queryName === null) continue;
+    const piped = pipeSchemaOf(queryDecorator, project);
+    if (piped) {
+      entries.push(`${queryName}${piped.optional ? "?" : ""}: ${piped.type}`);
+      continue;
+    }
     const typeNode = param.getTypeNode();
     const queryType = typeNode ? resolveTypeNodeToString(typeNode, sourceFile, project, 3) : "string";
     entries.push(`${queryName}${isParamOptional(param) ? "?" : ""}: ${queryType}`);
@@ -2254,8 +2934,8 @@ function extractQueryType(method, sourceFile, project) {
 function isParamOptional(param) {
   if (param.hasQuestionToken() || param.hasInitializer()) return true;
   const typeNode = param.getTypeNode();
-  if (typeNode && Node7.isUnionTypeNode(typeNode)) {
-    return typeNode.getTypeNodes().some((t) => t.getKind() === SyntaxKind3.UndefinedKeyword);
+  if (typeNode && Node10.isUnionTypeNode(typeNode)) {
+    return typeNode.getTypeNodes().some((t) => t.getKind() === SyntaxKind4.UndefinedKeyword);
   }
   return false;
 }
@@ -2267,7 +2947,7 @@ function extractParamsType(method, sourceFile, project) {
     const paramArgs = paramDecorator.getArguments();
     if (paramArgs.length === 0) continue;
     const nameArg = paramArgs[0];
-    if (!Node7.isStringLiteral(nameArg)) continue;
+    if (!Node10.isStringLiteral(nameArg)) continue;
     const paramName = nameArg.getLiteralValue();
     const typeNode = param.getTypeNode();
     const paramType = typeNode ? resolveTypeNodeToString(typeNode, sourceFile, project, 3) : "string";
@@ -2275,6 +2955,22 @@ function extractParamsType(method, sourceFile, project) {
   }
   return entries.length > 0 ? `{ ${entries.join("; ")} }` : null;
 }
+function extractPipedParamTypes(method, project) {
+  const types = {};
+  for (const param of method.getParameters()) {
+    const paramDecorator = param.getDecorators().find((d) => d.getName() === "Param");
+    if (!paramDecorator) continue;
+    const piped = pipeSchemaOf(paramDecorator, project);
+    if (!piped) continue;
+    const name = namedField(paramDecorator);
+    if (name !== null) {
+      types[name] = piped.type;
+    } else {
+      for (const field of piped.fields ?? []) types[field.name] = field.type;
+    }
+  }
+  return Object.keys(types).length > 0 ? types : null;
+}
 function extractUploadedFiles(method) {
   const FILE = "File | Blob";
   const entries = [];
@@ -2288,28 +2984,28 @@ function extractUploadedFiles(method) {
   for (const decorator of method.getDecorators()) {
     if (decorator.getName() !== "UseInterceptors") continue;
     for (const arg of decorator.getArguments()) {
-      if (!Node7.isCallExpression(arg)) continue;
+      if (!Node10.isCallExpression(arg)) continue;
       const interceptor = arg.getExpression().getText();
       const callArgs = arg.getArguments();
       const firstArg2 = callArgs[0];
       if (interceptor === "FileInterceptor") {
-        if (firstArg2 && Node7.isStringLiteral(firstArg2)) {
+        if (firstArg2 && Node10.isStringLiteral(firstArg2)) {
           entries.push(`${firstArg2.getLiteralValue()}: ${FILE}`);
           multipart = true;
         }
       } else if (interceptor === "FilesInterceptor") {
-        if (firstArg2 && Node7.isStringLiteral(firstArg2)) {
+        if (firstArg2 && Node10.isStringLiteral(firstArg2)) {
           entries.push(`${firstArg2.getLiteralValue()}: Array<${FILE}>`);
           multipart = true;
         }
       } else if (interceptor === "FileFieldsInterceptor") {
-        if (firstArg2 && Node7.isArrayLiteralExpression(firstArg2)) {
+        if (firstArg2 && Node10.isArrayLiteralExpression(firstArg2)) {
           for (const el of firstArg2.getElements()) {
-            if (!Node7.isObjectLiteralExpression(el)) continue;
+            if (!Node10.isObjectLiteralExpression(el)) continue;
             const nameProp = el.getProperty("name");
-            if (nameProp && Node7.isPropertyAssignment(nameProp)) {
+            if (nameProp && Node10.isPropertyAssignment(nameProp)) {
               const init = nameProp.getInitializer();
-              if (init && Node7.isStringLiteral(init)) {
+              if (init && Node10.isStringLiteral(init)) {
                 entries.push(`${init.getLiteralValue()}: Array<${FILE}>`);
               }
             }
@@ -2329,13 +3025,13 @@ function extractResponseType(method, sourceFile, project) {
   if (apiResponseDecorator) {
     const args = apiResponseDecorator.getArguments();
     const optsArg = args[0];
-    if (optsArg && Node7.isObjectLiteralExpression(optsArg)) {
+    if (optsArg && Node10.isObjectLiteralExpression(optsArg)) {
       for (const prop of optsArg.getProperties()) {
-        if (!Node7.isPropertyAssignment(prop)) continue;
+        if (!Node10.isPropertyAssignment(prop)) continue;
         if (prop.getName() !== "type") continue;
         const val = prop.getInitializer();
         if (!val) continue;
-        if (Node7.isArrayLiteralExpression(val)) {
+        if (Node10.isArrayLiteralExpression(val)) {
           const elements = val.getElements();
           const firstEl = elements[0];
           if (elements.length > 0 && firstEl !== void 0) {
@@ -2356,24 +3052,24 @@ function extractResponseType(method, sourceFile, project) {
 }
 function apiResponseStatus(decorator) {
   const optsArg = decorator.getArguments()[0];
-  if (!optsArg || !Node7.isObjectLiteralExpression(optsArg)) return null;
+  if (!optsArg || !Node10.isObjectLiteralExpression(optsArg)) return null;
   for (const prop of optsArg.getProperties()) {
-    if (!Node7.isPropertyAssignment(prop)) continue;
+    if (!Node10.isPropertyAssignment(prop)) continue;
     if (prop.getName() !== "status") continue;
     const val = prop.getInitializer();
-    if (val && Node7.isNumericLiteral(val)) return Number(val.getLiteralValue());
+    if (val && Node10.isNumericLiteral(val)) return Number(val.getLiteralValue());
   }
   return null;
 }
 function apiResponseTypeNode(decorator) {
   const optsArg = decorator.getArguments()[0];
-  if (!optsArg || !Node7.isObjectLiteralExpression(optsArg)) return null;
+  if (!optsArg || !Node10.isObjectLiteralExpression(optsArg)) return null;
   for (const prop of optsArg.getProperties()) {
-    if (!Node7.isPropertyAssignment(prop)) continue;
+    if (!Node10.isPropertyAssignment(prop)) continue;
     if (prop.getName() !== "type") continue;
     const val = prop.getInitializer();
     if (!val) return null;
-    if (Node7.isArrayLiteralExpression(val)) {
+    if (Node10.isArrayLiteralExpression(val)) {
       const first = val.getElements()[0];
       return first ? { node: first, isArray: true } : null;
     }
@@ -2391,7 +3087,7 @@ function extractErrorType(method, sourceFile, project) {
     const inner = resolveIdentifierToClassType(typeInfo.node, sourceFile, project, 3);
     const type = typeInfo.isArray ? `Array<${inner}>` : inner;
     let ref = null;
-    if (Node7.isIdentifier(typeInfo.node)) {
+    if (Node10.isIdentifier(typeInfo.node)) {
       const name = typeInfo.node.getText();
       const localDecl = sourceFile.getInterface(name) || sourceFile.getClass(name) || sourceFile.getTypeAlias(name);
       if (localDecl?.isExported()) {
@@ -2408,7 +3104,7 @@ function extractErrorType(method, sourceFile, project) {
   return null;
 }
 function resolveIdentifierToClassType(node, sourceFile, project, depth) {
-  if (!Node7.isIdentifier(node)) return "unknown";
+  if (!Node10.isIdentifier(node)) return "unknown";
   const name = node.getText();
   const resolved = findType(name, sourceFile, project);
   if (resolved) {
@@ -2428,9 +3124,9 @@ var STREAM_ENVELOPES = /* @__PURE__ */ new Set(["MessageEvent", "MessageEventLik
 var BINARY_RESPONSE_TYPES = /* @__PURE__ */ new Set(["StreamableFile", "Buffer"]);
 function detectBinaryResponse(method) {
   const node = unwrapNamedContainer(method.getReturnTypeNode(), /* @__PURE__ */ new Set(["Promise"]));
-  if (!node || !Node7.isTypeReference(node)) return false;
+  if (!node || !Node10.isTypeReference(node)) return false;
   const typeName = node.getTypeName();
-  const name = Node7.isIdentifier(typeName) ? typeName.getText() : "";
+  const name = Node10.isIdentifier(typeName) ? typeName.getText() : "";
   return BINARY_RESPONSE_TYPES.has(name);
 }
 function detectStreamElement(method) {
@@ -2445,9 +3141,9 @@ function detectStreamElement(method) {
   return null;
 }
 function streamContainerElement(node) {
-  if (!node || !Node7.isTypeReference(node)) return null;
+  if (!node || !Node10.isTypeReference(node)) return null;
   const typeName = node.getTypeName();
-  const name = Node7.isIdentifier(typeName) ? typeName.getText() : "";
+  const name = Node10.isIdentifier(typeName) ? typeName.getText() : "";
   if (STREAM_CONTAINERS.has(name) || STREAM_CONTAINERS_GENERATOR.has(name)) {
     return node.getTypeArguments()[0] ?? null;
   }
@@ -2457,9 +3153,9 @@ function hasAsQueryDecorator(method) {
   return method.getDecorators().some((d) => d.getName() === "AsQuery");
 }
 function unwrapNamedContainer(node, names) {
-  if (!node || !Node7.isTypeReference(node)) return node;
+  if (!node || !Node10.isTypeReference(node)) return node;
   const typeName = node.getTypeName();
-  const name = Node7.isIdentifier(typeName) ? typeName.getText() : "";
+  const name = Node10.isIdentifier(typeName) ? typeName.getText() : "";
   if (names.has(name)) {
     return node.getTypeArguments()[0] ?? node;
   }
@@ -2480,19 +3176,20 @@ function extractDtoContract(method, sourceFile, project, mixin, controllerClass)
     body = body ?? bodyType;
   }
   const paramsType = extractParamsType(method, sourceFile, project);
+  const paramTypes = extractPipedParamTypes(method, project);
   const response = isStream ? resolveTypeNodeToString(streamElement, sourceFile, project, 3) : extractResponseType(method, sourceFile, project);
   const errorInfo = extractErrorType(method, sourceFile, project);
-  if (body === null && query === null && paramsType === null && response === "unknown" && errorInfo === null && filterInfo === null && !isStream && !uploads.multipart && !binaryResponse && !asQuery) {
+  if (body === null && query === null && paramsType === null && paramTypes === null && response === "unknown" && errorInfo === null && filterInfo === null && !isStream && !uploads.multipart && !binaryResponse && !asQuery) {
     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()) {
+    if (param.getDecorators().some((d) => d.getName() === "Body") && param.getTypeNode() && !hasPipeSchema(param, "Body", project)) {
       bodyRef = resolveBodyQueryResponseRef(param.getTypeNode(), sourceFile, project);
     }
-    if (param.getDecorators().some((d) => d.getName() === "Query") && param.getTypeNode()) {
+    if (param.getDecorators().some((d) => d.getName() === "Query") && param.getTypeNode() && !hasPipeSchema(param, "Query", project)) {
       queryRef = resolveBodyQueryResponseRef(param.getTypeNode(), sourceFile, project);
     }
   }
@@ -2505,11 +3202,11 @@ function extractDtoContract(method, sourceFile, project, mixin, controllerClass)
     if (apiResp) {
       const args = apiResp.getArguments();
       const optsArg = args[0];
-      if (optsArg && Node7.isObjectLiteralExpression(optsArg)) {
+      if (optsArg && Node10.isObjectLiteralExpression(optsArg)) {
         for (const prop of optsArg.getProperties()) {
-          if (Node7.isPropertyAssignment(prop) && prop.getName() === "type") {
+          if (Node10.isPropertyAssignment(prop) && prop.getName() === "type") {
             const val = prop.getInitializer();
-            if (val && Node7.isIdentifier(val)) {
+            if (val && Node10.isIdentifier(val)) {
               const name = val.getText();
               const localDecl = sourceFile.getInterface(name) || sourceFile.getClass(name) || sourceFile.getTypeAlias(name);
               if (localDecl?.isExported()) {
@@ -2545,6 +3242,7 @@ function extractDtoContract(method, sourceFile, project, mixin, controllerClass)
     response,
     error: errorInfo?.type ?? null,
     params: paramsType,
+    paramTypes,
     queryRef,
     bodyRef,
     responseRef,
@@ -2565,6 +3263,7 @@ function extractDtoContract(method, sourceFile, project, mixin, controllerClass)
 function resolveParamClass(method, decoratorName, sourceFile, project) {
   for (const param of method.getParameters()) {
     if (!param.getDecorators().some((d) => d.getName() === decoratorName)) continue;
+    if (hasPipeSchema(param, decoratorName, project)) continue;
     const typeNode = param.getTypeNode();
     if (!typeNode) continue;
     const text = typeNode.getText().replace(/\[\]$/, "");
@@ -2577,129 +3276,6 @@ function resolveParamClass(method, decoratorName, sourceFile, project) {
   return null;
 }
 
-// src/discovery/zod-ast-to-ts.ts
-import { Node as Node8, SyntaxKind as SyntaxKind4 } from "ts-morph";
-function zodAstToTs(node) {
-  if (!Node8.isCallExpression(node)) return "unknown";
-  const expr = node.getExpression();
-  if (Node8.isPropertyAccessExpression(expr)) {
-    const methodName = expr.getName();
-    const receiver = expr.getExpression();
-    if (methodName === "optional") {
-      return `${zodAstToTs(receiver)} | undefined`;
-    }
-    if (methodName === "nullable") {
-      return `${zodAstToTs(receiver)} | null`;
-    }
-    const args = node.getArguments();
-    switch (methodName) {
-      case "string":
-        return "string";
-      case "number":
-        return "number";
-      case "boolean":
-        return "boolean";
-      case "unknown":
-        return "unknown";
-      case "any":
-        return "unknown";
-      case "literal": {
-        const lit = args[0];
-        if (!lit) return "unknown";
-        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 || !Node8.isArrayLiteralExpression(arrArg)) return "unknown";
-        const members = arrArg.getElements().map(
-          (el) => Node8.isStringLiteral(el) ? JSON.stringify(el.getLiteralValue()) : "unknown"
-        );
-        return members.join(" | ");
-      }
-      case "array": {
-        const inner = args[0];
-        if (!inner) return "unknown";
-        return `Array<${zodAstToTs(inner)}>`;
-      }
-      case "object": {
-        const objArg = args[0];
-        if (!objArg || !Node8.isObjectLiteralExpression(objArg)) return "unknown";
-        const lines = [];
-        for (const prop of objArg.getProperties()) {
-          if (!Node8.isPropertyAssignment(prop)) continue;
-          const key = prop.getName();
-          const valNode = prop.getInitializer();
-          if (!valNode) continue;
-          const tsType = zodAstToTs(valNode);
-          const isOpt = isOptionalChain(valNode);
-          lines.push(`${key}${isOpt ? "?" : ""}: ${tsType}`);
-        }
-        return `{ ${lines.join("; ")} }`;
-      }
-      case "union": {
-        const arrArg = args[0];
-        if (!arrArg || !Node8.isArrayLiteralExpression(arrArg)) return "unknown";
-        return arrArg.getElements().map(zodAstToTs).join(" | ");
-      }
-      case "record": {
-        const valArg = args.length === 1 ? args[0] : args[1];
-        if (!valArg) return "unknown";
-        return `Record<string, ${zodAstToTs(valArg)}>`;
-      }
-      case "tuple": {
-        const arrArg = args[0];
-        if (!arrArg || !Node8.isArrayLiteralExpression(arrArg)) return "unknown";
-        return `[${arrArg.getElements().map(zodAstToTs).join(", ")}]`;
-      }
-      default:
-        return "unknown";
-    }
-  }
-  return "unknown";
-}
-function isOptionalChain(node) {
-  if (!Node8.isCallExpression(node)) return false;
-  const expr = node.getExpression();
-  return Node8.isPropertyAccessExpression(expr) && expr.getName() === "optional";
-}
-function parseDefineContractCall(callExpr) {
-  if (!Node8.isCallExpression(callExpr)) return null;
-  const callee = callExpr.getExpression();
-  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 || !Node8.isObjectLiteralExpression(optsArg)) return null;
-  let query = null;
-  let body = null;
-  let response = "unknown";
-  let error = null;
-  let bodyZodText = null;
-  let queryZodText = null;
-  for (const prop of optsArg.getProperties()) {
-    if (!Node8.isPropertyAssignment(prop)) continue;
-    const propName = prop.getName();
-    const val = prop.getInitializer();
-    if (!val) continue;
-    if (propName === "query") {
-      query = zodAstToTs(val);
-      queryZodText = val.getText();
-    } else if (propName === "body") {
-      body = zodAstToTs(val);
-      bodyZodText = val.getText();
-    } else if (propName === "response") {
-      response = zodAstToTs(val);
-    } else if (propName === "error") {
-      error = zodAstToTs(val);
-    }
-  }
-  return { query, body, response, error, bodyZodText, queryZodText };
-}
-
 // src/discovery/contracts-fast.ts
 async function discoverContractsFast(opts) {
   const { cwd, glob, tsconfig } = opts;
@@ -2712,7 +3288,9 @@ async function discoverContractsFast(opts) {
   }
   bindDiscoveryContext(project, cwd, tsconfigPath, loaded);
   clearMixinTypeProject();
-  return extractAllRoutes(project);
+  const routes = extractAllRoutes(project);
+  clearSchemaTypeProject(project);
+  return routes;
 }
 function resolveTsconfigPath(cwd, tsconfig) {
   return tsconfig ? resolve3(tsconfig) : join4(cwd, "tsconfig.json");
@@ -2724,25 +3302,25 @@ var NO_TSCONFIG_OPTIONS = {
 };
 function loadDiscoveryTsconfig(tsconfigPath) {
   if (!existsSync(tsconfigPath)) return { options: null, files: [] };
-  const read = ts.readConfigFile(tsconfigPath, (path) => ts.sys.readFile(path));
+  const read = ts3.readConfigFile(tsconfigPath, (path) => ts3.sys.readFile(path));
   if (read.error) {
     return {
       options: null,
       files: [tsconfigPath],
-      error: ts.flattenDiagnosticMessageText(read.error.messageText, " ")
+      error: ts3.flattenDiagnosticMessageText(read.error.messageText, " ")
     };
   }
   const host = {
-    useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
+    useCaseSensitiveFileNames: ts3.sys.useCaseSensitiveFileNames,
     // The one line that keeps a tsconfig from being a filesystem walk.
     readDirectory: () => [],
-    fileExists: (path) => ts.sys.fileExists(path),
+    fileExists: (path) => ts3.sys.fileExists(path),
     // `extends` is resolved through the host, so a consumer whose `paths` live
     // in a base tsconfig keeps working.
-    readFile: (path) => ts.sys.readFile(path)
+    readFile: (path) => ts3.sys.readFile(path)
   };
-  const sourceFile = ts.readJsonConfigFile(tsconfigPath, (path) => ts.sys.readFile(path));
-  const parsed = ts.parseJsonSourceFileConfigFileContent(
+  const sourceFile = ts3.readJsonConfigFile(tsconfigPath, (path) => ts3.sys.readFile(path));
+  const parsed = ts3.parseJsonSourceFileConfigFileContent(
     sourceFile,
     host,
     dirname2(tsconfigPath),
@@ -2765,7 +3343,7 @@ function createDiscoveryProject(tsconfigPath, tsconfig = loadDiscoveryTsconfig(t
       `[nestjs-codegen/fast] Could not load ${tsconfigPath}: ${tsconfig.error} \u2014 continuing WITHOUT its compiler options, so path alias imports (e.g. '@/...') will not resolve and controllers extending an alias-imported factory will contribute NO routes to the generated client.`
     );
   }
-  return new Project3({
+  return new Project4({
     compilerOptions: tsconfig.options ?? { ...NO_TSCONFIG_OPTIONS },
     skipAddingFilesFromTsConfig: true,
     skipLoadingLibFiles: true,
@@ -2877,15 +3455,16 @@ var PersistentDiscovery = class _PersistentDiscovery {
     clearTypeResolutionCaches(this.project);
     clearEnumCache(this.project);
     clearMixinTypeProject();
+    clearSchemaTypeProject(this.project);
     return extractRoutesFrom(this.project, this.controllerPaths);
   }
 };
 function decoratorStringArg(decoratorExpr) {
   if (!decoratorExpr) return void 0;
-  if (Node9.isStringLiteral(decoratorExpr)) return decoratorExpr.getLiteralValue();
-  if (Node9.isArrayLiteralExpression(decoratorExpr)) {
+  if (Node11.isStringLiteral(decoratorExpr)) return decoratorExpr.getLiteralValue();
+  if (Node11.isArrayLiteralExpression(decoratorExpr)) {
     const first = decoratorExpr.getElements()[0];
-    if (first && Node9.isStringLiteral(first)) return first.getLiteralValue();
+    if (first && Node11.isStringLiteral(first)) return first.getLiteralValue();
   }
   return void 0;
 }
@@ -3006,9 +3585,9 @@ function extractContractRoute(args) {
   let contractDef = null;
   let bodyZodRef = null;
   let queryZodRef = null;
-  if (Node9.isCallExpression(firstDecoratorArg)) {
-    contractDef = parseDefineContractCall(firstDecoratorArg);
-  } else if (Node9.isIdentifier(firstDecoratorArg)) {
+  if (Node11.isCallExpression(firstDecoratorArg)) {
+    contractDef = parseDefineContractCall(firstDecoratorArg, project);
+  } else if (Node11.isIdentifier(firstDecoratorArg)) {
     const identName = firstDecoratorArg.getText();
     const resolvedVar = resolveImportedVariable(identName, sourceFile, project);
     if (!resolvedVar) {
@@ -3020,7 +3599,7 @@ function extractContractRoute(args) {
     const { decl: varDecl, file: declFile } = resolvedVar;
     const initializer = varDecl.getInitializer();
     if (!initializer) return null;
-    contractDef = parseDefineContractCall(initializer);
+    contractDef = parseDefineContractCall(initializer, project);
     if (contractDef && varDecl.isExported()) {
       const filePath = declFile.getFilePath();
       if (contractDef.body !== null) {
@@ -3091,6 +3670,7 @@ function extractDtoRoute(args) {
       body: dtoContract?.body ?? null,
       response: mixinResponse ?? dtoContract?.response ?? "unknown",
       error: dtoContract?.error ?? null,
+      paramTypes: dtoContract?.paramTypes ?? null,
       queryRef: dtoContract?.queryRef ?? null,
       bodyRef: dtoContract?.bodyRef ?? null,
       responseRef: dtoContract?.responseRef ?? null,
@@ -3213,7 +3793,7 @@ function createExtensionContext(config, getRoutes, trackedInputs) {
     },
     project() {
       if (!project) {
-        project = new Project4({
+        project = new Project5({
           skipAddingFilesFromTsConfig: true,
           skipLoadingLibFiles: true,
           skipFileDependencyResolution: true,
@@ -3331,10 +3911,11 @@ function insertIntoTree(tree, segments, leaf, fullName) {
     insertIntoTree(branch.children, rest, leaf, fullName);
   }
 }
-function buildParamsType(params) {
+function buildParamsType(params, paramTypes) {
   const pathParams = params.filter((p) => p.source === "path");
   if (pathParams.length === 0) return "never";
-  return `{ ${pathParams.map((p) => `${p.name}: string`).join("; ")} }`;
+  const typeOf = (name) => paramTypes && Object.hasOwn(paramTypes, name) && paramTypes[name] || "string";
+  return `{ ${pathParams.map((p) => `${p.name}: ${typeOf(p.name)}`).join("; ")} }`;
 }
 function hasPathParams(params) {
   return params.some((p) => p.source === "path");
@@ -3428,7 +4009,7 @@ function emitRouterTypeBlock(tree, indent, outDir, serialization) {
       }
       const response = buildResponseType(c, outDir, serialization);
       const error = buildErrorType(c);
-      const params = buildParamsType(c.params);
+      const params = buildParamsType(c.params, c.contractSource.paramTypes);
       const safeMethod = JSON.stringify(method);
       const safeUrl = JSON.stringify(c.path);
       const filterLiterals = filterFieldLiterals(c.contractSource.filterFields);
@@ -3697,6 +4278,9 @@ var EMPTY_PATH_NAMESPACE = [
   "}",
   ""
 ];
+function isClientCallable(route) {
+  return route.method.toUpperCase() !== "ALL";
+}
 function buildApiFile(routes, outDir, opts = {}) {
   const fetcherImportPath = opts.fetcherImportPath;
   const serialization = opts.serialization ?? "json";
@@ -3704,7 +4288,7 @@ function buildApiFile(routes, outDir, opts = {}) {
   const { layer } = resolveApiSlots(extensions);
   const memberExts = extensions.filter((e) => e.apiMembers);
   const headerExts = extensions.filter((e) => e.apiHeader);
-  const contracted = routes.filter((r) => r.contract);
+  const contracted = routes.filter((r) => r.contract && isClientCallable(r));
   const ctx = opts.ctx ?? {
     cwd: outDir ?? "",
     outDir: outDir ?? "",
@@ -4622,6 +5206,7 @@ function buildOpenApiSpec(routes, opts = {}) {
   const paths = {};
   for (const route of routes) {
     if (!route.contract) continue;
+    if (route.method.toUpperCase() === "ALL") continue;
     const oaPath = toOpenApiPath(route.path);
     const method = route.method.toLowerCase();
     let pathItem = paths[oaPath];
@@ -5281,7 +5866,7 @@ async function watch(config, onChange, options = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.25.1";
+var VERSION = "0.26.0";
 
 // src/cli/codegen.ts
 async function runCodegen(opts = {}) {