@mikro-orm/core 7.0.2-dev.9 → 7.0.2

package/metadata/MetadataProvider.d.ts

@@ -3,20 +3,31 @@ 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;
+  get(key: string, defaultValue?: any): any;
+  getLogger(): Logger;
+  getMetadataCacheAdapter(): SyncCacheAdapter;
+  getPlatform(): Platform;
 }
+/** Base metadata provider that resolves entity type information and manages metadata caching. */
 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;
+  protected readonly config: IConfiguration;
+  constructor(config: IConfiguration);
+  /** Resolves entity references and type information for all properties in the given metadata. */
+  loadEntityMetadata(meta: EntityMetadata): void;
+  /** Merges cached metadata into the given entity metadata, preserving function expressions. */
+  loadFromCache(meta: EntityMetadata, cache: EntityMetadata): void;
+  /** Whether this provider class uses metadata caching by default. */
+  static useCache(): boolean;
+  /** Whether metadata caching is enabled for this instance. */
+  useCache(): boolean;
+  saveToCache(meta: EntityMetadata): void;
+  /** Attempts to load metadata from cache, returning undefined if not available. */
+  getCachedMetadata<T>(
+    meta: Pick<EntityMetadata<T>, 'className' | 'path' | 'root'>,
+    root: EntityMetadata<T>,
+  ): EntityMetadata<T> | undefined;
+  /** Combines individual metadata cache entries into a single file. */
+  combineCache(): void;
+  /** Returns the cache key for the given entity metadata. */
+  getCacheKey(meta: Pick<EntityMetadata, 'className' | 'path'>): string;
 }

package/metadata/MetadataProvider.js

@@ -1,89 +1,95 @@
 import { Utils } from '../utils/Utils.js';
 import { EntitySchema } from './EntitySchema.js';
