@yandjin-mikro-orm/core 6.1.4-rc-sti-changes-1

package/entity/Reference.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ref = exports.rel = exports.ref = exports.ScalarReference = exports.Reference = void 0;
+const util_1 = require("util");
+const enums_1 = require("../enums");
+const wrap_1 = require("./wrap");
+const utils_1 = require("../utils");
+class Reference {
+    entity;
+    constructor(entity) {
+        this.entity = entity;
+        this.set(entity);
+        const meta = (0, wrap_1.helper)(this.entity).__meta;
+        meta.primaryKeys.forEach(primaryKey => {
+            Object.defineProperty(this, primaryKey, {
+                get() {
+                    return this.entity[primaryKey];
+                },
+            });
+        });
+        if (meta.serializedPrimaryKey && meta.primaryKeys[0] !== meta.serializedPrimaryKey) {
+            Object.defineProperty(this, meta.serializedPrimaryKey, {
+                get() {
+                    return (0, wrap_1.helper)(this.entity).getSerializedPrimaryKey();
+                },
+            });
+        }
+    }
+    static create(entity) {
+        const unwrapped = Reference.unwrapReference(entity);
+        const ref = (0, wrap_1.helper)(entity).toReference();
+        if (unwrapped !== ref.unwrap()) {
+            ref.set(unwrapped);
+        }
+        return ref;
+    }
+    static createFromPK(entityType, pk, options) {
+        const ref = this.createNakedFromPK(entityType, pk, options);
+        return (0, wrap_1.helper)(ref).toReference();
+    }
+    static createNakedFromPK(entityType, pk, options) {
+        const factory = entityType.prototype.__factory;
+        const entity = factory.createReference(entityType, pk, {
+            merge: false,
+            convertCustomTypes: false,
+            ...options,
+        });
+        const wrapped = (0, wrap_1.helper)(entity);
+        wrapped.__meta.primaryKeys.forEach(key => wrapped.__loadedProperties.add(key));
+        wrapped.__originalEntityData = factory.getComparator().prepareEntity(entity);
+        return entity;
+    }
+    /**
+     * Checks whether the argument is instance of `Reference` wrapper.
+     */
+    static isReference(data) {
+        return data && !!data.__reference;
+    }
+    /**
+     * Wraps the entity in a `Reference` wrapper if the property is defined as `ref`.
+     */
+    static wrapReference(entity, prop) {
+        if (entity && prop.ref && !Reference.isReference(entity)) {
+            return Reference.create(entity);
+        }
+        return entity;
+    }
+    /**
+     * Returns wrapped entity.
+     */
+    static unwrapReference(ref) {
+        return Reference.isReference(ref) ? ref.unwrap() : ref;
+    }
+    /**
+     * Ensures the underlying entity is loaded first (without reloading it if it already is loaded). Returns the entity.
+     * If the entity is not found in the database (e.g. it was deleted in the meantime, or currently active filters disallow loading of it)
+     * the method returns `null`. Use `loadOrFail()` if you want an error to be thrown in such a case.
+     */
+    async load(options = {}) {
+        if (!this.isInitialized() || options.refresh) {
+            const wrapped = (0, wrap_1.helper)(this.entity);
+            if (!wrapped.__em) {
+                return this.entity;
+            }
+            if (options.dataloader ?? [enums_1.DataloaderType.ALL, enums_1.DataloaderType.REFERENCE].includes(utils_1.DataloaderUtils.getDataloaderType(wrapped.__em.config.get('dataloader')))) {
+                // eslint-disable-next-line dot-notation
+                return wrapped.__em['refLoader'].load([this, options]);
+            }
+            return wrapped.init(options);
+        }
+        return this.entity;
+    }
+    /**
+     * 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) {
+            const wrapped = (0, wrap_1.helper)(this.entity);
+            options.failHandler ??= wrapped.__em.config.get('findOneOrFailHandler');
+            const entityName = this.entity.constructor.name;
+            const where = wrapped.getPrimaryKey();
+            throw options.failHandler(entityName, where);
+        }
+        return ret;
+    }
+    set(entity) {
+        this.entity = Reference.unwrapReference(entity);
+        delete (0, wrap_1.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`);
+        }
+        return this.entity;
+    }
+    getProperty(prop) {
+        return this.getEntity()[prop];
+    }
+    async loadProperty(prop, options) {
+        await this.loadOrFail(options);
+        return this.getEntity()[prop];
+    }
+    isInitialized() {
+        return (0, wrap_1.helper)(this.entity).__initialized;
+    }
+    populated(populated) {
+        (0, wrap_1.helper)(this.entity).populated(populated);
+    }
+    toJSON(...args) {
+        return (0, wrap_1.wrap)(this.entity).toJSON(...args);
+    }
+    /* istanbul ignore next */
+    /** @ignore */
+    [util_1.inspect.custom](depth) {
+        const object = { ...this };
+        const hidden = ['meta'];
+        hidden.forEach(k => delete object[k]);
+        const ret = (0, util_1.inspect)(object, { depth });
+        const wrapped = (0, wrap_1.helper)(this.entity);
+        const meta = wrapped.__meta;
+        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 {
+    value;
+    initialized;
+    entity;
+    property;
+    constructor(value, initialized = value != null) {
+        this.value = value;
+        this.initialized = initialized;
+    }
+    /**
+     * Ensures the underlying entity is loaded first (without reloading it if it already is loaded).
+     * Returns either the whole entity, or the requested property.
+     */
+    async load(options) {
+        const opts = typeof options === 'object' ? options : { prop: options };
+        if (!this.initialized || opts.refresh) {
+            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);
+        }
+        return this.value;
+    }
+    set(value) {
+        this.value = value;
+        this.initialized = true;
+    }
+    bind(entity, property) {
+        this.entity = entity;
+        this.property = property;
+        Object.defineProperty(this, 'entity', { enumerable: false, value: entity });
+    }
+    unwrap() {
+        return this.value;
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+    /* istanbul ignore next */
+    /** @ignore */
+    [util_1.inspect.custom]() {
+        return this.initialized ? `Ref<${(0, util_1.inspect)(this.value)}>` : `Ref<?>`;
+    }
+}
+exports.ScalarReference = ScalarReference;
+Object.defineProperties(Reference.prototype, {
+    __reference: { value: true, enumerable: false },
+    __meta: { get() { return this.entity.__meta; } },
+    __platform: { get() { return this.entity.__platform; } },
+    __helper: { get() { return this.entity.__helper; } },
+    $: { get() { return this.entity; } },
+    get: { get() { return () => this.entity; } },
+});
+Object.defineProperties(ScalarReference.prototype, {
+    __scalarReference: { value: true, enumerable: false },
+    $: { get() { return this.value; } },
+    get: { get() { return () => this.value; } },
+});
+/**
+ * shortcut for `wrap(entity).toReference()`
+ */
+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_1.Utils.isEntity(pk, true)) {
+        return (0, wrap_1.helper)(pk).toReference();
+    }
+    if (arguments.length === 1) {
+        return new ScalarReference(entityOrType, true);
+    }
+    if (pk == null) {
+        return pk;
+    }
+    return Reference.createFromPK(entityOrType, pk);
+}
+exports.ref = ref;
+/**
+ * shortcut for `Reference.createNakedFromPK(entityType, pk)`
+ */
+function rel(entityType, pk) {
+    if (pk == null || utils_1.Utils.isEntity(pk)) {
+        return pk;
+    }
+    return Reference.createNakedFromPK(entityType, pk);
+}
+exports.rel = rel;

