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

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,5 +1,5 @@
-import type { Constructor, Dictionary, FilterQuery } from '../typings';
-import type { FindOptions } from '../drivers/IDatabaseDriver';
+import type { Constructor, Dictionary, FilterQuery } from '../typings.js';
+import type { FindOptions } from '../drivers/IDatabaseDriver.js';
 export declare function Entity(options?: EntityOptions<any>): <T>(target: T & Dictionary) => T & Dictionary;
 export type EntityOptions<T> = {
     tableName?: string;

package/decorators/Entity.js

@@ -1,12 +1,9 @@
-"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;

package/decorators/Enum.d.ts

@@ -1,5 +1,5 @@
-import type { PropertyOptions } from './Property';
-import type { AnyEntity, Dictionary } from '../typings';
+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: AnyEntity, propertyName: string) => any;
 export interface EnumOptions<T> extends PropertyOptions<T> {
     items?: (number | string)[] | (() => Dictionary);

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,5 @@
-import type { AnyEntity } from '../typings';
-import type { PropertyOptions } from './Property';
+import type { AnyEntity } from '../typings.js';
+import type { PropertyOptions } from './Property.js';
 export declare function Formula<T extends object>(formula: string | ((alias: string) => string), options?: FormulaOptions<T>): (target: AnyEntity, 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,5 +1,5 @@
-import type { AnyEntity, Dictionary } from '../typings';
-import type { DeferMode } from '../enums';
+import type { AnyEntity, Dictionary } from '../typings.js';
+import type { DeferMode } from '../enums.js';
 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> {

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);
+        const meta = MetadataStorage.getMetadataFromDecorator(propertyName ? target.constructor : target);
         options.properties = 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,6 +1,6 @@
-import type { ReferenceOptions } from './Property';
-import type { EntityName, AnyEntity, FilterQuery, AnyString } from '../typings';
-import { type QueryOrderMap } from '../enums';
+import type { ReferenceOptions } from './Property.js';
+import type { EntityName, AnyEntity, FilterQuery, AnyString } from '../typings.js';
+import { type QueryOrderMap } from '../enums.js';
 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;
 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. */

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,6 +1,6 @@
-import type { ReferenceOptions } from './Property';
-import { type DeferMode } from '../enums';
-import type { AnyEntity, AnyString, EntityName } from '../typings';
+import type { ReferenceOptions } from './Property.js';
+import { type DeferMode } from '../enums.js';
+import type { AnyEntity, AnyString, EntityName } from '../typings.js';
 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;
 export interface ManyToOneOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
     /** Point to the inverse side property name. */

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,6 +1,6 @@
-import type { ReferenceOptions } from './Property';
-import { ReferenceKind, type QueryOrderMap } from '../enums';
-import type { EntityName, AnyEntity, FilterQuery } from '../typings';
+import type { ReferenceOptions } from './Property.js';
+import { ReferenceKind, type QueryOrderMap } from '../enums.js';
+import type { EntityName, AnyEntity, 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: 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;

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: import("../typings.js").AnyEntity, 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,5 +1,5 @@
-import type { PropertyOptions } from './Property';
-import type { AnyEntity } from '../typings';
+import type { PropertyOptions } from './Property.js';
+import type { AnyEntity } from '../typings.js';
 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;
 export interface PrimaryKeyOptions<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,8 +1,8 @@
-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';
+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: any, propertyName: string) => any;
 export interface PropertyOptions<Owner> {
     /**

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.`);
             }

package/decorators/hooks.js

@@ -1,59 +1,47 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BeforeCreate = BeforeCreate;
-exports.AfterCreate = AfterCreate;
-exports.BeforeUpdate = BeforeUpdate;
-exports.AfterUpdate = AfterUpdate;
-exports.BeforeUpsert = BeforeUpsert;
-exports.AfterUpsert = AfterUpsert;
-exports.OnInit = OnInit;
-exports.OnLoad = OnLoad;
-exports.BeforeDelete = BeforeDelete;
-exports.AfterDelete = AfterDelete;
-const metadata_1 = require("../metadata");
-const enums_1 = require("../enums");
+import { MetadataStorage } from '../metadata/MetadataStorage.js';
+import { EventType } from '../enums.js';
 function hook(type) {
     return function (target, method) {
-        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target.constructor);
+        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
         if (!meta.hooks[type]) {
             meta.hooks[type] = [];
         }
         meta.hooks[type].push(method);
     };
 }
-function BeforeCreate() {
-    return hook(enums_1.EventType.beforeCreate);
+export function BeforeCreate() {
+    return hook(EventType.beforeCreate);
 }
-function AfterCreate() {
-    return hook(enums_1.EventType.afterCreate);
+export function AfterCreate() {
+    return hook(EventType.afterCreate);
 }
-function BeforeUpdate() {
-    return hook(enums_1.EventType.beforeUpdate);
+export function BeforeUpdate() {
+    return hook(EventType.beforeUpdate);
 }
-function AfterUpdate() {
-    return hook(enums_1.EventType.afterUpdate);
+export function AfterUpdate() {
+    return hook(EventType.afterUpdate);
 }
-function BeforeUpsert() {
-    return hook(enums_1.EventType.beforeUpsert);
+export function BeforeUpsert() {
+    return hook(EventType.beforeUpsert);
 }
-function AfterUpsert() {
-    return hook(enums_1.EventType.afterUpsert);
+export function AfterUpsert() {
+    return hook(EventType.afterUpsert);
 }
-function OnInit() {
-    return hook(enums_1.EventType.onInit);
+export function OnInit() {
+    return hook(EventType.onInit);
 }
-function OnLoad() {
-    return hook(enums_1.EventType.onLoad);
+export function OnLoad() {
+    return hook(EventType.onLoad);
 }
 /**
  * Called before deleting entity, but only when providing initialized entity to EM#remove()
  */
-function BeforeDelete() {
-    return hook(enums_1.EventType.beforeDelete);
+export function BeforeDelete() {
+    return hook(EventType.beforeDelete);
 }
 /**
  * Called after deleting entity, but only when providing initialized entity to EM#remove()
  */
-function AfterDelete() {
-    return hook(enums_1.EventType.afterDelete);
+export function AfterDelete() {
+    return hook(EventType.afterDelete);
 }

package/decorators/index.d.ts

@@ -1,17 +1,17 @@
-export * from './PrimaryKey';
-export * from './Entity';
-export * from './OneToOne';
-export * from './ManyToOne';
-export * from './ManyToMany';
-export { OneToMany, OneToManyOptions } from './OneToMany';
-export * from './Property';
-export * from './Check';
-export * from './Enum';
-export * from './Formula';
-export * from './Indexed';
-export * from './Embeddable';
-export * from './Embedded';
-export * from './Filter';
-export * from './CreateRequestContext';
-export * from './hooks';
-export * from './Transactional';
+export * from './PrimaryKey.js';
+export * from './Entity.js';
+export * from './OneToOne.js';
+export * from './ManyToOne.js';
+export * from './ManyToMany.js';
+export { OneToMany, OneToManyOptions } 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';