// Importing required packages
const SwaggerParser = require("@apidevtools/swagger-parser");
const { outputFile, readJson, writeJson } = require("fs-extra");
const { join } = require("path");
const { OpenAPIV3 } = require("openapi-types");

const REFERENCE_GROUP_NAME = "Referências";

// Objeto com mapeamento de Nome do grupo para tags
const sidebarGroup = {
  Clientes: ["Clientes", "Funcionários"],
  Empresas: [
    "Empresas",
    "Grupos de empresas",
    "Métodos de pagamento",
    "Operadores",
    "Permissões",
  ],
  Empréstimos: [
    "Produtos",
    "Ofertas",
    "Políticas de crédito",
    "Empréstimos",
    "Parcelas",
    "Esteira",
  ],
  Cobrança: ["Faturas", "Itens da fatura", "Intenções de pagamento"],
  Arquivos: ["Arquivos", "Links de arquivos"],
  Fundos: ["Fundos"],
  Eventos: ["Webhooks externos", "Eventos", "Assinaturas", "Notificações"],
  Configurações: ["Temas", "Chaves da API", "Configurações"],
  Entidades: ["Entidade de dados", "Documentos"],
  Automações: ["Workflows"],
};

// Initialize groupData object
let groupData = {
  group: REFERENCE_GROUP_NAME,
  pages: [],
};

/**
 * Validates the OpenAPI specification and generates Frontmatter files
 * for API endpoints and schema definitions.
 *
 * @param {string} path - File path for the OpenAPI specification
 * @param {string} outDir - Directory to output Frontmatter files
 */
const generateOpenApiPages = async (path, outDir) => {
  let spec;

  // Validate OpenAPI specification
  try {
    spec = await SwaggerParser.validate(path);
  } catch (err) {
    console.error(err);
    throw new Error("Your OpenAPI file is invalid.");
  }

  // Validate existence of API paths in specification
  if (!spec.paths || Object.keys(spec.paths).length === 0) {
    throw new Error("No paths defined.");
  }

  // Loop through API paths to create Frontmatter for each endpoint
  Object.entries(spec.paths).forEach(([path, pathItemObject]) => {
    if (!pathItemObject) return;

    Object.values(OpenAPIV3.HttpMethods).forEach((method) => {
      const operation = pathItemObject[method];
      const operationId = operation?.operationId;
      const tags = operation?.tags || ["Ungrouped"];

      if (operationId) {
        createOpenApiFrontmatter(
          join(outDir, `endpoint/${operationId}.mdx`),
          method,
          path,
        );
        tags.forEach((tag) =>
          addPageToGroup(
            tag,
            `development/api-reference/endpoint/${operationId}`,
          ),
        );
      }
    });
  });

  // Generate schema pages if schemas are defined in specification
  if (spec.components && spec.components.schemas) {
    Object.entries(spec.components.schemas).forEach(([schemaName, schema]) => {
      createOpenApiSchemaFrontmatter(
        join(outDir, `schema/${schemaName}.mdx`),
        schemaName,
      );
      addPageToGroup(
        "Modelos",
        `development/api-reference/schema/${schemaName}`,
      );
    });
  } else {
    throw new Error("No schemas defined.");
  }
};

/**
 * Update navigation in the mint.json file
 *
 * @param {string} mintJsonPath - File path for mint.json
 */
const updateMintJson = async (mintJsonPath) => {
  const existingData = await readJson(mintJsonPath);

  if (existingData && Array.isArray(existingData.navigation)) {
    // Encontrar o índice do objeto com o grupo "Referências"
    const refIndex = existingData.navigation.findIndex(
      (page) => page.group === "Referências",
    );

    if (refIndex !== -1) {
      // Extrair os itens dentro do grupo "Referências"
      const refPages = existingData.navigation[refIndex].pages;

      // Remover o objeto "Referências" do array
      existingData.navigation.splice(refIndex, 1);

      // Adicionar os itens extraídos de "Referências" na raiz do array "pages"
      existingData.navigation = existingData.navigation.concat(refPages);
    }

    await writeJson("mint.json", existingData, { spaces: 2 });
  } else {
    console.error("Formato desconhecido em mint.json");
  }
};

