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

74.19

/src/logger/AbstractLogger.ts

import {
    Logger,
    LogLevel,
    LogMessage,
    LogMessageType,
    PrepareLogMessagesOptions,
} from "./Logger"
import { QueryRunner } from "../query-runner/QueryRunner"
import { LoggerOptions } from "./LoggerOptions"
import { PlatformTools } from "../platform/PlatformTools"

export abstract class AbstractLogger implements Logger {
    // -------------------------------------------------------------------------
    // Constructor
    // -------------------------------------------------------------------------

    constructor(protected options?: LoggerOptions) {}

    // -------------------------------------------------------------------------
    // Public Methods
    // -------------------------------------------------------------------------

    /**
     * Logs query and parameters used in it.
     */
    logQuery(query: string, parameters?: any[], queryRunner?: QueryRunner) {
        if (!this.isLogEnabledFor("query")) {
            return
        }

        this.writeLog(
            "query",
            {
                type: "query",
                prefix: "query",
                message: query,
                format: "sql",
                parameters,
            },
            queryRunner,
        )
    }

    /**
     * Logs query that is failed.
     */
    logQueryError(
        error: string,
        query: string,
        parameters?: any[],
        queryRunner?: QueryRunner,
    ) {
        if (!this.isLogEnabledFor("query-error")) {
            return
        }

        this.writeLog(
            "warn",
            [
                {
                    type: "query-error",
                    prefix: "query failed",
                    message: query,
                    format: "sql",
                    parameters,
                },
                {
                    type: "query-error",
                    prefix: "error",
                    message: error,
                },
            ],
            queryRunner,
        )
    }

    /**
     * Logs query that is slow.
     */
    logQuerySlow(
        time: number,
        query: string,
        parameters?: any[],
        queryRunner?: QueryRunner,
    ) {
        if (!this.isLogEnabledFor("query-slow")) {
            return
        }

        this.writeLog(
            "warn",
            [
                {
                    type: "query-slow",
                    prefix: "query is slow",
                    message: query,
                    format: "sql",
                    parameters,
                    additionalInfo: {
                        time,
                    },
                },
                {
                    type: "query-slow",
                    prefix: "execution time",
                    message: time,
                },
            ],
            queryRunner,
        )
    }

    /**
     * Logs events from the schema build process.
     */
    logSchemaBuild(message: string, queryRunner?: QueryRunner) {
        if (!this.isLogEnabledFor("schema-build")) {
            return
        }

        this.writeLog(
            "schema",
            {
                type: "schema-build",
                message,
            },
            queryRunner,
        )
    }

    /**
     * Logs events from the migration run process.
     */
    logMigration(message: string, queryRunner?: QueryRunner) {
        if (!this.isLogEnabledFor("migration")) {
            return
        }

        this.writeLog(
            "log",
            {
                type: "migration",
                message,
            },
            queryRunner,
        )
    }

    /**
     * Perform logging using given logger, or by default to the console.
     * Log has its own level and message.
     */
    log(
        level: "log" | "info" | "warn",
        message: any,
        queryRunner?: QueryRunner,
    ) {
        switch (level) {
            case "log":
                if (!this.isLogEnabledFor("log")) {
                    return
                }

                this.writeLog(
                    "log",
                    {
                        type: "log",
                        message,
                    },
                    queryRunner,
                )
                break

            case "info":
                if (!this.isLogEnabledFor("info")) {
                    return
                }

                this.writeLog(
                    "info",
                    {
                        type: "info",
                        prefix: "info",
                        message,
                    },
                    queryRunner,
                )
                break

            case "warn":
                if (!this.isLogEnabledFor("warn")) {
                    return
                }

                this.writeLog(
                    "warn",
                    {
                        type: "warn",
                        message,
                    },
                    queryRunner,
                )
                break
        }
    }

    // -------------------------------------------------------------------------
    // Protected Methods
    // -------------------------------------------------------------------------

    /**
     * Check is logging for level or message type is enabled.
     */
    protected isLogEnabledFor(type?: LogLevel | LogMessageType) {
        switch (type) {
            case "query":
                return (
                    this.options === "all" ||
                    this.options === true ||
                    (Array.isArray(this.options) &&
                        this.options.indexOf("query") !== -1)
                )

            case "error":
            case "query-error":
                return (
                    this.options === "all" ||
                    this.options === true ||
                    (Array.isArray(this.options) &&
                        this.options.indexOf("error") !== -1)
                )

            case "query-slow":
                return true

            case "schema":
            case "schema-build":
                return (
                    this.options === "all" ||
                    (Array.isArray(this.options) &&
                        this.options.indexOf("schema") !== -1)
                )

            case "migration":
                return true

            case "log":
                return (
                    this.options === "all" ||
                    (Array.isArray(this.options) &&
                        this.options.indexOf("log") !== -1)
                )

            case "info":
                return (
                    this.options === "all" ||
                    (Array.isArray(this.options) &&
                        this.options.indexOf("info") !== -1)
                )

            case "warn":
                return (
                    this.options === "all" ||
                    (Array.isArray(this.options) &&
                        this.options.indexOf("warn") !== -1)
                )

            default:
                return false
        }
    }

