@mikro-orm/core 7.1.0-dev.8 → 7.1.0-dev.9

package/EntityManager.d.ts

@@ -6,8 +6,8 @@ import { type EntityRepository } from './entity/EntityRepository.js';
 import { EntityLoader, type EntityLoaderOptions } from './entity/EntityLoader.js';
 import { Reference } from './entity/Reference.js';
 import { UnitOfWork } from './unit-of-work/UnitOfWork.js';
-import type { CountOptions, DeleteOptions, FilterOptions, FindAllOptions, FindByCursorOptions, FindOneOptions, FindOneOrFailOptions, FindOptions, GetReferenceOptions, IDatabaseDriver, LockOptions, NativeInsertUpdateOptions, StreamOptions, UpdateOptions, UpsertManyOptions, UpsertOptions } from './drivers/IDatabaseDriver.js';
-import type { AnyString, ArrayElement, AutoPath, ConnectionType, Dictionary, EntityClass, EntityData, EntityDictionary, EntityDTO, EntityMetadata, EntityName, FilterDef, FilterQuery, FromEntityType, GetRepository, IHydrator, IsSubset, Loaded, MergeLoaded, MergeSelected, ObjectQuery, PopulateOptions, Primary, Ref, RequiredEntityData, UnboxArray, IndexFilterQuery, WithUsingOptions } from './typings.js';
+import type { CountByOptions, CountOptions, DeleteOptions, FilterOptions, FindAllOptions, FindByCursorOptions, FindOneOptions, FindOneOrFailOptions, FindOptions, GetReferenceOptions, IDatabaseDriver, LockOptions, NativeInsertUpdateOptions, StreamOptions, UpdateOptions, UpsertManyOptions, UpsertOptions } from './drivers/IDatabaseDriver.js';
+import type { AnyString, ArrayElement, AutoPath, ConnectionType, Dictionary, EntityClass, EntityData, EntityDictionary, EntityDTO, EntityKey, EntityMetadata, EntityName, FilterDef, FilterQuery, FromEntityType, GetRepository, IHydrator, IsSubset, Loaded, MergeLoaded, MergeSelected, ObjectQuery, PopulateOptions, Primary, Ref, RequiredEntityData, UnboxArray, IndexFilterQuery, WithUsingOptions } from './typings.js';
 import { FlushMode, LockMode, PopulatePath, type TransactionOptions } from './enums.js';
 import type { MetadataStorage } from './metadata/MetadataStorage.js';
 import type { Transaction } from './connections/Connection.js';
@@ -441,6 +441,27 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
      * Returns total number of entities matching your `where` query.
      */
     count<Entity extends object, Hint extends string = never>(entityName: EntityName<Entity>, where?: FilterQuery<NoInfer<Entity>>, options?: CountOptions<Entity, Hint>): Promise<number>;
+    /**
+     * Counts entities grouped by one or more properties. Returns a dictionary keyed by the grouped
+     * field value(s), with counts as values. For composite `groupBy`, keys are joined with `~~~`.
+     *
+     * SQL drivers issue a single `GROUP BY` query; MongoDB uses an aggregation pipeline.
+     *
+     * @example
+     * ```ts
+     * // Count books per author
+     * const counts = await em.countBy(Book, 'author');
+     * // { '1': 2, '2': 1, '3': 3 }
+     *
+     * // Count with a filter
+     * const counts = await em.countBy(Book, 'author', { where: { active: true } });
+     *
+     * // Composite groupBy — keys joined with ~~~
+     * const counts = await em.countBy(Order, ['status', 'country']);
+     * // { 'pending~~~US': 5, 'shipped~~~DE': 3 }
+     * ```
+     */
+    countBy<Entity extends object>(entityName: EntityName<Entity>, groupBy: EntityKey<Entity> | readonly EntityKey<Entity>[], options?: CountByOptions<Entity>): Promise<Dictionary<number>>;
     /**
      * Tells the EntityManager to make an instance managed and persistent.
      * The entity will be entered into the database at or before transaction commit or as a result of the flush operation.
@@ -543,7 +564,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
      * some additional lazy properties, if so, we reload and merge the data from database
      */
     protected shouldRefresh<T extends object, P extends string = never, F extends string = never, E extends string = never>(meta: EntityMetadata<T>, entity: T, options: FindOneOptions<T, P, F, E>): boolean;