const createOpenApiFrontmatter = async (filename, method, path) => {
  const data = `---
openapi: ${method} ${path}
---`;
  await outputFile(filename, data);
};

const createOpenApiSchemaFrontmatter = async (filename, schemaName) => {
  const data = `---
openapi-schema: ${schemaName}
---`;
  await outputFile(filename, data);
};

const addPageToGroup = (tagName, pagePath) => {
  // Determina o grupo principal com base na tag
  let mainGroupName = null;
  Object.entries(sidebarGroup).forEach(([group, tags]) => {
    if (tags.includes(tagName)) {
      mainGroupName = group;
    }
  });

  if (!mainGroupName) {
    mainGroupName = tagName; // Define um grupo padrão caso a tag não seja encontrada
  }

  // Encontra ou cria o grupo principal
  let mainGroup = groupData.pages.find((g) => g.group === mainGroupName);
  if (!mainGroup) {
    mainGroup = { group: mainGroupName, pages: [] };
    groupData.pages.push(mainGroup);
  }

  // Encontra ou cria o subgrupo específico da tag dentro do grupo principal
  let tagSubGroup = mainGroup.pages.find((sub) => sub.group === tagName);
  if (!tagSubGroup) {
    tagSubGroup = { group: tagName, pages: [] };
    mainGroup.pages.push(tagSubGroup);
  }

  // Adiciona a página ao subgrupo da tag
  tagSubGroup.pages.push(pagePath);
};

/**
 * Sorts the pages within a group based on the HTTP methods in the operationId.
 * Orders: GET, POST, PUT, DELETE.
 *
 * @param {object} group - The group object to sort
 */
const sortGroupPages = (group) => {
  // Iterando sobre cada subgrupo
  group.pages.forEach((subgroup) => {
    // Agora, 'subgroup.pages' deve ser um array de strings (URLs)
    subgroup.pages.sort((a, b) => {
      // Assumindo que 'a' e 'b' são strings das URLs agora
      const aMethod = a.includes("/get")
        ? "A"
        : a.includes("/post")
          ? "B"
          : a.includes("/put")
            ? "C"
            : "D";
      const bMethod = b.includes("/get")
        ? "A"
        : b.includes("/post")
          ? "B"
          : b.includes("/put")
            ? "C"
            : "D";
      return aMethod.localeCompare(bMethod);
    });
  });
};

// Run generateOpenApiPages and update mint.json file
generateOpenApiPages(
  "./development/api-reference/openapi.json",
  "./development/api-reference",
).then(() => {
  groupData.pages.forEach(sortGroupPages);
  console.log(JSON.stringify(groupData, null, 2));
  updateMintJson("mint_with_reference.json");
});


<string>

CompanyGroupsCreate

Base39

Introdução

Documentação

Referência da API

Release Notes

Início

Originação

Cobrança

Integrações

Para desenvolvedores

Release notes

Suporte

Status

Soluções

Objetos principais

Este guia fornece uma lista abrangente de itens a serem configurados para inicializar o seu ambiente, seja ele de teste ou de produção, na plataforma.

Checklist

Novidades

Visão geral

Configuração de estilos customizados para o Portal do Cliente

Estilos customizados

Configuração de textos customizados para o Portal Cliente

Textos Customizados

Status da Base39

Central de Ajuda

Um produto é um conjunto de configurações que definem as regras de negócio de um empréstimo. Por exemplo, empréstimo consignado, antecipação do FGTS, antecipação de salário e etc.

Produtos

Elegibilidade

Oferta

Documentos

Desembolso

Detalhes de como realizar a migração da criação de documentos do empréstimo para as etapas da Esteira

Migração da criação de documentos

Esteira é um conjunto de etapas que definem o ciclo de vida de um empréstimo, desde a originação até o desembolso.

Esteira

