queryforge/dist/connections/SQLiteConnectionManager.js

A powerful, type-safe SQL query builder for Node.js with support for MySQL, PostgreSQL, and SQLite. Features fluent API, transaction management, and connection pooling.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.SQLiteConnectionManager = void 0;
const sqlite3_1 = require("sqlite3");
class SQLiteConnectionManager {
    constructor(config) {
        this.db = null;
        this.inTransaction = false;
        this.config = config;
    }
    async connect() {
        if (this.db) {
            return;
        }
        return new Promise((resolve, reject) => {
            this.db = new sqlite3_1.Database(this.config.database, err => {
                if (err) {
                    reject(new Error(`SQLite connection failed: ${err.message}`));
                }
                else {
                    resolve();
                }
            });
        });
    }
    async disconnect() {
        if (!this.db) {
            return;
        }
        return new Promise((resolve, reject) => {
            this.db.close(err => {
                if (err) {
                    reject(new Error(`SQLite disconnect failed: ${err.message}`));
                }
                else {
                    this.db = null;
                    resolve();
                }
            });
        });
    }
    async query(sql, parameters = []) {
        if (!this.db) {
            throw new Error('SQLite connection not established');
        }
        return new Promise((resolve, reject) => {
            const isSelect = sql.trim().toLowerCase().startsWith('select');
            if (isSelect) {
                this.db.all(sql, parameters, (err, rows) => {
                    if (err) {
                        reject(new Error(`SQLite query failed: ${err.message}`));
                    }
                    else {
                        resolve({
                            rows: rows,
                            count: rows.length,
                            query: sql,
                            parameters,
                        });
                    }
                });
            }
            else {
                this.db.run(sql, parameters, function (err) {
                    if (err) {
                        reject(new Error(`SQLite query failed: ${err.message}`));
                    }
                    else {
                        resolve({
                            rows: [],
                            count: this.changes,
                            query: sql,
                            parameters,
                        });
                    }
                });
            }
        });
    }
    async beginTransaction() {
        if (!this.db) {
            throw new Error('SQLite connection not established');
        }
        if (this.inTransaction) {
            throw new Error('Transaction already in progress');
        }
        return new Promise((resolve, reject) => {
            this.db.run('BEGIN TRANSACTION', err => {
                if (err) {
                    reject(new Error(`Begin transaction failed: ${err.message}`));
                }
                else {
                    this.inTransaction = true;
                    resolve();
                }
            });
        });
    }
    async commit() {
        if (!this.db) {
            throw new Error('SQLite connection not established');
        }
        if (!this.inTransaction) {
            throw new Error('No active transaction');
        }
        return new Promise((resolve, reject) => {
            this.db.run('COMMIT', err => {
                if (err) {
                    reject(new Error(`Commit failed: ${err.message}`));
                }
                else {
                    this.inTransaction = false;
                    resolve();
                }
            });
        });
    }
    async rollback() {
        if (!this.db) {
            throw new Error('SQLite connection not established');
        }
        if (!this.inTransaction) {
            throw new Error('No active transaction');
        }
        return new Promise((resolve, reject) => {
            this.db.run('ROLLBACK', err => {
                if (err) {
                    reject(new Error(`Rollback failed: ${err.message}`));
                }
                else {
                    this.inTransaction = false;
                    resolve();
                }
            });
        });
    }
    isConnected() {
        return this.db !== null;
    }
}
exports.SQLiteConnectionManager = SQLiteConnectionManager;
//# sourceMappingURL=SQLiteConnectionManager.js.map