tspace-mysql
Version:
Tspace MySQL is a promise-based ORM for Node.js, designed with modern TypeScript and providing type safety for schema databases.
214 lines • 7.14 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.MysqlDriver = void 0;
const mysql2_1 = __importDefault(require("mysql2"));
const __1 = require("..");
const MysqlQueryBuilder_1 = require("./MysqlQueryBuilder");
class MysqlDriver extends __1.BaseDriver {
constructor(options) {
super();
this.options = options;
}
connect() {
const options = this.options;
const configs = {
host: options.host,
port: options.port,
database: options.database,
user: options.user || options.username,
password: options.password,
connectionLimit: options.connectionLimit ?? 20,
connectTimeout: options.connectTimeout ?? 1000 * 60,
dateStrings: options.dateStrings ?? false,
waitForConnections: true,
queueLimit: 0,
enableKeepAlive: true,
keepAliveInitialDelay: 1000 * 20,
maxIdle: Math.max(2, Math.floor((options.connectionLimit ?? 20) / 3)),
idleTimeout: 1000 * 60,
charset: 'utf8mb4',
};
this.pool = mysql2_1.default.createPool(configs);
this.poolTrx = mysql2_1.default.createPool({
...configs,
connectionLimit: configs.connectionLimit * 1.5
});
this.pool.getConnection((err) => {
if (!err)
return;
if (err?.message?.includes('Unknown database')) {
const db = mysql2_1.default.createConnection({
host: options.host,
port: options.port,
user: options.user || options.username,
password: options.password,
});
const sql = new MysqlQueryBuilder_1.MysqlQueryBuilder({}).createDatabase(options.database);
db.query(sql, () => db.end());
return;
}
const message = this._messageError.bind(this);
process.nextTick(() => {
if (String(err.message).includes('Pool is close')) {
return;
}
console.log(message(err.message == null || err.message === '' ? err.code : err.message));
if (this.options.CONNECTION_ERROR)
return process.exit();
});
return;
});
this.pool.on("release", (connection) => {
this.emit("release", connection);
});
return {
database: () => options.database,
on: (event, data) => this.on(event, data),
queryBuilder: MysqlQueryBuilder_1.MysqlQueryBuilder,
query: (sql) => this._query(sql),
connection: () => this._connection(),
end: () => this._end()
};
}
disconnect(pool) {
if (pool == null)
return;
pool?.end(() => {
pool = undefined;
});
}
_query(sql) {
const start = Date.now();
return new Promise((resolve, reject) => {
return this.pool.query(sql, (err, results) => {
if (err)
return reject(err);
this._detectEventQuery({ start, sql });
this.meta(results, sql);
return resolve(this.returning(results));
});
});
}
async _connection() {
const conn = await this.poolTrx.promise().getConnection();
let started = false;
let closed = false;
let commited = false;
let rollbacked = false;
const query = async (sql) => {
const start = Date.now();
const [results] = await conn.query(sql);
this._detectEventQuery({ start, sql });
this.meta(results, sql);
return this.returning(results);
};
const startTransaction = async () => {
await conn.beginTransaction();
started = true;
closed = false;
return;
};
const commit = async () => {
if (closed) {
throw new Error(this.MESSAGE_TRX_CLOSED);
}
if (!started) {
throw new Error(this.MESSAGE_TRX_NOT_STARTED);
}
commited = true;
await conn.commit();
await end();
return;
};
const rollback = async () => {
if (closed) {
throw new Error(this.MESSAGE_TRX_CLOSED);
}
if (!started) {
throw new Error(this.MESSAGE_TRX_NOT_STARTED);
}
rollbacked = true;
await conn.rollback();
await end();
return;
};
const end = async () => {
if (closed)
return;
if (!started) {
throw new Error(this.MESSAGE_TRX_NOT_STARTED);
}
if (!commited && !rollbacked) {
await rollback();
return;
}
await conn.release();
started = false;
closed = true;
return;
};
const release = async () => {
if (closed)
return;
await conn.release();
return;
};
return {
on: (event, data) => this.on(event, data),
queryBuilder: MysqlQueryBuilder_1.MysqlQueryBuilder,
query,
startTransaction,
commit,
rollback,
end,
release
};
}
async _end() {
return new Promise((resolve, reject) => {
return this.pool.end((err) => {
if (err)
return reject(err);
this.pool = undefined;
return resolve();
});
});
}
meta(results, sql) {
if (Array.isArray(results))
return;
if (results.$meta == null)
results.$meta = {};
const command = this._detectQueryType(sql);
results.$meta = {
command
};
if (command === "INSERT") {
const insertIds = results.affectedRows <= 1
? [results.insertId]
: [...Array(results.affectedRows)].map((_, i) => results.insertId + i);
results.$meta = {
...results.$meta,
insertIds,
affected: true,
};
}
if (command === "UPDATE" || command === "DELETE") {
results.$meta = {
...results.$meta,
insertIds: [],
affected: Boolean(results.affectedRows),
};
}
}
returning(results) {
if (Array.isArray(results))
return results;
return results;
}
}
exports.MysqlDriver = MysqlDriver;
//# sourceMappingURL=MysqlDriver.js.map