Descreve o funcionamento de dependência entre as etapas da esteira.

Dependências

Os passsos configurados em todos os níveis são somados e exibidos na ordem de prioridade.

Hierarquia e exceções

Verificação de documento

O passo do tipo assinatura pode ser usado para verificar assinatura no Portal do Cliente, Portal Empresa e Backoffice

Verificação de assinatura

Desembolsar

A etapa do tipo criação de documentos pode ser utilizada para criar documentos referentes ao empréstimo.

Criação de documentos

Eventos do webhook publicados pelo fluxo de esteira

Eventos do webhook

Hooks

Templates

Políticas de crédito

O registro de vínculo empregatício preserva informações essenciais sobre a remuneração e margem consignável do cliente.

Guia de configurações necessárias para realizar o processo de transferência de funcionário entre empresas filiais.

Transferência entre filiais

Rescisão

Operadores

QITech

API Externa

Objetos mock, objetos simulados ou simplesmente mock são objetos que simulam o comportamento de objetos reais de forma controlada.

Mock

Clientes

Email

Temas

Configure os domínios das aplicações da Base39

Domínios

Validação de chave PIX

Guia passo a passo sobre como consultar parcelas vencidas e gerar uma fatura.

Vencidas

Pagamento excedente nas parcelas

Guia de como criar uma fatura de devolução.

Devolução

Guia de como criar uma fatura de redistribuição entre parcelas.

Redistribuir

Guia de como criar uma fatura recorrente da empresa.

Fatura recorrente da empresa

Fatura de rescisão

Alterar a data de vencimento de um boleto

Integração para desembolso e validação de chave PIX com a QITech.

Infobip

Twilio

SMTP

Sendgrid

Envio de e-mail sem SMTP

Kobana

UNICO

reCAPTCHA

A Base39 fornece ambientes diferentes para testes e produção. Esse guia mostra como usar esses ambientes.

Ambientes

Tipos de erros

Você pode usar esse parâmetro para anexar dados de valor-chave a esses objetos.

Metadata

Paginação

Tolerant reader

Expandindo referências

A sintaxe de pesquisa foi projetada para ser simples e intuitiva, permitindo que você realize buscas complexas com facilidade.

Pesquisa

A funcionalidade de campos solicitados oferece flexibilidade ao permitir a definição de campos específicos a serem incluídos nas respostas das chamadas de API.

Campos solicitados

Use chaves de API para autenticar requisições de API

Chaves de API

Data e hora

Valores percentuais

Valores financeiros

Formato do ID

Saiba mais sobre os limites de requisições da API e como trabalhar com eles

Limite de requisiões

Ambiente de testes

Auditoria

Idempotência

Escute os eventos da sua conta Base39 para que sua integração possa desencadear reações automaticamente.

Webhooks

Implemente essas práticas recomendadas ao usar webhooks.

Melhores práticas

Tipos de eventos

Na Base39, adotamos uma abordagem inovadora para garantir a máxima disponibilidade e resiliência dos nossos serviços

Resiliência

Obter empréstimo

Retorna todas os empréstimos. 

Os itens são retornados e ordenados por data de criação, com os itens mais recentes primeiro.

Listar empréstimos

Pesquise empréstimos que você criou anteriormente usando a linguagem de query.

Pesquisar empréstimos

Lista todas as parcelas de um empréstimo. 

Os itens são retornados e ordenados por data de criação, com os itens mais recentes primeiro. Fluxo de quitação antecipada: Para saber o valor das parcelas em um caso de quitação antecipada, envie o campo `payment_for` com a data de pagamento pretendida, assim o valor da parcela será calculado com base no valor presente (`VP`) da data de pagamento pretendida.

Listar parcelas

Retorna todas as etapas da esteira do empréstimo.

Os itens são retornados e ordenados por data de criação, com os itens mais recentes primeiro.

Listar passos da esteira de empréstimos

Atualiza o empréstimo especificado definindo os valores dos parâmetros passados. Quaisquer parâmetros não fornecidos serão deixados inalterados.