package/entity/WrappedEntity.d.ts

@@ -0,0 +1,67 @@
+/// <reference types="node" />
+import { inspect } from '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 } from '../drivers/IDatabaseDriver';
+export declare class WrappedEntity<Entity extends object> {
+    __initialized: boolean;
+    __touched: boolean;
+    __populated?: boolean;
+    __managed?: boolean;
+    __onLoadFired?: boolean;
+    __schema?: string;
+    __em?: EntityManager;
+    __serializationContext: {
+        root?: SerializationContext<Entity>;
+        populate?: PopulateOptions<Entity>[];
+        fields?: string[];
+    };
+    __loadedProperties: Set<string>;
+    __data: Dictionary;
+    __processing: boolean;
+    /** stores last known primary key, as its current state might be broken due to propagation/orphan removal, but we need to know the PK to be able t remove the entity */
+    __pk?: Primary<Entity>;
+    /** holds the reference wrapper instance (if created), so we can maintain the identity on reference wrappers too */
+    __reference?: Reference<Entity>;
+    /** holds last entity data snapshot, so we can compute changes when persisting managed entities */
+    __originalEntityData?: EntityData<Entity>;
+    /** holds wrapped primary key, so we can compute change set without eager commit */
+    __identifier?: EntityIdentifier;
+    private readonly entity;
+    private readonly hydrator;
+    private readonly pkGetter?;
+    private readonly pkSerializer?;
+    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;
+    toReference(): Ref<Entity> & LoadedReference<Loaded<Entity, AddEager<Entity>>>;
+    toObject<Ignored extends EntityKey<Entity> = never>(ignoreFields?: Ignored[]): Omit<EntityDTO<Entity>, Ignored>;
+    serialize<Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Entity, Hint, Exclude>): EntityDTO<Loaded<Entity, Hint>>;
+    toPOJO(): EntityDTO<Entity>;
+    toJSON(...args: any[]): EntityDictionary<Entity>;
+    assign<Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Data extends EntityData<Naked> | Partial<EntityDTO<Naked>> = EntityData<Naked> | Partial<EntityDTO<Naked>>>(data: Data & IsSubset<EntityData<Naked>, Data>, options?: AssignOptions): MergeSelected<Entity, Naked, keyof Data & string>;
+    init<Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(options?: FindOneOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes> | null>;
+    populate<Hint extends string = never>(populate: AutoPath<Entity, Hint, '*'>[] | false, options?: EntityLoaderOptions<Entity>): Promise<Loaded<Entity, Hint>>;
+    hasPrimaryKey(): boolean;
+    getPrimaryKey(convertCustomTypes?: boolean): Primary<Entity> | null;
+    getPrimaryKeys(convertCustomTypes?: boolean): Primary<Entity>[] | null;
+    getSchema(): string | undefined;
+    setSchema(schema?: string): void;
+    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 __primaryKeys(): Primary<Entity>[];
+    /** @ignore */
+    [inspect.custom](): string;
+}

