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

package/es/hooks.js

@@ -1,45 +1,53 @@
 import { EventType } from '@mikro-orm/core';
 function hook(type) {
-    return function (value, context) {
-        const meta = context.metadata;
-        meta.hooks ??= {};
-        meta.hooks[type] ??= [];
-        meta.hooks[type].push(value);
-    };
-}
+  return function (value, context) {
+    const meta = context.metadata;
+    meta.hooks ??= {};
+    meta.hooks[type] ??= [];
+    meta.hooks[type].push(value);
+  };
+}
+/** Called before a new entity is persisted to the database (TC39 decorator). */
 export function BeforeCreate() {
-    return hook(EventType.beforeCreate);
+  return hook(EventType.beforeCreate);
 }
+/** Called after a new entity has been persisted to the database (TC39 decorator). */
 export function AfterCreate() {
-    return hook(EventType.afterCreate);
+  return hook(EventType.afterCreate);
 }
+/** Called before an existing entity is updated in the database (TC39 decorator). */
 export function BeforeUpdate() {
-    return hook(EventType.beforeUpdate);
+  return hook(EventType.beforeUpdate);
 }
+/** Called after an existing entity has been updated in the database (TC39 decorator). */
 export function AfterUpdate() {
-    return hook(EventType.afterUpdate);
+  return hook(EventType.afterUpdate);
 }
+/** Called before an entity is upserted (TC39 decorator). */
 export function BeforeUpsert() {
-    return hook(EventType.beforeUpsert);
+  return hook(EventType.beforeUpsert);
 }
+/** Called after an entity has been upserted (TC39 decorator). */
 export function AfterUpsert() {
-    return hook(EventType.afterUpsert);
+  return hook(EventType.afterUpsert);
 }
+/** Called when an entity is instantiated by the EntityManager (TC39 decorator). */
 export function OnInit() {
-    return hook(EventType.onInit);
+  return hook(EventType.onInit);
 }
+/** Called after an entity is loaded from the database (TC39 decorator). */
 export function OnLoad() {
-    return hook(EventType.onLoad);
+  return hook(EventType.onLoad);
 }
 /**
  * Called before deleting entity, but only when providing initialized entity to EM#remove()
  */
 export function BeforeDelete() {
-    return hook(EventType.beforeDelete);
+  return hook(EventType.beforeDelete);
 }
 /**
  * Called after deleting entity, but only when providing initialized entity to EM#remove()
  */
 export function AfterDelete() {
-    return hook(EventType.afterDelete);
+  return hook(EventType.afterDelete);
 }

package/legacy/Check.d.ts

@@ -1,2 +1,5 @@
 import { type CheckConstraint, type EntityClass } from '@mikro-orm/core';
-export declare function Check<T>(options: CheckConstraint<T>): (target: T, propertyName?: T extends EntityClass<unknown> ? undefined : keyof T) => any;
+/** Defines a database check constraint on a property or entity class (legacy TypeScript decorator). */
+export declare function Check<T>(
+  options: CheckConstraint<T>,
+): (target: T, propertyName?: T extends EntityClass<unknown> ? undefined : keyof T) => any;

package/legacy/Check.js

@@ -1,12 +1,13 @@
 import { getMetadataFromDecorator } from '../utils.js';
+/** Defines a database check constraint on a property or entity class (legacy TypeScript decorator). */
 export function Check(options) {
-    return function (target, propertyName) {
-        const meta = getMetadataFromDecorator((propertyName ? target.constructor : target));
-        options.property ??= propertyName;
-        meta.checks.push(options);
-        if (!propertyName) {
-            return target;
-        }
-        return undefined;
-    };
+  return function (target, propertyName) {
+    const meta = getMetadataFromDecorator(propertyName ? target.constructor : target);
+    options.property ??= propertyName;
+    meta.checks.push(options);
+    if (!propertyName) {
+      return target;
+    }
+    return undefined;
+  };
 }

package/legacy/CreateRequestContext.d.ts

@@ -1,3 +1,8 @@
 import { type ContextProvider } from '../utils.js';
