@mikro-orm/core 7.0.0-dev.1 → 7.0.0-dev.11

package/decorators/hooks.js

@@ -1,59 +1,47 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BeforeCreate = BeforeCreate;
-exports.AfterCreate = AfterCreate;
-exports.BeforeUpdate = BeforeUpdate;
-exports.AfterUpdate = AfterUpdate;
-exports.BeforeUpsert = BeforeUpsert;
-exports.AfterUpsert = AfterUpsert;
-exports.OnInit = OnInit;
-exports.OnLoad = OnLoad;
-exports.BeforeDelete = BeforeDelete;
-exports.AfterDelete = AfterDelete;
-const metadata_1 = require("../metadata");
-const enums_1 = require("../enums");
+import { MetadataStorage } from '../metadata/MetadataStorage.js';
+import { EventType } from '../enums.js';
 function hook(type) {
     return function (target, method) {
-        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target.constructor);
+        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
         if (!meta.hooks[type]) {
             meta.hooks[type] = [];
         }
         meta.hooks[type].push(method);
     };
 }
-function BeforeCreate() {
-    return hook(enums_1.EventType.beforeCreate);
+export function BeforeCreate() {
+    return hook(EventType.beforeCreate);
 }
-function AfterCreate() {
-    return hook(enums_1.EventType.afterCreate);
+export function AfterCreate() {
+    return hook(EventType.afterCreate);
 }
-function BeforeUpdate() {
-    return hook(enums_1.EventType.beforeUpdate);
+export function BeforeUpdate() {
+    return hook(EventType.beforeUpdate);
 }
-function AfterUpdate() {
-    return hook(enums_1.EventType.afterUpdate);
+export function AfterUpdate() {
+    return hook(EventType.afterUpdate);
 }
-function BeforeUpsert() {
-    return hook(enums_1.EventType.beforeUpsert);
+export function BeforeUpsert() {
+    return hook(EventType.beforeUpsert);
 }
-function AfterUpsert() {
-    return hook(enums_1.EventType.afterUpsert);
+export function AfterUpsert() {
+    return hook(EventType.afterUpsert);
 }
-function OnInit() {
-    return hook(enums_1.EventType.onInit);
+export function OnInit() {
+    return hook(EventType.onInit);
 }
-function OnLoad() {
-    return hook(enums_1.EventType.onLoad);
+export function OnLoad() {
+    return hook(EventType.onLoad);
 }
 /**
  * Called before deleting entity, but only when providing initialized entity to EM#remove()
  */
-function BeforeDelete() {
-    return hook(enums_1.EventType.beforeDelete);
+export function BeforeDelete() {
+    return hook(EventType.beforeDelete);
 }
 /**
  * Called after deleting entity, but only when providing initialized entity to EM#remove()
  */
-function AfterDelete() {
-    return hook(enums_1.EventType.afterDelete);
+export function AfterDelete() {
+    return hook(EventType.afterDelete);
 }

package/decorators/index.d.ts

@@ -1,17 +1,17 @@
-export * from './PrimaryKey';
-export * from './Entity';
-export * from './OneToOne';
-export * from './ManyToOne';
-export * from './ManyToMany';
-export { OneToMany, OneToManyOptions } from './OneToMany';
-export * from './Property';
-export * from './Check';
-export * from './Enum';
-export * from './Formula';
-export * from './Indexed';
-export * from './Embeddable';
-export * from './Embedded';
-export * from './Filter';
-export * from './CreateRequestContext';
-export * from './hooks';
-export * from './Transactional';
+export * from './PrimaryKey.js';
+export * from './Entity.js';
+export * from './OneToOne.js';
+export * from './ManyToOne.js';
+export * from './ManyToMany.js';
+export { OneToMany, OneToManyOptions } from './OneToMany.js';
+export * from './Property.js';
+export * from './Check.js';
+export * from './Enum.js';
+export * from './Formula.js';
+export * from './Indexed.js';
+export * from './Embeddable.js';
+export * from './Embedded.js';
+export * from './Filter.js';
+export * from './CreateRequestContext.js';
+export * from './hooks.js';
+export * from './Transactional.js';

package/decorators/index.js

@@ -1,36 +1,17 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OneToMany = void 0;
-/* istanbul ignore file */
-__exportStar(require("./PrimaryKey"), exports);
-__exportStar(require("./Entity"), exports);
-__exportStar(require("./OneToOne"), exports);
-__exportStar(require("./ManyToOne"), exports);
-__exportStar(require("./ManyToMany"), exports);
-var OneToMany_1 = require("./OneToMany");
-Object.defineProperty(exports, "OneToMany", { enumerable: true, get: function () { return OneToMany_1.OneToMany; } });
-__exportStar(require("./Property"), exports);
-__exportStar(require("./Check"), exports);
-__exportStar(require("./Enum"), exports);
-__exportStar(require("./Formula"), exports);
-__exportStar(require("./Indexed"), exports);
-__exportStar(require("./Embeddable"), exports);
-__exportStar(require("./Embedded"), exports);
-__exportStar(require("./Filter"), exports);
-__exportStar(require("./CreateRequestContext"), exports);
-__exportStar(require("./hooks"), exports);
-__exportStar(require("./Transactional"), exports);
+export * from './PrimaryKey.js';
+export * from './Entity.js';
+export * from './OneToOne.js';
+export * from './ManyToOne.js';
+export * from './ManyToMany.js';
+export { OneToMany } from './OneToMany.js';
+export * from './Property.js';
+export * from './Check.js';
+export * from './Enum.js';
+export * from './Formula.js';
+export * from './Indexed.js';
+export * from './Embeddable.js';
+export * from './Embedded.js';
+export * from './Filter.js';
+export * from './CreateRequestContext.js';
+export * from './hooks.js';
+export * from './Transactional.js';

package/drivers/DatabaseDriver.d.ts

@@ -1,14 +1,15 @@
-import { type CountOptions, type DeleteOptions, type DriverMethodOptions, EntityManagerType, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type OrderDefinition } from './IDatabaseDriver';
-import type { ConnectionType, Dictionary, EntityData, EntityDictionary, EntityMetadata, EntityProperty, FilterQuery, PopulateOptions, Primary } from '../typings';
-import type { MetadataStorage } from '../metadata';
-import type { Connection, QueryResult, Transaction } from '../connections';
-import { type Configuration, type ConnectionOptions, EntityComparator } from '../utils';
-import { type QueryOrder } from '../enums';
-import type { Platform } from '../platforms';
-import type { Collection } from '../entity/Collection';
-import { EntityManager } from '../EntityManager';
-import { DriverException } from '../exceptions';
-import type { Logger } from '../logging/Logger';
+import { type CountOptions, type DeleteOptions, type DriverMethodOptions, EntityManagerType, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type OrderDefinition } from './IDatabaseDriver.js';
+import type { ConnectionType, Dictionary, EntityData, EntityDictionary, EntityMetadata, EntityProperty, FilterQuery, PopulateOptions, Primary } from '../typings.js';
+import type { MetadataStorage } from '../metadata/MetadataStorage.js';
+import type { Connection, QueryResult, Transaction } from '../connections/Connection.js';
+import { type Configuration, type ConnectionOptions } from '../utils/Configuration.js';
+import { EntityComparator } from '../utils/EntityComparator.js';
+import { type QueryOrder } from '../enums.js';
+import type { Platform } from '../platforms/Platform.js';
+import type { Collection } from '../entity/Collection.js';
+import { EntityManager } from '../EntityManager.js';
+import { DriverException } from '../exceptions.js';
+import type { Logger } from '../logging/Logger.js';
 export declare abstract class DatabaseDriver<C extends Connection> implements IDatabaseDriver<C> {
     readonly config: Configuration;
     protected readonly dependencies: string[];
@@ -28,7 +29,7 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
     nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
     abstract nativeDelete<T extends object>(entityName: string, where: FilterQuery<T>, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
     abstract count<T extends object, P extends string = never>(entityName: string, where: FilterQuery<T>, options?: CountOptions<T, P>): Promise<number>;
-    createEntityManager<D extends IDatabaseDriver = IDatabaseDriver>(useContext?: boolean): D[typeof EntityManagerType];
+    createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
     findVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
     countVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: CountOptions<T, any>): Promise<number>;
     aggregate(entityName: string, pipeline: any[]): Promise<any[]>;

package/drivers/DatabaseDriver.js

@@ -1,18 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatabaseDriver = void 0;
-const IDatabaseDriver_1 = require("./IDatabaseDriver");
-const utils_1 = require("../utils");
-const enums_1 = require("../enums");
-const EntityManager_1 = require("../EntityManager");
-const errors_1 = require("../errors");
-const exceptions_1 = require("../exceptions");
-const wrap_1 = require("../entity/wrap");
-const JsonType_1 = require("../types/JsonType");
-class DatabaseDriver {
+import { EntityManagerType, } from './IDatabaseDriver.js';
+import { Utils } from '../utils/Utils.js';
+import { Cursor } from '../utils/Cursor.js';
+import { EntityComparator } from '../utils/EntityComparator.js';
+import { isRaw, raw } from '../utils/RawQueryFragment.js';
+import { QueryOrderNumeric, ReferenceKind } from '../enums.js';
+import { EntityManager } from '../EntityManager.js';
+import { CursorError, ValidationError } from '../errors.js';
+import { DriverException } from '../exceptions.js';
+import { helper } from '../entity/wrap.js';
+import { JsonType } from '../types/JsonType.js';
+export class DatabaseDriver {
     config;
     dependencies;
-    [IDatabaseDriver_1.EntityManagerType];
+    [EntityManagerType];
     connection;
     replicas = [];
     platform;
@@ -28,14 +28,14 @@ class DatabaseDriver {
         throw new Error(`Batch updates are not supported by ${this.constructor.name} driver`);
     }
     createEntityManager(useContext) {
-        const EntityManagerClass = this.config.get('entityManager', EntityManager_1.EntityManager);
+        const EntityManagerClass = this.config.get('entityManager', EntityManager);
         return new EntityManagerClass(this.config, this, this.metadata, useContext);
     }
-    /* istanbul ignore next */
+    /* v8 ignore next 3 */
     async findVirtual(entityName, where, options) {
         throw new Error(`Virtual entities are not supported by ${this.constructor.name} driver.`);
     }
-    /* istanbul ignore next */
+    /* v8 ignore next 3 */
     async countVirtual(entityName, where, options) {
         throw new Error(`Counting virtual entities is not supported by ${this.constructor.name} driver.`);
     }
@@ -49,16 +49,14 @@ class DatabaseDriver {
         for (const coll of collections) {
             if (!coll.property.owner) {
                 if (coll.getSnapshot() === undefined) {
-                    throw errors_1.ValidationError.cannotModifyInverseCollection(coll.owner, coll.property);
+                    throw ValidationError.cannotModifyInverseCollection(coll.owner, coll.property);
                 }
                 continue;
             }
-            /* istanbul ignore next */
-            {
-                const pk = coll.property.targetMeta.primaryKeys[0];
-                const data = { [coll.property.name]: coll.getIdentifiers(pk) };
-                await this.nativeUpdate(coll.owner.constructor.name, (0, wrap_1.helper)(coll.owner).getPrimaryKey(), data, options);
-            }
+            /* v8 ignore next 3 */
+            const pk = coll.property.targetMeta.primaryKeys[0];
+            const data = { [coll.property.name]: coll.getIdentifiers(pk) };
+            await this.nativeUpdate(coll.owner.constructor.name, helper(coll.owner).getPrimaryKey(), data, options);
         }
     }
     mapResult(result, meta, populate = []) {
@@ -81,7 +79,7 @@ class DatabaseDriver {
         if (type === 'write' || this.replicas.length === 0) {
             return this.connection;
         }
-        const rand = utils_1.Utils.randomInt(0, this.replicas.length - 1);
+        const rand = Utils.randomInt(0, this.replicas.length - 1);
         return this.replicas[rand];
     }
     async close(force) {
@@ -93,7 +91,7 @@ class DatabaseDriver {
     }
     setMetadata(metadata) {
         this.metadata = metadata;
-        this.comparator = new utils_1.EntityComparator(this.metadata, this.platform);
+        this.comparator = new EntityComparator(this.metadata, this.platform);
         this.connection.setMetadata(metadata);
         this.connection.setPlatform(this.platform);
         this.replicas.forEach(replica => {
@@ -111,7 +109,7 @@ class DatabaseDriver {
         const { first, last, before, after, overfetch } = options;
         const limit = first ?? last;
         const isLast = !first && !!last;
-        const definition = utils_1.Cursor.getDefinition(meta, orderBy);
+        const definition = Cursor.getDefinition(meta, orderBy);
         const $and = [];
         // allow POJO as well, we care only about the correct key being present
         const isCursor = (val, key) => {
@@ -119,15 +117,15 @@ class DatabaseDriver {
         };
         const createCursor = (val, key, inverse = false) => {
             let def = isCursor(val, key) ? val[key] : val;
-            if (utils_1.Utils.isPlainObject(def)) {
-                def = utils_1.Cursor.for(meta, def, orderBy);
+            if (Utils.isPlainObject(def)) {
+                def = Cursor.for(meta, def, orderBy);
             }
-            /* istanbul ignore next */
-            const offsets = def ? utils_1.Cursor.decode(def) : [];
+            /* v8 ignore next */
+            const offsets = def ? Cursor.decode(def) : [];
             if (definition.length === offsets.length) {
                 return this.createCursorCondition(definition, offsets, inverse, meta);
             }
-            /* istanbul ignore next */
+            /* v8 ignore next */
             return {};
         };
         if (after) {
@@ -140,15 +138,15 @@ class DatabaseDriver {
             options.limit = limit + (overfetch ? 1 : 0);
         }
         const createOrderBy = (prop, direction) => {
-            if (utils_1.Utils.isPlainObject(direction)) {
-                const value = utils_1.Utils.keys(direction).reduce((o, key) => {
+            if (Utils.isPlainObject(direction)) {
+                const value = Utils.keys(direction).reduce((o, key) => {
                     Object.assign(o, createOrderBy(key, direction[key]));
                     return o;
                 }, {});
                 return ({ [prop]: value });
             }
-            const desc = direction === enums_1.QueryOrderNumeric.DESC || direction.toString().toLowerCase() === 'desc';
-            const dir = utils_1.Utils.xor(desc, isLast) ? 'desc' : 'asc';
+            const desc = direction === QueryOrderNumeric.DESC || direction.toString().toLowerCase() === 'desc';
+            const dir = Utils.xor(desc, isLast) ? 'desc' : 'asc';
             return ({ [prop]: dir });
         };
         return {
@@ -156,24 +154,23 @@ class DatabaseDriver {
             where: ($and.length > 1 ? { $and } : { ...$and[0] }),
         };
     }
-    /* istanbul ignore next */
     createCursorCondition(definition, offsets, inverse, meta) {
         const createCondition = (prop, direction, offset, eq = false) => {
             if (offset === null) {
-                throw errors_1.CursorError.missingValue(meta.className, prop);
+                throw CursorError.missingValue(meta.className, prop);
             }
-            if (utils_1.Utils.isPlainObject(direction)) {
-                const value = utils_1.Utils.keys(direction).reduce((o, key) => {
-                    if (utils_1.Utils.isEmpty(offset[key])) {
-                        throw errors_1.CursorError.missingValue(meta.className, `${prop}.${key}`);
+            if (Utils.isPlainObject(direction)) {
+                const value = Utils.keys(direction).reduce((o, key) => {
+                    if (Utils.isEmpty(offset[key])) {
+                        throw CursorError.missingValue(meta.className, `${prop}.${key}`);
                     }
                     Object.assign(o, createCondition(key, direction[key], offset[key], eq));
                     return o;
                 }, {});
                 return ({ [prop]: value });
             }
-            const desc = direction === enums_1.QueryOrderNumeric.DESC || direction.toString().toLowerCase() === 'desc';
-            const operator = utils_1.Utils.xor(desc, inverse) ? '$lt' : '$gt';
+            const desc = direction === QueryOrderNumeric.DESC || direction.toString().toLowerCase() === 'desc';
+            const operator = Utils.xor(desc, inverse) ? '$lt' : '$gt';
             return { [prop]: { [operator + (eq ? 'e' : '')]: offset } };
         };
         const [order, ...otherOrders] = definition;
@@ -222,7 +219,7 @@ class DatabaseDriver {
                 return;
             }
             if (prop.joinColumns && Array.isArray(data[k])) {
-                const copy = utils_1.Utils.flatten(data[k]);
+                const copy = Utils.flatten(data[k]);
                 delete data[k];
                 prop.joinColumns.forEach((joinColumn, idx) => data[joinColumn] = copy[idx]);
                 return;
@@ -232,49 +229,49 @@ class DatabaseDriver {
                 prop.ownColumns.forEach(joinColumn => data[joinColumn] = null);
                 return;
             }
-            if (prop.customType && convertCustomTypes && !(prop.customType instanceof JsonType_1.JsonType && object) && !(0, utils_1.isRaw)(data[k])) {
+            if (prop.customType && convertCustomTypes && !(prop.customType instanceof JsonType && object) && !isRaw(data[k])) {
                 data[k] = prop.customType.convertToDatabaseValue(data[k], this.platform, { fromQuery: true, key: k, mode: 'query-data' });
             }
-            if (prop.hasConvertToDatabaseValueSQL && !prop.object && !(0, utils_1.isRaw)(data[k])) {
+            if (prop.hasConvertToDatabaseValueSQL && !prop.object && !isRaw(data[k])) {
                 const quoted = this.platform.quoteValue(data[k]);
                 const sql = prop.customType.convertToDatabaseValueSQL(quoted, this.platform);
-                data[k] = (0, utils_1.raw)(sql.replace(/\?/g, '\\?'));
+                data[k] = raw(sql.replace(/\?/g, '\\?'));
             }
             if (prop.fieldNames) {
-                utils_1.Utils.renameKey(data, k, prop.fieldNames[0]);
+                Utils.renameKey(data, k, prop.fieldNames[0]);
             }
         });
         return data;
     }
     inlineEmbeddables(meta, data, where) {
-        /* istanbul ignore next */
+        /* v8 ignore next 3 */
         if (data == null) {
             return;
         }
-        utils_1.Utils.keys(data).forEach(k => {
-            if (utils_1.Utils.isOperator(k)) {
-                utils_1.Utils.asArray(data[k]).forEach(payload => this.inlineEmbeddables(meta, payload, where));
+        Utils.keys(data).forEach(k => {
+            if (Utils.isOperator(k)) {
+                Utils.asArray(data[k]).forEach(payload => this.inlineEmbeddables(meta, payload, where));
             }
         });
         meta.props.forEach(prop => {
-            if (prop.kind === enums_1.ReferenceKind.EMBEDDED && prop.object && !where && utils_1.Utils.isObject(data[prop.name])) {
+            if (prop.kind === ReferenceKind.EMBEDDED && prop.object && !where && Utils.isObject(data[prop.name])) {
                 return;
             }
-            if (prop.kind === enums_1.ReferenceKind.EMBEDDED && utils_1.Utils.isObject(data[prop.name])) {
+            if (prop.kind === ReferenceKind.EMBEDDED && Utils.isObject(data[prop.name])) {
                 const props = prop.embeddedProps;
                 let unknownProp = false;
                 Object.keys(data[prop.name]).forEach(kk => {
                     // explicitly allow `$exists`, `$eq` and `$ne` operators here as they can't be misused this way
-                    const operator = Object.keys(data[prop.name]).some(f => utils_1.Utils.isOperator(f) && !['$exists', '$ne', '$eq'].includes(f));
+                    const operator = Object.keys(data[prop.name]).some(f => Utils.isOperator(f) && !['$exists', '$ne', '$eq'].includes(f));
                     if (operator) {
-                        throw errors_1.ValidationError.cannotUseOperatorsInsideEmbeddables(meta.className, prop.name, data);
+                        throw ValidationError.cannotUseOperatorsInsideEmbeddables(meta.className, prop.name, data);
                     }
                     if (prop.object && where) {
                         const inline = (payload, sub, path) => {
-                            if (sub.kind === enums_1.ReferenceKind.EMBEDDED && utils_1.Utils.isObject(payload[sub.embedded[1]])) {
+                            if (sub.kind === ReferenceKind.EMBEDDED && Utils.isObject(payload[sub.embedded[1]])) {
                                 return Object.keys(payload[sub.embedded[1]]).forEach(kkk => {
                                     if (!sub.embeddedProps[kkk]) {
-                                        throw errors_1.ValidationError.invalidEmbeddableQuery(meta.className, kkk, sub.type);
+                                        throw ValidationError.invalidEmbeddableQuery(meta.className, kkk, sub.type);
                                     }
                                     inline(payload[sub.embedded[1]], sub.embeddedProps[kkk], [...path, sub.embedded[1]]);
                                 });
@@ -284,7 +281,7 @@ class DatabaseDriver {
                         const parentPropName = kk.substring(0, kk.indexOf('.'));
                         // we might be using some native JSON operator, e.g. with mongodb's `$geoWithin` or `$exists`
                         if (props[kk]) {
-                            /* istanbul ignore next */
+                            /* v8 ignore next */
                             inline(data[prop.name], props[kk] || props[parentPropName], [prop.name]);
                         }
                         else if (props[parentPropName]) {
@@ -298,7 +295,7 @@ class DatabaseDriver {
                         data[props[kk].name] = data[prop.name][props[kk].embedded[1]];
                     }
                     else {
-                        throw errors_1.ValidationError.invalidEmbeddableQuery(meta.className, kk, prop.type);
+                        throw ValidationError.invalidEmbeddableQuery(meta.className, kk, prop.type);
                     }
                 });
                 if (!unknownProp) {
@@ -309,14 +306,14 @@ class DatabaseDriver {
     }
     getPrimaryKeyFields(entityName) {
         const meta = this.metadata.find(entityName);
-        return meta ? utils_1.Utils.flatten(meta.getPrimaryProps().map(pk => pk.fieldNames)) : [this.config.getNamingStrategy().referenceColumnName()];
+        return meta ? Utils.flatten(meta.getPrimaryProps().map(pk => pk.fieldNames)) : [this.config.getNamingStrategy().referenceColumnName()];
     }
     createReplicas(cb) {
         const replicas = this.config.get('replicas', []);
         const ret = [];
         const props = ['dbName', 'clientUrl', 'host', 'port', 'user', 'password', 'multipleStatements', 'pool', 'name', 'driverOptions'];
         for (const conf of replicas) {
-            const replicaConfig = utils_1.Utils.copy(conf);
+            const replicaConfig = Utils.copy(conf);
             for (const prop of props) {
                 if (conf[prop]) {
                     continue;
@@ -341,7 +338,7 @@ class DatabaseDriver {
      * @inheritDoc
      */
     convertException(exception) {
-        if (exception instanceof exceptions_1.DriverException) {
+        if (exception instanceof DriverException) {
             return exception;
         }
         return this.platform.getExceptionConverter().convertException(exception);
@@ -376,4 +373,3 @@ class DatabaseDriver {
         return options?.schema ?? options?.parentSchema ?? schemaName ?? this.config.getSchema();
     }
 }
-exports.DatabaseDriver = DatabaseDriver;

package/drivers/IDatabaseDriver.d.ts

@@ -1,19 +1,19 @@
-import type { ConnectionType, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary, Dictionary, QBFilterQuery, IPrimaryKey, PopulateOptions, EntityDictionary, AutoPath, ObjectQuery, FilterObject, Populate } from '../typings';
-import type { Connection, QueryResult, Transaction } from '../connections';
-import type { FlushMode, LockMode, QueryOrderMap, QueryFlag, LoadStrategy, PopulateHint, PopulatePath } from '../enums';
-import type { Platform } from '../platforms';
-import type { MetadataStorage } from '../metadata';
-import type { Collection } from '../entity/Collection';
-import type { EntityManager } from '../EntityManager';
-import type { DriverException } from '../exceptions';
-import type { Configuration } from '../utils/Configuration';
-import type { LoggingOptions, LogContext } from '../logging';
-import type { RawQueryFragment } from '../utils/RawQueryFragment';
+import type { ConnectionType, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary, Dictionary, QBFilterQuery, IPrimaryKey, PopulateOptions, EntityDictionary, AutoPath, ObjectQuery, FilterObject, Populate } from '../typings.js';
+import type { Connection, QueryResult, Transaction } from '../connections/Connection.js';
+import type { FlushMode, LockMode, QueryOrderMap, QueryFlag, LoadStrategy, PopulateHint, PopulatePath } from '../enums.js';
+import type { Platform } from '../platforms/Platform.js';
+import type { MetadataStorage } from '../metadata/MetadataStorage.js';
+import type { Collection } from '../entity/Collection.js';
+import type { EntityManager } from '../EntityManager.js';
+import type { DriverException } from '../exceptions.js';
+import type { Configuration } from '../utils/Configuration.js';
+import type { LoggingOptions, LogContext } from '../logging/Logger.js';
+import type { RawQueryFragment } from '../utils/RawQueryFragment.js';
 export declare const EntityManagerType: unique symbol;
 export interface IDatabaseDriver<C extends Connection = Connection> {
     [EntityManagerType]: EntityManager<this>;
     readonly config: Configuration;
-    createEntityManager<D extends IDatabaseDriver = IDatabaseDriver>(useContext?: boolean): D[typeof EntityManagerType];
+    createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
     connect(): Promise<C>;
     close(force?: boolean): Promise<void>;
     reconnect(): Promise<C>;
@@ -146,8 +146,11 @@ export interface FindOptions<Entity, Hint extends string = never, Fields extends
     hintComments?: string | string[];
     loggerContext?: LogContext;
     logging?: LoggingOptions;
+    /** @internal used to apply filters to the auto-joined relations */
+    em?: EntityManager;
 }
-export interface FindByCursorOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'offset'> {
+export interface FindByCursorOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never, I extends boolean = true> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'offset'> {
+    includeCount?: I;
 }
 export interface FindOneOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'lockMode'> {
     lockMode?: LockMode;

package/drivers/IDatabaseDriver.js

@@ -1,4 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityManagerType = void 0;
-exports.EntityManagerType = Symbol('EntityManagerType');
+export const EntityManagerType = Symbol('EntityManagerType');

package/drivers/index.d.ts

@@ -1,2 +1,2 @@
-export * from './IDatabaseDriver';
-export * from './DatabaseDriver';
+export * from './IDatabaseDriver.js';
+export * from './DatabaseDriver.js';

package/drivers/index.js

@@ -1,18 +1,2 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./IDatabaseDriver"), exports);
-__exportStar(require("./DatabaseDriver"), exports);
+export * from './IDatabaseDriver.js';
+export * from './DatabaseDriver.js';

package/entity/ArrayCollection.d.ts

@@ -1,6 +1,6 @@
 import { inspect } from 'node:util';
-import type { EntityDTO, EntityProperty, IPrimaryKey, Primary } from '../typings';
-import { Reference } from './Reference';
+import type { EntityDTO, EntityProperty, IPrimaryKey, Primary } from '../typings.js';
+import { Reference } from './Reference.js';
 export declare class ArrayCollection<T extends object, O extends object> {
     readonly owner: O;
     protected readonly items: Set<T>;
@@ -14,7 +14,7 @@ export declare class ArrayCollection<T extends object, O extends object> {
     getItems(): T[];
     toArray<TT extends T>(): EntityDTO<TT>[];
     toJSON(): EntityDTO<T>[];
-    getIdentifiers<U extends IPrimaryKey = Primary<T> & IPrimaryKey>(field?: string): U[];
+    getIdentifiers<U extends IPrimaryKey = Primary<T> & IPrimaryKey>(field?: string | string[]): U[];
     add(entity: T | Reference<T> | Iterable<T | Reference<T>>, ...entities: (T | Reference<T>)[]): void;
     /**
      * @internal