@mikro-orm/core 7.0.6-dev.7 → 7.0.6-dev.9

package/EntityManager.js

@@ -779,6 +779,7 @@ export class EntityManager {
                 return entity;
             }
             where = helper(entity).getPrimaryKey();
+            em.#entityFactory.assignDefaultValues(entity, meta);
             data = em.#comparator.prepareEntity(entity);
         }
         else {
@@ -790,6 +791,7 @@ export class EntityManager {
                     return em.assign(exists, data);
                 }
             }
+            em.#entityFactory.assignDefaultValues(data, meta, true);
             for (const key of Object.keys(data)) {
                 const prop = meta.properties[key];
                 if (prop?.persist === false) {
@@ -928,6 +930,7 @@ export class EntityManager {
                     continue;
                 }
                 where = helper(entity).getPrimaryKey();
+                em.#entityFactory.assignDefaultValues(entity, meta);
                 row = em.#comparator.prepareEntity(entity);
             }
             else {
@@ -942,6 +945,7 @@ export class EntityManager {
                         continue;
                     }
                 }
+                em.#entityFactory.assignDefaultValues(row, meta, true);
                 for (const key of Object.keys(row)) {
                     const prop = meta.properties[key];
                     if (prop?.persist === false) {

package/entity/Collection.d.ts

@@ -21,6 +21,7 @@ export declare class Collection<T extends object, O extends object = object> {
     /**
      * Creates new Collection instance, assigns it to the owning entity and sets the items to it (propagating them to their inverse sides)
      */
+    static isCollection<T extends object, O extends object>(item: any): item is Collection<T, O>;
     static create<T extends object, O extends object = object>(owner: O, prop: EntityKey<O>, items: undefined | T[], initialized: boolean): Collection<T, O>;
     /**
      * Ensures the collection is loaded first (without reloading it if it already is loaded).

package/entity/Collection.js

@@ -5,6 +5,7 @@ import { Reference } from './Reference.js';
 import { helper, wrap } from './wrap.js';
 import { QueryHelper } from '../utils/QueryHelper.js';
 import { inspect } from '../logging/inspect.js';
+const collectionSymbol = Symbol('Collection');
 /** Represents a to-many relation (1:m or m:n) as an iterable, managed collection of entities. */
 export class Collection {
     owner;
@@ -19,6 +20,7 @@ export class Collection {
     #populated;
     constructor(owner, items, initialized = true) {
         this.owner = owner;
+        Object.defineProperty(this, collectionSymbol, { value: true, enumerable: false });
         /* v8 ignore next */
         if (items) {
             let i = 0;
@@ -30,6 +32,9 @@ export class Collection {
     /**
      * Creates new Collection instance, assigns it to the owning entity and sets the items to it (propagating them to their inverse sides)
      */
+    static isCollection(item) {
+        return item != null && Object.hasOwn(item, collectionSymbol);
+    }
     static create(owner, prop, items, initialized) {
         const coll = new Collection(owner, undefined, initialized);
         coll.property = helper(owner).__meta.properties[prop];
@@ -737,5 +742,4 @@ Object.defineProperties(Collection.prototype, {
             return () => this;
         },
     },
-    __collection: { value: true, enumerable: false, writable: false },
 });

package/entity/EntityFactory.d.ts

@@ -47,7 +47,8 @@ export declare class EntityFactory {
     /** Returns the EntityComparator instance used for diffing entities. */
     getComparator(): EntityComparator;
     private createEntity;
-    private assignDefaultValues;
+    /** @internal */
+    assignDefaultValues<T extends object>(entity: T, meta: EntityMetadata<T>, onCreateOnly?: boolean): void;
     private hydrate;
     private findEntity;
     private processDiscriminatorColumn;

package/entity/EntityFactory.js

@@ -30,7 +30,7 @@ export class EntityFactory {
     create(entityName, data, options = {}) {
         data = Reference.unwrapReference(data);
         options.initialized ??= true;
-        if (data.__entity) {
+        if (EntityHelper.isEntity(data)) {
             return data;
         }
         const meta = this.#metadata.get(entityName);
@@ -274,7 +274,8 @@ export class EntityFactory {
         }
         return entity;
     }
-    assignDefaultValues(entity, meta) {
+    /** @internal */
+    assignDefaultValues(entity, meta, onCreateOnly) {
         for (const prop of meta.props) {
             if (prop.embedded || [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
                 continue;
@@ -282,13 +283,13 @@ export class EntityFactory {
             if (prop.onCreate) {
                 entity[prop.name] ??= prop.onCreate(entity, this.#em);
             }
-            else if (prop.default != null && !isRaw(prop.default) && entity[prop.name] === undefined) {
+            else if (!onCreateOnly && prop.default != null && !isRaw(prop.default) && entity[prop.name] === undefined) {
                 entity[prop.name] = prop.default;
             }
             if (prop.kind === ReferenceKind.EMBEDDED && entity[prop.name]) {
                 const items = prop.array ? entity[prop.name] : [entity[prop.name]];
                 for (const item of items) {
-                    this.assignDefaultValues(item, prop.targetMeta);
+                    this.assignDefaultValues(item, prop.targetMeta, onCreateOnly);
                 }
             }
         }

package/entity/EntityHelper.d.ts

@@ -4,6 +4,7 @@ import { type EntityMetadata, type EntityProperty, type IHydrator } from '../typ
  * @internal
  */
 export declare class EntityHelper {
+    static isEntity(data: any): boolean;
     static decorate<T extends object>(meta: EntityMetadata<T>, em: EntityManager): void;
     /**
      * As a performance optimization, we create entity state methods lazily. We first add

package/entity/EntityHelper.js

@@ -7,10 +7,14 @@ import { ReferenceKind } from '../enums.js';
 import { helper } from './wrap.js';
 import { inspect } from '../logging/inspect.js';
 import { getEnv } from '../utils/env-vars.js';
+const entitySymbol = Symbol('Entity');
 /**
  * @internal
  */
 export class EntityHelper {
+    static isEntity(data) {
+        return data != null && typeof data === 'object' && !!data[entitySymbol];
+    }
     static decorate(meta, em) {
         const fork = em.fork(); // use fork so we can access `EntityFactory`
         const serializedPrimaryKey = meta.props.find(p => p.serializedPrimaryKey);
@@ -58,7 +62,7 @@ export class EntityHelper {
         // oxfmt-ignore
         const helperParams = meta.embeddable || meta.virtual ? [] : [em.getComparator().getPkGetter(meta), em.getComparator().getPkSerializer(meta), em.getComparator().getPkGetterConverted(meta)];
         Object.defineProperties(prototype, {
-            __entity: { value: !meta.embeddable, configurable: true },
+            [entitySymbol]: { value: !meta.embeddable, enumerable: false, configurable: true },
             __meta: { value: meta, configurable: true },
             __config: { value: em.config, configurable: true },
             __platform: { value: em.getPlatform(), configurable: true },

package/entity/Reference.d.ts

@@ -78,6 +78,7 @@ export declare class ScalarReference<Value> {
     unwrap(): Value | undefined;
     /** Returns whether the scalar value has been loaded. */
     isInitialized(): boolean;
+    static isScalarReference(data: any): data is ScalarReference<any>;
 }
 /** Options for `Reference.load()` to control how the referenced entity is loaded. */
 export interface LoadReferenceOptions<T extends object, P extends string = never, F extends string = never, E extends string = never> extends FindOneOptions<T, P, F, E> {

package/entity/Reference.js

@@ -4,12 +4,15 @@ import { Utils } from '../utils/Utils.js';
 import { QueryHelper } from '../utils/QueryHelper.js';
 import { NotFoundError } from '../errors.js';
 import { inspect } from '../logging/inspect.js';
+const referenceSymbol = Symbol('Reference');
+const scalarReferenceSymbol = Symbol('ScalarReference');
 /** Wrapper around an entity that provides lazy loading capabilities and identity-preserving reference semantics. */
 export class Reference {
     entity;
     property;
     constructor(entity) {
         this.entity = entity;
+        Object.defineProperty(this, referenceSymbol, { value: true, enumerable: false });
         this.set(entity);
         const meta = helper(this.entity).__meta;
         meta.primaryKeys.forEach(primaryKey => {
@@ -63,7 +66,7 @@ export class Reference {
      * Checks whether the argument is instance of `Reference` wrapper.
      */
     static isReference(data) {
-        return data && !!data.__reference;
+        return data != null && Object.hasOwn(data, referenceSymbol);
     }
     /**
      * Wraps the entity in a `Reference` wrapper if the property is defined as `ref`.
@@ -179,6 +182,7 @@ export class ScalarReference {
     #initialized;
     constructor(value, initialized = value != null) {
         this.value = value;
+        Object.defineProperty(this, scalarReferenceSymbol, { value: true, enumerable: false });
         this.#initialized = initialized;
     }
     /**
@@ -228,6 +232,9 @@ export class ScalarReference {
     isInitialized() {
         return this.#initialized;
     }
+    static isScalarReference(data) {
+        return data != null && typeof data === 'object' && Object.hasOwn(data, scalarReferenceSymbol);
+    }
     /** @ignore */
     /* v8 ignore next */
     [Symbol.for('nodejs.util.inspect.custom')]() {
@@ -235,7 +242,6 @@ export class ScalarReference {
     }
 }
 Object.defineProperties(Reference.prototype, {
-    __reference: { value: true, enumerable: false },
     __meta: {
         get() {
             return this.entity.__meta;
@@ -263,7 +269,6 @@ Object.defineProperties(Reference.prototype, {
     },
 });
 Object.defineProperties(ScalarReference.prototype, {
-    __scalarReference: { value: true, enumerable: false },
     $: {
         get() {
             return this.value;

package/hydration/ObjectHydrator.js

@@ -1,6 +1,7 @@
 import { Hydrator } from './Hydrator.js';
 import { Collection } from '../entity/Collection.js';
 import { Reference, ScalarReference } from '../entity/Reference.js';
+import { EntityHelper } from '../entity/EntityHelper.js';
 import { PolymorphicRef } from '../entity/PolymorphicRef.js';
 import { parseJsonSafe, Utils } from '../utils/Utils.js';
 import { ReferenceKind } from '../enums.js';
@@ -50,6 +51,8 @@ export class ObjectHydrator extends Hydrator {
         const context = new Map();
         const props = this.getProperties(meta, type);
         context.set('isPrimaryKey', Utils.isPrimaryKey);
+        context.set('isEntity', EntityHelper.isEntity);
+        context.set('isScalarReference', ScalarReference.isScalarReference);
         context.set('Collection', Collection);
         context.set('Reference', Reference);
         context.set('PolymorphicRef', PolymorphicRef);
@@ -122,7 +125,7 @@ export class ObjectHydrator extends Hydrator {
                 ret.push(`    entity${entityKey} = data${dataKey};`);
             }
             if (prop.ref) {
-                ret.push(`    const value = entity${entityKey}?.__scalarReference ? entity${entityKey}.unwrap() : entity${entityKey};`);
+                ret.push(`    const value = isScalarReference(entity${entityKey}) ? entity${entityKey}.unwrap() : entity${entityKey};`);
                 ret.push(`    entity${entityKey} = oldValue_${idx} ?? new ScalarReference(value);`);
                 ret.push(`    entity${entityKey}.bind(entity, '${prop.name}');`);
                 ret.push(`    entity${entityKey}.set(value);`);
@@ -419,7 +422,7 @@ export class ObjectHydrator extends Hydrator {
         const targetKey = this.safeKey(`${prop.targetMeta.tableName}_${this.#tmpIndex++}`);
         context.set(targetKey, prop.targetMeta.class);
         lines.push(`    if (isPrimaryKey(value, ${meta.compositePK})) return factory.createReference(${targetKey}, value, { convertCustomTypes, schema, normalizeAccessors, merge: true });`);
-        lines.push(`    if (value && value.__entity) return value;`);
+        lines.push(`    if (value && isEntity(value)) return value;`);
         lines.push(`    return factory.create(${targetKey}, value, { newEntity, convertCustomTypes, schema, normalizeAccessors, merge: true });`);
         lines.push(`  }`);
         return lines;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.0.6-dev.7",
+  "version": "7.0.6-dev.9",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",

package/utils/EntityComparator.js

@@ -60,11 +60,12 @@ export class EntityComparator {
         }
         const lines = [];
         const context = new Map();
+        context.set('isEntityOrRef', (val) => Utils.isEntity(val, true));
         if (meta.primaryKeys.length > 1) {
             lines.push(`  const cond = {`);
             meta.primaryKeys.forEach(pk => {
                 if (meta.properties[pk].kind !== ReferenceKind.SCALAR) {
-                    lines.push(`    ${pk}: (entity${this.wrap(pk)} != null && (entity${this.wrap(pk)}.__entity || entity${this.wrap(pk)}.__reference)) ? entity${this.wrap(pk)}.__helper.getPrimaryKey() : entity${this.wrap(pk)},`);
+                    lines.push(`    ${pk}: (entity${this.wrap(pk)} != null && isEntityOrRef(entity${this.wrap(pk)})) ? entity${this.wrap(pk)}.__helper.getPrimaryKey() : entity${this.wrap(pk)},`);
                 }
                 else {
                     lines.push(`    ${pk}: entity${this.wrap(pk)},`);
@@ -77,7 +78,7 @@ export class EntityComparator {
         else {
             const pk = meta.primaryKeys[0];
             if (meta.properties[pk].kind !== ReferenceKind.SCALAR) {
-                lines.push(`  if (entity${this.wrap(pk)} != null && (entity${this.wrap(pk)}.__entity || entity${this.wrap(pk)}.__reference)) {`);
+                lines.push(`  if (entity${this.wrap(pk)} != null && isEntityOrRef(entity${this.wrap(pk)})) {`);
                 lines.push(`    const pk = entity${this.wrap(pk)}.__helper.getPrimaryKey();`);
                 if (meta.properties[pk].targetMeta.compositePK) {
                     lines.push(`    if (typeof pk === 'object' && pk != null) {`);
@@ -110,11 +111,12 @@ export class EntityComparator {
         }
         const lines = [];
         const context = new Map();
+        context.set('isEntityOrRef', (val) => Utils.isEntity(val, true));
         if (meta.primaryKeys.length > 1) {
             lines.push(`  const cond = {`);
             meta.primaryKeys.forEach(pk => {
                 if (meta.properties[pk].kind !== ReferenceKind.SCALAR) {
-                    lines.push(`    ${pk}: (entity${this.wrap(pk)} != null && (entity${this.wrap(pk)}.__entity || entity${this.wrap(pk)}.__reference)) ? entity${this.wrap(pk)}.__helper.getPrimaryKey(true) : entity${this.wrap(pk)},`);
+                    lines.push(`    ${pk}: (entity${this.wrap(pk)} != null && isEntityOrRef(entity${this.wrap(pk)})) ? entity${this.wrap(pk)}.__helper.getPrimaryKey(true) : entity${this.wrap(pk)},`);
                 }
                 else {
                     if (meta.properties[pk].customType) {
@@ -133,7 +135,7 @@ export class EntityComparator {
         else {
             const pk = meta.primaryKeys[0];
             if (meta.properties[pk].kind !== ReferenceKind.SCALAR) {
-                lines.push(`  if (entity${this.wrap(pk)} != null && (entity${this.wrap(pk)}.__entity || entity${this.wrap(pk)}.__reference)) return entity${this.wrap(pk)}.__helper.getPrimaryKey(true);`);
+                lines.push(`  if (entity${this.wrap(pk)} != null && isEntityOrRef(entity${this.wrap(pk)})) return entity${this.wrap(pk)}.__helper.getPrimaryKey(true);`);
             }
             if (meta.properties[pk].customType) {
                 const convertorKey = this.registerCustomType(meta.properties[pk], context);
@@ -161,13 +163,14 @@ export class EntityComparator {
         }
         const lines = [];
         const context = new Map();
+        context.set('isEntityOrRef', (val) => Utils.isEntity(val, true));
         context.set('getCompositeKeyValue', (val) => Utils.flatten(Utils.getCompositeKeyValue(val, meta, 'convertToDatabaseValue', this.#platform)));
         context.set('getPrimaryKeyHash', (val) => Utils.getPrimaryKeyHash(Utils.asArray(val)));
         if (meta.primaryKeys.length > 1) {
             lines.push(`  const pks = entity.__helper.__pk ? getCompositeKeyValue(entity.__helper.__pk) : [`);
             meta.primaryKeys.forEach(pk => {
                 if (meta.properties[pk].kind !== ReferenceKind.SCALAR) {
-                    lines.push(`    (entity${this.wrap(pk)} != null && (entity${this.wrap(pk)}.__entity || entity${this.wrap(pk)}.__reference)) ? entity${this.wrap(pk)}.__helper.getSerializedPrimaryKey() : entity${this.wrap(pk)},`);
+                    lines.push(`    (entity${this.wrap(pk)} != null && isEntityOrRef(entity${this.wrap(pk)})) ? entity${this.wrap(pk)}.__helper.getSerializedPrimaryKey() : entity${this.wrap(pk)},`);
                 }
                 else {
                     lines.push(`    entity${this.wrap(pk)},`);
@@ -180,7 +183,7 @@ export class EntityComparator {
             const pk = meta.primaryKeys[0];
             const prop = meta.properties[pk];
             if (prop.kind !== ReferenceKind.SCALAR) {
-                lines.push(`  if (entity${this.wrap(pk)} != null && (entity${this.wrap(pk)}.__entity || entity${this.wrap(pk)}.__reference)) return entity${this.wrap(pk)}.__helper.getSerializedPrimaryKey();`);
+                lines.push(`  if (entity${this.wrap(pk)} != null && isEntityOrRef(entity${this.wrap(pk)})) return entity${this.wrap(pk)}.__helper.getSerializedPrimaryKey();`);
             }
             const serializedPrimaryKey = meta.props.find(p => p.serializedPrimaryKey);
             if (serializedPrimaryKey) {

package/utils/RawQueryFragment.js

@@ -1,4 +1,5 @@
 import { Utils } from './Utils.js';
+const rawSymbol = Symbol('RawQueryFragment');
 /** Represents a raw SQL fragment with optional parameters, usable as both a value and an object key via Symbol coercion. */
 export class RawQueryFragment {
     sql;
@@ -8,6 +9,7 @@ export class RawQueryFragment {
     constructor(sql, params = []) {
         this.sql = sql;
         this.params = params;
+        Object.defineProperty(this, rawSymbol, { value: true, enumerable: false });
     }
     /** Returns a unique symbol key for this fragment, creating and caching it on first access. */
     get key() {
@@ -74,12 +76,9 @@ export class RawQueryFragment {
     }
 }
 export { RawQueryFragment as Raw };
-Object.defineProperties(RawQueryFragment.prototype, {
-    __raw: { value: true, enumerable: false },
-});
 /** Checks whether the given value is a `RawQueryFragment` instance. */
 export function isRaw(value) {
-    return typeof value === 'object' && value !== null && '__raw' in value;
+    return typeof value === 'object' && value !== null && Object.hasOwn(value, rawSymbol);
 }
 /** @internal */
 export const ALIAS_REPLACEMENT = '[::alias::]';

package/utils/Utils.d.ts

@@ -1,7 +1,7 @@
 import type { CompiledFunctions, Dictionary, EntityData, EntityDictionary, EntityKey, EntityMetadata, EntityName, EntityProperty, Primary } from '../typings.js';
-import type { Collection } from '../entity/Collection.js';
 import type { Platform } from '../platforms/Platform.js';
-import { type ScalarReference } from '../entity/Reference.js';
+import { ScalarReference } from '../entity/Reference.js';
+import { Collection } from '../entity/Collection.js';
 import { type RawQueryFragmentSymbol } from './RawQueryFragment.js';
 /** Deeply compares two objects for equality, handling dates, regexes, and raw fragments. */
 export declare function compareObjects(a: any, b: any): boolean;
@@ -108,7 +108,7 @@ export declare class Utils {
     /**
      * Checks whether given object is a scalar reference.
      */
-    static isScalarReference<T = unknown>(data: any, allowReference?: boolean): data is ScalarReference<any> & {};
+    static isScalarReference<T = unknown>(data: any): data is ScalarReference<any> & {};
     /**
      * Checks whether the argument is empty (array without items, object without keys or falsy value).
      */

package/utils/Utils.js

@@ -1,7 +1,10 @@
 import { clone } from './clone.js';
 import { GroupOperator, PlainObject, QueryOperator, ReferenceKind } from '../enums.js';
 import { helper } from '../entity/wrap.js';
-import { Raw } from './RawQueryFragment.js';
+import { Reference, ScalarReference } from '../entity/Reference.js';
+import { Collection } from '../entity/Collection.js';
+import { EntityHelper } from '../entity/EntityHelper.js';
+import { Raw, isRaw } from './RawQueryFragment.js';
 function compareConstructors(a, b) {
     if (a.constructor === b.constructor) {
         return true;
@@ -22,7 +25,7 @@ export function compareObjects(a, b) {
     if (!a || !b || typeof a !== 'object' || typeof b !== 'object' || !compareConstructors(a, b)) {
         return false;
     }
-    if (a.__raw && b.__raw) {
+    if (isRaw(a) && isRaw(b)) {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
         return a.sql === b.sql && compareArrays(a.params, b.params);
     }
@@ -129,7 +132,7 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.6-dev.7';
+    static #ORM_VERSION = '7.0.6-dev.9';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */
@@ -220,6 +223,9 @@ export class Utils {
         const source = sources.shift();
         if (Utils.isObject(target) && Utils.isPlainObject(source)) {
             for (const [key, value] of Object.entries(source)) {
+                if (['__proto__', 'constructor', 'prototype'].includes(key)) {
+                    continue;
+                }
                 if (ignoreUndefined && typeof value === 'undefined') {
                     continue;
                 }
@@ -500,16 +506,16 @@ export class Utils {
         if (!Utils.isObject(data)) {
             return false;
         }
-        if (allowReference && !!data.__reference) {
+        if (allowReference && Reference.isReference(data)) {
             return true;
         }
-        return !!data.__entity;
+        return EntityHelper.isEntity(data);
     }
     /**
      * Checks whether given object is a scalar reference.
      */
-    static isScalarReference(data, allowReference = false) {
-        return typeof data === 'object' && data?.__scalarReference;
+    static isScalarReference(data) {
+        return ScalarReference.isScalarReference(data);
     }
     /**
      * Checks whether the argument is empty (array without items, object without keys or falsy value).
@@ -596,7 +602,7 @@ export class Utils {
         return ret;
     }
     static isCollection(item) {
-        return item?.__collection;
+        return Collection.isCollection(item);
     }
     // FNV-1a 64-bit
     static hash(data, length) {

package/utils/clone.js

@@ -120,6 +120,7 @@ export function clone(parent, respectCustomCloneMethod = true) {
             const symbol = symbols[i];
             const descriptor = Object.getOwnPropertyDescriptor(parent, symbol);
             if (descriptor && !descriptor.enumerable) {
+                Object.defineProperty(child, symbol, { ...descriptor, value: _clone(descriptor.value) });
                 continue;
             }
             child[symbol] = _clone(parent[symbol]);