orcaq 1.0.20

package/.output/server/node_modules/typeorm/driver/sqlite/SqliteDriver.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteDriver = void 0;
+const tslib_1 = require("tslib");
+const promises_1 = tslib_1.__importDefault(require("fs/promises"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const DriverPackageNotInstalledError_1 = require("../../error/DriverPackageNotInstalledError");
+const SqliteQueryRunner_1 = require("./SqliteQueryRunner");
+const PlatformTools_1 = require("../../platform/PlatformTools");
+const AbstractSqliteDriver_1 = require("../sqlite-abstract/AbstractSqliteDriver");
+const PathUtils_1 = require("../../util/PathUtils");
+/**
+ * Organizes communication with sqlite DBMS.
+ */
+class SqliteDriver extends AbstractSqliteDriver_1.AbstractSqliteDriver {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(connection) {
+        super(connection);
+        this.connection = connection;
+        this.options = connection.options;
+        this.database = this.options.database;
+        // load sqlite package
+        this.loadDependencies();
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Closes connection with database.
+     */
+    async disconnect() {
+        return new Promise((ok, fail) => {
+            this.queryRunner = undefined;
+            this.databaseConnection.close((err) => err ? fail(err) : ok());
+        });
+    }
+    /**
+     * Creates a query runner used to execute database queries.
+     */
+    createQueryRunner(mode) {
+        if (!this.queryRunner)
+            this.queryRunner = new SqliteQueryRunner_1.SqliteQueryRunner(this);
+        return this.queryRunner;
+    }
+    normalizeType(column) {
+        if (column.type === Buffer) {
+            return "blob";
+        }
+        return super.normalizeType(column);
+    }
+    async afterConnect() {
+        return this.attachDatabases();
+    }
+    /**
+     * For SQLite, the database may be added in the decorator metadata. It will be a filepath to a database file.
+     */
+    buildTableName(tableName, _schema, database) {
+        if (!database)
+            return tableName;
+        if (this.getAttachedDatabaseHandleByRelativePath(database))
+            return `${this.getAttachedDatabaseHandleByRelativePath(database)}.${tableName}`;
+        if (database === this.options.database)
+            return tableName;
+        // we use the decorated name as supplied when deriving attach handle (ideally without non-portable absolute path)
+        const identifierHash = (0, PathUtils_1.filepathToName)(database);
+        // decorated name will be assumed relative to main database file when non absolute. Paths supplied as absolute won't be portable
+        const absFilepath = (0, PathUtils_1.isAbsolute)(database)
+            ? database
+            : path_1.default.join(this.getMainDatabasePath(), database);
+        this.attachedDatabases[database] = {
+            attachFilepathAbsolute: absFilepath,
+            attachFilepathRelative: database,
+            attachHandle: identifierHash,
+        };
+        return `${identifierHash}.${tableName}`;
+    }
+    // -------------------------------------------------------------------------
+    // Protected Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Creates connection with the database.
+     */
+    async createDatabaseConnection() {
+        if (this.options.flags === undefined ||
+            !(this.options.flags & this.sqlite.OPEN_URI)) {
+            await this.createDatabaseDirectory(this.options.database);
+        }
+        const databaseConnection = await new Promise((ok, fail) => {
+            if (this.options.flags === undefined) {
+                const connection = new this.sqlite.Database(this.options.database, (err) => {
+                    if (err)
+                        return fail(err);
+                    ok(connection);
+                });
+            }
+            else {
+                const connection = new this.sqlite.Database(this.options.database, this.options.flags, (err) => {
+                    if (err)
+                        return fail(err);
+                    ok(connection);
+                });
+            }
+        });
+        // Internal function to run a command on the connection and fail if an error occured.
+        function run(line) {
+            return new Promise((ok, fail) => {
+                databaseConnection.run(line, (err) => {
+                    if (err)
+                        return fail(err);
+                    ok();
+                });
+            });
+        }
+        // in the options, if encryption key for SQLCipher is setted.
+        // Must invoke key pragma before trying to do any other interaction with the database.
+        if (this.options.key) {
+            await run(`PRAGMA key = ${JSON.stringify(this.options.key)}`);
+        }
+        if (this.options.enableWAL) {
+            await run(`PRAGMA journal_mode = WAL`);
+        }
+        if (this.options.busyTimeout &&
+            typeof this.options.busyTimeout === "number" &&
+            this.options.busyTimeout > 0) {
+            await run(`PRAGMA busy_timeout = ${this.options.busyTimeout}`);
+        }
+        // we need to enable foreign keys in sqlite to make sure all foreign key related features
+        // working properly. this also makes onDelete to work with sqlite.
+        await run(`PRAGMA foreign_keys = ON`);
+        return databaseConnection;
+    }
+    /**
+     * If driver dependency is not given explicitly, then try to load it via "require".
+     */
+    loadDependencies() {
+        try {
+            const sqlite = this.options.driver || PlatformTools_1.PlatformTools.load("sqlite3");
+            this.sqlite = sqlite.verbose();
+        }
+        catch (e) {
+            throw new DriverPackageNotInstalledError_1.DriverPackageNotInstalledError("SQLite", "sqlite3");
+        }
+    }
+    /**
+     * Auto creates database directory if it does not exist.
+     */
+    async createDatabaseDirectory(fullPath) {
+        await promises_1.default.mkdir(path_1.default.dirname(fullPath), { recursive: true });
+    }
+    /**
+     * Performs the attaching of the database files. The attachedDatabase should have been populated during calls to #buildTableName
+     * during EntityMetadata production (see EntityMetadata#buildTablePath)
+     *
+     * https://sqlite.org/lang_attach.html
+     */
+    async attachDatabases() {
+        // @todo - possibly check number of databases (but unqueriable at runtime sadly) - https://www.sqlite.org/limits.html#max_attached
+        for await (const { attachHandle, attachFilepathAbsolute, } of Object.values(this.attachedDatabases)) {
+            await this.createDatabaseDirectory(attachFilepathAbsolute);
+            await this.connection.query(`ATTACH "${attachFilepathAbsolute}" AS "${attachHandle}"`);
+        }
+    }
+    getMainDatabasePath() {
+        const optionsDb = this.options.database;
+        return path_1.default.dirname((0, PathUtils_1.isAbsolute)(optionsDb)
+            ? optionsDb
+            : path_1.default.join(process.cwd(), optionsDb));
+    }
+}
+exports.SqliteDriver = SqliteDriver;
+
+//# sourceMappingURL=SqliteDriver.js.map

package/.output/server/node_modules/typeorm/driver/sqlite/SqliteQueryRunner.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteQueryRunner = void 0;
+const ConnectionIsNotSetError_1 = require("../../error/ConnectionIsNotSetError");
+const QueryFailedError_1 = require("../../error/QueryFailedError");
+const QueryRunnerAlreadyReleasedError_1 = require("../../error/QueryRunnerAlreadyReleasedError");
+const QueryResult_1 = require("../../query-runner/QueryResult");
+const Broadcaster_1 = require("../../subscriber/Broadcaster");
+const BroadcasterResult_1 = require("../../subscriber/BroadcasterResult");
+const AbstractSqliteQueryRunner_1 = require("../sqlite-abstract/AbstractSqliteQueryRunner");
+/**
+ * Runs queries on a single sqlite database connection.
+ *
+ * Does not support compose primary keys with autoincrement field.
+ * todo: need to throw exception for this case.
+ */
+class SqliteQueryRunner extends AbstractSqliteQueryRunner_1.AbstractSqliteQueryRunner {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(driver) {
+        super();
+        this.driver = driver;
+        this.connection = driver.connection;
+        this.broadcaster = new Broadcaster_1.Broadcaster(this);
+    }
+    /**
+     * Called before migrations are run.
+     */
+    async beforeMigration() {
+        await this.query(`PRAGMA foreign_keys = OFF`);
+    }
+    /**
+     * Called after migrations are run.
+     */
+    async afterMigration() {
+        await this.query(`PRAGMA foreign_keys = ON`);
+    }
+    /**
+     * Executes a given SQL query.
+     */
+    async query(query, parameters, useStructuredResult = false) {
+        if (this.isReleased)
+            throw new QueryRunnerAlreadyReleasedError_1.QueryRunnerAlreadyReleasedError();
+        const connection = this.driver.connection;
+        const options = connection.options;
+        const maxQueryExecutionTime = this.driver.options.maxQueryExecutionTime;
+        const broadcaster = this.broadcaster;
+        if (!connection.isInitialized) {
+            throw new ConnectionIsNotSetError_1.ConnectionIsNotSetError("sqlite");
+        }
+        const databaseConnection = await this.connect();
+        this.driver.connection.logger.logQuery(query, parameters, this);
+        await broadcaster.broadcast("BeforeQuery", query, parameters);
+        const broadcasterResult = new BroadcasterResult_1.BroadcasterResult();
+        return new Promise(async (ok, fail) => {
+            try {
+                const queryStartTime = Date.now();
+                const isInsertQuery = query.startsWith("INSERT ");
+                const isDeleteQuery = query.startsWith("DELETE ");
+                const isUpdateQuery = query.startsWith("UPDATE ");
+                const execute = async () => {
+                    if (isInsertQuery || isDeleteQuery || isUpdateQuery) {
+                        await databaseConnection.run(query, parameters, handler);
+                    }
+                    else {
+                        await databaseConnection.all(query, parameters, handler);
+                    }
+                };
+                const self = this;
+                const handler = function (err, rows) {
+                    if (err && err.toString().indexOf("SQLITE_BUSY:") !== -1) {
+                        if (typeof options.busyErrorRetry === "number" &&
+                            options.busyErrorRetry > 0) {
+                            setTimeout(execute, options.busyErrorRetry);
+                            return;
+                        }
+                    }
+                    // log slow queries if maxQueryExecution time is set
+                    const queryEndTime = Date.now();
+                    const queryExecutionTime = queryEndTime - queryStartTime;
+                    if (maxQueryExecutionTime &&
+                        queryExecutionTime > maxQueryExecutionTime)
+                        connection.logger.logQuerySlow(queryExecutionTime, query, parameters, self);
+                    if (err) {
+                        connection.logger.logQueryError(err, query, parameters, self);
+                        broadcaster.broadcastAfterQueryEvent(broadcasterResult, query, parameters, false, undefined, undefined, err);
+                        return fail(new QueryFailedError_1.QueryFailedError(query, parameters, err));
+                    }
+                    else {
+                        const result = new QueryResult_1.QueryResult();
+                        if (isInsertQuery) {
+                            result.raw = this["lastID"];
+                        }
+                        else {
+                            result.raw = rows;
+                        }
+                        broadcaster.broadcastAfterQueryEvent(broadcasterResult, query, parameters, true, queryExecutionTime, result.raw, undefined);
+                        if (Array.isArray(rows)) {
+                            result.records = rows;
+                        }
+                        result.affected = this["changes"];
+                        if (useStructuredResult) {
+                            ok(result);
+                        }
+                        else {
+                            ok(result.raw);
+                        }
+                    }
+                };
+                await execute();
+            }
+            catch (err) {
+                fail(err);
+            }
+            finally {
+                await broadcasterResult.wait();
+            }
+        });
+    }
+}
+exports.SqliteQueryRunner = SqliteQueryRunner;
+
+//# sourceMappingURL=SqliteQueryRunner.js.map