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

package/entity/EntityRepository.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityRepository = void 0;
-const errors_1 = require("../errors");
-const Utils_1 = require("../utils/Utils");
-class EntityRepository {
+import { ValidationError } from '../errors.js';
+import { Utils } from '../utils/Utils.js';
+export class EntityRepository {
     em;
     entityName;
     constructor(em, entityName) {
@@ -191,7 +188,7 @@ class EntityRepository {
         return this.getEntityManager().count(this.entityName, where, options);
     }
     getEntityName() {
-        return Utils_1.Utils.className(this.entityName);
+        return Utils.className(this.entityName);
     }
     /**
      * Returns the underlying EntityManager instance
@@ -200,15 +197,14 @@ class EntityRepository {
         return this.em;
     }
     validateRepositoryType(entities, method) {
-        entities = Utils_1.Utils.asArray(entities);
+        entities = Utils.asArray(entities);
         if (entities.length === 0) {
             return;
         }
         const entityName = entities[0].constructor.name;
-        const repoType = Utils_1.Utils.className(this.entityName);
+        const repoType = Utils.className(this.entityName);
         if (entityName && repoType !== entityName) {
-            throw errors_1.ValidationError.fromWrongRepositoryType(entityName, repoType, method);
+            throw ValidationError.fromWrongRepositoryType(entityName, repoType, method);
         }
     }
 }
-exports.EntityRepository = EntityRepository;

package/entity/Reference.d.ts

@@ -1,8 +1,8 @@
-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, AddOptional, 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;
+    private property?;
     constructor(entity: T);
     static create<T extends object>(entity: T | Ref<T>): Ref<T>;
     static createFromPK<T extends object>(entityType: EntityClass<T>, pk: Primary<T>, options?: {
@@ -42,8 +42,6 @@ export declare class Reference<T extends object> {
     isInitialized(): boolean;
     populated(populated?: boolean): void;
     toJSON(...args: any[]): Dictionary;
-    /** @ignore */
-    [inspect.custom](depth?: number): string;
 }
 export declare class ScalarReference<Value> {
     private value?;
@@ -56,12 +54,15 @@ export declare class ScalarReference<Value> {
      * Returns either the whole entity, or the requested property.
      */
     load(options?: Omit<LoadReferenceOptions<any, any>, 'populate' | 'fields' | 'exclude'>): Promise<Value | undefined>;
+    /**
+     * Ensures the underlying entity is loaded first (without reloading it if it already is loaded).
+     * Returns the entity or throws an error just like `em.findOneOrFail()` (and respects the same config options).
+     */
+    loadOrFail(options?: Omit<LoadReferenceOrFailOptions<any, any>, 'populate' | 'fields' | 'exclude'>): Promise<Value>;
     set(value: Value): void;
     bind<Entity extends object>(entity: Entity, property: EntityKey<Entity>): void;
     unwrap(): Value | undefined;
     isInitialized(): boolean;
-    /** @ignore */
-    [inspect.custom](): string;
 }
 export interface LoadReferenceOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends FindOneOptions<T, P, F, E> {
     dataloader?: boolean;
@@ -72,15 +73,11 @@ export interface LoadReferenceOrFailOptions<T extends object, P extends string =
 /**
  * shortcut for `wrap(entity).toReference()`
  */
-export declare function ref<T>(entity: T | Ref<T>): Ref<T> & LoadedReference<Loaded<T, AddEager<T>>>;
+export declare function ref<I extends unknown | Ref<unknown> | undefined | null, T extends I & {}>(entity: I): Ref<T> & LoadedReference<Loaded<T, AddEager<T>>> | AddOptional<typeof entity>;
 /**
  * shortcut for `Reference.createFromPK(entityType, pk)`
  */
-export declare function ref<T, PKV extends Primary<T> = Primary<T>>(entityType: EntityClass<T>, pk?: T | PKV): Ref<T>;
-/**
- * shortcut for `wrap(entity).toReference()`
- */
-export declare function ref<T>(value: T | Ref<T>): Ref<T> & LoadedReference<Loaded<T, AddEager<T>>>;
+export declare function ref<I extends unknown | undefined | null, T, PKV extends Primary<T> = Primary<T>>(entityType: EntityClass<T>, pk: I): Ref<T> | AddOptional<typeof pk>;
 /**
  * shortcut for `Reference.createNakedFromPK(entityType, pk)`
  */

package/entity/Reference.js

@@ -1,18 +1,16 @@
-"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 { DataloaderType } from '../enums.js';
+import { helper, wrap } from './wrap.js';
+import { Utils } from '../utils/Utils.js';
+import { QueryHelper } from '../utils/QueryHelper.js';
+import { NotFoundError } from '../errors.js';
+import { inspect } from '../logging/inspect.js';
+export class Reference {
     entity;
+    property;
     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 +21,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,16 +36,21 @@ 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() ?? ref;
     }
     static createNakedFromPK(entityType, pk, options) {
         const factory = entityType.prototype.__factory;
+        if (!factory) {
+            // this can happen only if `ref()` is used as a property initializer, and the value is important only for the
+            // inference of defaults, so it's fine to return it directly without wrapping with `Reference` class
+            return pk;
+        }
         const entity = factory.createReference(entityType, pk, {
             merge: false,
             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;
@@ -63,7 +66,9 @@ class Reference {
      */
     static wrapReference(entity, prop) {
         if (entity && prop.ref && !Reference.isReference(entity)) {
-            return Reference.create(entity);
+            const ref = Reference.create(entity);
+            ref.property = prop;
+            return ref;
         }
         return entity;
     }
@@ -79,17 +84,18 @@ 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;
         }
+        options = { ...options, filters: QueryHelper.mergePropertyFilters(this.property?.filters, options.filters) };
         if (this.isInitialized() && !options.refresh && options.populate) {
             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())) {
-                // eslint-disable-next-line dot-notation
-                return wrapped.__em['refLoader'].load([this, options]);
+            if (options.dataloader ?? [DataloaderType.ALL, DataloaderType.REFERENCE].includes(wrapped.__em.config.getDataloaderType())) {
+                const dataLoader = await wrapped.__em.getDataLoader('ref');
+                return dataLoader.load([this, options]);
             }
             return wrapped.init(options);
         }
@@ -102,7 +108,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 +118,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 +137,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) {
+    [Symbol.for('nodejs.util.inspect.custom')](depth = 2) {
         const object = { ...this };
-        const hidden = ['meta'];
+        const hidden = ['meta', 'property'];
         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,10 +178,24 @@ 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;
     }
+    /**
+     * Ensures the underlying entity is loaded first (without reloading it if it already is loaded).
+     * Returns the entity or throws an error just like `em.findOneOrFail()` (and respects the same config options).
+     */
+    async loadOrFail(options = {}) {
+        const ret = await this.load(options);
+        if (ret == null) {
+            const wrapped = helper(this.entity);
+            options.failHandler ??= wrapped.__em.config.get('findOneOrFailHandler');
+            const entityName = this.entity.constructor.name;
+            throw NotFoundError.failedToLoadProperty(entityName, this.property, wrapped.getPrimaryKey());
+        }
+        return ret;
+    }
     set(value) {
         this.value = value;
         this.initialized = true;
@@ -193,13 +211,12 @@ class ScalarReference {
     isInitialized() {
         return this.initialized;
     }
-    /* istanbul ignore next */
     /** @ignore */
-    [node_util_1.inspect.custom]() {
-        return this.initialized ? `Ref<${(0, node_util_1.inspect)(this.value)}>` : `Ref<?>`;
+    /* v8 ignore next */
+    [Symbol.for('nodejs.util.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 +233,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 +254,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,17 +1,15 @@
-import type { PopulatePath } from '../enums';
-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 { PopulatePath } from '../enums.js';
+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;
     __populated?: boolean;
     __managed?: boolean;
     __onLoadFired?: boolean;
@@ -41,7 +39,6 @@ export declare class WrappedEntity<Entity extends object> {
     private readonly pkGetterConverted?;
     constructor(entity: Entity, hydrator: IHydrator, pkGetter?: (e: Entity) => Primary<Entity>, pkSerializer?: (e: Entity) => string, pkGetterConverted?: (e: Entity) => Primary<Entity>);
     isInitialized(): boolean;
-    isTouched(): boolean;
     isManaged(): boolean;
     populated(populated?: boolean | undefined): void;
     setSerializationContext<Hint extends string = never, Fields extends string = '*', Exclude extends string = never>(options: LoadHint<Entity, Hint, Fields, Exclude>): void;
@@ -61,9 +58,7 @@ 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("@mikro-orm/sql").Platform;
+    get __config(): import("@mikro-orm/sql").Configuration<import("../drivers/IDatabaseDriver.js").IDatabaseDriver<import("@mikro-orm/sql").Connection>, EntityManager<import("../drivers/IDatabaseDriver.js").IDatabaseDriver<import("@mikro-orm/sql").Connection>>>;
     get __primaryKeys(): Primary<Entity>[];
-    /** @ignore */
-    [inspect.custom](): string;
 }

package/entity/WrappedEntity.js

@@ -1,16 +1,12 @@
-"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 { 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;
@@ -18,7 +14,6 @@ class WrappedEntity {
         this.pkSerializer = pkSerializer;
         this.pkGetterConverted = pkGetterConverted;
         this.__initialized = true;
-        this.__touched = false;
         this.__serializationContext = {};
         this.__loadedProperties = new Set();
         this.__data = {};
@@ -27,9 +22,6 @@ class WrappedEntity {
     isInitialized() {
         return this.__initialized;
     }
-    isTouched() {
-        return this.__touched;
-    }
     isManaged() {
         return !!this.__managed;
     }
@@ -39,7 +31,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 +45,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 +65,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 +91,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 +110,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 +145,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);
     }
     /** @ignore */
-    [node_util_1.inspect.custom]() {
+    [Symbol.for('nodejs.util.inspect.custom')]() {
         return `[WrappedEntity<${this.__meta.className}>]`;
     }
 }
-exports.WrappedEntity = WrappedEntity;