@mikro-orm/core 7.0.0-dev.7 → 7.0.0-dev.71

package/entity/Reference.d.ts

@@ -1,8 +1,9 @@
 import { inspect } from 'node:util';
-import type { AddEager, Dictionary, EntityClass, EntityKey, EntityProperty, Loaded, LoadedReference, Primary, Ref } from '../typings.js';
+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?: {
@@ -56,6 +57,11 @@ 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;
@@ -72,15 +78,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

@@ -2,8 +2,11 @@ import { inspect } from 'node:util';
 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';
 export class Reference {
     entity;
+    property;
     constructor(entity) {
         this.entity = entity;
         this.set(entity);
@@ -33,10 +36,15 @@ export class Reference {
     }
     static createFromPK(entityType, pk, options) {
         const ref = this.createNakedFromPK(entityType, pk, options);
-        return 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,
@@ -58,7 +66,9 @@ export 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;
     }
@@ -78,13 +88,14 @@ export class Reference {
         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 ?? [DataloaderType.ALL, DataloaderType.REFERENCE].includes(wrapped.__em.config.getDataloaderType())) {
-                // eslint-disable-next-line dot-notation
-                return wrapped.__em['refLoader'].load([this, options]);
+                const dataLoader = await wrapped.__em.getDataLoader('ref');
+                return dataLoader.load([this, options]);
             }
             return wrapped.init(options);
         }
@@ -137,7 +148,7 @@ export class Reference {
     /** @ignore */
     [inspect.custom](depth = 2) {
         const object = { ...this };
-        const hidden = ['meta'];
+        const hidden = ['meta', 'property'];
         hidden.forEach(k => delete object[k]);
         const ret = inspect(object, { depth });
         const wrapped = helper(this.entity);
@@ -171,6 +182,22 @@ export class ScalarReference {
         }
         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;
+            const where = wrapped.getPrimaryKey();
+            const whereString = typeof where === 'object' ? inspect(where) : where;
+            throw new NotFoundError(`${entityName} (${whereString}) failed to load property '${this.property}'`);
+        }
+        return ret;
+    }
     set(value) {
         this.value = value;
         this.initialized = true;

package/entity/WrappedEntity.d.ts

@@ -11,7 +11,6 @@ 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 +40,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;

package/entity/WrappedEntity.js

@@ -15,7 +15,6 @@ export class WrappedEntity {
         this.pkSerializer = pkSerializer;
         this.pkGetterConverted = pkGetterConverted;
         this.__initialized = true;
-        this.__touched = false;
         this.__serializationContext = {};
         this.__loadedProperties = new Set();
         this.__data = {};
@@ -24,9 +23,6 @@ export class WrappedEntity {
     isInitialized() {
         return this.__initialized;
     }
-    isTouched() {
-        return this.__touched;
-    }
     isManaged() {
         return !!this.__managed;
     }
@@ -150,7 +146,7 @@ export class WrappedEntity {
         return this.__em?.config ?? this.entity.__config;
     }
     get __primaryKeys() {
-        return Utils.getPrimaryKeyValues(this.entity, this.__meta.primaryKeys);
+        return Utils.getPrimaryKeyValues(this.entity, this.__meta);
     }
     /** @ignore */
     [inspect.custom]() {