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

package/drivers/IDatabaseDriver.d.ts

@@ -248,6 +248,7 @@ export interface NativeInsertUpdateOptions<T> {
     /** `nativeUpdate()` only option */
     upsert?: boolean;
     loggerContext?: LogContext;
+    logging?: LoggingOptions;
     /** sql only */
     unionWhere?: ObjectQuery<T>[];
     /** sql only */
@@ -310,6 +311,8 @@ export interface UpdateOptions<T> {
     filters?: FilterOptions;
     schema?: string;
     ctx?: Transaction;
+    loggerContext?: LogContext;
+    logging?: LoggingOptions;
     /** sql only */
     unionWhere?: ObjectQuery<T>[];
     /** sql only */
@@ -347,6 +350,7 @@ export interface DriverMethodOptions {
     ctx?: Transaction;
     schema?: string;
     loggerContext?: LogContext;
+    logging?: LoggingOptions;
 }
 /** MongoDB-style collation options for locale-aware string comparison. */
 export interface CollationOptions {

package/entity/EntityFactory.js

@@ -139,12 +139,6 @@ export class EntityFactory {
         const existsData = this.#comparator.prepareEntity(entity);
         const originalEntityData = helper(entity).__originalEntityData ?? {};
         const diff = this.#comparator.diffEntities(meta.class, originalEntityData, existsData);
-        // version properties are not part of entity snapshots
-        if (meta.versionProperty &&
-            data[meta.versionProperty] &&
-            data[meta.versionProperty] !== originalEntityData[meta.versionProperty]) {
-            diff[meta.versionProperty] = data[meta.versionProperty];
-        }
         const diff2 = this.#comparator.diffEntities(meta.class, existsData, data, { includeInverseSides: true });
         // do not override values changed by user; for uninitialized entities,
         // the diff may include stale snapshot entries (value is undefined) — skip those
@@ -167,10 +161,11 @@ export class EntityFactory {
             return diff2[key] === undefined;
         })
             .forEach(key => delete diff2[key]);
-        // but always add collection properties, formulas, and generated columns if they are part of the `data`,
-        // as these are excluded from `comparableProps` and won't appear in the diff
+        // but always add collection properties, formulas, generated columns, and version properties if they
+        // are part of the `data`, as these are excluded from `comparableProps` and won't appear in the diff
         Utils.keys(data)
             .filter(key => meta.properties[key]?.formula ||
+            meta.properties[key]?.version ||
             (meta.properties[key]?.generated && !meta.properties[key]?.primary) ||
             [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(meta.properties[key]?.kind))
             .forEach(key => (diff2[key] = data[key]));

package/entity/EntityLoader.js

@@ -47,7 +47,12 @@ export class EntityLoader {
             throw ValidationError.invalidPropertyName(entityName, invalid.field);
         }
         this.setSerializationContext(entities, populate, options);
+        const addedToVisited = [];
         for (const entity of entities) {
+            if (visited.has(entity)) {
+                continue;
+            }
+            addedToVisited.push(entity);
             visited.add(entity);
         }
         for (const pop of populate) {
@@ -79,7 +84,7 @@ export class EntityLoader {
                 });
             }
         }
-        for (const entity of entities) {
+        for (const entity of addedToVisited) {
             visited.delete(entity);
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.0.11-dev.1",
+  "version": "7.0.11-dev.11",
   "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/typings.d.ts

@@ -441,12 +441,13 @@ type RequiredNullableKeys<T> = {
     [K in keyof T]: Exclude<T[K], null> extends RequiredNullable.Brand ? K : never;
 }[keyof T];
 type ProbablyOptionalProps<T> = PrimaryProperty<T> | ExplicitlyOptionalProps<T> | Exclude<NonNullable<NullableKeys<T, null | undefined>>, RequiredNullableKeys<T>>;
+type RestoreOptUnknown<T> = [Exclude<T, null | undefined>] extends [Opt.Brand] ? [Opt.Brand] extends [Exclude<T, null | undefined>] ? unknown : T : T;
 type IsOptional<T, K extends keyof T, I> = T[K] extends CollectionShape ? true : ExtractType<T[K]> extends I ? true : K extends ProbablyOptionalProps<T> ? true : false;
 type RequiredKeys<T, K extends keyof T, I> = IsOptional<T, K, I> extends false ? CleanKeys<T, K> : never;
 type OptionalKeys<T, K extends keyof T, I> = IsOptional<T, K, I> extends false ? never : CleanKeys<T, K>;
 /** Data shape for creating or updating entities. All properties are optional. Used in `em.create()` and `em.assign()`. */
 export type EntityData<T, C extends boolean = false> = {
-    [K in EntityKey<T>]?: EntityDataItem<T[K] & {}, C>;
+    [K in EntityKey<T>]?: RestoreOptUnknown<T[K]> | EntityDataItem<T[K] & {}, C>;
 };
 /**
  * Data shape for `em.create()` with required/optional distinction based on entity metadata.
@@ -454,9 +455,9 @@ export type EntityData<T, C extends boolean = false> = {
  * `I` excludes additional types from being required (used for inverse side of relations).
  */
 export type RequiredEntityData<T, I = never, C extends boolean = false> = {
-    [K in keyof T as RequiredKeys<T, K, I>]: T[K] | RequiredEntityDataProp<T[K], T, C> | Primary<T[K]> | PolymorphicPrimary<T[K]> | Raw;
+    [K in keyof T as RequiredKeys<T, K, I>]: RestoreOptUnknown<T[K]> | RequiredEntityDataProp<T[K], T, C> | Primary<T[K]> | PolymorphicPrimary<T[K]> | Raw;
 } & {
-    [K in keyof T as OptionalKeys<T, K, I>]?: T[K] | RequiredEntityDataProp<T[K], T, C> | Primary<T[K]> | PolymorphicPrimary<T[K]> | Raw | null;
+    [K in keyof T as OptionalKeys<T, K, I>]?: RestoreOptUnknown<T[K]> | RequiredEntityDataProp<T[K], T, C> | Primary<T[K]> | PolymorphicPrimary<T[K]> | Raw | null;
 };
 /** `EntityData<T>` extended with an index signature, allowing arbitrary additional properties. */
 export type EntityDictionary<T> = EntityData<T> & Record<any, any>;
@@ -494,7 +495,9 @@ type PrimaryOrObject<T, U, C extends TypeConfig> = PreferExplicitConfig<C, Extra
 } : Primary<U>;
 type DTOWrapper<T, C extends TypeConfig, Flat extends boolean> = Flat extends true ? EntityDTOFlat<T, C> : EntityDTO<T, C>;
 /** Resolves the serialized (DTO) type for a single entity property. Unwraps references, collections, and custom serialized types. */
-export type EntityDTOProp<E, T, C extends TypeConfig = never, Flat extends boolean = false> = T extends Scalar ? T : T extends ScalarReference<infer U> ? U : T extends {
+export type EntityDTOProp<E, T, C extends TypeConfig = never, Flat extends boolean = false> = T extends Scalar ? T extends {
+    __serialized?: infer U;
+} ? IsUnknown<U> extends false ? U : T : T : T extends ScalarReference<infer U> ? U : T extends {
     __serialized?: infer U;
 } ? IsUnknown<U> extends false ? U : T : T extends LoadedReferenceShape<infer U> ? DTOWrapper<U, C, Flat> : T extends ReferenceShape<infer U> ? PrimaryOrObject<E, U, C> : T extends LoadedCollectionShape<infer U> ? DTOWrapper<U & object, C, Flat>[] : T extends CollectionShape<infer U> ? PrimaryOrObject<E, U & object, C>[] : T extends readonly (infer U)[] ? U extends Scalar ? T : EntityDTOProp<E, U, C, Flat>[] : T extends Relation<T> ? DTOWrapper<T, C, Flat> : T;
 type UnwrapLoadedEntity<T> = T extends {

package/unit-of-work/ChangeSetPersister.js

@@ -327,6 +327,10 @@ export class ChangeSetPersister {
         const primaryKeys = meta.primaryKeys.concat(...meta.concurrencyCheckKeys);
         options = this.prepareOptions(meta, options, {
             fields: primaryKeys,
+            orderBy: meta.primaryKeys.reduce((o, pk) => {
+                o[pk] = 'asc';
+                return o;
+            }, {}),
         });
         const res = await this.#driver.find(meta.root.class, { $or }, options);
         if (res.length !== changeSets.length) {

package/utils/Utils.js

@@ -141,7 +141,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.11-dev.1';
+    static #ORM_VERSION = '7.0.11-dev.11';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */