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

package/entity/EntityHelper.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityHelper = void 0;
-const node_util_1 = require("node:util");
-const typings_1 = require("../typings");
-const EntityTransformer_1 = require("../serialization/EntityTransformer");
-const Reference_1 = require("./Reference");
-const Utils_1 = require("../utils/Utils");
-const WrappedEntity_1 = require("./WrappedEntity");
-const enums_1 = require("../enums");
-const wrap_1 = require("./wrap");
+import { inspect } from 'node:util';
+import { EagerProps, EntityRepositoryType, HiddenProps, OptionalProps, PrimaryKeyProp, } from '../typings.js';
+import { EntityTransformer } from '../serialization/EntityTransformer.js';
+import { Reference } from './Reference.js';
+import { Utils } from '../utils/Utils.js';
+import { WrappedEntity } from './WrappedEntity.js';
+import { ReferenceKind } from '../enums.js';
+import { helper } from './wrap.js';
 /**
  * @internal
  */
-class EntityHelper {
+export class EntityHelper {
     static decorate(meta, em) {
         const fork = em.fork(); // use fork so we can access `EntityFactory`
         const serializedPrimaryKey = meta.props.find(p => p.serializedPrimaryKey);
@@ -35,7 +32,7 @@ class EntityHelper {
         const prototype = meta.prototype;
         if (!prototype.toJSON) { // toJSON can be overridden
             prototype.toJSON = function (...args) {
-                return EntityTransformer_1.EntityTransformer.toObject(this, ...args.slice(meta.toJsonParams.length));
+                return EntityTransformer.toObject(this, ...args.slice(meta.toJsonParams.length));
             };
         }
     }
@@ -56,7 +53,7 @@ class EntityHelper {
             __helper: {
                 get() {
                     Object.defineProperty(this, '__helper', {
-                        value: new WrappedEntity_1.WrappedEntity(this, em.getHydrator(), ...helperParams),
+                        value: new WrappedEntity(this, em.getHydrator(), ...helperParams),
                         enumerable: false,
                         configurable: true,
                     });
@@ -78,8 +75,8 @@ class EntityHelper {
         Object
             .values(meta.properties)
             .forEach(prop => {
-            const isCollection = [enums_1.ReferenceKind.ONE_TO_MANY, enums_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind);
-            const isReference = [enums_1.ReferenceKind.ONE_TO_ONE, enums_1.ReferenceKind.MANY_TO_ONE].includes(prop.kind) && (prop.inversedBy || prop.mappedBy) && !prop.mapToPk;
+            const isCollection = [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind);
+            const isReference = [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind) && (prop.inversedBy || prop.mappedBy) && !prop.mapToPk;
             if (isReference) {
                 Object.defineProperty(meta.prototype, prop.name, {
                     set(val) {
@@ -115,49 +112,52 @@ class EntityHelper {
     }
     static defineCustomInspect(meta) {
         // @ts-ignore
-        meta.prototype[node_util_1.inspect.custom] ??= function (depth = 2) {
+        meta.prototype[inspect.custom] ??= function (depth = 2) {
             const object = { ...this };
             // ensure we dont have internal symbols in the POJO
-            [typings_1.OptionalProps, typings_1.EntityRepositoryType, typings_1.PrimaryKeyProp, typings_1.EagerProps, typings_1.HiddenProps].forEach(sym => delete object[sym]);
+            [OptionalProps, EntityRepositoryType, PrimaryKeyProp, EagerProps, HiddenProps].forEach(sym => delete object[sym]);
             meta.props
                 .filter(prop => object[prop.name] === undefined)
                 .forEach(prop => delete object[prop.name]);
-            const ret = (0, node_util_1.inspect)(object, { depth });
+            const ret = inspect(object, { depth });
             let name = (this).constructor.name;
             const showEM = ['true', 't', '1'].includes(process.env.MIKRO_ORM_LOG_EM_ID?.toString().toLowerCase() ?? '');
             if (showEM) {
-                if ((0, wrap_1.helper)(this).__em) {
-                    name += ` [managed by ${(0, wrap_1.helper)(this).__em.id}]`;
+                if (helper(this).__em) {
+                    name += ` [managed by ${helper(this).__em.id}]`;
                 }
                 else {
                     name += ` [not managed]`;
                 }
             }
             // distinguish not initialized entities
-            if (!(0, wrap_1.helper)(this).__initialized) {
+            if (!helper(this).__initialized) {
                 name = `(${name})`;
             }
             return ret === '[Object]' ? `[${name}]` : name + ' ' + ret;
         };
     }
     static defineReferenceProperty(meta, prop, ref, hydrator) {
-        const wrapped = (0, wrap_1.helper)(ref);
+        const wrapped = helper(ref);
         Object.defineProperty(ref, prop.name, {
             get() {
-                return (0, wrap_1.helper)(ref).__data[prop.name];
+                return helper(ref).__data[prop.name];
             },
             set(val) {
-                const entity = Reference_1.Reference.unwrapReference(val ?? wrapped.__data[prop.name]);
-                const old = Reference_1.Reference.unwrapReference(wrapped.__data[prop.name]);
-                wrapped.__data[prop.name] = Reference_1.Reference.wrapReference(val, prop);
+                const entity = Reference.unwrapReference(val ?? wrapped.__data[prop.name]);
+                const old = Reference.unwrapReference(wrapped.__data[prop.name]);
+                if (old && old !== entity && prop.kind === ReferenceKind.MANY_TO_ONE && prop.inversedBy && old[prop.inversedBy]) {
+                    old[prop.inversedBy].removeWithoutPropagation(this);
+                }
+                wrapped.__data[prop.name] = Reference.wrapReference(val, prop);
                 // when propagation from inside hydration, we set the FK to the entity data immediately
                 if (val && hydrator.isRunning() && wrapped.__originalEntityData && prop.owner) {
-                    wrapped.__originalEntityData[prop.name] = Utils_1.Utils.getPrimaryKeyValues(wrapped.__data[prop.name], prop.targetMeta.primaryKeys, true);
+                    wrapped.__originalEntityData[prop.name] = Utils.getPrimaryKeyValues(wrapped.__data[prop.name], prop.targetMeta.primaryKeys, true);
                 }
                 else {
                     wrapped.__touched = !hydrator.isRunning();
                 }
-                EntityHelper.propagate(meta, entity, this, prop, Reference_1.Reference.unwrapReference(val), old);
+                EntityHelper.propagate(meta, entity, this, prop, Reference.unwrapReference(val), old);
             },
             enumerable: true,
             configurable: true,
@@ -172,51 +172,51 @@ class EntityHelper {
                 continue;
             }
             const inverse = value?.[prop2.name];
-            if (prop.kind === enums_1.ReferenceKind.MANY_TO_ONE && Utils_1.Utils.isCollection(inverse) && inverse.isInitialized()) {
+            if (prop.kind === ReferenceKind.MANY_TO_ONE && Utils.isCollection(inverse) && inverse.isInitialized()) {
                 inverse.addWithoutPropagation(owner);
-                (0, wrap_1.helper)(owner).__em?.getUnitOfWork().cancelOrphanRemoval(owner);
+                helper(owner).__em?.getUnitOfWork().cancelOrphanRemoval(owner);
             }
-            if (prop.kind === enums_1.ReferenceKind.ONE_TO_ONE) {
-                if ((value != null && Reference_1.Reference.unwrapReference(inverse) !== owner) ||
+            if (prop.kind === ReferenceKind.ONE_TO_ONE) {
+                if ((value != null && Reference.unwrapReference(inverse) !== owner) ||
                     (value == null && entity?.[prop2.name] != null)) {
-                    if (entity && (!prop.owner || (0, wrap_1.helper)(entity).__initialized)) {
+                    if (entity && (!prop.owner || helper(entity).__initialized)) {
                         EntityHelper.propagateOneToOne(entity, owner, prop, prop2, value, old);
                     }
                     if (old && prop.orphanRemoval) {
-                        (0, wrap_1.helper)(old).__em?.getUnitOfWork().scheduleOrphanRemoval(old);
+                        helper(old).__em?.getUnitOfWork().scheduleOrphanRemoval(old);
                     }
                 }
             }
         }
     }
     static propagateOneToOne(entity, owner, prop, prop2, value, old) {
-        (0, wrap_1.helper)(entity).__pk = (0, wrap_1.helper)(entity).getPrimaryKey();
+        helper(entity).__pk = helper(entity).getPrimaryKey();
         // the inverse side will be changed on the `value` too, so we need to clean-up and schedule orphan removal there too
-        if (!prop.primary && !prop2.mapToPk && value?.[prop2.name] != null && Reference_1.Reference.unwrapReference(value[prop2.name]) !== entity) {
-            const other = Reference_1.Reference.unwrapReference(value[prop2.name]);
-            delete (0, wrap_1.helper)(other).__data[prop.name];
+        if (!prop.primary && !prop2.mapToPk && value?.[prop2.name] != null && Reference.unwrapReference(value[prop2.name]) !== entity) {
+            const other = Reference.unwrapReference(value[prop2.name]);
+            delete helper(other).__data[prop.name];
             if (prop2.orphanRemoval) {
-                (0, wrap_1.helper)(other).__em?.getUnitOfWork().scheduleOrphanRemoval(other);
+                helper(other).__em?.getUnitOfWork().scheduleOrphanRemoval(other);
             }
         }
         if (value == null) {
             entity[prop2.name] = value;
         }
         else if (prop2.mapToPk) {
-            entity[prop2.name] = (0, wrap_1.helper)(owner).getPrimaryKey();
+            entity[prop2.name] = helper(owner).getPrimaryKey();
         }
         else {
-            entity[prop2.name] = Reference_1.Reference.wrapReference(owner, prop);
+            entity[prop2.name] = Reference.wrapReference(owner, prop);
         }
         if (old?.[prop2.name] != null) {
-            delete (0, wrap_1.helper)(old).__data[prop2.name];
+            delete helper(old).__data[prop2.name];
         }
     }
     static ensurePropagation(entity) {
         if (entity.__gettersDefined) {
             return;
         }
-        const wrapped = (0, wrap_1.helper)(entity);
+        const wrapped = helper(entity);
         const meta = wrapped.__meta;
         const platform = wrapped.__platform;
         const serializedPrimaryKey = meta.props.find(p => p.serializedPrimaryKey);
@@ -250,4 +250,3 @@ class EntityHelper {
         }
     }
 }
-exports.EntityHelper = EntityHelper;

package/entity/EntityIdentifier.d.ts

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

package/entity/EntityIdentifier.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityIdentifier = void 0;
 /**
  * @internal
  */
-class EntityIdentifier {
+export class EntityIdentifier {
     value;
     constructor(value) {
         this.value = value;
@@ -16,4 +13,3 @@ class EntityIdentifier {
         return this.value;
     }
 }
-exports.EntityIdentifier = EntityIdentifier;

package/entity/EntityLoader.d.ts

@@ -1,8 +1,8 @@
-import type { ConnectionType, Dictionary, FilterQuery, PopulateOptions } from '../typings';
-import type { EntityManager } from '../EntityManager';
-import { LoadStrategy, type LockMode, type PopulateHint, PopulatePath, type QueryOrderMap } from '../enums';
-import type { EntityField } from '../drivers/IDatabaseDriver';
-import type { LoggingOptions } from '../logging/Logger';
+import type { ConnectionType, Dictionary, FilterQuery, PopulateOptions } from '../typings.js';
+import type { EntityManager } from '../EntityManager.js';
+import { LoadStrategy, type LockMode, type PopulateHint, PopulatePath, type QueryOrderMap } from '../enums.js';
+import type { EntityField } from '../drivers/IDatabaseDriver.js';
+import type { LoggingOptions } from '../logging/Logger.js';
 export type EntityLoaderOptions<Entity, Fields extends string = PopulatePath.ALL, Excludes extends string = never> = {
     where?: FilterQuery<Entity>;
     populateWhere?: PopulateHint | `${PopulateHint}`;