npm package: @scalesentinel/datastoreforge
Description: Ferramentas para escalar bancos de dados existentes
Author: Suissa
Latest version: 1.0.4

![AutoScaleDB logo](https://i.imgur.com/zzERlC4.png)

# 🚀 AutoScaleDB


AutoScaleDB é uma solução ideal para escalar Bancos de Dados Relacionais, permitindo a reutilização de sua infraestrutura existente. Com suporte a sharding, replicas e separação CQRS (Command Query Responsibility Segregation), o AutoScaleDB garante um balanceamento eficiente da carga de trabalho entre leitura e escrita.

## 🌟 Recursos

Escalabilidade Automática: Distribui a carga entre várias réplicas automaticamente.

Suporte a Sharding: Fragmentação automática para melhor desempenho.

Separação CQRS: Bancos de escrita e leitura otimizados para diferentes cargas de trabalho.

Reutilização de Infraestrutura: Adapte seu banco de dados atual para escalar sem precisar de novas tecnologias.

## 🛠️ Instalação

```bash
npm install @scalesentinel/datastoreforge
```

## Uso Básico

Crie um .env

```env
# Define qual banco usar (mysql, mariadb, postgres, sqlserver)
STORAGE_SCALE_DATABASE=mysql

# Modos: single-db, readdb, writedb, no-sharding
STORAGE_SCALE_MODE=single-db

# Ativar ou desativar sharding (true ou false)
STORAGE_SCALE_SHARDING=true

# Número de shards (padrão 3)
STORAGE_SCALE_SHARDING_COUNT=2

# Credenciais do banco
DB_PASSWORD=senha123
MASTER_USER=replicator
MASTER_PASSWORD=replica123
```


```ts
import { AutoScaleDB } from "@scalesentinel/datastoreforge";

// Escala com sharding e replicação
AutoScaleDB.scale("mysql");

// Escala sem sharding
AutoScaleDB.scale("mariadb", "no-sharding");

// Banco apenas de escrita, sem sharding
AutoScaleDB.scale("mariadb", "writedb", "no-sharding");

// Banco apenas de escrita
AutoScaleDB.scale("postgres", "writedb");

// Banco apenas de leitura
AutoScaleDB.scale("sqlserver", "readdb");
```

## 🔧 Modos de Operação

| **Modo**  | **Descrição** |
|----------------|------------------------------------------------|
| **default**   | Sharding + Replicação (3 shards) |
| **no-sharding**      | Apenas replicação mestre-escravo |
| **writedb**    | Configura nó principal como super_read_only (otimizado para escrita) |
| **readdb**     | Configura nó secundário como read_only (otimizado para leitura) |


## 🔑 Conceitos-Chave

### 1. 🔄 Replicas

As réplicas são utilizadas para distribuir a carga de leitura, garantindo que consultas complexas não impactem o desempenho da escrita.

Leitura otimizada: Índices especializados são usados para melhorar a performance.

Failover automático: Se uma réplica falha, o sistema redireciona automaticamente para outra disponível.

Escalabilidade horizontal: Adição dinâmica de novas réplicas conforme a demanda.

### 2. 📖✍️ Separação CQRS(Command Query Responsibility Segregation)

| **Tipo**  | **Características** |
|----------------|------------------------------------------------|
| **writedb**   | Prioriza inserções/atualizações, menos índices, replicação assíncrona. |
| **readdb**      | Consultas rápidas, índices otimizados, consistência eventual. |

O AutoScaleDB permite dividir as operações entre bancos otimizados para escrita e leitura:

#### Banco de escrita (writedb):

Priorizado para inserções e atualizações.

Pode ter menos índices para maior desempenho em transações intensivas.

Suporte a replicação assíncrona para evitar bloqueios.

#### Banco de leitura (readdb):

Priorizado para consultas rápidas.

Índices otimizados para buscas e relatórios.

Mantém consistência eventual através de replicação.


##### 🚀 Explicação


✅ MySQL / MariaDB: 
  -  Usa SET GLOBAL read_only = ON/OFF.
✅ PostgreSQL: 
  - Adiciona default_transaction_read_only = on/off ao arquivo de configuração.
  - Executa pg_ctl reload para aplicar sem reiniciar o banco.
✅ SQL Server
  - Usa ALTER DATABASE master SET READ_ONLY ON/OFF.
✅ MariaDB
  - Mesmo comportamento do MySQL.

## 3. 🧩 Sharding

O sharding permite dividir os dados entre múltiplos servidores, evitando gargalos de performance.

Sharding automático: Configuração simplificada para distribuir dados de forma eficiente.

Balanceamento dinâmico: O AutoScaleDB gerencia a distribuição sem necessidade de configuração manual.

Compatível com múltiplos bancos: Pode ser utilizado em MySQL, PostgreSQL, MariaDB e SQL Server.


| **Banco**  | **Estratégia** | **Implementação** |
|----------------|------------------------------------------------|
| **MySQL**   | Partitioning + Custom Hashing | Divisão de tabelas por função hash |
| **MariaDB**      | Galera Cluster + Weighted Sharding | Configuração de pesos nos nós |
| **SQLServer**      | Partitioned Tables + Scheme | Funções e esquemas de partição |


🏆 Comparação com Outras Implementações:


| **Critério**  | **SQL Server** | **MySQL/MariaDB** | **PostgreSQL** |
|----------------|------------------------------------------------|
| **Estratégia**   | Partição por intervalo | Hash em índice secundário |  Hash em PK/índice  |
| **Escalabilidade**      | Limitada a intervalos predefinidos | Dinâmica via redistribuição | Flexível com fallback |
| **Complexidade de Consulta**      | Requer conhecimento dos intervalos | Roteamento automático por hash|  Distribuição transparente  |
| **Manutenção**   | Alta (rebalanceamento manual) | Média (depende de índices) | Baixa (gerenciamento automático) |
| **Caso de Uso Ideal**   | Dados temporais/sequenciais | Cargas heterogêneas |  Schemas complexos  |
			
			
			
			
		
			










## 🛠 Configuração Avançada

O AutoScaleDB permite configurações personalizadas para bancos de escrita:

```ts
AutoScaleDB.config("writedb", {
    maxConnections: 500, // Número máximo de conexões concorrentes
    transactionIsolation: "SERIALIZABLE", // Nível de isolamento para evitar concorrência
    replication: {
        mode: "async", // Replicação assíncrona para melhor desempenho
        replicas: ["db-writer-1", "db-writer-2"] // Réplicas específicas para escrita
    }
});
```

### 🏢SQL Server:
```ts
AutoScaleDB.config("writedb", {
    dbType: "sqlserver",
    maxConnections: 800,
    transactionIsolation: "SNAPSHOT",
    replication: {
        mode: "async",
        replicas: ["sql-writer-1", "sql-writer-2"]
    },
    queryOptimizer: "AUTO",
    tempDBOptimized: true
});
```

### 🐬MySQL:
```ts
AutoScaleDB.config("writedb", {
    dbType: "mysql",
    maxConnections: 1500,
    transactionIsolation: "READ COMMITTED",
    replication: {
        mode: "semi-sync",
        replicas: ["mysql-writer-1", "mysql-writer-2"]
    },
    cacheSize: "512MB",
    innodbFlushLogAtTrxCommit: 2
});
```

### 🏛️ MariaDB: 
```ts
AutoScaleDB.config("writedb", {
    dbType: "mariadb",
    maxConnections: 1200,
    transactionIsolation: "READ COMMITTED",
    replication: {
        mode: "async",
        replicas: ["mariadb-writer-1", "mariadb-writer-2"]
    },
    threadHandling: "pool-of-threads",
    maxHeapTableSize: "256MB"
});
```


O AutoScaleDB é a solução ideal para escalar bancos relacionais sem precisar mudar sua infraestrutura. Ele permite que você otimize operações de leitura e escrita, implemente sharding e mantenha alta disponibilidade com réplicas eficientes.

> Experimente agora e leve a escalabilidade do seu banco de dados para o próximo nível!



## Sharding

```mermaid
graph TD
  A[Início] --> B{Existem colunas sugeridas?}
  B -->|Sim| C[Procurar índice correspondente]
  B -->|Não| D[Pegar primeiro índice disponível]
  C --> E{Encontrou?}
  E -->|Sim| F[Usar coluna]
  E -->|Não| D
  D --> G{Existem índices?}
  G -->|Sim| H[Extrair coluna do índice]
  G -->|Não| I[Criar índice automático]
```

### Banco TimeSeries

Eu escolhi como banco padrão de TimeSeries o TimeScale depois de fazer uma análise comparando-o com o Apache Druid.