No mundo do desenvolvimento de software, os padrões de design servem como soluções testadas pelo tempo para problemas comuns.
Um dos conjuntos de padrões de projeto menos comumente discutidos, mas igualmente vitais, é o GRASP (General Responsibility Assignment Software Patterns). Os princípios do GRASP geralmente se correlacionam com os princípios do SOLID e outros padrões de design OOP.
GRASP, ou General Responsibility Assignment Software Patterns, é uma coleção de diretrizes destinadas a atribuir responsabilidades a classes e objetos no design orientado a objetos. Como podemos usar esses padrões em nosso desenvolvimento Javascript (Node.js)? É claro que Javascript suporta classes, que são construídas nativamente em protótipos, onde podemos aplicar GRASP de maneira semelhante à que faríamos em Java.
No entanto, na minha opinião, os padrões GRASP também podem ser aplicados à programação funcional.

O que é GRASP?

Os nove padrões GRASP são:

1. Especialista em Informação
2. Criador
3. Controlador
4. Acoplamento baixo
5. Alta Coesão
6. Polimorfismo
7. Fabricação Pura
8. Indireção
9. Variações protegidas

Especialista em Informação

Atribuir responsabilidades a funções que possuem os dados ou conhecimentos necessários para executar uma tarefa. Na programação funcional, este princípio pode ser aplicado atribuindo responsabilidades a funções ou módulos que possuem os dados ou contexto necessários para executar uma tarefa.

// User management module
const createUser = (name, email) => ({ name, email });

const getUserEmail = (user) => user.email;

const updateUserEmail = (user, newEmail) => ({
  ...user,
  email: newEmail,
});

const user = createUser('John Doe', '[email protected]');
console.log(getUserEmail(user));  // '[email protected]'

const updatedUser = updateUserEmail(user, '[email protected]');
console.log(getUserEmail(updatedUser));  // '[email protected]'

Criador

Use funções de fábrica para criar estruturas de dados ou objetos complexos. Na programação funcional, embora não tratemos de classes da mesma forma que na programação orientada a objetos, podemos aplicar o princípio do Criador atribuindo a responsabilidade de criar estruturas de dados ou inicializar objetos a funções ou módulos que possuem as informações necessárias e contexto.

const createUser = (name, email) => ({ name, email });

Controlador

Use funções de ordem superior para lidar com eventos do sistema e delegar tarefas. Na programação funcional, os controladores geralmente assumem a forma de funções que orquestram o fluxo de dados e ações entre diferentes partes do sistema, garantindo que as responsabilidades sejam claramente separadas.

// Example of express.js controller
const handleRequest = (req, res, userService) => {
  const user = userService.createUser(req.body.name, req.body.email);
  res.send(user);
};

Acoplamento baixo

Garanta que as funções sejam independentes e dependam apenas de entradas explícitas. Na programação funcional, o baixo acoplamento é alcançado projetando funções e módulos que operam independentemente uns dos outros, com dependência mínima dos detalhes internos de outras funções ou módulos

const sendEmail = (emailService, email) => emailService.send(email);

Alta Coesão

Alta Coesão refere-se ao grau em que os elementos dentro de um módulo ou função pertencem uns aos outros. Na programação funcional, alcançar alta coesão significa projetar funções e módulos para que executem uma tarefa única e bem definida ou um conjunto de tarefas intimamente relacionado.

const createUser = (name, email) => ({ name, email });
const addUser = (users, user) => [...users, user];

const createAndAddUser = (users, name, email)=>{
  const user = createUser(name, email);
  return addUser(users, user)
}
// usage
const users = [
  { name: 'Alice', email: '[email protected]' },
  { name: 'Bob', email: '[email protected]' },
];

const newUsers = createAndAddUser(users, 'Charlie', '[email protected]');

Polimorfismo

Use funções de ordem superior e funções de primeira classe para obter polimorfismo. Na programação funcional, o polimorfismo é normalmente alcançado por meio de funções de ordem superior, funções genéricas e sistemas de tipos como Typescript

const processPayment = (paymentMethod) => paymentMethod.process();

Fabricação Pura

Crie funções utilitárias que não correspondam diretamente aos conceitos de domínio, mas forneçam a funcionalidade necessária, quando não existir nenhuma função ou classe de domínio adequada.

const log = (message) => console.log(message);

Indireção

Indireção na programação funcional refere-se ao uso de funções intermediárias para gerenciar interações entre diferentes partes de um sistema. Um bom exemplo em Node.js pode ser o padrão Middleware.

const withNumberFilterMiddleware = (data) => data.filter(item => !isNaN(Number(item)));

Variações Protegidas

Variações protegidas na programação funcional significam criar um design que seja resiliente a mudanças, encapsulando as partes que variam e garantindo que o restante do sistema esteja protegido contra essas variações. Na programação funcional, esse princípio pode ser aplicado por meio do uso de abstração, imutabilidade e encapsulamento para criar código robusto e de fácil manutenção, menos suscetível a mudanças.

const processCreditCardPayment = (amount) => {
  console.log(`Processing credit card payment of ${amount}`);
  // Credit card payment logic
};

const processPayPalPayment = (amount) => {
  console.log(`Processing PayPal payment of ${amount}`);
  // PayPal payment logic
};

const processPayment = (paymentMethod, amount) => {
  paymentMethod(amount);
};

// Use different payment methods without changing the processPayment function
processPayment(processCreditCardPayment, 100);
processPayment(processPayPalPayment, 200);

Resumo

Como você pode ver, os princípios GRASP estão correlacionados com muitos padrões de design conhecidos, bem como com os princípios SOLID. A alta coesão é quase igual ao princípio da responsabilidade única e assim por diante.
Esses princípios não são apenas princípios OOP, mas princípios gerais para programar código limpo e bem arquitetado, seja programação funcional ou OOP.