@mikro-orm/decorators 7.0.4-dev.8 → 7.0.4

package/legacy/ManyToOne.d.ts

@@ -1,5 +1,10 @@
 import { type ManyToOneOptions, type EntityName } from '@mikro-orm/core';
 /** 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: (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,4 +1,10 @@
 import { type EntityName, type OneToManyOptions } from '@mikro-orm/core';
 /** 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;
+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,4 +1,10 @@
 import { type EntityName, type OneToOneOptions } from '@mikro-orm/core';
 /** 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;
+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,5 +1,9 @@
 import { type PrimaryKeyOptions, type SerializedPrimaryKeyOptions } from '@mikro-orm/core';
 /** 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;
+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;
+export declare function SerializedPrimaryKey<T extends object>(
+  options?: SerializedPrimaryKeyOptions<T>,
+): (target: T, propertyName: string) => void;

package/legacy/PrimaryKey.js

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

package/legacy/Property.js

@@ -2,29 +2,29 @@ import { Utils, ReferenceKind } from '@mikro-orm/core';
 import { validateSingleDecorator, getMetadataFromDecorator } from '../utils.js';
 /** Defines a scalar property on an entity (legacy TypeScript decorator). */
 export function Property(options = {}) {
-    return function (target, propertyName) {
-        const meta = getMetadataFromDecorator(target.constructor);
-        const desc = Object.getOwnPropertyDescriptor(target, propertyName) || {};
-        validateSingleDecorator(meta, propertyName, ReferenceKind.SCALAR);
-        const name = options.name || propertyName;
-        if (propertyName !== name && !(desc.value instanceof Function)) {
-            Utils.renameKey(options, 'name', 'fieldName');
-        }
-        options.name = propertyName;
-        const { check, ...opts } = options;
-        const prop = { kind: ReferenceKind.SCALAR, ...opts };
-        prop.getter = !!desc.get;
-        prop.setter = !!desc.set;
-        if (desc.value instanceof Function) {
-            prop.getter = true;
-            prop.persist = false;
-            prop.type = 'method';
-            prop.getterName = propertyName;
-            prop.name = name;
-        }
-        if (check) {
-            meta.checks.push({ property: prop.name, expression: check });
-        }
-        meta.properties[prop.name] = prop;
-    };
+  return function (target, propertyName) {
+    const meta = getMetadataFromDecorator(target.constructor);
+    const desc = Object.getOwnPropertyDescriptor(target, propertyName) || {};
+    validateSingleDecorator(meta, propertyName, ReferenceKind.SCALAR);
+    const name = options.name || propertyName;
+    if (propertyName !== name && !(desc.value instanceof Function)) {
+      Utils.renameKey(options, 'name', 'fieldName');
+    }
+    options.name = propertyName;
+    const { check, ...opts } = options;
+    const prop = { kind: ReferenceKind.SCALAR, ...opts };
+    prop.getter = !!desc.get;
+    prop.setter = !!desc.set;
+    if (desc.value instanceof Function) {
+      prop.getter = true;
+      prop.persist = false;
+      prop.type = 'method';
+      prop.getterName = propertyName;
+      prop.name = name;
+    }
+    if (check) {
+      meta.checks.push({ property: prop.name, expression: check });
+    }
+    meta.properties[prop.name] = prop;
+  };
 }

package/legacy/ReflectMetadataProvider.d.ts

@@ -2,6 +2,6 @@ import 'reflect-metadata';
 import { type EntityMetadata, type EntityProperty, MetadataProvider } from '@mikro-orm/core';
 /** Metadata provider that uses `reflect-metadata` to infer property types from TypeScript's emitted design:type metadata. */
 export declare class ReflectMetadataProvider extends MetadataProvider {
-    loadEntityMetadata(meta: EntityMetadata): void;
-    protected initPropertyType(meta: EntityMetadata, prop: EntityProperty): void;
+  loadEntityMetadata(meta: EntityMetadata): void;
+  protected initPropertyType(meta: EntityMetadata, prop: EntityProperty): void;
 }

package/legacy/ReflectMetadataProvider.js

@@ -1,50 +1,54 @@
 import 'reflect-metadata';
