@mikro-orm/decorators 7.0.4 → 7.0.5-dev.1

package/es/Property.js

@@ -2,41 +2,45 @@ import { ReferenceKind, Utils } from '@mikro-orm/core';
 import { prepareMetadataContext } from '../utils.js';
 /** Defines a scalar property on an entity (TC39 decorator). */
 export function Property(options = {}) {
-  return function (value, context) {
-    const meta = prepareMetadataContext(context, ReferenceKind.SCALAR);
-    const { check, ...opts } = options;
-    const prop = { kind: ReferenceKind.SCALAR, ...opts };
-    const name = options.name ?? context.name;
-    meta.checks ??= [];
-    if (context.name !== name) {
-      Utils.renameKey(options, 'name', 'fieldName');
-    }
-    if (context.kind === 'field') {
-      prop.name = context.name;
-      prop.getter = false;
-      prop.setter = false;
-    } else if (context.kind === 'getter') {
-      prop.name = context.name;
-      prop.getter = true;
-      prop.setter = false;
-    } else if (context.kind === 'setter') {
-      prop.name = context.name;
-      prop.getter = false;
-      prop.setter = true;
-    } else if (context.kind === 'accessor') {
-      prop.name = context.name;
-      prop.getter = true;
-      prop.setter = true;
-    } else if (context.kind === 'method') {
-      prop.getter = true;
-      prop.persist = false;
-      prop.type = 'method';
-      prop.getterName = context.name;
-      prop.name = name;
-    }
-    if (check) {
-      meta.checks.push({ property: prop.name, expression: check });
-    }
-    meta.properties[prop.name] = prop;
-  };
+    return function (value, context) {
+        const meta = prepareMetadataContext(context, ReferenceKind.SCALAR);
+        const { check, ...opts } = options;
+        const prop = { kind: ReferenceKind.SCALAR, ...opts };
+        const name = options.name ?? context.name;
+        meta.checks ??= [];
+        if (context.name !== name) {
+            Utils.renameKey(options, 'name', 'fieldName');
+        }
+        if (context.kind === 'field') {
+            prop.name = context.name;
+            prop.getter = false;
+            prop.setter = false;
+        }
+        else if (context.kind === 'getter') {
+            prop.name = context.name;
+            prop.getter = true;
+            prop.setter = false;
+        }
+        else if (context.kind === 'setter') {
+            prop.name = context.name;
+            prop.getter = false;
+            prop.setter = true;
+        }
+        else if (context.kind === 'accessor') {
+            prop.name = context.name;
+            prop.getter = true;
+            prop.setter = true;
+        }
+        else if (context.kind === 'method') {
+            prop.getter = true;
+            prop.persist = false;
+            prop.type = 'method';
+            prop.getterName = context.name;
+            prop.name = name;
+        }
+        if (check) {
+            meta.checks.push({ property: prop.name, expression: check });
+        }
+        meta.properties[prop.name] = prop;
+    };
 }

package/es/Transactional.d.ts

@@ -1,8 +1,8 @@
 import { type TransactionOptions } from '@mikro-orm/core';
 import { type ContextProvider } from '../utils.js';
 type TransactionalOptions<T> = TransactionOptions & {
-  context?: ContextProvider<T>;
-  contextName?: string;
+    context?: ContextProvider<T>;
+    contextName?: string;
 };
 /**
  * This decorator wraps the method with `em.transactional()`, so you can provide `TransactionOptions` just like with `em.transactional()`.
@@ -11,10 +11,5 @@ type TransactionalOptions<T> = TransactionOptions & {
  * It works on async functions and can be nested with `em.transactional()`.
  * Unlike `em.transactional()`, this decorator uses `REQUIRED` propagation by default, which means it will join existing transactions.
  */
