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

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.

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]);

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;
`);

Conclusão

Funções e procedures são componentes essenciais para gerenciar operações complexas no banco de dados. Combinando o poder do Node.js e TypeORM, é possível integrá-las de maneira eficiente e escalável. Seguir boas práticas de versionamento e usar hacks avançados garantem que seu sistema permaneça consistente e fácil de manter.