@semacode/cli 1.5.35 → 1.5.37

package/dist/typescript-http.js

@@ -1,854 +1,5 @@
-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) || ts.isCallExpression(declaracao.initializer) || ts.isIdentifier(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);
-}
+// SEMA-GOVERNED: sema.governanca_ia_contexto
+// Descricao: fachada de extracao HTTP TypeScript; consulte contratos/sema/governanca_ia_contexto.sema antes de editar.
+export { extrairRotasTypeScriptHttp } from "./typescript-http-rotas.js";
+export { inferirSemanticaHandlerTypeScriptHttp, localizarExportacaoTypeScriptHttp, } from "./typescript-http-semantica.js";
 //# sourceMappingURL=typescript-http.js.map