orcaq 1.0.20

package/.output/server/node_modules/typeorm/driver/cordova/CordovaDriver.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CordovaDriver = void 0;
+const AbstractSqliteDriver_1 = require("../sqlite-abstract/AbstractSqliteDriver");
+const CordovaQueryRunner_1 = require("./CordovaQueryRunner");
+const DriverPackageNotInstalledError_1 = require("../../error/DriverPackageNotInstalledError");
+class CordovaDriver extends AbstractSqliteDriver_1.AbstractSqliteDriver {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(connection) {
+        super(connection);
+        this.transactionSupport = "none";
+        // this.connection = connection;
+        // this.options = connection.options as CordovaConnectionOptions;
+        this.database = this.options.database;
+        // load sqlite package
+        this.loadDependencies();
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Closes connection with database.
+     */
+    async disconnect() {
+        this.queryRunner = undefined;
+        return new Promise((ok, fail) => {
+            this.databaseConnection.close(ok, fail);
+        });
+    }
+    /**
+     * Creates a query runner used to execute database queries.
+     */
+    createQueryRunner(mode) {
+        if (!this.queryRunner)
+            this.queryRunner = new CordovaQueryRunner_1.CordovaQueryRunner(this);
+        return this.queryRunner;
+    }
+    // -------------------------------------------------------------------------
+    // Protected Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Creates connection with the database.
+     */
+    async createDatabaseConnection() {
+        const options = Object.assign({}, {
+            name: this.options.database,
+            location: this.options.location,
+        }, this.options.extra || {});
+        const connection = await new Promise((resolve, fail) => {
+            this.sqlite.openDatabase(options, (db) => resolve(db), (err) => fail(err));
+        });
+        await new Promise((ok, fail) => {
+            // 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.
+            connection.executeSql(`PRAGMA foreign_keys = ON`, [], () => ok(), (err) => fail(err));
+        });
+        return connection;
+    }
+    /**
+     * If driver dependency is not given explicitly, then try to load it via "require".
+     */
+    loadDependencies() {
+        try {
+            const sqlite = this.options.driver || window.sqlitePlugin;
+            this.sqlite = sqlite;
+        }
+        catch (e) {
+            throw new DriverPackageNotInstalledError_1.DriverPackageNotInstalledError("Cordova-SQLite", "cordova-sqlite-storage");
+        }
+    }
+}
+exports.CordovaDriver = CordovaDriver;
+
+//# sourceMappingURL=CordovaDriver.js.map

package/.output/server/node_modules/typeorm/driver/cordova/CordovaQueryRunner.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CordovaQueryRunner = void 0;
+const error_1 = require("../../error");
+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.
+ */
+class CordovaQueryRunner 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 databaseConnection = await this.connect();
+        this.driver.connection.logger.logQuery(query, parameters, this);
+        await this.broadcaster.broadcast("BeforeQuery", query, parameters);
+        const broadcasterResult = new BroadcasterResult_1.BroadcasterResult();
+        const queryStartTime = Date.now();
+        try {
+            const raw = await new Promise(async (ok, fail) => {
+                databaseConnection.executeSql(query, parameters, (raw) => ok(raw), (err) => fail(err));
+            });
+            // log slow queries if maxQueryExecution time is set
+            const maxQueryExecutionTime = this.driver.options.maxQueryExecutionTime;
+            const queryEndTime = Date.now();
+            const queryExecutionTime = queryEndTime - queryStartTime;
+            this.broadcaster.broadcastAfterQueryEvent(broadcasterResult, query, parameters, true, queryExecutionTime, raw, undefined);
+            if (maxQueryExecutionTime &&
+                queryExecutionTime > maxQueryExecutionTime) {
+                this.driver.connection.logger.logQuerySlow(queryExecutionTime, query, parameters, this);
+            }
+            const result = new QueryResult_1.QueryResult();
+            if (query.substr(0, 11) === "INSERT INTO") {
+                result.raw = raw.insertId;
+            }
+            else {
+                const resultSet = [];
+                for (let i = 0; i < raw.rows.length; i++) {
+                    resultSet.push(raw.rows.item(i));
+                }
+                result.records = resultSet;
+                result.raw = resultSet;
+            }
+            if (useStructuredResult) {
+                return result;
+            }
+            else {
+                return result.raw;
+            }
+        }
+        catch (err) {
+            this.driver.connection.logger.logQueryError(err, query, parameters, this);
+            this.broadcaster.broadcastAfterQueryEvent(broadcasterResult, query, parameters, false, undefined, undefined, err);
+            throw new QueryFailedError_1.QueryFailedError(query, parameters, err);
+        }
+        finally {
+            await broadcasterResult.wait();
+        }
+    }
+    /**
+     * Insert a new row with given values into the given table.
+     * Returns value of the generated column if given and generate column exist in the table.
+     // todo: implement new syntax
+    async insert(tableName: string, keyValues: ObjectLiteral): Promise<InsertResult> {
+        const keys = Object.keys(keyValues);
+        const columns = keys.map(key => `"${key}"`).join(", ");
+        const values = keys.map(key => "?").join(",");
+        const generatedColumns = this.connection.hasMetadata(tableName) ? this.connection.getMetadata(tableName).generatedColumns : [];
+        const sql = columns.length > 0 ? (`INSERT INTO "${tableName}"(${columns}) VALUES (${values})`) : `INSERT INTO "${tableName}" DEFAULT VALUES`;
+        const parameters = keys.map(key => keyValues[key]);
+
+        return new Promise<InsertResult>(async (ok, fail) => {
+            this.driver.connection.logger.logQuery(sql, parameters, this);
+            const __this = this;
+            const databaseConnection = await this.connect();
+            databaseConnection.executeSql(sql, parameters, (resultSet: any) => {
+                const generatedMap = generatedColumns.reduce((map, generatedColumn) => {
+                    const value = generatedColumn.isPrimary && generatedColumn.generationStrategy === "increment" && resultSet.insertId ? resultSet.insertId : keyValues[generatedColumn.databaseName];
+                    if (!value) return map;
+                    return OrmUtils.mergeDeep(map, generatedColumn.createValueMap(value));
+                }, {} as ObjectLiteral);
+
+                ok({
+                    result: undefined,
+                    generatedMap: Object.keys(generatedMap).length > 0 ? generatedMap : undefined
+                });
+            }, (err: any) => {
+                __this.driver.connection.logger.logQueryError(err, sql, parameters, this);
+                fail(err);
+            });
+        });
+    }*/
+    /**
+     * Would start a transaction but this driver does not support transactions.
+     */
+    async startTransaction() {
+        throw new error_1.TypeORMError("Transactions are not supported by the Cordova driver");
+    }
+    /**
+     * Would start a transaction but this driver does not support transactions.
+     */
+    async commitTransaction() {
+        throw new error_1.TypeORMError("Transactions are not supported by the Cordova driver");
+    }
+    /**
+     * Would start a transaction but this driver does not support transactions.
+     */
+    async rollbackTransaction() {
+        throw new error_1.TypeORMError("Transactions are not supported by the Cordova driver");
+    }
+    /**
+     * Removes all tables from the currently connected database.
+     * Be careful with using this method and avoid using it in production or migrations
+     * (because it can clear all your database).
+     */
+    async clearDatabase() {
+        await this.query(`PRAGMA foreign_keys = OFF`);
+        try {
+            const selectViewDropsQuery = `SELECT 'DROP VIEW "' || name || '";' as query FROM "sqlite_master" WHERE "type" = 'view'`;
+            const dropViewQueries = await this.query(selectViewDropsQuery);
+            const selectTableDropsQuery = `SELECT 'DROP TABLE "' || name || '";' as query FROM "sqlite_master" WHERE "type" = 'table' AND "name" != 'sqlite_sequence'`;
+            const dropTableQueries = await this.query(selectTableDropsQuery);
+            await Promise.all(dropViewQueries.map((q) => this.query(q["query"])));
+            await Promise.all(dropTableQueries.map((q) => this.query(q["query"])));
+        }
+        finally {
+            await this.query(`PRAGMA foreign_keys = ON`);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Protected Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Parametrizes given object of values. Used to create column=value queries.
+     */
+    parametrize(objectLiteral, startIndex = 0) {
+        return Object.keys(objectLiteral).map((key, index) => `"${key}"` + "=?");
+    }
+}
+exports.CordovaQueryRunner = CordovaQueryRunner;
+
+//# sourceMappingURL=CordovaQueryRunner.js.map

package/.output/server/node_modules/typeorm/driver/expo/ExpoDriver.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpoDriver = void 0;
+const AbstractSqliteDriver_1 = require("../sqlite-abstract/AbstractSqliteDriver");
+const ExpoQueryRunner_1 = require("./ExpoQueryRunner");
+class ExpoDriver extends AbstractSqliteDriver_1.AbstractSqliteDriver {
+    constructor(connection) {
+        super(connection);
+        this.sqlite = this.options.driver;
+    }
+    async disconnect() {
+        this.queryRunner = undefined;
+        await this.databaseConnection.closeAsync();
+        this.databaseConnection = undefined;
+    }
+    createQueryRunner() {
+        if (!this.queryRunner)
+            this.queryRunner = new ExpoQueryRunner_1.ExpoQueryRunner(this);
+        return this.queryRunner;
+    }
+    async createDatabaseConnection() {
+        this.databaseConnection = await this.sqlite.openDatabaseAsync(this.options.database);
+        await this.databaseConnection.runAsync("PRAGMA foreign_keys = ON");
+        return this.databaseConnection;
+    }
+}
+exports.ExpoDriver = ExpoDriver;
+
+//# sourceMappingURL=ExpoDriver.js.map

package/.output/server/node_modules/typeorm/driver/expo/ExpoDriverFactory.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpoDriverFactory = void 0;
+const ExpoDriver_1 = require("./ExpoDriver");
+const ExpoLegacyDriver_1 = require("./legacy/ExpoLegacyDriver");
+class ExpoDriverFactory {
+    constructor(connection) {
+        this.connection = connection;
+    }
+    create() {
+        if (this.isLegacyDriver) {
+            return new ExpoLegacyDriver_1.ExpoLegacyDriver(this.connection);
+        }
+        return new ExpoDriver_1.ExpoDriver(this.connection);
+    }
+    get isLegacyDriver() {
+        return !("openDatabaseAsync" in this.connection.options.driver);
+    }
+}
+exports.ExpoDriverFactory = ExpoDriverFactory;
+
+//# sourceMappingURL=ExpoDriverFactory.js.map

package/.output/server/node_modules/typeorm/driver/expo/ExpoQueryRunner.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpoQueryRunner = void 0;
+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");
+class ExpoQueryRunner extends AbstractSqliteQueryRunner_1.AbstractSqliteQueryRunner {
+    constructor(driver) {
+        super();
+        this.driver = driver;
+        this.connection = driver.connection;
+        this.broadcaster = new Broadcaster_1.Broadcaster(this);
+    }
+    async beforeMigration() {
+        await this.query("PRAGMA foreign_keys = OFF");
+    }
+    async afterMigration() {
+        await this.query("PRAGMA foreign_keys = ON");
+    }
+    async query(query, parameters, useStructuredResult = false) {
+        if (this.isReleased)
+            throw new QueryRunnerAlreadyReleasedError_1.QueryRunnerAlreadyReleasedError();
+        const databaseConnection = await this.connect();
+        const broadcasterResult = new BroadcasterResult_1.BroadcasterResult();
+        this.driver.connection.logger.logQuery(query, parameters, this);
+        await this.broadcaster.broadcast("BeforeQuery", query, parameters);
+        const queryStartTime = Date.now();
+        const statement = await databaseConnection.prepareAsync(query);
+        try {
+            const rawResult = await statement.executeAsync(parameters);
+            const maxQueryExecutionTime = this.driver.options.maxQueryExecutionTime;
+            const queryEndTime = Date.now();
+            const queryExecutionTime = queryEndTime - queryStartTime;
+            this.broadcaster.broadcastAfterQueryEvent(broadcasterResult, query, parameters, true, queryExecutionTime, rawResult, undefined);
+            await broadcasterResult.wait();
+            if (maxQueryExecutionTime &&
+                queryExecutionTime > maxQueryExecutionTime) {
+                this.driver.connection.logger.logQuerySlow(queryExecutionTime, query, parameters, this);
+            }
+            const result = new QueryResult_1.QueryResult();
+            result.affected = rawResult.changes;
+            result.records = await rawResult.getAllAsync();
+            result.raw = query.startsWith("INSERT INTO")
+                ? rawResult.lastInsertRowId
+                : result.records;
+            return useStructuredResult ? result : result.raw;
+        }
+        catch (err) {
+            this.driver.connection.logger.logQueryError(err, query, parameters, this);
+            this.broadcaster.broadcastAfterQueryEvent(broadcasterResult, query, parameters, false, 0, undefined, err);
+            await broadcasterResult.wait();
+            throw new QueryFailedError_1.QueryFailedError(query, parameters, err);
+        }
+        finally {
+            await broadcasterResult.wait();
+            await statement.finalizeAsync();
+        }
+    }
+}
+exports.ExpoQueryRunner = ExpoQueryRunner;
+
+//# sourceMappingURL=ExpoQueryRunner.js.map

package/.output/server/node_modules/typeorm/driver/expo/legacy/ExpoLegacyDriver.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpoLegacyDriver = void 0;
+const AbstractSqliteDriver_1 = require("../../sqlite-abstract/AbstractSqliteDriver");
+const ExpoLegacyQueryRunner_1 = require("./ExpoLegacyQueryRunner");
+class ExpoLegacyDriver extends AbstractSqliteDriver_1.AbstractSqliteDriver {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(connection) {
+        super(connection);
+        this.database = this.options.database;
+        // load sqlite package
+        this.sqlite = this.options.driver;
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Closes connection with database.
+     */
+    async disconnect() {
+        return new Promise((ok, fail) => {
+            try {
+                this.queryRunner = undefined;
+                this.databaseConnection._db.close();
+                this.databaseConnection = undefined;
+                ok();
+            }
+            catch (error) {
+                fail(error);
+            }
+        });
+    }
+    /**
+     * Creates a query runner used to execute database queries.
+     */
+    createQueryRunner(mode) {
+        if (!this.queryRunner)
+            this.queryRunner = new ExpoLegacyQueryRunner_1.ExpoLegacyQueryRunner(this);
+        return this.queryRunner;
+    }
+    // -------------------------------------------------------------------------
+    // Protected Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Creates connection with the database.
+     */
+    createDatabaseConnection() {
+        return new Promise((ok, fail) => {
+            try {
+                const databaseConnection = this.sqlite.openDatabase(this.options.database);
+                /*
+                // we need to enable foreign keys in sqlite to make sure all foreign key related features
+                // working properly. this also makes onDelete work with sqlite.
+                */
+                databaseConnection.transaction((tsx) => {
+                    tsx.executeSql(`PRAGMA foreign_keys = ON`, [], (t, result) => {
+                        ok(databaseConnection);
+                    }, (t, err) => {
+                        fail({ transaction: t, error: err });
+                    });
+                }, (err) => {
+                    fail(err);
+                });
+            }
+            catch (error) {
+                fail(error);
+            }
+        });
+    }
+}
+exports.ExpoLegacyDriver = ExpoLegacyDriver;
+
+//# sourceMappingURL=ExpoLegacyDriver.js.map

package/.output/server/node_modules/typeorm/driver/expo/legacy/ExpoLegacyQueryRunner.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpoLegacyQueryRunner = void 0;
+const QueryRunnerAlreadyReleasedError_1 = require("../../../error/QueryRunnerAlreadyReleasedError");
+const QueryFailedError_1 = require("../../../error/QueryFailedError");
+const AbstractSqliteQueryRunner_1 = require("../../sqlite-abstract/AbstractSqliteQueryRunner");
+const TransactionNotStartedError_1 = require("../../../error/TransactionNotStartedError");
+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.
+ */
+class ExpoLegacyQueryRunner extends AbstractSqliteQueryRunner_1.AbstractSqliteQueryRunner {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(driver) {
+        super();
+        this.driver = driver;
+        this.connection = driver.connection;
+        this.broadcaster = new Broadcaster_1.Broadcaster(this);
+    }
+    /**
+     * Starts transaction. Within Expo, all database operations happen in a
+     * transaction context, so issuing a `BEGIN TRANSACTION` command is
+     * redundant and will result in the following error:
+     *
+     * `Error: Error code 1: cannot start a transaction within a transaction`
+     *
+     * Instead, we keep track of a `Transaction` object in `this.transaction`
+     * and continue using the same object until we wish to commit the
+     * transaction.
+     */
+    async startTransaction() {
+        this.isTransactionActive = true;
+        try {
+            await this.broadcaster.broadcast("BeforeTransactionStart");
+        }
+        catch (err) {
+            this.isTransactionActive = false;
+            throw err;
+        }
+        this.transactionDepth += 1;
+        await this.broadcaster.broadcast("AfterTransactionStart");
+    }
+    /**
+     * Commits transaction.
+     * Error will be thrown if transaction was not started.
+     * Since Expo will automatically commit the transaction once all the
+     * callbacks of the transaction object have been completed, "committing" a
+     * transaction in this driver's context means that we delete the transaction
+     * object and set the stage for the next transaction.
+     */
+    async commitTransaction() {
+        if (!this.isTransactionActive &&
+            typeof this.transaction === "undefined")
+            throw new TransactionNotStartedError_1.TransactionNotStartedError();
+        await this.broadcaster.broadcast("BeforeTransactionCommit");
+        this.transaction = undefined;
+        this.isTransactionActive = false;
+        this.transactionDepth -= 1;
+        await this.broadcaster.broadcast("AfterTransactionCommit");
+    }
+    /**
+     * Rollbacks transaction.
+     * Error will be thrown if transaction was not started.
+     * This method's functionality is identical to `commitTransaction()` because
+     * the transaction lifecycle is handled within the Expo transaction object.
+     * Issuing separate statements for `COMMIT` or `ROLLBACK` aren't necessary.
+     */
+    async rollbackTransaction() {
+        if (!this.isTransactionActive &&
+            typeof this.transaction === "undefined")
+            throw new TransactionNotStartedError_1.TransactionNotStartedError();
+        await this.broadcaster.broadcast("BeforeTransactionRollback");
+        this.transaction = undefined;
+        this.isTransactionActive = false;
+        this.transactionDepth -= 1;
+        await this.broadcaster.broadcast("AfterTransactionRollback");
+    }
+    /**
+     * Called before migrations are run.
+     */
+    async beforeMigration() {
+        const databaseConnection = await this.connect();
+        return new Promise((ok, fail) => {
+            databaseConnection.exec([{ sql: "PRAGMA foreign_keys = OFF", args: [] }], false, (err) => (err ? fail(err) : ok()));
+        });
+    }
+    /**
+     * Called after migrations are run.
+     */
+    async afterMigration() {
+        const databaseConnection = await this.connect();
+        return new Promise((ok, fail) => {
+            databaseConnection.exec([{ sql: "PRAGMA foreign_keys = ON", args: [] }], false, (err) => (err ? fail(err) : ok()));
+        });
+    }
+    /**
+     * Executes a given SQL query.
+     */
+    async query(query, parameters, useStructuredResult = false) {
+        if (this.isReleased)
+            throw new QueryRunnerAlreadyReleasedError_1.QueryRunnerAlreadyReleasedError();
+        return new Promise(async (ok, fail) => {
+            const databaseConnection = await this.connect();
+            const broadcasterResult = new BroadcasterResult_1.BroadcasterResult();
+            this.driver.connection.logger.logQuery(query, parameters, this);
+            this.broadcaster.broadcastBeforeQueryEvent(broadcasterResult, query, parameters);
+            const queryStartTime = Date.now();
+            // All Expo SQL queries are executed in a transaction context
+            databaseConnection.transaction(async (transaction) => {
+                if (typeof this.transaction === "undefined") {
+                    await this.startTransaction();
+                    this.transaction = transaction;
+                }
+                this.transaction.executeSql(query, parameters, async (t, raw) => {
+                    // log slow queries if maxQueryExecution time is set
+                    const maxQueryExecutionTime = this.driver.options.maxQueryExecutionTime;
+                    const queryEndTime = Date.now();
+                    const queryExecutionTime = queryEndTime - queryStartTime;
+                    this.broadcaster.broadcastAfterQueryEvent(broadcasterResult, query, parameters, true, queryExecutionTime, raw, undefined);
+                    await broadcasterResult.wait();
+                    if (maxQueryExecutionTime &&
+                        queryExecutionTime > maxQueryExecutionTime) {
+                        this.driver.connection.logger.logQuerySlow(queryExecutionTime, query, parameters, this);
+                    }
+                    const result = new QueryResult_1.QueryResult();
+                    if (raw?.hasOwnProperty("rowsAffected")) {
+                        result.affected = raw.rowsAffected;
+                    }
+                    if (raw?.hasOwnProperty("rows")) {
+                        let resultSet = [];
+                        for (let i = 0; i < raw.rows.length; i++) {
+                            resultSet.push(raw.rows.item(i));
+                        }
+                        result.raw = resultSet;
+                        result.records = resultSet;
+                    }
+                    // return id of inserted row, if query was insert statement.
+                    if (query.startsWith("INSERT INTO")) {
+                        result.raw = raw.insertId;
+                    }
+                    if (useStructuredResult) {
+                        ok(result);
+                    }
+                    else {
+                        ok(result.raw);
+                    }
+                }, async (t, err) => {
+                    this.driver.connection.logger.logQueryError(err, query, parameters, this);
+                    this.broadcaster.broadcastAfterQueryEvent(broadcasterResult, query, parameters, false, undefined, undefined, err);
+                    await broadcasterResult.wait();
+                    fail(new QueryFailedError_1.QueryFailedError(query, parameters, err));
+                });
+            }, async (err) => {
+                await this.rollbackTransaction();
+                fail(err);
+            }, () => {
+                this.isTransactionActive = false;
+                this.transaction = undefined;
+            });
+        });
+    }
+}
+exports.ExpoLegacyQueryRunner = ExpoLegacyQueryRunner;
+
+//# sourceMappingURL=ExpoLegacyQueryRunner.js.map