Dicas para Usar Funções e Procedures em Node.js (Guia Definitivo)

A arquitetura de uma aplicação backend moderna frequentemente levanta um debate clássico: onde deve residir a lógica de processamento mais pesada? Na camada da aplicação ou diretamente no banco de dados? Embora a tendência atual favoreça manter o controle no código, ignorar o poder nativo do seu banco relacional pode resultar em perda de performance, gargalos de rede e consultas ineficientes.

É exatamente nesse cenário de otimização que aplicar as melhores dicas para usar Funções e Procedures em Node.js se torna um diferencial técnico. Neste guia definitivo, vamos desmistificar o uso dessas estruturas, explorando desde as diferenças fundamentais até hacks avançados de integração com ORMs modernos como TypeORM, Drizzle e Prisma. Se você quer escrever um backend mais seguro, rápido e escalável, este artigo é para você.

Com a popularidade crescente de Node.js e TypeORM, a necessidade de gerenciar funções e procedures no banco de dados de forma eficiente tem se tornado cada vez mais comum. TypeORM, sendo um poderoso ORM (Object-Relational Mapping), oferece suporte para lidar com essas estruturas de maneira organizada e escalável.

Dicas para Usar Funções e Procedures em Node.js

Este artigo explora as diferenças entre funções e procedures no contexto de Node.js e TypeORM, além de boas práticas de versionamento para manter consistência e escalabilidade em seus projetos.

Funções e Procedures no Banco de Dados

Embora funções e procedures sejam criadas e mantidas no banco de dados, sua integração com Node.js e TypeORM pode facilitar sua execução e gerenciamento.

Diferenças Fundamentais

Exemplo com Funções

Função SQL para calcular imposto:

CREATE FUNCTION CalculateTax(subtotal DECIMAL(10,2))
RETURNS DECIMAL(10,2)
BEGIN
    RETURN subtotal * 0.2;
END;

Uso no TypeORM:

import { DataSource } from 'typeorm';

const dataSource = new DataSource({
    type: 'mysql',
    host: 'localhost',
    username: 'root',
    password: 'password',
    database: 'example_db',
});

dataSource.initialize().then(async () => {
    const result = await dataSource.query('SELECT CalculateTax(100) AS tax');
    console.log(result); // [{ tax: 20 }]
});

Exemplo com Procedures

Procedure SQL para atualizar estoque:

DELIMITER //
CREATE PROCEDURE UpdateStock(IN product_id INT, IN quantity INT)
BEGIN
    UPDATE inventory SET stock = stock + quantity WHERE id = product_id;
END //
DELIMITER ;

Uso no TypeORM:

await dataSource.query('CALL UpdateStock(?, ?)', [101, 50]);

Quando Usar Funções ou Procedures em Node.js

Funções

Cenários:

1. Cálculos simples e reutilizáveis.
2. Manipulação de strings.
3. Usadas diretamente em consultas SQL.

Vantagens:

• Simplicidade de uso em SELECT.
• Compatibilidade com diferentes partes da consulta SQL.

Exemplo Prático com TypeORM

const result = await dataSource.query('SELECT FormatDate(?) AS formatted_date', ['2024-01-01']);
console.log(result); // [{ formatted_date: '01/01/2024' }]

Procedures

Cenários:

1. Fluxos complexos que envolvem várias etapas.
2. Alterações no banco de dados (INSERT, UPDATE, DELETE).
3. Automação de processos repetitivos.

Vantagens:

• Redução de lógica no backend.
• Centralização de operações críticas no banco.

Exemplo Prático com TypeORM

await dataSource.query('CALL GenerateMonthlyReport(?, ?)', [12, 2023]);

Evolução dos ORMs – Executando Procedures no Prisma e Drizzle ORM

Enquanto o TypeORM consolidou seu espaço, projetos mais recentes têm adotado alternativas modernas que focam em type-safety extremo, como Drizzle ORM e Prisma. Mostrar como lidar com DB Objects nessas ferramentas agrega muito valor:

• No Drizzle ORM: Como o Drizzle é muito próximo do SQL puro, a execução de procedures é feita de forma extremamente limpa usando o template literal sql.

  import { sql } from 'drizzle-orm';
  // Chamando uma procedure de atualização de estoque de forma segura
  await db.execute(sql`CALL UpdateStock(${productId}, ${quantity})`);
  

