burdy/src/server/drivers/sqlite-patch.js

Open Source Headless Platform

"use strict";
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());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.sqlitePatch = void 0;
const async_mutex_1 = require("async-mutex");
const typeorm_1 = require("typeorm");
const DriverFactory_1 = require("typeorm/driver/DriverFactory");
const BetterSqlite3QueryRunner_1 = require("typeorm/driver/better-sqlite3/BetterSqlite3QueryRunner");
const BetterSqlite3Driver_1 = require("typeorm/driver/better-sqlite3/BetterSqlite3Driver");
const mutex = new async_mutex_1.Mutex();
class BetterSqliteQueryRunner extends BetterSqlite3QueryRunner_1.BetterSqlite3QueryRunner {
    releaseMutex() {
        if (this.releaser) {
            this.releaser();
            this.releaser = null;
        }
    }
    startTransaction() {
        const _super = Object.create(null, {
            startTransaction: { get: () => super.startTransaction }
        });
        return __awaiter(this, void 0, void 0, function* () {
            this.releaser = yield mutex.acquire();
            return _super.startTransaction.call(this);
        });
    }
    commitTransaction() {
        const _super = Object.create(null, {
            commitTransaction: { get: () => super.commitTransaction }
        });
        return __awaiter(this, void 0, void 0, function* () {
            yield _super.commitTransaction.call(this);
            this.releaseMutex();
        });
    }
    rollbackTransaction() {
        const _super = Object.create(null, {
            rollbackTransaction: { get: () => super.rollbackTransaction }
        });
        return __awaiter(this, void 0, void 0, function* () {
            yield _super.rollbackTransaction.call(this);
            this.releaseMutex();
        });
    }
    release() {
        if (!this.isTransactionActive) {
            this.releaseMutex();
        }
        return super.release();
    }
}
class BetterSqliteDriver extends BetterSqlite3Driver_1.BetterSqlite3Driver {
    constructor() {
        super(...arguments);
        this.supportedDataTypes = [
            'int',
            'integer',
            'tinyint',
            'smallint',
            'mediumint',
            'bigint',
            'unsigned big int',
            'int2',
            'int8',
            'integer',
            'character',
            'varchar',
            'varying character',
            'nchar',
            'native character',
            'nvarchar',
            'text',
            'clob',
            'text',
            'blob',
            'real',
            'double',
            'double precision',
            'float',
            'real',
            'numeric',
            'decimal',
            'boolean',
            'date',
            'time',
            'datetime',
            'json',
        ];
    }
    createQueryRunner(mode = 'master') {
        if (mode === 'slave') {
            return new BetterSqliteQueryRunner(this);
        }
        if (!this.queryRunner) {
            this.queryRunner = new BetterSqliteQueryRunner(this);
        }
        return this.queryRunner;
    }
    preparePersistentValue(value, columnMetadata) {
        if (columnMetadata.type === 'json') {
            return JSON.stringify(value);
        }
        return super.preparePersistentValue(value, columnMetadata);
    }
    prepareHydratedValue(value, columnMetadata) {
        if (columnMetadata.type === 'json') {
            return typeof value === "string" ? JSON.parse(value) : value;
        }
        return super.prepareHydratedValue(value, columnMetadata);
    }
    normalizeType(column) {
        if (column.type === 'json') {
            return 'text';
        }
        return super.normalizeType(column);
    }
}
class DriverFactoryPatched extends DriverFactory_1.DriverFactory {
    create(connection) {
        const type = connection.options.type;
        if (type.includes('sqlite')) {
            return new BetterSqliteDriver(connection);
        }
        return super.create(connection);
    }
}
class ConnectionPatched extends typeorm_1.Connection {
    constructor(connectionOptions) {
        super(connectionOptions);
        const that = this;
        that.driver = new DriverFactoryPatched().create(this);
    }
}
// Provides SQLite transaction pool and forces better-sqlite3 to be used
const sqlitePatch = () => {
    const createConnection = typeorm_1.ConnectionManager.prototype.create;
    typeorm_1.ConnectionManager.prototype.create = function (options) {
        const defaultConnection = createConnection.apply(this, [
            options,
        ]);
        const connection = new ConnectionPatched(options);
        this.connectionMap.set(defaultConnection.name, connection);
        return connection;
    };
};
exports.sqlitePatch = sqlitePatch;