-import { EntitySchema, MetadataProvider, ReferenceKind, Utils, } from '@mikro-orm/core';
+import { EntitySchema, MetadataProvider, ReferenceKind, Utils } from '@mikro-orm/core';
 /** Metadata provider that uses `reflect-metadata` to infer property types from TypeScript's emitted design:type metadata. */
 export class ReflectMetadataProvider extends MetadataProvider {
-    loadEntityMetadata(meta) {
-        // load types and column names
-        for (const prop of meta.props) {
-            /* v8 ignore next */
-            if (typeof prop.entity === 'string') {
-                throw new Error(`Relation target needs to be an entity class or EntitySchema instance, '${prop.entity}' given instead for ${meta.className}.${prop.name}.`);
-            }
-            else if (prop.entity) {
-                const tmp = prop.entity();
-                prop.type = Array.isArray(tmp)
-                    ? tmp
-                        .map(t => Utils.className(t))
-                        .sort()
-                        .join(' | ')
-                    : Utils.className(tmp);
-                prop.target = EntitySchema.is(tmp) ? tmp.meta.class : tmp;
-            }
-            else {
-                this.initPropertyType(meta, prop);
-            }
-        }
+  loadEntityMetadata(meta) {
+    // load types and column names
+    for (const prop of meta.props) {
+      /* v8 ignore next */
+      if (typeof prop.entity === 'string') {
+        throw new Error(
+          `Relation target needs to be an entity class or EntitySchema instance, '${prop.entity}' given instead for ${meta.className}.${prop.name}.`,
+        );
+      } else if (prop.entity) {
+        const tmp = prop.entity();
+        prop.type = Array.isArray(tmp)
+          ? tmp
+              .map(t => Utils.className(t))
+              .sort()
+              .join(' | ')
+          : Utils.className(tmp);
+        prop.target = EntitySchema.is(tmp) ? tmp.meta.class : tmp;
+      } else {
+        this.initPropertyType(meta, prop);
+      }
     }
-    initPropertyType(meta, prop) {
-        const type = Reflect.getMetadata('design:type', meta.prototype, prop.name);
-        if (!prop.type &&
-            (!type || (type === Object && prop.kind !== ReferenceKind.SCALAR)) &&
-            !(prop.enum && (prop.items?.length ?? 0) > 0)) {
-            throw new Error(`Please provide either 'type' or 'entity' attribute in ${meta.className}.${prop.name}. Make sure you have 'emitDecoratorMetadata' enabled in your tsconfig.json.`);
-        }
-        // Force mapping to UnknownType which is a string when we see just `Object`, as that often means failed inference.
-        // This is to prevent defaulting to JSON column type, which can often be hard to revert and cause hard to understand issues with PKs.
-        // If there are explicitly provided `columnTypes`, we use those instead for the inference, this way
-        // we can have things like `columnType: 'timestamp'` be respected as `type: 'Date'`.
-        if (prop.kind === ReferenceKind.SCALAR && type === Object && !prop.columnTypes) {
-            prop.type ??= 'any';
-            return;
-        }
-        let typeName = type?.name;
-        if (typeName && ['string', 'number', 'boolean', 'array', 'object'].includes(typeName.toLowerCase())) {
-            typeName = typeName.toLowerCase();
-        }
-        prop.type ??= typeName;
-        prop.runtimeType ??= typeName;
-        prop.target = type;
+  }
+  initPropertyType(meta, prop) {
+    const type = Reflect.getMetadata('design:type', meta.prototype, prop.name);
+    if (
+      !prop.type &&
+      (!type || (type === Object && prop.kind !== ReferenceKind.SCALAR)) &&
+      !(prop.enum && (prop.items?.length ?? 0) > 0)
+    ) {
+      throw new Error(
+        `Please provide either 'type' or 'entity' attribute in ${meta.className}.${prop.name}. Make sure you have 'emitDecoratorMetadata' enabled in your tsconfig.json.`,
+      );
     }
+    // Force mapping to UnknownType which is a string when we see just `Object`, as that often means failed inference.
+    // This is to prevent defaulting to JSON column type, which can often be hard to revert and cause hard to understand issues with PKs.
+    // If there are explicitly provided `columnTypes`, we use those instead for the inference, this way
+    // we can have things like `columnType: 'timestamp'` be respected as `type: 'Date'`.
+    if (prop.kind === ReferenceKind.SCALAR && type === Object && !prop.columnTypes) {
+      prop.type ??= 'any';
+      return;
+    }
+    let typeName = type?.name;
+    if (typeName && ['string', 'number', 'boolean', 'array', 'object'].includes(typeName.toLowerCase())) {
+      typeName = typeName.toLowerCase();
+    }
+    prop.type ??= typeName;
+    prop.runtimeType ??= typeName;
+    prop.target = type;
+  }
 }

package/legacy/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()`.

package/legacy/Transactional.js

@@ -8,22 +8,25 @@ 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 (target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        if (originalMethod.constructor.name !== 'AsyncFunction') {
-            throw new Error('@Transactional() should be use with async functions');
-        }
-        descriptor.value = 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(() => originalMethod.apply(this, args), txOptions);
-        };
-        return descriptor;
+  return function (target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    if (originalMethod.constructor.name !== 'AsyncFunction') {
+      throw new Error('@Transactional() should be use with async functions');
+    }
+    descriptor.value = 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(() => originalMethod.apply(this, args), txOptions);
     };
+    return descriptor;
+  };
 }

package/legacy/hooks.js

@@ -1,53 +1,53 @@
 import { EventType } from '@mikro-orm/core';
 import { getMetadataFromDecorator } from '../utils.js';
 function hook(type) {
-    return function (target, method) {
-        const meta = getMetadataFromDecorator(target.constructor);
-        meta.hooks[type] ??= [];
-        meta.hooks[type].push(method);
-    };
+  return function (target, method) {
+    const meta = getMetadataFromDecorator(target.constructor);
+    meta.hooks[type] ??= [];
+    meta.hooks[type].push(method);
+  };
 }
 /** Called before a new entity is persisted to the database (legacy TypeScript decorator). */
 export function BeforeCreate() {
-    return hook(EventType.beforeCreate);
+  return hook(EventType.beforeCreate);
 }
 /** Called after a new entity has been persisted to the database (legacy TypeScript decorator). */
 export function AfterCreate() {
-    return hook(EventType.afterCreate);
+  return hook(EventType.afterCreate);
 }
 /** Called before an existing entity is updated in the database (legacy TypeScript decorator). */
 export function BeforeUpdate() {
-    return hook(EventType.beforeUpdate);
+  return hook(EventType.beforeUpdate);
 }
 /** Called after an existing entity has been updated in the database (legacy TypeScript decorator). */
 export function AfterUpdate() {
-    return hook(EventType.afterUpdate);
+  return hook(EventType.afterUpdate);
 }
 /** Called before an entity is upserted (legacy TypeScript decorator). */
 export function BeforeUpsert() {
-    return hook(EventType.beforeUpsert);
+  return hook(EventType.beforeUpsert);
 }
 /** Called after an entity has been upserted (legacy TypeScript decorator). */
 export function AfterUpsert() {
-    return hook(EventType.afterUpsert);
+  return hook(EventType.afterUpsert);
 }
 /** Called when an entity is instantiated by the EntityManager (legacy TypeScript decorator). */
 export function OnInit() {
-    return hook(EventType.onInit);
+  return hook(EventType.onInit);
 }
 /** Called after an entity is loaded from the database (legacy TypeScript 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/decorators",
-  "version": "7.0.4-dev.8",
+  "version": "7.0.4",
   "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",
@@ -49,10 +49,10 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.0.3"
+    "@mikro-orm/core": "^7.0.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.4-dev.8",
+    "@mikro-orm/core": "7.0.4",
     "reflect-metadata": "^0.1.0 || ^0.2.0"
   },
   "peerDependenciesMeta": {

package/utils.d.ts

@@ -1,17 +1,36 @@
-import { type Dictionary, EntityManager, type EntityMetadata, EntityRepository, type MaybePromise, MetadataStorage, MikroORM, type ReferenceKind } from '@mikro-orm/core';
+import {
+  type Dictionary,
+  EntityManager,
+  type EntityMetadata,
+  EntityRepository,
+  type MaybePromise,
+  MetadataStorage,
+  MikroORM,
+  type ReferenceKind,
+} from '@mikro-orm/core';
 /**
  * The type of context that the user intends to inject.
  */
-export type ContextProvider<T> = MaybePromise<MikroORM> | ((type: T) => MaybePromise<MikroORM | EntityManager | EntityRepository<any> | {
-    getEntityManager(): EntityManager;
-}>);
+export type ContextProvider<T> =
+  | MaybePromise<MikroORM>
+  | ((type: T) => MaybePromise<
+      | MikroORM
+      | EntityManager
+      | EntityRepository<any>
+      | {
+          getEntityManager(): EntityManager;
+        }
+    >);
 /**
  * Find `EntityManager` in provided context, or else in instance's `orm` or `em` properties.
  */
-export declare function resolveContextProvider<T>(caller: T & {
+export declare function resolveContextProvider<T>(
+  caller: T & {
     orm?: MaybePromise<MikroORM>;
     em?: MaybePromise<EntityManager>;
-}, provider?: ContextProvider<T>): Promise<EntityManager | undefined>;
+  },
+  provider?: ContextProvider<T>,
+): Promise<EntityManager | undefined>;
 /**
  * Relation decorators allow using two signatures
  * - using first parameter as options object
@@ -33,13 +52,24 @@ export declare function validateSingleDecorator(meta: EntityMetadata, propertyNa
  * We need to use the `Object.hasOwn` here, since the metadata object respects inheritance, and the `properties` object might already
  * exist for some base entity.
  */
-export declare function prepareMetadataContext<T>(context: ClassFieldDecoratorContext<T> | ClassGetterDecoratorContext<T> | ClassSetterDecoratorContext<T> | ClassAccessorDecoratorContext<T> | ClassMethodDecoratorContext<T>, kind?: ReferenceKind): EntityMetadata<T>;
+export declare function prepareMetadataContext<T>(
+  context:
+    | ClassFieldDecoratorContext<T>
+    | ClassGetterDecoratorContext<T>
+    | ClassSetterDecoratorContext<T>
+    | ClassAccessorDecoratorContext<T>
+    | ClassMethodDecoratorContext<T>,
+  kind?: ReferenceKind,
+): EntityMetadata<T>;
 /**
  * Uses some dark magic to get source path to caller where decorator is used.
  * Analyzes stack trace of error created inside the function call.
  */
 export declare function lookupPathFromDecorator(name: string, stack?: string[]): string;
 /** Retrieves or creates the metadata object for a decorated entity class. */
-export declare function getMetadataFromDecorator<T = any>(target: T & Dictionary & {
-    [MetadataStorage.PATH_SYMBOL]?: string;
-}): EntityMetadata<T>;
+export declare function getMetadataFromDecorator<T = any>(
+  target: T &
+    Dictionary & {
+      [MetadataStorage.PATH_SYMBOL]?: string;
+    },
+): EntityMetadata<T>;