@semacode/cli 0.8.2

package/dist/typescript-http.js

@@ -0,0 +1,854 @@
+import ts from "typescript";
+const METODOS_HTTP = new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+function normalizarSeparadores(relacao) {
+    return relacao.replace(/\\/g, "/");
+}
+function deduplicarRotas(rotas) {
+    const mapa = new Map();
+    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) {
+    const mapa = new Map();
+    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) {
+    return [...new Set(valores)].sort((a, b) => a - b);
+}
+function desembrulharExpressao(expr) {
+    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, sourceFile) {
+    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 = [];
+    for (const declaracao of statement.declarationList.declarations) {
+        if (!ts.isIdentifier(declaracao.name) || !declaracao.initializer) {
+            continue;
+        }
+        if (ts.isArrowFunction(declaracao.initializer) || ts.isFunctionExpression(declaracao.initializer)) {
+            nomes.push(declaracao.name.getText(sourceFile));
+        }
+    }
+    return nomes;
+}
+function extrairMetodosHttpNext(sourceFile) {
+    const encontrados = new Set();
+    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) {
+    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 = [];
+    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, nomeSimbolo, corpo) {
+    const rotas = [];
+    const visitar = (node) => {
+        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, relacaoArquivo) {
+    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 = [];
+    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) {
+    return /(^|_)?id$/i.test(nome) || /Id$/.test(nome)
+        ? "Id"
+        : undefined;
+}
+function normalizarTypeNode(typeNode) {
+    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) => Boolean(item));
+        if (uteis.length === 1) {
+            return uteis[0];
+        }
+    }
+    return typeNode;
+}
+function extrairCamposTypeNode(typeNode, sourceFile) {
+    const normalizado = normalizarTypeNode(typeNode);
+    if (!normalizado || !ts.isTypeLiteralNode(normalizado)) {
+        return [];
+    }
+    const campos = [];
+    for (const membro of normalizado.members) {
+        if (!ts.isPropertySignature(membro) || !membro.name) {
+            continue;
+        }
+        let nome;
+        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, sourceFile, typeNodeDeclarado) {
+    const typeNode = normalizarTypeNode(typeNodeDeclarado)
+        ?? (() => {
+            let atual = 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, nomeCampo) {
+    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, sourceFile) {
+    const campos = [];
+    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) {
+    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, requestNames) {
+    return ts.isPropertyAccessExpression(expr)
+        && expr.name.text === "url"
+        && ts.isIdentifier(expr.expression)
+        && requestNames.has(expr.expression.text);
+}
+function ehNewUrl(expr, requestNames) {
+    return ts.isNewExpression(expr)
+        && ts.isIdentifier(expr.expression)
+        && expr.expression.text === "URL"
+        && Boolean(expr.arguments?.some((argumento) => ehRequestUrl(argumento, requestNames)));
+}
+function ehSearchParamsSource(expr, requestNames, urlAliases, searchParamsAliases) {
+    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, requestNames, metodo) {
+    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) {
+    if (!ts.isPropertyAccessExpression(call.expression)) {
+        return undefined;
+    }
+    const alvo = call.expression.expression;
+    if (!ts.isIdentifier(alvo)) {
+        return undefined;
+    }
+    return alvo.text;
+}
+function resolverMetadadosOrigemBody(expr, sourceFile, requestNames, bodyAliases, jsonAliases, safeParseAliases, schemasZod, typeNodeDeclarado) {
+    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, sourceFile, camposConhecidos) {
+    const conhecidos = new Map(camposConhecidos.map((campo) => [campo.nome, campo]));
+    const campos = [];
+    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, nome) {
+    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) {
+    const schemas = new Map();
+    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;
+            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;
+            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 = [];
+            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, nomeExportado, sourceFile) {
+    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, nomeCampo) {
+    let atual = 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, sourceFile, valoresLocais) {
+    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 = [];
+            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, nomeExportado) {
+    for (const node of sourceFile.statements) {
+        const localizada = localizarExportacaoEmStatement(node, nomeExportado, sourceFile);
+        if (localizada) {
+            return localizada;
+        }
+    }
+    return undefined;
+}
+export function inferirSemanticaHandlerTypeScriptHttp(sourceFile, nomeExportado) {
+    const exportacao = localizarExportacaoTypeScriptHttp(sourceFile, nomeExportado);
+    if (!exportacao?.corpo) {
+        return undefined;
+    }
+    const requestNames = new Set();
+    const urlAliases = new Set();
+    const searchParamsAliases = new Set();
+    const jsonAliases = new Set();
+    const formAliases = new Set();
+    const bodyAliases = new Map();
+    const bodyDeclaracoesDiretas = [];
+    const safeParseAliases = new Map();
+    const valoresLocais = new Map();
+    const schemasZod = extrairSchemasZodLocais(sourceFile);
+    for (const parametro of exportacao.parametros) {
+        if (ts.isIdentifier(parametro.name)) {
+            requestNames.add(parametro.name.text);
+        }
+    }
+    const visitarDeclaracoes = (node) => {
+        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;
+                    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;
+                    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 = [];
+    const body = [];
+    const response = [];
+    const statuses = [];
+    let bodyTipoTexto;
+    let responseTipoTexto;
+    const adicionarBodyCampos = (campos, tipoTexto) => {
+        if (campos.length > 0) {
+            body.push(...campos);
+        }
+        bodyTipoTexto ??= tipoTexto;
+    };
+    const visitarSemantica = (node) => {
+        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, relacaoArquivo) {
+    const rotas = [];
+    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);
+}
+//# sourceMappingURL=typescript-http.js.map