15718025836

Committed 17 Jun 2025 09:05PM UTC coverage: 76.35% (-0.04%) from 76.389%

Build # 15718025836

Build Type

push

github

Committed by

web-flow

Commit Message

fix: fix null pointer exception on date array column comparison (#11532)

* fix: fix null pointer exception on date array column comparison

Follow up to https://github.com/typeorm/typeorm/pull/11269 which was
calling Array.map without validating if the array was null. Now only
normalize if both values (entity and database) are not null.

Closes: https://github.com/typeorm/typeorm/issues/11514

* clean test

Run Details

9291 of 12879 branches covered (72.14%)

Branch coverage included in aggregate %.

3 of 3 new or added lines in 1 file covered. (100.0%)

8 existing lines in 3 files now uncovered.

19002 of 24178 relevant lines covered (78.59%)

197039.47 hits per line

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

64.66

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

typeorm / typeorm / 15718025836

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