feat: add exists and exists by (#10291)

This PR deprecates `exist` in favor of `exists` and `existsBy`.

docs/entity-manager-api.md

@@ -183,6 +183,22 @@ await manager.increment(User, { firstName: "Timber" }, "age", 3)
 await manager.decrement(User, { firstName: "Timber" }, "age", 3)
 ```
 
+-   `exists` - Check whether any entity exists that matches `FindOptions`.
+
+```typescript
+const exists = await manager.exists(User, {
+    where: {
+        firstName: "Timber",
+    },
+})
+```
+
+-   `existsBy` - Checks whether any entity exists that matches `FindOptionsWhere`.
+
+```typescript
+const exists = await manager.existsBy(User, { firstName: "Timber" })
+```
+
 -   `count` - Counts entities that match `FindOptions`. Useful for pagination.
 
 ```typescript

docs/repository-api.md

@@ -257,6 +257,22 @@ await repository.increment({ firstName: "Timber" }, "age", 3)
 await repository.decrement({ firstName: "Timber" }, "age", 3)
 ```
 
+-   `exists` - Check whether any entity exists that matches `FindOptions`.
+
+```typescript
+const exists = await repository.exists({
+    where: {
+        firstName: "Timber",
+    },
+})
+```
+
+-   `existsBy` - Checks whether any entity exists that matches `FindOptionsWhere`.
+
+```typescript
+const exists = await repository.existsBy({ firstName: "Timber" })
+```
+
 -   `count` - Counts entities that match `FindOptions`. Useful for pagination.
 
 ```typescript

src/entity-manager/EntityManager.ts

@@ -955,7 +955,7 @@ export class EntityManager {
     }
 
     /**
-     * Checks whether any entity exists with the given condition
+     * Checks whether any entity exists with the given options.
      */
     exists<Entity extends ObjectLiteral>(
         entityClass: EntityTarget<Entity>,
@@ -971,6 +971,19 @@ export class EntityManager {
             .getExists()
     }
 
+    /**
+     * Checks whether any entity exists with the given conditions.
+     */
+    async existsBy<Entity extends ObjectLiteral>(
+        entityClass: EntityTarget<Entity>,
+        where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[],
+    ): Promise<boolean> {
+        const metadata = this.connection.getMetadata(entityClass)
+        return this.createQueryBuilder(entityClass, metadata.name)
+            .setFindOptions({ where })
+            .getExists()
+    }
+
     /**
      * Counts entities that match given options.
      * Useful for pagination.

src/repository/BaseEntity.ts

@@ -389,6 +389,26 @@ export class BaseEntity {
         return this.getRepository<T>().delete(criteria)
     }
 
+    /**
+     * Checks whether any entity exists that matches the given options.
+     */
+    static exists<T extends BaseEntity>(
+        this: { new (): T } & typeof BaseEntity,
+        options?: FindManyOptions<T>,
+    ): Promise<boolean> {
+        return this.getRepository<T>().exists(options)
+    }
+
+    /**
+     * Checks whether any entity exists that matches the given conditions.
+     */
+    static existsBy<T extends BaseEntity>(
+        this: { new (): T } & typeof BaseEntity,
+        where: FindOptionsWhere<T>,
+    ): Promise<boolean> {
+        return this.getRepository<T>().existsBy(where)
+    }
+
     /**
      * Counts entities that match given options.
      */

src/repository/Repository.ts

@@ -453,12 +453,32 @@ export class Repository<Entity extends ObjectLiteral> {
     }
 
     /**
-     * Checks whether any entity exists that match given options.
+     * Checks whether any entity exists that matches the given options.
+     *
+     * @deprecated use `exists` method instead, for example:
+     *
+     * .exists()
      */
     exist(options?: FindManyOptions<Entity>): Promise<boolean> {
         return this.manager.exists(this.metadata.target, options)
     }
 
+    /**
+     * Checks whether any entity exists that matches the given options.
+     */
+    exists(options?: FindManyOptions<Entity>): Promise<boolean> {
+        return this.manager.exists(this.metadata.target, options)
+    }
+
+    /**
+     * Checks whether any entity exists that matches the given conditions.
+     */
+    existsBy(
+        where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[],
+    ): Promise<boolean> {
+        return this.manager.existsBy(this.metadata.target, where)
+    }
+
     /**
      * Counts entities that match given options.
      * Useful for pagination.

test/functional/query-builder/exists/query-builder-exists.ts

@@ -7,7 +7,7 @@ import { DataSource } from "../../../../src/data-source/DataSource"
 import { expect } from "chai"
 import { Test } from "./entity/Test"
 
-describe("query builder > exist", () => {
+describe("query builder > exists", () => {
     let connections: DataSource[]
     before(
         async () =>
@@ -25,8 +25,8 @@ describe("query builder > exist", () => {
             connections.map(async (connection) => {
                 const repo = connection.getRepository(Test)
 
-                const exist = await repo.exist()
-                expect(exist).to.be.equal(false)
+                const exists = await repo.exists()
+                expect(exists).to.be.equal(false)
             }),
         ))
 
@@ -38,8 +38,8 @@ describe("query builder > exist", () => {
                 await repo.save({ id: "ok" })
                 await repo.save({ id: "nok" })
 
-                const exist = await repo.exist()
-                expect(exist).to.be.equal(true)
+                const exists = await repo.exists()
+                expect(exists).to.be.equal(true)
             }),
         ))
 })

test/functional/repository/find-methods/repostiory-find-methods.ts

@@ -149,8 +149,8 @@ describe("repository > find methods", () => {
                         await postRepository.save(post)
                     }
 
-                    // check exist method
-                    const exists = await postRepository.exist({
+                    // check exists method
+                    const exists = await postRepository.exists({
                         order: { id: "ASC" },
                     })
                     exists.should.be.equal(true)
@@ -169,8 +169,8 @@ describe("repository > find methods", () => {
                         await postRepository.save(post)
                     }
 
-                    // check exist method
-                    const exists = await postRepository.exist({
+                    // check exists method
+                    const exists = await postRepository.exists({
                         where: { categoryName: "odd" },
                         order: { id: "ASC" },
                     })
@@ -191,8 +191,8 @@ describe("repository > find methods", () => {
                         await postRepository.save(post)
                     }
 
-                    // check exist method
-                    const exists = await postRepository.exist({
+                    // check exists method
+                    const exists = await postRepository.exists({
                         where: { categoryName: "odd", isNew: true },
                         order: { id: "ASC" },
                     })
@@ -215,8 +215,8 @@ describe("repository > find methods", () => {
                         await postRepository.save(post)
                     }
 
-                    // check exist method
-                    const exists = await postRepository.exist()
+                    // check exists method
+                    const exists = await postRepository.exists()
                     exists.should.be.equal(true)
                 }),
             ))
@@ -236,8 +236,8 @@ describe("repository > find methods", () => {
                         await postRepository.save(post)
                     }
 
-                    // check exist method
-                    const exists = await postRepository.exist({
+                    // check exists method
+                    const exists = await postRepository.exists({
                         where: { categoryName: "even", isNew: true },
                         skip: 1,
                         take: 2,