orcaq 1.0.20

package/.output/server/node_modules/typeorm/driver/aurora-postgres/AuroraPostgresDriver.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuroraPostgresDriver = void 0;
+const PostgresDriver_1 = require("../postgres/PostgresDriver");
+const PlatformTools_1 = require("../../platform/PlatformTools");
+const AuroraPostgresQueryRunner_1 = require("./AuroraPostgresQueryRunner");
+const ApplyValueTransformers_1 = require("../../util/ApplyValueTransformers");
+const DriverUtils_1 = require("../DriverUtils");
+class PostgresWrapper extends PostgresDriver_1.PostgresDriver {
+}
+class AuroraPostgresDriver extends PostgresWrapper {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(connection) {
+        super();
+        /**
+         * Represent transaction support by this driver
+         */
+        this.transactionSupport = "nested";
+        this.connection = connection;
+        this.options = connection.options;
+        this.isReplicated = false;
+        // load data-api package
+        this.loadDependencies();
+        this.client = new this.DataApiDriver(this.options.region, this.options.secretArn, this.options.resourceArn, this.options.database, (query, parameters) => this.connection.logger.logQuery(query, parameters), this.options.serviceConfigOptions, this.options.formatOptions);
+        this.database = DriverUtils_1.DriverUtils.buildDriverOptions(this.options).database;
+    }
+    // -------------------------------------------------------------------------
+    // Public Implemented Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Performs connection to the database.
+     * Based on pooling options, it can either create connection immediately,
+     * either create a pool and create connection when needed.
+     */
+    async connect() { }
+    /**
+     * Closes connection with database.
+     */
+    async disconnect() { }
+    /**
+     * Creates a query runner used to execute database queries.
+     */
+    createQueryRunner(mode) {
+        return new AuroraPostgresQueryRunner_1.AuroraPostgresQueryRunner(this, new this.DataApiDriver(this.options.region, this.options.secretArn, this.options.resourceArn, this.options.database, (query, parameters) => this.connection.logger.logQuery(query, parameters), this.options.serviceConfigOptions, this.options.formatOptions), mode);
+    }
+    /**
+     * Prepares given value to a value to be persisted, based on its column type and metadata.
+     */
+    preparePersistentValue(value, columnMetadata) {
+        if (this.options.formatOptions &&
+            this.options.formatOptions.castParameters === false) {
+            return super.preparePersistentValue(value, columnMetadata);
+        }
+        if (columnMetadata.transformer)
+            value = ApplyValueTransformers_1.ApplyValueTransformers.transformTo(columnMetadata.transformer, value);
+        return this.client.preparePersistentValue(value, columnMetadata);
+    }
+    /**
+     * Prepares given value to a value to be persisted, based on its column type and metadata.
+     */
+    prepareHydratedValue(value, columnMetadata) {
+        if (this.options.formatOptions &&
+            this.options.formatOptions.castParameters === false) {
+            return super.prepareHydratedValue(value, columnMetadata);
+        }
+        if (columnMetadata.transformer)
+            value = ApplyValueTransformers_1.ApplyValueTransformers.transformFrom(columnMetadata.transformer, value);
+        return this.client.prepareHydratedValue(value, columnMetadata);
+    }
+    // -------------------------------------------------------------------------
+    // Protected Methods
+    // -------------------------------------------------------------------------
+    /**
+     * If driver dependency is not given explicitly, then try to load it via "require".
+     */
+    loadDependencies() {
+        const driver = this.options.driver ||
+            PlatformTools_1.PlatformTools.load("typeorm-aurora-data-api-driver");
+        const { pg } = driver;
+        this.DataApiDriver = pg;
+    }
+    /**
+     * Executes given query.
+     */
+    executeQuery(connection, query) {
+        return this.connection.query(query);
+    }
+    /**
+     * Makes any action after connection (e.g. create extensions in Postgres driver).
+     */
+    async afterConnect() {
+        const extensionsMetadata = await this.checkMetadataForExtensions();
+        if (extensionsMetadata.hasExtensions) {
+            await this.enableExtensions(extensionsMetadata, this.connection);
+        }
+        return Promise.resolve();
+    }
+}
+exports.AuroraPostgresDriver = AuroraPostgresDriver;
+
+//# sourceMappingURL=AuroraPostgresDriver.js.map

