Repository navigation
Expand file tree
/
Copy pathdatabase.js
More file actions
111 lines (101 loc) · 3.87 KB
/
Copy pathdatabase.js
File metadata and controls
111 lines (101 loc) · 3.87 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
const path = require('path');
require('dotenv').config({ path: path.join(__dirname, '.env') }); // .env fica na mesma pasta deste arquivo
const sql = require('mssql');
const config = {
server: process.env.DB_SERVER,
port: parseInt(process.env.DB_PORT),
database: process.env.DB_DATABASE,
user: process.env.DB_USER,
password: process.env.DB_PASSWORD,
options: {
encrypt: false,
trustServerCertificate: true,
enableArithAbort: true,
appName: 'GERTEC',
},
// min:1 mantém uma conexão quente (evita derrubar/recriar o pool a cada poucos segundos);
// idleTimeoutMillis maior evita o "thrash" que o valor antigo (3s) causava.
pool: { max: 10, min: 1, idleTimeoutMillis: 30000 },
};
let pool = null; // pool atual; pode ser recriado quando a conexão cai
let connecting = null; // promessa de conexão em andamento (evita conexões concorrentes)
// Erros que indicam "conexão caiu" — nesses casos vale recriar o pool e tentar de novo.
// Erros de SQL reais (sintaxe, permissão, etc.) NÃO entram aqui: repetir não adianta.
function isConnectionError(err) {
const code = err && (err.code || (err.originalError && err.originalError.code));
return ['ECONNCLOSED', 'ECONNRESET', 'ESOCKET', 'ETIMEOUT', 'ELOGIN', 'ENOTOPEN']
.includes(code)
|| /closed|terminat|not connected|connection.*(lost|reset)/i.test((err && err.message) || '');
}
async function connectOnce() {
const p = new sql.ConnectionPool(config);
p.on('error', err => {
console.error('❌ Erro no pool SQL:', err.message);
if (pool === p) pool = null; // invalida para forçar reconexão na próxima query
});
await p.connect();
return p;
}
// Conecta com retry/backoff. NÃO fica rejeitado pra sempre: a cada nova query
// que chama getPool() uma nova rodada de tentativas é disparada.
async function connectWithRetry(maxTentativas = 10) {
let ultimo;
for (let t = 1; t <= maxTentativas; t++) {
try {
const p = await connectOnce();
console.log(`Conectado: ${config.server},${config.port} — ${config.database}`);
return p;
} catch (err) {
ultimo = err;
const espera = Math.min(15000, 1000 * Math.pow(2, Math.min(t, 4))); // backoff até 15s
console.error(`Falha ao conectar (tentativa ${t}/${maxTentativas}): ${err.message}. Retry em ${espera / 1000}s`);
await new Promise(r => setTimeout(r, espera));
}
}
throw ultimo;
}
async function getPool() {
if (pool && pool.connected) return pool;
if (!connecting) {
connecting = connectWithRetry()
.then(p => { pool = p; return p; })
.finally(() => { connecting = null; });
}
return connecting;
}
// Dispara a conexão já no boot, mas sem derrubar o processo se o SQL ainda não subiu.
const poolConnect = getPool().catch(err =>
console.error('Boot sem SQL ainda (vai reconectar sob demanda):', err.message));
async function query(queryStr, params = {}) {
let ultimoErro;
for (let tentativa = 1; tentativa <= 2; tentativa++) {
try {
const p = await getPool();
const request = p.request();
for (const [key, val] of Object.entries(params)) request.input(key, val);
const result = await request.query(queryStr);
return result.recordset;
} catch (err) {
ultimoErro = err;
if (isConnectionError(err)) {
console.error(`Query falhou por conexão (tentativa ${tentativa}/2): ${err.message}. Reconectando...`);
pool = null; // invalida e força novo pool na próxima volta
connecting = null;
continue;
}
throw err; // erro de SQL real — propaga sem repetir
}
}
throw ultimoErro;
}
async function queryOne(queryStr, params = {}) {
const rows = await query(queryStr, params);
return rows[0] || null;
}
module.exports = {
sql,
poolConnect,
query,
queryOne,
get pool() { return pool; }, // compat: ninguém usa direto hoje, mas mantém a API
};