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

package/metadata/EntitySchema.d.ts

@@ -14,6 +14,7 @@ type EmbeddedTypeDef<Target> = {
 } | {
     entity: () => EntityName<Target> | EntityName[];
 };
+/** Union type representing all possible property definition shapes in an EntitySchema. */
 export type EntitySchemaProperty<Target, Owner> = ({
     kind: ReferenceKind.MANY_TO_ONE | 'm:1';
 } & TypeDef<Target> & ManyToOneOptions<Owner, Target>) | ({
@@ -28,6 +29,7 @@ export type EntitySchemaProperty<Target, Owner> = ({
     enum: true;
 } & EnumOptions<Owner>) | (TypeDef<Target> & PropertyOptions<Owner>);
 type OmitBaseProps<Entity, Base> = IsNever<Base> extends true ? Entity : Omit<Entity, keyof Base>;
+/** Configuration object for defining an entity via EntitySchema. */
 export type EntitySchemaMetadata<Entity, Base = never, Class extends EntityCtor = EntityCtor<Entity>> = Omit<Partial<EntityMetadata<Entity>>, 'name' | 'properties' | 'extends'> & ({
     name: string;
 } | {
@@ -42,6 +44,7 @@ export type EntitySchemaMetadata<Entity, Base = never, Class extends EntityCtor
 } & {
     inheritance?: 'tpt';
 };
+/** Class-less entity definition that provides a programmatic API for defining entities without decorators. */
 export declare class EntitySchema<Entity = any, Base = never, Class extends EntityCtor = EntityCtor<Entity>> {
     /**
      * When schema links the entity class via `class` option, this registry allows the lookup from opposite side,
@@ -60,24 +63,43 @@ export declare class EntitySchema<Entity = any, Base = never, Class extends Enti
      * (e.g. when using `tsx` or `@swc-node/register` with `"type": "commonjs"` projects).
      */
     static is(item: unknown): item is EntitySchema;
+    /** Creates an EntitySchema from existing EntityMetadata (used internally). */
     static fromMetadata<T = AnyEntity, U = never>(meta: EntityMetadata<T> | DeepPartial<EntityMetadata<T>>): EntitySchema<T, U>;
+    /** Adds a scalar property to the entity schema. */
     addProperty(name: EntityKey<Entity>, type?: TypeType, options?: PropertyOptions<Entity> | EntityProperty<Entity>): void;
+    /** Adds an enum property to the entity schema. */
     addEnum(name: EntityKey<Entity>, type?: TypeType, options?: EnumOptions<Entity>): void;
+    /** Adds a version property for optimistic locking. */
     addVersion(name: EntityKey<Entity>, type: TypeType, options?: PropertyOptions<Entity>): void;
+    /** Adds a primary key property to the entity schema. */
     addPrimaryKey(name: EntityKey<Entity>, type: TypeType, options?: PrimaryKeyOptions<Entity>): void;
+    /** Adds a serialized primary key property (e.g. for MongoDB ObjectId). */
     addSerializedPrimaryKey(name: EntityKey<Entity>, type: TypeType, options?: SerializedPrimaryKeyOptions<Entity>): void;
+    /** Adds an embedded property to the entity schema. */
     addEmbedded<Target = AnyEntity>(name: EntityKey<Entity>, options: EmbeddedOptions<Entity, Target>): void;
+    /** Adds a many-to-one relation to the entity schema. */
     addManyToOne<Target = AnyEntity>(name: EntityKey<Entity>, type: TypeType, options: ManyToOneOptions<Entity, Target>): void;
+    /** Adds a many-to-many relation to the entity schema. */
     addManyToMany<Target = AnyEntity>(name: EntityKey<Entity>, type: TypeType, options: ManyToManyOptions<Entity, Target>): void;
+    /** Adds a one-to-many relation to the entity schema. */
     addOneToMany<Target = AnyEntity>(name: EntityKey<Entity>, type: TypeType, options: OneToManyOptions<Entity, Target>): void;
+    /** Adds a one-to-one relation to the entity schema. */
     addOneToOne<Target = AnyEntity>(name: EntityKey<Entity>, type: TypeType, options: OneToOneOptions<Entity, Target>): void;
+    /** Adds an index definition to the entity schema. */
     addIndex<Key extends string>(options: IndexOptions<Entity, Key>): void;
+    /** Adds a unique constraint definition to the entity schema. */
     addUnique<Key extends string>(options: UniqueOptions<Entity, Key>): void;
+    /** Sets a custom repository class for this entity. */
     setCustomRepository(repository: () => Constructor): void;
+    /** Sets the base entity that this schema extends. */
     setExtends(base: EntityName): void;
+    /** Sets or replaces the entity class associated with this schema. */
     setClass(cls: Class): void;
+    /** Returns the underlying EntityMetadata. */
     get meta(): EntityMetadata<Entity, Class>;
+    /** Returns the entity class name. */
     get name(): string | EntityName<Entity>;
+    /** Returns the database table name. */
     get tableName(): string;
     get class(): Class;
     get properties(): Record<string, any>;

package/metadata/EntitySchema.js

@@ -4,6 +4,7 @@ import { Cascade, ReferenceKind } from '../enums.js';
 import { Type } from '../types/Type.js';
 import { Utils } from '../utils/Utils.js';
 import { EnumArrayType } from '../types/EnumArrayType.js';
+/** Class-less entity definition that provides a programmatic API for defining entities without decorators. */
 export class EntitySchema {
     /**
      * When schema links the entity class via `class` option, this registry allows the lookup from opposite side,
@@ -38,11 +39,13 @@ export class EntitySchema {
         }
         return item != null && typeof item === 'object' && item.constructor?.name === 'EntitySchema' && 'meta' in item;
     }
+    /** Creates an EntitySchema from existing EntityMetadata (used internally). */
     static fromMetadata(meta) {
         const schema = new EntitySchema({ ...meta, internal: true });
         schema.internal = true;
         return schema;
     }
+    /** Adds a scalar property to the entity schema. */
     addProperty(name, type, options = {}) {
         this.renameCompositeOptions(name, options);
         const prop = {
@@ -63,6 +66,7 @@ export class EntitySchema {
         }
         this._meta.properties[name] = prop;
     }
+    /** Adds an enum property to the entity schema. */
     addEnum(name, type, options = {}) {
         if (options.items instanceof Function) {
             options.items = Utils.extractEnumValues(options.items());
@@ -82,16 +86,20 @@ export class EntitySchema {
         }
         this.addProperty(name, this.internal ? type : type || 'enum', prop);
     }
+    /** Adds a version property for optimistic locking. */
     addVersion(name, type, options = {}) {
         this.addProperty(name, type, { version: true, ...options });
     }
+    /** Adds a primary key property to the entity schema. */
     addPrimaryKey(name, type, options = {}) {
         this.addProperty(name, type, { primary: true, ...options });
     }
+    /** Adds a serialized primary key property (e.g. for MongoDB ObjectId). */
     addSerializedPrimaryKey(name, type, options = {}) {
         this._meta.serializedPrimaryKey = name;
         this.addProperty(name, type, { serializedPrimaryKey: true, ...options });
     }
+    /** Adds an embedded property to the entity schema. */
     addEmbedded(name, options) {
         this.renameCompositeOptions(name, options);
         Utils.defaultValue(options, 'prefix', true);
@@ -105,6 +113,7 @@ export class EntitySchema {
             ...options,
         };
     }
+    /** Adds a many-to-one relation to the entity schema. */
     addManyToOne(name, type, options) {
         const prop = this.createProperty(ReferenceKind.MANY_TO_ONE, options);
         prop.owner = true;
@@ -118,6 +127,7 @@ export class EntitySchema {
         Utils.defaultValue(prop, 'createForeignKeyConstraint', true);
         this.addProperty(name, type, prop);
     }
+    /** Adds a many-to-many relation to the entity schema. */
     addManyToMany(name, type, options) {
         options.fixedOrder = options.fixedOrder || !!options.fixedOrderColumn;
         if (!options.owner && !options.mappedBy) {
@@ -131,10 +141,12 @@ export class EntitySchema {
         const prop = this.createProperty(ReferenceKind.MANY_TO_MANY, options);
         this.addProperty(name, type, prop);
     }
+    /** Adds a one-to-many relation to the entity schema. */
     addOneToMany(name, type, options) {
         const prop = this.createProperty(ReferenceKind.ONE_TO_MANY, options);
         this.addProperty(name, type, prop);
     }
+    /** Adds a one-to-one relation to the entity schema. */
     addOneToOne(name, type, options) {
         const prop = this.createProperty(ReferenceKind.ONE_TO_ONE, options);
         Utils.defaultValue(prop, 'owner', !!prop.inversedBy || !prop.mappedBy);
@@ -154,18 +166,23 @@ export class EntitySchema {
         }
         this.addProperty(name, type, prop);
     }
+    /** Adds an index definition to the entity schema. */
     addIndex(options) {
         this._meta.indexes.push(options);
     }
+    /** Adds a unique constraint definition to the entity schema. */
     addUnique(options) {
         this._meta.uniques.push(options);
     }
+    /** Sets a custom repository class for this entity. */
     setCustomRepository(repository) {
         this._meta.repository = repository;
     }
+    /** Sets the base entity that this schema extends. */
     setExtends(base) {
         this._meta.extends = base;
     }
+    /** Sets or replaces the entity class associated with this schema. */
     setClass(cls) {
         const oldClass = this._meta.class;
         const sameClass = this._meta.class === cls;
@@ -191,12 +208,15 @@ export class EntitySchema {
             this._meta.extends ??= base.name ? base : undefined;
         }
     }
+    /** Returns the underlying EntityMetadata. */
     get meta() {
         return this._meta;
     }
+    /** Returns the entity class name. */
     get name() {
         return this._meta.className;
     }
+    /** Returns the database table name. */
     get tableName() {
         return this._meta.tableName;
     }
@@ -241,7 +261,7 @@ export class EntitySchema {
     isPartOfTPTHierarchy() {
         let parent = this._meta.extends;
         while (parent) {
-            const parentSchema = parent instanceof EntitySchema ? parent : EntitySchema.REGISTRY.get(parent);
+            const parentSchema = EntitySchema.is(parent) ? parent : EntitySchema.REGISTRY.get(parent);
             if (!parentSchema) {
                 break;
             }
@@ -321,7 +341,7 @@ export class EntitySchema {
                         .sort()
                         .join(' | ')
                     : Utils.className(tmp);
-                const target = tmp instanceof EntitySchema ? tmp.meta.class : tmp;
+                const target = EntitySchema.is(tmp) ? tmp.meta.class : tmp;
                 return { type, target };
             }
         }

package/metadata/MetadataDiscovery.d.ts

@@ -3,13 +3,17 @@ import type { Configuration } from '../utils/Configuration.js';
 import { MetadataStorage } from './MetadataStorage.js';
 import { EntitySchema } from './EntitySchema.js';
 import type { Platform } from '../platforms/Platform.js';
+/** Discovers, validates, and processes entity metadata from configured sources. */
 export declare class MetadataDiscovery {
     #private;
     constructor(metadata: MetadataStorage, platform: Platform, config: Configuration);
+    /** Discovers all entities asynchronously and returns the populated MetadataStorage. */
     discover(preferTs?: boolean): Promise<MetadataStorage>;
+    /** Discovers all entities synchronously and returns the populated MetadataStorage. */
     discoverSync(): MetadataStorage;
     private mapDiscoveredEntities;
     private initAccessors;
+    /** Processes discovered entities: initializes relations, embeddables, indexes, and inheritance. */
     processDiscoveredEntities(discovered: EntityMetadata[]): EntityMetadata[];
     private findEntities;
     private discoverMissingTargets;

package/metadata/MetadataDiscovery.js

@@ -11,6 +11,7 @@ import { t, Type } from '../types/index.js';
 import { colors } from '../logging/colors.js';
 import { raw, Raw } from '../utils/RawQueryFragment.js';
 import { BaseEntity } from '../entity/BaseEntity.js';
+/** Discovers, validates, and processes entity metadata from configured sources. */
 export class MetadataDiscovery {
     #namingStrategy;
     #metadataProvider;
@@ -30,6 +31,7 @@ export class MetadataDiscovery {
         this.#logger = this.#config.getLogger();
         this.#schemaHelper = this.#platform.getSchemaHelper();
     }
+    /** Discovers all entities asynchronously and returns the populated MetadataStorage. */
     async discover(preferTs = true) {
         this.#discovered.length = 0;
         const startTime = Date.now();
@@ -50,6 +52,7 @@ export class MetadataDiscovery {
         await this.#config.get('discovery').afterDiscovered?.(storage, this.#platform);
         return storage;
     }
+    /** Discovers all entities synchronously and returns the populated MetadataStorage. */
     discoverSync() {
         this.#discovered.length = 0;
         const startTime = Date.now();
@@ -121,6 +124,7 @@ export class MetadataDiscovery {
             }
         }
     }
+    /** Processes discovered entities: initializes relations, embeddables, indexes, and inheritance. */
     processDiscoveredEntities(discovered) {
         for (const meta of discovered) {
             let i = 1;
@@ -228,7 +232,7 @@ export class MetadataDiscovery {
     }
     tryDiscoverTargets(targets) {
         for (const target of targets) {
-            const schema = target instanceof EntitySchema ? target : undefined;
+            const schema = EntitySchema.is(target) ? target : undefined;
             const isDiscoverable = typeof target === 'function' || schema;
             if (isDiscoverable && target.name) {
                 // Get the actual class for EntitySchema, or use target directly for classes
@@ -254,7 +258,7 @@ export class MetadataDiscovery {
         // discover parents (base entities) automatically
         for (const meta of this.#metadata) {
             let parent = meta.extends;
-            if (parent instanceof EntitySchema && !this.#metadata.has(parent.init().meta.class)) {
+            if (EntitySchema.is(parent) && !this.#metadata.has(parent.init().meta.class)) {
                 this.discoverReferences([parent], false);
             }
             if (typeof parent === 'function' && parent.name && !this.#metadata.has(parent)) {
@@ -293,21 +297,23 @@ export class MetadataDiscovery {
         if (EntitySchema.REGISTRY.has(entity)) {
             entity = EntitySchema.REGISTRY.get(entity);
         }
-        if (entity instanceof EntitySchema) {
+        if (EntitySchema.is(entity)) {
             const meta = Utils.copy(entity.meta, false);
             return EntitySchema.fromMetadata(meta);
         }
-        const path = entity[MetadataStorage.PATH_SYMBOL];
+        // After the EntitySchema check, entity must be an EntityClass
+        const cls = entity;
+        const path = cls[MetadataStorage.PATH_SYMBOL];
         if (path) {
-            const meta = Utils.copy(MetadataStorage.getMetadata(entity.name, path), false);
+            const meta = Utils.copy(MetadataStorage.getMetadata(cls.name, path), false);
             meta.path = path;
-            this.#metadata.set(entity, meta);
+            this.#metadata.set(cls, meta);
         }
-        const exists = this.#metadata.has(entity);
-        const meta = this.#metadata.get(entity, true);
+        const exists = this.#metadata.has(cls);
+        const meta = this.#metadata.get(cls, true);
         meta.abstract ??= !(exists && meta.name);
         const schema = EntitySchema.fromMetadata(meta);
-        schema.setClass(entity);
+        schema.setClass(cls);
         return schema;
     }
     getRootEntity(meta) {
@@ -1435,7 +1441,7 @@ export class MetadataDiscovery {
         }
         return metadata.find(m => {
             const ext = meta.extends;
-            if (ext instanceof EntitySchema) {
+            if (EntitySchema.is(ext)) {
                 return m.class === ext.meta.class || m.className === ext.meta.className;
             }
             return m.class === ext || m.className === Utils.className(ext);
@@ -1610,8 +1616,9 @@ export class MetadataDiscovery {
             !prop.customType) {
             // if the type is an ORM defined mapped type without `ensureComparable: true`,
             // we use just the type name, to have more performant hydration code
+            const brand = Type.getOrmType(prop.type);
             const type = Utils.keys(t).find(type => {
-                return !Type.getType(t[type]).ensureComparable(meta, prop) && prop.type === t[type];
+                return (!Type.getType(t[type]).ensureComparable(meta, prop) && (prop.type === t[type] || brand === type));
             });
             if (type) {
                 prop.type = type === 'datetime' ? 'Date' : type;

package/metadata/MetadataProvider.d.ts

@@ -8,15 +8,23 @@ export interface IConfiguration {
     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);
+    /** 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,10 +1,12 @@
 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;
     }
+    /** Resolves entity references and type information for all properties in the given metadata. */
     loadEntityMetadata(meta) {
         for (const prop of meta.props) {
             /* v8 ignore next */
@@ -19,13 +21,14 @@ export class MetadataProvider {
                         .sort()
                         .join(' | ')
                     : Utils.className(tmp);
-                prop.target = tmp instanceof EntitySchema ? tmp.meta.class : 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}.`);
             }
         }
     }
+    /** 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];
@@ -56,15 +59,18 @@ export class MetadataProvider {
             }
         }
     }
+    /** 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;
@@ -76,6 +82,7 @@ export class MetadataProvider {
         }
         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
@@ -83,6 +90,7 @@ export class MetadataProvider {
             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,37 @@
 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>);
+    /** 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

@@ -8,6 +8,7 @@ function getGlobalStorage(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');
@@ -35,15 +36,19 @@ export class MetadataStorage {
         }
         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) {
@@ -57,6 +62,7 @@ export class MetadataStorage {
         this.set(entityName, meta);
         return meta;
     }
+    /** Finds metadata for the given entity, returning undefined if not registered. */
     find(entityName) {
         if (!entityName) {
             return;
@@ -65,14 +71,16 @@ export class MetadataStorage {
         if (meta) {
             return meta;
         }
-        if (entityName instanceof EntitySchema) {
+        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;
@@ -80,6 +88,7 @@ export class MetadataStorage {
         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) {
@@ -89,6 +98,7 @@ export class MetadataStorage {
             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));
     }
@@ -97,12 +107,15 @@ export class MetadataStorage {
             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);
     }

package/naming-strategy/AbstractNamingStrategy.d.ts

@@ -1,5 +1,6 @@
 import type { NamingStrategy } from './NamingStrategy.js';
 import { type ReferenceKind } from '../enums.js';
+/** Base class for naming strategies, providing default implementations for common naming conventions. */
 export declare abstract class AbstractNamingStrategy implements NamingStrategy {
     getClassName(file: string, separator?: string): string;
     classToMigrationName(timestamp: string, customMigrationName?: string): string;

package/naming-strategy/AbstractNamingStrategy.js

@@ -1,5 +1,6 @@
 import { PopulatePath } from '../enums.js';
 const populatePathMembers = Object.values(PopulatePath);
+/** Base class for naming strategies, providing default implementations for common naming conventions. */
 export class AbstractNamingStrategy {
     getClassName(file, separator = '-') {
         const name = file.split('.')[0];

package/naming-strategy/MongoNamingStrategy.d.ts

@@ -1,4 +1,5 @@
 import { AbstractNamingStrategy } from './AbstractNamingStrategy.js';
+/** Naming strategy for MongoDB that uses camelCase property names and hyphenated collection names. */
 export declare class MongoNamingStrategy extends AbstractNamingStrategy {
     classToTableName(entityName: string, tableName?: string): string;
     joinColumnName(propertyName: string): string;

package/naming-strategy/MongoNamingStrategy.js

@@ -1,4 +1,5 @@
 import { AbstractNamingStrategy } from './AbstractNamingStrategy.js';
+/** Naming strategy for MongoDB that uses camelCase property names and hyphenated collection names. */
 export class MongoNamingStrategy extends AbstractNamingStrategy {
     classToTableName(entityName, tableName) {
         return tableName ?? entityName.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();

package/naming-strategy/UnderscoreNamingStrategy.d.ts

@@ -1,4 +1,5 @@
 import { AbstractNamingStrategy } from './AbstractNamingStrategy.js';
+/** Naming strategy that converts camelCase names to snake_case for table and column names. */
 export declare class UnderscoreNamingStrategy extends AbstractNamingStrategy {
     classToTableName(entityName: string, tableName?: string): string;
     joinColumnName(propertyName: string): string;

package/naming-strategy/UnderscoreNamingStrategy.js

@@ -1,4 +1,5 @@
 import { AbstractNamingStrategy } from './AbstractNamingStrategy.js';
+/** Naming strategy that converts camelCase names to snake_case for table and column names. */
 export class UnderscoreNamingStrategy extends AbstractNamingStrategy {
     classToTableName(entityName, tableName) {
         return tableName ?? this.underscore(entityName);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.0.2-dev.9",
+  "version": "7.0.3-dev.0",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",

package/platforms/ExceptionConverter.d.ts

@@ -1,5 +1,6 @@
 import type { Dictionary } from '../typings.js';
 import { DriverException } from '../exceptions.js';
+/** Converts native database errors into standardized DriverException instances. */
 export declare class ExceptionConverter {
     convertException(exception: Error & Dictionary): DriverException;
 }

package/platforms/ExceptionConverter.js

@@ -1,4 +1,5 @@
 import { DriverException } from '../exceptions.js';
+/** Converts native database errors into standardized DriverException instances. */
 export class ExceptionConverter {
     /* v8 ignore next */
     convertException(exception) {