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

package/entity/EntityValidator.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityValidator = void 0;
-const enums_1 = require("../enums");
-const Utils_1 = require("../utils/Utils");
-const errors_1 = require("../errors");
-const wrap_1 = require("./wrap");
-const RawQueryFragment_1 = require("../utils/RawQueryFragment");
-class EntityValidator {
+import { ReferenceKind } from '../enums.js';
+import { Utils } from '../utils/Utils.js';
+import { ValidationError } from '../errors.js';
+import { helper } from './wrap.js';
+import { RawQueryFragment } from '../utils/RawQueryFragment.js';
+export class EntityValidator {
     strict;
     KNOWN_TYPES = new Set(['string', 'number', 'boolean', 'bigint', 'Uint8Array', 'Date', 'Buffer', 'RegExp']);
     constructor(strict) {
@@ -17,11 +14,11 @@ class EntityValidator {
             if (prop.inherited) {
                 return;
             }
-            if ([enums_1.ReferenceKind.ONE_TO_MANY, enums_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
+            if ([ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
                 this.validateCollection(entity, prop);
             }
             const SCALAR_TYPES = ['string', 'number', 'boolean', 'Date'];
-            if (prop.kind !== enums_1.ReferenceKind.SCALAR || !SCALAR_TYPES.includes(prop.type)) {
+            if (prop.kind !== ReferenceKind.SCALAR || !SCALAR_TYPES.includes(prop.type)) {
                 return;
             }
             const newValue = this.validateProperty(prop, this.getValue(payload, prop), entity);
@@ -29,14 +26,13 @@ class EntityValidator {
                 return;
             }
             this.setValue(payload, prop, newValue);
-            /* istanbul ignore else */
             if (entity[prop.name]) {
                 entity[prop.name] = payload[prop.name];
             }
         });
     }
     validateRequired(entity) {
-        const wrapped = (0, wrap_1.helper)(entity);
+        const wrapped = helper(entity);
         for (const prop of wrapped.__meta.props) {
             if (!prop.nullable &&
                 !prop.autoincrement &&
@@ -45,47 +41,48 @@ class EntityValidator {
                 !prop.onCreate &&
                 !prop.generated &&
                 !prop.embedded &&
-                ![enums_1.ReferenceKind.ONE_TO_MANY, enums_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind) &&
+                ![ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind) &&
                 prop.name !== wrapped.__meta.root.discriminatorColumn &&
                 prop.type.toLowerCase() !== 'objectid' &&
                 prop.persist !== false &&
                 entity[prop.name] == null) {
-                throw errors_1.ValidationError.propertyRequired(entity, prop);
+                throw ValidationError.propertyRequired(entity, prop);
             }
         }
     }
     validateProperty(prop, givenValue, entity) {
-        if (givenValue == null || givenValue instanceof RawQueryFragment_1.RawQueryFragment) {
+        if (givenValue == null || givenValue instanceof RawQueryFragment) {
             return givenValue;
         }
         const expectedType = prop.runtimeType;
         const propName = prop.embedded ? prop.name.replace(/~/g, '.') : prop.name;
-        let givenType = Utils_1.Utils.getObjectType(givenValue);
+        let givenType = Utils.getObjectType(givenValue);
         let ret = givenValue;
         if (!this.strict) {
             ret = this.fixTypes(expectedType, givenType, givenValue);
-            givenType = Utils_1.Utils.getObjectType(ret);
+            givenType = Utils.getObjectType(ret);
         }
         if (prop.enum && prop.items) {
+            /* v8 ignore next 3 */
             if (!prop.items.some(it => it === givenValue)) {
-                throw errors_1.ValidationError.fromWrongPropertyType(entity, propName, expectedType, givenType, givenValue);
+                throw ValidationError.fromWrongPropertyType(entity, propName, expectedType, givenType, givenValue);
             }
         }
         else {
             if (givenType !== expectedType && this.KNOWN_TYPES.has(expectedType)) {
-                throw errors_1.ValidationError.fromWrongPropertyType(entity, propName, expectedType, givenType, givenValue);
+                throw ValidationError.fromWrongPropertyType(entity, propName, expectedType, givenType, givenValue);
             }
         }
         return ret;
     }
     validateParams(params, type = 'search condition', field) {
-        if (Utils_1.Utils.isPrimaryKey(params) || Utils_1.Utils.isEntity(params)) {
+        if (Utils.isPrimaryKey(params) || Utils.isEntity(params)) {
             return;
         }
         if (Array.isArray(params)) {
             return params.forEach(item => this.validateParams(item, type, field));
         }
-        if (Utils_1.Utils.isPlainObject(params)) {
+        if (Utils.isPlainObject(params)) {
             Object.keys(params).forEach(k => {
                 this.validateParams(params[k], type, k);
             });
@@ -94,11 +91,11 @@ class EntityValidator {
     validatePrimaryKey(entity, meta) {
         const pkExists = meta.primaryKeys.every(pk => entity[pk] != null) || entity[meta.serializedPrimaryKey] != null;
         if (!entity || !pkExists) {
-            throw errors_1.ValidationError.fromMergeWithoutPK(meta);
+            throw ValidationError.fromMergeWithoutPK(meta);
         }
     }
     validateEmptyWhere(where) {
-        if (Utils_1.Utils.isEmpty(where)) {
+        if (Utils.isEmpty(where)) {
             throw new Error(`You cannot call 'EntityManager.findOne()' with empty 'where' parameter`);
         }
     }
@@ -109,15 +106,15 @@ class EntityValidator {
         return o[prop.name];
     }
     setValue(o, prop, v) {
-        /* istanbul ignore next */
+        /* v8 ignore next 3 */
         if (prop.embedded && prop.embedded[0] in o) {
             return o[prop.embedded[0]][prop.embedded[1]] = v;
         }
         o[prop.name] = v;
     }
     validateCollection(entity, prop) {
-        if (prop.hydrate !== false && (0, wrap_1.helper)(entity).__initialized && !entity[prop.name]) {
-            throw errors_1.ValidationError.fromCollectionNotInitialized(entity, prop);
+        if (prop.hydrate !== false && helper(entity).__initialized && !entity[prop.name]) {
+            throw ValidationError.fromCollectionNotInitialized(entity, prop);
         }
     }
     fixTypes(expectedType, givenType, givenValue) {
@@ -134,7 +131,7 @@ class EntityValidator {
     }
     fixDateType(givenValue) {
         let date;
-        if (Utils_1.Utils.isString(givenValue) && givenValue.match(/^-?\d+(\.\d+)?$/)) {
+        if (Utils.isString(givenValue) && givenValue.match(/^-?\d+(\.\d+)?$/)) {
             date = new Date(+givenValue);
         }
         else {
@@ -151,4 +148,3 @@ class EntityValidator {
         return +bool === givenValue ? bool : givenValue;
     }
 }
-exports.EntityValidator = EntityValidator;

package/entity/Reference.d.ts

@@ -1,6 +1,6 @@
 import { inspect } from 'node:util';
-import type { AddEager, Dictionary, EntityClass, EntityKey, EntityProperty, Loaded, LoadedReference, Primary, Ref } from '../typings';
-import type { FindOneOptions, FindOneOrFailOptions } from '../drivers/IDatabaseDriver';
+import type { AddEager, Dictionary, EntityClass, EntityKey, EntityProperty, Loaded, LoadedReference, Primary, Ref } from '../typings.js';
+import type { FindOneOptions, FindOneOrFailOptions } from '../drivers/IDatabaseDriver.js';
 export declare class Reference<T extends object> {
     private entity;
     constructor(entity: T);

package/entity/Reference.js

@@ -1,18 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Ref = exports.ScalarReference = exports.Reference = void 0;
-exports.ref = ref;
-exports.rel = rel;
-const node_util_1 = require("node:util");
-const enums_1 = require("../enums");
-const wrap_1 = require("./wrap");
-const Utils_1 = require("../utils/Utils");
-class Reference {
+import { inspect } from 'node:util';
+import { DataloaderType } from '../enums.js';
+import { helper, wrap } from './wrap.js';
+import { Utils } from '../utils/Utils.js';
+export class Reference {
     entity;
     constructor(entity) {
         this.entity = entity;
         this.set(entity);
-        const meta = (0, wrap_1.helper)(this.entity).__meta;
+        const meta = helper(this.entity).__meta;
         meta.primaryKeys.forEach(primaryKey => {
             Object.defineProperty(this, primaryKey, {
                 get() {
@@ -23,14 +18,14 @@ class Reference {
         if (meta.serializedPrimaryKey && meta.primaryKeys[0] !== meta.serializedPrimaryKey) {
             Object.defineProperty(this, meta.serializedPrimaryKey, {
                 get() {
-                    return (0, wrap_1.helper)(this.entity).getSerializedPrimaryKey();
+                    return helper(this.entity).getSerializedPrimaryKey();
                 },
             });
         }
     }
     static create(entity) {
         const unwrapped = Reference.unwrapReference(entity);
-        const ref = (0, wrap_1.helper)(entity).toReference();
+        const ref = helper(entity).toReference();
         if (unwrapped !== ref.unwrap()) {
             ref.set(unwrapped);
         }
@@ -38,7 +33,7 @@ class Reference {
     }
     static createFromPK(entityType, pk, options) {
         const ref = this.createNakedFromPK(entityType, pk, options);
-        return (0, wrap_1.helper)(ref).toReference();
+        return helper(ref).toReference();
     }
     static createNakedFromPK(entityType, pk, options) {
         const factory = entityType.prototype.__factory;
@@ -47,7 +42,7 @@ class Reference {
             convertCustomTypes: false,
             ...options,
         });
-        const wrapped = (0, wrap_1.helper)(entity);
+        const wrapped = helper(entity);
         wrapped.__meta.primaryKeys.forEach(key => wrapped.__loadedProperties.add(key));
         wrapped.__originalEntityData = factory.getComparator().prepareEntity(entity);
         return entity;
@@ -79,7 +74,7 @@ class Reference {
      * the method returns `null`. Use `loadOrFail()` if you want an error to be thrown in such a case.
      */
     async load(options = {}) {
-        const wrapped = (0, wrap_1.helper)(this.entity);
+        const wrapped = helper(this.entity);
         if (!wrapped.__em) {
             return this.entity;
         }
@@ -87,7 +82,7 @@ class Reference {
             await wrapped.__em.populate(this.entity, options.populate, options);
         }
         if (!this.isInitialized() || options.refresh) {
-            if (options.dataloader ?? [enums_1.DataloaderType.ALL, enums_1.DataloaderType.REFERENCE].includes(wrapped.__em.config.getDataloaderType())) {
+            if (options.dataloader ?? [DataloaderType.ALL, DataloaderType.REFERENCE].includes(wrapped.__em.config.getDataloaderType())) {
                 // eslint-disable-next-line dot-notation
                 return wrapped.__em['refLoader'].load([this, options]);
             }
@@ -102,7 +97,7 @@ class Reference {
     async loadOrFail(options = {}) {
         const ret = await this.load(options);
         if (!ret) {
-            const wrapped = (0, wrap_1.helper)(this.entity);
+            const wrapped = helper(this.entity);
             options.failHandler ??= wrapped.__em.config.get('findOneOrFailHandler');
             const entityName = this.entity.constructor.name;
             const where = wrapped.getPrimaryKey();
@@ -112,14 +107,14 @@ class Reference {
     }
     set(entity) {
         this.entity = Reference.unwrapReference(entity);
-        delete (0, wrap_1.helper)(this.entity).__reference;
+        delete helper(this.entity).__reference;
     }
     unwrap() {
         return this.entity;
     }
     getEntity() {
         if (!this.isInitialized()) {
-            throw new Error(`Reference<${(0, wrap_1.helper)(this.entity).__meta.name}> ${(0, wrap_1.helper)(this.entity).getPrimaryKey()} not initialized`);
+            throw new Error(`Reference<${helper(this.entity).__meta.name}> ${helper(this.entity).getPrimaryKey()} not initialized`);
         }
         return this.entity;
     }
@@ -131,31 +126,29 @@ class Reference {
         return this.getEntity()[prop];
     }
     isInitialized() {
-        return (0, wrap_1.helper)(this.entity).__initialized;
+        return helper(this.entity).__initialized;
     }
     populated(populated) {
-        (0, wrap_1.helper)(this.entity).populated(populated);
+        helper(this.entity).populated(populated);
     }
     toJSON(...args) {
-        return (0, wrap_1.wrap)(this.entity).toJSON(...args);
+        return wrap(this.entity).toJSON(...args);
     }
-    /* istanbul ignore next */
     /** @ignore */
-    [node_util_1.inspect.custom](depth = 2) {
+    [inspect.custom](depth = 2) {
         const object = { ...this };
         const hidden = ['meta'];
         hidden.forEach(k => delete object[k]);
-        const ret = (0, node_util_1.inspect)(object, { depth });
-        const wrapped = (0, wrap_1.helper)(this.entity);
+        const ret = inspect(object, { depth });
+        const wrapped = helper(this.entity);
         const meta = wrapped.__meta;
+        /* v8 ignore next */
         const pk = wrapped.hasPrimaryKey() ? '<' + wrapped.getSerializedPrimaryKey() + '>' : '';
         const name = `Ref<${meta.className}${pk}>`;
         return ret === '[Object]' ? `[${name}]` : name + ' ' + ret;
     }
 }
-exports.Reference = Reference;
-exports.Ref = Reference;
-class ScalarReference {
+export class ScalarReference {
     value;
     initialized;
     entity;
@@ -174,7 +167,7 @@ class ScalarReference {
             if (this.entity == null || this.property == null) {
                 throw new Error('Cannot load scalar reference that is not bound to an entity property.');
             }
-            await (0, wrap_1.helper)(this.entity).populate([this.property], opts);
+            await helper(this.entity).populate([this.property], opts);
         }
         return this.value;
     }
@@ -193,13 +186,12 @@ class ScalarReference {
     isInitialized() {
         return this.initialized;
     }
-    /* istanbul ignore next */
+    /* v8 ignore next 4 */
     /** @ignore */
-    [node_util_1.inspect.custom]() {
-        return this.initialized ? `Ref<${(0, node_util_1.inspect)(this.value)}>` : `Ref<?>`;
+    [inspect.custom]() {
+        return this.initialized ? `Ref<${inspect(this.value)}>` : `Ref<?>`;
     }
 }
-exports.ScalarReference = ScalarReference;
 Object.defineProperties(Reference.prototype, {
     __reference: { value: true, enumerable: false },
     __meta: { get() { return this.entity.__meta; } },
@@ -216,15 +208,15 @@ Object.defineProperties(ScalarReference.prototype, {
 /**
  * shortcut for `wrap(entity).toReference()`
  */
-function ref(entityOrType, pk) {
+export function ref(entityOrType, pk) {
     if (entityOrType == null) {
         return entityOrType;
     }
-    if (Utils_1.Utils.isEntity(entityOrType, true)) {
-        return (0, wrap_1.helper)(entityOrType).toReference();
+    if (Utils.isEntity(entityOrType, true)) {
+        return helper(entityOrType).toReference();
     }
-    if (Utils_1.Utils.isEntity(pk, true)) {
-        return (0, wrap_1.helper)(pk).toReference();
+    if (Utils.isEntity(pk, true)) {
+        return helper(pk).toReference();
     }
     if (arguments.length === 1) {
         return new ScalarReference(entityOrType, true);
@@ -237,9 +229,10 @@ function ref(entityOrType, pk) {
 /**
  * shortcut for `Reference.createNakedFromPK(entityType, pk)`
  */
-function rel(entityType, pk) {
-    if (pk == null || Utils_1.Utils.isEntity(pk)) {
+export function rel(entityType, pk) {
+    if (pk == null || Utils.isEntity(pk)) {
         return pk;
     }
     return Reference.createNakedFromPK(entityType, pk);
 }
+export { Reference as Ref };

package/entity/WrappedEntity.d.ts

@@ -1,14 +1,14 @@
-import type { PopulatePath } from '../enums';
+import type { PopulatePath } from '../enums.js';
 import { inspect } from 'node:util';
-import type { EntityManager } from '../EntityManager';
-import type { Dictionary, EntityData, EntityDictionary, EntityMetadata, IHydrator, EntityKey, PopulateOptions, Primary, AutoPath, Ref, AddEager, LoadedReference, EntityDTO, Loaded, FromEntityType, IsSubset, MergeSelected } from '../typings';
-import { Reference } from './Reference';
-import { type AssignOptions } from './EntityAssigner';
-import type { EntityLoaderOptions } from './EntityLoader';
-import type { EntityIdentifier } from './EntityIdentifier';
-import type { SerializationContext } from '../serialization/SerializationContext';
-import { type SerializeOptions } from '../serialization/EntitySerializer';
-import type { FindOneOptions, LoadHint } from '../drivers/IDatabaseDriver';
+import type { EntityManager } from '../EntityManager.js';
+import type { Dictionary, EntityData, EntityDictionary, EntityMetadata, IHydrator, EntityKey, PopulateOptions, Primary, AutoPath, Ref, AddEager, LoadedReference, EntityDTO, Loaded, FromEntityType, IsSubset, MergeSelected } from '../typings.js';
+import { Reference } from './Reference.js';
+import { type AssignOptions } from './EntityAssigner.js';
+import type { EntityLoaderOptions } from './EntityLoader.js';
+import type { EntityIdentifier } from './EntityIdentifier.js';
+import type { SerializationContext } from '../serialization/SerializationContext.js';
+import { type SerializeOptions } from '../serialization/EntitySerializer.js';
+import type { FindOneOptions, LoadHint } from '../drivers/IDatabaseDriver.js';
 export declare class WrappedEntity<Entity extends object> {
     __initialized: boolean;
     __touched: boolean;
@@ -61,8 +61,8 @@ export declare class WrappedEntity<Entity extends object> {
     setPrimaryKey(id: Primary<Entity> | null): void;
     getSerializedPrimaryKey(): string;
     get __meta(): EntityMetadata<Entity>;
-    get __platform(): import("..").Platform;
-    get __config(): import("..").Configuration<import("../drivers/IDatabaseDriver").IDatabaseDriver<import("..").Connection>, EntityManager<import("../drivers/IDatabaseDriver").IDatabaseDriver<import("..").Connection>>>;
+    get __platform(): import("../index.js").Platform;
+    get __config(): import("../index.js").Configuration<import("../drivers/IDatabaseDriver.js").IDatabaseDriver<import("../index.js").Connection>, EntityManager<import("../drivers/IDatabaseDriver.js").IDatabaseDriver<import("../index.js").Connection>>>;
     get __primaryKeys(): Primary<Entity>[];
     /** @ignore */
     [inspect.custom](): string;

package/entity/WrappedEntity.js

@@ -1,16 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WrappedEntity = void 0;
-const node_util_1 = require("node:util");
-const Reference_1 = require("./Reference");
-const EntityTransformer_1 = require("../serialization/EntityTransformer");
-const EntityAssigner_1 = require("./EntityAssigner");
-const Utils_1 = require("../utils/Utils");
-const errors_1 = require("../errors");
-const wrap_1 = require("./wrap");
-const EntitySerializer_1 = require("../serialization/EntitySerializer");
-const utils_1 = require("./utils");
-class WrappedEntity {
+import { inspect } from 'node:util';
+import { Reference } from './Reference.js';
+import { EntityTransformer } from '../serialization/EntityTransformer.js';
+import { EntityAssigner } from './EntityAssigner.js';
+import { Utils } from '../utils/Utils.js';
+import { ValidationError } from '../errors.js';
+import { helper } from './wrap.js';
+import { EntitySerializer } from '../serialization/EntitySerializer.js';
+import { expandDotPaths } from './utils.js';
+export class WrappedEntity {
     constructor(entity, hydrator, pkGetter, pkSerializer, pkGetterConverted) {
         this.entity = entity;
         this.hydrator = hydrator;
@@ -39,7 +36,7 @@ class WrappedEntity {
     setSerializationContext(options) {
         const exclude = options.exclude ?? [];
         const context = this.__serializationContext;
-        const populate = (0, utils_1.expandDotPaths)(this.__meta, options.populate);
+        const populate = expandDotPaths(this.__meta, options.populate);
         context.populate = context.populate ? context.populate.concat(populate) : populate;
         context.exclude = context.exclude ? context.exclude.concat(exclude) : exclude;
         if (context.fields && options.fields) {
@@ -53,17 +50,17 @@ class WrappedEntity {
         }
     }
     toReference() {
-        this.__reference ??= new Reference_1.Reference(this.entity);
+        this.__reference ??= new Reference(this.entity);
         return this.__reference;
     }
     toObject(ignoreFields) {
-        return EntityTransformer_1.EntityTransformer.toObject(this.entity, ignoreFields);
+        return EntityTransformer.toObject(this.entity, ignoreFields);
     }
     serialize(options) {
-        return EntitySerializer_1.EntitySerializer.serialize(this.entity, options);
+        return EntitySerializer.serialize(this.entity, options);
     }
     toPOJO() {
-        return EntityTransformer_1.EntityTransformer.toObject(this.entity, [], true);
+        return EntityTransformer.toObject(this.entity, [], true);
     }
     toJSON(...args) {
         // toJSON methods is added to the prototype during discovery to support automatic serialization via JSON.stringify()
@@ -73,17 +70,17 @@ class WrappedEntity {
         if ('assign' in this.entity) {
             return this.entity.assign(data, options);
         }
-        return EntityAssigner_1.EntityAssigner.assign(this.entity, data, options);
+        return EntityAssigner.assign(this.entity, data, options);
     }
     async init(options) {
         if (!this.__em) {
-            throw errors_1.ValidationError.entityNotManaged(this.entity);
+            throw ValidationError.entityNotManaged(this.entity);
         }
         return this.__em.findOne(this.entity.constructor.name, this.entity, { ...options, refresh: true, schema: this.__schema });
     }
     async populate(populate, options = {}) {
         if (!this.__em) {
-            throw errors_1.ValidationError.entityNotManaged(this.entity);
+            throw ValidationError.entityNotManaged(this.entity);
         }
         // @ts-ignore hard to type
         await this.__em.populate(this.entity, populate, options);
@@ -99,7 +96,7 @@ class WrappedEntity {
             return null;
         }
         if (this.__pk != null && this.__meta.compositePK) {
-            return Utils_1.Utils.getCompositeKeyValue(this.__pk, this.__meta, convertCustomTypes ? 'convertToDatabaseValue' : false, this.__platform);
+            return Utils.getCompositeKeyValue(this.__pk, this.__meta, convertCustomTypes ? 'convertToDatabaseValue' : false, this.__platform);
         }
         if (convertCustomTypes && this.__pk != null && prop.customType) {
             return prop.customType.convertToDatabaseValue(this.__pk, this.__platform);
@@ -118,8 +115,8 @@ class WrappedEntity {
         if (this.__meta.compositePK) {
             return this.__meta.primaryKeys.reduce((ret, pk) => {
                 const child = this.entity[pk];
-                if (Utils_1.Utils.isEntity(child, true)) {
-                    const childPk = (0, wrap_1.helper)(child).getPrimaryKeys(convertCustomTypes);
+                if (Utils.isEntity(child, true)) {
+                    const childPk = helper(child).getPrimaryKeys(convertCustomTypes);
                     ret.push(...childPk);
                 }
                 else {
@@ -153,11 +150,10 @@ class WrappedEntity {
         return this.__em?.config ?? this.entity.__config;
     }
     get __primaryKeys() {
-        return Utils_1.Utils.getPrimaryKeyValues(this.entity, this.__meta.primaryKeys);
+        return Utils.getPrimaryKeyValues(this.entity, this.__meta.primaryKeys);
     }
     /** @ignore */
-    [node_util_1.inspect.custom]() {
+    [inspect.custom]() {
         return `[WrappedEntity<${this.__meta.className}>]`;
     }
 }
-exports.WrappedEntity = WrappedEntity;

package/entity/index.d.ts

@@ -1,13 +1,13 @@
-export * from './EntityRepository';
-export * from './EntityIdentifier';
-export * from './EntityValidator';
-export * from './EntityAssigner';
-export * from './EntityHelper';
-export * from './EntityFactory';
-export * from './ArrayCollection';
-export * from './Collection';
-export * from './EntityLoader';
-export * from './Reference';
-export * from './BaseEntity';
-export * from './WrappedEntity';
-export * from './wrap';
+export * from './EntityRepository.js';
+export * from './EntityIdentifier.js';
+export * from './EntityValidator.js';
+export * from './EntityAssigner.js';
+export * from './EntityHelper.js';
+export * from './EntityFactory.js';
+export * from './ArrayCollection.js';
+export * from './Collection.js';
+export * from './EntityLoader.js';
+export * from './Reference.js';
+export * from './BaseEntity.js';
+export * from './WrappedEntity.js';
+export * from './wrap.js';

package/entity/index.js

@@ -1,29 +1,13 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./EntityRepository"), exports);
-__exportStar(require("./EntityIdentifier"), exports);
-__exportStar(require("./EntityValidator"), exports);
-__exportStar(require("./EntityAssigner"), exports);
-__exportStar(require("./EntityHelper"), exports);
-__exportStar(require("./EntityFactory"), exports);
-__exportStar(require("./ArrayCollection"), exports);
-__exportStar(require("./Collection"), exports);
-__exportStar(require("./EntityLoader"), exports);
-__exportStar(require("./Reference"), exports);
-__exportStar(require("./BaseEntity"), exports);
-__exportStar(require("./WrappedEntity"), exports);
-__exportStar(require("./wrap"), exports);
+export * from './EntityRepository.js';
+export * from './EntityIdentifier.js';
+export * from './EntityValidator.js';
+export * from './EntityAssigner.js';
+export * from './EntityHelper.js';
+export * from './EntityFactory.js';
+export * from './ArrayCollection.js';
+export * from './Collection.js';
+export * from './EntityLoader.js';
+export * from './Reference.js';
+export * from './BaseEntity.js';
+export * from './WrappedEntity.js';
+export * from './wrap.js';

package/entity/utils.d.ts

@@ -1,4 +1,4 @@
-import type { EntityMetadata, PopulateOptions } from '../typings';
+import type { EntityMetadata, PopulateOptions } from '../typings.js';
 /**
  * @internal
  */

package/entity/utils.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.expandDotPaths = expandDotPaths;
-const enums_1 = require("../enums");
-const core_1 = require("@mikro-orm/core");
+import { PopulatePath, ReferenceKind } from '../enums.js';
+import { Utils } from '@mikro-orm/core';
 /**
  * Expands `books.perex` like populate to use `children` array instead of the dot syntax
  */
@@ -19,13 +16,13 @@ function expandNestedPopulate(parentProp, parts, strategy, all) {
 /**
  * @internal
  */
-function expandDotPaths(meta, populate, normalized = false) {
-    const ret = normalized ? populate : core_1.Utils.asArray(populate).map(field => {
+export function expandDotPaths(meta, populate, normalized = false) {
+    const ret = normalized ? populate : Utils.asArray(populate).map(field => {
         if (typeof field === 'string') {
             return { field };
         }
-        /* istanbul ignore next */
-        return typeof field === 'boolean' || field.field === enums_1.PopulatePath.ALL
+        /* v8 ignore next 3 */
+        return typeof field === 'boolean' || field.field === PopulatePath.ALL
             ? { all: !!field, field: meta.primaryKeys[0] }
             : field;
     });
@@ -38,12 +35,12 @@ function expandDotPaths(meta, populate, normalized = false) {
         p.children ??= [];
         const prop = meta.properties[p.field];
         p.strategy ??= prop.strategy;
-        if (parts[0] === enums_1.PopulatePath.ALL) {
+        if (parts[0] === PopulatePath.ALL) {
             prop.targetMeta.props
-                .filter(prop => prop.lazy || prop.kind !== enums_1.ReferenceKind.SCALAR)
+                .filter(prop => prop.lazy || prop.kind !== ReferenceKind.SCALAR)
                 .forEach(prop => p.children.push({ field: prop.name, strategy: p.strategy }));
         }
-        else if (prop.kind === enums_1.ReferenceKind.EMBEDDED) {
+        else if (prop.kind === ReferenceKind.EMBEDDED) {
             const embeddedProp = Object.values(prop.embeddedProps).find(c => c.embedded[1] === parts[0]);
             ret.push({
                 ...p,

package/entity/wrap.d.ts

@@ -1,4 +1,4 @@
-import type { IWrappedEntity, IWrappedEntityInternal } from '../typings';
+import type { IWrappedEntity, IWrappedEntityInternal } from '../typings.js';
 /**
  * returns WrappedEntity instance associated with this entity. This includes all the internal properties like `__meta` or `__em`.
  */