@f-o-t/brasil-api 0.1.0

package/dist/index.js

@@ -0,0 +1,523 @@
+// src/config.ts
+var defaultConfig = {
+  baseUrl: "https://brasilapi.com.br/api",
+  timeout: 1e4
+};
+var currentConfig = { ...defaultConfig };
+function getConfig() {
+  return currentConfig;
+}
+function configureBrasilApi(config) {
+  currentConfig = { ...currentConfig, ...config };
+}
+function setConfig(config) {
+  configureBrasilApi(config);
+}
+function resetConfig() {
+  currentConfig = { ...defaultConfig };
+}
+// src/errors.ts
+class BrasilApiError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BrasilApiError";
+    Object.setPrototypeOf(this, BrasilApiError.prototype);
+  }
+}
+
+class BrasilApiNetworkError extends BrasilApiError {
+  statusCode;
+  endpoint;
+  constructor(message, statusCode, endpoint) {
+    super(message);
+    this.name = "BrasilApiNetworkError";
+    this.statusCode = statusCode;
+    this.endpoint = endpoint;
+    Object.setPrototypeOf(this, BrasilApiNetworkError.prototype);
+  }
+}
+
+class BrasilApiValidationError extends BrasilApiError {
+  zodError;
+  validationType;
+  constructor(message, zodError, validationType) {
+    const formattedMessage = formatValidationError(message, zodError, validationType);
+    super(formattedMessage);
+    this.name = "BrasilApiValidationError";
+    this.zodError = zodError;
+    this.validationType = validationType;
+    Object.setPrototypeOf(this, BrasilApiValidationError.prototype);
+  }
+}
+
+class BrasilApiResponseError extends BrasilApiValidationError {
+  constructor(message, zodError) {
+    super(message, zodError, "response");
+    this.name = "BrasilApiResponseError";
+    Object.setPrototypeOf(this, BrasilApiResponseError.prototype);
+  }
+}
+function formatValidationError(baseMessage, zodError, validationType) {
+  const issues = zodError.issues.map((err) => {
+    const path = err.path.join(".");
+    return `  - ${path}: ${err.message}`;
+  }).join(`
+`);
+  return `${baseMessage} (${validationType} validation failed):
+${issues}`;
+}
+// src/cep.ts
+import { z } from "zod";
+
+// src/client.ts
+async function fetchApi(endpoint, schema) {
+  const config = getConfig();
+  const url = `${config.baseUrl}${endpoint}`;
+  const controller = new AbortController;
+  const timeoutId = setTimeout(() => controller.abort(), config.timeout);
+  try {
+    const response = await fetch(url, {
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      throw new BrasilApiNetworkError(`HTTP ${response.status}: ${response.statusText}`, response.status, endpoint);
+    }
+    const data = await response.json();
+    const result = schema.safeParse(data);
+    if (!result.success) {
+      throw new BrasilApiResponseError("Invalid API response format", result.error);
+    }
+    return result.data;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof BrasilApiNetworkError) {
+      throw error;
+    }
+    if (error instanceof BrasilApiResponseError) {
+      throw error;
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new BrasilApiNetworkError(`Request timeout after ${config.timeout}ms`, undefined, endpoint);
+    }
+    throw new BrasilApiNetworkError(`Network request failed: ${error instanceof Error ? error.message : "Unknown error"}`, undefined, endpoint);
+  }
+}
+
+// src/cep.ts
+var CepInputSchema = z.string().regex(/^\d{5}-?\d{3}$/, "CEP must be in format 12345-678 or 12345678");
+var CepResponseSchema = z.object({
+  cep: z.string(),
+  state: z.string(),
+  city: z.string(),
+  neighborhood: z.string(),
+  street: z.string(),
+  service: z.string()
+});
+var CepV2ResponseSchema = CepResponseSchema.extend({
+  location: z.object({
+    type: z.literal("Point"),
+    coordinates: z.object({
+      longitude: z.string(),
+      latitude: z.string()
+    })
+  })
+});
+async function getCep(cep) {
+  const validationResult = CepInputSchema.safeParse(cep);
+  if (!validationResult.success) {
+    throw new BrasilApiValidationError("Invalid CEP format", validationResult.error, "input");
+  }
+  const cleanCep = cep.replace("-", "");
+  return fetchApi(`/cep/v1/${cleanCep}`, CepResponseSchema);
+}
+async function getCepV2(cep) {
+  const validationResult = CepInputSchema.safeParse(cep);
+  if (!validationResult.success) {
+    throw new BrasilApiValidationError("Invalid CEP format", validationResult.error, "input");
+  }
+  const cleanCep = cep.replace("-", "");
+  return fetchApi(`/cep/v2/${cleanCep}`, CepV2ResponseSchema);
+}
+// src/banks.ts
+import { z as z2 } from "zod";
+var BankCodeInputSchema = z2.number().int().positive();
+var BankSchema = z2.object({
+  ispb: z2.string(),
+  name: z2.string(),
+  code: z2.number().nullable(),
+  fullName: z2.string()
+});
+async function getBanks() {
+  return fetchApi("/banks/v1", z2.array(BankSchema));
+}
+async function getBank(code) {
+  const validationResult = BankCodeInputSchema.safeParse(code);
+  if (!validationResult.success) {
+    throw new BrasilApiValidationError("Invalid bank code", validationResult.error, "input");
+  }
+  return fetchApi(`/banks/v1/${code}`, BankSchema);
+}
+// src/cnpj.ts
+import { z as z3 } from "zod";
+var CnpjInputSchema = z3.string().regex(/^\d{2}\.?\d{3}\.?\d{3}\/?\d{4}-?\d{2}$/, "CNPJ must be 14 digits with optional punctuation");
+var CnpjResponseSchema = z3.object({
+  cnpj: z3.string(),
+  razao_social: z3.string().optional(),
+  nome_fantasia: z3.string().optional(),
+  uf: z3.string().optional(),
+  municipio: z3.string().optional(),
+  natureza_juridica: z3.string().optional(),
+  situacao_cadastral: z3.string().optional(),
+  data_inicio_atividade: z3.string().optional(),
+  cnae_fiscal: z3.string().optional(),
+  qsa: z3.array(z3.any())
+});
+async function getCnpj(cnpj) {
+  const validationResult = CnpjInputSchema.safeParse(cnpj);
+  if (!validationResult.success) {
+    throw new BrasilApiValidationError("Invalid CNPJ format", validationResult.error, "input");
+  }
+  const cleanCnpj = cnpj.replace(/[.\-/]/g, "");
+  return fetchApi(`/cnpj/v1/${cleanCnpj}`, CnpjResponseSchema);
+}
+// src/ddd.ts
+import { z as z4 } from "zod";
+var DddInputSchema = z4.union([
+  z4.number().int().min(10).max(99),
+  z4.string().regex(/^\d{2}$/, "DDD must be 2 digits")
+]);
+var DddResponseSchema = z4.object({
+  state: z4.string(),
+  cities: z4.array(z4.string())
+});
+async function getDdd(ddd) {
+  const validationResult = DddInputSchema.safeParse(ddd);
+  if (!validationResult.success) {
+    throw new BrasilApiValidationError("Invalid DDD format", validationResult.error, "input");
+  }
+  return fetchApi(`/ddd/v1/${ddd}`, DddResponseSchema);
+}
+// src/feriados.ts
+import { z as z5 } from "zod";
+var YearInputSchema = z5.number().int({ message: "Year must be an integer" }).min(1900, { message: "Year must be between 1900 and 2199" }).max(2199, { message: "Year must be between 1900 and 2199" });
+var FeriadoSchema = z5.object({
+  date: z5.string(),
+  name: z5.string(),
+  type: z5.string()
+});
+var FeriadosArraySchema = z5.array(FeriadoSchema);
+var BRASIL_API_BASE_URL = "https://brasilapi.com.br/api";
+async function getFeriados(year) {
+  const yearValidation = YearInputSchema.safeParse(year);
+  if (!yearValidation.success) {
+    throw new BrasilApiValidationError("Invalid year parameter", yearValidation.error, "input");
+  }
+  const url = `${BRASIL_API_BASE_URL}/feriados/v1/${year}`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch holidays: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  const parsed = FeriadosArraySchema.parse(data);
+  return parsed;
+}
+// src/ibge.ts
+import { z as z6 } from "zod";
+var StateCodeInputSchema = z6.string().regex(/^[A-Z]{2}$/i, "State code must be 2 letters");
+var RegiaoSchema = z6.object({
+  id: z6.number(),
+  sigla: z6.string(),
+  nome: z6.string()
+});
+var EstadoSchema = z6.object({
+  id: z6.number(),
+  sigla: z6.string(),
+  nome: z6.string(),
+  regiao: RegiaoSchema
+});
+var EstadosArraySchema = z6.array(EstadoSchema);
+var MunicipioSchema = z6.object({
+  nome: z6.string(),
+  codigo_ibge: z6.string()
+});
+var MunicipiosArraySchema = z6.array(MunicipioSchema);
+async function getEstados() {
+  return fetchApi("/ibge/uf/v1", EstadosArraySchema);
+}
+async function getMunicipios(uf) {
+  const validationResult = StateCodeInputSchema.safeParse(uf);
+  if (!validationResult.success) {
+    throw new BrasilApiValidationError("Invalid state code format", validationResult.error, "input");
+  }
+  const ufUpper = uf.toUpperCase();
+  return fetchApi(`/ibge/municipios/v1/${ufUpper}`, MunicipiosArraySchema);
+}
+// src/isbn.ts
+import { z as z7 } from "zod";
+var IsbnInputSchema = z7.string().regex(/^(?:\d{10}|\d{13})$/, "ISBN must be 10 or 13 digits");
+var DimensionsSchema = z7.object({}).passthrough();
+var IsbnResponseSchema = z7.object({
+  isbn: z7.string(),
+  title: z7.string(),
+  subtitle: z7.string().nullable(),
+  authors: z7.array(z7.string()),
+  publisher: z7.string(),
+  synopsis: z7.string().nullable(),
+  dimensions: DimensionsSchema.nullable(),
+  year: z7.number().nullable(),
+  format: z7.string(),
+  page_count: z7.number(),
+  subjects: z7.array(z7.string()),
+  location: z7.string().nullable(),
+  retail_price: z7.string().nullable(),
+  cover_url: z7.string().nullable(),
+  provider: z7.string()
+});
+async function getIsbn(isbn) {
+  const validationResult = IsbnInputSchema.safeParse(isbn);
+  if (!validationResult.success) {
+    throw new BrasilApiValidationError("Invalid ISBN format", validationResult.error, "input");
+  }
+  return fetchApi(`/isbn/v1/${isbn}`, IsbnResponseSchema);
+}
+// src/ncm.ts
+import { z as z8 } from "zod";
+var NcmSchema = z8.object({
+  codigo: z8.string(),
+  descricao: z8.string(),
+  data_inicio: z8.string(),
+  data_fim: z8.string(),
+  tipo_ato: z8.string(),
+  numero_ato: z8.string(),
+  ano_ato: z8.string()
+});
+var NcmsArraySchema = z8.array(NcmSchema);
+async function getNcms() {
+  return fetchApi("/ncm/v1", NcmsArraySchema);
+}
+async function getNcm(code) {
+  return fetchApi(`/ncm/v1/${code}`, NcmSchema);
+}
+// src/pix.ts
+import { z as z9 } from "zod";
+var PixParticipantSchema = z9.object({
+  ispb: z9.string(),
+  nome: z9.string(),
+  nome_reduzido: z9.string(),
+  modalidade_participacao: z9.string(),
+  tipo_participacao: z9.string(),
+  inicio_operacao: z9.string()
+});
+var PixParticipantsArraySchema = z9.array(PixParticipantSchema);
+async function getPixParticipants() {
+  return fetchApi("/pix/v1/participants", PixParticipantsArraySchema);
+}
+// src/registrobr.ts
+import { z as z10 } from "zod";
+var DomainStatusSchema = z10.object({
+  status_code: z10.number(),
+  status: z10.string(),
+  fqdn: z10.string(),
+  hosts: z10.array(z10.string()),
+  "publication-status": z10.string(),
+  "expires-at": z10.string(),
+  suggestions: z10.array(z10.string())
+});
+async function getDomainStatus(domain) {
+  return fetchApi(`/registrobr/v1/${domain}`, DomainStatusSchema);
+}
+// src/taxas.ts
+import { z as z11 } from "zod";
+var TaxaSchema = z11.object({
+  nome: z11.string(),
+  valor: z11.number().nullable()
+});
+var TaxasArraySchema = z11.array(TaxaSchema);
+async function getTaxas() {
+  return fetchApi("/taxas/v1", TaxasArraySchema);
+}
+async function getTaxa(sigla) {
+  return fetchApi(`/taxas/v1/${sigla}`, TaxaSchema);
+}
+// src/corretoras.ts
+import { z as z12 } from "zod";
+var CorretoraSchema = z12.object({
+  cnpj: z12.string(),
+  type: z12.string(),
+  nome_social: z12.string(),
+  nome_comercial: z12.string(),
+  status: z12.string(),
+  email: z12.string().optional(),
+  telefone: z12.string().optional(),
+  cep: z12.string().optional(),
+  pais: z12.string().optional(),
+  uf: z12.string().optional(),
+  municipio: z12.string().optional(),
+  bairro: z12.string().optional(),
+  complemento: z12.string().optional(),
+  logradouro: z12.string().optional(),
+  data_patrimonio_liquido: z12.string().optional(),
+  valor_patrimonio_liquido: z12.string().optional(),
+  codigo_cvm: z12.string().optional(),
+  data_inicio_situacao: z12.string().optional(),
+  data_registro: z12.string().optional()
+});
+var CorretorasArraySchema = z12.array(CorretoraSchema);
+async function getCorretoras() {
+  return fetchApi("/cvm/corretoras/v1", CorretorasArraySchema);
+}
+async function getCorretora(cnpj) {
+  return fetchApi(`/cvm/corretoras/v1/${cnpj}`, CorretoraSchema);
+}
+// src/cptec.ts
+import { z as z13 } from "zod";
+var CidadeSchema = z13.object({
+  id: z13.number(),
+  nome: z13.string(),
+  estado: z13.string()
+});
+var CidadesArraySchema = z13.array(CidadeSchema);
+var ClimaSchema = z13.object({
+  data: z13.string(),
+  condicao: z13.string(),
+  condicao_desc: z13.string().optional(),
+  min: z13.number(),
+  max: z13.number(),
+  indice_uv: z13.number()
+});
+var PrevisaoSchema = z13.object({
+  cidade: z13.string(),
+  estado: z13.string(),
+  atualizado_em: z13.string(),
+  clima: z13.array(ClimaSchema)
+});
+var OndaDadoSchema = z13.object({
+  hora: z13.string().optional(),
+  vento: z13.number(),
+  direcao_vento: z13.string(),
+  direcao_vento_desc: z13.string().optional(),
+  altura_onda: z13.number(),
+  direcao_onda: z13.string().optional(),
+  direcao_onda_desc: z13.string().optional(),
+  agitation: z13.string()
+});
+var OndaDiariaSchema = z13.object({
+  data: z13.string(),
+  dados_ondas: z13.array(OndaDadoSchema)
+});
+var PrevisaoOndasSchema = z13.object({
+  cidade: z13.string(),
+  estado: z13.string(),
+  atualizado_em: z13.string(),
+  ondas: z13.array(OndaDiariaSchema)
+});
+async function getCidades() {
+  return fetchApi("/cptec/v1/cidade", CidadesArraySchema);
+}
+async function getPrevisao(cityCode, days = 1) {
+  return fetchApi(`/cptec/v1/clima/previsao/${cityCode}/${days}`, PrevisaoSchema);
+}
+async function getPrevisaoOndas(cityCode) {
+  return fetchApi(`/cptec/v1/ondas/${cityCode}`, PrevisaoOndasSchema);
+}
+// src/cambio.ts
+import { z as z14 } from "zod";
+var MoedaSchema = z14.object({
+  simbolo: z14.string(),
+  nome: z14.string(),
+  tipo_moeda: z14.string()
+});
+var MoedasArraySchema = z14.array(MoedaSchema);
+var CotacaoItemSchema = z14.object({
+  paridade_compra: z14.number(),
+  paridade_venda: z14.number(),
+  cotacao_compra: z14.number(),
+  cotacao_venda: z14.number(),
+  data_hora_cotacao: z14.string(),
+  tipo_boletim: z14.string()
+});
+var CotacaoResponseSchema = z14.object({
+  moeda: z14.string(),
+  data: z14.string(),
+  cotacoes: z14.array(CotacaoItemSchema)
+});
+async function getMoedas() {
+  return fetchApi("/cambio/v1/moedas", MoedasArraySchema);
+}
+async function getCotacao(moeda, data) {
+  return fetchApi(`/cambio/v1/cotacao/${moeda}/${data}`, CotacaoResponseSchema);
+}
+// src/fipe.ts
+import { z as z15 } from "zod";
+var FipeMarcaSchema = z15.object({
+  nome: z15.string(),
+  valor: z15.string()
+});
+var FipeMarcasArraySchema = z15.array(FipeMarcaSchema);
+var FipePrecoSchema = z15.object({
+  valor: z15.string(),
+  marca: z15.string(),
+  modelo: z15.string(),
+  anoModelo: z15.number(),
+  combustivel: z15.string(),
+  codigoFipe: z15.string(),
+  mesReferencia: z15.string(),
+  tipoVeiculo: z15.number(),
+  siglaCombustivel: z15.string(),
+  dataConsulta: z15.string().optional()
+});
+var FipeTabelaSchema = z15.object({
+  codigo: z15.number(),
+  mes: z15.string()
+});
+var FipeTabelasArraySchema = z15.array(FipeTabelaSchema);
+async function getFipeMarcas(tipoVeiculo) {
+  return fetchApi(`/fipe/marcas/v1/${tipoVeiculo}`, FipeMarcasArraySchema);
+}
+async function getFipePreco(codigoFipe) {
+  return fetchApi(`/fipe/preco/v1/${codigoFipe}`, FipePrecoSchema);
+}
+async function getFipeTabelas() {
+  return fetchApi("/fipe/tabelas/v1", FipeTabelasArraySchema);
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+export {
+  setConfig,
+  resetConfig,
+  getTaxas,
+  getTaxa,
+  getPrevisaoOndas,
+  getPrevisao,
+  getPixParticipants,
+  getNcms,
+  getNcm,
+  getMunicipios,
+  getMoedas,
+  getIsbn,
+  getFipeTabelas,
+  getFipePreco,
+  getFipeMarcas,
+  getFeriados,
+  getEstados,
+  getDomainStatus,
+  getDdd,
+  getCotacao,
+  getCorretoras,
+  getCorretora,
+  getConfig,
+  getCnpj,
+  getCidades,
+  getCepV2,
+  getCep,
+  getBanks,
+  getBank,
+  configureBrasilApi,
+  VERSION,
+  BrasilApiValidationError,
+  BrasilApiResponseError,
+  BrasilApiNetworkError,
+  BrasilApiError
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+   "name": "@f-o-t/brasil-api",
+   "version": "0.1.0",
+   "description": "Type-safe Brasil API wrapper with Zod validation",
+   "type": "module",
+   "license": "MIT",
+   "homepage": "https://github.com/F-O-T/montte-nx/blob/master/libraries/brasil-api",
+   "repository": {
+      "type": "git",
+      "url": "https://github.com/F-O-T/montte-nx.git"
+   },
+   "bugs": {
+      "url": "https://github.com/F-O-T/montte-nx/issues"
+   },
+   "private": false,
+   "publishConfig": {
+      "access": "public"
+   },
+   "module": "./dist/index.js",
+   "types": "./dist/index.d.ts",
+   "exports": {
+      ".": {
+         "bun": "./src/index.ts",
+         "import": {
+            "default": "./dist/index.js",
+            "types": "./dist/index.d.ts"
+         },
+         "types": "./src/index.ts"
+      },
+      "./package.json": "./package.json"
+   },
+   "files": [
+      "dist"
+   ],
+   "scripts": {
+      "build": "bunup",
+      "dev": "bunup --watch",
+      "test": "bun test",
+      "test:watch": "bun test --watch",
+      "test:coverage": "bun test --coverage",
+      "typecheck": "tsc",
+      "check": "biome check --write .",
+      "release": "bumpp --commit --push --tag"
+   },
+   "dependencies": {
+      "zod": "^3.23.8"
+   },
+   "devDependencies": {
+      "@biomejs/biome": "2.3.10",
+      "@types/bun": "1.3.5",
+      "bumpp": "10.3.2",
+      "bunup": "0.16.11",
+      "typescript": "5.9.3"
+   },
+   "peerDependencies": {
+      "typescript": ">=4.5.0"
+   },
+   "peerDependenciesMeta": {
+      "typescript": {
+         "optional": true
+      }
+   }
+}