@mikro-orm/decorators 7.0.0-dev.64

package/es/OneToOne.js

@@ -0,0 +1,13 @@
+import { MetadataValidator, ReferenceKind, Utils, } from '@mikro-orm/core';
+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 });
+        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.d.ts

@@ -0,0 +1,3 @@
+import { type PrimaryKeyOptions, type SerializedPrimaryKeyOptions } from '@mikro-orm/core';
+export declare function PrimaryKey<T extends object>(options?: PrimaryKeyOptions<T>): (value: unknown, context: ClassFieldDecoratorContext<T, unknown>) => void;
+export declare function SerializedPrimaryKey<T extends object>(options?: SerializedPrimaryKeyOptions<T>): (value: unknown, context: ClassFieldDecoratorContext<T, unknown>) => void;

package/es/PrimaryKey.js

@@ -0,0 +1,17 @@
+import { ReferenceKind, MetadataValidator, } from '@mikro-orm/core';
+function createDecorator(options, serialized) {
+    return function (value, context) {
+        const meta = context.metadata;
+        meta.properties ??= {};
+        MetadataValidator.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 };
+    };
+}
+export function PrimaryKey(options = {}) {
+    return createDecorator(options, false);
+}
+export function SerializedPrimaryKey(options = {}) {
+    return createDecorator(options, true);
+}

package/es/Property.d.ts

@@ -0,0 +1,2 @@
+import { type PropertyOptions } from '@mikro-orm/core';
+export declare function Property<T extends object>(options?: PropertyOptions<T>): (value: unknown, context: ClassFieldDecoratorContext<T> | ClassGetterDecoratorContext<T> | ClassMethodDecoratorContext<T>) => void;

package/es/Property.js

@@ -0,0 +1,31 @@
+import { MetadataValidator, ReferenceKind, Utils, } from '@mikro-orm/core';
+export function Property(options = {}) {
+    return function (value, context) {
+        const meta = context.metadata;
+        meta.properties ??= {};
+        MetadataValidator.validateSingleDecorator(meta, context.name, 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 === '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

@@ -0,0 +1,15 @@
+import { type TransactionOptions } from '@mikro-orm/core';
+import { type ContextProvider } from '../resolveContextProvider.js';
+type TransactionalOptions<T> = TransactionOptions & {
+    context?: ContextProvider<T>;
+    contextName?: string;
+};
+/**
+ * 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,
+ * and if omitted, the transaction will begin in the current context implicitly.
+ * 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 {};

package/es/Transactional.js

@@ -0,0 +1,27 @@
+import { RequestContext, TransactionContext, TransactionPropagation } from '@mikro-orm/core';
+import { resolveContextProvider } from '../resolveContextProvider.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,
+ * and if omitted, the transaction will begin in the current context implicitly.
+ * 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 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);
+        };
+    };
+}

package/es/hooks.d.ts

@@ -0,0 +1,16 @@
+export declare function BeforeCreate(): (value: (...args: any[]) => unknown, context: ClassMethodDecoratorContext) => void;
+export declare function AfterCreate(): (value: (...args: any[]) => unknown, context: ClassMethodDecoratorContext) => void;
+export declare function BeforeUpdate(): (value: (...args: any[]) => unknown, context: ClassMethodDecoratorContext) => void;
+export declare function AfterUpdate(): (value: (...args: any[]) => unknown, context: ClassMethodDecoratorContext) => void;
+export declare function BeforeUpsert(): (value: (...args: any[]) => unknown, context: ClassMethodDecoratorContext) => void;
+export declare function AfterUpsert(): (value: (...args: any[]) => unknown, context: ClassMethodDecoratorContext) => void;
+export declare function OnInit(): (value: (...args: any[]) => unknown, context: ClassMethodDecoratorContext) => void;
+export declare function OnLoad(): (value: (...args: any[]) => unknown, context: ClassMethodDecoratorContext) => void;
+/**
+ * Called before deleting entity, but only when providing initialized entity to EM#remove()
+ */
+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;

package/es/hooks.js

@@ -0,0 +1,45 @@
+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);
+    };
+}
+export function BeforeCreate() {
+    return hook(EventType.beforeCreate);
+}
+export function AfterCreate() {
+    return hook(EventType.afterCreate);
+}
+export function BeforeUpdate() {
+    return hook(EventType.beforeUpdate);
+}
+export function AfterUpdate() {
+    return hook(EventType.afterUpdate);
+}
+export function BeforeUpsert() {
+    return hook(EventType.beforeUpsert);
+}
+export function AfterUpsert() {
+    return hook(EventType.afterUpsert);
+}
+export function OnInit() {
+    return hook(EventType.onInit);
+}
+export function 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);
+}
+/**
+ * Called after deleting entity, but only when providing initialized entity to EM#remove()
+ */
+export function AfterDelete() {
+    return hook(EventType.afterDelete);
+}

package/es/index.d.ts