+/** Base metadata provider that resolves entity type information and manages metadata caching. */
 export class MetadataProvider {
-    config;
-    constructor(config) {
-        this.config = config;
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /** Resolves entity references and type information for all properties in the given metadata. */
+  loadEntityMetadata(meta) {
+    for (const prop of meta.props) {
+      /* v8 ignore next */
+      if (typeof prop.entity === 'string') {
+        prop.type = prop.entity;
+      } else if (prop.entity) {
+        const tmp = prop.entity();
+        prop.type = Array.isArray(tmp)
+          ? tmp
+              .map(t => Utils.className(t))
+              .sort()
+              .join(' | ')
+          : Utils.className(tmp);
+        prop.target = EntitySchema.is(tmp) ? tmp.meta.class : tmp;
+      } else if (!prop.type && !((prop.enum || prop.array) && (prop.items?.length ?? 0) > 0)) {
+        throw new Error(`Please provide either 'type' or 'entity' attribute in ${meta.className}.${prop.name}.`);
+      }
     }
-    loadEntityMetadata(meta) {
-        for (const prop of meta.props) {
-            /* v8 ignore next */
-            if (typeof prop.entity === 'string') {
-                prop.type = prop.entity;
-            }
-            else if (prop.entity) {
-                const tmp = prop.entity();
-                prop.type = Array.isArray(tmp)
-                    ? tmp
-                        .map(t => Utils.className(t))
-                        .sort()
-                        .join(' | ')
-                    : Utils.className(tmp);
-                prop.target = tmp instanceof EntitySchema ? tmp.meta.class : tmp;
-            }
-            else if (!prop.type && !((prop.enum || prop.array) && (prop.items?.length ?? 0) > 0)) {
-                throw new Error(`Please provide either 'type' or 'entity' attribute in ${meta.className}.${prop.name}.`);
-            }
+  }
+  /** Merges cached metadata into the given entity metadata, preserving function expressions. */
+  loadFromCache(meta, cache) {
+    Object.values(cache.properties).forEach(prop => {
+      const metaProp = meta.properties[prop.name];
+      /* v8 ignore next */
+      if (metaProp?.enum && Array.isArray(metaProp.items)) {
+        delete prop.items;
+      }
+    });
+    // Preserve function expressions from indexes/uniques — they can't survive JSON cache serialization
+    const expressionMap = new Map();
+    for (const arr of [meta.indexes, meta.uniques]) {
+      for (const idx of arr ?? []) {
+        if (typeof idx.expression === 'function' && idx.name) {
+          expressionMap.set(idx.name, idx.expression);
         }
+      }
     }
-    loadFromCache(meta, cache) {
-        Object.values(cache.properties).forEach(prop => {
-            const metaProp = meta.properties[prop.name];
-            /* v8 ignore next */
-            if (metaProp?.enum && Array.isArray(metaProp.items)) {
-                delete prop.items;
-            }
-        });
-        // Preserve function expressions from indexes/uniques — they can't survive JSON cache serialization
-        const expressionMap = new Map();
-        for (const arr of [meta.indexes, meta.uniques]) {
-            for (const idx of arr ?? []) {
-                if (typeof idx.expression === 'function' && idx.name) {
-                    expressionMap.set(idx.name, idx.expression);
-                }
-            }
+    Utils.mergeConfig(meta, cache);
+    // Restore function expressions that were lost during JSON serialization
+    if (expressionMap.size > 0) {
+      for (const arr of [meta.indexes, meta.uniques]) {
+        for (const idx of arr ?? []) {
+          const fn = idx.name && expressionMap.get(idx.name);
+          if (fn && typeof idx.expression !== 'function') {
+            idx.expression = fn;
+          }
         }
-        Utils.mergeConfig(meta, cache);
-        // Restore function expressions that were lost during JSON serialization
-        if (expressionMap.size > 0) {
-            for (const arr of [meta.indexes, meta.uniques]) {
-                for (const idx of arr ?? []) {
-                    const fn = idx.name && expressionMap.get(idx.name);
-                    if (fn && typeof idx.expression !== 'function') {
-                        idx.expression = fn;
-                    }
-                }
-            }
-        }
-    }
-    static useCache() {
-        return false;
+      }
     }
-    useCache() {
-        return this.config.get('metadataCache').enabled ?? MetadataProvider.useCache();
+  }
+  /** Whether this provider class uses metadata caching by default. */
+  static useCache() {
+    return false;
+  }
+  /** Whether metadata caching is enabled for this instance. */
+  useCache() {
+    return this.config.get('metadataCache').enabled ?? MetadataProvider.useCache();
+  }
+  saveToCache(meta) {
+    //
+  }
+  /** Attempts to load metadata from cache, returning undefined if not available. */
+  getCachedMetadata(meta, root) {
+    if (!this.useCache()) {
+      return undefined;
     }
-    saveToCache(meta) {
-        //
-    }
-    getCachedMetadata(meta, root) {
-        if (!this.useCache()) {
-            return undefined;
-        }
-        const cache = meta.path && this.config.getMetadataCacheAdapter().get(this.getCacheKey(meta));
-        if (cache) {
-            this.loadFromCache(meta, cache);
-            meta.root = root;
-        }
-        return cache;
-    }
-    combineCache() {
-        const path = this.config.getMetadataCacheAdapter().combine?.();
-        // override the path in the options, so we can log it from the CLI in `cache:generate` command
-        if (path) {
-            this.config.get('metadataCache').combined = path;
-        }
+    const cache = meta.path && this.config.getMetadataCacheAdapter().get(this.getCacheKey(meta));
+    if (cache) {
+      this.loadFromCache(meta, cache);
+      meta.root = root;
     }
-    getCacheKey(meta) {
-        return meta.className;
+    return cache;
+  }
+  /** Combines individual metadata cache entries into a single file. */
+  combineCache() {
+    const path = this.config.getMetadataCacheAdapter().combine?.();
+    // override the path in the options, so we can log it from the CLI in `cache:generate` command
+    if (path) {
+      this.config.get('metadataCache').combined = path;
     }
+  }
+  /** Returns the cache key for the given entity metadata. */
+  getCacheKey(meta) {
+    return meta.className;
+  }
 }

package/metadata/MetadataStorage.d.ts

@@ -1,23 +1,43 @@
 import { type Dictionary, EntityMetadata, type EntityName } from '../typings.js';
 import type { EntityManager } from '../EntityManager.js';
+/** Registry that stores and provides access to entity metadata by class, name, or id. */
 export declare class MetadataStorage {
-    #private;
-    static readonly PATH_SYMBOL: unique symbol;
-    constructor(metadata?: Dictionary<EntityMetadata>);
-    static getMetadata(): Dictionary<EntityMetadata>;
-    static getMetadata<T = any>(entity: string, path: string): EntityMetadata<T>;
-    static isKnownEntity(name: string): boolean;
-    static clear(): void;
-    getAll(): Map<EntityName, EntityMetadata>;
-    get<T = any>(entityName: EntityName<T>, init?: boolean): EntityMetadata<T>;
-    find<T = any>(entityName: EntityName<T>): EntityMetadata<T> | undefined;
-    has<T>(entityName: EntityName<T>): boolean;
-    set<T>(entityName: EntityName<T>, meta: EntityMetadata): EntityMetadata;
-    reset<T>(entityName: EntityName<T>): void;
-    decorate(em: EntityManager): void;
-    [Symbol.iterator](): IterableIterator<EntityMetadata>;
-    getById<T>(id: number): EntityMetadata<T>;
-    getByClassName<T = any, V extends boolean = true>(className: string, validate?: V): V extends true ? EntityMetadata<T> : EntityMetadata<T> | undefined;
-    getByUniqueName<T = any, V extends boolean = true>(uniqueName: string, validate?: V): V extends true ? EntityMetadata<T> : EntityMetadata<T> | undefined;
-    private validate;
+  #private;
+  static readonly PATH_SYMBOL: unique symbol;
+  constructor(metadata?: Dictionary<EntityMetadata>);
+  /** Returns the global metadata dictionary, or a specific entry by entity name and path. */
+  static getMetadata(): Dictionary<EntityMetadata>;
+  static getMetadata<T = any>(entity: string, path: string): EntityMetadata<T>;
+  /** Checks whether an entity with the given class name exists in the global metadata. */
+  static isKnownEntity(name: string): boolean;
+  /** Clears all entries from the global metadata registry. */
+  static clear(): void;
+  /** Returns the map of all registered entity metadata. */
+  getAll(): Map<EntityName, EntityMetadata>;
+  /** Returns metadata for the given entity, optionally initializing it if not found. */
+  get<T = any>(entityName: EntityName<T>, init?: boolean): EntityMetadata<T>;
+  /** Finds metadata for the given entity, returning undefined if not registered. */
+  find<T = any>(entityName: EntityName<T>): EntityMetadata<T> | undefined;
+  /** Checks whether metadata exists for the given entity. */
+  has<T>(entityName: EntityName<T>): boolean;
+  /** Registers metadata for the given entity. */
+  set<T>(entityName: EntityName<T>, meta: EntityMetadata): EntityMetadata;
+  /** Removes metadata for the given entity from all internal maps. */
+  reset<T>(entityName: EntityName<T>): void;
+  /** Decorates all entity prototypes with helper methods (e.g. init, toJSON). */
+  decorate(em: EntityManager): void;
+  [Symbol.iterator](): IterableIterator<EntityMetadata>;
+  /** Returns metadata by its internal numeric id. */
+  getById<T>(id: number): EntityMetadata<T>;
+  /** Returns metadata by class name, optionally throwing if not found. */
+  getByClassName<T = any, V extends boolean = true>(
+    className: string,
+    validate?: V,
+  ): V extends true ? EntityMetadata<T> : EntityMetadata<T> | undefined;
+  /** Returns metadata by unique name, optionally throwing if not found. */
+  getByUniqueName<T = any, V extends boolean = true>(
+    uniqueName: string,
+    validate?: V,
+  ): V extends true ? EntityMetadata<T> : EntityMetadata<T> | undefined;
+  private validate;
 }

package/metadata/MetadataStorage.js

@@ -4,112 +4,125 @@ import { MetadataError } from '../errors.js';
 import { EntityHelper } from '../entity/EntityHelper.js';
 import { EntitySchema } from './EntitySchema.js';
 function getGlobalStorage(namespace) {
-    const key = `mikro-orm-${namespace}`;
-    globalThis[key] = globalThis[key] || {};
-    return globalThis[key];
+  const key = `mikro-orm-${namespace}`;
+  globalThis[key] = globalThis[key] || {};
+  return globalThis[key];
 }
+/** Registry that stores and provides access to entity metadata by class, name, or id. */
 export class MetadataStorage {
-    static PATH_SYMBOL = Symbol.for('@mikro-orm/core/MetadataStorage.PATH_SYMBOL');
-    static #metadata = getGlobalStorage('metadata');
-    #metadataMap = new Map();
-    #idMap;
-    #classNameMap;
-    #uniqueNameMap;
-    constructor(metadata = {}) {
-        this.#idMap = {};
-        this.#uniqueNameMap = {};
-        this.#classNameMap = Utils.copy(metadata, false);
-        for (const meta of Object.values(this.#classNameMap)) {
-            this.#idMap[meta._id] = meta;
-            this.#uniqueNameMap[meta.uniqueName] = meta;
-            this.#metadataMap.set(meta.class, meta);
-        }
-    }
-    static getMetadata(entity, path) {
-        const key = entity && path ? entity + '-' + Utils.hash(path) : null;
-        if (key && !MetadataStorage.#metadata[key]) {
-            MetadataStorage.#metadata[key] = new EntityMetadata({ className: entity, path });
-        }
-        if (key) {
-            return MetadataStorage.#metadata[key];
-        }
-        return MetadataStorage.#metadata;
-    }
-    static isKnownEntity(name) {
-        return !!Object.values(this.#metadata).find(meta => meta.className === name);
-    }
-    static clear() {
-        Object.keys(this.#metadata).forEach(k => delete this.#metadata[k]);
-    }
-    getAll() {
-        return this.#metadataMap;
-    }
-    get(entityName, init = false) {
-        const exists = this.find(entityName);
-        if (exists) {
-            return exists;
-        }
-        const className = Utils.className(entityName);
-        if (!init) {
-            throw MetadataError.missingMetadata(className);
-        }
-        const meta = new EntityMetadata({ class: entityName, name: className });
-        this.set(entityName, meta);
-        return meta;
-    }
-    find(entityName) {
-        if (!entityName) {
-            return;
-        }
-        const meta = this.#metadataMap.get(entityName);
-        if (meta) {
-            return meta;
-        }
-        if (entityName instanceof EntitySchema) {
-            return this.#metadataMap.get(entityName.meta.class) ?? entityName.meta;
-        }
-        return this.#classNameMap[Utils.className(entityName)];
-    }
-    has(entityName) {
-        return this.#metadataMap.has(entityName);
-    }
-    set(entityName, meta) {
-        this.#metadataMap.set(entityName, meta);
-        this.#idMap[meta._id] = meta;
-        this.#uniqueNameMap[meta.uniqueName] = meta;
-        this.#classNameMap[Utils.className(entityName)] = meta;
-        return meta;
-    }
-    reset(entityName) {
-        const meta = this.find(entityName);
-        if (meta) {
-            this.#metadataMap.delete(meta.class);
-            delete this.#idMap[meta._id];
-            delete this.#uniqueNameMap[meta.uniqueName];
-            delete this.#classNameMap[meta.className];
-        }
-    }
-    decorate(em) {
-        [...this.#metadataMap.values()].filter(meta => meta.prototype).forEach(meta => EntityHelper.decorate(meta, em));
-    }
-    *[Symbol.iterator]() {
-        for (const meta of this.#metadataMap.values()) {
-            yield meta;
-        }
-    }
-    getById(id) {
-        return this.#idMap[id];
-    }
-    getByClassName(className, validate = true) {
-        return this.validate(this.#classNameMap[className], className, validate);
-    }
-    getByUniqueName(uniqueName, validate = true) {
-        return this.validate(this.#uniqueNameMap[uniqueName], uniqueName, validate);
-    }
-    validate(meta, id, validate) {
-        if (!meta && validate) {
-            throw MetadataError.missingMetadata(id);
-        }
-        return meta;
-    }
+  static PATH_SYMBOL = Symbol.for('@mikro-orm/core/MetadataStorage.PATH_SYMBOL');
+  static #metadata = getGlobalStorage('metadata');
+  #metadataMap = new Map();
+  #idMap;
+  #classNameMap;
+  #uniqueNameMap;
+  constructor(metadata = {}) {
+    this.#idMap = {};
+    this.#uniqueNameMap = {};
+    this.#classNameMap = Utils.copy(metadata, false);
+    for (const meta of Object.values(this.#classNameMap)) {
+      this.#idMap[meta._id] = meta;
+      this.#uniqueNameMap[meta.uniqueName] = meta;
+      this.#metadataMap.set(meta.class, meta);
+    }
+  }
+  static getMetadata(entity, path) {
+    const key = entity && path ? entity + '-' + Utils.hash(path) : null;
+    if (key && !MetadataStorage.#metadata[key]) {
+      MetadataStorage.#metadata[key] = new EntityMetadata({ className: entity, path });
+    }
+    if (key) {
+      return MetadataStorage.#metadata[key];
+    }
+    return MetadataStorage.#metadata;
+  }
+  /** Checks whether an entity with the given class name exists in the global metadata. */
+  static isKnownEntity(name) {
+    return !!Object.values(this.#metadata).find(meta => meta.className === name);
+  }
+  /** Clears all entries from the global metadata registry. */
+  static clear() {
+    Object.keys(this.#metadata).forEach(k => delete this.#metadata[k]);
+  }
+  /** Returns the map of all registered entity metadata. */
+  getAll() {
+    return this.#metadataMap;
+  }
+  /** Returns metadata for the given entity, optionally initializing it if not found. */
+  get(entityName, init = false) {
+    const exists = this.find(entityName);
+    if (exists) {
+      return exists;
+    }
+    const className = Utils.className(entityName);
+    if (!init) {
+      throw MetadataError.missingMetadata(className);
+    }
+    const meta = new EntityMetadata({ class: entityName, name: className });
+    this.set(entityName, meta);
+    return meta;
+  }
+  /** Finds metadata for the given entity, returning undefined if not registered. */
+  find(entityName) {
+    if (!entityName) {
+      return;
+    }
+    const meta = this.#metadataMap.get(entityName);
+    if (meta) {
+      return meta;
+    }
+    if (EntitySchema.is(entityName)) {
+      return this.#metadataMap.get(entityName.meta.class) ?? entityName.meta;
+    }
+    return this.#classNameMap[Utils.className(entityName)];
+  }
+  /** Checks whether metadata exists for the given entity. */
+  has(entityName) {
+    return this.#metadataMap.has(entityName);
+  }
+  /** Registers metadata for the given entity. */
+  set(entityName, meta) {
+    this.#metadataMap.set(entityName, meta);
+    this.#idMap[meta._id] = meta;
+    this.#uniqueNameMap[meta.uniqueName] = meta;
+    this.#classNameMap[Utils.className(entityName)] = meta;
+    return meta;
+  }
+  /** Removes metadata for the given entity from all internal maps. */
+  reset(entityName) {
+    const meta = this.find(entityName);
+    if (meta) {
+      this.#metadataMap.delete(meta.class);
+      delete this.#idMap[meta._id];
+      delete this.#uniqueNameMap[meta.uniqueName];
+      delete this.#classNameMap[meta.className];
+    }
+  }
+  /** Decorates all entity prototypes with helper methods (e.g. init, toJSON). */
+  decorate(em) {
+    [...this.#metadataMap.values()].filter(meta => meta.prototype).forEach(meta => EntityHelper.decorate(meta, em));
+  }
+  *[Symbol.iterator]() {
+    for (const meta of this.#metadataMap.values()) {
+      yield meta;
+    }
+  }
+  /** Returns metadata by its internal numeric id. */
+  getById(id) {
+    return this.#idMap[id];
+  }
+  /** Returns metadata by class name, optionally throwing if not found. */
+  getByClassName(className, validate = true) {
+    return this.validate(this.#classNameMap[className], className, validate);
+  }
+  /** Returns metadata by unique name, optionally throwing if not found. */
+  getByUniqueName(uniqueName, validate = true) {
+    return this.validate(this.#uniqueNameMap[uniqueName], uniqueName, validate);
+  }
+  validate(meta, id, validate) {
+    if (!meta && validate) {
+      throw MetadataError.missingMetadata(id);
+    }
+    return meta;
+  }
 }

package/metadata/MetadataValidator.d.ts

@@ -5,43 +5,43 @@ import type { MetadataStorage } from './MetadataStorage.js';
  * @internal
  */
 export declare class MetadataValidator {
-    validateEntityDefinition<T>(metadata: MetadataStorage, name: EntityName<T>, options: MetadataDiscoveryOptions): void;
-    validateDiscovered(discovered: EntityMetadata[], options: MetadataDiscoveryOptions): void;
-    private validateReference;
-    private validateTargetKey;
-    /**
-     * Checks if a property has a unique constraint (either via `unique: true` or single-property `@Unique` decorator).
-     * Composite unique constraints are not sufficient for targetKey.
-     */
-    private isPropertyUnique;
-    private validatePolymorphicTargets;
-    private validateBidirectional;
-    private validateOwningSide;
-    private validateInverseSide;
-    private validateIndexes;
-    private validateDuplicateFieldNames;
-    private validateVersionField;
-    /**
-     * Validates that entity properties do not use dangerous names that could lead to
-     * prototype pollution vulnerabilities. This validation ensures that property names
-     * cannot be exploited to modify object prototypes when values are assigned during
-     * entity hydration or persistence operations.
-     *
-     * @internal
-     */
-    private validatePropertyNames;
-    /**
-     * Validates view entity configuration.
-     * View entities must have an expression.
-     */
-    private validateViewEntity;
-    /**
-     * Validates that STI and TPT are not mixed in the same inheritance hierarchy.
-     * An entity hierarchy can use either STI (discriminatorColumn) or TPT (inheritance: 'tpt'),
-     * but not both.
-     *
-     * Note: This validation runs before `initTablePerTypeInheritance` sets `inheritanceType`,
-     * so we check the raw `inheritance` option from the decorator/schema.
-     */
-    private validateInheritanceStrategies;
+  validateEntityDefinition<T>(metadata: MetadataStorage, name: EntityName<T>, options: MetadataDiscoveryOptions): void;
+  validateDiscovered(discovered: EntityMetadata[], options: MetadataDiscoveryOptions): void;
+  private validateReference;
+  private validateTargetKey;
+  /**
+   * Checks if a property has a unique constraint (either via `unique: true` or single-property `@Unique` decorator).
+   * Composite unique constraints are not sufficient for targetKey.
+   */
+  private isPropertyUnique;
+  private validatePolymorphicTargets;
+  private validateBidirectional;
+  private validateOwningSide;
+  private validateInverseSide;
+  private validateIndexes;
+  private validateDuplicateFieldNames;
+  private validateVersionField;
+  /**
+   * Validates that entity properties do not use dangerous names that could lead to
+   * prototype pollution vulnerabilities. This validation ensures that property names
+   * cannot be exploited to modify object prototypes when values are assigned during
+   * entity hydration or persistence operations.
+   *
+   * @internal
+   */
+  private validatePropertyNames;
+  /**
+   * Validates view entity configuration.
+   * View entities must have an expression.
+   */
+  private validateViewEntity;
+  /**
+   * Validates that STI and TPT are not mixed in the same inheritance hierarchy.
+   * An entity hierarchy can use either STI (discriminatorColumn) or TPT (inheritance: 'tpt'),
+   * but not both.
+   *
+   * Note: This validation runs before `initTablePerTypeInheritance` sets `inheritanceType`,
+   * so we check the raw `inheritance` option from the decorator/schema.
+   */
+  private validateInheritanceStrategies;
 }