node-firebird-transaction-easy
Version:
199 lines (198 loc) • 7.97 kB
JavaScript
;
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const node_firebird_1 = __importDefault(require("node-firebird"));
//errorLog.level = 'debug';
class FirebirdTransaction {
constructor(_connOptions) {
this.connOptions = _connOptions;
this.db = undefined;
this.transaction = undefined;
}
/**
* Get the firebird connection
* @returns connection
*/
getDbConnection() {
return __awaiter(this, void 0, void 0, function* () {
var connOptions = this.connOptions;
return new Promise(function (resolve, reject) {
node_firebird_1.default.attach(connOptions, function (err, db) {
if (err) {
//errorLog.error('...Reject: ', err);
reject(err);
return;
}
else {
resolve(db);
}
});
});
});
}
/**
* Start a transaction in DB
* @param isSequentialRead Define if the transaction is ISOLATION_REPEATABLE_READ, or ISOLATION_READ_COMMITED
*/
startTransaction(isSequentialRead = undefined) {
return __awaiter(this, void 0, void 0, function* () {
var createTransaction = function (dbConn, _isSequentialRead) {
var isolationLevel = node_firebird_1.default.ISOLATION_READ_COMMITED;
if (_isSequentialRead) {
isolationLevel = node_firebird_1.default.ISOLATION_REPEATABLE_READ;
}
return new Promise(function (resolve, reject) {
//if (this._gerarLog) console.trace('FbTransaction() >> StartTransaction()...');
dbConn.transaction(isolationLevel, function (err, transaction) {
if (err) {
dbConn.detach();
reject(err);
return;
}
else {
resolve(transaction);
return;
}
});
});
};
if (!this.db) {
this.db = yield this.getDbConnection();
}
this.transaction = yield createTransaction(this.db, isSequentialRead);
});
}
/**
* Função para fazer a leitura dos blobs texto existentes no SQL
* @param rows Linhas lidas do banco de dados para carregar os blobs
* @param blobFields campos blobs a serem carregados
* @returns Lista de linhas com os Blobs junto
*/
readBlobsFromRows(rows, blobFields) {
return __awaiter(this, void 0, void 0, function* () {
for (var i = 0; i < rows.length; i++) { // lê a lista que retorna do BD
for (let x = 0; x < blobFields.length; x++) {
const field = blobFields[x];
let blobValue = yield this.readBlobPromise(rows[i], field);
rows[i][field] = blobValue;
}
}
return rows; // retorna a lista da consulta
});
}
/**
* Carrega do banco de dados o bloco
* @param row
* @param field
* @returns
*/
readBlobPromise(row, field) {
return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => {
if (row[field] && row[field] != null && row[field] != undefined) {
row[field](function (err, name, eventEmitter) {
let buffers = [];
eventEmitter.on('data', (chunk) => {
buffers.push(chunk);
});
eventEmitter.once('end', () => {
let buffer = buffers.join('');
resolve(buffer);
});
eventEmitter.once('error', (err) => {
reject(err);
});
});
}
else {
resolve(null);
}
});
});
}
/**
*
* @param sql
* @param params
* @param blobFields
* @returns
*/
execute(sql, params, blobFields) {
return __awaiter(this, void 0, void 0, function* () {
var _this = this;
var localExec = function (transaction, _sql, _params, _blobFields) {
return __awaiter(this, void 0, void 0, function* () {
return new Promise(function (resolve, reject) {
return __awaiter(this, void 0, void 0, function* () {
transaction.query(_sql, _params, (err, result) => __awaiter(this, void 0, void 0, function* () {
if (err) {
transaction.rollback();
reject(err);
return;
}
else {
if (_blobFields) {
result = yield _this.readBlobsFromRows(result, _blobFields);
}
resolve(result);
}
}));
});
});
});
};
if (!this.transaction)
this.startTransaction(false);
return yield localExec(this.transaction, sql, params, blobFields);
});
}
/**
*
*/
commit() {
return __awaiter(this, void 0, void 0, function* () {
var commit = function (dbConn, transaction) {
return new Promise(function (resolve, reject) {
transaction.commit(function (err) {
if (err) {
transaction.rollback();
reject(err);
}
else {
dbConn.detach();
resolve();
}
});
});
};
yield commit(this.db, this.transaction);
this.transaction = undefined;
this.db = undefined;
});
}
/**
*
*/
rollback() {
return __awaiter(this, void 0, void 0, function* () {
if (this.transaction) {
this.transaction.rollback();
this.db.detach();
}
this.transaction = undefined;
this.db = undefined;
});
}
}
exports.default = FirebirdTransaction;