-export declare function CreateRequestContext<T extends object>(context?: ContextProvider<T>, respectExistingContext?: boolean): MethodDecorator;
+/** Wraps an async method in a new RequestContext, forking the EntityManager (legacy TypeScript decorator). */
+export declare function CreateRequestContext<T extends object>(
+  context?: ContextProvider<T>,
+  respectExistingContext?: boolean,
+): MethodDecorator;
+/** Like `@CreateRequestContext`, but reuses an existing RequestContext if one is available (legacy TypeScript decorator). */
 export declare function EnsureRequestContext<T extends object>(context?: ContextProvider<T>): MethodDecorator;

package/legacy/CreateRequestContext.js

@@ -1,31 +1,35 @@
 import { RequestContext, TransactionContext } from '@mikro-orm/core';
 import { resolveContextProvider } from '../utils.js';
+/** Wraps an async method in a new RequestContext, forking the EntityManager (legacy TypeScript decorator). */
 export function CreateRequestContext(context, respectExistingContext = false) {
-    return function (target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        const name = respectExistingContext ? 'EnsureRequestContext' : 'CreateRequestContext';
-        if (originalMethod.constructor.name !== 'AsyncFunction') {
-            throw new Error(`@${name}() should be use with async functions`);
-        }
-        descriptor.value = async function (...args) {
-            const em = await resolveContextProvider(this, context);
-            if (!em) {
-                throw new Error(`@${name}() decorator can only be applied to methods of classes with \`orm: MikroORM\` property, \`em: EntityManager\` property, or with a callback parameter like \`@${name}(() => orm)\` that returns one of those types. The parameter will contain a reference to current \`this\`. Returning an EntityRepository from it is also supported.`);
-            }
-            // reuse existing context if available for given respect `contextName`
-            if (respectExistingContext && RequestContext.getEntityManager(em.name)) {
-                return originalMethod.apply(this, args);
-            }
-            // Otherwise, the outer tx context would be preferred.
-            const txContext = TransactionContext.currentTransactionContext();
-            const provider = txContext ? TransactionContext : RequestContext;
-            return txContext
-                ? provider.create(em.fork({ useContext: true }), () => originalMethod.apply(this, args))
-                : provider.create(em, () => originalMethod.apply(this, args));
-        };
-        return descriptor;
+  return function (target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    const name = respectExistingContext ? 'EnsureRequestContext' : 'CreateRequestContext';
+    if (originalMethod.constructor.name !== 'AsyncFunction') {
+      throw new Error(`@${name}() should be use with async functions`);
+    }
+    descriptor.value = async function (...args) {
+      const em = await resolveContextProvider(this, context);
+      if (!em) {
+        throw new Error(
+          `@${name}() decorator can only be applied to methods of classes with \`orm: MikroORM\` property, \`em: EntityManager\` property, or with a callback parameter like \`@${name}(() => orm)\` that returns one of those types. The parameter will contain a reference to current \`this\`. Returning an EntityRepository from it is also supported.`,
+        );
+      }
+      // reuse existing context if available for given respect `contextName`
+      if (respectExistingContext && RequestContext.getEntityManager(em.name)) {
+        return originalMethod.apply(this, args);
+      }
+      // Otherwise, the outer tx context would be preferred.
+      const txContext = TransactionContext.currentTransactionContext();
+      const provider = txContext ? TransactionContext : RequestContext;
+      return txContext
+        ? provider.create(em.fork({ useContext: true }), () => originalMethod.apply(this, args))
+        : provider.create(em, () => originalMethod.apply(this, args));
     };
+    return descriptor;
+  };
 }
+/** Like `@CreateRequestContext`, but reuses an existing RequestContext if one is available (legacy TypeScript decorator). */
 export function EnsureRequestContext(context) {
-    return CreateRequestContext(context, true);
+  return CreateRequestContext(context, true);
 }

package/legacy/Embeddable.d.ts

@@ -1,2 +1,3 @@
 import { type EmbeddableOptions } from '@mikro-orm/core';
+/** Marks a class as an embeddable type (legacy TypeScript decorator). */
 export declare function Embeddable<T>(options?: EmbeddableOptions<T>): (target: T) => T;

package/legacy/Embeddable.js

@@ -1,11 +1,12 @@
 import { getMetadataFromDecorator } from '../utils.js';
+/** Marks a class as an embeddable type (legacy TypeScript decorator). */
 export function Embeddable(options = {}) {
-    return function (target) {
-        const meta = getMetadataFromDecorator(target);
-        meta.class = target;
-        meta.name = meta.class.name;
-        meta.embeddable = true;
-        Object.assign(meta, options);
-        return target;
-    };
+  return function (target) {
+    const meta = getMetadataFromDecorator(target);
+    meta.class = target;
+    meta.name = meta.class.name;
+    meta.embeddable = true;
+    Object.assign(meta, options);
+    return target;
+  };
 }

package/legacy/Embedded.d.ts

@@ -1,2 +1,6 @@
 import { type AnyEntity, type EntityName, type EmbeddedOptions } from '@mikro-orm/core';
-export declare function Embedded<Owner extends object, Target>(type?: EmbeddedOptions<Owner, Target> | (() => EntityName<Target> | EntityName[]), options?: EmbeddedOptions<Owner, Target>): (target: AnyEntity, propertyName: string) => void;
+/** Defines an embedded property on an entity (legacy TypeScript decorator). */
+export declare function Embedded<Owner extends object, Target>(
+  type?: EmbeddedOptions<Owner, Target> | (() => EntityName<Target> | EntityName[]),
+  options?: EmbeddedOptions<Owner, Target>,
+): (target: AnyEntity, propertyName: string) => void;

package/legacy/Embedded.js

@@ -1,15 +1,16 @@
-import { ReferenceKind, Utils, } from '@mikro-orm/core';
+import { ReferenceKind, Utils } from '@mikro-orm/core';
 import { validateSingleDecorator, getMetadataFromDecorator } from '../utils.js';
+/** Defines an embedded property on an entity (legacy TypeScript decorator). */
 export function Embedded(type = {}, options = {}) {
-    return function (target, propertyName) {
-        const meta = getMetadataFromDecorator(target.constructor);
-        validateSingleDecorator(meta, propertyName, ReferenceKind.EMBEDDED);
-        options = type instanceof Function ? { entity: type, ...options } : { ...type, ...options };
-        Utils.defaultValue(options, 'prefix', true);
-        meta.properties[propertyName] = {
-            name: propertyName,
-            kind: ReferenceKind.EMBEDDED,
-            ...options,
-        };
+  return function (target, propertyName) {
+    const meta = getMetadataFromDecorator(target.constructor);
+    validateSingleDecorator(meta, propertyName, ReferenceKind.EMBEDDED);
+    options = type instanceof Function ? { entity: type, ...options } : { ...type, ...options };
+    Utils.defaultValue(options, 'prefix', true);
+    meta.properties[propertyName] = {
+      name: propertyName,
+      kind: ReferenceKind.EMBEDDED,
+      ...options,
     };
+  };
 }

package/legacy/Entity.d.ts

@@ -1,2 +1,3 @@
 import { type EntityClass, type EntityOptions } from '@mikro-orm/core';
+/** Marks a class as a MikroORM entity (legacy TypeScript decorator). */
 export declare function Entity<T extends EntityClass<unknown>>(options?: EntityOptions<T>): (target: T) => void;

package/legacy/Entity.js

@@ -1,12 +1,13 @@
 import { Utils } from '@mikro-orm/core';
 import { getMetadataFromDecorator } from '../utils.js';
+/** Marks a class as a MikroORM entity (legacy TypeScript decorator). */
 export function Entity(options = {}) {
-    return function (target) {
-        const meta = getMetadataFromDecorator(target);
-        Utils.mergeConfig(meta, options);
-        meta.class = target;
-        if (!options.abstract || meta.discriminatorColumn) {
-            meta.name = target.name;
-        }
-    };
+  return function (target) {
+    const meta = getMetadataFromDecorator(target);
+    Utils.mergeConfig(meta, options);
+    meta.class = target;
+    if (!options.abstract || meta.discriminatorColumn) {
+      meta.name = target.name;
+    }
+  };
 }

package/legacy/Enum.d.ts

@@ -1,2 +1,5 @@
 import { type EnumOptions, type AnyEntity, type Dictionary } from '@mikro-orm/core';
-export declare function Enum<T extends object>(options?: EnumOptions<AnyEntity> | (() => Dictionary)): (target: T, propertyName: string) => void;
+/** Defines an enum property on an entity (legacy TypeScript decorator). */
+export declare function Enum<T extends object>(
+  options?: EnumOptions<AnyEntity> | (() => Dictionary),
+): (target: T, propertyName: string) => void;

package/legacy/Enum.js

@@ -1,14 +1,15 @@
-import { ReferenceKind, } from '@mikro-orm/core';
+import { ReferenceKind } from '@mikro-orm/core';
 import { getMetadataFromDecorator } from '../utils.js';
+/** Defines an enum property on an entity (legacy TypeScript decorator). */
 export function Enum(options = {}) {
-    return function (target, propertyName) {
-        const meta = getMetadataFromDecorator(target.constructor);
-        options = options instanceof Function ? { items: options } : options;
-        meta.properties[propertyName] = {
-            name: propertyName,
-            kind: ReferenceKind.SCALAR,
-            enum: true,
-            ...options,
-        };
+  return function (target, propertyName) {
+    const meta = getMetadataFromDecorator(target.constructor);
+    options = options instanceof Function ? { items: options } : options;
+    meta.properties[propertyName] = {
+      name: propertyName,
+      kind: ReferenceKind.SCALAR,
+      enum: true,
+      ...options,
     };
+  };
 }

package/legacy/Filter.d.ts

@@ -1,2 +1,3 @@
 import { type FilterDef, type EntityClass } from '@mikro-orm/core';
+/** Registers a named filter on an entity class (legacy TypeScript decorator). */
 export declare function Filter<T extends EntityClass<unknown>>(options: FilterDef<T>): (target: T) => void;

package/legacy/Filter.js

@@ -1,7 +1,8 @@
 import { getMetadataFromDecorator } from '../utils.js';
+/** Registers a named filter on an entity class (legacy TypeScript decorator). */
 export function Filter(options) {
-    return function (target) {
-        const meta = getMetadataFromDecorator(target);
-        meta.filters[options.name] = options;
-    };
+  return function (target) {
+    const meta = getMetadataFromDecorator(target);
+    meta.filters[options.name] = options;
+  };
 }

package/legacy/Formula.d.ts

@@ -1,2 +1,6 @@
 import { type FormulaCallback, type PropertyOptions } from '@mikro-orm/core';
-export declare function Formula<T extends object>(formula: string | FormulaCallback<T>, options?: PropertyOptions<T>): (target: T, propertyName: string) => void;
+/** Defines a computed SQL formula property on an entity (legacy TypeScript decorator). */
+export declare function Formula<T extends object>(
+  formula: string | FormulaCallback<T>,
+  options?: PropertyOptions<T>,
+): (target: T, propertyName: string) => void;

package/legacy/Formula.js

@@ -1,13 +1,14 @@
-import { ReferenceKind, } from '@mikro-orm/core';
+import { ReferenceKind } from '@mikro-orm/core';
 import { getMetadataFromDecorator } from '../utils.js';
+/** Defines a computed SQL formula property on an entity (legacy TypeScript decorator). */
 export function Formula(formula, options = {}) {
-    return function (target, propertyName) {
-        const meta = getMetadataFromDecorator(target.constructor);
-        meta.properties[propertyName] = {
-            name: propertyName,
-            kind: ReferenceKind.SCALAR,
-            formula,
-            ...options,
-        };
+  return function (target, propertyName) {
+    const meta = getMetadataFromDecorator(target.constructor);
+    meta.properties[propertyName] = {
+      name: propertyName,
+      kind: ReferenceKind.SCALAR,
+      formula,
+      ...options,
     };
+  };
 }

package/legacy/Indexed.d.ts

@@ -1,3 +1,9 @@
 import { type EntityClass, type IndexOptions, type UniqueOptions } from '@mikro-orm/core';
-export declare function Index<T extends object, H extends string>(options?: IndexOptions<T, H>): (target: T, propertyName?: T extends EntityClass<unknown> ? undefined : keyof T) => any;
-export declare function Unique<T extends object, H extends string>(options?: UniqueOptions<T, H>): (target: T, propertyName?: T extends EntityClass<unknown> ? undefined : keyof T) => any;
+/** Defines a database index on a property or entity class (legacy TypeScript decorator). */
+export declare function Index<T extends object, H extends string>(
+  options?: IndexOptions<T, H>,
+): (target: T, propertyName?: T extends EntityClass<unknown> ? undefined : keyof T) => any;
+/** Defines a unique constraint on a property or entity class (legacy TypeScript decorator). */
+export declare function Unique<T extends object, H extends string>(
+  options?: UniqueOptions<T, H>,
+): (target: T, propertyName?: T extends EntityClass<unknown> ? undefined : keyof T) => any;

package/legacy/Indexed.js

@@ -1,19 +1,21 @@
 import { getMetadataFromDecorator } from '../utils.js';
 function createDecorator(options, unique) {
-    return function (target, propertyName) {
-        const meta = getMetadataFromDecorator(propertyName ? target.constructor : target);
-        options.properties ??= propertyName;
-        const key = unique ? 'uniques' : 'indexes';
-        meta[key].push(options);
-        if (!propertyName) {
-            return target;
-        }
-        return undefined;
-    };
+  return function (target, propertyName) {
+    const meta = getMetadataFromDecorator(propertyName ? target.constructor : target);
+    options.properties ??= propertyName;
+    const key = unique ? 'uniques' : 'indexes';
+    meta[key].push(options);
+    if (!propertyName) {
+      return target;
+    }
+    return undefined;
+  };
 }
+/** Defines a database index on a property or entity class (legacy TypeScript decorator). */
 export function Index(options = {}) {
-    return createDecorator(options, false);
+  return createDecorator(options, false);
 }
+/** Defines a unique constraint on a property or entity class (legacy TypeScript decorator). */
 export function Unique(options = {}) {
-    return createDecorator(options, true);
+  return createDecorator(options, true);
 }

package/legacy/ManyToMany.d.ts

@@ -1,4 +1,11 @@
 import { type EntityName, type ManyToManyOptions } from '@mikro-orm/core';
-export declare function ManyToMany<Target extends object, Owner extends object>(entity: () => EntityName<Target>, mappedBy?: (string & keyof Target) | ((e: Target) => any), options?: Partial<ManyToManyOptions<Owner, Target>>): (target: Owner, propertyName: keyof Owner) => void;
+/** Defines a many-to-many relationship (legacy TypeScript decorator). */
+export declare function ManyToMany<Target extends object, Owner extends object>(
+  entity: () => EntityName<Target>,
+  mappedBy?: (string & keyof Target) | ((e: Target) => any),
+  options?: Partial<ManyToManyOptions<Owner, Target>>,
+): (target: Owner, propertyName: keyof Owner) => void;
 export declare function ManyToMany<Target extends object, Owner extends object>(entity: string, options?: any): never;
-export declare function ManyToMany<Target extends object, Owner extends object>(options?: ManyToManyOptions<Owner, Target>): (target: Owner, propertyName: keyof Owner) => void;
+export declare function ManyToMany<Target extends object, Owner extends object>(
+  options?: ManyToManyOptions<Owner, Target>,
+): (target: Owner, propertyName: keyof Owner) => void;

package/legacy/ManyToMany.js

@@ -1,11 +1,11 @@
-import { ReferenceKind, } from '@mikro-orm/core';
+import { ReferenceKind } from '@mikro-orm/core';
 import { processDecoratorParameters, validateSingleDecorator, getMetadataFromDecorator } from '../utils.js';
 export function ManyToMany(entity, mappedBy, options = {}) {
-    return function (target, propertyName) {
-        options = processDecoratorParameters({ entity, mappedBy, options });
-        const meta = getMetadataFromDecorator(target.constructor);
-        validateSingleDecorator(meta, propertyName, ReferenceKind.MANY_TO_MANY);
-        const property = { name: propertyName, kind: ReferenceKind.MANY_TO_MANY };
-        meta.properties[propertyName] = Object.assign(meta.properties[propertyName] ?? {}, property, options);
-    };
+  return function (target, propertyName) {
+    options = processDecoratorParameters({ entity, mappedBy, options });
+    const meta = getMetadataFromDecorator(target.constructor);
+    validateSingleDecorator(meta, propertyName, ReferenceKind.MANY_TO_MANY);
+    const property = { name: propertyName, kind: ReferenceKind.MANY_TO_MANY };
+    meta.properties[propertyName] = Object.assign(meta.properties[propertyName] ?? {}, property, options);
+  };
 }

package/legacy/ManyToOne.d.ts

@@ -1,4 +1,10 @@
 import { type ManyToOneOptions, type EntityName } from '@mikro-orm/core';
-export declare function ManyToOne<Target extends object, Owner extends object>(entity: (e?: any) => EntityName<Target> | EntityName[], options?: Partial<ManyToOneOptions<Owner, Target>>): (target: Owner, propertyName: string) => void;
+/** Defines a many-to-one relationship (legacy TypeScript decorator). */
+export declare function ManyToOne<Target extends object, Owner extends object>(
+  entity: (e?: any) => EntityName<Target> | EntityName[],
+  options?: Partial<ManyToOneOptions<Owner, Target>>,
+): (target: Owner, propertyName: string) => void;
 export declare function ManyToOne<Target extends object, Owner extends object>(entity: string, options?: any): never;
-export declare function ManyToOne<Target extends object, Owner extends object>(options?: ManyToOneOptions<Owner, Target>): (target: Owner, propertyName: string) => void;
+export declare function ManyToOne<Target extends object, Owner extends object>(
+  options?: ManyToOneOptions<Owner, Target>,
+): (target: Owner, propertyName: string) => void;

package/legacy/ManyToOne.js

@@ -1,11 +1,11 @@
-import { ReferenceKind, } from '@mikro-orm/core';
+import { ReferenceKind } from '@mikro-orm/core';
 import { processDecoratorParameters, validateSingleDecorator, getMetadataFromDecorator } from '../utils.js';
 export function ManyToOne(entity = {}, options = {}) {
-    return function (target, propertyName) {
-        options = processDecoratorParameters({ entity, options });
-        const meta = getMetadataFromDecorator(target.constructor);
-        validateSingleDecorator(meta, propertyName, ReferenceKind.MANY_TO_ONE);
-        const property = { name: propertyName, kind: ReferenceKind.MANY_TO_ONE };
-        meta.properties[propertyName] = Object.assign(meta.properties[propertyName] ?? {}, property, options);
-    };
+  return function (target, propertyName) {
+    options = processDecoratorParameters({ entity, options });
+    const meta = getMetadataFromDecorator(target.constructor);
+    validateSingleDecorator(meta, propertyName, ReferenceKind.MANY_TO_ONE);
+    const property = { name: propertyName, kind: ReferenceKind.MANY_TO_ONE };
+    meta.properties[propertyName] = Object.assign(meta.properties[propertyName] ?? {}, property, options);
+  };
 }

package/legacy/OneToMany.d.ts

@@ -1,3 +1,10 @@
 import { type EntityName, type OneToManyOptions } from '@mikro-orm/core';
-export declare function OneToMany<Target extends object, Owner extends object>(entity: (e?: any) => EntityName<Target>, mappedBy: (string & keyof Target) | ((e: Target) => any), options?: Partial<OneToManyOptions<Owner, Target>>): (target: Owner, propertyName: string) => void;
-export declare function OneToMany<Target extends object, Owner extends object>(options: OneToManyOptions<Owner, Target>): (target: Owner, propertyName: string) => void;
+/** Defines a one-to-many relationship (legacy TypeScript decorator). */
+export declare function OneToMany<Target extends object, Owner extends object>(
+  entity: (e?: any) => EntityName<Target>,
+  mappedBy: (string & keyof Target) | ((e: Target) => any),
+  options?: Partial<OneToManyOptions<Owner, Target>>,
+): (target: Owner, propertyName: string) => void;
+export declare function OneToMany<Target extends object, Owner extends object>(
+  options: OneToManyOptions<Owner, Target>,
+): (target: Owner, propertyName: string) => void;

package/legacy/OneToMany.js

@@ -1,11 +1,11 @@
-import { ReferenceKind, } from '@mikro-orm/core';
+import { ReferenceKind } from '@mikro-orm/core';
 import { processDecoratorParameters, validateSingleDecorator, getMetadataFromDecorator } from '../utils.js';
 export function OneToMany(entity, mappedBy, options = {}) {
-    return function (target, propertyName) {
-        options = processDecoratorParameters({ entity, mappedBy, options });
-        const meta = getMetadataFromDecorator(target.constructor);
-        validateSingleDecorator(meta, propertyName, ReferenceKind.ONE_TO_MANY);
-        const property = { name: propertyName, kind: ReferenceKind.ONE_TO_MANY };
-        meta.properties[propertyName] = Object.assign(meta.properties[propertyName] ?? {}, property, options);
-    };
+  return function (target, propertyName) {
+    options = processDecoratorParameters({ entity, mappedBy, options });
+    const meta = getMetadataFromDecorator(target.constructor);
+    validateSingleDecorator(meta, propertyName, ReferenceKind.ONE_TO_MANY);
+    const property = { name: propertyName, kind: ReferenceKind.ONE_TO_MANY };
+    meta.properties[propertyName] = Object.assign(meta.properties[propertyName] ?? {}, property, options);
+  };
 }

package/legacy/OneToOne.d.ts

@@ -1,3 +1,10 @@
 import { type EntityName, type OneToOneOptions } from '@mikro-orm/core';
-export declare function OneToOne<Target, Owner>(entity: (e: Owner) => EntityName<Target> | EntityName[], mappedByOrOptions?: (string & keyof Target) | ((e: Target) => any) | Partial<OneToOneOptions<Owner, Target>>, options?: Partial<OneToOneOptions<Owner, Target>>): (target: Owner, propertyName: string) => void;
-export declare function OneToOne<Target, Owner>(entity?: OneToOneOptions<Owner, Target>): (target: Owner, propertyName: string) => void;
+/** Defines a one-to-one relationship (legacy TypeScript decorator). */
+export declare function OneToOne<Target, Owner>(
+  entity: (e: Owner) => EntityName<Target> | EntityName[],
+  mappedByOrOptions?: (string & keyof Target) | ((e: Target) => any) | Partial<OneToOneOptions<Owner, Target>>,
+  options?: Partial<OneToOneOptions<Owner, Target>>,
+): (target: Owner, propertyName: string) => void;
+export declare function OneToOne<Target, Owner>(
+  entity?: OneToOneOptions<Owner, Target>,
+): (target: Owner, propertyName: string) => void;

package/legacy/OneToOne.js

@@ -1,13 +1,13 @@
-import { ReferenceKind, } from '@mikro-orm/core';
+import { ReferenceKind } from '@mikro-orm/core';
 import { processDecoratorParameters, validateSingleDecorator, getMetadataFromDecorator } from '../utils.js';
 export function OneToOne(entity, mappedByOrOptions, options = {}) {
-    const mappedBy = typeof mappedByOrOptions === 'object' ? mappedByOrOptions.mappedBy : mappedByOrOptions;
-    options = typeof mappedByOrOptions === 'object' ? { ...mappedByOrOptions, ...options } : options;
-    return function (target, propertyName) {
-        options = processDecoratorParameters({ entity, mappedBy, options });
-        const meta = getMetadataFromDecorator(target.constructor);
-        validateSingleDecorator(meta, propertyName, ReferenceKind.ONE_TO_ONE);
-        const property = { name: propertyName, kind: ReferenceKind.ONE_TO_ONE };
-        meta.properties[propertyName] = Object.assign(meta.properties[propertyName] ?? {}, property, options);
-    };
+  const mappedBy = typeof mappedByOrOptions === 'object' ? mappedByOrOptions.mappedBy : mappedByOrOptions;
+  options = typeof mappedByOrOptions === 'object' ? { ...mappedByOrOptions, ...options } : options;
+  return function (target, propertyName) {
+    options = processDecoratorParameters({ entity, mappedBy, options });
+    const meta = getMetadataFromDecorator(target.constructor);
+    validateSingleDecorator(meta, propertyName, ReferenceKind.ONE_TO_ONE);
+    const property = { name: propertyName, kind: ReferenceKind.ONE_TO_ONE };
+    meta.properties[propertyName] = Object.assign(meta.properties[propertyName] ?? {}, property, options);
+  };
 }

package/legacy/PrimaryKey.d.ts

@@ -1,3 +1,9 @@
 import { type PrimaryKeyOptions, type SerializedPrimaryKeyOptions } from '@mikro-orm/core';
-export declare function PrimaryKey<T extends object>(options?: PrimaryKeyOptions<T>): (target: T, propertyName: string) => void;
-export declare function SerializedPrimaryKey<T extends object>(options?: SerializedPrimaryKeyOptions<T>): (target: T, propertyName: string) => void;
+/** Marks a property as the primary key of an entity (legacy TypeScript decorator). */
+export declare function PrimaryKey<T extends object>(
+  options?: PrimaryKeyOptions<T>,
+): (target: T, propertyName: string) => void;
+/** Marks a property as the serialized form of the primary key, e.g. for MongoDB ObjectId (legacy TypeScript decorator). */
+export declare function SerializedPrimaryKey<T extends object>(
+  options?: SerializedPrimaryKeyOptions<T>,
+): (target: T, propertyName: string) => void;

package/legacy/PrimaryKey.js

@@ -1,21 +1,23 @@
-import { ReferenceKind, } from '@mikro-orm/core';
+import { ReferenceKind } from '@mikro-orm/core';
 import { validateSingleDecorator, getMetadataFromDecorator } from '../utils.js';
 function createDecorator(options, serialized) {
-    return function (target, propertyName) {
-        const meta = getMetadataFromDecorator(target.constructor);
-        validateSingleDecorator(meta, propertyName, ReferenceKind.SCALAR);
-        const k = serialized ? 'serializedPrimaryKey' : 'primary';
-        options[k] = true;
-        meta.properties[propertyName] = {
-            name: propertyName,
-            kind: ReferenceKind.SCALAR,
-            ...options,
-        };
+  return function (target, propertyName) {
+    const meta = getMetadataFromDecorator(target.constructor);
+    validateSingleDecorator(meta, propertyName, ReferenceKind.SCALAR);
+    const k = serialized ? 'serializedPrimaryKey' : 'primary';
+    options[k] = true;
+    meta.properties[propertyName] = {
+      name: propertyName,
+      kind: ReferenceKind.SCALAR,
+      ...options,
     };
+  };
 }
+/** Marks a property as the primary key of an entity (legacy TypeScript decorator). */
 export function PrimaryKey(options = {}) {
-    return createDecorator(options, false);
+  return createDecorator(options, false);
 }
+/** Marks a property as the serialized form of the primary key, e.g. for MongoDB ObjectId (legacy TypeScript decorator). */
 export function SerializedPrimaryKey(options = {}) {
-    return createDecorator(options, true);
+  return createDecorator(options, true);
 }

package/legacy/Property.d.ts

@@ -1,2 +1,5 @@
 import { type PropertyOptions } from '@mikro-orm/core';
-export declare function Property<T extends object>(options?: PropertyOptions<T>): (target: T, propertyName: string) => void;
+/** Defines a scalar property on an entity (legacy TypeScript decorator). */
+export declare function Property<T extends object>(
+  options?: PropertyOptions<T>,
+): (target: T, propertyName: string) => void;