@mikro-orm/decorators 7.0.0-dev.65 → 7.0.0-dev.67

package/es/CreateRequestContext.d.ts

@@ -1,3 +1,3 @@
-import { type ContextProvider } from '../resolveContextProvider.js';
+import { type ContextProvider } from '../utils.js';
 export declare function CreateRequestContext<T extends object>(contextProvider?: ContextProvider<T>, respectExistingContext?: boolean): (value: (this: T, ...args: any) => any, context: ClassMethodDecoratorContext<T>) => (this: T, ...args: any[]) => Promise<any>;
 export declare function EnsureRequestContext<T extends object>(context?: ContextProvider<T>): (value: (this: T, ...args: any) => any, context: ClassMethodDecoratorContext<T, (this: T, ...args: any) => any>) => (this: T, ...args: any[]) => Promise<any>;

package/es/CreateRequestContext.js

@@ -1,5 +1,5 @@
 import { RequestContext, TransactionContext } from '@mikro-orm/core';
-import { resolveContextProvider } from '../resolveContextProvider.js';
+import { resolveContextProvider } from '../utils.js';
 export function CreateRequestContext(contextProvider, respectExistingContext = false) {
     return function (value, context) {
         const name = respectExistingContext ? 'EnsureRequestContext' : 'CreateRequestContext';

package/es/Embeddable.js

@@ -1,7 +1,8 @@
-import { MetadataStorage, Utils, } from '@mikro-orm/core';
+import { Utils, } from '@mikro-orm/core';
+import { getMetadataFromDecorator } from '../utils.js';
 export function Embeddable(options = {}) {
     return function (target, context) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target);
+        const meta = getMetadataFromDecorator(target);
         Utils.mergeConfig(meta, context.metadata, options);
         meta.class = target;
         meta.name = meta.class.name;

package/es/Embedded.js

@@ -1,9 +1,10 @@
-import { MetadataValidator, ReferenceKind, Utils, } from '@mikro-orm/core';
+import { ReferenceKind, Utils, } from '@mikro-orm/core';
+import { validateSingleDecorator } from '../utils.js';
 export function Embedded(type = {}, options = {}) {
     return function (value, context) {
         const meta = context.metadata;
         meta.properties ??= {};
-        MetadataValidator.validateSingleDecorator(meta, context.name, ReferenceKind.EMBEDDED);
+        validateSingleDecorator(meta, context.name, ReferenceKind.EMBEDDED);
         options = type instanceof Function ? { entity: type, ...options } : { ...type, ...options };
         Utils.defaultValue(options, 'prefix', true);
         meta.properties[context.name] = {

package/es/Entity.js

@@ -1,7 +1,8 @@
-import { MetadataStorage, Utils, } from '@mikro-orm/core';
+import { Utils, } from '@mikro-orm/core';
+import { getMetadataFromDecorator } from '../utils.js';
 export function Entity(options = {}) {
     return function (target, context) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target);
+        const meta = getMetadataFromDecorator(target);
         Utils.mergeConfig(meta, context.metadata, options);
         meta.class = target;
         if (!options.abstract || meta.discriminatorColumn) {

package/es/Filter.js

@@ -1,7 +1,7 @@
-import { MetadataStorage } from '@mikro-orm/core';
+import { getMetadataFromDecorator } from '../utils.js';
 export function Filter(options) {
     return function (target) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target);
+        const meta = getMetadataFromDecorator(target);
         meta.filters[options.name] = options;
     };
 }

package/es/ManyToMany.js

@@ -1,10 +1,11 @@
-import { MetadataValidator, ReferenceKind, Utils, } from '@mikro-orm/core';
+import { ReferenceKind, Utils, } from '@mikro-orm/core';
+import { processDecoratorParameters, validateSingleDecorator } from '../utils.js';
 export function ManyToMany(entity, mappedBy, options = {}) {
     return function (_, context) {
         const meta = context.metadata;
         meta.properties ??= {};
-        MetadataValidator.validateSingleDecorator(meta, context.name, ReferenceKind.MANY_TO_MANY);
-        options = Utils.processDecoratorParameters({ entity, mappedBy, options });
+        validateSingleDecorator(meta, context.name, ReferenceKind.MANY_TO_MANY);
+        options = processDecoratorParameters({ entity, mappedBy, options });
         const property = { name: context.name, kind: ReferenceKind.MANY_TO_MANY };
         meta.properties[context.name] ??= {};
         Utils.mergeConfig(meta.properties[context.name], property, options);

package/es/ManyToOne.js

@@ -1,10 +1,11 @@
-import { ReferenceKind, MetadataValidator, Utils, } from '@mikro-orm/core';
+import { ReferenceKind, Utils, } from '@mikro-orm/core';
+import { processDecoratorParameters, validateSingleDecorator } from '../utils.js';
 export function ManyToOne(entity = {}, options = {}) {
     return function (_, context) {
         const meta = context.metadata;
         meta.properties ??= {};
-        MetadataValidator.validateSingleDecorator(meta, context.name, ReferenceKind.MANY_TO_ONE);
-        options = Utils.processDecoratorParameters({ entity, options });
+        validateSingleDecorator(meta, context.name, ReferenceKind.MANY_TO_ONE);
+        options = processDecoratorParameters({ entity, options });
         const property = { name: context.name, kind: ReferenceKind.MANY_TO_ONE };
         meta.properties[context.name] = Utils.mergeConfig(meta.properties[context.name] ?? {}, property, options);
     };

package/es/OneToMany.js

@@ -1,10 +1,11 @@
-import { MetadataValidator, ReferenceKind, Utils, } from '@mikro-orm/core';
+import { ReferenceKind, Utils, } from '@mikro-orm/core';
+import { processDecoratorParameters, validateSingleDecorator } from '../utils.js';
 export function OneToMany(entity, mappedBy, options = {}) {
     return function (value, context) {
         const meta = context.metadata;
         meta.properties ??= {};
-        MetadataValidator.validateSingleDecorator(meta, context.name, ReferenceKind.ONE_TO_MANY);
-        options = Utils.processDecoratorParameters({ entity, mappedBy, options });
+        validateSingleDecorator(meta, context.name, ReferenceKind.ONE_TO_MANY);
+        options = processDecoratorParameters({ entity, mappedBy, options });
         const property = { name: context.name, kind: ReferenceKind.ONE_TO_MANY };
         meta.properties[context.name] ??= {};
         Utils.mergeConfig(meta.properties[context.name], property, options);

package/es/OneToOne.js

@@ -1,12 +1,13 @@
-import { MetadataValidator, ReferenceKind, Utils, } from '@mikro-orm/core';
+import { ReferenceKind, } from '@mikro-orm/core';
+import { processDecoratorParameters, validateSingleDecorator } 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 (_, context) {
         const meta = context.metadata;
         meta.properties ??= {};
-        MetadataValidator.validateSingleDecorator(meta, context.name, ReferenceKind.ONE_TO_ONE);
-        options = Utils.processDecoratorParameters({ entity, mappedBy, options });
+        validateSingleDecorator(meta, context.name, ReferenceKind.ONE_TO_ONE);
+        options = processDecoratorParameters({ entity, mappedBy, options });
         const property = { name: context.name, kind: ReferenceKind.ONE_TO_ONE };
         meta.properties[context.name] = Object.assign(meta.properties[context.name] ?? {}, property, options);
     };

package/es/PrimaryKey.js

@@ -1,9 +1,10 @@
-import { ReferenceKind, MetadataValidator, } from '@mikro-orm/core';
+import { ReferenceKind, } from '@mikro-orm/core';
+import { validateSingleDecorator } from '../utils.js';
 function createDecorator(options, serialized) {
     return function (value, context) {
         const meta = context.metadata;
         meta.properties ??= {};
-        MetadataValidator.validateSingleDecorator(meta, context.name, ReferenceKind.SCALAR);
+        validateSingleDecorator(meta, context.name, ReferenceKind.SCALAR);
         const key = serialized ? 'serializedPrimaryKey' : 'primary';
         options[key] = true;
         meta.properties[context.name] = { name: context.name, kind: ReferenceKind.SCALAR, ...options };

package/es/Property.js

@@ -1,9 +1,10 @@
-import { MetadataValidator, ReferenceKind, Utils, } from '@mikro-orm/core';
+import { ReferenceKind, Utils, } from '@mikro-orm/core';
+import { validateSingleDecorator } from '../utils.js';
 export function Property(options = {}) {
     return function (value, context) {
         const meta = context.metadata;
         meta.properties ??= {};
-        MetadataValidator.validateSingleDecorator(meta, context.name, ReferenceKind.SCALAR);
+        validateSingleDecorator(meta, context.name, ReferenceKind.SCALAR);
         const { check, ...opts } = options;
         const prop = { kind: ReferenceKind.SCALAR, ...opts };
         const name = options.name ?? context.name;

package/es/Transactional.d.ts

@@ -1,5 +1,5 @@
 import { type TransactionOptions } from '@mikro-orm/core';
-import { type ContextProvider } from '../resolveContextProvider.js';
+import { type ContextProvider } from '../utils.js';
 type TransactionalOptions<T> = TransactionOptions & {
     context?: ContextProvider<T>;
     contextName?: string;

package/es/Transactional.js

@@ -1,5 +1,5 @@
 import { RequestContext, TransactionContext, TransactionPropagation } from '@mikro-orm/core';
-import { resolveContextProvider } from '../resolveContextProvider.js';
+import { resolveContextProvider } from '../utils.js';
 /**
  * This decorator wraps the method with `em.transactional()`, so you can provide `TransactionOptions` just like with `em.transactional()`.
  * The difference is that you can specify the context in which the transaction begins by providing `context` option,

package/legacy/Check.js

@@ -1,7 +1,7 @@
-import { MetadataStorage } from '@mikro-orm/core';
+import { getMetadataFromDecorator } from '../utils.js';
 export function Check(options) {
     return function (target, propertyName) {
-        const meta = MetadataStorage.getMetadataFromDecorator((propertyName ? target.constructor : target));
+        const meta = getMetadataFromDecorator((propertyName ? target.constructor : target));
         options.property ??= propertyName;
         meta.checks.push(options);
         if (!propertyName) {

package/legacy/CreateRequestContext.d.ts

@@ -1,3 +1,3 @@
-import { type ContextProvider } from '../resolveContextProvider.js';
+import { type ContextProvider } from '../utils.js';
 export declare function CreateRequestContext<T extends object>(context?: ContextProvider<T>, respectExistingContext?: boolean): MethodDecorator;
 export declare function EnsureRequestContext<T extends object>(context?: ContextProvider<T>): MethodDecorator;

package/legacy/CreateRequestContext.js

@@ -1,5 +1,5 @@
 import { RequestContext, TransactionContext } from '@mikro-orm/core';
-import { resolveContextProvider } from '../resolveContextProvider.js';
+import { resolveContextProvider } from '../utils.js';
 export function CreateRequestContext(context, respectExistingContext = false) {
     return function (target, propertyKey, descriptor) {
         const originalMethod = descriptor.value;

package/legacy/Embeddable.js

@@ -1,7 +1,7 @@
-import { MetadataStorage } from '@mikro-orm/core';
+import { getMetadataFromDecorator } from '../utils.js';
 export function Embeddable(options = {}) {
     return function (target) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target);
+        const meta = getMetadataFromDecorator(target);
         meta.class = target;
         meta.name = meta.class.name;
         meta.embeddable = true;

package/legacy/Embedded.js

@@ -1,8 +1,9 @@
-import { MetadataValidator, MetadataStorage, ReferenceKind, Utils, } from '@mikro-orm/core';
+import { ReferenceKind, Utils, } from '@mikro-orm/core';
+import { validateSingleDecorator, getMetadataFromDecorator } from '../utils.js';
 export function Embedded(type = {}, options = {}) {
     return function (target, propertyName) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
-        MetadataValidator.validateSingleDecorator(meta, propertyName, ReferenceKind.EMBEDDED);
+        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] = {

package/legacy/Entity.js

@@ -1,7 +1,8 @@
-import { MetadataStorage, Utils } from '@mikro-orm/core';
+import { Utils } from '@mikro-orm/core';
+import { getMetadataFromDecorator } from '../utils.js';
 export function Entity(options = {}) {
     return function (target) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target);
+        const meta = getMetadataFromDecorator(target);
         Utils.mergeConfig(meta, options);
         meta.class = target;
         if (!options.abstract || meta.discriminatorColumn) {

package/legacy/Enum.js

@@ -1,7 +1,8 @@
-import { MetadataStorage, ReferenceKind, } from '@mikro-orm/core';
+import { ReferenceKind, } from '@mikro-orm/core';
+import { getMetadataFromDecorator } from '../utils.js';
 export function Enum(options = {}) {
     return function (target, propertyName) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
+        const meta = getMetadataFromDecorator(target.constructor);
         options = options instanceof Function ? { items: options } : options;
         meta.properties[propertyName] = {
             name: propertyName,

package/legacy/Filter.js

@@ -1,7 +1,7 @@
-import { MetadataStorage } from '@mikro-orm/core';
+import { getMetadataFromDecorator } from '../utils.js';
 export function Filter(options) {
     return function (target) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target);
+        const meta = getMetadataFromDecorator(target);
         meta.filters[options.name] = options;
     };
 }

package/legacy/Formula.js

@@ -1,7 +1,8 @@
-import { MetadataStorage, ReferenceKind, } from '@mikro-orm/core';
+import { ReferenceKind } from '@mikro-orm/core';
+import { getMetadataFromDecorator } from '../utils.js';
 export function Formula(formula, options = {}) {
     return function (target, propertyName) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
+        const meta = getMetadataFromDecorator(target.constructor);
         meta.properties[propertyName] = {
             name: propertyName,
             kind: ReferenceKind.SCALAR,

package/legacy/Indexed.js

@@ -1,7 +1,7 @@
-import { MetadataStorage } from '@mikro-orm/core';
+import { getMetadataFromDecorator } from '../utils.js';
 function createDecorator(options, unique) {
     return function (target, propertyName) {
-        const meta = MetadataStorage.getMetadataFromDecorator(propertyName ? target.constructor : target);
+        const meta = getMetadataFromDecorator(propertyName ? target.constructor : target);
         options.properties ??= propertyName;
         const key = unique ? 'uniques' : 'indexes';
         meta[key].push(options);

package/legacy/ManyToMany.js

@@ -1,9 +1,10 @@
-import { MetadataStorage, MetadataValidator, ReferenceKind, Utils, } 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 = Utils.processDecoratorParameters({ entity, mappedBy, options });
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
-        MetadataValidator.validateSingleDecorator(meta, propertyName, ReferenceKind.MANY_TO_MANY);
+        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.js

@@ -1,9 +1,10 @@
-import { ReferenceKind, MetadataStorage, MetadataValidator, Utils, } 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 = Utils.processDecoratorParameters({ entity, options });
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
-        MetadataValidator.validateSingleDecorator(meta, propertyName, ReferenceKind.MANY_TO_ONE);
+        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.js

@@ -1,9 +1,10 @@
-import { MetadataStorage, MetadataValidator, ReferenceKind, Utils, } 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 = Utils.processDecoratorParameters({ entity, mappedBy, options });
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
-        MetadataValidator.validateSingleDecorator(meta, propertyName, ReferenceKind.ONE_TO_MANY);
+        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.js

@@ -1,11 +1,12 @@
-import { MetadataStorage, MetadataValidator, ReferenceKind, Utils, } 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 = Utils.processDecoratorParameters({ entity, mappedBy, options });
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
-        MetadataValidator.validateSingleDecorator(meta, propertyName, ReferenceKind.ONE_TO_ONE);
+        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.js

@@ -1,8 +1,9 @@
-import { MetadataStorage, MetadataValidator, 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 = MetadataStorage.getMetadataFromDecorator(target.constructor);
-        MetadataValidator.validateSingleDecorator(meta, propertyName, ReferenceKind.SCALAR);
+        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 };

package/legacy/Property.js

@@ -1,9 +1,10 @@
-import { MetadataStorage, MetadataValidator, Utils, ReferenceKind, } from '@mikro-orm/core';
+import { Utils, ReferenceKind, } from '@mikro-orm/core';
+import { validateSingleDecorator, getMetadataFromDecorator } from '../utils.js';
 export function Property(options = {}) {
     return function (target, propertyName) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
+        const meta = getMetadataFromDecorator(target.constructor);
         const desc = Object.getOwnPropertyDescriptor(target, propertyName) || {};
-        MetadataValidator.validateSingleDecorator(meta, propertyName, ReferenceKind.SCALAR);
+        validateSingleDecorator(meta, propertyName, ReferenceKind.SCALAR);
         const name = options.name || propertyName;
         if (propertyName !== name && !(desc.value instanceof Function)) {
             Utils.renameKey(options, 'name', 'fieldName');

package/legacy/Transactional.d.ts

@@ -1,5 +1,5 @@
 import { type TransactionOptions } from '@mikro-orm/core';
-import { type ContextProvider } from '../resolveContextProvider.js';
+import { type ContextProvider } from '../utils.js';
 type TransactionalOptions<T> = TransactionOptions & {
     context?: ContextProvider<T>;
     contextName?: string;

package/legacy/Transactional.js

@@ -1,5 +1,5 @@
 import { TransactionPropagation, RequestContext, TransactionContext } from '@mikro-orm/core';
-import { resolveContextProvider } from '../resolveContextProvider.js';
+import { resolveContextProvider } from '../utils.js';
 /**
  * This decorator wraps the method with `em.transactional()`, so you can provide `TransactionOptions` just like with `em.transactional()`.
  * The difference is that you can specify the context in which the transaction begins by providing `context` option,

package/legacy/hooks.js

@@ -1,7 +1,8 @@
-import { MetadataStorage, EventType } from '@mikro-orm/core';
+import { EventType } from '@mikro-orm/core';
+import { getMetadataFromDecorator } from '../utils.js';
 function hook(type) {
     return function (target, method) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
+        const meta = getMetadataFromDecorator(target.constructor);
         meta.hooks[type] ??= [];
         meta.hooks[type].push(method);
     };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/decorators",
   "type": "module",
-  "version": "7.0.0-dev.65",
+  "version": "7.0.0-dev.67",
   "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.",
   "exports": {
     "./package.json": "./package.json",
@@ -55,7 +55,7 @@
     "@mikro-orm/core": "^6.6.1"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.65",
+    "@mikro-orm/core": "7.0.0-dev.67",
     "reflect-metadata": "^0.1.0 || ^0.2.0"
   },
   "peerDependenciesMeta": {

package/utils.d.ts

@@ -0,0 +1,38 @@
+import { type ReferenceKind, type EntityMetadata, type Dictionary, type MaybePromise, EntityManager, EntityRepository, MikroORM, MetadataStorage } 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;
+}>);
+/**
+ * Find `EntityManager` in provided context, or else in instance's `orm` or `em` properties.
+ */
+export declare function resolveContextProvider<T>(caller: T & {
+    orm?: MaybePromise<MikroORM>;
+    em?: MaybePromise<EntityManager>;
+}, provider?: ContextProvider<T>): Promise<EntityManager | undefined>;
+/**
+ * Relation decorators allow using two signatures
+ * - using first parameter as options object
+ * - using all parameters
+ *
+ * This function validates those two ways are not mixed and returns the final options object.
+ * If the second way is used, we always consider the last parameter as options object.
+ * @internal
+ */
+export declare function processDecoratorParameters<T>(params: Dictionary): T;
+/**
+ * Validate there is only one property decorator. This disallows using `@Property()` together with e.g. `@ManyToOne()`
+ * on the same property. One should use only `@ManyToOne()` in such case.
+ * We allow the existence of the property in metadata if the reference type is the same, this should allow things like HMR to work.
+ */
+export declare function validateSingleDecorator(meta: EntityMetadata, propertyName: string, reference: ReferenceKind): void;
+/**
+ * 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;
+export declare function getMetadataFromDecorator<T = any>(target: T & Dictionary & {
+    [MetadataStorage.PATH_SYMBOL]?: string;
+}): EntityMetadata<T>;

package/utils.js

@@ -0,0 +1,105 @@
+import { Utils, EntityManager, EntityRepository, MikroORM, MetadataError, MetadataStorage, } from '@mikro-orm/core';
+function getEntityManager(caller, context) {
+    if (context instanceof EntityManager) {
+        return context;
+    }
+    if (context instanceof EntityRepository) {
+        return context.getEntityManager();
+    }
+    if (context instanceof MikroORM) {
+        return context.em;
+    }
+    if (caller.em instanceof EntityManager) {
+        return caller.em;
+    }
+    if (caller.orm instanceof MikroORM) {
+        return caller.orm.em;
+    }
+    return undefined;
+}
+/**
+ * Find `EntityManager` in provided context, or else in instance's `orm` or `em` properties.
+ */
+export async function resolveContextProvider(caller, provider) {
+    const context = typeof provider === 'function' ? await provider(caller) : await provider;
+    return getEntityManager({ orm: await caller.orm, em: await caller.em }, context);
+}
+/**
+ * Relation decorators allow using two signatures
+ * - using first parameter as options object
+ * - using all parameters
+ *
+ * This function validates those two ways are not mixed and returns the final options object.
+ * If the second way is used, we always consider the last parameter as options object.
+ * @internal
+ */
+export function processDecoratorParameters(params) {
+    const keys = Object.keys(params);
+    const values = Object.values(params);
+    if (!Utils.isPlainObject(values[0])) {
+        const lastKey = keys[keys.length - 1];
+        const last = params[lastKey];
+        delete params[lastKey];
+        return { ...last, ...params };
+    }
+    // validate only first parameter is used if its an option object
+    const empty = (v) => v == null || (Utils.isPlainObject(v) && !Utils.hasObjectKeys(v));
+    if (values.slice(1).some(v => !empty(v))) {
+        throw new Error('Mixing first decorator parameter as options object with other parameters is forbidden. ' +
+            'If you want to use the options parameter at first position, provide all options inside it.');
+    }
+    return values[0];
+}
+/**
+ * Validate there is only one property decorator. This disallows using `@Property()` together with e.g. `@ManyToOne()`
+ * on the same property. One should use only `@ManyToOne()` in such case.
+ * We allow the existence of the property in metadata if the reference type is the same, this should allow things like HMR to work.
+ */
+export function validateSingleDecorator(meta, propertyName, reference) {
+    if (meta.properties[propertyName] && meta.properties[propertyName].kind !== reference) {
+        throw MetadataError.multipleDecorators(meta.className, propertyName);
+    }
+}
+/**
+ * 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 function lookupPathFromDecorator(name, stack) {
+    // use some dark magic to get source path to caller
+    stack = stack || new Error().stack.split('\n');
+    // In some situations (e.g. swc 1.3.4+), the presence of a source map can obscure the call to
+    // __decorate(), replacing it with the constructor name. To support these cases we look for
+    // Reflect.decorate() as well. Also when babel is used, we need to check
+    // the `_applyDecoratedDescriptor` method instead.
+    let line = stack.findIndex(line => line.match(/__decorate|Reflect\.decorate|_applyDecoratedDescriptor/));
+    // bun does not have those lines at all, only the DecorateProperty/DecorateConstructor,
+    // but those are also present in node, so we need to check this only if they weren't found.
+    if (line === -1) {
+        // here we handle bun which stack is different from nodejs so we search for reflect-metadata
+        // Different bun versions might have different stack traces. The "last index" works for both 1.2.6 and 1.2.7.
+        const reflectLine = stack.findLastIndex(line => Utils.normalizePath(line).includes('node_modules/reflect-metadata/Reflect.js'));
+        if (reflectLine === -1 || reflectLine + 2 >= stack.length || !stack[reflectLine + 1].includes('bun:wrap')) {
+            return name;
+        }
+        line = reflectLine + 2;
+    }
+    if (stack[line].includes('Reflect.decorate')) {
+        line++;
+    }
+    if (Utils.normalizePath(stack[line]).includes('node_modules/tslib/tslib')) {
+        line++;
+    }
+    try {
+        const re = stack[line].match(/\(.+\)/i) ? /\((.*):\d+:\d+\)/ : /at\s*(.*):\d+:\d+$/;
+        return Utils.normalizePath(stack[line].match(re)[1]);
+    }
+    catch {
+        return name;
+    }
+}
+export function getMetadataFromDecorator(target) {
+    if (!Object.hasOwn(target, MetadataStorage.PATH_SYMBOL)) {
+        Object.defineProperty(target, MetadataStorage.PATH_SYMBOL, { value: lookupPathFromDecorator(target.name), writable: true });
+    }
+    return MetadataStorage.getMetadata(target.name, target[MetadataStorage.PATH_SYMBOL]);
+}

package/resolveContextProvider.d.ts

@@ -1,14 +0,0 @@
-import { type MaybePromise, EntityManager, EntityRepository, MikroORM } 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;
-}>);
-/**
- * Find `EntityManager` in provided context, or else in instance's `orm` or `em` properties.
- */
-export declare function resolveContextProvider<T>(caller: T & {
-    orm?: MaybePromise<MikroORM>;
-    em?: MaybePromise<EntityManager>;
-}, provider?: ContextProvider<T>): Promise<EntityManager | undefined>;

package/resolveContextProvider.js

@@ -1,26 +0,0 @@
-import { EntityManager, EntityRepository, MikroORM } from '@mikro-orm/core';
-function getEntityManager(caller, context) {
-    if (context instanceof EntityManager) {
-        return context;
-    }
-    if (context instanceof EntityRepository) {
-        return context.getEntityManager();
-    }
-    if (context instanceof MikroORM) {
-        return context.em;
-    }
-    if (caller.em instanceof EntityManager) {
-        return caller.em;
-    }
-    if (caller.orm instanceof MikroORM) {
-        return caller.orm.em;
-    }
-    return undefined;
-}
-/**
- * Find `EntityManager` in provided context, or else in instance's `orm` or `em` properties.
- */
-export async function resolveContextProvider(caller, provider) {
-    const context = typeof provider === 'function' ? await provider(caller) : await provider;
-    return getEntityManager({ orm: await caller.orm, em: await caller.em }, context);
-}