@mikro-orm/core 7.0.0-dev.1 → 7.0.0-dev.11

package/decorators/Embedded.d.ts

@@ -1,8 +1,8 @@
-import type { AnyEntity } from '../typings';
+import type { AnyEntity } from '../typings.js';
 export declare function Embedded<T extends object>(type?: EmbeddedOptions | (() => AnyEntity), options?: EmbeddedOptions): (target: AnyEntity, propertyName: string) => any;
 /** With `absolute` the prefix is set at the root of the entity (regardless of the nesting level) */
 export type EmbeddedPrefixMode = 'absolute' | 'relative';
-export type EmbeddedOptions = {
+export interface EmbeddedOptions {
     entity?: string | (() => AnyEntity | AnyEntity[]);
     type?: string;
     prefix?: string | boolean;
@@ -15,4 +15,4 @@ export type EmbeddedOptions = {
     serializedName?: string;
     groups?: string[];
     persist?: boolean;
-};
+}

package/decorators/Embedded.js

@@ -1,20 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Embedded = Embedded;
-const metadata_1 = require("../metadata");
-const utils_1 = require("../utils");
-const enums_1 = require("../enums");
-function Embedded(type = {}, options = {}) {
+import { MetadataValidator } from '../metadata/MetadataValidator.js';
+import { MetadataStorage } from '../metadata/MetadataStorage.js';
+import { Utils } from '../utils/Utils.js';
+import { ReferenceKind } from '../enums.js';
+export function Embedded(type = {}, options = {}) {
     return function (target, propertyName) {
-        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target.constructor);
-        metadata_1.MetadataValidator.validateSingleDecorator(meta, propertyName, enums_1.ReferenceKind.EMBEDDED);
+        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
+        MetadataValidator.validateSingleDecorator(meta, propertyName, ReferenceKind.EMBEDDED);
         options = type instanceof Function ? { entity: type, ...options } : { ...type, ...options };
-        utils_1.Utils.defaultValue(options, 'prefix', true);
+        Utils.defaultValue(options, 'prefix', true);
         meta.properties[propertyName] = {
             name: propertyName,
-            kind: enums_1.ReferenceKind.EMBEDDED,
+            kind: ReferenceKind.EMBEDDED,
             ...options,
         };
-        return utils_1.Utils.propertyDecoratorReturnValue();
+        return Utils.propertyDecoratorReturnValue();
     };
 }

package/decorators/Entity.d.ts

@@ -1,11 +1,11 @@
-import type { Constructor, Dictionary, FilterQuery } from '../typings';
-import type { FindOptions } from '../drivers/IDatabaseDriver';
-export declare function Entity(options?: EntityOptions<any>): <T>(target: T & Dictionary) => T & Dictionary;
-export type EntityOptions<T> = {
+import type { AnyString, Constructor, Dictionary, EntityClass, ObjectQuery } from '../typings.js';
+import type { FindOptions } from '../drivers/IDatabaseDriver.js';
+export declare function Entity<T extends EntityClass<unknown>>(options?: EntityOptions<T>): (target: T) => void;
+export type EntityOptions<T, E = T extends EntityClass<infer P> ? P : T> = {
     tableName?: string;
     schema?: string;
     collection?: string;
-    discriminatorColumn?: string;
+    discriminatorColumn?: (T extends EntityClass<infer P> ? keyof P : string) | AnyString;
     discriminatorMap?: Dictionary<string>;
     discriminatorValue?: number | string;
     forceConstructor?: boolean;
@@ -13,6 +13,6 @@ export type EntityOptions<T> = {
     abstract?: boolean;
     readonly?: boolean;
     virtual?: boolean;
-    expression?: string | ((em: any, where: FilterQuery<T>, options: FindOptions<T, any, any, any>) => object);
+    expression?: string | ((em: any, where: ObjectQuery<E>, options: FindOptions<E, any, any, any>) => object);
     repository?: () => Constructor;
 };

package/decorators/Entity.js

@@ -1,16 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Entity = Entity;
-const metadata_1 = require("../metadata");
-const utils_1 = require("../utils");
-function Entity(options = {}) {
+import { MetadataStorage } from '../metadata/MetadataStorage.js';
+import { Utils } from '../utils/Utils.js';
+export function Entity(options = {}) {
     return function (target) {
-        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target);
-        utils_1.Utils.mergeConfig(meta, options);
+        const meta = MetadataStorage.getMetadataFromDecorator(target);
+        Utils.mergeConfig(meta, options);
         meta.class = target;
         if (!options.abstract || meta.discriminatorColumn) {
             meta.name = target.name;
         }
-        return target;
     };
 }

package/decorators/Enum.d.ts

@@ -1,6 +1,6 @@
-import type { PropertyOptions } from './Property';
-import type { AnyEntity, Dictionary } from '../typings';
-export declare function Enum<T extends object>(options?: EnumOptions<AnyEntity> | (() => Dictionary)): (target: AnyEntity, propertyName: string) => any;
+import type { PropertyOptions } from './Property.js';
+import type { AnyEntity, Dictionary } from '../typings.js';
+export declare function Enum<T extends object>(options?: EnumOptions<AnyEntity> | (() => Dictionary)): (target: T, propertyName: string) => any;
 export interface EnumOptions<T> extends PropertyOptions<T> {
     items?: (number | string)[] | (() => Dictionary);
     array?: boolean;

package/decorators/Enum.js

@@ -1,19 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Enum = Enum;
-const metadata_1 = require("../metadata");
-const enums_1 = require("../enums");
-const Utils_1 = require("../utils/Utils");
-function Enum(options = {}) {
+import { MetadataStorage } from '../metadata/MetadataStorage.js';
+import { ReferenceKind } from '../enums.js';
+import { Utils } from '../utils/Utils.js';
+export function Enum(options = {}) {
     return function (target, propertyName) {
-        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target.constructor);
+        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
         options = options instanceof Function ? { items: options } : options;
         meta.properties[propertyName] = {
             name: propertyName,
-            kind: enums_1.ReferenceKind.SCALAR,
+            kind: ReferenceKind.SCALAR,
             enum: true,
             ...options,
         };
-        return Utils_1.Utils.propertyDecoratorReturnValue();
+        return Utils.propertyDecoratorReturnValue();
     };
 }

package/decorators/Filter.d.ts

@@ -1,2 +1,2 @@
-import type { Dictionary, FilterDef } from '../typings';
+import type { Dictionary, FilterDef } from '../typings.js';
 export declare function Filter<T>(options: FilterDef): <U>(target: U & Dictionary) => U & Dictionary;

package/decorators/Filter.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Filter = Filter;
-const metadata_1 = require("../metadata");
-function Filter(options) {
+import { MetadataStorage } from '../metadata/MetadataStorage.js';
+export function Filter(options) {
     return function (target) {
-        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target);
+        const meta = MetadataStorage.getMetadataFromDecorator(target);
         meta.filters[options.name] = options;
         return target;
     };

package/decorators/Formula.d.ts

@@ -1,5 +1,4 @@
-import type { AnyEntity } from '../typings';
-import type { PropertyOptions } from './Property';
-export declare function Formula<T extends object>(formula: string | ((alias: string) => string), options?: FormulaOptions<T>): (target: AnyEntity, propertyName: string) => any;
+import type { PropertyOptions } from './Property.js';
+export declare function Formula<T extends object>(formula: string | ((alias: string) => string), options?: FormulaOptions<T>): (target: T, propertyName: string) => any;
 export interface FormulaOptions<T> extends PropertyOptions<T> {
 }

package/decorators/Formula.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Formula = Formula;
-const metadata_1 = require("../metadata");
-const enums_1 = require("../enums");
-const Utils_1 = require("../utils/Utils");
-function Formula(formula, options = {}) {
+import { MetadataStorage } from '../metadata/MetadataStorage.js';
+import { ReferenceKind } from '../enums.js';
+import { Utils } from '../utils/Utils.js';
+export function Formula(formula, options = {}) {
     return function (target, propertyName) {
-        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target.constructor);
+        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
         meta.properties[propertyName] = {
             name: propertyName,
-            kind: enums_1.ReferenceKind.SCALAR,
+            kind: ReferenceKind.SCALAR,
             formula,
             ...options,
         };
-        return Utils_1.Utils.propertyDecoratorReturnValue();
+        return Utils.propertyDecoratorReturnValue();
     };
 }

package/decorators/Indexed.d.ts

@@ -1,17 +1,19 @@
-import type { AnyEntity, Dictionary } from '../typings';
-import type { DeferMode } from '../enums';
-export declare function Index<T>(options?: IndexOptions<T>): (target: AnyEntity, propertyName?: string) => any;
-export declare function Unique<T>(options?: UniqueOptions<T>): (target: AnyEntity, propertyName?: string) => any;
-interface BaseOptions<T> {
+import type { EntityClass, Dictionary, AutoPath } from '../typings.js';
+import type { DeferMode } from '../enums.js';
+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;
+type MaybeArray<T> = T | T[];
+type Properties<T, H extends string> = MaybeArray<AutoPath<T, H>>;
+interface BaseOptions<T, H extends string> {
     name?: string;
-    properties?: keyof T | (keyof T)[];
+    properties?: (T extends EntityClass<infer P> ? Properties<P, H> : Properties<T, H>);
     options?: Dictionary;
     expression?: string;
 }
-export interface UniqueOptions<T> extends BaseOptions<T> {
+export interface UniqueOptions<T, H extends string = string> extends BaseOptions<T, H> {
     deferMode?: DeferMode | `${DeferMode}`;
 }
-export interface IndexOptions<T> extends BaseOptions<T> {
+export interface IndexOptions<T, H extends string = string> extends BaseOptions<T, H> {
     type?: string;
 }
 export {};

package/decorators/Indexed.js

@@ -1,24 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Index = Index;
-exports.Unique = Unique;
-const metadata_1 = require("../metadata");
-const Utils_1 = require("../utils/Utils");
+import { MetadataStorage } from '../metadata/MetadataStorage.js';
+import { Utils } from '../utils/Utils.js';
 function createDecorator(options, unique) {
     return function (target, propertyName) {
-        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(propertyName ? target.constructor : target);
-        options.properties = options.properties || 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 Utils_1.Utils.propertyDecoratorReturnValue();
+        return Utils.propertyDecoratorReturnValue();
     };
 }
-function Index(options = {}) {
+export function Index(options = {}) {
     return createDecorator(options, false);
 }
-function Unique(options = {}) {
+export function Unique(options = {}) {
     return createDecorator(options, true);
 }

package/decorators/ManyToMany.d.ts

@@ -1,7 +1,7 @@
-import type { ReferenceOptions } from './Property';
-import type { EntityName, AnyEntity, FilterQuery, AnyString } from '../typings';
-import { type QueryOrderMap } from '../enums';
-export declare function ManyToMany<T extends object, O>(entity?: ManyToManyOptions<T, O> | string | (() => EntityName<T>), mappedBy?: (string & keyof T) | ((e: T) => any), options?: Partial<ManyToManyOptions<T, O>>): (target: AnyEntity, propertyName: string) => any;
+import type { ReferenceOptions } from './Property.js';
+import type { EntityName, FilterQuery, AnyString } from '../typings.js';
+import { type QueryOrderMap } from '../enums.js';
+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) => any;
 export interface ManyToManyOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
     /** Set this side as owning. Owning side is where the foreign key is defined. This option is not required if you use `inversedBy` or `mappedBy` to distinguish owning and inverse side. */
     owner?: boolean;

package/decorators/ManyToMany.js

@@ -1,16 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ManyToMany = ManyToMany;
-const metadata_1 = require("../metadata");
-const utils_1 = require("../utils");
-const enums_1 = require("../enums");
-function ManyToMany(entity, mappedBy, options = {}) {
+import { MetadataStorage } from '../metadata/MetadataStorage.js';
+import { MetadataValidator } from '../metadata/MetadataValidator.js';
+import { Utils } from '../utils/Utils.js';
+import { ReferenceKind } from '../enums.js';
+export function ManyToMany(entity, mappedBy, options = {}) {
     return function (target, propertyName) {
-        options = utils_1.Utils.processDecoratorParameters({ entity, mappedBy, options });
-        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target.constructor);
-        metadata_1.MetadataValidator.validateSingleDecorator(meta, propertyName, enums_1.ReferenceKind.MANY_TO_MANY);
-        const property = { name: propertyName, kind: enums_1.ReferenceKind.MANY_TO_MANY };
+        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);
-        return utils_1.Utils.propertyDecoratorReturnValue();
+        return Utils.propertyDecoratorReturnValue();
     };
 }

package/decorators/ManyToOne.d.ts

@@ -1,7 +1,7 @@
-import type { ReferenceOptions } from './Property';
-import { type DeferMode } from '../enums';
-import type { AnyEntity, AnyString, EntityName } from '../typings';
-export declare function ManyToOne<T extends object, O>(entity?: ManyToOneOptions<T, O> | string | ((e?: any) => EntityName<T>), options?: Partial<ManyToOneOptions<T, O>>): (target: AnyEntity, propertyName: string) => any;
+import type { ReferenceOptions } from './Property.js';
+import { type DeferMode } from '../enums.js';
+import type { AnyString, EntityName } from '../typings.js';
+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) => any;
 export interface ManyToOneOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
     /** Point to the inverse side property name. */
     inversedBy?: (string & keyof Target) | ((e: Target) => any);

package/decorators/ManyToOne.js

@@ -1,16 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ManyToOne = ManyToOne;
-const metadata_1 = require("../metadata");
-const utils_1 = require("../utils");
-const enums_1 = require("../enums");
-function ManyToOne(entity = {}, options = {}) {
+import { MetadataStorage } from '../metadata/MetadataStorage.js';
+import { MetadataValidator } from '../metadata/MetadataValidator.js';
+import { Utils } from '../utils/Utils.js';
+import { ReferenceKind } from '../enums.js';
+export function ManyToOne(entity = {}, options = {}) {
     return function (target, propertyName) {
-        options = utils_1.Utils.processDecoratorParameters({ entity, options });
-        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target.constructor);
-        metadata_1.MetadataValidator.validateSingleDecorator(meta, propertyName, enums_1.ReferenceKind.MANY_TO_ONE);
-        const property = { name: propertyName, kind: enums_1.ReferenceKind.MANY_TO_ONE };
+        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);
-        return utils_1.Utils.propertyDecoratorReturnValue();
+        return Utils.propertyDecoratorReturnValue();
     };
 }

package/decorators/OneToMany.d.ts

@@ -1,9 +1,9 @@
-import type { ReferenceOptions } from './Property';
-import { ReferenceKind, type QueryOrderMap } from '../enums';
-import type { EntityName, AnyEntity, FilterQuery } from '../typings';
-export declare function createOneToDecorator<Target, Owner>(entity: OneToManyOptions<Owner, Target> | string | ((e?: any) => EntityName<Target>), mappedBy: (string & keyof Target) | ((e: Target) => any) | undefined, options: Partial<OneToManyOptions<Owner, Target>>, kind: ReferenceKind): (target: AnyEntity, propertyName: string) => any;
-export declare function OneToMany<Target, Owner>(entity: string | ((e?: any) => EntityName<Target>), mappedBy: (string & keyof Target) | ((e: Target) => any), options?: Partial<OneToManyOptions<Owner, Target>>): (target: AnyEntity, propertyName: string) => void;
-export declare function OneToMany<Target, Owner>(options: OneToManyOptions<Owner, Target>): (target: AnyEntity, propertyName: string) => void;
+import type { ReferenceOptions } from './Property.js';
+import { ReferenceKind, type QueryOrderMap } from '../enums.js';
+import type { EntityName, FilterQuery } from '../typings.js';
+export declare function createOneToDecorator<Target, Owner>(entity: OneToManyOptions<Owner, Target> | string | ((e?: any) => EntityName<Target>), mappedBy: (string & keyof Target) | ((e: Target) => any) | undefined, options: Partial<OneToManyOptions<Owner, Target>>, kind: ReferenceKind): (target: Owner, propertyName: string) => any;
+export declare function OneToMany<Target, Owner>(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, Owner>(options: OneToManyOptions<Owner, Target>): (target: Owner, propertyName: string) => void;
 export interface OneToManyOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
     /** Remove the entity when it gets disconnected from the relationship (see {@doclink cascading | Cascading}). */
     orphanRemoval?: boolean;

package/decorators/OneToMany.js

@@ -1,20 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createOneToDecorator = createOneToDecorator;
-exports.OneToMany = OneToMany;
-const metadata_1 = require("../metadata");
-const utils_1 = require("../utils");
-const enums_1 = require("../enums");
-function createOneToDecorator(entity, mappedBy, options, kind) {
+import { MetadataStorage } from '../metadata/MetadataStorage.js';
+import { MetadataValidator } from '../metadata/MetadataValidator.js';
+import { Utils } from '../utils/Utils.js';
+import { ReferenceKind } from '../enums.js';
+export function createOneToDecorator(entity, mappedBy, options, kind) {
     return function (target, propertyName) {
-        options = utils_1.Utils.processDecoratorParameters({ entity, mappedBy, options });
-        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target.constructor);
-        metadata_1.MetadataValidator.validateSingleDecorator(meta, propertyName, kind);
+        options = Utils.processDecoratorParameters({ entity, mappedBy, options });
+        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
+        MetadataValidator.validateSingleDecorator(meta, propertyName, kind);
         const property = { name: propertyName, kind };
         meta.properties[propertyName] = Object.assign(meta.properties[propertyName] ?? {}, property, options);
-        return utils_1.Utils.propertyDecoratorReturnValue();
+        return Utils.propertyDecoratorReturnValue();
     };
 }
-function OneToMany(entity, mappedBy, options = {}) {
-    return createOneToDecorator(entity, mappedBy, options, enums_1.ReferenceKind.ONE_TO_MANY);
+export function OneToMany(entity, mappedBy, options = {}) {
+    return createOneToDecorator(entity, mappedBy, options, ReferenceKind.ONE_TO_MANY);
 }

package/decorators/OneToOne.d.ts

@@ -1,7 +1,7 @@
-import { type DeferMode } from '../enums';
-import { type OneToManyOptions } from './OneToMany';
-import type { AnyString, EntityName } from '../typings';
-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: import("../typings").AnyEntity, propertyName: string) => any;
+import { type DeferMode } from '../enums.js';
+import { type OneToManyOptions } from './OneToMany.js';
+import type { AnyString, EntityName } from '../typings.js';
+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) => any;
 export interface OneToOneOptions<Owner, Target> extends Partial<Omit<OneToManyOptions<Owner, Target>, 'orderBy'>> {
     /** Set this side as owning. Owning side is where the foreign key is defined. This option is not required if you use `inversedBy` or `mappedBy` to distinguish owning and inverse side. */
     owner?: boolean;

package/decorators/OneToOne.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OneToOne = OneToOne;
-const enums_1 = require("../enums");
-const OneToMany_1 = require("./OneToMany");
-function OneToOne(entity, mappedByOrOptions, options = {}) {
+import { ReferenceKind } from '../enums.js';
+import { createOneToDecorator } from './OneToMany.js';
+export function OneToOne(entity, mappedByOrOptions, options = {}) {
     const mappedBy = typeof mappedByOrOptions === 'object' ? mappedByOrOptions.mappedBy : mappedByOrOptions;
     options = typeof mappedByOrOptions === 'object' ? { ...mappedByOrOptions, ...options } : options;
-    return (0, OneToMany_1.createOneToDecorator)(entity, mappedBy, options, enums_1.ReferenceKind.ONE_TO_ONE);
+    return createOneToDecorator(entity, mappedBy, options, ReferenceKind.ONE_TO_ONE);
 }

package/decorators/PrimaryKey.d.ts

@@ -1,7 +1,6 @@
-import type { PropertyOptions } from './Property';
-import type { AnyEntity } from '../typings';
-export declare function PrimaryKey<T extends object>(options?: PrimaryKeyOptions<T>): (target: AnyEntity, propertyName: string) => any;
-export declare function SerializedPrimaryKey<T extends object>(options?: SerializedPrimaryKeyOptions<T>): (target: AnyEntity, propertyName: string) => any;
+import type { PropertyOptions } from './Property.js';
+export declare function PrimaryKey<T extends object>(options?: PrimaryKeyOptions<T>): (target: T, propertyName: string) => any;
+export declare function SerializedPrimaryKey<T extends object>(options?: SerializedPrimaryKeyOptions<T>): (target: T, propertyName: string) => any;
 export interface PrimaryKeyOptions<T> extends PropertyOptions<T> {
 }
 export interface SerializedPrimaryKeyOptions<T> extends PropertyOptions<T> {

package/decorators/PrimaryKey.js

@@ -1,23 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PrimaryKey = PrimaryKey;
-exports.SerializedPrimaryKey = SerializedPrimaryKey;
-const metadata_1 = require("../metadata");
-const enums_1 = require("../enums");
-const Utils_1 = require("../utils/Utils");
+import { MetadataStorage } from '../metadata/MetadataStorage.js';
+import { MetadataValidator } from '../metadata/MetadataValidator.js';
+import { ReferenceKind } from '../enums.js';
+import { Utils } from '../utils/Utils.js';
 function createDecorator(options, serialized) {
     return function (target, propertyName) {
-        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target.constructor);
-        metadata_1.MetadataValidator.validateSingleDecorator(meta, propertyName, enums_1.ReferenceKind.SCALAR);
+        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: enums_1.ReferenceKind.SCALAR, ...options };
-        return Utils_1.Utils.propertyDecoratorReturnValue();
+        meta.properties[propertyName] = { name: propertyName, kind: ReferenceKind.SCALAR, ...options };
+        return Utils.propertyDecoratorReturnValue();
     };
 }
-function PrimaryKey(options = {}) {
+export function PrimaryKey(options = {}) {
     return createDecorator(options, false);
 }
-function SerializedPrimaryKey(options = {}) {
+export function SerializedPrimaryKey(options = {}) {
     return createDecorator(options, true);
 }

package/decorators/Property.d.ts

@@ -1,9 +1,9 @@
-import { type Cascade, type LoadStrategy } from '../enums';
-import type { EntityName, Constructor, CheckCallback, GeneratedColumnCallback, AnyString, AnyEntity } from '../typings';
-import type { Type, types } from '../types';
-import type { EntityManager } from '../EntityManager';
-import type { SerializeOptions } from '../serialization/EntitySerializer';
-export declare function Property<T extends object>(options?: PropertyOptions<T>): (target: any, propertyName: string) => any;
+import { type Cascade, type LoadStrategy } from '../enums.js';
+import type { EntityName, Constructor, CheckCallback, GeneratedColumnCallback, AnyString, AnyEntity } from '../typings.js';
+import type { Type, types } from '../types/index.js';
+import type { EntityManager } from '../EntityManager.js';
+import type { SerializeOptions } from '../serialization/EntitySerializer.js';
+export declare function Property<T extends object>(options?: PropertyOptions<T>): (target: T, propertyName: string) => any;
 export interface PropertyOptions<Owner> {
     /**
      * Alias for `fieldName`.

package/decorators/Property.js

@@ -1,21 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Property = Property;
-const metadata_1 = require("../metadata");
-const utils_1 = require("../utils");
-const enums_1 = require("../enums");
-function Property(options = {}) {
+import { MetadataStorage } from '../metadata/MetadataStorage.js';
+import { MetadataValidator } from '../metadata/MetadataValidator.js';
+import { Utils } from '../utils/Utils.js';
+import { ReferenceKind } from '../enums.js';
+export function Property(options = {}) {
     return function (target, propertyName) {
-        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target.constructor);
+        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
         const desc = Object.getOwnPropertyDescriptor(target, propertyName) || {};
-        metadata_1.MetadataValidator.validateSingleDecorator(meta, propertyName, enums_1.ReferenceKind.SCALAR);
+        MetadataValidator.validateSingleDecorator(meta, propertyName, ReferenceKind.SCALAR);
         const name = options.name || propertyName;
         if (propertyName !== name && !(desc.value instanceof Function)) {
-            utils_1.Utils.renameKey(options, 'name', 'fieldName');
+            Utils.renameKey(options, 'name', 'fieldName');
         }
         options.name = propertyName;
         const { check, ...opts } = options;
-        const prop = { kind: enums_1.ReferenceKind.SCALAR, ...opts };
+        const prop = { kind: ReferenceKind.SCALAR, ...opts };
         prop.getter = !!desc.get;
         prop.setter = !!desc.set;
         if (desc.value instanceof Function) {
@@ -29,6 +27,6 @@ function Property(options = {}) {
             meta.checks.push({ property: prop.name, expression: check });
         }
         meta.properties[prop.name] = prop;
-        return utils_1.Utils.propertyDecoratorReturnValue();
+        return Utils.propertyDecoratorReturnValue();
     };
 }

package/decorators/Transactional.d.ts

@@ -1,5 +1,5 @@
-import type { TransactionOptions } from '../enums';
-import type { ContextProvider } from '../typings';
+import type { TransactionOptions } from '../enums.js';
+import type { ContextProvider } from '../typings.js';
 type TransactionalOptions<T> = TransactionOptions & {
     context?: ContextProvider<T>;
 };

package/decorators/Transactional.js

@@ -1,16 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Transactional = Transactional;
-const RequestContext_1 = require("../utils/RequestContext");
-const resolveContextProvider_1 = require("../utils/resolveContextProvider");
-const TransactionContext_1 = require("../utils/TransactionContext");
+import { RequestContext } from '../utils/RequestContext.js';
+import { resolveContextProvider } from '../utils/resolveContextProvider.js';
+import { TransactionContext } from '../utils/TransactionContext.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()`.
  */
-function Transactional(options = {}) {
+export function Transactional(options = {}) {
     return function (target, propertyKey, descriptor) {
         const originalMethod = descriptor.value;
         if (originalMethod.constructor.name !== 'AsyncFunction') {
@@ -18,9 +15,9 @@ function Transactional(options = {}) {
         }
         descriptor.value = async function (...args) {
             const { context, ...txOptions } = options;
-            const em = await (0, resolveContextProvider_1.resolveContextProvider)(this, context)
-                || TransactionContext_1.TransactionContext.getEntityManager()
-                || RequestContext_1.RequestContext.getEntityManager();
+            const em = (await resolveContextProvider(this, context))
+                || TransactionContext.getEntityManager()
+                || RequestContext.getEntityManager();
             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.`);
             }