@mikro-orm/core 7.0.0-dev.32 → 7.0.0-dev.321

package/utils/ConfigurationLoader.js

@@ -1,330 +1 @@
-import dotenv from 'dotenv';
-import { realpathSync } from 'node:fs';
-import { colors } from '../logging/colors.js';
-import { Configuration } from './Configuration.js';
-import { Utils } from './Utils.js';
-/**
- * @internal
- */
-export class ConfigurationLoader {
-    static async getConfiguration(contextName = 'default', paths = ConfigurationLoader.getConfigPaths(), options = {}) {
-        // Backwards compatibility layer
-        if (typeof contextName === 'boolean' || !Array.isArray(paths)) {
-            this.registerDotenv(options);
-            const configPathFromArg = ConfigurationLoader.configPathsFromArg();
-            const configPaths = configPathFromArg ?? (Array.isArray(paths) ? paths : ConfigurationLoader.getConfigPaths());
-            const config = contextName
-                ? (await ConfigurationLoader.getConfiguration(process.env.MIKRO_ORM_CONTEXT_NAME ?? 'default', configPaths, Array.isArray(paths) ? {} : paths))
-                : await (async () => {
-                    const env = await this.loadEnvironmentVars();
-                    const [path, tmp] = await this.getConfigFile(configPaths);
-                    if (!path) {
-                        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(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 = await this.loadEnvironmentVars();
-        const configFinder = (cfg) => {
-            return typeof cfg === 'object' && cfg !== null && ('contextName' in cfg ? cfg.contextName === contextName : (contextName === 'default'));
-        };
-        const isValidConfigFactoryResult = (cfg) => {
-            return typeof cfg === 'object' && cfg !== null && (!('contextName' in cfg) || cfg.contextName === contextName);
-        };
-        const result = await this.getConfigFile(paths);
-        if (!result[0]) {
-            if (Utils.hasObjectKeys(env)) {
-                return new Configuration(Utils.mergeConfig({ contextName }, options, env));
-            }
-            throw new Error(`MikroORM config file not found in ['${paths.join(`', '`)}']`);
-        }
-        const path = result[0];
-        let tmp = result[1];
-        if (Array.isArray(tmp)) {
-            const tmpFirstIndex = tmp.findIndex(configFinder);
-            if (tmpFirstIndex === -1) {
-                // Static config not found. Try factory functions
-                let configCandidate;
-                for (let i = 0, l = tmp.length; i < l; ++i) {
-                    const f = tmp[i];
-                    if (typeof f !== 'function') {
-                        continue;
-                    }
-                    configCandidate = await f(contextName);
-                    if (!isValidConfigFactoryResult(configCandidate)) {
-                        continue;
-                    }
-                    tmp = configCandidate;
-                    break;
-                }
-                if (Array.isArray(tmp)) {
-                    throw new Error(`MikroORM config '${contextName}' was not found within the config file '${path}'. Either add a config with this name to the array, or add a function that when given this name will return a configuration object without a name, or with name set to this name.`);
-                }
-            }
-            else {
-                const tmpLastIndex = tmp.findLastIndex(configFinder);
-                if (tmpLastIndex !== tmpFirstIndex) {
-                    throw new Error(`MikroORM config '${contextName}' is not unique within the array exported by '${path}' (first occurrence index: ${tmpFirstIndex}; last occurrence index: ${tmpLastIndex})`);
-                }
-                tmp = tmp[tmpFirstIndex];
-            }
-        }
-        else {
-            if (tmp instanceof Function) {
-                tmp = await tmp(contextName);
-                if (!isValidConfigFactoryResult(tmp)) {
-                    throw new Error(`MikroORM config '${contextName}' was not what the function exported from '${path}' provided. Ensure it returns a config object with no name, or name matching the requested one.`);
-                }
-            }
-            else {
-                if (!configFinder(tmp)) {
-                    throw new Error(`MikroORM config '${contextName}' was not what the default export from '${path}' provided.`);
-                }
-            }
-        }
-        const esmConfigOptions = this.isESM() ? { entityGenerator: { esmImport: true } } : {};
-        return new Configuration(Utils.mergeConfig({}, esmConfigOptions, tmp, options, env));
-    }
-    static async getConfigFile(paths) {
-        for (let path of paths) {
-            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 (Utils.pathExistsSync(`${basePath}/package.json`)) {
-            /* v8 ignore next 5 */
-            try {
-                return Utils.readJSONSync(`${basePath}/package.json`);
-            }
-            catch {
-                return {};
-            }
-        }
-        const parentFolder = realpathSync(`${basePath}/..`);
-        // we reached the root folder
-        if (basePath === parentFolder) {
-            return {};
-        }
-        return this.getPackageConfig(parentFolder);
-    }
-    static getSettings() {
-        const config = ConfigurationLoader.getPackageConfig();
-        const settings = { ...config['mikro-orm'] };
-        const bool = (v) => ['true', 't', '1'].includes(v.toLowerCase());
-        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.preferTs = true;
-        }
-        return settings;
-    }
-    static configPathsFromArg() {
-        const options = Utils.parseArgs();
-        const configArgName = process.env.MIKRO_ORM_CONFIG_ARG_NAME ?? 'config';
-        if (options[configArgName]) {
-            return [options[configArgName]];
-        }
-        return undefined;
-    }
-    static getConfigPaths() {
-        const paths = [];
-        const settings = ConfigurationLoader.getSettings();
-        if (process.env.MIKRO_ORM_CLI_CONFIG) {
-            paths.push(process.env.MIKRO_ORM_CLI_CONFIG);
-        }
-        paths.push(...(settings.configPaths || []));
-        const alwaysAllowTs = settings.alwaysAllowTs ?? process.versions.bun;
-        if (settings.preferTs !== false || alwaysAllowTs) {
-            paths.push('./src/mikro-orm.config.ts');
-            paths.push('./mikro-orm.config.ts');
-        }
-        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 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 async registerTypeScriptSupport(configPath = 'tsconfig.json') {
-        /* v8 ignore next 3 */
-        if (process.versions.bun) {
-            return true;
-        }
-        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',
-        });
-        return !!supported;
-    }
-    static registerDotenv(options) {
-        const path = process.env.MIKRO_ORM_ENV ?? ((options?.baseDir ?? process.cwd()) + '/.env');
-        const env = {};
-        dotenv.config({ path, processEnv: env, quiet: true });
-        // only propagate known env vars
-        for (const key of Object.keys(env)) {
-            if (key.startsWith('MIKRO_ORM_')) {
-                process.env[key] ??= env[key]; // respect user provided values
-            }
-        }
-    }
-    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' },
-            mysql: { className: 'MySqlDriver', module: '@mikro-orm/mysql' },
-            mssql: { className: 'MsSqlDriver', module: '@mikro-orm/mssql' },
-            mariadb: { className: 'MariaDbDriver', module: '@mikro-orm/mariadb' },
-            postgresql: { className: 'PostgreSqlDriver', module: '@mikro-orm/postgresql' },
-            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 read = (o, envKey, key, mapper = v => v) => {
-            if (!(envKey in process.env)) {
-                return;
-            }
-            const val = process.env[envKey];
-            o[key] = mapper(val);
-        };
-        const cleanup = (o, k) => Utils.hasObjectKeys(o[k]) ? {} : delete o[k];
-        read(ret, 'MIKRO_ORM_BASE_DIR', 'baseDir');
-        read(ret, 'MIKRO_ORM_ENTITIES', 'entities', array);
-        read(ret, 'MIKRO_ORM_ENTITIES_TS', 'entitiesTs', array);
-        read(ret, 'MIKRO_ORM_CLIENT_URL', 'clientUrl');
-        read(ret, 'MIKRO_ORM_HOST', 'host');
-        read(ret, 'MIKRO_ORM_PORT', 'port', num);
-        read(ret, 'MIKRO_ORM_USER', 'user');
-        read(ret, 'MIKRO_ORM_PASSWORD', 'password');
-        read(ret, 'MIKRO_ORM_DB_NAME', 'dbName');
-        read(ret, 'MIKRO_ORM_SCHEMA', 'schema');
-        read(ret, 'MIKRO_ORM_LOAD_STRATEGY', 'loadStrategy');
-        read(ret, 'MIKRO_ORM_BATCH_SIZE', 'batchSize', num);
-        read(ret, 'MIKRO_ORM_USE_BATCH_INSERTS', 'useBatchInserts', bool);
-        read(ret, 'MIKRO_ORM_USE_BATCH_UPDATES', 'useBatchUpdates', bool);
-        read(ret, 'MIKRO_ORM_STRICT', 'strict', bool);
-        read(ret, 'MIKRO_ORM_VALIDATE', 'validate', bool);
-        read(ret, 'MIKRO_ORM_ALLOW_GLOBAL_CONTEXT', 'allowGlobalContext', bool);
-        read(ret, 'MIKRO_ORM_AUTO_JOIN_ONE_TO_ONE_OWNER', 'autoJoinOneToOneOwner', bool);
-        read(ret, 'MIKRO_ORM_POPULATE_AFTER_FLUSH', 'populateAfterFlush', bool);
-        read(ret, 'MIKRO_ORM_FORCE_ENTITY_CONSTRUCTOR', 'forceEntityConstructor', bool);
-        read(ret, 'MIKRO_ORM_FORCE_UNDEFINED', 'forceUndefined', bool);
-        read(ret, 'MIKRO_ORM_FORCE_UTC_TIMEZONE', 'forceUtcTimezone', bool);
-        read(ret, 'MIKRO_ORM_TIMEZONE', 'timezone');
-        read(ret, 'MIKRO_ORM_ENSURE_INDEXES', 'ensureIndexes', bool);
-        read(ret, 'MIKRO_ORM_IMPLICIT_TRANSACTIONS', 'implicitTransactions', bool);
-        read(ret, 'MIKRO_ORM_DEBUG', 'debug', bool);
-        read(ret, 'MIKRO_ORM_COLORS', 'colors', bool);
-        ret.discovery = {};
-        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_WARN_WHEN_NO_ENTITIES', 'warnWhenNoEntities', bool);
-        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_REQUIRE_ENTITIES_ARRAY', 'requireEntitiesArray', bool);
-        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_ALWAYS_ANALYSE_PROPERTIES', 'alwaysAnalyseProperties', bool);
-        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_DISABLE_DYNAMIC_FILE_ACCESS', 'disableDynamicFileAccess', bool);
-        cleanup(ret, 'discovery');
-        ret.migrations = {};
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_TABLE_NAME', 'tableName');
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_PATH', 'path');
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_PATH_TS', 'pathTs');
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_GLOB', 'glob');
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_TRANSACTIONAL', 'transactional', bool);
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_DISABLE_FOREIGN_KEYS', 'disableForeignKeys', bool);
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_ALL_OR_NOTHING', 'allOrNothing', bool);
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_DROP_TABLES', 'dropTables', bool);
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_SAFE', 'safe', bool);
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_SILENT', 'silent', bool);
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_EMIT', 'emit');
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_SNAPSHOT', 'snapshot', bool);
-        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_SNAPSHOT_NAME', 'snapshotName');
-        cleanup(ret, 'migrations');
-        ret.schemaGenerator = {};
-        read(ret.schemaGenerator, 'MIKRO_ORM_SCHEMA_GENERATOR_DISABLE_FOREIGN_KEYS', 'disableForeignKeys', bool);
-        read(ret.schemaGenerator, 'MIKRO_ORM_SCHEMA_GENERATOR_CREATE_FOREIGN_KEY_CONSTRAINTS', 'createForeignKeyConstraints', bool);
-        cleanup(ret, 'schemaGenerator');
-        ret.seeder = {};
-        read(ret.seeder, 'MIKRO_ORM_SEEDER_PATH', 'path');
-        read(ret.seeder, 'MIKRO_ORM_SEEDER_PATH_TS', 'pathTs');
-        read(ret.seeder, 'MIKRO_ORM_SEEDER_GLOB', 'glob');
-        read(ret.seeder, 'MIKRO_ORM_SEEDER_EMIT', 'emit');
-        read(ret.seeder, 'MIKRO_ORM_SEEDER_DEFAULT_SEEDER', 'defaultSeeder');
-        cleanup(ret, 'seeder');
-        return ret;
-    }
-    static getORMPackages() {
-        const pkg = this.getPackageConfig();
-        return new Set([
-            ...Object.keys(pkg.dependencies ?? {}),
-            ...Object.keys(pkg.devDependencies ?? {}),
-        ]);
-    }
-    static getORMPackageVersion(name) {
-        try {
-            const pkg = Utils.requireFrom(`${name}/package.json`);
-            /* v8 ignore next */
-            return pkg?.version;
-        }
-        catch (e) {
-            return undefined;
-        }
-    }
-    // inspired by https://github.com/facebook/docusaurus/pull/3386
-    static checkPackageVersion() {
-        const coreVersion = Utils.getORMVersion();
-        if (process.env.MIKRO_ORM_ALLOW_VERSION_MISMATCH || coreVersion === 'N/A') {
-            return coreVersion;
-        }
-        const deps = this.getORMPackages();
-        const exceptions = new Set(['nestjs', 'sql-highlighter', 'mongo-highlighter']);
-        const ormPackages = [...deps].filter(d => d.startsWith('@mikro-orm/') && d !== '@mikro-orm/core' && !exceptions.has(d.substring('@mikro-orm/'.length)));
-        for (const ormPackage of ormPackages) {
-            const version = this.getORMPackageVersion(ormPackage);
-            if (version != null && version !== coreVersion) {
-                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?`);
-            }
-        }
-        return coreVersion;
-    }
-}
+export {};

package/utils/Cursor.d.ts

@@ -1,4 +1,3 @@
-import { inspect } from 'node:util';
 import type { EntityMetadata, FilterObject, Loaded } from '../typings.js';
 import type { FindByCursorOptions, OrderDefinition } from '../drivers/IDatabaseDriver.js';
 import { type QueryOrder } from '../enums.js';
@@ -71,6 +70,4 @@ export declare class Cursor<Entity extends object, Hint extends string = never,
     static encode(value: unknown[]): string;
     static decode(value: string): unknown[];
     static getDefinition<Entity extends object>(meta: EntityMetadata<Entity>, orderBy: OrderDefinition<Entity>): [never, QueryOrder][];
-    /** @ignore */
-    [inspect.custom](): string;
 }

package/utils/Cursor.js

@@ -1,10 +1,10 @@
-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 { Raw } from '../utils/RawQueryFragment.js';
 import { CursorError } from '../errors.js';
+import { inspect } from '../logging/inspect.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()`
@@ -95,15 +95,22 @@ export class Cursor {
     from(entity) {
         const processEntity = (entity, prop, direction, object = false) => {
             if (Utils.isPlainObject(direction)) {
+                const unwrapped = Reference.unwrapReference(entity[prop]);
+                // Check if the relation is loaded - for nested properties, undefined means not populated
+                if (Utils.isEntity(unwrapped) && !helper(unwrapped).isInitialized()) {
+                    throw CursorError.entityNotPopulated(entity, prop);
+                }
                 return Utils.keys(direction).reduce((o, key) => {
-                    Object.assign(o, processEntity(Reference.unwrapReference(entity[prop]), key, direction[key], true));
+                    Object.assign(o, processEntity(unwrapped, key, direction[key], true));
                     return o;
                 }, {});
             }
-            if (entity[prop] == null) {
-                throw CursorError.entityNotPopulated(entity, prop);
-            }
             let value = entity[prop];
+            // Allow null/undefined values in cursor - they will be handled in createCursorCondition
+            // undefined can occur with forceUndefined config option which converts null to undefined
+            if (value == null) {
+                return object ? { [prop]: null } : null;
+            }
             if (Utils.isEntity(value, true)) {
                 value = helper(value).getPrimaryKey();
             }
@@ -111,7 +118,7 @@ export class Cursor {
                 value = value.unwrap();
             }
             if (object) {
-                return ({ [prop]: value });
+                return { [prop]: value };
             }
             return value;
         };
@@ -131,14 +138,20 @@ export class Cursor {
      */
     static for(meta, entity, orderBy) {
         const definition = this.getDefinition(meta, orderBy);
-        return Cursor.encode(definition.map(([key]) => entity[key]));
+        return Cursor.encode(definition.map(([key]) => {
+            const value = entity[key];
+            if (value === undefined) {
+                throw CursorError.missingValue(meta.className, key);
+            }
+            return value;
+        }));
     }
     static encode(value) {
         return Buffer.from(JSON.stringify(value)).toString('base64url');
     }
     static decode(value) {
         return JSON.parse(Buffer.from(value, 'base64url').toString('utf8')).map((value) => {
-            if (typeof value === 'string' && value.match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}/)) {
+            if (typeof value === 'string' && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}/.exec(value)) {
                 return new Date(value);
             }
             return value;
@@ -147,14 +160,16 @@ export class Cursor {
     static getDefinition(meta, orderBy) {
         return Utils.asArray(orderBy).flatMap(order => {
             const ret = [];
-            for (const key of Utils.keys(order)) {
-                if (RawQueryFragment.isKnownFragment(key)) {
+            for (const key of Utils.getObjectQueryKeys(order)) {
+                if (Raw.isKnownFragmentSymbol(key)) {
                     ret.push([key, order[key]]);
                     continue;
                 }
                 const prop = meta.properties[key];
                 /* v8 ignore next */
-                if (!prop || !([ReferenceKind.SCALAR, ReferenceKind.EMBEDDED, ReferenceKind.MANY_TO_ONE].includes(prop.kind) || (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner))) {
+                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]]);
@@ -162,9 +177,9 @@ export class Cursor {
             return ret;
         });
     }
-    /* v8 ignore start */
     /** @ignore */
-    [inspect.custom]() {
+    /* v8 ignore next */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
         const type = this.items[0]?.constructor.name;
         const { items, startCursor, endCursor, hasPrevPage, hasNextPage, totalCount, length } = this;
         const options = inspect({ startCursor, endCursor, totalCount, hasPrevPage, hasNextPage, items, length }, { depth: 0 });

package/utils/DataloaderUtils.d.ts

@@ -1,9 +1,10 @@
-import type DataLoader from 'dataloader';
-import type { Primary, Ref } from '../typings.js';
+import type { Constructor, Primary, Ref } from '../typings.js';
 import { Collection, type InitCollectionOptions } 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>>;
 export declare class DataloaderUtils {
+    private static DataLoader?;
     /**
      * Groups identified references by entity and returns a Map with the
      * class name as the index and the corresponding primary keys as the value.
@@ -13,7 +14,7 @@ export declare class DataloaderUtils {
      * Returns the reference dataloader batchLoadFn, which aggregates references by entity,
      * makes one query per entity and maps each input reference to the corresponding result.
      */
-    static getRefBatchLoadFn(em: EntityManager): DataLoader.BatchLoadFn<[Ref<any>, Omit<LoadReferenceOptions<any, any>, 'dataloader'>?], any>;
+    static getRefBatchLoadFn(em: EntityManager): BatchLoadFn<[Ref<any>, Omit<LoadReferenceOptions<any, any>, 'dataloader'>?], any>;
     /**
      * Groups collections by entity and returns a Map whose keys are the entity names and whose values are filter Maps
      * which we can use to narrow down the find query to return just the items of the collections that have been dataloaded.
@@ -37,10 +38,14 @@ export declare class DataloaderUtils {
      * Returns the 1:M collection dataloader batchLoadFn, which aggregates collections by entity,
      * makes one query per entity and maps each input collection to the corresponding result.
      */
-    static getColBatchLoadFn(em: EntityManager): DataLoader.BatchLoadFn<[Collection<any>, Omit<InitCollectionOptions<any, any>, 'dataloader'>?], any>;
+    static getColBatchLoadFn(em: EntityManager): BatchLoadFn<[Collection<any>, Omit<InitCollectionOptions<any, any>, 'dataloader'>?], any>;
     /**
      * Returns the M:N collection dataloader batchLoadFn, which aggregates collections by entity,
      * makes one query per entity and maps each input collection to the corresponding result.
      */
-    static getManyToManyColBatchLoadFn(em: EntityManager): DataLoader.BatchLoadFn<[Collection<any>, Omit<InitCollectionOptions<any, any>, 'dataloader'>?], any>;
+    static getManyToManyColBatchLoadFn(em: EntityManager): BatchLoadFn<[Collection<any>, Omit<InitCollectionOptions<any, any>, 'dataloader'>?], any>;
+    static getDataLoader(): Promise<Constructor<{
+        load: (...args: unknown[]) => Promise<unknown>;
+    }>>;
 }
+export {};

package/utils/DataloaderUtils.js

@@ -3,6 +3,7 @@ import { helper } from '../entity/wrap.js';
 import { Reference } from '../entity/Reference.js';
 import { Utils } from './Utils.js';
 export class DataloaderUtils {
+    static DataLoader;
     /**
      * Groups identified references by entity and returns a Map with the
      * class name as the index and the corresponding primary keys as the value.
@@ -10,7 +11,7 @@ export class DataloaderUtils {
     static groupPrimaryKeysByEntityAndOpts(refsWithOpts) {
         const map = new Map();
         for (const [ref, opts] of refsWithOpts) {
-            /* The key is a combination of the className and a stringified version if the load options because we want
+            /* The key is a combination of the uniqueName (a unique table name based identifier) and a stringified version if the load options because we want
                to map each combination of entities/options into separate find queries in order to return accurate results.
                This could be further optimized finding the "lowest common denominator" among the different options
                for each Entity and firing a single query for each Entity instead of Entity+options combination.
@@ -23,7 +24,7 @@ export 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 = `${helper(ref).__meta.className}|${JSON.stringify(opts ?? {})}`;
+            const key = `${helper(ref).__meta.uniqueName}|${JSON.stringify(opts ?? {})}`;
             let primaryKeysSet = map.get(key);
             if (primaryKeysSet == null) {
                 primaryKeysSet = new Set();
@@ -41,9 +42,10 @@ export class DataloaderUtils {
         return async (refsWithOpts) => {
             const groupedIdsMap = DataloaderUtils.groupPrimaryKeysByEntityAndOpts(refsWithOpts);
             const promises = Array.from(groupedIdsMap).map(([key, idsSet]) => {
-                const className = key.substring(0, key.indexOf('|'));
+                const uniqueName = key.substring(0, key.indexOf('|'));
                 const opts = JSON.parse(key.substring(key.indexOf('|') + 1));
-                return em.find(className, Array.from(idsSet), opts);
+                const meta = em.getMetadata().getByUniqueName(uniqueName);
+                return em.find(meta.class, Array.from(idsSet), opts);
             });
             await Promise.all(promises);
             /* Instead of assigning each find result to the original reference we use a shortcut
@@ -69,7 +71,7 @@ export class DataloaderUtils {
             The value is another Map which we can use to filter the find query to get results pertaining to the collections that have been dataloaded:
             its keys are the props we are going to filter to and its values are the corresponding PKs.
             */
-            const key = `${col.property.targetMeta.className}|${JSON.stringify(opts ?? {})}`;
+            const key = `${col.property.targetMeta.uniqueName}|${JSON.stringify(opts ?? {})}`;
             let filterMap = entitiesMap.get(key); // We are going to use this map to filter the entities pertaining to the collections that have been dataloaded.
             if (filterMap == null) {
                 filterMap = new Map();
@@ -96,31 +98,33 @@ export class DataloaderUtils {
      */
     static entitiesAndOptsMapToQueries(entitiesAndOptsMap, em) {
         return Array.from(entitiesAndOptsMap, async ([key, filterMap]) => {
-            const className = key.substring(0, key.indexOf('|'));
+            const uniqueName = key.substring(0, key.indexOf('|'));
             const opts = JSON.parse(key.substring(key.indexOf('|') + 1));
-            const res = await em.find(className, opts?.where != null && Object.keys(opts.where).length > 0 ?
-                {
+            const meta = em.getMetadata().getByUniqueName(uniqueName);
+            const res = await em.find(meta.class, opts?.where != null && Object.keys(opts.where).length > 0
+                ? {
                     $and: [
                         {
                             $or: Array.from(filterMap.entries()).map(([prop, pks]) => {
-                                return ({ [prop]: Array.from(pks) });
+                                return { [prop]: Array.from(pks) };
                             }),
                         },
                         opts.where,
                     ],
-                } : {
-                // The entries of the filter Map will be used as the values of the $or operator
-                $or: Array.from(filterMap.entries()).map(([prop, pks]) => {
-                    return ({ [prop]: Array.from(pks) });
-                }),
-            }, {
+                }
+                : {
+                    // The entries of the filter Map will be used as the values of the $or operator
+                    $or: Array.from(filterMap.entries()).map(([prop, pks]) => {
+                        return { [prop]: Array.from(pks) };
+                    }),
+                }, {
                 ...opts,
                 // We need to populate the inverse side of the relationship in order to be able to later retrieve the PK(s) from its item(s)
                 populate: [
-                    ...(opts.populate === false ? [] : opts.populate ?? []),
+                    ...(opts.populate === false ? [] : (opts.populate ?? [])),
                     ...Array.from(filterMap.keys()).filter(
                     // We need to do so only if the inverse side is a collection, because we can already retrieve the PK from a reference without having to load it
-                    prop => em.getMetadata(className).properties[prop]?.ref !== true),
+                    prop => meta.properties[prop]?.ref !== true),
                 ],
             });
             return [key, res];
@@ -163,11 +167,11 @@ export class DataloaderUtils {
             // We need to filter the results in order to map each input collection
             // to a subset of each query matching the collection items.
             return collsWithOpts.map(([col, opts]) => {
-                const key = `${col.property.targetMeta.className}|${JSON.stringify(opts ?? {})}`;
+                const key = `${col.property.targetMeta.uniqueName}|${JSON.stringify(opts ?? {})}`;
                 const entities = resultsMap.get(key);
                 if (entities == null) {
                     // Should never happen
-                    /* v8 ignore next 3 */
+                    /* v8 ignore next */
                     throw new Error('Cannot match results');
                 }
                 return entities.filter(DataloaderUtils.getColFilter(col));
@@ -182,7 +186,7 @@ export class DataloaderUtils {
         return async (collsWithOpts) => {
             const groups = new Map();
             for (const [col, opts] of collsWithOpts) {
-                const key = `${col.property.targetMeta.className}.${col.property.name}|${JSON.stringify(opts ?? {})}`;
+                const key = `${col.property.targetMeta.uniqueName}.${col.property.name}|${JSON.stringify(opts ?? {})}`;
                 const value = groups.get(key) ?? [];
                 value.push([col, opts ?? {}]);
                 groups.set(key, value);
@@ -197,17 +201,33 @@ export class DataloaderUtils {
                 const owners = group.map(c => c[0].owner);
                 const $or = [];
                 // a bit of a hack, but we need to prefix the key, since we have only a column name, not a property name
-                const alias = em.config.getNamingStrategy().aliasName(prop.pivotEntity, 0);
+                const alias = em.config.getNamingStrategy().aliasName(Utils.className(prop.pivotEntity), 0);
                 const fk = `${alias}.${Utils.getPrimaryKeyHash(prop.joinColumns)}`;
                 for (const c of group) {
                     $or.push({ $and: [c[1]?.where ?? {}, { [fk]: c[0].owner }] });
                     options.refresh ??= c[1]?.refresh;
                 }
                 options.where = wrap({ $or });
-                const r = await em.getEntityLoader().findChildrenFromPivotTable(owners, prop, options, orderBy, populate, group[0][1]?.ref);
+                const r = await em
+                    .getEntityLoader()
+                    .findChildrenFromPivotTable(owners, prop, options, orderBy, populate, group[0][1]?.ref);
                 ret.push(...r);
             }
             return ret;
         };
     }
+    static async getDataLoader() {
+        if (this.DataLoader) {
+            return this.DataLoader;
+        }
+        try {
+            const mod = await import('dataloader');
+            const DataLoader = mod.default;
+            return (this.DataLoader ??= DataLoader);
+        }
+        catch {
+            /* v8 ignore next */
+            throw new Error("DataLoader is not found, make sure `dataloader` package is installed in your project's dependencies.");
+        }
+    }
 }