@@ -0,0 +1,17 @@
+export * from './PrimaryKey.js';
+export * from './Entity.js';
+export * from './OneToOne.js';
+export * from './ManyToOne.js';
+export * from './ManyToMany.js';
+export * from './OneToMany.js';
+export * from './Property.js';
+export * from './Check.js';
+export * from './Enum.js';
+export * from './Formula.js';
+export * from './Indexed.js';
+export * from './Embeddable.js';
+export * from './Embedded.js';
+export * from './Filter.js';
+export * from './CreateRequestContext.js';
+export * from './hooks.js';
+export * from './Transactional.js';

package/es/index.js

@@ -0,0 +1,17 @@
+export * from './PrimaryKey.js';
+export * from './Entity.js';
+export * from './OneToOne.js';
+export * from './ManyToOne.js';
+export * from './ManyToMany.js';
+export * from './OneToMany.js';
+export * from './Property.js';
+export * from './Check.js';
+export * from './Enum.js';
+export * from './Formula.js';
+export * from './Indexed.js';
+export * from './Embeddable.js';
+export * from './Embedded.js';
+export * from './Filter.js';
+export * from './CreateRequestContext.js';
+export * from './hooks.js';
+export * from './Transactional.js';

package/legacy/Check.d.ts

@@ -0,0 +1,2 @@
+import { type CheckConstraint, type EntityClass } from '@mikro-orm/core';
+export declare function Check<T>(options: CheckConstraint<T>): (target: T, propertyName?: T extends EntityClass<unknown> ? undefined : keyof T) => any;

package/legacy/Check.js

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

package/legacy/CreateRequestContext.d.ts

@@ -0,0 +1,3 @@
+import { type ContextProvider } from '../resolveContextProvider.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

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

package/legacy/Embeddable.d.ts

@@ -0,0 +1,2 @@
+import { type EmbeddableOptions } from '@mikro-orm/core';
+export declare function Embeddable<T>(options?: EmbeddableOptions<T>): (target: T) => T;

package/legacy/Embeddable.js

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

package/legacy/Embedded.d.ts

@@ -0,0 +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;

package/legacy/Embedded.js

@@ -0,0 +1,14 @@
+import { MetadataValidator, MetadataStorage, ReferenceKind, Utils, } from '@mikro-orm/core';
+export function Embedded(type = {}, options = {}) {
+    return function (target, propertyName) {
+        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
+        MetadataValidator.validateSingleDecorator(meta, propertyName, ReferenceKind.EMBEDDED);
+        options = type instanceof Function ? { entity: type, ...options } : { ...type, ...options };
+        Utils.defaultValue(options, 'prefix', true);
+        meta.properties[propertyName] = {
+            name: propertyName,
+            kind: ReferenceKind.EMBEDDED,
+            ...options,
+        };
+    };
+}

package/legacy/Entity.d.ts

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

package/legacy/Entity.js

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

package/legacy/Enum.d.ts

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

package/legacy/Enum.js

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

package/legacy/Filter.d.ts

@@ -0,0 +1,2 @@
+import { type FilterDef, type EntityClass } from '@mikro-orm/core';
+export declare function Filter<T extends EntityClass<unknown>>(options: FilterDef<T>): (target: T) => void;

package/legacy/Filter.js

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

package/legacy/Formula.d.ts

@@ -0,0 +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;

package/legacy/Formula.js

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

package/legacy/Indexed.d.ts

@@ -0,0 +1,3 @@
+import { type EntityClass, type IndexOptions, type UniqueOptions } from '@mikro-orm/core';
+export declare function Index<T extends object, H extends string>(options?: IndexOptions<T, H>): (target: T, propertyName?: (T extends EntityClass<unknown> ? undefined : keyof T) | undefined) => 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) | undefined) => any;

package/legacy/Indexed.js

@@ -0,0 +1,19 @@
+import { MetadataStorage } from '@mikro-orm/core';
+function createDecorator(options, unique) {
+    return function (target, propertyName) {
+        const meta = MetadataStorage.getMetadataFromDecorator(propertyName ? target.constructor : target);
+        options.properties ??= propertyName;
+        const key = unique ? 'uniques' : 'indexes';
+        meta[key].push(options);
+        if (!propertyName) {
+            return target;
+        }
+        return undefined;
+    };
+}
+export function Index(options = {}) {
+    return createDecorator(options, false);
+}
+export function Unique(options = {}) {
+    return createDecorator(options, true);
+}

package/legacy/ManyToMany.d.ts

@@ -0,0 +1,2 @@
+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;

package/legacy/ManyToMany.js

@@ -0,0 +1,10 @@
+import { MetadataStorage, MetadataValidator, ReferenceKind, Utils, } from '@mikro-orm/core';
+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);
+        const property = { name: propertyName, kind: ReferenceKind.MANY_TO_MANY };
+        meta.properties[propertyName] = Object.assign(meta.properties[propertyName] ?? {}, property, options);
+    };
+}

