@mikro-orm/decorators 7.0.0-dev.98 → 7.0.0-rc.0

package/es/Embeddable.js

@@ -1,9 +1,10 @@
-import { 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 = getMetadataFromDecorator(target);
-        Utils.mergeConfig(meta, context.metadata, options);
+        const metadata = { ...context.metadata };
+        Utils.mergeConfig(meta, metadata, options);
         meta.class = target;
         meta.name = meta.class.name;
         meta.embeddable = true;

package/es/Embedded.d.ts

@@ -1,2 +1,2 @@
 import { type EntityName, type EmbeddedOptions } from '@mikro-orm/core';
-export declare function Embedded<Owner extends object, Target>(type?: EmbeddedOptions<Owner, Target> | (() => EntityName<Target> | EntityName<Target>[]), options?: EmbeddedOptions<Owner, Target>): (value: unknown, context: ClassFieldDecoratorContext<Owner>) => void;
+export declare function Embedded<Owner extends object, Target>(type?: EmbeddedOptions<Owner, Target> | (() => EntityName<Target> | EntityName[]), options?: EmbeddedOptions<Owner, Target>): (value: unknown, context: ClassFieldDecoratorContext<Owner>) => void;

package/es/Embedded.js

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

package/es/Entity.d.ts

@@ -1,2 +1,2 @@
-import { type EntityOptions, type EntityClass, type Constructor } from '@mikro-orm/core';
+import { type Constructor, type EntityOptions, type EntityClass } from '@mikro-orm/core';
 export declare function Entity<Owner extends EntityClass<unknown> & Constructor>(options?: EntityOptions<Owner>): (target: Owner, context: ClassDecoratorContext<Owner>) => void;

package/es/Entity.js

@@ -1,9 +1,10 @@
-import { 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 = getMetadataFromDecorator(target);
-        Utils.mergeConfig(meta, context.metadata, options);
+        const metadata = { ...context.metadata };
+        Utils.mergeConfig(meta, metadata, options);
         meta.class = target;
         if (!options.abstract || meta.discriminatorColumn) {
             meta.name = context.name;

package/es/Enum.js

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

package/es/Formula.d.ts

@@ -1,2 +1,2 @@
-import { type PropertyOptions } from '@mikro-orm/core';
-export declare function Formula<Owner extends object>(formula: string | ((alias: string) => string), options?: PropertyOptions<Owner>): (value: unknown, context: ClassFieldDecoratorContext<Owner>) => void;
+import { type FormulaCallback, type PropertyOptions } from '@mikro-orm/core';
+export declare function Formula<Owner extends object>(formula: string | FormulaCallback<Owner>, options?: PropertyOptions<Owner>): (value: unknown, context: ClassFieldDecoratorContext<Owner>) => void;

package/es/Formula.js

@@ -1,8 +1,8 @@
 import { ReferenceKind, } from '@mikro-orm/core';
+import { prepareMetadataContext } from '../utils.js';
 export function Formula(formula, options = {}) {
     return function (value, context) {
-        const meta = context.metadata;
-        meta.properties ??= {};
+        const meta = prepareMetadataContext(context);
         meta.properties[context.name] = {
             name: context.name,
             kind: ReferenceKind.SCALAR,

package/es/ManyToMany.js

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

package/es/ManyToOne.d.ts

@@ -1,2 +1,2 @@
 import { type ManyToOneOptions, type EntityName, type Ref } from '@mikro-orm/core';
-export declare function ManyToOne<Target extends object, Owner extends object>(entity?: ManyToOneOptions<Owner, Target> | string | ((e?: Owner) => EntityName<Target>), options?: Partial<ManyToOneOptions<Owner, Target>>): (_: unknown, context: ClassFieldDecoratorContext<Owner, Target | undefined | null | Ref<Target>>) => void;
+export declare function ManyToOne<Target extends object, Owner extends object>(entity?: ManyToOneOptions<Owner, Target> | ((e?: Owner) => EntityName<Target> | EntityName[]), options?: Partial<ManyToOneOptions<Owner, Target>>): (_: unknown, context: ClassFieldDecoratorContext<Owner, Target | undefined | null | Ref<Target>>) => void;

package/es/ManyToOne.js

@@ -1,10 +1,8 @@
 import { ReferenceKind, Utils, } from '@mikro-orm/core';
-import { processDecoratorParameters, validateSingleDecorator } from '../utils.js';
+import { prepareMetadataContext, processDecoratorParameters } from '../utils.js';
 export function ManyToOne(entity = {}, options = {}) {
     return function (_, context) {
-        const meta = context.metadata;
-        meta.properties ??= {};
-        validateSingleDecorator(meta, context.name, ReferenceKind.MANY_TO_ONE);
+        const meta = prepareMetadataContext(context, 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,8 @@
 import { ReferenceKind, Utils, } from '@mikro-orm/core';
-import { processDecoratorParameters, validateSingleDecorator } from '../utils.js';
+import { prepareMetadataContext, processDecoratorParameters } from '../utils.js';
 export function OneToMany(entity, mappedBy, options = {}) {
     return function (value, context) {
-        const meta = context.metadata;
-        meta.properties ??= {};
-        validateSingleDecorator(meta, context.name, ReferenceKind.ONE_TO_MANY);
+        const meta = prepareMetadataContext(context, ReferenceKind.ONE_TO_MANY);
         options = processDecoratorParameters({ entity, mappedBy, options });
         const property = { name: context.name, kind: ReferenceKind.ONE_TO_MANY };
         meta.properties[context.name] ??= {};

package/es/OneToOne.d.ts

@@ -1,2 +1,2 @@
 import { type EntityName, type OneToOneOptions, type Ref } from '@mikro-orm/core';
-export declare function OneToOne<Target extends object, Owner extends object>(entity?: OneToOneOptions<Owner, Target> | string | ((e: Owner) => EntityName<Target>), mappedByOrOptions?: (string & keyof Target) | ((e: Target) => any) | Partial<OneToOneOptions<Owner, Target>>, options?: Partial<OneToOneOptions<Owner, Target>>): (_: unknown, context: ClassFieldDecoratorContext<Owner, Target | Ref<Target> | null | undefined>) => void;
+export declare function OneToOne<Target extends object, Owner extends object>(entity?: OneToOneOptions<Owner, Target> | string | ((e: Owner) => EntityName<Target> | EntityName[]), mappedByOrOptions?: (string & keyof Target) | ((e: Target) => any) | Partial<OneToOneOptions<Owner, Target>>, options?: Partial<OneToOneOptions<Owner, Target>>): (_: unknown, context: ClassFieldDecoratorContext<Owner, Target | Ref<Target> | null | undefined>) => void;

package/es/OneToOne.js

@@ -1,12 +1,10 @@
 import { ReferenceKind, } from '@mikro-orm/core';
-import { processDecoratorParameters, validateSingleDecorator } from '../utils.js';
+import { prepareMetadataContext, processDecoratorParameters } 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 ??= {};
-        validateSingleDecorator(meta, context.name, ReferenceKind.ONE_TO_ONE);
+        const meta = prepareMetadataContext(context, 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,10 +1,8 @@
 import { ReferenceKind, } from '@mikro-orm/core';
-import { validateSingleDecorator } from '../utils.js';
+import { prepareMetadataContext } from '../utils.js';
 function createDecorator(options, serialized) {
     return function (value, context) {
-        const meta = context.metadata;
-        meta.properties ??= {};
-        validateSingleDecorator(meta, context.name, ReferenceKind.SCALAR);
+        const meta = prepareMetadataContext(context, 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,10 +1,8 @@
 import { ReferenceKind, Utils, } from '@mikro-orm/core';
-import { validateSingleDecorator } from '../utils.js';
+import { prepareMetadataContext } from '../utils.js';
 export function Property(options = {}) {
     return function (value, context) {
-        const meta = context.metadata;
-        meta.properties ??= {};
-        validateSingleDecorator(meta, context.name, ReferenceKind.SCALAR);
+        const meta = prepareMetadataContext(context, ReferenceKind.SCALAR);
         const { check, ...opts } = options;
         const prop = { kind: ReferenceKind.SCALAR, ...opts };
         const name = options.name ?? context.name;

package/legacy/Embedded.d.ts

@@ -1,2 +1,2 @@
 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<Target>[]), 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/Formula.d.ts

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

package/legacy/ManyToMany.d.ts

@@ -1,2 +1,4 @@
 import { type EntityName, type ManyToManyOptions } from '@mikro-orm/core';
-export declare function ManyToMany<Target extends object, Owner extends object>(entity?: ManyToManyOptions<Owner, Target> | string | (() => 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;

package/legacy/ManyToOne.d.ts

@@ -1,2 +1,4 @@
 import { type ManyToOneOptions, type EntityName } from '@mikro-orm/core';
-export declare function ManyToOne<Target extends object, Owner extends object>(entity?: ManyToOneOptions<Owner, Target> | string | ((e?: any) => EntityName<Target>), options?: Partial<ManyToOneOptions<Owner, Target>>): (target: Owner, propertyName: keyof Owner) => 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;

package/legacy/OneToMany.d.ts

@@ -1,3 +1,3 @@
 import { type EntityName, type OneToManyOptions } from '@mikro-orm/core';
-export declare function OneToMany<Target extends object, Owner extends object>(entity: string | ((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>(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/OneToOne.d.ts

@@ -1,2 +1,3 @@
 import { type EntityName, type OneToOneOptions } from '@mikro-orm/core';
-export declare function OneToOne<Target, Owner>(entity?: OneToOneOptions<Owner, Target> | string | ((e: Owner) => EntityName<Target>), 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: ((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/ReflectMetadataProvider.js

@@ -1,15 +1,17 @@
 import 'reflect-metadata';
-import { MetadataProvider, ReferenceKind, Utils } from '@mikro-orm/core';
+import { EntitySchema, MetadataProvider, ReferenceKind, Utils, } from '@mikro-orm/core';
 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') {
-                prop.type = prop.entity;
+                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 = tmp instanceof EntitySchema ? tmp.meta.class : tmp;
             }
             else {
                 this.initPropertyType(meta, prop);
@@ -35,5 +37,6 @@ export class ReflectMetadataProvider extends MetadataProvider {
         }
         prop.type ??= typeName;
         prop.runtimeType ??= typeName;
+        prop.target = type;
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/decorators",
   "type": "module",
-  "version": "7.0.0-dev.98",
+  "version": "7.0.0-rc.0",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "exports": {
     "./package.json": "./package.json",
@@ -43,7 +43,7 @@
     "node": ">= 22.17.0"
   },
   "scripts": {
-    "build": "yarn clean && yarn compile && yarn copy",
+    "build": "yarn compile && yarn copy",
     "clean": "yarn run -T rimraf ./dist",
     "compile": "yarn run -T tsc -p tsconfig.build.json",
     "copy": "node ../../scripts/copy.mjs"
@@ -52,10 +52,10 @@
     "access": "public"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.6.1"
+    "@mikro-orm/core": "^6.6.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.98",
+    "@mikro-orm/core": "7.0.0-rc.0",
     "reflect-metadata": "^0.1.0 || ^0.2.0"
   },
   "peerDependenciesMeta": {

package/utils.d.ts

@@ -1,4 +1,4 @@
-import { type ReferenceKind, type EntityMetadata, type Dictionary, type MaybePromise, EntityManager, EntityRepository, MikroORM, MetadataStorage } 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.
  */
@@ -25,9 +25,15 @@ 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.
+ * We allow the existence of the property in metadata if the reference kind is the same, this should allow things like HMR to work.
  */
-export declare function validateSingleDecorator(meta: EntityMetadata, propertyName: string, reference: ReferenceKind): void;
+export declare function validateSingleDecorator(meta: EntityMetadata, propertyName: string, kind: ReferenceKind): void;
+/**
+ * Prepares and returns a metadata context for an entity, ensuring default structure and validating proper usage of a single decorator.
+ * 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> | 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.

package/utils.js

@@ -1,4 +1,4 @@
-import { Utils, EntityManager, EntityRepository, MikroORM, MetadataError, MetadataStorage, } from '@mikro-orm/core';
+import { EntityManager, EntityRepository, MetadataError, MetadataStorage, MikroORM, Utils, } from '@mikro-orm/core';
 function getEntityManager(caller, context) {
     if (context instanceof EntityManager) {
         return context;
@@ -53,13 +53,28 @@ export function processDecoratorParameters(params) {
 /**
  * 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.
+ * We allow the existence of the property in metadata if the reference kind 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) {
+export function validateSingleDecorator(meta, propertyName, kind) {
+    if (meta.properties[propertyName] && meta.properties[propertyName].kind !== kind) {
         throw MetadataError.multipleDecorators(meta.className, propertyName);
     }
 }
+/**
+ * Prepares and returns a metadata context for an entity, ensuring default structure and validating proper usage of a single decorator.
+ * 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 function prepareMetadataContext(context, kind) {
+    const meta = context.metadata;
+    if (!Object.hasOwn(meta, 'properties')) {
+        meta.properties = { ...meta.properties };
+    }
+    if (kind) {
+        validateSingleDecorator(meta, context.name, kind);
+    }
+    return meta;
+}
 /**
  * Uses some dark magic to get source path to caller where decorator is used.
  * Analyzes stack trace of error created inside the function call.
@@ -77,7 +92,7 @@ export function lookupPathFromDecorator(name, stack) {
     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'));
+        const reflectLine = stack.findLastIndex(line => line.replace(/\\/g, '/').includes('node_modules/reflect-metadata/Reflect.js'));
         if (reflectLine === -1 || reflectLine + 2 >= stack.length || !stack[reflectLine + 1].includes('bun:wrap')) {
             return name;
         }
@@ -86,12 +101,12 @@ export function lookupPathFromDecorator(name, stack) {
     if (stack[line].includes('Reflect.decorate')) {
         line++;
     }
-    if (Utils.normalizePath(stack[line]).includes('node_modules/tslib/tslib')) {
+    if (stack[line].replace(/\\/g, '/').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]);
+        return stack[line].match(re)[1];
     }
     catch {
         return name;