-export declare function Transactional<
-  Owner extends object,
-  Value extends (this: Owner, ...args: any) => any = (this: Owner, ...args: any) => any,
->(
-  options?: TransactionalOptions<Owner>,
-): (value: Value, context: ClassMethodDecoratorContext<Owner, Value>) => (this: Owner, ...args: any) => Promise<any>;
+export declare function Transactional<Owner extends object, Value extends (this: Owner, ...args: any) => any = (this: Owner, ...args: any) => any>(options?: TransactionalOptions<Owner>): (value: Value, context: ClassMethodDecoratorContext<Owner, Value>) => (this: Owner, ...args: any) => Promise<any>;
 export {};

package/es/Transactional.js

@@ -8,23 +8,20 @@ import { resolveContextProvider } from '../utils.js';
  * Unlike `em.transactional()`, this decorator uses `REQUIRED` propagation by default, which means it will join existing transactions.
  */
 export function Transactional(options = {}) {
-  return function (value, context) {
-    if (value.constructor.name !== 'AsyncFunction') {
-      throw new Error('@Transactional() should be use with async functions');
-    }
-    return async function (...args) {
-      const { context, contextName, ...txOptions } = options;
-      txOptions.propagation ??= TransactionPropagation.REQUIRED;
-      const em =
-        (await resolveContextProvider(this, context)) ||
-        TransactionContext.getEntityManager(contextName) ||
-        RequestContext.getEntityManager(contextName);
-      if (!em) {
-        throw new Error(
-          `@Transactional() decorator can only be applied to methods of classes with \`orm: MikroORM\` property, \`em: EntityManager\` property, or with a callback parameter like \`@Transactional(() => orm)\` that returns one of those types. The parameter will contain a reference to current \`this\`. Returning an EntityRepository from it is also supported.`,
-        );
-      }
-      return em.transactional(() => value.apply(this, args), txOptions);
+    return function (value, context) {
+        if (value.constructor.name !== 'AsyncFunction') {
+            throw new Error('@Transactional() should be use with async functions');
+        }
+        return async function (...args) {
+            const { context, contextName, ...txOptions } = options;
+            txOptions.propagation ??= TransactionPropagation.REQUIRED;
+            const em = (await resolveContextProvider(this, context)) ||
+                TransactionContext.getEntityManager(contextName) ||
+                RequestContext.getEntityManager(contextName);
+            if (!em) {
+                throw new Error(`@Transactional() decorator can only be applied to methods of classes with \`orm: MikroORM\` property, \`em: EntityManager\` property, or with a callback parameter like \`@Transactional(() => orm)\` that returns one of those types. The parameter will contain a reference to current \`this\`. Returning an EntityRepository from it is also supported.`);
+            }
+            return em.transactional(() => value.apply(this, args), txOptions);
+        };
     };
-  };
 }

package/es/hooks.d.ts

@@ -1,33 +1,15 @@
 /** Called before a new entity is persisted to the database (TC39 decorator). */
-export declare function BeforeCreate(): (
-  value: (...args: any[]) => unknown,
-  context: ClassMethodDecoratorContext,
-) => void;
+export declare function BeforeCreate(): (value: (...args: any[]) => unknown, context: ClassMethodDecoratorContext) => void;
 /** Called after a new entity has been persisted to the database (TC39 decorator). */
-export declare function AfterCreate(): (
-  value: (...args: any[]) => unknown,
-  context: ClassMethodDecoratorContext,
-) => void;
+export declare function AfterCreate(): (value: (...args: any[]) => unknown, context: ClassMethodDecoratorContext) => void;
 /** Called before an existing entity is updated in the database (TC39 decorator). */
-export declare function BeforeUpdate(): (
-  value: (...args: any[]) => unknown,
-  context: ClassMethodDecoratorContext,
-) => void;
+export declare function BeforeUpdate(): (value: (...args: any[]) => unknown, context: ClassMethodDecoratorContext) => void;
 /** Called after an existing entity has been updated in the database (TC39 decorator). */
-export declare function AfterUpdate(): (
-  value: (...args: any[]) => unknown,
-  context: ClassMethodDecoratorContext,
-) => void;
+export declare function AfterUpdate(): (value: (...args: any[]) => unknown, context: ClassMethodDecoratorContext) => void;
 /** Called before an entity is upserted (TC39 decorator). */
-export declare function BeforeUpsert(): (
-  value: (...args: any[]) => unknown,
-  context: ClassMethodDecoratorContext,
-) => void;
+export declare function BeforeUpsert(): (value: (...args: any[]) => unknown, context: ClassMethodDecoratorContext) => void;
 /** Called after an entity has been upserted (TC39 decorator). */
-export declare function AfterUpsert(): (
-  value: (...args: any[]) => unknown,
-  context: ClassMethodDecoratorContext,
-) => void;
+export declare function AfterUpsert(): (value: (...args: any[]) => unknown, context: ClassMethodDecoratorContext) => void;
 /** Called when an entity is instantiated by the EntityManager (TC39 decorator). */
 export declare function OnInit(): (value: (...args: any[]) => unknown, context: ClassMethodDecoratorContext) => void;
 /** Called after an entity is loaded from the database (TC39 decorator). */
@@ -35,14 +17,8 @@ export declare function OnLoad(): (value: (...args: any[]) => unknown, context:
 /**
  * Called before deleting entity, but only when providing initialized entity to EM#remove()
  */
-export declare function BeforeDelete(): (
-  value: (...args: any[]) => unknown,
-  context: ClassMethodDecoratorContext,
-) => void;
+export declare function BeforeDelete(): (value: (...args: any[]) => unknown, context: ClassMethodDecoratorContext) => void;
 /**
  * Called after deleting entity, but only when providing initialized entity to EM#remove()
  */
-export declare function AfterDelete(): (
-  value: (...args: any[]) => unknown,
-  context: ClassMethodDecoratorContext,
-) => void;
+export declare function AfterDelete(): (value: (...args: any[]) => unknown, context: ClassMethodDecoratorContext) => void;

package/es/hooks.js

@@ -1,53 +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,5 +1,3 @@
 import { type CheckConstraint, type EntityClass } from '@mikro-orm/core';
 /** 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;
+export declare function Check<T>(options: CheckConstraint<T>): (target: T, propertyName?: T extends EntityClass<unknown> ? undefined : keyof T) => any;

package/legacy/Check.js

@@ -1,13 +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,8 +1,5 @@
 import { type ContextProvider } from '../utils.js';
 /** 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;
+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

@@ -2,34 +2,32 @@ 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 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 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.js

@@ -1,12 +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,6 +1,3 @@
 import { type AnyEntity, type EntityName, type EmbeddedOptions } from '@mikro-orm/core';
 /** 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;
+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,16 +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.js

@@ -2,12 +2,12 @@ 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,5 +1,3 @@
 import { type EnumOptions, type AnyEntity, type Dictionary } from '@mikro-orm/core';
 /** 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;
+export declare function Enum<T extends object>(options?: EnumOptions<AnyEntity> | (() => Dictionary)): (target: T, propertyName: string) => void;

package/legacy/Enum.js

@@ -1,15 +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.js

@@ -1,8 +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,6 +1,3 @@
 import { type FormulaCallback, type PropertyOptions } from '@mikro-orm/core';
 /** 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;
+export declare function Formula<T extends object>(formula: string | FormulaCallback<T>, options?: PropertyOptions<T>): (target: T, propertyName: string) => void;

package/legacy/Formula.js

@@ -1,14 +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,9 +1,5 @@
 import { type EntityClass, type IndexOptions, type UniqueOptions } from '@mikro-orm/core';
 /** 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;
+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;
+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,21 +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,11 +1,5 @@
 import { type EntityName, type ManyToManyOptions } from '@mikro-orm/core';
 /** 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: () => 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);
+    };
 }