tspace-mysql/dist/lib/core/Driver/sqlite/SqliteDriver.js

Tspace MySQL is a promise-based ORM for Node.js, designed with modern TypeScript and providing type safety for schema databases.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.SqliteDriver = void 0;
const path_1 = __importDefault(require("path"));
const fs_1 = __importDefault(require("fs"));
const __1 = require("..");
const SqliteQueryBuilder_1 = require("./SqliteQueryBuilder");
class SqliteDriver extends __1.BaseDriver {
    constructor(options) {
        super();
        this.options = options;
    }
    connect() {
        const options = this.options;
        const sqlite = this.import("better-sqlite3");
        const configs = {
            path: path_1.default.resolve(options.database),
            dir: path_1.default.dirname(path_1.default.resolve(options.database))
        };
        if (!fs_1.default.existsSync(configs.dir)) {
            fs_1.default.mkdirSync(configs.dir, { recursive: true });
        }
        this.pool = new sqlite(configs.path);
        this.poolTrx = new sqlite(configs.path);
        return {
            database: () => options.database,
            on: (event, data) => this.on(event, data),
            queryBuilder: SqliteQueryBuilder_1.SqliteQueryBuilder,
            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) => {
            try {
                let results = null;
                const command = this._detectQueryType(sql);
                if (command === 'SELECT') {
                    results = this.pool.prepare(sql).all();
                }
                else if (command === 'UNKNOWN') {
                    results = this.pool.exec(sql);
                }
                else {
                    results = this.pool.prepare(sql).run();
                }
                this._detectEventQuery({ start, sql });
                this.meta(results, sql);
                return resolve(this.returning(results));
            }
            catch (err) {
                return reject(err);
            }
        });
    }
    async _connection() {
        const conn = await this.poolTrx;
        let started = false;
        let closed = false;
        let commited = false;
        let rollbacked = false;
        const query = async (sql) => {
            const start = Date.now();
            let results = null;
            const command = this._detectQueryType(sql);
            if (command === 'SELECT') {
                results = conn.prepare(sql).all();
            }
            else if (command === 'UNKNOWN') {
                results = conn.exec(sql);
            }
            else {
                results = conn.prepare(sql).run();
            }
            this._detectEventQuery({ start, sql });
            this.meta(results, sql);
            return this.returning(results);
        };
        const startTransaction = async () => {
            await conn.exec('BEGIN');
            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.exec('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.exec('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;
            }
            started = false;
            closed = true;
            return;
        };
        const release = async () => {
            if (closed)
                return;
            return;
        };
        return {
            on: (event, data) => this.on(event, data),
            queryBuilder: SqliteQueryBuilder_1.SqliteQueryBuilder,
            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);
        if (command === "INSERT") {
            const insertIds = results.changes > 1
                ? [...Array(results.changes)].map((_, i) => results.lastInsertRowid - i)
                : [results.lastInsertRowid];
            results.$meta = {
                command,
                insertIds,
                affected: true,
            };
        }
        if (command === "UPDATE" || command === "DELETE") {
            results.$meta = {
                command,
                insertIds: [],
                affected: Boolean(results.changes),
            };
        }
    }
    returning(results) {
        if (Array.isArray(results))
            return results;
        return results;
    }
}
exports.SqliteDriver = SqliteDriver;
//# sourceMappingURL=SqliteDriver.js.map