19549987525

Committed 20 Nov 2025 08:11PM UTC coverage: 80.769% (+4.3%) from 76.433%

Build # 19549987525

Build Type

push

github

Committed by

web-flow

Commit Message

ci: run tests on commits to master and next (#11783)

Co-authored-by: Oleg "OSA413" Sokolov <OSA413@users.noreply.github.com>

Run Details

26500 of 32174 branches covered (82.36%)

Branch coverage included in aggregate %.

91252 of 113615 relevant lines covered (80.32%)

88980.79 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.19

/src/driver/sqljs/SqljsQueryRunner.ts

import { QueryFailedError } from "../../error/QueryFailedError"
import { QueryRunnerAlreadyReleasedError } from "../../error/QueryRunnerAlreadyReleasedError"
import { QueryResult } from "../../query-runner/QueryResult"
import { Broadcaster } from "../../subscriber/Broadcaster"
import { BroadcasterResult } from "../../subscriber/BroadcasterResult"
import { AbstractSqliteQueryRunner } from "../sqlite-abstract/AbstractSqliteQueryRunner"
import { SqljsDriver } from "./SqljsDriver"

/**
 * Runs queries on a single sqlite database connection.
 */
export class SqljsQueryRunner extends AbstractSqliteQueryRunner {
    /**
     * Flag to determine if a modification has happened since the last time this query runner has requested a save.
     */
    private isDirty = false

    /**
     * Database driver used by connection.
     */
    driver: SqljsDriver

    // -------------------------------------------------------------------------
    // Constructor
    // -------------------------------------------------------------------------

    constructor(driver: SqljsDriver) {
        super()
        this.driver = driver
        this.connection = driver.connection
        this.broadcaster = new Broadcaster(this)
    }

    // -------------------------------------------------------------------------
    // Public methods
    // -------------------------------------------------------------------------

    /**
     * Called before migrations are run.
     */
    async beforeMigration(): Promise<void> {
        await this.query(`PRAGMA foreign_keys = OFF`)
    }

    /**
     * Called after migrations are run.
     */
    async afterMigration(): Promise<void> {
        await this.query(`PRAGMA foreign_keys = ON`)
    }

    private async flush() {
        if (this.isDirty) {
            await this.driver.autoSave()
            this.isDirty = false
        }
    }

    async release(): Promise<void> {
        await this.flush()
        return super.release()
    }

    /**
     * Commits transaction.
     * Error will be thrown if transaction was not started.
     */
    async commitTransaction(): Promise<void> {
        await super.commitTransaction()
        if (!this.isTransactionActive) {
            await this.flush()
        }
    }

    /**
     * Executes a given SQL query.
     */
    async query(
        query: string,
        parameters: any[] = [],
        useStructuredResult = false,
    ): Promise<any> {
        if (this.isReleased) throw new QueryRunnerAlreadyReleasedError()

        const command = query.trim().split(" ", 1)[0]

        const databaseConnection = this.driver.databaseConnection

        this.driver.connection.logger.logQuery(query, parameters, this)
        await this.broadcaster.broadcast("BeforeQuery", query, parameters)

        const broadcasterResult = new BroadcasterResult()
        const queryStartTime = Date.now()
        let statement: any

        try {
            statement = databaseConnection.prepare(query)
            if (parameters) {
                parameters = parameters.map((p) =>
                    typeof p !== "undefined" ? p : null,
                )

                statement.bind(parameters)
            }

            // 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
            )
                this.driver.connection.logger.logQuerySlow(
                    queryExecutionTime,
                    query,
                    parameters,
                    this,
                )

            const records: any[] = []

            while (statement.step()) {
                records.push(statement.getAsObject())
            }

            this.broadcaster.broadcastAfterQueryEvent(
                broadcasterResult,
                query,
                parameters,
                true,
                queryExecutionTime,
                records,
                undefined,
            )

            const result = new QueryResult()

            result.affected = databaseConnection.getRowsModified()
            result.records = records
            result.raw = records

            statement.free()

            if (command !== "SELECT") {
                this.isDirty = true
            }

            if (useStructuredResult) {
                return result
            } else {
                return result.raw
            }
        } catch (err) {
            if (statement) {
                statement.free()
            }

            this.driver.connection.logger.logQueryError(
                err,
                query,
                parameters,
                this,
            )
            this.broadcaster.broadcastAfterQueryEvent(
                broadcasterResult,
                query,
                parameters,
                false,
                undefined,
                undefined,
                err,
            )

            throw new QueryFailedError(query, parameters, err)
        } finally {
            await broadcasterResult.wait()
        }
    }
}