• No Prisma: O Prisma utiliza o método $executeRaw ou $queryRaw para chamadas diretas ao banco.

  // Executando uma função escalar
  const result = await prisma.$queryRaw`SELECT CalculateTax(${subtotal}) AS tax`;
  

Boas Práticas de Versionamento com Node.js e TypeORM

Gerenciar a evolução de funções e procedures é essencial para evitar problemas em ambientes de produção. Com Node.js e TypeORM, você pode usar ferramentas e estratégias específicas para versionamento.

1. Migrations no TypeORM

O TypeORM suporta migrations, que são scripts para gerenciar alterações no banco de dados.

Exemplo de Migration para Adicionar uma Função

import { MigrationInterface, QueryRunner } from 'typeorm';

export class AddCalculateTaxFunction1681023456789 implements MigrationInterface {
    public async up(queryRunner: QueryRunner): Promise<void> {
        await queryRunner.query(`
            CREATE FUNCTION CalculateTax(subtotal DECIMAL(10,2))
            RETURNS DECIMAL(10,2)
            BEGIN
                RETURN subtotal * 0.2;
            END;
        `);
    }

    public async down(queryRunner: QueryRunner): Promise<void> {
        await queryRunner.query('DROP FUNCTION IF EXISTS CalculateTax');
    }
}

2. Script de Rollback

Sempre inclua um script para reverter alterações.

Exemplo:

export class AddUpdateStockProcedure1681023456790 implements MigrationInterface {
    public async up(queryRunner: QueryRunner): Promise<void> {
        await queryRunner.query(`
            CREATE PROCEDURE UpdateStock(IN product_id INT, IN quantity INT)
            BEGIN
                UPDATE inventory SET stock = stock + quantity WHERE id = product_id;
            END;
        `);
    }

    public async down(queryRunner: QueryRunner): Promise<void> {
        await queryRunner.query('DROP PROCEDURE IF EXISTS UpdateStock');
    }
}

3. Documentação e Comentários

• Documente o propósito e as alterações de cada função ou procedure.
• Use comentários nos arquivos de migration.

4. Teste Automatizado de Funções e Procedures

• Execute testes diretamente no banco usando ferramentas como Jest.

Exemplo de Teste com Jest:

import { DataSource } from 'typeorm';

describe('Database Functions', () => {
    let dataSource: DataSource;

    beforeAll(async () => {
        dataSource = new DataSource({ /* Configurações */ });
        await dataSource.initialize();
    });

    afterAll(async () => {
        await dataSource.destroy();
    });

    it('should calculate tax correctly', async () => {
        const result = await dataSource.query('SELECT CalculateTax(100) AS tax');
        expect(result[0].tax).toBe(20);
    });
});

5. Automação com CI/CD

• Integre migrations e testes de banco em pipelines CI/CD (e.g., Jenkins, GitHub Actions).
• Execute migrations antes de publicar novas versões.

Hacks Avançados

1. Usar Parâmetros Dinâmicos em Funções

Crie funções flexíveis com parâmetros opcionais.

CREATE FUNCTION CalculateTaxDynamic(subtotal DECIMAL(10,2), rate DECIMAL(5,2) DEFAULT 0.2)
RETURNS DECIMAL(10,2)
BEGIN
    RETURN subtotal * rate;
END;

2. Combinar Funções com Views

Simplifique consultas complexas usando funções dentro de views.

CREATE VIEW monthly_sales AS
SELECT
    MONTH(sale_date) AS month,
    YEAR(sale_date) AS year,
    CalculateTax(SUM(total)) AS tax
FROM sales
GROUP BY MONTH(sale_date), YEAR(sale_date);

3. Monitoramento de Funções e Procedures

Armazene metadados de uso:

CREATE TABLE function_usage (
    id INT AUTO_INCREMENT PRIMARY KEY,
    function_name VARCHAR(255),
    called_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

Adicione tracking nas migrations:

await queryRunner.query(`
    CREATE TRIGGER track_function_usage
    AFTER CALL ON CalculateTax
    FOR EACH ROW
    BEGIN
        INSERT INTO function_usage (function_name) VALUES ('CalculateTax');
    END;
`);