PipeHub

PipeHub é uma ferramenta desenvolvida com a filosofia de compreender e gerenciar as regras de negócio de sua aplicação JavaScript convertendo-as em dados JSON tornando sua regra de negócio não mais um código preso a uma linguagem específica, mas sim em dados úteis que podem ser facilmente inspecionados, testados e versionados tanto por seu aplicativo quanto por sistemas de terceiros.

Uma vez que seu sistema agora pode exportar suas regras de negócio para outros sistemas indiferentes de sua linguagem ou arquitetura, o mesmo pode ocorrer de forma reversa. Seu sistema pode importar diariamente uma nova versão de suas regras gerada por terceiros ou até mesmo por inteligência artificial.

Sim! Tudo isso de forma simples e SEGURA! 👨🏻‍💻💜

Como fazemos isso?

Seguindo o modelo da programação funcional em JavaScript, PipeHub partirá do princípio de que toda função desenvolvida em seu escopo utilize-se injeção de dependência para suas funcionalidades externas, focando-se somente em sua regra de negócio.

Em um cenário fictício, desenvolver uma função em PipeHub seria o mesmo que programar um robô para executar certas tarefas do dia a dia utilizando-se de uma caixa de ferramentas. Vamos chamar este robô de PH 🤖 e suas ferramentas por sua vez são suas dependências e sem elas o robô não poderá executar sua tarefa como esperado.

Uma vez programado e aprovado para uma tarefa em específico, você poderá compartilhar seu robô com um vizinho ou até mesmo armazená-lo em um depósito caso precise dele novamente no futuro, porém, não será possível repassar sua caixa de ferramentas junto com ele, e ai que está o segredo do PipeHub ser tão incrível.

Uma vez executado em outro cenário, será necessário entregar para ele outras ferramentas que possua o mesmo objetivo (contrato) de cumprir o que suas ferramentas antigas possuía para que também o robô consiga entregar o mesmo resultado em um local remoto assim também como fazia em sua casa.

Sendo assim, uma vez separando nosso robô de sua caixa de ferramentas, também separamos a nossa funcionalidade de suas dependências externas, evitando assim efeitos colaterais por utilizar recursos globais ou fora do escopo tornando esta função uma função "pura" (saiba mais) onde sabemos exatamente a sua responsabilidade e podemos com isso exportar e versionar somente as regras de negócio de sua função.

Porque não posso exportar e importar JavaScript para minha aplicação?

Uma vez sua aplicação programada seja em JavaScript ou qualquer outra linguagem, a mesma deverá cumprir alguns requisitos básicos para ser considerada uma aplicação estável, segura e que tenha um bom desempenho. Isso inclui versionamento de código, documentação de funcionalidades e testes unitários e de integração.

Uma vez que seu sistema está estruturado sobre esta base que o torna seguro, você não deverá permitir que nenhum código de terceiro seja importado para seu sistema de forma automática sem antes passar por um analista e ser devidamente testado contra bugs, e no pior cenário e não menos comum, um código malicioso poderá hackear sua aplicação e até roubar seus dados.

Posso confiar em arquivos JSON?

Por isso o PipeHub não importa ou exporta códigos nativos que podem corromper a integridade de seu sistema. Ao invés disso utilizamos dados de anotação para armazenar suas regras e exportamos o mesmo em um aquivo JSON (Java Script Object Notation).

Uma vez seu código mapeado um arquivo JSON, o mesmo pode ser compartilhado e importado de sistemas de terceiros da mesma forma que seu sistema pode enviar e receber e-mails.

Compatibilidade

Compatível com as maiores bibliotecas do Javascript para programação funcional como Lodash, Ramda e Mori entre outras ferramentas que utilizam-se dos mesmos padrões.

Installation

Use the package manager npm to install PipeHub.

npm i pipehub

Usage

Inciaremos utilizando Ramda como dependência direta por ser funcional desde sua origem. Você pode utilizar Lodash/fp como alternativa também.

Vemos abaixo um exemplo de uma função utilizando PipeHub. Chamamos ela de "changePlayer" e será responsável por fazer alterações em personagens do game Zelda.

import pipehub from "pipehub";

const changePlayers = pipehub((props) => {
  // Desempacotando as dependências
  const { pipe, filter, map } = props.ramda;
  const { merge, not, isType, setType } = props.utils;

  // Corpo da função utilizando pipes
  return pipe(
    filter(not(isType("villain"))),
    merge(pipe(filter(isType("warrior")), map(setType("KING"))))
  );
});

Esta é considerada uma função pura, pois todas suas dependências foram passadas por parâmetros utilizando "props". Em seguida é contruido toda a regra de negócio utilizando as pipes e o resultado será retornado para quem o invocar.

Convertendo a função em JSON

const JsonData = changePlayers.json();

console.log(JsonData);

E será impresso assim:

{
  ":type": "function",
  "path": "ramda.pipe",
  "props": [
    {
      ":type": "function",
      "path": "ramda.filter",
      "props": [
        {
          ":type": "function",
          "path": "utils.not",
          "props": [
            {
              ":type": "function",
              "path": "utils.isType",
              "props": ["villain"]
            }
          ]
        }
      ]
    },
    {
      ":type": "function",
      "path": "utils.merge",
      "props": [
        {
          ":type": "function",
          "path": "ramda.pipe",
          "props": [
            {
              ":type": "function",
              "path": "ramda.filter",
              "props": [
                {
                  ":type": "function",
                  "path": "utils.isType",
                  "props": ["warrior"]
                }
              ]
            },
            {
              ":type": "function",
              "path": "ramda.map",
              "props": [
                {
                  ":type": "function",
                  "path": "utils.setType",
                  "props": ["KING"]
                }
              ]
            }
          ]
        }
      ]
    }
  ]
}

Criando algumas funções como dependência

A princípio adicionamos algumas funções como dependência associada ao objeto "utils".

const utils = {
  // Mescla o resultado filtrado sobre a listagem original
  merge: (pipe) => (x) => Object.assign(x, pipe(x)),
  // Verifica se o tipo condiz com o parâmetro
  isType: (type) => (x) => type === x.type,
  // Nega a resposta
  not: (pipe) => (x) => !pipe(x),
  // Seta o tipo de personagem conforme o parâmetro
  setType: (type) => (x) => ((x.type = type), x),
};

E agora criamos os personagens.

const players = {
  zelda: { type: "princess", name: "Zelda" },
  link: { type: "warrior", name: "Link" },
  ganon: { type: "villain", name: "Ganon" },
};

Recriando a função a partir do JSON

const ChangePlayers = pipehub.create(JsonData);

console.log(ChangePlayers.getCode());

Que imprimirá a função recriada de forma dinâmica.

({ ramda, utils }) => {
  return ramda.pipe(
    ramda.filter(utils.not(utils.isType("villain"))),
    utils.merge(
      ramda.pipe(
        ramda.filter(utils.isType("warrior")),
        ramda.map(utils.setType("KING"))
      )
    )
  );
};

Executando a função com os parâmetros

const ChangePlayers = pipehub.create(JsonData);

// Criamos o objeto principal contendo todas as dependências da função
const props = { ramda, utils };

// executamos a função passando primeiro as dependências e por último passamos os dados dos jogadores.
const MappedPlayers = ChangePlayers(props)(players);

console.log(MappedPlayers);

Que imprimirá:

{
  "zelda": { "type": "princess", "name": "Zelda" },
  "link": { "type": "KING", "name": "Link" }
}

Contribuindo com o projeto

Solicitações pull são bem-vindas. Para mudanças importantes, abra um problema primeiro para discutir o que você gostaria de mudar.

License

MIT