package/legacy/ManyToOne.d.ts

@@ -0,0 +1,2 @@
+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;

package/legacy/ManyToOne.js

@@ -0,0 +1,10 @@
+import { ReferenceKind, MetadataStorage, MetadataValidator, Utils, } from '@mikro-orm/core';
+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);
+        const property = { name: propertyName, kind: ReferenceKind.MANY_TO_ONE };
+        meta.properties[propertyName] = Object.assign(meta.properties[propertyName] ?? {}, property, options);
+    };
+}

package/legacy/OneToMany.d.ts

@@ -0,0 +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>(options: OneToManyOptions<Owner, Target>): (target: Owner, propertyName: string) => void;

package/legacy/OneToMany.js

@@ -0,0 +1,10 @@
+import { MetadataStorage, MetadataValidator, ReferenceKind, Utils, } from '@mikro-orm/core';
+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);
+        const property = { name: propertyName, kind: ReferenceKind.ONE_TO_MANY };
+        meta.properties[propertyName] = Object.assign(meta.properties[propertyName] ?? {}, property, options);
+    };
+}

package/legacy/OneToOne.d.ts

@@ -0,0 +1,2 @@
+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;

package/legacy/OneToOne.js

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

package/legacy/PrimaryKey.d.ts

@@ -0,0 +1,3 @@
+import { type PrimaryKeyOptions, type SerializedPrimaryKeyOptions } from '@mikro-orm/core';
+export declare function PrimaryKey<T extends object>(options?: PrimaryKeyOptions<T>): (target: T, propertyName: string) => void;
+export declare function SerializedPrimaryKey<T extends object>(options?: SerializedPrimaryKeyOptions<T>): (target: T, propertyName: string) => void;

package/legacy/PrimaryKey.js

@@ -0,0 +1,16 @@
+import { MetadataStorage, MetadataValidator, ReferenceKind, } from '@mikro-orm/core';
+function createDecorator(options, serialized) {
+    return function (target, propertyName) {
+        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
+        MetadataValidator.validateSingleDecorator(meta, propertyName, ReferenceKind.SCALAR);
+        const k = serialized ? 'serializedPrimaryKey' : 'primary';
+        options[k] = true;
+        meta.properties[propertyName] = { name: propertyName, kind: ReferenceKind.SCALAR, ...options };
+    };
+}
+export function PrimaryKey(options = {}) {
+    return createDecorator(options, false);
+}
+export function SerializedPrimaryKey(options = {}) {
+    return createDecorator(options, true);
+}

package/legacy/Property.d.ts

@@ -0,0 +1,2 @@
+import { type PropertyOptions } from '@mikro-orm/core';
+export declare function Property<T extends object>(options?: PropertyOptions<T>): (target: T, propertyName: string) => void;

package/legacy/Property.js

@@ -0,0 +1,28 @@
+import { MetadataStorage, MetadataValidator, Utils, ReferenceKind, } from '@mikro-orm/core';
+export function Property(options = {}) {
+    return function (target, propertyName) {
+        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
+        const desc = Object.getOwnPropertyDescriptor(target, propertyName) || {};
+        MetadataValidator.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

@@ -0,0 +1,6 @@
+import 'reflect-metadata';
+import { type EntityMetadata, type EntityProperty, MetadataProvider } from '@mikro-orm/core';
+export declare class ReflectMetadataProvider extends MetadataProvider {
+    loadEntityMetadata(meta: EntityMetadata): void;
+    protected initPropertyType(meta: EntityMetadata, prop: EntityProperty): void;
+}

package/legacy/ReflectMetadataProvider.js

@@ -0,0 +1,39 @@
+import 'reflect-metadata';
+import { 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) {
+            if (typeof prop.entity === 'string') {
+                prop.type = prop.entity;
+            }
+            else if (prop.entity) {
+                const tmp = prop.entity();
+                prop.type = Array.isArray(tmp) ? tmp.map(t => Utils.className(t)).sort().join(' | ') : Utils.className(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;
+    }
+}

package/legacy/Transactional.d.ts

@@ -0,0 +1,15 @@
+import { type TransactionOptions } from '@mikro-orm/core';
+import { type ContextProvider } from '../resolveContextProvider.js';
+type TransactionalOptions<T> = TransactionOptions & {
+    context?: ContextProvider<T>;
+    contextName?: string;
+};
+/**
+ * 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,
+ * and if omitted, the transaction will begin in the current context implicitly.
+ * 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<T extends object>(options?: TransactionalOptions<T>): MethodDecorator;
+export {};

package/legacy/Transactional.js

@@ -0,0 +1,29 @@
+import { TransactionPropagation, RequestContext, TransactionContext } from '@mikro-orm/core';
+import { resolveContextProvider } from '../resolveContextProvider.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,
+ * and if omitted, the transaction will begin in the current context implicitly.
+ * 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 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;
+    };
+}