@semacode/cli 1.5.14 → 1.5.16

package/src/typescript-http.ts

@@ -0,0 +1,1076 @@
+import ts from "typescript";
+
+export interface ParametroRotaTypeScript {
+  nome: string;
+  tipoSema: "Texto" | "Inteiro" | "Decimal" | "Id";
+}
+
+export interface RotaTypeScriptExtraida {
+  origem: "nextjs" | "firebase";
+  metodo: string;
+  caminho: string;
+  simbolo: string;
+  parametros: ParametroRotaTypeScript[];
+}
+
+export interface CampoInferidoTypeScriptHttp {
+  nome: string;
+  tipoTexto?: string;
+  obrigatorio: boolean;
+}
+
+export interface ExportacaoTypeScriptHttp {
+  corpo?: ts.Block;
+  retorno?: string;
+  parametros: readonly ts.ParameterDeclaration[];
+  declaracao: ts.FunctionLikeDeclarationBase;
+}
+
+export interface SemanticaHandlerTypeScriptHttp {
+  query: CampoInferidoTypeScriptHttp[];
+  body: CampoInferidoTypeScriptHttp[];
+  bodyTipoTexto?: string;
+  response: CampoInferidoTypeScriptHttp[];
+  responseTipoTexto?: string;
+  statuses: number[];
+  errorStatuses: number[];
+}
+
+interface ValorLocalTypeScriptHttp {
+  tipoTexto?: string;
+  campos: CampoInferidoTypeScriptHttp[];
+  status?: number;
+}
+
+const METODOS_HTTP = new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+
+function normalizarSeparadores(relacao: string): string {
+  return relacao.replace(/\\/g, "/");
+}
+
+function deduplicarRotas(rotas: RotaTypeScriptExtraida[]): RotaTypeScriptExtraida[] {
+  const mapa = new Map<string, RotaTypeScriptExtraida>();
+  for (const rota of rotas) {
+    const chave = `${rota.origem}:${rota.metodo}:${rota.caminho}:${rota.simbolo}`;
+    if (!mapa.has(chave)) {
+      mapa.set(chave, rota);
+    }
+  }
+  return [...mapa.values()];
+}
+
+function deduplicarCampos(campos: CampoInferidoTypeScriptHttp[]): CampoInferidoTypeScriptHttp[] {
+  const mapa = new Map<string, CampoInferidoTypeScriptHttp>();
+  for (const campo of campos) {
+    const chave = campo.nome;
+    const existente = mapa.get(chave);
+    if (!existente) {
+      mapa.set(chave, campo);
+      continue;
+    }
+    mapa.set(chave, {
+      nome: campo.nome,
+      tipoTexto: existente.tipoTexto ?? campo.tipoTexto,
+      obrigatorio: existente.obrigatorio || campo.obrigatorio,
+    });
+  }
+  return [...mapa.values()];
+}
+
+function deduplicarNumeros(valores: number[]): number[] {
+  return [...new Set(valores)].sort((a, b) => a - b);
+}
+
+function desembrulharExpressao(expr: ts.Expression): ts.Expression {
+  let atual = expr;
+
+  while (true) {
+    if (ts.isParenthesizedExpression(atual) || ts.isAsExpression(atual) || ts.isSatisfiesExpression(atual) || ts.isTypeAssertionExpression(atual)) {
+      atual = atual.expression;
+      continue;
+    }
+    if (ts.isAwaitExpression(atual)) {
+      atual = atual.expression;
+      continue;
+    }
+    return atual;
+  }
+}
+
+function extrairNomeExportado(statement: ts.Statement, sourceFile: ts.SourceFile): string[] {
+  if (ts.isFunctionDeclaration(statement) && statement.name && statement.modifiers?.some((item) => item.kind === ts.SyntaxKind.ExportKeyword)) {
+    return [statement.name.text];
+  }
+
+  if (!ts.isVariableStatement(statement) || !statement.modifiers?.some((item) => item.kind === ts.SyntaxKind.ExportKeyword)) {
+    return [];
+  }
+
+  const nomes: string[] = [];
+  for (const declaracao of statement.declarationList.declarations) {
+    if (!ts.isIdentifier(declaracao.name) || !declaracao.initializer) {
+      continue;
+    }
+    if (ts.isArrowFunction(declaracao.initializer) || ts.isFunctionExpression(declaracao.initializer) || ts.isCallExpression(declaracao.initializer) || ts.isIdentifier(declaracao.initializer)) {
+      nomes.push(declaracao.name.getText(sourceFile));
+    }
+  }
+  return nomes;
+}
+
+function extrairMetodosHttpNext(sourceFile: ts.SourceFile): string[] {
+  const encontrados = new Set<string>();
+  for (const statement of sourceFile.statements) {
+    for (const nome of extrairNomeExportado(statement, sourceFile)) {
+      const metodo = nome.toUpperCase();
+      if (METODOS_HTTP.has(metodo)) {
+        encontrados.add(metodo);
+      }
+    }
+  }
+  return [...encontrados];
+}
+
+function inferirCaminhoNext(relacaoArquivo: string): { caminho: string; parametros: ParametroRotaTypeScript[] } | undefined {
+  const relacao = normalizarSeparadores(relacaoArquivo);
+  const segmentos = relacao.split("/");
+  const indiceSrcAppApi = segmentos.findIndex((segmento, indice) =>
+    segmento === "src" && segmentos[indice + 1] === "app" && segmentos[indice + 2] === "api");
+  const indiceAppApi = segmentos.findIndex((segmento, indice) => segmento === "app" && segmentos[indice + 1] === "api");
+
+  const inicioApi = indiceSrcAppApi >= 0
+    ? indiceSrcAppApi + 3
+    : indiceAppApi >= 0
+      ? indiceAppApi + 2
+      : -1;
+  if (inicioApi < 0) {
+    return undefined;
+  }
+
+  const caminhoAteRoute = segmentos.slice(inicioApi, -1);
+  if (segmentos.at(-1) !== "route.ts" && segmentos.at(-1) !== "route.js") {
+    return undefined;
+  }
+
+  const parametros: ParametroRotaTypeScript[] = [];
+  const partes = caminhoAteRoute
+    .filter((segmento) => segmento && !/^\(.*\)$/.test(segmento) && !segmento.startsWith("@"))
+    .map((segmento) => {
+      const opcionalCatchAll = segmento.match(/^\[\[\.\.\.([A-Za-z_]\w*)\]\]$/);
+      if (opcionalCatchAll) {
+        parametros.push({ nome: opcionalCatchAll[1]!, tipoSema: "Texto" });
+        return `{${opcionalCatchAll[1]}}`;
+      }
+
+      const catchAll = segmento.match(/^\[\.\.\.([A-Za-z_]\w*)\]$/);
+      if (catchAll) {
+        parametros.push({ nome: catchAll[1]!, tipoSema: "Texto" });
+        return `{${catchAll[1]}}`;
+      }
+
+      const dinamico = segmento.match(/^\[([A-Za-z_]\w*)\]$/);
+      if (dinamico) {
+        const nome = dinamico[1]!;
+        parametros.push({
+          nome,
+          tipoSema: /(^|_)id$/i.test(nome) ? "Id" : "Texto",
+        });
+        return `{${nome}}`;
+      }
+
+      return segmento;
+    });
+
+  return {
+    caminho: (`/api/${partes.join("/")}`).replace(/\/+/g, "/"),
+    parametros,
+  };
+}
+
+function identificarRotasNodeHttp(
+  sourceFile: ts.SourceFile,
+  nomeSimbolo: string,
+  corpo: ts.Block,
+): RotaTypeScriptExtraida[] {
+  const rotas: Array<{ metodo: string; caminho: string }> = [];
+
+  const visitar = (node: ts.Node): void => {
+    if (ts.isIfStatement(node)) {
+      const expressao = node.expression.getText(sourceFile);
+      const caminho = expressao.match(/(?:req|request)\.url\s*===\s*["'`]([^"'`]+)["'`]/)?.[1];
+      const metodo = expressao.match(/(?:req|request)\.method\s*===\s*["'`]([A-Z]+)["'`]/)?.[1]?.toUpperCase();
+      if (caminho && metodo && METODOS_HTTP.has(metodo)) {
+        rotas.push({ caminho, metodo });
+      }
+    }
+    node.forEachChild(visitar);
+  };
+
+  visitar(corpo);
+  return deduplicarRotas(rotas.map((rota) => ({
+    origem: "firebase",
+    metodo: rota.metodo,
+    caminho: rota.caminho,
+    simbolo: nomeSimbolo,
+    parametros: [],
+  })));
+}
+
+function extrairRotasNodeWorker(sourceFile: ts.SourceFile, relacaoArquivo: string): RotaTypeScriptExtraida[] {
+  const relacao = normalizarSeparadores(relacaoArquivo);
+  const pareceWorkerHttp = /(?:^|\/)(?:apps\/worker\/|src\/services\/health-check|health-check\.ts$|sema_contract_bridge\.ts$)/.test(relacao);
+  if (!pareceWorkerHttp) {
+    return [];
+  }
+
+  const rotas: RotaTypeScriptExtraida[] = [];
+
+  for (const statement of sourceFile.statements) {
+    if (ts.isFunctionDeclaration(statement) && statement.name && statement.body && statement.modifiers?.some((item) => item.kind === ts.SyntaxKind.ExportKeyword)) {
+      rotas.push(...identificarRotasNodeHttp(sourceFile, statement.name.text, statement.body));
+      continue;
+    }
+
+    if (ts.isVariableStatement(statement) && statement.modifiers?.some((item) => item.kind === ts.SyntaxKind.ExportKeyword)) {
+      for (const declaracao of statement.declarationList.declarations) {
+        if (!ts.isIdentifier(declaracao.name) || !declaracao.initializer) {
+          continue;
+        }
+        if (ts.isArrowFunction(declaracao.initializer) || ts.isFunctionExpression(declaracao.initializer)) {
+          const corpo = declaracao.initializer.body;
+          if (ts.isBlock(corpo)) {
+            rotas.push(...identificarRotasNodeHttp(sourceFile, declaracao.name.text, corpo));
+          }
+        }
+      }
+      continue;
+    }
+
+    if (!ts.isClassDeclaration(statement) || !statement.name) {
+      continue;
+    }
+
+    for (const member of statement.members) {
+      if (!ts.isMethodDeclaration(member) || !member.body || !member.name) {
+        continue;
+      }
+      rotas.push(...identificarRotasNodeHttp(sourceFile, `${statement.name.text}.${member.name.getText(sourceFile)}`, member.body));
+    }
+  }
+
+  return deduplicarRotas(rotas);
+}
+
+function tipoInferidoPorNomeCampo(nome: string): string | undefined {
+  return /(^|_)?id$/i.test(nome) || /Id$/.test(nome)
+    ? "Id"
+    : undefined;
+}
+
+function normalizarTypeNode(typeNode: ts.TypeNode | undefined): ts.TypeNode | undefined {
+  if (!typeNode) {
+    return undefined;
+  }
+  if (ts.isParenthesizedTypeNode(typeNode)) {
+    return normalizarTypeNode(typeNode.type);
+  }
+  if (ts.isUnionTypeNode(typeNode)) {
+    const uteis = typeNode.types
+      .filter((item) => item.kind !== ts.SyntaxKind.NullKeyword && item.kind !== ts.SyntaxKind.UndefinedKeyword)
+      .map((item) => normalizarTypeNode(item))
+      .filter((item): item is ts.TypeNode => Boolean(item));
+    if (uteis.length === 1) {
+      return uteis[0];
+    }
+  }
+  return typeNode;
+}
+
+function extrairCamposTypeNode(typeNode: ts.TypeNode | undefined, sourceFile: ts.SourceFile): CampoInferidoTypeScriptHttp[] {
+  const normalizado = normalizarTypeNode(typeNode);
+  if (!normalizado || !ts.isTypeLiteralNode(normalizado)) {
+    return [];
+  }
+
+  const campos: CampoInferidoTypeScriptHttp[] = [];
+  for (const membro of normalizado.members) {
+    if (!ts.isPropertySignature(membro) || !membro.name) {
+      continue;
+    }
+
+    let nome: string | undefined;
+    if (ts.isIdentifier(membro.name) || ts.isStringLiteralLike(membro.name) || ts.isNumericLiteral(membro.name)) {
+      nome = membro.name.text;
+    }
+
+    if (!nome) {
+      continue;
+    }
+
+    campos.push({
+      nome,
+      tipoTexto: membro.type?.getText(sourceFile) ?? tipoInferidoPorNomeCampo(nome),
+      obrigatorio: !membro.questionToken,
+    });
+  }
+
+  return deduplicarCampos(campos);
+}
+
+function extrairMetadadosTipoExplicito(
+  expr: ts.Expression,
+  sourceFile: ts.SourceFile,
+  typeNodeDeclarado?: ts.TypeNode,
+): { tipoTexto?: string; campos: CampoInferidoTypeScriptHttp[] } {
+  const typeNode =
+    normalizarTypeNode(typeNodeDeclarado)
+    ?? (() => {
+      let atual: ts.Expression = expr;
+      while (true) {
+        if (ts.isParenthesizedExpression(atual)) {
+          atual = atual.expression;
+          continue;
+        }
+        if (ts.isAsExpression(atual) || ts.isSatisfiesExpression(atual) || ts.isTypeAssertionExpression(atual)) {
+          return normalizarTypeNode(atual.type);
+        }
+        if (ts.isAwaitExpression(atual)) {
+          atual = atual.expression;
+          continue;
+        }
+        return undefined;
+      }
+    })();
+
+  return {
+    tipoTexto: typeNode?.getText(sourceFile),
+    campos: extrairCamposTypeNode(typeNode, sourceFile),
+  };
+}
+
+function inferirTipoBasicoDeExpressao(expr: ts.Expression | undefined, nomeCampo?: string): string | undefined {
+  if (!expr) {
+    return nomeCampo ? tipoInferidoPorNomeCampo(nomeCampo) : undefined;
+  }
+  if (ts.isParenthesizedExpression(expr) || ts.isAsExpression(expr) || ts.isSatisfiesExpression(expr) || ts.isTypeAssertionExpression(expr)) {
+    return inferirTipoBasicoDeExpressao(expr.expression, nomeCampo);
+  }
+  if (ts.isAwaitExpression(expr)) {
+    return inferirTipoBasicoDeExpressao(expr.expression, nomeCampo);
+  }
+  if (ts.isStringLiteralLike(expr) || ts.isNoSubstitutionTemplateLiteral(expr) || ts.isTemplateExpression(expr)) {
+    return "string";
+  }
+  if (ts.isNumericLiteral(expr)) {
+    return "number";
+  }
+  if (expr.kind === ts.SyntaxKind.TrueKeyword || expr.kind === ts.SyntaxKind.FalseKeyword) {
+    return "boolean";
+  }
+  if (ts.isArrayLiteralExpression(expr) || ts.isObjectLiteralExpression(expr)) {
+    return "Json";
+  }
+  if (expr.kind === ts.SyntaxKind.NullKeyword) {
+    return "Json";
+  }
+  if (ts.isCallExpression(expr)) {
+    const nome = expr.expression.getText().replace(/\s+/g, "");
+    if (/^(Number|parseFloat)$/.test(nome)) {
+      return "number";
+    }
+    if (/^parseInt$/.test(nome)) {
+      return "int";
+    }
+    if (/^(Boolean)$/.test(nome)) {
+      return "boolean";
+    }
+    if (/^(String)$/.test(nome)) {
+      return "string";
+    }
+  }
+  return nomeCampo ? tipoInferidoPorNomeCampo(nomeCampo) : undefined;
+}
+
+function extrairCamposObjetoLiteral(objeto: ts.ObjectLiteralExpression, sourceFile: ts.SourceFile): CampoInferidoTypeScriptHttp[] {
+  const campos: CampoInferidoTypeScriptHttp[] = [];
+  for (const propriedade of objeto.properties) {
+    if (!ts.isPropertyAssignment(propriedade) && !ts.isShorthandPropertyAssignment(propriedade)) {
+      continue;
+    }
+    const nome = propriedade.name.getText(sourceFile).replace(/^["']|["']$/g, "");
+    campos.push({
+      nome,
+      tipoTexto: inferirTipoBasicoDeExpressao(
+        ts.isPropertyAssignment(propriedade) ? propriedade.initializer : propriedade.name,
+        nome,
+      ),
+      obrigatorio: true,
+    });
+  }
+  return deduplicarCampos(campos);
+}
+
+function extrairStatusHttp(expr?: ts.Expression): number | undefined {
+  if (!expr || !ts.isObjectLiteralExpression(expr)) {
+    return undefined;
+  }
+  for (const propriedade of expr.properties) {
+    if (!ts.isPropertyAssignment(propriedade) || propriedade.name.getText().replace(/^["']|["']$/g, "") !== "status") {
+      continue;
+    }
+    if (ts.isNumericLiteral(propriedade.initializer)) {
+      return Number(propriedade.initializer.text);
+    }
+  }
+  return undefined;
+}
+
+function ehRequestUrl(expr: ts.Expression, requestNames: Set<string>): boolean {
+  return ts.isPropertyAccessExpression(expr)
+    && expr.name.text === "url"
+    && ts.isIdentifier(expr.expression)
+    && requestNames.has(expr.expression.text);
+}
+
+function ehNewUrl(expr: ts.Expression, requestNames: Set<string>): boolean {
+  return ts.isNewExpression(expr)
+    && ts.isIdentifier(expr.expression)
+    && expr.expression.text === "URL"
+    && Boolean(expr.arguments?.some((argumento) => ehRequestUrl(argumento, requestNames)));
+}
+
+function ehSearchParamsSource(expr: ts.Expression, requestNames: Set<string>, urlAliases: Set<string>, searchParamsAliases: Set<string>): boolean {
+  const normalizado = desembrulharExpressao(expr);
+
+  if (ts.isIdentifier(normalizado)) {
+    return searchParamsAliases.has(normalizado.text);
+  }
+
+  if (ts.isPropertyAccessExpression(normalizado) && normalizado.name.text === "searchParams") {
+    const alvo = normalizado.expression;
+    if (ts.isPropertyAccessExpression(alvo) && alvo.name.text === "nextUrl" && ts.isIdentifier(alvo.expression) && requestNames.has(alvo.expression.text)) {
+      return true;
+    }
+    if (ts.isIdentifier(alvo) && urlAliases.has(alvo.text)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function ehCallRequest(expr: ts.Expression, requestNames: Set<string>, metodo: "json" | "formData"): boolean {
+  const alvo = desembrulharExpressao(expr);
+  return ts.isCallExpression(alvo)
+    && ts.isPropertyAccessExpression(alvo.expression)
+    && alvo.expression.name.text === metodo
+    && ts.isIdentifier(alvo.expression.expression)
+    && requestNames.has(alvo.expression.expression.text);
+}
+
+function obterNomeSchema(call: ts.CallExpression): string | undefined {
+  if (!ts.isPropertyAccessExpression(call.expression)) {
+    return undefined;
+  }
+  const alvo = call.expression.expression;
+  if (!ts.isIdentifier(alvo)) {
+    return undefined;
+  }
+  return alvo.text;
+}
+
+function resolverMetadadosOrigemBody(
+  expr: ts.Expression,
+  sourceFile: ts.SourceFile,
+  requestNames: Set<string>,
+  bodyAliases: Map<string, { tipoTexto?: string; campos: CampoInferidoTypeScriptHttp[] }>,
+  jsonAliases: Set<string>,
+  safeParseAliases: Map<string, CampoInferidoTypeScriptHttp[]>,
+  schemasZod: Map<string, CampoInferidoTypeScriptHttp[]>,
+  typeNodeDeclarado?: ts.TypeNode,
+): { tipoTexto?: string; campos: CampoInferidoTypeScriptHttp[] } | undefined {
+  const normalizado = desembrulharExpressao(expr);
+
+  if (ts.isIdentifier(normalizado) && bodyAliases.has(normalizado.text)) {
+    return bodyAliases.get(normalizado.text);
+  }
+
+  if (ehCallRequest(expr, requestNames, "json")) {
+    return extrairMetadadosTipoExplicito(expr, sourceFile, typeNodeDeclarado);
+  }
+
+  if (
+    ts.isCallExpression(normalizado)
+    && ts.isPropertyAccessExpression(normalizado.expression)
+    && ["parse", "safeParse"].includes(normalizado.expression.name.text)
+  ) {
+    const schemaNome = obterNomeSchema(normalizado);
+    const schemaCampos = schemaNome ? schemasZod.get(schemaNome) : undefined;
+    const argumento = normalizado.arguments[0];
+    const argumentoNormalizado = argumento ? desembrulharExpressao(argumento) : undefined;
+    if (
+      schemaCampos
+      && argumento
+      && (
+        ehCallRequest(argumento, requestNames, "json")
+        || (argumentoNormalizado && ts.isIdentifier(argumentoNormalizado) && jsonAliases.has(argumentoNormalizado.text))
+      )
+    ) {
+      return {
+        tipoTexto: undefined,
+        campos: schemaCampos,
+      };
+    }
+  }
+
+  if (
+    ts.isPropertyAccessExpression(normalizado)
+    && normalizado.name.text === "data"
+    && ts.isIdentifier(normalizado.expression)
+    && safeParseAliases.has(normalizado.expression.text)
+  ) {
+    return {
+      tipoTexto: undefined,
+      campos: safeParseAliases.get(normalizado.expression.text) ?? [],
+    };
+  }
+
+  return undefined;
+}
+
+function extrairCamposBindingPattern(
+  pattern: ts.ObjectBindingPattern,
+  sourceFile: ts.SourceFile,
+  camposConhecidos: CampoInferidoTypeScriptHttp[],
+): CampoInferidoTypeScriptHttp[] {
+  const conhecidos = new Map(camposConhecidos.map((campo) => [campo.nome, campo]));
+  const campos: CampoInferidoTypeScriptHttp[] = [];
+
+  for (const elemento of pattern.elements) {
+    if (!ts.isIdentifier(elemento.name)) {
+      continue;
+    }
+
+    const nomeCampo = elemento.propertyName?.getText(sourceFile) ?? elemento.name.text;
+    const conhecido = conhecidos.get(nomeCampo);
+    campos.push({
+      nome: nomeCampo,
+      tipoTexto: conhecido?.tipoTexto ?? inferirTipoBasicoDeExpressao(elemento.initializer, nomeCampo) ?? tipoInferidoPorNomeCampo(nomeCampo),
+      obrigatorio: conhecido?.obrigatorio ?? false,
+    });
+  }
+
+  return deduplicarCampos(campos);
+}
+
+function extrairCampoZod(expr: ts.Expression, nome: string): CampoInferidoTypeScriptHttp {
+  const texto = expr.getText().replace(/\s+/g, "");
+  let tipoTexto = tipoInferidoPorNomeCampo(nome);
+  if (/\.uuid\(/i.test(texto)) {
+    tipoTexto = "Id";
+  } else if (/\.string\(/i.test(texto)) {
+    tipoTexto = "string";
+  } else if (/\.number\(/i.test(texto) || /\.int\(/i.test(texto)) {
+    tipoTexto = /\.int\(/i.test(texto) ? "int" : "number";
+  } else if (/\.boolean\(/i.test(texto)) {
+    tipoTexto = "boolean";
+  } else if (/\.date\(/i.test(texto)) {
+    tipoTexto = "date";
+  } else if (/\.array\(/i.test(texto) || /\.object\(/i.test(texto) || /\.record\(/i.test(texto)) {
+    tipoTexto = "Json";
+  }
+
+  return {
+    nome,
+    tipoTexto,
+    obrigatorio: !/\.optional\(/i.test(texto),
+  };
+}
+
+function extrairSchemasZodLocais(sourceFile: ts.SourceFile): Map<string, CampoInferidoTypeScriptHttp[]> {
+  const schemas = new Map<string, CampoInferidoTypeScriptHttp[]>();
+
+  sourceFile.forEachChild((node) => {
+    if (!ts.isVariableStatement(node)) {
+      return;
+    }
+
+    for (const declaracao of node.declarationList.declarations) {
+      if (!ts.isIdentifier(declaracao.name) || !declaracao.initializer) {
+        continue;
+      }
+
+      let chamada: ts.CallExpression | undefined;
+      if (ts.isCallExpression(declaracao.initializer)) {
+        chamada = declaracao.initializer;
+      } else if (
+        ts.isCallExpression(declaracao.initializer)
+        && ts.isPropertyAccessExpression(declaracao.initializer.expression)
+      ) {
+        chamada = declaracao.initializer;
+      } else if (
+        ts.isCallExpression(declaracao.initializer)
+        && ts.isPropertyAccessExpression(declaracao.initializer.expression)
+      ) {
+        chamada = declaracao.initializer;
+      }
+
+      const chamadaInicial = chamada ?? (ts.isCallExpression(declaracao.initializer) ? declaracao.initializer : undefined);
+      if (!chamadaInicial) {
+        continue;
+      }
+
+      let chamadaObjeto: ts.CallExpression | undefined;
+      if (
+        ts.isPropertyAccessExpression(chamadaInicial.expression)
+        && chamadaInicial.expression.name.text === "object"
+      ) {
+        chamadaObjeto = chamadaInicial;
+      } else if (
+        ts.isPropertyAccessExpression(chamadaInicial.expression)
+        && ts.isCallExpression(chamadaInicial.expression.expression)
+        && ts.isPropertyAccessExpression(chamadaInicial.expression.expression.expression)
+        && chamadaInicial.expression.expression.expression.name.text === "object"
+      ) {
+        chamadaObjeto = chamadaInicial.expression.expression;
+      }
+
+      if (!chamadaObjeto) {
+        continue;
+      }
+
+      const objeto = chamadaObjeto.arguments[0];
+      if (!objeto || !ts.isObjectLiteralExpression(objeto)) {
+        continue;
+      }
+
+      const campos: CampoInferidoTypeScriptHttp[] = [];
+      for (const propriedade of objeto.properties) {
+        if (!ts.isPropertyAssignment(propriedade)) {
+          continue;
+        }
+        const nomeCampo = propriedade.name.getText(sourceFile).replace(/^["']|["']$/g, "");
+        campos.push(extrairCampoZod(propriedade.initializer, nomeCampo));
+      }
+      if (campos.length > 0) {
+        schemas.set(declaracao.name.text, deduplicarCampos(campos));
+      }
+    }
+  });
+
+  return schemas;
+}
+
+function localizarExportacaoEmStatement(
+  statement: ts.Statement,
+  nomeExportado: string,
+  sourceFile: ts.SourceFile,
+): ExportacaoTypeScriptHttp | undefined {
+  if (ts.isFunctionDeclaration(statement) && statement.name?.text === nomeExportado && statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
+    return {
+      corpo: statement.body,
+      retorno: statement.type?.getText(sourceFile),
+      parametros: statement.parameters,
+      declaracao: statement,
+    };
+  }
+
+  if (!ts.isVariableStatement(statement) || !statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
+    return undefined;
+  }
+
+  for (const declaracao of statement.declarationList.declarations) {
+    if (!ts.isIdentifier(declaracao.name) || declaracao.name.text !== nomeExportado || !declaracao.initializer) {
+      continue;
+    }
+    if (ts.isArrowFunction(declaracao.initializer) || ts.isFunctionExpression(declaracao.initializer)) {
+      return {
+        corpo: ts.isBlock(declaracao.initializer.body) ? declaracao.initializer.body : undefined,
+        retorno: declaracao.initializer.type?.getText(sourceFile),
+        parametros: declaracao.initializer.parameters,
+        declaracao: declaracao.initializer,
+      };
+    }
+  }
+
+  return undefined;
+}
+
+function inferirTipoPorContexto(node: ts.Node, nomeCampo: string): string | undefined {
+  let atual: ts.Node | undefined = node;
+  let profundidade = 0;
+
+  while (atual && profundidade < 4) {
+    atual = atual.parent;
+    profundidade += 1;
+    if (!atual) {
+      break;
+    }
+    if (ts.isCallExpression(atual)) {
+      const nome = atual.expression.getText().replace(/\s+/g, "");
+      if (/^(Number|parseFloat)$/.test(nome)) {
+        return "number";
+      }
+      if (/^parseInt$/.test(nome)) {
+        return "int";
+      }
+      if (/^(Boolean)$/.test(nome)) {
+        return "boolean";
+      }
+      if (/^(String)$/.test(nome)) {
+        return "string";
+      }
+    }
+  }
+
+  return tipoInferidoPorNomeCampo(nomeCampo);
+}
+
+function extrairRetornoHttp(
+  expr: ts.Expression,
+  sourceFile: ts.SourceFile,
+  valoresLocais: Map<string, ValorLocalTypeScriptHttp>,
+): { campos: CampoInferidoTypeScriptHttp[]; tipoTexto?: string; status?: number } | undefined {
+  const normalizado = desembrulharExpressao(expr);
+
+  if (ts.isCallExpression(normalizado) && ts.isPropertyAccessExpression(normalizado.expression)) {
+    const alvo = normalizado.expression.expression.getText(sourceFile);
+    const metodo = normalizado.expression.name.text;
+    if ((alvo === "NextResponse" || alvo === "Response") && metodo === "json") {
+      const primeiro = normalizado.arguments[0];
+      const segundo = normalizado.arguments[1];
+      let campos: CampoInferidoTypeScriptHttp[] = [];
+      let tipoTexto = normalizado.typeArguments?.[0]?.getText(sourceFile);
+
+      if (primeiro && ts.isObjectLiteralExpression(primeiro)) {
+        campos = extrairCamposObjetoLiteral(primeiro, sourceFile);
+      } else if (primeiro && ts.isIdentifier(primeiro)) {
+        const valorLocal = valoresLocais.get(primeiro.text);
+        if (valorLocal) {
+          campos = valorLocal.campos;
+          tipoTexto ??= valorLocal.tipoTexto;
+        }
+      }
+
+      return {
+        campos,
+        tipoTexto,
+        status: extrairStatusHttp(segundo),
+      };
+    }
+  }
+
+  if (ts.isNewExpression(normalizado) && ts.isIdentifier(normalizado.expression) && normalizado.expression.text === "Response") {
+    const tipoTexto = normalizado.typeArguments?.[0]?.getText(sourceFile);
+    return {
+      campos: [],
+      tipoTexto,
+      status: extrairStatusHttp(normalizado.arguments?.[1]),
+    };
+  }
+
+  if (ts.isObjectLiteralExpression(normalizado)) {
+    return {
+      campos: extrairCamposObjetoLiteral(normalizado, sourceFile),
+    };
+  }
+
+  if (ts.isIdentifier(normalizado)) {
+    const valorLocal = valoresLocais.get(normalizado.text);
+    if (valorLocal) {
+      return {
+        campos: valorLocal.campos,
+        tipoTexto: valorLocal.tipoTexto,
+        status: valorLocal.status,
+      };
+    }
+  }
+
+  return undefined;
+}
+
+export function localizarExportacaoTypeScriptHttp(
+  sourceFile: ts.SourceFile,
+  nomeExportado: string,
+): ExportacaoTypeScriptHttp | undefined {
+  for (const node of sourceFile.statements) {
+    const localizada = localizarExportacaoEmStatement(node, nomeExportado, sourceFile);
+    if (localizada) {
+      return localizada;
+    }
+  }
+  return undefined;
+}
+
+export function inferirSemanticaHandlerTypeScriptHttp(
+  sourceFile: ts.SourceFile,
+  nomeExportado: string,
+): SemanticaHandlerTypeScriptHttp | undefined {
+  const exportacao = localizarExportacaoTypeScriptHttp(sourceFile, nomeExportado);
+  if (!exportacao?.corpo) {
+    return undefined;
+  }
+
+  const requestNames = new Set<string>();
+  const urlAliases = new Set<string>();
+  const searchParamsAliases = new Set<string>();
+  const jsonAliases = new Set<string>();
+  const formAliases = new Set<string>();
+  const bodyAliases = new Map<string, { tipoTexto?: string; campos: CampoInferidoTypeScriptHttp[] }>();
+  const bodyDeclaracoesDiretas: CampoInferidoTypeScriptHttp[] = [];
+  const safeParseAliases = new Map<string, CampoInferidoTypeScriptHttp[]>();
+  const valoresLocais = new Map<string, ValorLocalTypeScriptHttp>();
+  const schemasZod = extrairSchemasZodLocais(sourceFile);
+
+  for (const parametro of exportacao.parametros) {
+    if (ts.isIdentifier(parametro.name)) {
+      requestNames.add(parametro.name.text);
+    }
+  }
+
+  const visitarDeclaracoes = (node: ts.Node): void => {
+    if (ts.isVariableDeclaration(node) && node.initializer) {
+      const inicializadorNormalizado = desembrulharExpressao(node.initializer);
+
+      if (ts.isIdentifier(node.name)) {
+        const nome = node.name.text;
+
+        if (ehNewUrl(node.initializer, requestNames)) {
+          urlAliases.add(nome);
+        }
+
+        if (ehSearchParamsSource(node.initializer, requestNames, urlAliases, searchParamsAliases)) {
+          searchParamsAliases.add(nome);
+        }
+
+        if (ehCallRequest(node.initializer, requestNames, "json")) {
+          const metadadosBody = extrairMetadadosTipoExplicito(node.initializer, sourceFile, node.type);
+          jsonAliases.add(nome);
+          bodyAliases.set(nome, {
+            tipoTexto: metadadosBody.tipoTexto,
+            campos: metadadosBody.campos,
+          });
+        }
+
+        if (ehCallRequest(node.initializer, requestNames, "formData")) {
+          formAliases.add(nome);
+        }
+
+        if (
+          ts.isCallExpression(inicializadorNormalizado)
+          && ts.isPropertyAccessExpression(inicializadorNormalizado.expression)
+          && ["parse", "safeParse"].includes(inicializadorNormalizado.expression.name.text)
+        ) {
+          const chamada = inicializadorNormalizado;
+          const acessoChamada = chamada.expression as ts.PropertyAccessExpression;
+          const schemaNome = obterNomeSchema(chamada);
+          const arg = chamada.arguments[0];
+          const schemaCampos = schemaNome ? schemasZod.get(schemaNome) : undefined;
+          const argNormalizado = arg ? desembrulharExpressao(arg) : undefined;
+          if (schemaCampos && arg && (ehCallRequest(arg, requestNames, "json") || (argNormalizado && ts.isIdentifier(argNormalizado) && jsonAliases.has(argNormalizado.text)))) {
+            if (acessoChamada.name.text === "parse") {
+              bodyAliases.set(nome, { campos: schemaCampos, tipoTexto: undefined });
+            } else {
+              safeParseAliases.set(nome, schemaCampos);
+            }
+          }
+        }
+
+        if (
+          ts.isPropertyAccessExpression(inicializadorNormalizado)
+          && inicializadorNormalizado.name.text === "data"
+          && ts.isIdentifier(inicializadorNormalizado.expression)
+          && safeParseAliases.has(inicializadorNormalizado.expression.text)
+        ) {
+          const acesso = inicializadorNormalizado;
+          const alvoAcesso = acesso.expression as ts.Identifier;
+          bodyAliases.set(nome, {
+            campos: safeParseAliases.get(alvoAcesso.text) ?? [],
+            tipoTexto: undefined,
+          });
+        }
+
+        if (ts.isObjectLiteralExpression(node.initializer)) {
+          valoresLocais.set(nome, {
+            tipoTexto: node.type?.getText(sourceFile),
+            campos: extrairCamposObjetoLiteral(node.initializer, sourceFile),
+          });
+        } else if (ts.isIdentifier(node.initializer) && valoresLocais.has(node.initializer.text)) {
+          valoresLocais.set(nome, valoresLocais.get(node.initializer.text)!);
+        } else {
+          const retornoHttp = extrairRetornoHttp(node.initializer, sourceFile, valoresLocais);
+          if (retornoHttp) {
+            valoresLocais.set(nome, {
+              tipoTexto: retornoHttp.tipoTexto,
+              campos: retornoHttp.campos,
+              status: retornoHttp.status,
+            });
+          }
+        }
+      }
+
+      if (ts.isObjectBindingPattern(node.name)) {
+        const metadadosBody = resolverMetadadosOrigemBody(
+          node.initializer,
+          sourceFile,
+          requestNames,
+          bodyAliases,
+          jsonAliases,
+          safeParseAliases,
+          schemasZod,
+          node.type,
+        );
+
+        if (metadadosBody) {
+          const camposBinding = extrairCamposBindingPattern(node.name, sourceFile, metadadosBody.campos);
+          bodyDeclaracoesDiretas.push(...camposBinding);
+
+          const inicializadorNormalizado = desembrulharExpressao(node.initializer);
+          if (ts.isIdentifier(inicializadorNormalizado) && bodyAliases.has(inicializadorNormalizado.text)) {
+            bodyAliases.set(inicializadorNormalizado.text, {
+              tipoTexto: bodyAliases.get(inicializadorNormalizado.text)?.tipoTexto ?? metadadosBody.tipoTexto,
+              campos: deduplicarCampos([
+                ...(bodyAliases.get(inicializadorNormalizado.text)?.campos ?? []),
+                ...camposBinding,
+              ]),
+            });
+          }
+        }
+      }
+
+      if (
+        ts.isObjectBindingPattern(node.name)
+        && ehNewUrl(node.initializer, requestNames)
+      ) {
+        for (const elemento of node.name.elements) {
+          if (!ts.isIdentifier(elemento.name)) {
+            continue;
+          }
+          const nomeCampo = elemento.propertyName?.getText(sourceFile) ?? elemento.name.text;
+          if (nomeCampo === "searchParams") {
+            searchParamsAliases.add(elemento.name.text);
+          }
+        }
+      }
+    }
+
+    node.forEachChild(visitarDeclaracoes);
+  };
+
+  visitarDeclaracoes(exportacao.corpo);
+
+  const query: CampoInferidoTypeScriptHttp[] = [];
+  const body: CampoInferidoTypeScriptHttp[] = [];
+  const response: CampoInferidoTypeScriptHttp[] = [];
+  const statuses: number[] = [];
+  let bodyTipoTexto: string | undefined;
+  let responseTipoTexto: string | undefined;
+
+  const adicionarBodyCampos = (campos: CampoInferidoTypeScriptHttp[], tipoTexto?: string) => {
+    if (campos.length > 0) {
+      body.push(...campos);
+    }
+    bodyTipoTexto ??= tipoTexto;
+  };
+
+  const visitarSemantica = (node: ts.Node): void => {
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+      const alvo = node.expression.expression;
+      const metodo = node.expression.name.text;
+
+      if (["get", "getAll", "has"].includes(metodo)) {
+        const argumento = node.arguments[0];
+        if (argumento && ts.isStringLiteralLike(argumento) && ehSearchParamsSource(alvo, requestNames, urlAliases, searchParamsAliases)) {
+          query.push({
+            nome: argumento.text,
+            tipoTexto: inferirTipoPorContexto(node, argumento.text) ?? "string",
+            obrigatorio: false,
+          });
+        }
+        if (argumento && ts.isStringLiteralLike(argumento) && ts.isIdentifier(alvo) && formAliases.has(alvo.text)) {
+          body.push({
+            nome: argumento.text,
+            tipoTexto: inferirTipoPorContexto(node, argumento.text) ?? "string",
+            obrigatorio: false,
+          });
+        }
+      }
+
+      if (["parse", "safeParse"].includes(metodo)) {
+        const schemaNome = obterNomeSchema(node);
+        const schemaCampos = schemaNome ? schemasZod.get(schemaNome) : undefined;
+        const argumento = node.arguments[0];
+        if (schemaCampos && argumento && (ehCallRequest(argumento, requestNames, "json") || (ts.isIdentifier(argumento) && jsonAliases.has(argumento.text)))) {
+          adicionarBodyCampos(schemaCampos);
+        }
+      }
+    }
+
+    if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && bodyAliases.has(node.expression.text)) {
+        const bodyAlias = bodyAliases.get(node.expression.text)!;
+        if (!bodyAlias.campos.some((campo) => campo.nome === node.name.text)) {
+          body.push({
+            nome: node.name.text,
+            tipoTexto: inferirTipoPorContexto(node, node.name.text) ?? "string",
+            obrigatorio: false,
+          });
+        }
+      bodyTipoTexto ??= bodyAlias.tipoTexto;
+    }
+
+      if (ts.isReturnStatement(node) && node.expression) {
+        const retorno = extrairRetornoHttp(node.expression, sourceFile, valoresLocais);
+        if (retorno) {
+          if (typeof retorno.status === "number") {
+            statuses.push(retorno.status);
+          }
+          if (retorno.status === undefined || retorno.status < 400) {
+            response.push(...retorno.campos);
+            responseTipoTexto ??= retorno.tipoTexto;
+          }
+        }
+      }
+
+    node.forEachChild(visitarSemantica);
+  };
+
+  visitarSemantica(exportacao.corpo);
+
+  adicionarBodyCampos(bodyDeclaracoesDiretas);
+  for (const bodyAlias of bodyAliases.values()) {
+    adicionarBodyCampos(bodyAlias.campos, bodyAlias.tipoTexto);
+  }
+
+  const statusesDeduplicados = deduplicarNumeros(statuses);
+  return {
+    query: deduplicarCampos(query),
+    body: deduplicarCampos(body),
+    bodyTipoTexto,
+    response: deduplicarCampos(response),
+    responseTipoTexto,
+    statuses: statusesDeduplicados,
+    errorStatuses: statusesDeduplicados.filter((status) => status >= 400),
+  };
+}
+
+export function extrairRotasTypeScriptHttp(
+  sourceFile: ts.SourceFile,
+  relacaoArquivo: string,
+): RotaTypeScriptExtraida[] {
+  const rotas: RotaTypeScriptExtraida[] = [];
+  const caminhoNext = inferirCaminhoNext(relacaoArquivo);
+  if (caminhoNext) {
+    for (const metodo of extrairMetodosHttpNext(sourceFile)) {
+      rotas.push({
+        origem: "nextjs",
+        metodo,
+        caminho: caminhoNext.caminho,
+        simbolo: metodo,
+        parametros: caminhoNext.parametros,
+      });
+    }
+  }
+
+  rotas.push(...extrairRotasNodeWorker(sourceFile, relacaoArquivo));
+  return deduplicarRotas(rotas);
+}