    /**
     * Write log to specific output.
     */
    protected abstract writeLog(
        level: LogLevel,
        message:
            | LogMessage
            | string
            | number
            | (LogMessage | string | number)[],
        queryRunner?: QueryRunner,
    ): void

    /**
     * Prepare and format log messages
     */
    protected prepareLogMessages(
        logMessage:
            | LogMessage
            | string
            | number
            | (LogMessage | string | number)[],
        options?: Partial<PrepareLogMessagesOptions>,
        queryRunner?: QueryRunner,
    ): LogMessage[] {
        options = {
            ...{
                addColonToPrefix: true,
                appendParameterAsComment: true,
                highlightSql: true,
                formatSql: false,
            },
            ...options,
        }
        const messages = Array.isArray(logMessage) ? logMessage : [logMessage]

        for (let message of messages) {
            if (typeof message !== "object") {
                message = {
                    message,
                }
            }

            if (message.format === "sql") {
                let sql = String(message.message)

                if (options.formatSql) {
                    sql = PlatformTools.formatSql(
                        sql,
                        queryRunner?.connection?.options.type,
                    )
                }

                if (
                    options.appendParameterAsComment &&
                    message.parameters &&
                    message.parameters.length
                ) {
                    sql += ` -- PARAMETERS: ${this.stringifyParams(
                        message.parameters,
                    )}`
                }

                if (options.highlightSql) {
                    sql = PlatformTools.highlightSql(sql)
                }

                message.message = sql
            }

            if (options.addColonToPrefix && message.prefix) {
                message.prefix += ":"
            }
        }

        return messages as LogMessage[]
    }

    /**
     * Converts parameters to a string.
     * Sometimes parameters can have circular objects and therefor we are handle this case too.
     */
    protected stringifyParams(parameters: any[]) {
        try {
            return JSON.stringify(parameters)
        } catch (error) {
            // most probably circular objects in parameters
            return parameters
        }
    }
}

