fix: allow where IsNull for ManyToOne relations

Closes: #9980

src/query-builder/SelectQueryBuilder.ts

@@ -4154,6 +4154,16 @@ export class SelectQueryBuilder<Entity>
                                     " " +
                                     parseInt(where[key].value),
                             )
+                        } else if (where[key].type === "isNull") {
+                            if (relation.isManyToOne) {
+                                andConditions.push(
+                                    `${alias}.${propertyPath} IS NULL`,
+                                )
+                            } else {
+                                throw new Error(
+                                    `This relation isn't supported by given find operator`,
+                                )
+                            }
                         }
                     } else {
                         // const joinAlias = alias + "_" + relation.propertyName;

test/github-issues/8890/entity/Author.ts

@@ -0,0 +1,20 @@
+import { Column, Entity, OneToMany, PrimaryColumn } from "../../../../src"
+import { Post } from "./Post"
+
+@Entity()
+export class Author {
+    @PrimaryColumn()
+    id: number
+
+    @Column()
+    firstName: string
+
+    @Column()
+    lastName: string
+
+    @Column()
+    age: number
+
+    @OneToMany(() => Post, (post) => post.author)
+    posts: Post[]
+}

test/github-issues/8890/entity/Post.ts

@@ -0,0 +1,24 @@
+import {
+    Column,
+    Entity,
+    ManyToOne,
+    PrimaryGeneratedColumn,
+} from "../../../../src"
+import { Author } from "./Author"
+
+@Entity()
+export class Post {
+    @PrimaryGeneratedColumn()
+    id: number
+
+    @Column()
+    title: string
+
+    @Column()
+    text: string
+
+    @ManyToOne(() => Author, (author) => author.posts, {
+        nullable: true,
+    })
+    author: Author
+}

test/github-issues/8890/issue-8890-utils.ts

@@ -0,0 +1,32 @@
+import "reflect-metadata"
+import { EntityManager } from "../../../src"
+import { Post } from "./entity/Post"
+import { Author } from "./entity/Author"
+
+export async function prepareData(manager: EntityManager) {
+    const post1 = new Post()
+    post1.id = 1
+    post1.title = "Post #1"
+    post1.text = "About post #1"
+    await manager.save(post1)
+
+    const post2 = new Post()
+    post2.id = 2
+    post2.title = "Post #2"
+    post2.text = "About post #2"
+    await manager.save(post2)
+
+    const post3 = new Post()
+    post3.id = 3
+    post3.title = "Post #3"
+    post3.text = "About post #3"
+    await manager.save(post3)
+
+    const author1 = new Author()
+    author1.id = 1
+    author1.firstName = "Timber"
+    author1.lastName = "Saw"
+    author1.age = 25
+    author1.posts = [post1]
+    await manager.save(author1)
+}

test/github-issues/8890/issue-8890.ts

@@ -0,0 +1,51 @@
+import "reflect-metadata"
+import "../../utils/test-setup"
+import { DataSource, IsNull } from "../../../src"
+import {
+    closeTestingConnections,
+    createTestingConnections,
+    reloadTestingDatabases,
+} from "../../utils/test-utils"
+import { Post } from "./entity/Post"
+import { prepareData } from "./issue-8890-utils"
+
+describe("github issues > #8890 it should be possible to query IS NULL on ManyToOne relations", () => {
+    let connections: DataSource[]
+    before(
+        async () =>
+            (connections = await createTestingConnections({
+                __dirname,
+            })),
+    )
+    beforeEach(() => reloadTestingDatabases(connections))
+    after(() => closeTestingConnections(connections))
+
+    it("where IsNull", () =>
+        Promise.all(
+            connections.map(async (connection) => {
+                await prepareData(connection.manager)
+
+                const posts = await connection
+                    .createQueryBuilder(Post, "post")
+                    .setFindOptions({
+                        where: {
+                            author: IsNull(),
+                        },
+                    })
+                    .orderBy("id", "ASC")
+                    .getMany()
+                posts.should.be.eql([
+                    {
+                        id: 2,
+                        title: "Post #2",
+                        text: "About post #2",
+                    },
+                    {
+                        id: 3,
+                        title: "Post #3",
+                        text: "About post #3",
+                    },
+                ])
+            }),
+        ))
+})