136 lines
5.1 KiB
TypeScript
136 lines
5.1 KiB
TypeScript
/**
|
|
* Códigos padrão usados pelo contrato de respostas.
|
|
*
|
|
* Observação: este enum é parte da API pública do pacote.
|
|
*/
|
|
declare enum codigosResposta {
|
|
sucesso = 200,
|
|
erroConhecido = 400,
|
|
erroPermissao = 401,
|
|
erroNaoEncontrado = 404,
|
|
erroDesconhecido = 500,
|
|
tempoEsgotado = 504
|
|
}
|
|
type tipoRespostaSucesso<T> = {
|
|
cod: codigosResposta.sucesso;
|
|
valor: T;
|
|
mensagem: undefined;
|
|
eErro: false;
|
|
eCerto: true;
|
|
detalhes?: string[];
|
|
};
|
|
type tipoRespostaErro = {
|
|
cod: codigosResposta.erroConhecido | codigosResposta.erroDesconhecido | codigosResposta.erroPermissao | codigosResposta.erroNaoEncontrado | codigosResposta.tempoEsgotado;
|
|
valor: undefined;
|
|
mensagem: string;
|
|
eErro: true;
|
|
eCerto: false;
|
|
detalhes?: string[];
|
|
};
|
|
type tipoResposta<T> = tipoRespostaSucesso<T> | tipoRespostaErro;
|
|
type tipoPrErroInterno = {
|
|
erro: any;
|
|
mensagem?: string;
|
|
local: string;
|
|
__filename?: string;
|
|
};
|
|
/**
|
|
* Tipo do callback opcional de interceptação de respostas.
|
|
*
|
|
* Quando fornecido, é invocado após a construção de toda resposta,
|
|
* permitindo side-effects (ex.: logging, telemetria) sem alterar o tipo.
|
|
*/
|
|
type tipoCallbackResposta = <X>(resposta: tipoResposta<X>) => tipoResposta<X>;
|
|
/**
|
|
* Cria um conjunto de geradores de respostas.
|
|
*
|
|
* @param registrarErroInterno callback para registrar/normalizar erros internos.
|
|
*/
|
|
interface InterfaceRespostas {
|
|
valor: <T>(valor: T, detalhes?: string[]) => tipoRespostaSucesso<T>;
|
|
valorTrue: (detalhes?: string[]) => tipoRespostaSucesso<true>;
|
|
erro: (mensagem: string, detalhes?: string[]) => tipoRespostaErro;
|
|
erroPermissao: (mensagem?: string | undefined | null, detalhes?: string[]) => tipoRespostaErro;
|
|
erroInterno: (op: tipoPrErroInterno) => tipoRespostaErro;
|
|
naoEncontrado: (mensagem?: string | undefined | null, detalhes?: string[]) => tipoRespostaErro;
|
|
tempoEsgotado: (mensagem?: string | undefined | null, detalhes?: string[]) => tipoRespostaErro;
|
|
erroEspera: (mensagem?: string | undefined | null, detalhes?: string[]) => tipoRespostaErro;
|
|
}
|
|
declare const IniciarRespostas: (
|
|
/** Callback opcional de interceptação — invocado após a construção de cada resposta */
|
|
callback?: tipoCallbackResposta) => InterfaceRespostas;
|
|
/**
|
|
* @deprecated Use IniciarRespostas em seu lugar
|
|
*/
|
|
declare const gerarRespostas: (callback?: tipoCallbackResposta) => InterfaceRespostas;
|
|
/**
|
|
* Instância default (sem handler de interceptação).
|
|
*/
|
|
declare const respostaComuns: InterfaceRespostas;
|
|
|
|
/**
|
|
* Mapa de códigos HTTP de erro usados pelo sistema ELicencie.
|
|
*
|
|
* Single source of truth para derivar `codigoErroELicencie`.
|
|
*/
|
|
declare const codigosErros: {
|
|
readonly 400: "Erro de requisição";
|
|
readonly 403: "Não autenticado";
|
|
readonly 500: "Erro interno";
|
|
readonly 504: "Tempo de resposta excedido";
|
|
};
|
|
/** Códigos HTTP de erro reconhecidos pelo ELicencie. */
|
|
type codigoErroELicencie = keyof typeof codigosErros;
|
|
interface tipoRespostaSucessoELicencie<T> {
|
|
codigo: 200;
|
|
eErro: false;
|
|
valor: T;
|
|
erro: undefined;
|
|
detalhes?: Record<string, any>;
|
|
}
|
|
interface tipoRespostaErroELicencie {
|
|
codigo: codigoErroELicencie;
|
|
eErro: true;
|
|
erro: string;
|
|
valor: undefined;
|
|
detalhes?: Record<string, any>;
|
|
}
|
|
type tipoRespostaELicencie<T> = tipoRespostaSucessoELicencie<T> | tipoRespostaErroELicencie;
|
|
/**
|
|
* Durante a transição de sistema, a entrada pode chegar em qualquer um
|
|
* dos dois formatos. O conversor detecta e normaliza para P-Resposta.
|
|
*/
|
|
type tipoEntradaTransicao<T> = tipoRespostaELicencie<T> | tipoResposta<T>;
|
|
/**
|
|
* Converte uma resposta para o formato **P-Resposta** (padrão do pacote),
|
|
* mantendo em runtime os campos de **ambos** os formatos para
|
|
* compatibilidade durante a transição de sistema.
|
|
*
|
|
* **Tipo de retorno:** `tipoResposta<T>`
|
|
*
|
|
* **Conteúdo em runtime:** campos P-Resposta + campos ELicencie
|
|
*
|
|
* | P-Resposta | ELicencie | Relação |
|
|
* |-------------|-------------|----------------------|
|
|
* | `cod` | `codigo` | mapeamento de código |
|
|
* | `mensagem` | `erro` | mesmo conteúdo |
|
|
* | `valor` | `valor` | direto |
|
|
* | `eErro` | `eErro` | direto |
|
|
* | `eCerto` | — | derivado |
|
|
* | `detalhes` | `detalhes` | string[] / Record |
|
|
*
|
|
* @example
|
|
* ```ts
|
|
* const res = converterRespostaELicencieParaPResposta(respostaQualquer)
|
|
*
|
|
* // Consumidor P-Resposta
|
|
* if (res.eCerto) console.log(res.valor)
|
|
*
|
|
* // Consumidor ELicencie (lê campo extra em runtime)
|
|
* const resAny = res as any
|
|
* if (!resAny.eErro) console.log(resAny.valor)
|
|
* ```
|
|
*/
|
|
declare const converterRespostaELicencieParaPResposta: <T>(entrada: tipoEntradaTransicao<T>) => tipoResposta<T>;
|
|
|
|
export { IniciarRespostas, type InterfaceRespostas, type codigoErroELicencie, codigosErros, codigosResposta, converterRespostaELicencieParaPResposta, gerarRespostas, respostaComuns, type tipoCallbackResposta, type tipoEntradaTransicao, type tipoPrErroInterno, type tipoResposta, type tipoRespostaELicencie, type tipoRespostaErro, type tipoRespostaErroELicencie, type tipoRespostaSucesso, type tipoRespostaSucessoELicencie };
|