Diferenças Entre Funções e Procedures em Node.js

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

Aspecto	Funções	Procedures
Uso Principal	Retornar valores únicos.	Executar operações complexas.
Integração SQL	Usadas em consultas SQL.	Chamadas por meio de comandos diretos.
Alterações no DB	Não alteram o banco diretamente.	Podem alterar o banco de dados.
Retorno	Retornam valores.	Podem retornar múltiplos valores por parâmetros de saída.

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.