1	import { QueryFailedError } from "../../error/QueryFailedError"	26✔
2	import { QueryRunnerAlreadyReleasedError } from "../../error/QueryRunnerAlreadyReleasedError"	26✔
3	import { QueryResult } from "../../query-runner/QueryResult"	26✔
4	import { Broadcaster } from "../../subscriber/Broadcaster"	26✔
5	import { BroadcasterResult } from "../../subscriber/BroadcasterResult"	26✔
6	import { AbstractSqliteQueryRunner } from "../sqlite-abstract/AbstractSqliteQueryRunner"	26✔
7	import { SqljsDriver } from "./SqljsDriver"	26✔
8		26✔
9	/**	26✔
10	* Runs queries on a single sqlite database connection.	26✔
11	*/	26✔
12	export class SqljsQueryRunner extends AbstractSqliteQueryRunner {	26✔
13	/**	26✔
14	* Flag to determine if a modification has happened since the last time this query runner has requested a save.	26✔
15	*/	26✔
16	private isDirty = false	26✔
17		26✔
18	/**	26✔
19	* Database driver used by connection.	26✔
20	*/	26✔
21	driver: SqljsDriver	26✔
22		26✔
23	// -------------------------------------------------------------------------	26✔
24	// Constructor	26✔
25	// -------------------------------------------------------------------------	26✔
26		26✔
27	constructor(driver: SqljsDriver) {	26✔
28	super()	1,284✔
29	this.driver = driver	1,284✔
30	this.connection = driver.connection	1,284✔
31	this.broadcaster = new Broadcaster(this)	1,284✔
32	}	1,284✔
33		26✔
34	// -------------------------------------------------------------------------	26✔
35	// Public methods	26✔
36	// -------------------------------------------------------------------------	26✔
37		26✔
38	/**	26✔
39	* Called before migrations are run.	26✔
40	*/	26✔
41	async beforeMigration(): Promise<void> {	26✔
42	await this.query(`PRAGMA foreign_keys = OFF`)	3,840✔
43	}	3,840✔
44		26✔
45	/**	26✔
46	* Called after migrations are run.	26✔
47	*/	26✔
48	async afterMigration(): Promise<void> {	26✔
49	await this.query(`PRAGMA foreign_keys = ON`)	3,831✔
50	}	3,831✔
51		26✔
52	private async flush() {	26✔
53	if (this.isDirty) {	58,323✔
54	await this.driver.autoSave()	34,128✔
55	this.isDirty = false	34,128✔
56	}	34,128✔
57	}	58,323✔
58		26✔
59	async release(): Promise<void> {	26✔
60	await this.flush()	32,712✔
61	return super.release()	32,712✔
62	}	32,712✔
63		26✔
64	/**	26✔
65	* Commits transaction.	26✔
66	* Error will be thrown if transaction was not started.	26✔
67	*/	26✔
68	async commitTransaction(): Promise<void> {	26✔
69	await super.commitTransaction()	25,641✔
70	if (!this.isTransactionActive) {	25,641✔
71	await this.flush()	25,611✔
72	}	25,611✔
73	}	25,641✔
74		26✔
75	/**	26✔
76	* Executes a given SQL query.	26✔
77	*/	26✔
78	async query(	26✔
79	query: string,	197,028✔
80	parameters: any[] = [],	197,028✔
81	useStructuredResult = false,	197,028✔
82	): Promise<any> {	197,028✔
83	if (this.isReleased) throw new QueryRunnerAlreadyReleasedError()	197,028!
84		197,028✔
85	const command = query.trim().split(" ", 1)[0]	197,028✔
86		197,028✔
87	const databaseConnection = this.driver.databaseConnection	197,028✔
88		197,028✔
89	this.driver.connection.logger.logQuery(query, parameters, this)	197,028✔
90	await this.broadcaster.broadcast("BeforeQuery", query, parameters)	197,028✔
91		197,028✔
92	const broadcasterResult = new BroadcasterResult()	197,028✔
93	const queryStartTime = Date.now()	197,028✔
94	let statement: any	197,028✔
95		197,028✔
96	try {	197,028✔
97	statement = databaseConnection.prepare(query)	197,028✔
98	if (parameters) {	197,028✔
99	parameters = parameters.map((p) =>	197,019✔
100	typeof p !== "undefined" ? p : null,	197,019✔
101	)	197,019✔
102		197,019✔
103	statement.bind(parameters)	197,019✔
104	}	197,019✔
105		197,019✔
106	// log slow queries if maxQueryExecution time is set	197,019✔
107	const maxQueryExecutionTime =	197,019✔
108	this.driver.options.maxQueryExecutionTime	197,019✔
109	const queryEndTime = Date.now()	197,019✔
110	const queryExecutionTime = queryEndTime - queryStartTime	197,019✔
111		197,019✔
112	if (	197,019✔
113	maxQueryExecutionTime &&	197,019!
114	queryExecutionTime > maxQueryExecutionTime	×
115	)	197,028✔
116	this.driver.connection.logger.logQuerySlow(	197,028!
117	queryExecutionTime,	×
118	query,	×
119	parameters,	×
120	this,	×
121	)	×
122		197,019✔
123	const records: any[] = []	197,019✔
124		197,019✔
125	while (statement.step()) {	197,028✔
126	records.push(statement.getAsObject())	38,754✔
127	}	38,754✔
128		197,007✔
129	this.broadcaster.broadcastAfterQueryEvent(	197,007✔
130	broadcasterResult,	197,007✔
131	query,	197,007✔
132	parameters,	197,007✔
133	true,	197,007✔
134	queryExecutionTime,	197,007✔
135	records,	197,007✔
136	undefined,	197,007✔
137	)	197,007✔
138		197,007✔
139	const result = new QueryResult()	197,007✔
140		197,007✔
141	result.affected = databaseConnection.getRowsModified()	197,007✔
142	result.records = records	197,007✔
143	result.raw = records	197,007✔
144		197,007✔
145	statement.free()	197,007✔
146		197,007✔
147	if (command !== "SELECT") {	197,028✔
148	this.isDirty = true	155,220✔
149	}	155,220✔
150		197,007✔
151	if (useStructuredResult) {	197,028✔
152	return result	48,279✔
153	} else {	197,028✔
154	return result.raw	148,728✔
155	}	148,728✔
156	} catch (err) {	197,028✔
157	if (statement) {	21✔
158	statement.free()	12✔
159	}	12✔
160		21✔
161	this.driver.connection.logger.logQueryError(	21✔
162	err,	21✔
163	query,	21✔
164	parameters,	21✔
165	this,	21✔
166	)	21✔
167	this.broadcaster.broadcastAfterQueryEvent(	21✔
168	broadcasterResult,	21✔
169	query,	21✔
170	parameters,	21✔
171	false,	21✔
172	undefined,	21✔
173	undefined,	21✔
174	err,	21✔
175	)	21✔
176		21✔
177	throw new QueryFailedError(query, parameters, err)	21✔
178	} finally {	197,028!
179	await broadcasterResult.wait()	197,028✔
180	}	197,028✔
181	}	197,028✔
182	}	26✔

typeorm / typeorm / 19549987525

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous