Parte 5 - Condicionais no JSON: tomando decisões fora do código (Copy)

Na parte anterior, mostramos como transformar seu sistema em uma engine de execução baseada em JSON, onde cada ação é registrada e interpretada em tempo de execução. Agora, vamos elevar o jogo:

E se você pudesse colocar decisões no JSON? E se fosse possível definir condicionais fora do código, criando fluxos diferentes baseados em dados de tempo de execução?

Sim, isso é possível. E não precisa de um parser de linguagem complexo. Basta estrutura.

Um exemplo simples de JSON com condicional

[
  { "acao": "VerificarEstoque", "produtoId": 101 },
  {
    "condicional": {
      "se": { "variavel": "estoque", "operador": ">", "valor": 0 },
      "entao": [
        { "acao": "SepararProduto", "produtoId": 101 },
        { "acao": "EnviarEmail", "para": "cliente@exemplo.com" }
      ],
      "senao": [
        { "acao": "EnviarEmail", "para": "cliente@exemplo.com", "mensagem": "Produto indisponível" }
      ]
    }
  }
]

Como isso é interpretado no seu código

Você precisa criar uma estrutura simples para armazenar variáveis de contexto:

var
  Context: TDictionary<string, Variant>;

As ações podem modificar esse contexto:

RegisterAction('VerificarEstoque',
  procedure(Params: TJSONObject)
  begin
    var Estoque := ConsultarEstoque(Params.GetValue('produtoId').AsInteger);
    Context.AddOrSetValue('estoque', Estoque);
  end);

E para interpretar condicionais:

procedure ExecutarCondicional(JSON: TJSONObject);
var
  Se, Entao, Senao: TJSONValue;
  Variavel: string;
  Operador: string;
  ValorEsperado, ValorAtual: Variant;
begin
  Se := JSON.GetValue('se');
  Variavel := Se.GetValue<TJSONObject>('se').GetValue<string>('variavel');
  Operador := Se.GetValue<TJSONObject>('se').GetValue<string>('operador');
  ValorEsperado := Se.GetValue<TJSONObject>('se').GetValue<string>('valor');

  if Context.TryGetValue(Variavel, ValorAtual) then
  begin
    var Resultado := AvaliarCondicao(ValorAtual, Operador, ValorEsperado);
    if Resultado then
      ExecutarAcoes(JSON.GetValue<TJSONObject>('condicional').GetValue<TJSONArray>('entao'))
    else if JSON.GetValue<TJSONObject>('condicional').TryGetValue('senao', Senao) then
      ExecutarAcoes(Senao as TJSONArray);
  end;
end;

A função AvaliarCondicao pode ser uma simples comparação de strings, números ou booleanos.

Por que isso é poderoso?

• Seu sistema pode reagir a dados dinâmicos, sem recompilar nada
• Lógicas podem ser alteradas por um analista funcional ou um consultor
• Fluxos podem ser validados, testados e versionados externamente

Isso não é perigoso?

Sim. Toda vez que você tira a lógica do código e coloca fora, você ganha flexibilidade mas perde segurança de tipo, autocompletar, validação em tempo de compilação, etc.

Mas se o seu sistema é complexo e muda o tempo todo, essa troca pode valer muito a pena.

Casos onde isso brilha

• Sistemas de workflow
• Regras tributárias variáveis
• Processos comerciais customizados por cliente
• Automação de integrações e pipelines

Conclusão

Dar poder ao JSON não significa perder o controle. Significa delegar inteligência.
E quanto mais inteligente é sua engine, menos você precisa mexer no código para adaptar seu sistema.

Com condicionais no JSON, você não está mais só executando comandos. Você está criando um mini sistema de decisão. E isso é o começo de algo muito maior.

Próximo artigo sugerido: "Regras como dados: criando sua própria linguagem declarativa"