-    protected prepareOptions(options: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any> | CountOptions<any, any>): void;
+    protected prepareOptions(options: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any> | CountOptions<any, any> | CountByOptions<any>): void;
     /**
      * @internal
      */
@@ -585,7 +606,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
      */
     set schema(schema: string | null | undefined);
     /** @internal */
-    getDataLoader(type: 'ref' | '1:m' | 'm:n'): Promise<any>;
+    getDataLoader(type: 'ref' | '1:m' | 'm:n' | 'count'): Promise<any>;
     /**
      * Returns the ID of this EntityManager. Respects the context, so global EM will give you the contextual ID
      * if executed inside request context handler.

package/EntityManager.js

@@ -1458,6 +1458,29 @@ export class EntityManager {
         await em.storeCache(options.cache, cached, () => +count);
         return +count;
     }
+    /**
+     * Counts entities grouped by one or more properties. Returns a dictionary keyed by the grouped
+     * field value(s), with counts as values. For composite `groupBy`, keys are joined with `~~~`.
+     *
+     * SQL drivers issue a single `GROUP BY` query; MongoDB uses an aggregation pipeline.
+     *
+     * @example
+     * ```ts
+     * // Count books per author
+     * const counts = await em.countBy(Book, 'author');
+     * // { '1': 2, '2': 1, '3': 3 }
+     *
+     * // Count with a filter
+     * const counts = await em.countBy(Book, 'author', { where: { active: true } });
+     *
+     * // Composite groupBy — keys joined with ~~~
+     * const counts = await em.countBy(Order, ['status', 'country']);
+     * // { 'pending~~~US': 5, 'shipped~~~DE': 3 }
+     * ```
+     */
+    async countBy(entityName, groupBy, options) {
+        throw new Error(`${this.constructor.name}.countBy() is not supported by the current driver`);
+    }
     /**
      * Tells the EntityManager to make an instance managed and persistent.
      * The entity will be entered into the database at or before transaction commit or as a result of the flush operation.
@@ -2031,6 +2054,8 @@ export class EntityManager {
                 return (em.#loaders[type] ??= new DataLoader(DataloaderUtils.getColBatchLoadFn(em)));
             case 'm:n':
                 return (em.#loaders[type] ??= new DataLoader(DataloaderUtils.getManyToManyColBatchLoadFn(em)));
+            case 'count':
+                return (em.#loaders[type] ??= new DataLoader(DataloaderUtils.getCountBatchLoadFn(em)));
         }
     }
     /**

package/drivers/IDatabaseDriver.d.ts

@@ -325,6 +325,16 @@ export interface CountOptions<T extends object, P extends string = never> {
     /** @internal used to apply filters to the auto-joined relations */
     em?: EntityManager;
 }