Essa requisição aceita praticamente os mesmos argumentos que a requisição de criação do empréstimo.

Atualizar empréstimo

Criar empréstimo

Cancelar empréstimo

Anular empréstimo

Marcar empréstimo como expirado

Altera o estado de um empréstimo para aberto.

Alterar o estado de um empréstimo para aberto

Desembolsar empréstimo

Criar transação

Criar parcela

Marcar empréstimo como pendente

Anexar arquivo ao empréstimo

Assinar empréstimo

Exclui permanentemente um empréstimo. Não pode ser desfeito.

Excluir empréstimo

Remove do empréstimo o vínculo de um arquivo (esta operação não deletará o arquivo).

Desanexar arquivo do empréstimo

Retorna todas as políticas de crédito. 

Os itens são retornados e ordenados por data de criação, com os itens mais recentes primeiro.

Listar políticas de crédito

Obter política de crédito

Criar política de crédito

Atualizar política de crédito

Deletar uma política de crédito

Listar etapas

Atualizar etapa

Reexecuta a validação de uma etapa do empréstimo. Só é possível reexecutar passos com status diferente de `done`.

Revalidar etapa

Solicita a atualização do step com suporte a operação de atualização(refresh). Somente steps do tipo `UNICO` suporta operação de atualização(refresh) e somente step com status que sejam `failed` ou `in_progress`.

Solicita atualização da etapa

Retorna todos os produtos. 

Os itens são retornados e ordenados por data de criação, com os itens mais recentes primeiro.

Listar produtos

Listar produtos elegíveis

Obter produto

Criar produto

Atualiza o produto especificado definindo os valores dos parâmetros passados. Quaisquer parâmetros não fornecidos serão deixados inalterados.

Essa requisição aceita praticamente os mesmos argumentos que a requisição de criação do produto.

Atualizar produto

Exclui permanentemente um produto. Não pode ser desfeito.

Excluir produto

Obter oferta

Calcular oferta

Obter parcela

Retorna todas as parcelas. 

Os itens são retornados e ordenados por data de criação, com os itens mais recentes primeiro.

Buscar parcelas

Anular parcela

Marcar parcela como incobrável

Exportar parcelas

Retorna todas as empresas. 

Os itens são retornados e ordenados por data de criação, com os itens mais recentes primeiro.

Listar empresas

Obter empresa

Pesquise empresas que você criou anteriormente usando a linguagem de query.

Pesquisar empresas

Inclui uma nova empresa com informações como nome, endereço, documento e outros detalhes relevantes. A operação retorna um identificador único da empresa para futuras consultas e operações

Criar empresa

Atualiza a empresa especificado definindo os valores dos parâmetros passados. Quaisquer parâmetros não fornecidos serão deixados inalterados.

Essa requisição aceita praticamente os mesmos argumentos que a requisição de criação da empresa.

Atualizar empresa

Exclui permanentemente uma empresa. Não pode ser desfeito.

Excluir empresa

Obter grupo de empresas

Retorna todos os grupos de empresas.

Os itens são retornados e ordenados por data de criação, com os itens mais recentes primeiro.

Listar grupos de empresas

Pesquise grupos de empresas que você criou anteriormente usando a linguagem de query.

Pesquisar grupos de empresas

Atualiza o grupo de empresas especificado definindo os valores dos parâmetros passados. Quaisquer parâmetros não fornecidos serão deixados inalterados.

Essa requisição aceita praticamente os mesmos argumentos que a requisição de criação do grupo de empresas.

Atualizar grupo de empresas

Criar grupo de empresas

Exclui permanentemente um grupo de empresas. Não pode ser desfeito.

Excluir grupo de empresas

Obter operador

Retorna todas as permissões de um operador. 

Os itens são retornados e ordenados por data de criação, com os itens mais recentes primeiro.

Listar permissões

Obter permissão

Retorna todos os operadores. 

Os itens são retornados e ordenados por data de criação, com os itens mais recentes primeiro.