package/.output/server/node_modules/typeorm/driver/aurora-postgres/AuroraPostgresQueryRunner.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuroraPostgresQueryRunner = void 0;
+const QueryRunnerAlreadyReleasedError_1 = require("../../error/QueryRunnerAlreadyReleasedError");
+const TransactionNotStartedError_1 = require("../../error/TransactionNotStartedError");
+const PostgresQueryRunner_1 = require("../postgres/PostgresQueryRunner");
+const QueryResult_1 = require("../../query-runner/QueryResult");
+const error_1 = require("../../error");
+class PostgresQueryRunnerWrapper extends PostgresQueryRunner_1.PostgresQueryRunner {
+    constructor(driver, mode) {
+        super(driver, mode);
+    }
+}
+/**
+ * Runs queries on a single postgres database connection.
+ */
+class AuroraPostgresQueryRunner extends PostgresQueryRunnerWrapper {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(driver, client, mode) {
+        super(driver, mode);
+        this.client = client;
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Creates/uses database connection from the connection pool to perform further operations.
+     * Returns obtained database connection.
+     */
+    connect() {
+        if (this.databaseConnection)
+            return Promise.resolve(this.databaseConnection);
+        if (this.databaseConnectionPromise)
+            return this.databaseConnectionPromise;
+        if (this.mode === "slave" && this.driver.isReplicated) {
+            this.databaseConnectionPromise = this.driver
+                .obtainSlaveConnection()
+                .then(([connection, release]) => {
+                this.driver.connectedQueryRunners.push(this);
+                this.databaseConnection = connection;
+                this.releaseCallback = release;
+                return this.databaseConnection;
+            });
+        }
+        else {
+            // master
+            this.databaseConnectionPromise = this.driver
+                .obtainMasterConnection()
+                .then(([connection, release]) => {
+                this.driver.connectedQueryRunners.push(this);
+                this.databaseConnection = connection;
+                this.releaseCallback = release;
+                return this.databaseConnection;
+            });
+        }
+        return this.databaseConnectionPromise;
+    }
+    /**
+     * Starts transaction on the current connection.
+     */
+    async startTransaction(isolationLevel) {
+        this.isTransactionActive = true;
+        try {
+            await this.broadcaster.broadcast("BeforeTransactionStart");
+        }
+        catch (err) {
+            this.isTransactionActive = false;
+            throw err;
+        }
+        if (this.transactionDepth === 0) {
+            await this.client.startTransaction();
+        }
+        else {
+            await this.query(`SAVEPOINT typeorm_${this.transactionDepth}`);
+        }
+        this.transactionDepth += 1;
+        await this.broadcaster.broadcast("AfterTransactionStart");
+    }
+    /**
+     * Commits transaction.
+     * Error will be thrown if transaction was not started.
+     */
+    async commitTransaction() {
+        if (!this.isTransactionActive)
+            throw new TransactionNotStartedError_1.TransactionNotStartedError();
+        await this.broadcaster.broadcast("BeforeTransactionCommit");
+        if (this.transactionDepth > 1) {
+            await this.query(`RELEASE SAVEPOINT typeorm_${this.transactionDepth - 1}`);
+        }
+        else {
+            await this.client.commitTransaction();
+            this.isTransactionActive = false;
+        }
+        this.transactionDepth -= 1;
+        await this.broadcaster.broadcast("AfterTransactionCommit");
+    }
+    /**
+     * Rollbacks transaction.
+     * Error will be thrown if transaction was not started.
+     */
+    async rollbackTransaction() {
+        if (!this.isTransactionActive)
+            throw new TransactionNotStartedError_1.TransactionNotStartedError();
+        await this.broadcaster.broadcast("BeforeTransactionRollback");
+        if (this.transactionDepth > 1) {
+            await this.query(`ROLLBACK TO SAVEPOINT typeorm_${this.transactionDepth - 1}`);
+        }
+        else {
+            await this.client.rollbackTransaction();
+            this.isTransactionActive = false;
+        }
+        this.transactionDepth -= 1;
+        await this.broadcaster.broadcast("AfterTransactionRollback");
+    }
+    /**
+     * Executes a given SQL query.
+     */
+    async query(query, parameters, useStructuredResult = false) {
+        if (this.isReleased)
+            throw new QueryRunnerAlreadyReleasedError_1.QueryRunnerAlreadyReleasedError();
+        const raw = await this.client.query(query, parameters);
+        const result = new QueryResult_1.QueryResult();
+        result.raw = raw;
+        if (raw?.hasOwnProperty("records") && Array.isArray(raw.records)) {
+            result.records = raw.records;
+        }
+        if (raw?.hasOwnProperty("numberOfRecordsUpdated")) {
+            result.affected = raw.numberOfRecordsUpdated;
+        }
+        if (!useStructuredResult) {
+            return result.raw;
+        }
+        return result;
+    }
+    /**
+     * Change table comment.
+     */
+    changeTableComment(tableOrName, comment) {
+        throw new error_1.TypeORMError(`aurora-postgres driver does not support change comment.`);
+    }
+}
+exports.AuroraPostgresQueryRunner = AuroraPostgresQueryRunner;
+
+//# sourceMappingURL=AuroraPostgresQueryRunner.js.map

package/.output/server/node_modules/typeorm/driver/better-sqlite3/BetterSqlite3Driver.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BetterSqlite3Driver = 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 error_1 = require("../../error");
+const PlatformTools_1 = require("../../platform/PlatformTools");
+const AbstractSqliteDriver_1 = require("../sqlite-abstract/AbstractSqliteDriver");
+const BetterSqlite3QueryRunner_1 = require("./BetterSqlite3QueryRunner");
+const PathUtils_1 = require("../../util/PathUtils");
+/**
+ * Organizes communication with sqlite DBMS.
+ */
+class BetterSqlite3Driver 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() {
+        this.queryRunner = undefined;
+        this.databaseConnection.close();
+    }
+    /**
+     * Creates a query runner used to execute database queries.
+     */
+    createQueryRunner(mode) {
+        if (!this.queryRunner)
+            this.queryRunner = new BetterSqlite3QueryRunner_1.BetterSqlite3QueryRunner(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() {
+        // not to create database directory if is in memory
+        if (this.options.database !== ":memory:")
+            await this.createDatabaseDirectory(path_1.default.dirname(this.options.database));
+        const { database, readonly = false, fileMustExist = false, timeout = 5000, verbose = null, nativeBinding = null, prepareDatabase, } = this.options;
+        const databaseConnection = this.sqlite(database, {
+            readonly,
+            fileMustExist,
+            timeout,
+            verbose,
+            nativeBinding,
+        });
+        // 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) {
+            databaseConnection.exec(`PRAGMA key = ${JSON.stringify(this.options.key)}`);
+        }
+        // function to run before a database is used in typeorm.
+        if (typeof prepareDatabase === "function") {
+            prepareDatabase(databaseConnection);
+        }
+        // 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.
+        databaseConnection.exec(`PRAGMA foreign_keys = ON`);
+        // turn on WAL mode to enhance performance
+        if (this.options.enableWAL) {
+            databaseConnection.exec(`PRAGMA journal_mode = WAL`);
+        }
+        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("better-sqlite3");
+            this.sqlite = sqlite;
+        }
+        catch (e) {
+            throw new error_1.DriverPackageNotInstalledError("SQLite", "better-sqlite3");
+        }
+    }
+    /**
+     * Auto creates database directory if it does not exist.
+     */
+    async createDatabaseDirectory(dbPath) {
+        await promises_1.default.mkdir(dbPath, { 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(path_1.default.dirname(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(this.options.baseDirectory, optionsDb));
+    }
+}
+exports.BetterSqlite3Driver = BetterSqlite3Driver;
+
+//# sourceMappingURL=BetterSqlite3Driver.js.map

package/.output/server/node_modules/typeorm/driver/better-sqlite3/BetterSqlite3QueryRunner.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BetterSqlite3QueryRunner = void 0;
+const QueryRunnerAlreadyReleasedError_1 = require("../../error/QueryRunnerAlreadyReleasedError");
+const QueryFailedError_1 = require("../../error/QueryFailedError");
+const AbstractSqliteQueryRunner_1 = require("../sqlite-abstract/AbstractSqliteQueryRunner");
+const Broadcaster_1 = require("../../subscriber/Broadcaster");
+const QueryResult_1 = require("../../query-runner/QueryResult");
+const BroadcasterResult_1 = require("../../subscriber/BroadcasterResult");
+/**
+ * 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 BetterSqlite3QueryRunner extends AbstractSqliteQueryRunner_1.AbstractSqliteQueryRunner {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(driver) {
+        super();
+        this.stmtCache = new Map();
+        this.driver = driver;
+        this.connection = driver.connection;
+        this.broadcaster = new Broadcaster_1.Broadcaster(this);
+        if (typeof this.driver.options.statementCacheSize === "number") {
+            this.cacheSize = this.driver.options.statementCacheSize;
+        }
+        else {
+            this.cacheSize = 100;
+        }
+    }
+    async getStmt(query) {
+        if (this.cacheSize > 0) {
+            let stmt = this.stmtCache.get(query);
+            if (!stmt) {
+                const databaseConnection = await this.connect();
+                stmt = databaseConnection.prepare(query);
+                this.stmtCache.set(query, stmt);
+                while (this.stmtCache.size > this.cacheSize) {
+                    // since es6 map keeps the insertion order,
+                    // it comes to be FIFO cache
+                    const key = this.stmtCache.keys().next().value;
+                    this.stmtCache.delete(key);
+                }
+            }
+            return stmt;
+        }
+        else {
+            const databaseConnection = await this.connect();
+            return databaseConnection.prepare(query);
+        }
+    }
+    /**
+     * 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 broadcasterResult = new BroadcasterResult_1.BroadcasterResult();
+        this.driver.connection.logger.logQuery(query, parameters, this);
+        this.broadcaster.broadcastBeforeQueryEvent(broadcasterResult, query, parameters);
+        const queryStartTime = Date.now();
+        const stmt = await this.getStmt(query);
+        try {
+            const result = new QueryResult_1.QueryResult();
+            if (stmt.reader) {
+                const raw = stmt.all.apply(stmt, parameters);
+                result.raw = raw;
+                if (Array.isArray(raw)) {
+                    result.records = raw;
+                }
+            }
+            else {
+                const raw = stmt.run.apply(stmt, parameters);
+                result.affected = raw.changes;
+                result.raw = raw.lastInsertRowid;
+            }
+            // log slow queries if maxQueryExecution time is set
+            const maxQueryExecutionTime = this.driver.options.maxQueryExecutionTime;
+            const queryEndTime = Date.now();
+            const queryExecutionTime = queryEndTime - queryStartTime;
+            if (maxQueryExecutionTime &&
+                queryExecutionTime > maxQueryExecutionTime)
+                connection.logger.logQuerySlow(queryExecutionTime, query, parameters, this);
+            this.broadcaster.broadcastAfterQueryEvent(broadcasterResult, query, parameters, true, queryExecutionTime, result.raw, undefined);
+            if (!useStructuredResult) {
+                return result.raw;
+            }
+            return result;
+        }
+        catch (err) {
+            connection.logger.logQueryError(err, query, parameters, this);
+            throw new QueryFailedError_1.QueryFailedError(query, parameters, err);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Protected Methods
+    // -------------------------------------------------------------------------
+    async loadTableRecords(tablePath, tableOrIndex) {
+        const [database, tableName] = this.splitTablePath(tablePath);
+        const res = await this.query(`SELECT ${database ? `'${database}'` : null} as database, * FROM ${this.escapePath(`${database ? `${database}.` : ""}sqlite_master`)} WHERE "type" = '${tableOrIndex}' AND "${tableOrIndex === "table" ? "name" : "tbl_name"}" IN ('${tableName}')`);
+        return res;
+    }
+    async loadPragmaRecords(tablePath, pragma) {
+        const [database, tableName] = this.splitTablePath(tablePath);
+        const res = await this.query(`PRAGMA ${database ? `"${database}".` : ""}${pragma}("${tableName}")`);
+        return res;
+    }
+}
+exports.BetterSqlite3QueryRunner = BetterSqlite3QueryRunner;
+
+//# sourceMappingURL=BetterSqlite3QueryRunner.js.map

package/.output/server/node_modules/typeorm/driver/capacitor/CapacitorDriver.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapacitorDriver = void 0;
+const AbstractSqliteDriver_1 = require("../sqlite-abstract/AbstractSqliteDriver");
+const CapacitorQueryRunner_1 = require("./CapacitorQueryRunner");
+const error_1 = require("../../error");
+class CapacitorDriver extends AbstractSqliteDriver_1.AbstractSqliteDriver {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(connection) {
+        super(connection);
+        this.database = this.options.database;
+        this.driver = this.options.driver;
+        // load sqlite package
+        this.sqlite = this.options.driver;
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Performs connection to the database.
+     */
+    async connect() {
+        this.databaseConnection = this.createDatabaseConnection();
+        await this.databaseConnection;
+    }
+    /**
+     * Closes connection with database.
+     */
+    async disconnect() {
+        this.queryRunner = undefined;
+        const databaseConnection = await this.databaseConnection;
+        return databaseConnection.close().then(() => {
+            this.databaseConnection = undefined;
+        });
+    }
+    /**
+     * Creates a query runner used to execute database queries.
+     */
+    createQueryRunner(mode) {
+        if (!this.queryRunner)
+            this.queryRunner = new CapacitorQueryRunner_1.CapacitorQueryRunner(this);
+        return this.queryRunner;
+    }
+    // -------------------------------------------------------------------------
+    // Protected Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Creates connection with the database.
+     */
+    async createDatabaseConnection() {
+        const databaseMode = this.options.mode || "no-encryption";
+        const isDatabaseEncryted = databaseMode !== "no-encryption";
+        const databaseVersion = typeof this.options.version === "undefined"
+            ? 1
+            : this.options.version;
+        const connection = await this.sqlite.createConnection(this.options.database, isDatabaseEncryted, databaseMode, databaseVersion);
+        await connection.open();
+        // 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 connection.execute(`PRAGMA foreign_keys = ON`);
+        if (this.options.journalMode &&
+            ["DELETE", "TRUNCATE", "PERSIST", "MEMORY", "WAL", "OFF"].indexOf(this.options.journalMode) !== -1) {
+            await connection.execute(`PRAGMA journal_mode = ${this.options.journalMode}`);
+        }
+        return connection;
+    }
+    loadDependencies() {
+        this.sqlite = this.driver;
+        if (!this.driver) {
+            throw new error_1.DriverPackageNotInstalledError("Capacitor", "@capacitor-community/sqlite");
+        }
+    }
+}
+exports.CapacitorDriver = CapacitorDriver;
+
+//# sourceMappingURL=CapacitorDriver.js.map