package/entity/WrappedEntity.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WrappedEntity = void 0;
+const util_1 = require("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");
+class WrappedEntity {
+    constructor(entity, hydrator, pkGetter, pkSerializer, pkGetterConverted) {
+        this.entity = entity;
+        this.hydrator = hydrator;
+        this.pkGetter = pkGetter;
+        this.pkSerializer = pkSerializer;
+        this.pkGetterConverted = pkGetterConverted;
+        this.__initialized = true;
+        this.__touched = false;
+        this.__serializationContext = {};
+        this.__loadedProperties = new Set();
+        this.__data = {};
+        this.__processing = false;
+    }
+    isInitialized() {
+        return this.__initialized;
+    }
+    isTouched() {
+        return this.__touched;
+    }
+    isManaged() {
+        return !!this.__managed;
+    }
+    populated(populated = true) {
+        this.__populated = populated;
+    }
+    toReference() {
+        this.__reference ??= new Reference_1.Reference(this.entity);
+        return this.__reference;
+    }
+    toObject(ignoreFields) {
+        return EntityTransformer_1.EntityTransformer.toObject(this.entity, ignoreFields);
+    }
+    serialize(options) {
+        return EntitySerializer_1.EntitySerializer.serialize(this.entity, options);
+    }
+    toPOJO() {
+        return EntityTransformer_1.EntityTransformer.toObject(this.entity, [], true);
+    }
+    toJSON(...args) {
+        // toJSON methods is added to the prototype during discovery to support automatic serialization via JSON.stringify()
+        return this.entity.toJSON(...args);
+    }
+    assign(data, options) {
+        if ('assign' in this.entity) {
+            return this.entity.assign(data, options);
+        }
+        return EntityAssigner_1.EntityAssigner.assign(this.entity, data, options);
+    }
+    async init(options) {
+        if (!this.__em) {
+            throw errors_1.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);
+        }
+        // @ts-ignore hard to type
+        await this.__em.populate(this.entity, populate, options);
+        return this.entity;
+    }
+    hasPrimaryKey() {
+        const pk = this.getPrimaryKey();
+        return pk != null;
+    }
+    getPrimaryKey(convertCustomTypes = false) {
+        const prop = this.__meta.getPrimaryProps()[0];
+        if (!prop) {
+            return null;
+        }
+        if (this.__pk != null && this.__meta.compositePK) {
+            return Utils_1.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);
+        }
+        if (convertCustomTypes) {
+            return this.__pk ?? this.pkGetterConverted(this.entity);
+        }
+        return this.__pk ?? this.pkGetter(this.entity);
+    }
+    // this method is currently used only in `Driver.syncCollection` and can be probably removed
+    getPrimaryKeys(convertCustomTypes = false) {
+        const pk = this.getPrimaryKey(convertCustomTypes);
+        if (pk == null) {
+            return null;
+        }
+        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);
+                    ret.push(...childPk);
+                }
+                else {
+                    ret.push(child);
+                }
+                return ret;
+            }, []);
+        }
+        return [pk];
+    }
+    getSchema() {
+        return this.__schema;
+    }
+    setSchema(schema) {
+        this.__schema = schema;
+    }
+    setPrimaryKey(id) {
+        this.entity[this.__meta.primaryKeys[0]] = id;
+        this.__pk = id;
+    }
+    getSerializedPrimaryKey() {
+        return this.pkSerializer(this.entity);
+    }
+    get __meta() {
+        return this.entity.__meta;
+    }
+    get __platform() {
+        return this.entity.__platform;
+    }
+    get __config() {
+        return this.__em?.config ?? this.entity.__config;
+    }
+    get __primaryKeys() {
+        return Utils_1.Utils.getPrimaryKeyValues(this.entity, this.__meta.primaryKeys);
+    }
+    /** @ignore */
+    [util_1.inspect.custom]() {
+        return `[WrappedEntity<${this.__meta.className}>]`;
+    }
+}
+exports.WrappedEntity = WrappedEntity;