+/** Options for `em.countBy()` queries. */
+export interface CountByOptions<T extends object> {
+    where?: FilterQuery<T>;
+    filters?: FilterOptions;
+    having?: FilterQuery<T>;
+    schema?: string;
+    flushMode?: FlushMode | `${FlushMode}`;
+    loggerContext?: LogContext;
+    logging?: LoggingOptions;
+}
 /** Options for `em.qb().update()` operations. */
 export interface UpdateOptions<T> {
     filters?: FilterOptions;

package/entity/Collection.d.ts

@@ -37,6 +37,7 @@ export declare class Collection<T extends object, O extends object = object> {
     /**
      * Gets the count of collection items from database instead of counting loaded items.
      * The value is cached (unless you use the `where` option), use `refresh: true` to force reload it.
+     * When the dataloader is enabled (globally or per-query), multiple calls are batched into a single grouped query.
      */
     loadCount(options?: LoadCountOptions<T> | boolean): Promise<number>;
     /** Queries a subset of the collection items from the database with custom filtering, ordering, and pagination. */
@@ -193,4 +194,6 @@ export interface LoadCountOptions<T extends object> extends CountOptions<T, '*'>
     refresh?: boolean;
     /** Additional filtering conditions for the count query. */
     where?: FilterQuery<T>;
+    /** Whether to use the dataloader for batching count operations. */
+    dataloader?: boolean;
 }

package/entity/Collection.js

@@ -79,10 +79,11 @@ export class Collection {
     /**
      * Gets the count of collection items from database instead of counting loaded items.
      * The value is cached (unless you use the `where` option), use `refresh: true` to force reload it.
+     * When the dataloader is enabled (globally or per-query), multiple calls are batched into a single grouped query.
      */
     async loadCount(options = {}) {
         options = typeof options === 'boolean' ? { refresh: options } : options;
-        const { refresh, where, ...countOptions } = options;
+        const { refresh, where, dataloader, ...countOptions } = options;
         if (!refresh && !where && this.#count != null) {
             return this.#count;
         }
@@ -92,8 +93,15 @@ export class Collection {
             this.property.owner) {
             return (this.#count = this.length);
         }
-        const cond = this.createLoadCountCondition(where ?? {});
-        const count = await em.count(this.property.targetMeta.class, cond, countOptions);
+        let count;
+        if (dataloader ?? [DataloaderType.ALL, DataloaderType.COLLECTION].includes(em.config.getDataloaderType())) {
+            const loader = await em.getDataLoader('count');
+            count = await loader.load([this, { where, ...countOptions }]);
+        }
+        else {
+            const cond = this.createLoadCountCondition(where ?? {});
+            count = await em.count(this.property.targetMeta.class, cond, countOptions);
+        }
         if (!where) {
             this.#count = count;
         }

package/entity/EntityRepository.d.ts

@@ -1,8 +1,8 @@
 import type { PopulatePath } from '../enums.js';
 import type { CreateOptions, EntityManager, MergeOptions } from '../EntityManager.js';
 import type { AssignOptions } from './EntityAssigner.js';
-import type { EntityData, EntityName, Primary, Loaded, FilterQuery, EntityDictionary, AutoPath, RequiredEntityData, Ref, EntityType, EntityDTO, MergeSelected, FromEntityType, IsSubset, MergeLoaded, ArrayElement, IndexFilterQuery, WithUsingOptions } from '../typings.js';
-import type { CountOptions, DeleteOptions, FindAllOptions, FindByCursorOptions, FindOneOptions, FindOneOrFailOptions, FindOptions, GetReferenceOptions, NativeInsertUpdateOptions, StreamOptions, UpdateOptions, UpsertManyOptions, UpsertOptions } from '../drivers/IDatabaseDriver.js';
+import type { Dictionary, EntityData, EntityDictionary, EntityKey, EntityName, FilterQuery, Loaded, Primary, AutoPath, RequiredEntityData, Ref, EntityType, EntityDTO, MergeSelected, FromEntityType, IsSubset, MergeLoaded, ArrayElement, IndexFilterQuery, WithUsingOptions } from '../typings.js';
+import type { CountByOptions, CountOptions, DeleteOptions, FindAllOptions, FindByCursorOptions, FindOneOptions, FindOneOrFailOptions, FindOptions, GetReferenceOptions, NativeInsertUpdateOptions, StreamOptions, UpdateOptions, UpsertManyOptions, UpsertOptions } from '../drivers/IDatabaseDriver.js';
 import type { EntityLoaderOptions } from './EntityLoader.js';
 import type { Cursor } from '../utils/Cursor.js';
 /** Repository class providing a type-safe API for querying and persisting a specific entity type. */
@@ -207,6 +207,16 @@ export declare class EntityRepository<Entity extends object> {
      * Returns total number of entities matching your `where` query.
      */
     count<Hint extends string = never>(where?: FilterQuery<Entity>, options?: CountOptions<Entity, Hint>): Promise<number>;
+    /**
+     * Counts entities grouped by one or more properties.
+     *
+     * @example
+     * ```ts
+     * const counts = await repo.countBy('status');
+     * // { 'active': 5, 'inactive': 2 }
+     * ```
+     */
+    countBy(groupBy: EntityKey<Entity> | readonly EntityKey<Entity>[], options?: CountByOptions<Entity>): Promise<Dictionary<number>>;
     /** Returns the entity class name associated with this repository. */
     getEntityName(): string;
     /**

package/entity/EntityRepository.js

@@ -194,6 +194,18 @@ export class EntityRepository {
     async count(where = {}, options = {}) {
         return this.getEntityManager().count(this.entityName, where, options);
     }
+    /**
+     * Counts entities grouped by one or more properties.
+     *
+     * @example
+     * ```ts
+     * const counts = await repo.countBy('status');
+     * // { 'active': 5, 'inactive': 2 }
+     * ```
+     */
+    async countBy(groupBy, options) {
+        return this.getEntityManager().countBy(this.entityName, groupBy, options);
+    }
     /** Returns the entity class name associated with this repository. */
     getEntityName() {
         return Utils.className(this.entityName);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.1.0-dev.8",
+  "version": "7.1.0-dev.9",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",

package/utils/DataloaderUtils.d.ts

@@ -1,5 +1,5 @@
 import type { Constructor, Primary, Ref } from '../typings.js';
-import { Collection, type InitCollectionOptions } from '../entity/Collection.js';
+import { Collection, type InitCollectionOptions, type LoadCountOptions } from '../entity/Collection.js';
 import { type EntityManager } from '../EntityManager.js';
 import { type LoadReferenceOptions } from '../entity/Reference.js';
 type BatchLoadFn<K, V> = (keys: readonly K[]) => PromiseLike<ArrayLike<V | Error>>;
@@ -44,6 +44,15 @@ export declare class DataloaderUtils {
      * makes one query per entity and maps each input collection to the corresponding result.
      */
     static getManyToManyColBatchLoadFn(em: EntityManager): BatchLoadFn<[Collection<any>, Omit<InitCollectionOptions<any, any>, 'dataloader'>?], any>;
+    /**
+     * Returns the count dataloader batchLoadFn, which aggregates `Collection.loadCount()` calls
+     * by entity and relation, issues a single grouped count query per entity+options combination
+     * via `em.countBy()`, and maps each input collection to the corresponding count.
+     *
+     * For 1:M relations, groups by the FK property on the target entity.
+     * For M:N relations, groups by the owner FK on the pivot entity.
+     */
+    static getCountBatchLoadFn(em: EntityManager): BatchLoadFn<[Collection<any>, Omit<LoadCountOptions<any>, 'dataloader' | 'refresh'>?], number>;
     static getDataLoader(): Promise<Constructor<{
         load: (...args: unknown[]) => Promise<unknown>;
     }>>;

package/utils/DataloaderUtils.js

@@ -1,6 +1,7 @@
 import { Collection } from '../entity/Collection.js';
 import { helper } from '../entity/wrap.js';
 import { Reference } from '../entity/Reference.js';
+import { ReferenceKind } from '../enums.js';
 import { Utils } from './Utils.js';
 export class DataloaderUtils {
     static DataLoader;
@@ -216,6 +217,83 @@ export class DataloaderUtils {
             return ret;
         };
     }
+    /**
+     * Returns the count dataloader batchLoadFn, which aggregates `Collection.loadCount()` calls
+     * by entity and relation, issues a single grouped count query per entity+options combination
+     * via `em.countBy()`, and maps each input collection to the corresponding count.
+     *
+     * For 1:M relations, groups by the FK property on the target entity.
+     * For M:N relations, groups by the owner FK on the pivot entity.
+     */
+    static getCountBatchLoadFn(em) {
+        return async (collsWithOpts) => {
+            const groups = new Map();
+            const keys = [];
+            for (const [col, opts] of collsWithOpts) {
+                const prop = col.property;
+                let fkProp;
+                let countByClass;
+                let targetFilterProp;
+                if (prop.kind === ReferenceKind.ONE_TO_MANY) {
+                    fkProp = prop.mappedBy;
+                    countByClass = prop.targetMeta.class;
+                }
+                else {
+                    // M:N: group by the owner FK on the pivot entity
+                    const pivotMeta = em.getMetadata().get(prop.pivotEntity);
+                    const ownerPivotProp = pivotMeta.relations[prop.owner ? 0 : 1];
+                    const targetPivotProp = pivotMeta.relations[prop.owner ? 1 : 0];
+                    fkProp = ownerPivotProp.name;
+                    countByClass = pivotMeta.class;
+                    targetFilterProp = targetPivotProp.name;
+                }
+                // Include the owner-side uniqueName in the key so that two distinct owner entity types
+                // sharing a relation with the same property name (e.g. `Author.books` and `Publisher.books`)
+                // don't collide into a single batch that would use one owner's FK mapping for the other.
+                const ownerUniqueName = helper(col.owner).__meta.uniqueName;
+                const key = `${ownerUniqueName}.${prop.name}|${JSON.stringify(opts ?? {})}`;
+                keys.push(key);
+                let group = groups.get(key);
+                if (!group) {
+                    group = { fkProp, countByClass, targetFilterProp, ownerPKs: new Map(), opts: opts ?? {} };
+                    groups.set(key, group);
+                }
+                const pk = helper(col.owner).getPrimaryKey();
+                group.ownerPKs.set(JSON.stringify(pk), pk);
+            }
+            const promises = Array.from(groups.entries()).map(async ([key, group]) => {
+                const allPKs = Array.from(group.ownerPKs.values());
+                const { where, ...countOpts } = group.opts;
+                const conditions = [{ [group.fkProp]: { $in: allPKs } }];
+                if (where) {
+                    conditions.push(where);
+                }
+                // For M:N, apply the target entity's filters through the pivot's target relation
+                if (group.targetFilterProp) {
+                    const targetMeta = em.getMetadata().find(group.countByClass);
+                    const targetRelMeta = targetMeta.properties[group.targetFilterProp]?.targetMeta;
+                    if (targetRelMeta) {
+                        const filterCond = await em.applyFilters(targetRelMeta.class, {}, countOpts.filters, 'read');
+                        if (filterCond && Object.keys(filterCond).length > 0) {
+                            conditions.push({ [group.targetFilterProp]: filterCond });
+                        }
+                    }
+                }
+                const fkWhere = conditions.length === 1 ? conditions[0] : { $and: conditions };
+                const counts = await em.countBy(group.countByClass, group.fkProp, {
+                    where: fkWhere,
+                    ...countOpts,
+                });
+                return [key, counts];
+            });
+            const resultsMap = new Map(await Promise.all(promises));
+            return collsWithOpts.map(([col], i) => {
+                const pk = helper(col.owner).getPrimaryKey();
+                const counts = resultsMap.get(keys[i]);
+                return counts?.[String(pk)] ?? 0;
+            });
+        };
+    }
     static async getDataLoader() {
         if (this.DataLoader) {
             return this.DataLoader;

package/utils/Utils.js

@@ -141,7 +141,7 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.1.0-dev.8';
+    static #ORM_VERSION = '7.1.0-dev.9';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */