@mikro-orm/core 7.0.0-dev.76 → 7.0.0-dev.78

package/EntityManager.js

@@ -239,7 +239,7 @@ export class EntityManager {
         if (options.populateWhere === PopulateHint.ALL) {
             return { where: {}, populateWhere: options.populateWhere };
         }
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (options.populateWhere === PopulateHint.INFER) {
             return { where, populateWhere: options.populateWhere };
         }
@@ -977,7 +977,7 @@ export class EntityManager {
                     });
                     return this.comparator.matching(entityName, cond, tmp);
                 });
-                /* v8 ignore next 3 */
+                /* v8 ignore next */
                 if (!row) {
                     throw new Error(`Cannot find matching entity for condition ${JSON.stringify(cond)}`);
                 }
@@ -1000,7 +1000,7 @@ export class EntityManager {
                         }, {});
                         return this.comparator.matching(entityName, cond, pk);
                     });
-                    /* v8 ignore next 3 */
+                    /* v8 ignore next */
                     if (!row) {
                         throw new Error(`Cannot find matching entity for condition ${JSON.stringify(cond)}`);
                     }
@@ -1674,7 +1674,7 @@ export class EntityManager {
         }
         if (typeof options.populate !== 'boolean') {
             options.populate = Utils.asArray(options.populate).map(field => {
-                /* v8 ignore next 3 */
+                /* v8 ignore next */
                 if (typeof field === 'boolean' || field === PopulatePath.ALL) {
                     return [{ field: meta.primaryKeys[0], strategy: options.strategy, all: !!field }]; //
                 }

package/MikroORM.d.ts

@@ -4,8 +4,35 @@ import { MetadataStorage } from './metadata/MetadataStorage.js';
 import { Configuration, type Options } from './utils/Configuration.js';
 import type { EntityManager } from './EntityManager.js';
 import type { AnyEntity, Constructor, EntityClass, EntityMetadata, EntityName, IEntityGenerator, IMigrator, ISeedManager } from './typings.js';
+/** @internal */
+export declare function lookupExtensions(options: Options): Promise<void>;
 /**
- * Helper class for bootstrapping the MikroORM.
+ * The main class used to configure and bootstrap the ORM.
+ *
+ * @example
+ * ```ts
+ * // import from driver package
+ * import { MikroORM, defineEntity, p } from '@mikro-orm/sqlite';
+ *
+ * const User = defineEntity({
+ *   name: 'User',
+ *   properties: {
+ *     id: p.integer().primary(),
+ *     name: p.string(),
+ *   },
+ * });
+ *
+ * const orm = new MikroORM({
+ *   entities: [User],
+ *   dbName: 'my.db',
+ * });
+ * await orm.schema.update();
+ *
+ * const em = orm.em.fork();
+ * const u1 = em.create(User, { name: 'John' });
+ * const u2 = em.create(User, { name: 'Ben' });
+ * await em.flush();
+ * ```
  */
 export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver, EM extends Driver[typeof EntityManagerType] & EntityManager<Driver> = Driver[typeof EntityManagerType] & EntityManager<Driver>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> {
     /** The global EntityManager instance. If you are using `RequestContext` helper, it will automatically pick the request specific context under the hood */
@@ -42,7 +69,7 @@ export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver,
      */
     isConnected(): Promise<boolean>;
     /**
-     * Checks whether the database connection is active, returns .
+     * Checks whether the database connection is active, returns the reason if not.
      */
     checkConnection(): Promise<{
         ok: true;

package/MikroORM.js

@@ -1,11 +1,69 @@
 import { MetadataDiscovery } from './metadata/MetadataDiscovery.js';
 import { MetadataStorage } from './metadata/MetadataStorage.js';
 import { Configuration } from './utils/Configuration.js';
-import { ConfigurationLoader } from './utils/ConfigurationLoader.js';
+import { loadEnvironmentVars } from './utils/env-vars.js';
 import { Utils } from './utils/Utils.js';
 import { colors } from './logging/colors.js';
+async function registerExtension(name, mod, extensions) {
+    /* v8 ignore next */
+    const resolved = await mod.catch(() => null);
+    const module = resolved?.[name];
+    /* v8 ignore else */
+    if (module) {
+        extensions.push(module);
+    }
+}
+/** @internal */
+export async function lookupExtensions(options) {
+    const extensions = options.extensions ?? [];
+    const exists = (name) => extensions.some(ext => ext.name === name);
+    if (!exists('SeedManager')) {
+        await registerExtension('SeedManager', import('@mikro-orm/seeder' + ''), extensions);
+    }
+    if (!exists('Migrator')) {
+        await registerExtension('Migrator', import('@mikro-orm/migrations' + ''), extensions);
+    }
+    /* v8 ignore if */
+    if (!exists('Migrator')) {
+        await registerExtension('Migrator', import('@mikro-orm/migrations-mongodb' + ''), extensions);
+    }
+    if (!exists('EntityGenerator')) {
+        await registerExtension('EntityGenerator', import('@mikro-orm/entity-generator' + ''), extensions);
+    }
+    options.extensions = extensions;
+    const metadataCacheEnabled = options.metadataCache?.enabled || options.metadataProvider?.useCache?.();
+    if (metadataCacheEnabled) {
+        options.metadataCache ??= {};
+        options.metadataCache.adapter ??= await import('@mikro-orm/core/fs-utils').then(m => m.FileCacheAdapter);
+    }
+}
 /**
- * Helper class for bootstrapping the MikroORM.
+ * The main class used to configure and bootstrap the ORM.
+ *
+ * @example
+ * ```ts
+ * // import from driver package
+ * import { MikroORM, defineEntity, p } from '@mikro-orm/sqlite';
+ *
+ * const User = defineEntity({
+ *   name: 'User',
+ *   properties: {
+ *     id: p.integer().primary(),
+ *     name: p.string(),
+ *   },
+ * });
+ *
+ * const orm = new MikroORM({
+ *   entities: [User],
+ *   dbName: 'my.db',
+ * });
+ * await orm.schema.update();
+ *
+ * const em = orm.em.fork();
+ * const u1 = em.create(User, { name: 'John' });
+ * const u2 = em.create(User, { name: 'Ben' });
+ * await em.flush();
+ * ```
  */
 export class MikroORM {
     /** The global EntityManager instance. If you are using `RequestContext` helper, it will automatically pick the request specific context under the hood */
@@ -20,12 +78,14 @@ export class MikroORM {
      * If you omit the `options` parameter, your CLI config will be used.
      */
     static async init(options) {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (!options) {
             throw new Error(`options parameter is required`);
         }
+        options = { ...options };
         options.discovery ??= {};
         options.discovery.skipSyncDiscovery ??= true;
+        await lookupExtensions(options);
         const orm = new this(options);
         const preferTs = orm.config.get('preferTs', Utils.detectTypeScriptSupport());
         orm.metadata = await orm.discovery.discover(preferTs);
@@ -39,14 +99,13 @@ export class MikroORM {
      * - no support for folder based discovery
      */
     constructor(options) {
-        const env = ConfigurationLoader.loadEnvironmentVars();
-        const coreVersion = ConfigurationLoader.checkPackageVersion();
+        const env = loadEnvironmentVars();
         options = Utils.merge(options, env);
         this.config = new Configuration(options);
         const discovery = this.config.get('discovery');
         this.driver = this.config.getDriver();
         this.logger = this.config.getLogger();
-        this.logger.log('info', `MikroORM version: ${colors.green(coreVersion)}`);
+        this.logger.log('info', `MikroORM version: ${colors.green(Utils.getORMVersion())}`);
         this.discovery = new MetadataDiscovery(new MetadataStorage(), this.driver.getPlatform(), this.config);
         this.driver.getPlatform().init(this);
         for (const extension of this.config.get('extensions')) {
@@ -68,7 +127,7 @@ export class MikroORM {
      * Reconnects, possibly to a different database.
      */
     async reconnect(options = {}) {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         for (const key of Utils.keys(options)) {
             this.config.set(key, options[key]);
         }
@@ -81,7 +140,7 @@ export class MikroORM {
         return this.driver.getConnection().isConnected();
     }
     /**
-     * Checks whether the database connection is active, returns .
+     * Checks whether the database connection is active, returns the reason if not.
      */
     async checkConnection() {
         return this.driver.getConnection().checkConnection();
@@ -91,12 +150,8 @@ export class MikroORM {
      */
     async close(force = false) {
         await this.driver.close(force);
-        if (this.config.getMetadataCacheAdapter()?.close) {
-            await this.config.getMetadataCacheAdapter().close();
-        }
-        if (this.config.getResultCacheAdapter()?.close) {
-            await this.config.getResultCacheAdapter().close();
-        }
+        await this.config.getMetadataCacheAdapter().close?.();
+        await this.config.getResultCacheAdapter().close?.();
     }
     /**
      * Gets the `MetadataStorage` (without parameters) or `EntityMetadata` instance when provided with the `entityName` parameter.

package/cache/FileCacheAdapter.d.ts

@@ -8,7 +8,7 @@ export declare class FileCacheAdapter implements SyncCacheAdapter {
     constructor(options: {
         cacheDir: string;
         combined?: boolean | string;
-    }, baseDir: string, pretty?: boolean);
+    } | undefined, baseDir: string, pretty?: boolean);
     /**
      * @inheritDoc
      */

package/cache/FileCacheAdapter.js

@@ -1,4 +1,5 @@
 import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import { fs } from '../utils/fs-utils.js';
 import { Utils } from '../utils/Utils.js';
 export class FileCacheAdapter {
     options;
@@ -6,10 +7,11 @@ export class FileCacheAdapter {
     pretty;
     VERSION = Utils.getORMVersion();
     cache = {};
-    constructor(options, baseDir, pretty = false) {
+    constructor(options = {}, baseDir, pretty = false) {
         this.options = options;
         this.baseDir = baseDir;
         this.pretty = pretty;
+        this.options.cacheDir ??= process.cwd() + '/temp';
     }
     /**
      * @inheritDoc
@@ -19,7 +21,7 @@ export class FileCacheAdapter {
         if (!existsSync(path)) {
             return null;
         }
-        const payload = Utils.readJSONSync(path);
+        const payload = fs.readJSONSync(path);
         const hash = this.getHash(payload.origin);
         if (!hash || payload.hash !== hash) {
             return null;
@@ -50,7 +52,7 @@ export class FileCacheAdapter {
      */
     clear() {
         const path = this.path('*');
-        const files = Utils.glob(path);
+        const files = fs.glob(path);
         files.forEach(file => unlinkSync(file));
         this.cache = {};
     }
@@ -67,7 +69,7 @@ export class FileCacheAdapter {
         return path;
     }
     path(name) {
-        Utils.ensureDir(this.options.cacheDir);
+        fs.ensureDir(this.options.cacheDir);
         return `${this.options.cacheDir}/${name}.json`;
     }
     getHash(origin) {

package/cache/GeneratedCacheAdapter.d.ts

@@ -1,7 +1,6 @@
 import type { CacheAdapter } from './CacheAdapter.js';
 import type { Dictionary } from '../typings.js';
 export declare class GeneratedCacheAdapter implements CacheAdapter {
-    private readonly options;
     private readonly data;
     constructor(options: {
         data: Dictionary;

package/cache/GeneratedCacheAdapter.js

@@ -1,8 +1,6 @@
 export class GeneratedCacheAdapter {
-    options;
     data = new Map();
     constructor(options) {
-        this.options = options;
         this.data = new Map(Object.entries(options.data));
     }
     /**

package/cache/index.d.ts

@@ -1,5 +1,4 @@
 export * from './CacheAdapter.js';
 export * from './NullCacheAdapter.js';
-export * from './FileCacheAdapter.js';
 export * from './MemoryCacheAdapter.js';
 export * from './GeneratedCacheAdapter.js';

package/cache/index.js

@@ -1,5 +1,4 @@
 export * from './CacheAdapter.js';
 export * from './NullCacheAdapter.js';
-export * from './FileCacheAdapter.js';
 export * from './MemoryCacheAdapter.js';
 export * from './GeneratedCacheAdapter.js';

package/drivers/DatabaseDriver.js

@@ -31,11 +31,11 @@ export class DatabaseDriver {
         const EntityManagerClass = this.config.get('entityManager', EntityManager);
         return new EntityManagerClass(this.config, this, this.metadata, useContext);
     }
-    /* v8 ignore next 3 */
+    /* v8 ignore next */
     async findVirtual(entityName, where, options) {
         throw new Error(`Virtual entities are not supported by ${this.constructor.name} driver.`);
     }
-    /* v8 ignore next 3 */
+    /* v8 ignore next */
     async countVirtual(entityName, where, options) {
         throw new Error(`Counting virtual entities is not supported by ${this.constructor.name} driver.`);
     }
@@ -53,7 +53,7 @@ export class DatabaseDriver {
                 }
                 continue;
             }
-            /* v8 ignore next 3 */
+            /* v8 ignore next */
             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);
@@ -253,7 +253,7 @@ export class DatabaseDriver {
         return data;
     }
     inlineEmbeddables(meta, data, where) {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (data == null) {
             return;
         }

package/entity/Collection.js

@@ -18,7 +18,7 @@ export class Collection {
     _populated;
     constructor(owner, items, initialized = true) {
         this.owner = owner;
-        /* v8 ignore next 5 */
+        /* v8 ignore next */
         if (items) {
             let i = 0;
             this.items = new Set(items);
@@ -619,7 +619,7 @@ export class Collection {
     get property() {
         if (!this._property) {
             const meta = wrap(this.owner, true).__meta;
-            /* v8 ignore next 3 */
+            /* v8 ignore next */
             if (!meta) {
                 throw MetadataError.fromUnknownEntity(this.owner.constructor.name, 'Collection.property getter, maybe you just forgot to initialize the ORM?');
             }

package/entity/EntityAssigner.js

@@ -120,7 +120,7 @@ export class EntityAssigner {
         }
         const meta2 = helper(ref).__meta;
         const prop2 = meta2.properties[prop.inversedBy || prop.mappedBy];
-        /* v8 ignore next 7 */
+        /* v8 ignore next */
         if (prop2 && !ref[prop2.name]) {
             if (Reference.isReference(ref)) {
                 ref.unwrap()[prop2.name] = Reference.wrapReference(entity, prop2);
@@ -173,7 +173,7 @@ export class EntityAssigner {
                 }
                 return this.createCollectionItem(item, em, prop, invalid, options);
             }
-            /* v8 ignore next 3 */
+            /* v8 ignore next */
             if (options.updateNestedEntities && !options.updateByPrimaryKey && collection[idx] && helper(collection[idx])?.isInitialized()) {
                 return EntityAssigner.assign(collection[idx], item, options);
             }

package/entity/EntityFactory.js

@@ -323,7 +323,7 @@ export class EntityFactory {
                 return Reference.wrapReference(target, prop);
             }
             if (prop?.kind === ReferenceKind.EMBEDDED && value) {
-                /* v8 ignore next 3 */
+                /* v8 ignore next */
                 if (Utils.isEntity(value)) {
                     return value;
                 }

package/entity/EntityLoader.js

@@ -41,7 +41,7 @@ export class EntityLoader {
         }
         populate = this.normalizePopulate(entityName, populate, options.strategy, options.lookup);
         const invalid = populate.find(({ field }) => !this.em.canPopulate(entityName, field));
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (options.validate && invalid) {
             throw ValidationError.invalidPropertyName(entityName, invalid.field);
         }
@@ -463,7 +463,7 @@ export class EntityLoader {
                 const parts = f.toString().split('.');
                 const propName = parts.shift();
                 const childPropName = parts.join('.');
-                /* v8 ignore next 3 */
+                /* v8 ignore next */
                 if (propName === prop.name) {
                     ret.push(childPropName);
                 }
@@ -514,7 +514,7 @@ export class EntityLoader {
             return wrapped.__loadedProperties.has(field);
         }
         const [f, ...r] = field.split('.');
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (!wrapped.__loadedProperties.has(f) || !wrapped.__meta.properties[f]?.targetMeta) {
             return false;
         }
@@ -547,7 +547,7 @@ export class EntityLoader {
             .map(e => Reference.unwrapReference(e[field]));
     }
     filterByReferences(entities, field, refresh) {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (refresh) {
             return entities;
         }

package/entity/Reference.js

@@ -213,8 +213,8 @@ export class ScalarReference {
     isInitialized() {
         return this.initialized;
     }
-    /* v8 ignore next 4 */
     /** @ignore */
+    /* v8 ignore next */
     [inspect.custom]() {
         return this.initialized ? `Ref<${inspect(this.value)}>` : `Ref<?>`;
     }

package/entity/WrappedEntity.d.ts

@@ -59,8 +59,8 @@ export declare class WrappedEntity<Entity extends object> {
     setPrimaryKey(id: Primary<Entity> | null): void;
     getSerializedPrimaryKey(): string;
     get __meta(): EntityMetadata<Entity>;
-    get __platform(): import("../index.js").Platform;
-    get __config(): import("../index.js").Configuration<import("../drivers/IDatabaseDriver.js").IDatabaseDriver<import("../index.js").Connection>, EntityManager<import("../drivers/IDatabaseDriver.js").IDatabaseDriver<import("../index.js").Connection>>>;
+    get __platform(): import("@mikro-orm/knex").Platform;
+    get __config(): import("@mikro-orm/knex").Configuration<import("../drivers/IDatabaseDriver.js").IDatabaseDriver<import("@mikro-orm/knex").Connection>, EntityManager<import("../drivers/IDatabaseDriver.js").IDatabaseDriver<import("@mikro-orm/knex").Connection>>>;
     get __primaryKeys(): Primary<Entity>[];
     /** @ignore */
     [inspect.custom](): string;

package/entity/utils.js

@@ -21,7 +21,7 @@ export function expandDotPaths(meta, populate, normalized = false) {
         if (typeof field === 'string') {
             return { field };
         }
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         return typeof field === 'boolean' || field.field === PopulatePath.ALL
             ? { all: !!field, field: meta.primaryKeys[0] }
             : field;

package/entity/validators.js

@@ -11,7 +11,7 @@ export function validateProperty(prop, givenValue, entity) {
     const propName = prop.embedded ? prop.name.replace(/~/g, '.') : prop.name;
     const givenType = Utils.getObjectType(givenValue);
     if (prop.enum && prop.items) {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (!prop.items.some(it => it === givenValue)) {
             throw ValidationError.fromWrongPropertyType(entity, propName, expectedType, givenType, givenValue);
         }

package/hydration/Hydrator.js

@@ -1,4 +1,4 @@
-/* v8 ignore start */
+/* v8 ignore next */
 export class Hydrator {
     metadata;
     platform;
@@ -45,4 +45,3 @@ export class Hydrator {
         entity[prop.name] = data[prop.name];
     }
 }
-/* v8 ignore stop */

package/hydration/ObjectHydrator.js

@@ -51,7 +51,7 @@ export class ObjectHydrator extends Hydrator {
         context.set('Reference', Reference);
         const registerCustomType = (prop, convertorKey, method, context) => {
             context.set(`${method}_${convertorKey}`, (val) => {
-                /* v8 ignore next 3 */
+                /* v8 ignore next */
                 if (RawQueryFragment.isKnownFragment(val)) {
                     return val;
                 }

package/metadata/MetadataDiscovery.d.ts

@@ -9,7 +9,6 @@ export declare class MetadataDiscovery {
     private readonly config;
     private readonly namingStrategy;
     private readonly metadataProvider;
-    private readonly cache;
     private readonly logger;
     private readonly schemaHelper;
     private readonly validator;
@@ -29,7 +28,6 @@ export declare class MetadataDiscovery {
     private getSchema;
     private getRootEntity;
     private discoverEntity;
-    private saveToCache;
     private initNullability;
     private applyNamingStrategy;
     private initOwnColumns;

package/metadata/MetadataDiscovery.js

@@ -1,4 +1,3 @@
-import { extname } from 'node:path';
 import { EntityMetadata, } from '../typings.js';
 import { Utils } from '../utils/Utils.js';
 import { MetadataValidator } from './MetadataValidator.js';
@@ -15,7 +14,6 @@ export class MetadataDiscovery {
     config;
     namingStrategy;
     metadataProvider;
-    cache;
     logger;
     schemaHelper;
     validator = new MetadataValidator();
@@ -26,7 +24,6 @@ export class MetadataDiscovery {
         this.config = config;
         this.namingStrategy = this.config.getNamingStrategy();
         this.metadataProvider = this.config.getMetadataProvider();
-        this.cache = this.config.getMetadataCacheAdapter();
         this.logger = this.config.getLogger();
         this.schemaHelper = this.platform.getSchemaHelper();
     }
@@ -145,11 +142,7 @@ export class MetadataDiscovery {
             discovered.push(...this.processEntity(meta));
         }
         discovered.forEach(meta => meta.sync(true));
-        const combinedCachePath = this.cache.combine?.();
-        // override the path in the options, so we can log it from the CLI in `cache:generate` command
-        if (combinedCachePath) {
-            this.config.get('metadataCache').combined = combinedCachePath;
-        }
+        this.metadataProvider.combineCache();
         return discovered.map(meta => {
             meta = this.metadata.get(meta.className);
             meta.sync(true);
@@ -224,7 +217,7 @@ export class MetadataDiscovery {
             if (typeof parent === 'function' && parent.name && !this.metadata.has(parent.name)) {
                 this.discoverReferences([parent], false);
             }
-            /* v8 ignore next 3 */
+            /* v8 ignore next */
             if (!meta.class) {
                 continue;
             }
@@ -287,11 +280,9 @@ export class MetadataDiscovery {
         this.logger.log('discovery', `- processing entity ${colors.cyan(meta.className)}${colors.grey(path ? ` (${path})` : '')}`);
         const root = this.getRootEntity(meta);
         schema.meta.path = Utils.relativePath(meta.path, this.config.get('baseDir'));
-        const cache = this.metadataProvider.useCache() && meta.path && this.cache.get(meta.className + extname(meta.path));
+        const cache = this.metadataProvider.getCachedMetadata(meta, root);
         if (cache) {
             this.logger.log('discovery', `- using cached metadata for entity ${colors.cyan(meta.className)}`);
-            this.metadataProvider.loadFromCache(meta, cache);
-            meta.root = root;
             this.discovered.push(meta);
             return;
         }
@@ -305,39 +296,10 @@ export class MetadataDiscovery {
             const entityName = root.discriminatorColumn ? root.name : meta.name;
             meta.collection = this.namingStrategy.classToTableName(entityName);
         }
-        delete meta.root; // to allow caching (as root can contain cycles)
-        this.saveToCache(meta);
+        this.metadataProvider.saveToCache(meta);
         meta.root = root;
         this.discovered.push(meta);
     }
-    saveToCache(meta) {
-        if (!this.metadataProvider.useCache()) {
-            return;
-        }
-        const copy = Utils.copy(meta, false);
-        for (const prop of copy.props) {
-            if (Type.isMappedType(prop.type)) {
-                Reflect.deleteProperty(prop, 'type');
-                Reflect.deleteProperty(prop, 'customType');
-            }
-            if (prop.default) {
-                const raw = RawQueryFragment.getKnownFragment(prop.default);
-                if (raw) {
-                    prop.defaultRaw ??= this.platform.formatQuery(raw.sql, raw.params);
-                    Reflect.deleteProperty(prop, 'default');
-                }
-            }
-            Reflect.deleteProperty(prop, 'targetMeta');
-        }
-        [
-            'prototype', 'props', 'referencingProperties', 'propertyOrder', 'relations',
-            'concurrencyCheckKeys', 'checks',
-        ].forEach(key => delete copy[key]);
-        // base entity without properties might not have path, but nothing to cache there
-        if (meta.path) {
-            this.cache.set(meta.className + extname(meta.path), copy, meta.path);
-        }
-    }
     initNullability(prop) {
         if (prop.kind === ReferenceKind.ONE_TO_ONE) {
             return Utils.defaultValue(prop, 'nullable', prop.optional || !prop.owner);
@@ -375,7 +337,7 @@ export class MetadataDiscovery {
             if (prop.joinColumns.length !== prop.columnTypes.length) {
                 prop.columnTypes = prop.joinColumns.flatMap(field => {
                     const matched = meta.props.find(p => p.fieldNames?.includes(field));
-                    /* v8 ignore next 3 */
+                    /* v8 ignore next */
                     if (!matched) {
                         throw MetadataError.fromWrongForeignKey(meta, prop, 'columnTypes');
                     }
@@ -538,7 +500,7 @@ export class MetadataDiscovery {
         }
         else if (fks.length >= 2) {
             [first, second] = fks;
-            /* v8 ignore next 3 */
+            /* v8 ignore next */
         }
         else {
             return [];
@@ -1016,7 +978,7 @@ export class MetadataDiscovery {
         if (typeof prop.defaultRaw !== 'undefined') {
             return prop.defaultRaw;
         }
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (prop.default != null) {
             return '' + this.platform.quoteVersionValue(prop.default, prop);
         }

package/metadata/MetadataProvider.d.ts

@@ -1,13 +1,22 @@
 import type { EntityMetadata } from '../typings.js';
 import type { Logger } from '../logging/Logger.js';
+import type { SyncCacheAdapter } from '../cache/CacheAdapter.js';
+import type { Platform } from '../platforms/Platform.js';
 export interface IConfiguration {
     get(key: string, defaultValue?: any): any;
     getLogger(): Logger;
+    getMetadataCacheAdapter(): SyncCacheAdapter;
+    getPlatform(): Platform;
 }
 export declare class MetadataProvider {
     protected readonly config: IConfiguration;
     constructor(config: IConfiguration);
     loadEntityMetadata(meta: EntityMetadata): void;
     loadFromCache(meta: EntityMetadata, cache: EntityMetadata): void;
+    static useCache(): boolean;
     useCache(): boolean;
+    saveToCache(meta: EntityMetadata): void;
+    getCachedMetadata<T>(meta: Pick<EntityMetadata<T>, 'className' | 'path' | 'root'>, root: EntityMetadata<T>): EntityMetadata<T> | undefined;
+    combineCache(): void;
+    getCacheKey(meta: Pick<EntityMetadata, 'className' | 'path'>): string;
 }