package/entity/index.d.ts

@@ -0,0 +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';

package/entity/index.js

@@ -0,0 +1,29 @@
+"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);

package/entity/wrap.d.ts

@@ -0,0 +1,15 @@
+import type { IWrappedEntity, IWrappedEntityInternal } from '../typings';
+/**
+ * returns WrappedEntity instance associated with this entity. This includes all the internal properties like `__meta` or `__em`.
+ */
+export declare function wrap<T extends object>(entity: T, preferHelper: true): IWrappedEntityInternal<T>;
+/**
+ * wraps entity type with WrappedEntity internal properties and helpers like init/isInitialized/populated/toJSON
+ */
+export declare function wrap<T extends object>(entity: T, preferHelper?: false): IWrappedEntity<T>;
+/**
+ * wraps entity type with WrappedEntity internal properties and helpers like init/isInitialized/populated/toJSON
+ * use `preferHelper = true` to have access to the internal `__` properties like `__meta` or `__em`
+ * @internal
+ */
+export declare function helper<T extends object>(entity: T): IWrappedEntityInternal<T>;

package/entity/wrap.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.helper = exports.wrap = void 0;
+/**
+ * wraps entity type with WrappedEntity internal properties and helpers like init/isInitialized/populated/toJSON
+ * use `preferHelper = true` to have access to the internal `__` properties like `__meta` or `__em`
+ */
+function wrap(entity, preferHelper = false) {
+    if (!entity) {
+        return entity;
+    }
+    if (entity.__baseEntity && !preferHelper) {
+        return entity;
+    }
+    return entity.__helper ?? entity;
+}
+exports.wrap = wrap;
+/**
+ * wraps entity type with WrappedEntity internal properties and helpers like init/isInitialized/populated/toJSON
+ * use `preferHelper = true` to have access to the internal `__` properties like `__meta` or `__em`
+ * @internal
+ */
+function helper(entity) {
+    return entity.__helper;
+}
+exports.helper = helper;