1	import {	26✔
2	Logger,	26✔
3	LogLevel,	26✔
4	LogMessage,	26✔
5	LogMessageType,	26✔
6	PrepareLogMessagesOptions,	26✔
7	} from "./Logger"	26✔
8	import { QueryRunner } from "../query-runner/QueryRunner"	26✔
9	import { LoggerOptions } from "./LoggerOptions"	26✔
10	import { PlatformTools } from "../platform/PlatformTools"	26✔
11		26✔
12	export abstract class AbstractLogger implements Logger {	26✔
13	// -------------------------------------------------------------------------	26✔
14	// Constructor	26✔
15	// -------------------------------------------------------------------------	26✔
16		26✔
17	constructor(protected options?: LoggerOptions) {}	26✔
18		26✔
19	// -------------------------------------------------------------------------	26✔
20	// Public Methods	26✔
21	// -------------------------------------------------------------------------	26✔
22		26✔
23	/**	26✔
24	* Logs query and parameters used in it.	26✔
25	*/	26✔
26	logQuery(query: string, parameters?: any[], queryRunner?: QueryRunner) {	26✔
27	if (!this.isLogEnabledFor("query")) {	1,953,570✔
28	return	1,949,790✔
29	}	1,949,790✔
30		3,780✔
31	this.writeLog(	3,780✔
32	"query",	3,780✔
33	{	3,780✔
34	type: "query",	3,780✔
35	prefix: "query",	3,780✔
36	message: query,	3,780✔
37	format: "sql",	3,780✔
38	parameters,	3,780✔
39	},	3,780✔
40	queryRunner,	3,780✔
41	)	3,780✔
42	}	3,780✔
43		26✔
44	/**	26✔
45	* Logs query that is failed.	26✔
46	*/	26✔
47	logQueryError(	26✔
48	error: string,	253✔
49	query: string,	253✔
50	parameters?: any[],	253✔
51	queryRunner?: QueryRunner,	253✔
52	) {	253✔
53	if (!this.isLogEnabledFor("query-error")) {	253✔
54	return	253✔
55	}	253✔
56		×
57	this.writeLog(	×
58	"warn",	×
59	[	×
60	{	×
61	type: "query-error",	×
62	prefix: "query failed",	×
63	message: query,	×
64	format: "sql",	×
65	parameters,	×
66	},	×
67	{	×
68	type: "query-error",	×
69	prefix: "error",	×
70	message: error,	×
71	},	×
72	],	×
73	queryRunner,	×
74	)	×
75	}	×
76		26✔
77	/**	26✔
78	* Logs query that is slow.	26✔
79	*/	26✔
80	logQuerySlow(	26✔
81	time: number,	14✔
82	query: string,	14✔
83	parameters?: any[],	14✔
84	queryRunner?: QueryRunner,	14✔
85	) {	14✔
86	if (!this.isLogEnabledFor("query-slow")) {	14!
87	return	×
88	}	×
89		14✔
90	this.writeLog(	14✔
91	"warn",	14✔
92	[	14✔
93	{	14✔
94	type: "query-slow",	14✔
95	prefix: "query is slow",	14✔
96	message: query,	14✔
97	format: "sql",	14✔
98	parameters,	14✔
99	additionalInfo: {	14✔
100	time,	14✔
101	},	14✔
102	},	14✔
103	{	14✔
104	type: "query-slow",	14✔
105	prefix: "execution time",	14✔
106	message: time,	14✔
107	},	14✔
108	],	14✔
109	queryRunner,	14✔
110	)	14✔
111	}	14✔
112		26✔
113	/**	26✔
114	* Logs events from the schema build process.	26✔
115	*/	26✔
116	logSchemaBuild(message: string, queryRunner?: QueryRunner) {	26✔
117	if (!this.isLogEnabledFor("schema-build")) {	184,681✔
118	return	184,513✔
119	}	184,513✔
120		168!
121	this.writeLog(	168✔
122	"schema",	168✔
123	{	168✔
124	type: "schema-build",	168✔
125	message,	168✔
126	},	168✔
127	queryRunner,	168✔
128	)	168✔
129	}	168✔
130		26✔
131	/**	26✔
132	* Logs events from the migration run process.	26✔
133	*/	26✔
134	logMigration(message: string, queryRunner?: QueryRunner) {	26✔
135	if (!this.isLogEnabledFor("migration")) {	64!
136	return	×
137	}	×
138		64✔
139	this.writeLog(	64✔
140	"log",	64✔
141	{	64✔
142	type: "migration",	64✔
143	message,	64✔
144	},	64✔
145	queryRunner,	64✔
146	)	64✔
147	}	64✔
148		26✔
149	/**	26✔
150	* Perform logging using given logger, or by default to the console.	26✔
151	* Log has its own level and message.	26✔
152	*/	26✔
153	log(	26✔
154	level: "log" \| "info" \| "warn",	11,379✔
155	message: any,	11,379✔
156	queryRunner?: QueryRunner,	11,379✔
157	) {	11,379✔
158	switch (level) {	11,379✔
159	case "log":	11,379!
160	if (!this.isLogEnabledFor("log")) {	×
161	return	×
162	}	×
163		×
164	this.writeLog(	×
165	"log",	×
166	{	×
167	type: "log",	×
168	message,	×
169	},	×
170	queryRunner,	×
171	)	×
172	break	×
173		11,379✔
174	case "info":	11,379✔
175	if (!this.isLogEnabledFor("info")) {	11,377✔
176	return	11,377✔
177	}	11,377✔
178		×
179	this.writeLog(	×
180	"info",	×
181	{	×
182	type: "info",	×
183	prefix: "info",	×
184	message,	×
185	},	×
186	queryRunner,	×
187	)	×
188	break	×
189		11,379✔
190	case "warn":	11,379!
191	if (!this.isLogEnabledFor("warn")) {	2✔
192	return	2✔
193	}	2✔
194		×
195	this.writeLog(	×
196	"warn",	×
197	{	×
198	type: "warn",	×
199	message,	×
200	},	×
201	queryRunner,	×
202	)	×
203	break	×
204	}	11,379✔
205	}	11,379✔
206		26✔
207	// -------------------------------------------------------------------------	26✔
208	// Protected Methods	26✔
209	// -------------------------------------------------------------------------	26✔
210		26✔
211	/**	26✔
212	* Check is logging for level or message type is enabled.	26✔
213	*/	26✔
214	protected isLogEnabledFor(type?: LogLevel \| LogMessageType) {	26✔
215	switch (type) {	2,149,961✔
216	case "query":	2,149,961✔
217	return (	1,953,570✔
218	this.options === "all" \|\|	1,953,570!
219	this.options === true \|\|	1,953,570!
220	(Array.isArray(this.options) &&	1,950,899✔
221	this.options.indexOf("query") !== -1)	1,950,899✔
222	)	1,953,570✔
223		2,149,961✔
224	case "error":	2,149,961!
225	case "query-error":	2,149,961!
226	return (	253✔
227	this.options === "all" \|\|	253✔
228	this.options === true \|\|	253✔
229	(Array.isArray(this.options) &&	253!
230	this.options.indexOf("error") !== -1)	253✔
231	)	253✔
232		2,149,961✔
233	case "query-slow":	2,149,961!
234	return true	14✔
235		2,149,961✔
236	case "schema":	2,149,961!
237	case "schema-build":	2,149,961✔
238	return (	184,681✔
239	this.options === "all" \|\|	184,681✔
240	(Array.isArray(this.options) &&	184,513!
241	this.options.indexOf("schema") !== -1)	184,513✔
242	)	184,681✔
243		2,149,961✔
244	case "migration":	2,149,961!
245	return true	64✔
246		2,149,961✔
247	case "log":	2,149,961!
248	return (	×
249	this.options === "all" \|\|	×
250	(Array.isArray(this.options) &&	×
251	this.options.indexOf("log") !== -1)	×
252	)	×
253		2,149,961✔
254	case "info":	2,149,961✔
255	return (	11,377✔
256	this.options === "all" \|\|	11,377✔
257	(Array.isArray(this.options) &&	11,377!
258	this.options.indexOf("info") !== -1)	11,377✔
259	)	11,377✔
260		2,149,961✔
261	case "warn":	2,149,961!
262	return (	2✔
263	this.options === "all" \|\|	2✔
264	(Array.isArray(this.options) &&	2!
265	this.options.indexOf("warn") !== -1)	2✔
266	)	2✔
267		2,149,961✔
268	default:	2,149,961!
269	return false	×
270	}	2,149,961✔
271	}	2,149,961✔
272		26✔
273	/**	26✔
274	* Write log to specific output.	26✔
275	*/	26✔
276	protected abstract writeLog(	26✔
277	level: LogLevel,	26✔
278	message:	26✔
279	\| LogMessage	26✔
280	\| string	26✔
281	\| number	26✔
282	\| (LogMessage \| string \| number)[],	26✔
283	queryRunner?: QueryRunner,	26✔
284	): void	26✔
285		26✔
286	/**	26✔
287	* Prepare and format log messages	26✔
288	*/	26✔
289	protected prepareLogMessages(	26✔
290	logMessage:	4,026✔
291	\| LogMessage	4,026✔
292	\| string	4,026✔
293	\| number	4,026✔
294	\| (LogMessage \| string \| number)[],	4,026✔
295	options?: Partial<PrepareLogMessagesOptions>,	4,026✔
296	queryRunner?: QueryRunner,	4,026✔
297	): LogMessage[] {	4,026✔
298	options = {	4,026✔
299	...{	4,026✔
300	addColonToPrefix: true,	4,026✔
301	appendParameterAsComment: true,	4,026✔
302	highlightSql: true,	4,026✔
303	formatSql: false,	4,026✔
304	},	4,026✔
305	...options,	4,026✔
306	}	4,026✔
307	const messages = Array.isArray(logMessage) ? logMessage : [logMessage]	4,026!
308		4,026✔
309	for (let message of messages) {	4,026✔
310	if (typeof message !== "object") {	4,040!
311	message = {	×
312	message,	×
313	}	×
314	}	×
315		4,040✔
316	if (message.format === "sql") {	4,040✔
317	let sql = String(message.message)	3,794✔
318		3,794✔
319	if (options.formatSql) {	3,794✔
320	sql = PlatformTools.formatSql(	78✔
321	sql,	78✔
322	queryRunner?.connection?.options.type,	78!
323	)	78✔
324	}	78✔
325		3,794✔
326	if (	3,794✔
327	options.appendParameterAsComment &&	3,794✔
328	message.parameters &&	3,794!
329	message.parameters.length	926✔
330	) {	3,794!
331	sql += ` -- PARAMETERS: ${this.stringifyParams(	14✔
332	message.parameters,	14✔
333	)}`	14✔
334	}	14✔
335		3,794✔
336	if (options.highlightSql) {	3,794✔
337	sql = PlatformTools.highlightSql(sql)	92✔
338	}	92✔
339		3,794✔
340	message.message = sql	3,794✔
341	}	3,794✔
342		4,040✔
343	if (options.addColonToPrefix && message.prefix) {	4,040✔
344	message.prefix += ":"	106✔
345	}	106✔
346	}	4,040✔
347		4,026✔
348	return messages as LogMessage[]	4,026✔
349	}	4,026✔
350		26✔
351	/**	26✔
352	* Converts parameters to a string.	26✔
353	* Sometimes parameters can have circular objects and therefor we are handle this case too.	26✔
354	*/	26✔
355	protected stringifyParams(parameters: any[]) {	26✔
356	try {	14✔
357	return JSON.stringify(parameters)	14✔
358	} catch (error) {	14!
359	// most probably circular objects in parameters	×
360	return parameters	×
361	}	×
362	}	14✔
363	}	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