@mikro-orm/core 7.0.0-dev.0 → 7.0.0-dev.2

package/utils/ConfigurationLoader.js

@@ -1,21 +1,14 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigurationLoader = void 0;
-const dotenv_1 = __importDefault(require("dotenv"));
-const fs_extra_1 = require("fs-extra");
-const node_os_1 = require("node:os");
-const node_path_1 = require("node:path");
-const node_url_1 = require("node:url");
-const colors_1 = require("../logging/colors");
-const Configuration_1 = require("./Configuration");
-const Utils_1 = require("./Utils");
+import dotenv from 'dotenv';
+import { realpathSync } from 'node:fs';
+import { platform } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { colors } from '../logging/colors.js';
+import { Configuration } from './Configuration.js';
+import { Utils } from './Utils.js';
 /**
  * @internal
  */
-class ConfigurationLoader {
+export class ConfigurationLoader {
     static async getConfiguration(contextName = 'default', paths = ConfigurationLoader.getConfigPaths(), options = {}) {
         // Backwards compatibility layer
         if (typeof contextName === 'boolean' || !Array.isArray(paths)) {
@@ -26,22 +19,22 @@ class ConfigurationLoader {
             const config = contextName
                 ? (await ConfigurationLoader.getConfiguration(process.env.MIKRO_ORM_CONTEXT_NAME ?? 'default', configPaths, Array.isArray(paths) ? {} : paths))
                 : await (async () => {
-                    const env = this.loadEnvironmentVars();
+                    const env = await this.loadEnvironmentVars();
                     const [path, tmp] = await this.getConfigFile(configPaths);
                     if (!path) {
-                        if (Utils_1.Utils.hasObjectKeys(env)) {
-                            return new Configuration_1.Configuration(Utils_1.Utils.mergeConfig({}, options, env), false);
+                        if (Utils.hasObjectKeys(env)) {
+                            return new Configuration(Utils.mergeConfig({}, options, env), false);
                         }
                         throw new Error(`MikroORM config file not found in ['${configPaths.join(`', '`)}']`);
                     }
-                    return new Configuration_1.Configuration(Utils_1.Utils.mergeConfig(tmp, options, env), false);
+                    return new Configuration(Utils.mergeConfig(tmp, options, env), false);
                 })();
             if (configPathFromArg) {
                 config.getLogger().warn('deprecated', 'Path for config file was inferred from the command line arguments. Instead, you should set the MIKRO_ORM_CLI_CONFIG environment variable to specify the path, or if you really must use the command line arguments, import the config manually based on them, and pass it to init.', { label: 'D0001' });
             }
             return config;
         }
-        const env = this.loadEnvironmentVars();
+        const env = await this.loadEnvironmentVars();
         const configFinder = (cfg) => {
             return typeof cfg === 'object' && cfg !== null && ('contextName' in cfg ? cfg.contextName === contextName : (contextName === 'default'));
         };
@@ -50,8 +43,8 @@ class ConfigurationLoader {
         };
         const result = await this.getConfigFile(paths);
         if (!result[0]) {
-            if (Utils_1.Utils.hasObjectKeys(env)) {
-                return new Configuration_1.Configuration(Utils_1.Utils.mergeConfig({ contextName }, options, env));
+            if (Utils.hasObjectKeys(env)) {
+                return new Configuration(Utils.mergeConfig({ contextName }, options, env));
             }
             throw new Error(`MikroORM config file not found in ['${paths.join(`', '`)}']`);
         }
@@ -100,31 +93,31 @@ class ConfigurationLoader {
             }
         }
         const esmConfigOptions = this.isESM() ? { entityGenerator: { esmImport: true } } : {};
-        return new Configuration_1.Configuration(Utils_1.Utils.mergeConfig({}, esmConfigOptions, tmp, options, env));
+        return new Configuration(Utils.mergeConfig({}, esmConfigOptions, tmp, options, env));
     }
     static async getConfigFile(paths) {
         for (let path of paths) {
-            path = Utils_1.Utils.absolutePath(path);
-            path = Utils_1.Utils.normalizePath(path);
-            if ((0, fs_extra_1.pathExistsSync)(path)) {
-                const config = await Utils_1.Utils.dynamicImport(path);
-                /* istanbul ignore next */
+            path = Utils.absolutePath(path);
+            path = Utils.normalizePath(path);
+            if (Utils.pathExistsSync(path)) {
+                const config = await Utils.dynamicImport(path);
+                /* v8 ignore next */
                 return [path, await (config.default ?? config)];
             }
         }
         return [];
     }
     static getPackageConfig(basePath = process.cwd()) {
-        if ((0, fs_extra_1.pathExistsSync)(`${basePath}/package.json`)) {
-            /* istanbul ignore next */
+        if (Utils.pathExistsSync(`${basePath}/package.json`)) {
+            /* v8 ignore next 5 */
             try {
-                return (0, fs_extra_1.readJSONSync)(`${basePath}/package.json`);
+                return Utils.readJSONSync(`${basePath}/package.json`);
             }
             catch {
                 return {};
             }
         }
-        const parentFolder = (0, fs_extra_1.realpathSync)(`${basePath}/..`);
+        const parentFolder = realpathSync(`${basePath}/..`);
         // we reached the root folder
         if (basePath === parentFolder) {
             return {};
@@ -135,17 +128,17 @@ class ConfigurationLoader {
         const config = ConfigurationLoader.getPackageConfig();
         const settings = { ...config['mikro-orm'] };
         const bool = (v) => ['true', 't', '1'].includes(v.toLowerCase());
-        settings.useTsNode = process.env.MIKRO_ORM_CLI_USE_TS_NODE != null ? bool(process.env.MIKRO_ORM_CLI_USE_TS_NODE) : settings.useTsNode;
+        settings.preferTs = process.env.MIKRO_ORM_CLI_PREFER_TS != null ? bool(process.env.MIKRO_ORM_CLI_PREFER_TS) : settings.preferTs;
         settings.tsConfigPath = process.env.MIKRO_ORM_CLI_TS_CONFIG_PATH ?? settings.tsConfigPath;
         settings.alwaysAllowTs = process.env.MIKRO_ORM_CLI_ALWAYS_ALLOW_TS != null ? bool(process.env.MIKRO_ORM_CLI_ALWAYS_ALLOW_TS) : settings.alwaysAllowTs;
         settings.verbose = process.env.MIKRO_ORM_CLI_VERBOSE != null ? bool(process.env.MIKRO_ORM_CLI_VERBOSE) : settings.verbose;
         if (process.env.MIKRO_ORM_CLI_CONFIG?.endsWith('.ts')) {
-            settings.useTsNode = true;
+            settings.preferTs = true;
         }
         return settings;
     }
     static configPathsFromArg() {
-        const options = Utils_1.Utils.parseArgs();
+        const options = Utils.parseArgs();
         const configArgName = process.env.MIKRO_ORM_CONFIG_ARG_NAME ?? 'config';
         if (options[configArgName]) {
             return [options[configArgName]];
@@ -160,60 +153,46 @@ class ConfigurationLoader {
         }
         paths.push(...(settings.configPaths || []));
         const alwaysAllowTs = settings.alwaysAllowTs ?? process.versions.bun;
-        if (settings.useTsNode !== false || alwaysAllowTs) {
+        if (settings.preferTs !== false || alwaysAllowTs) {
             paths.push('./src/mikro-orm.config.ts');
             paths.push('./mikro-orm.config.ts');
         }
-        const distDir = (0, fs_extra_1.pathExistsSync)(process.cwd() + '/dist');
-        const buildDir = (0, fs_extra_1.pathExistsSync)(process.cwd() + '/build');
-        /* istanbul ignore next */
+        const distDir = Utils.pathExistsSync(process.cwd() + '/dist');
+        const buildDir = Utils.pathExistsSync(process.cwd() + '/build');
+        /* v8 ignore next */
         const path = distDir ? 'dist' : (buildDir ? 'build' : 'src');
         paths.push(`./${path}/mikro-orm.config.js`);
         paths.push('./mikro-orm.config.js');
-        const tsNode = Utils_1.Utils.detectTsNode();
-        return Utils_1.Utils.unique(paths).filter(p => p.endsWith('.js') || tsNode || alwaysAllowTs);
+        const typeScriptSupport = Utils.detectTypeScriptSupport();
+        /* v8 ignore next */
+        return Utils.unique(paths).filter(p => p.endsWith('.js') || typeScriptSupport || alwaysAllowTs);
     }
     static isESM() {
         const config = ConfigurationLoader.getPackageConfig();
         const type = config?.type ?? '';
         return type === 'module';
     }
-    static registerTsNode(configPath = 'tsconfig.json') {
-        /* istanbul ignore next */
+    static async registerTypeScriptSupport(configPath = 'tsconfig.json') {
+        /* v8 ignore next 3 */
         if (process.versions.bun) {
             return true;
         }
-        const tsConfigPath = (0, node_path_1.isAbsolute)(configPath) ? configPath : (0, node_path_1.join)(process.cwd(), configPath);
-        const tsNode = Utils_1.Utils.tryRequire({
-            module: 'ts-node',
-            from: tsConfigPath,
-            warning: 'ts-node not installed, support for working with TS files might not work',
+        process.env.SWC_NODE_PROJECT ??= configPath;
+        process.env.MIKRO_ORM_CLI_ALWAYS_ALLOW_TS ??= '1';
+        const esm = this.isESM();
+        /* v8 ignore next 2 */
+        const importMethod = esm ? 'tryImport' : 'tryRequire';
+        const module = esm ? '@swc-node/register/esm-register' : '@swc-node/register';
+        const supported = await Utils[importMethod]({
+            module,
+            warning: '@swc-node/register and @swc/core are not installed, support for working with TypeScript files might not work',
         });
-        /* istanbul ignore next */
-        if (!tsNode) {
-            return false;
-        }
-        const { options } = tsNode.register({
-            project: tsConfigPath,
-            transpileOnly: true,
-            compilerOptions: {
-                module: 'nodenext',
-                moduleResolution: 'nodenext',
-            },
-        }).config;
-        if (Object.entries(options?.paths ?? {}).length > 0) {
-            Utils_1.Utils.requireFrom('tsconfig-paths', tsConfigPath).register({
-                baseUrl: options.baseUrl ?? '.',
-                paths: options.paths,
-            });
-        }
-        return true;
+        return !!supported;
     }
     static registerDotenv(options) {
-        const baseDir = options instanceof Configuration_1.Configuration ? options.get('baseDir') : options?.baseDir;
-        const path = process.env.MIKRO_ORM_ENV ?? ((baseDir ?? process.cwd()) + '/.env');
+        const path = process.env.MIKRO_ORM_ENV ?? ((options?.baseDir ?? process.cwd()) + '/.env');
         const env = {};
-        dotenv_1.default.config({ path, processEnv: env });
+        dotenv.config({ path, processEnv: env });
         // only propagate known env vars
         for (const key of Object.keys(env)) {
             if (key.startsWith('MIKRO_ORM_')) {
@@ -221,8 +200,8 @@ class ConfigurationLoader {
             }
         }
     }
-    static loadEnvironmentVars() {
-        const ret = {};
+    static async loadEnvironmentVars() {
+        const ret = this.loadEnvironmentVarsSync();
         // only to keep some sort of back compatibility with those using env vars only, to support `MIKRO_ORM_TYPE`
         const PLATFORMS = {
             mongo: { className: 'MongoDriver', module: '@mikro-orm/mongodb' },
@@ -233,10 +212,18 @@ class ConfigurationLoader {
             sqlite: { className: 'SqliteDriver', module: '@mikro-orm/sqlite' },
             libsql: { className: 'LibSqlDriver', module: '@mikro-orm/libsql' },
         };
+        if (process.env.MIKRO_ORM_TYPE) {
+            const val = process.env.MIKRO_ORM_TYPE;
+            const driver = await import(PLATFORMS[val].module);
+            ret.driver = driver[PLATFORMS[val].className];
+        }
+        return ret;
+    }
+    static loadEnvironmentVarsSync() {
+        const ret = {};
         const array = (v) => v.split(',').map(vv => vv.trim());
         const bool = (v) => ['true', 't', '1'].includes(v.toLowerCase());
         const num = (v) => +v;
-        const driver = (v) => Utils_1.Utils.requireFrom(PLATFORMS[v].module)[PLATFORMS[v].className];
         const read = (o, envKey, key, mapper = v => v) => {
             if (!(envKey in process.env)) {
                 return;
@@ -244,9 +231,8 @@ class ConfigurationLoader {
             const val = process.env[envKey];
             o[key] = mapper(val);
         };
-        const cleanup = (o, k) => Utils_1.Utils.hasObjectKeys(o[k]) ? {} : delete o[k];
+        const cleanup = (o, k) => Utils.hasObjectKeys(o[k]) ? {} : delete o[k];
         read(ret, 'MIKRO_ORM_BASE_DIR', 'baseDir');
-        read(ret, 'MIKRO_ORM_TYPE', 'driver', driver);
         read(ret, 'MIKRO_ORM_ENTITIES', 'entities', array);
         read(ret, 'MIKRO_ORM_ENTITIES_TS', 'entitiesTs', array);
         read(ret, 'MIKRO_ORM_CLIENT_URL', 'clientUrl');
@@ -319,24 +305,24 @@ class ConfigurationLoader {
         if (this.isESM()) {
             return;
         }
-        /* istanbul ignore next */
+        /* v8 ignore next 11 */
         options.dynamicImportProvider ??= id => {
-            if ((0, node_os_1.platform)() === 'win32') {
+            if (platform() === 'win32') {
                 try {
-                    id = (0, node_url_1.fileURLToPath)(id);
+                    id = fileURLToPath(id);
                 }
                 catch {
                     // ignore
                 }
             }
-            return Utils_1.Utils.requireFrom(id);
+            return Utils.requireFrom(id);
         };
-        Utils_1.Utils.setDynamicImportProvider(options.dynamicImportProvider);
+        Utils.setDynamicImportProvider(options.dynamicImportProvider);
     }
     static getORMPackageVersion(name) {
-        /* istanbul ignore next */
         try {
-            const pkg = Utils_1.Utils.requireFrom(`${name}/package.json`);
+            const pkg = Utils.requireFrom(`${name}/package.json`);
+            /* v8 ignore next */
             return pkg?.version;
         }
         catch (e) {
@@ -345,7 +331,7 @@ class ConfigurationLoader {
     }
     // inspired by https://github.com/facebook/docusaurus/pull/3386
     static checkPackageVersion() {
-        const coreVersion = Utils_1.Utils.getORMVersion();
+        const coreVersion = Utils.getORMVersion();
         if (process.env.MIKRO_ORM_ALLOW_VERSION_MISMATCH) {
             return coreVersion;
         }
@@ -355,8 +341,8 @@ class ConfigurationLoader {
         for (const ormPackage of ormPackages) {
             const version = this.getORMPackageVersion(ormPackage);
             if (version != null && version !== coreVersion) {
-                throw new Error(`Bad ${colors_1.colors.cyan(ormPackage)} version ${colors_1.colors.yellow('' + version)}.\n` +
-                    `All official @mikro-orm/* packages need to have the exact same version as @mikro-orm/core (${colors_1.colors.green(coreVersion)}).\n` +
+                throw new Error(`Bad ${colors.cyan(ormPackage)} version ${colors.yellow('' + version)}.\n` +
+                    `All official @mikro-orm/* packages need to have the exact same version as @mikro-orm/core (${colors.green(coreVersion)}).\n` +
                     `Only exceptions are packages that don't live in the 'mikro-orm' repository: ${[...exceptions].join(', ')}.\n` +
                     `Maybe you want to check, or regenerate your yarn.lock or package-lock.json file?`);
             }
@@ -364,4 +350,3 @@ class ConfigurationLoader {
         return coreVersion;
     }
 }
-exports.ConfigurationLoader = ConfigurationLoader;

package/utils/Cursor.d.ts

@@ -1,7 +1,7 @@
 import { inspect } from 'node:util';
-import type { EntityMetadata, FilterObject, Loaded } from '../typings';
-import type { FindByCursorOptions, OrderDefinition } from '../drivers/IDatabaseDriver';
-import { type QueryOrder } from '../enums';
+import type { EntityMetadata, FilterObject, Loaded } from '../typings.js';
+import type { FindByCursorOptions, OrderDefinition } from '../drivers/IDatabaseDriver.js';
+import { type QueryOrder } from '../enums.js';
 /**
  * As an alternative to the offset-based pagination with `limit` and `offset`, we can paginate based on a cursor.
  * A cursor is an opaque string that defines a specific place in ordered entity graph. You can use `em.findByCursor()`

package/utils/Cursor.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Cursor = void 0;
-const node_util_1 = require("node:util");
-const Utils_1 = require("./Utils");
-const enums_1 = require("../enums");
-const Reference_1 = require("../entity/Reference");
-const wrap_1 = require("../entity/wrap");
-const RawQueryFragment_1 = require("../utils/RawQueryFragment");
-const errors_1 = require("../errors");
+import { inspect } from 'node:util';
+import { Utils } from './Utils.js';
+import { ReferenceKind } from '../enums.js';
+import { Reference } from '../entity/Reference.js';
+import { helper } from '../entity/wrap.js';
+import { RawQueryFragment } from '../utils/RawQueryFragment.js';
+import { CursorError } from '../errors.js';
 /**
  * As an alternative to the offset-based pagination with `limit` and `offset`, we can paginate based on a cursor.
  * A cursor is an opaque string that defines a specific place in ordered entity graph. You can use `em.findByCursor()`
@@ -55,7 +52,7 @@ const errors_1 = require("../errors");
  * }
  * ```
  */
-class Cursor {
+export class Cursor {
     items;
     totalCount;
     hasPrevPage;
@@ -97,18 +94,18 @@ class Cursor {
      */
     from(entity) {
         const processEntity = (entity, prop, direction, object = false) => {
-            if (Utils_1.Utils.isPlainObject(direction)) {
-                return Utils_1.Utils.keys(direction).reduce((o, key) => {
-                    Object.assign(o, processEntity(Reference_1.Reference.unwrapReference(entity[prop]), key, direction[key], true));
+            if (Utils.isPlainObject(direction)) {
+                return Utils.keys(direction).reduce((o, key) => {
+                    Object.assign(o, processEntity(Reference.unwrapReference(entity[prop]), key, direction[key], true));
                     return o;
                 }, {});
             }
             if (entity[prop] == null) {
-                throw errors_1.CursorError.entityNotPopulated(entity, prop);
+                throw CursorError.entityNotPopulated(entity, prop);
             }
             let value = entity[prop];
-            if (Utils_1.Utils.isEntity(value, true)) {
-                value = (0, wrap_1.helper)(value).getPrimaryKey();
+            if (Utils.isEntity(value, true)) {
+                value = helper(value).getPrimaryKey();
             }
             if (object) {
                 return ({ [prop]: value });
@@ -145,15 +142,16 @@ class Cursor {
         });
     }
     static getDefinition(meta, orderBy) {
-        return Utils_1.Utils.asArray(orderBy).flatMap(order => {
+        return Utils.asArray(orderBy).flatMap(order => {
             const ret = [];
-            for (const key of Utils_1.Utils.keys(order)) {
-                if (RawQueryFragment_1.RawQueryFragment.isKnownFragment(key)) {
+            for (const key of Utils.keys(order)) {
+                if (RawQueryFragment.isKnownFragment(key)) {
                     ret.push([key, order[key]]);
                     continue;
                 }
                 const prop = meta.properties[key];
-                if (!prop || !([enums_1.ReferenceKind.SCALAR, enums_1.ReferenceKind.EMBEDDED, enums_1.ReferenceKind.MANY_TO_ONE].includes(prop.kind) || (prop.kind === enums_1.ReferenceKind.ONE_TO_ONE && prop.owner))) {
+                /* v8 ignore next */
+                if (!prop || !([ReferenceKind.SCALAR, ReferenceKind.EMBEDDED, ReferenceKind.MANY_TO_ONE].includes(prop.kind) || (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner))) {
                     continue;
                 }
                 ret.push([prop.name, order[prop.name]]);
@@ -161,13 +159,12 @@ class Cursor {
             return ret;
         });
     }
-    /* istanbul ignore next */
+    /* v8 ignore start */
     /** @ignore */
-    [node_util_1.inspect.custom]() {
+    [inspect.custom]() {
         const type = this.items[0]?.constructor.name;
         const { items, startCursor, endCursor, hasPrevPage, hasNextPage, totalCount, length } = this;
-        const options = (0, node_util_1.inspect)({ startCursor, endCursor, totalCount, hasPrevPage, hasNextPage, items, length }, { depth: 0 });
+        const options = inspect({ startCursor, endCursor, totalCount, hasPrevPage, hasNextPage, items, length }, { depth: 0 });
         return `Cursor${type ? `<${type}>` : ''} ${options.replace('items: [Array]', 'items: [...]')}`;
     }
 }
-exports.Cursor = Cursor;

package/utils/DataloaderUtils.d.ts

@@ -1,8 +1,8 @@
-import type { Primary, Ref } from '../typings';
-import { Collection, type InitCollectionOptions } from '../entity/Collection';
-import { type EntityManager } from '../EntityManager';
+import type { Primary, Ref } from '../typings.js';
+import { Collection, type InitCollectionOptions } from '../entity/Collection.js';
+import { type EntityManager } from '../EntityManager.js';
 import type DataLoader from 'dataloader';
-import { type LoadReferenceOptions } from '../entity/Reference';
+import { type LoadReferenceOptions } from '../entity/Reference.js';
 export declare class DataloaderUtils {
     /**
      * Groups identified references by entity and returns a Map with the

package/utils/DataloaderUtils.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataloaderUtils = void 0;
-const Collection_1 = require("../entity/Collection");
-const wrap_1 = require("../entity/wrap");
-const enums_1 = require("../enums");
-const Reference_1 = require("../entity/Reference");
-class DataloaderUtils {
+import { Collection } from '../entity/Collection.js';
+import { helper } from '../entity/wrap.js';
+import { ReferenceKind } from '../enums.js';
+import { Reference } from '../entity/Reference.js';
+export class DataloaderUtils {
     /**
      * Groups identified references by entity and returns a Map with the
      * class name as the index and the corresponding primary keys as the value.
@@ -26,13 +23,13 @@ class DataloaderUtils {
                Thus such approach should probably be configurable, if not opt-in.
                NOTE: meta + opts multi maps (https://github.com/martian17/ds-js) might be a more elegant way
                to implement this but not necessarily faster.  */
-            const key = `${(0, wrap_1.helper)(ref).__meta.className}|${JSON.stringify(opts ?? {})}`;
+            const key = `${helper(ref).__meta.className}|${JSON.stringify(opts ?? {})}`;
             let primaryKeysSet = map.get(key);
             if (primaryKeysSet == null) {
                 primaryKeysSet = new Set();
                 map.set(key, primaryKeysSet);
             }
-            primaryKeysSet.add((0, wrap_1.helper)(ref).getPrimaryKey());
+            primaryKeysSet.add(helper(ref).getPrimaryKey());
         }
         return map;
     }
@@ -87,7 +84,7 @@ class DataloaderUtils {
                 filterMap.set(inversedProp, primaryKeys);
             }
             // This is the PK that in conjunction with the filter Map key (the prop) will lead to this specific Collection
-            primaryKeys.add((0, wrap_1.helper)(col.owner).getPrimaryKey());
+            primaryKeys.add(helper(col.owner).getPrimaryKey());
         }
         return entitiesMap;
     }
@@ -141,8 +138,8 @@ class DataloaderUtils {
             // This is the inverse side of the relationship where the filtering will be done in order to match the target collection
             // Either inversedBy or mappedBy exist because we already checked in groupInversedOrMappedKeysByEntity
             const inverseProp = collection.property.inversedBy ?? collection.property.mappedBy;
-            const target = Reference_1.Reference.unwrapReference(result[inverseProp]);
-            if (target instanceof Collection_1.Collection) {
+            const target = Reference.unwrapReference(result[inverseProp]);
+            if (target instanceof Collection) {
                 for (const item of target) {
                     if (item === collection.owner) {
                         return true;
@@ -153,7 +150,7 @@ class DataloaderUtils {
                 return target === collection.owner;
             }
             // FIXME https://github.com/mikro-orm/mikro-orm/issues/6031
-            if (!target && collection.property.kind === enums_1.ReferenceKind.MANY_TO_MANY) {
+            if (!target && collection.property.kind === ReferenceKind.MANY_TO_MANY) {
                 throw new Error(`Inverse side is required for M:N relations with dataloader: ${collection.owner.constructor.name}.${collection.property.name}`);
             }
             return false;
@@ -175,7 +172,7 @@ class DataloaderUtils {
                 const entities = resultsMap.get(key);
                 if (entities == null) {
                     // Should never happen
-                    /* istanbul ignore next */
+                    /* v8 ignore next 3 */
                     throw new Error('Cannot match results');
                 }
                 return entities.filter(DataloaderUtils.getColFilter(col));
@@ -183,4 +180,3 @@ class DataloaderUtils {
         };
     }
 }
-exports.DataloaderUtils = DataloaderUtils;

package/utils/EntityComparator.d.ts

@@ -1,5 +1,5 @@
-import type { EntityData, EntityDictionary, EntityMetadata, EntityProperty, IMetadataStorage } from '../typings';
-import type { Platform } from '../platforms';
+import type { EntityData, EntityDictionary, EntityMetadata, EntityProperty, IMetadataStorage } from '../typings.js';
+import type { Platform } from '../platforms/Platform.js';
 type Comparator<T> = (a: T, b: T) => EntityData<T>;
 type ResultMapper<T> = (result: EntityData<T>) => EntityData<T> | null;
 type SnapshotGenerator<T> = (entity: T) => EntityData<T>;