@mikro-orm/core 7.2.2-dev.9 → 7.3.0-dev.1

package/EntityManager.d.ts

@@ -580,6 +580,11 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
      * Checks whether this EntityManager is currently operating inside a database transaction.
      */
     isInTransaction(): boolean;
+    /**
+     * Checks whether transactions are disabled for this EntityManager.
+     * @internal
+     */
+    isTransactionDisabled(): boolean;
     /**
      * Gets the transaction context (driver dependent object used to make sure queries are executed on same connection).
      */
@@ -633,7 +638,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     /**
      * @internal
      */
-    tryCache<T extends object, R>(entityName: EntityName<T>, config: boolean | number | [string, number] | undefined, key: unknown, refresh?: boolean, merge?: boolean): Promise<{
+    tryCache<T extends object, R>(entityName: EntityName<T>, config: boolean | number | [string, number] | undefined, key: unknown, refresh?: boolean, merge?: boolean, schema?: string): Promise<{
         data?: R | null;
         key: string;
     } | undefined>;

package/EntityManager.js

@@ -133,7 +133,7 @@ export class EntityManager {
         options.populate = (await em.preparePopulate(entityName, options));
         const populate = options.populate;
         const cacheKey = em.cacheKey(entityName, options, 'em.find', where);
-        const cached = await em.tryCache(entityName, options.cache, cacheKey, options.refresh, true);
+        const cached = await em.tryCache(entityName, options.cache, cacheKey, options.refresh, true, options.schema);
         if (cached?.data) {
             await em.#entityLoader.populate(entityName, cached.data, populate, {
                 ...options,
@@ -834,7 +834,7 @@ export class EntityManager {
         validateParams(where);
         options.populate = (await em.preparePopulate(entityName, options));
         const cacheKey = em.cacheKey(entityName, options, 'em.findOne', where);
-        const cached = await em.tryCache(entityName, options.cache, cacheKey, options.refresh, true);
+        const cached = await em.tryCache(entityName, options.cache, cacheKey, options.refresh, true, options.schema);
         if (cached?.data !== undefined) {
             if (cached.data) {
                 await em.#entityLoader.populate(entityName, [cached.data], options.populate, {
@@ -1110,7 +1110,18 @@ export class EntityManager {
                 const ret = [];
                 for (const idx of shapes.values()) {
                     const res = await this.upsertMany(entityName, idx.map(i => data[i]), options);
-                    idx.forEach((i, j) => (ret[i] = res[j]));
+                    const seen = new Set();
+                    let j = 0;
+                    // `res` holds every entity once, so skip the rows resolving to an entity an earlier row already took
+                    for (const i of idx) {
+                        const row = data[i];
+                        const entity = Utils.isEntity(row)
+                            ? row
+                            : em.#unitOfWork.tryGetById(entityName, row, options.schema, false);
+                        if (!seen.has(entity)) {
+                            seen.add((ret[i] = res[j++]));
+                        }
+                    }
                 }
                 // rows resolving to the same entity are returned once, as in the single statement path
                 return [...new Set(ret.filter(entity => entity))];
@@ -1123,9 +1134,10 @@ export class EntityManager {
         const generatedFields = new Set();
         const allData = [];
         const allWhere = [];
+        const dataIndexes = [];
+        const result = [];
         const entities = new Map();
         const entitiesByData = new Map();
-        const entitiesByAllDataIdx = new Map();
         for (let i = 0; i < data.length; i++) {
             let row = data[i];
             let where;
@@ -1133,14 +1145,12 @@ export class EntityManager {
                 const entity = row;
                 if (helper(entity).__managed && helper(entity).__em === em && !this.config.get('upsertManaged')) {
                     em.#entityFactory.mergeData(meta, entity, row, { initialized: true });
-                    entities.set(entity, row);
-                    entitiesByData.set(row, entity);
+                    result[i] = entity;
                     continue;
                 }
                 where = helper(entity).getPrimaryKey();
                 getOnCreateGeneratedFields(meta, entity).forEach(field => generatedFields.add(field));
                 em.#entityFactory.assignDefaultValues(entity, meta);
-                entitiesByAllDataIdx.set(allData.length, entity);
                 row = em.#comparator.prepareEntity(entity);
             }
             else {
@@ -1150,8 +1160,7 @@ export class EntityManager {
                     const exists = em.#unitOfWork.getById(entityName, where, options.schema);
                     if (exists) {
                         em.assign(exists, row);
-                        entities.set(exists, row);
-                        entitiesByData.set(row, exists);
+                        result[i] = exists;
                         continue;
                     }
                 }
@@ -1184,22 +1193,25 @@ export class EntityManager {
             validateParams(row, 'insert data');
             allData.push(row);
             allWhere.push(where);
+            dataIndexes.push(i);
         }
-        if (entities.size === data.length) {
-            return [...entities.keys()];
+        if (allData.length === 0) {
+            return [...new Set(result)];
         }
         // `onCreate` generated values are for the insert clause only, they must not overwrite existing rows
         if (generatedFields.size > 0 && !options.onConflictMergeFields) {
             options.onConflictExcludeFields = [...(options.onConflictExcludeFields ?? []), ...generatedFields];
         }
         if (em.eventManager.hasListeners(EventType.beforeUpsert, meta)) {
-            for (const dto of data) {
-                const entity = entitiesByData.get(dto) ?? dto;
+            for (const index of dataIndexes) {
+                const entity = data[index];
                 await em.eventManager.dispatchEvent(EventType.beforeUpsert, { entity, em, meta }, meta);
             }
-            for (const [idx, entity] of entitiesByAllDataIdx) {
-                allData[idx] = em.#comparator.prepareEntity(entity);
-            }
+            dataIndexes.forEach((index, idx) => {
+                if (Utils.isEntity(data[index])) {
+                    allData[idx] = em.#comparator.prepareEntity(data[index]);
+                }
+            });
         }
         const res = await em.withSessionContext(options.ctx ?? em.#transactionContext, ctx => em.driver.nativeUpdateMany(entityName, allWhere, allData, {
             upsert: true,
@@ -1207,15 +1219,16 @@ export class EntityManager {
             ...options,
             ctx,
         }));
-        entities.clear();
-        entitiesByData.clear();
         const loadPK = new Map();
         allData.forEach((row, i) => {
-            em.#unitOfWork.getChangeSetPersister().mapReturnedValues(Utils.isEntity(data[i]) ? data[i] : null, Utils.isEntity(data[i]) ? {} : data[i], 
+            // Managed inputs skipped by the SQL batch still occupy positions in `data`.
+            const index = dataIndexes[i];
+            const item = data[index];
+            em.#unitOfWork.getChangeSetPersister().mapReturnedValues(Utils.isEntity(item) ? item : null, Utils.isEntity(item) ? {} : item, 
             // A suppressed conflict omits its row; positional mapping would hydrate a different entity.
             res.rows?.length === allData.length ? res.rows[i] : undefined, meta, true);
-            const entity = Utils.isEntity(data[i])
-                ? data[i]
+            const entity = Utils.isEntity(item)
+                ? item
                 : em.#entityFactory.create(entityName, row, {
                     refresh: true,
                     initialized: true,
@@ -1226,18 +1239,19 @@ export class EntityManager {
             }
             entities.set(entity, row);
             entitiesByData.set(row, entity);
+            result[index] = entity;
         });
         // skip the reload only when RETURNING brought back a row for every input
         // (onConflictWhere can suppress writes, leaving some rows out)
         // oxfmt-ignore
         const uniqueFields = options.onConflictFields ?? (Utils.isPlainObject(allWhere[0]) ? Object.keys(allWhere[0]).flatMap(key => Utils.splitPrimaryKeys(key)) : meta.primaryKeys);
         const platform = this.getPlatform();
-        const returning = getOnConflictReturningFields(meta, data[0], uniqueFields, options, platform);
+        const returning = getOnConflictReturningFields(meta, data[dataIndexes[0]], uniqueFields, options, platform);
         if (options.onConflictWhere && res.rows?.length !== allData.length) {
             returning.push(...meta.comparableProps.filter(p => !p.lazy && !p.embeddable).map(p => p.name));
         }
         const reloadFields = returning.length > 0 &&
-            !((platform.usesReturningStatement() || platform.usesOutputStatement()) && res.rows?.length === data.length);
+            !((platform.usesReturningStatement() || platform.usesOutputStatement()) && res.rows?.length === allData.length);
         if (options.onConflictAction === 'ignore' || (!res.rows?.length && loadPK.size > 0) || reloadFields) {
             const unique = meta.hydrateProps.filter(p => !p.lazy).map(p => p.name);
             const add = new Set(propIndex !== false && propIndex >= 0
@@ -1247,7 +1261,8 @@ export class EntityManager {
                 Utils.keys(cond).forEach(key => add.add(key));
             }
             const where = { $or: [] };
-            data.forEach((item, idx) => {
+            dataIndexes.forEach((index, idx) => {
+                const item = data[index];
                 where.$or[idx] = {};
                 const props = Array.isArray(uniqueFields) ? uniqueFields : Object.keys(item);
                 props.forEach(prop => {
@@ -1317,7 +1332,7 @@ export class EntityManager {
                 await em.eventManager.dispatchEvent(EventType.afterUpsert, { entity, em, meta }, meta);
             }
         }
-        return [...entities.keys()];
+        return [...new Set(result)];
     }
     /**
      * Runs your callback wrapped inside a database transaction.
@@ -1974,6 +1989,13 @@ export class EntityManager {
     isInTransaction() {
         return !!this.getContext(false).#transactionContext;
     }
+    /**
+     * Checks whether transactions are disabled for this EntityManager.
+     * @internal
+     */
+    isTransactionDisabled() {
+        return !!this.getContext(false).#disableTransactions;
+    }
     /**
      * Gets the transaction context (driver dependent object used to make sure queries are executed on same connection).
      */
@@ -2329,7 +2351,7 @@ export class EntityManager {
     /**
      * @internal
      */
-    async tryCache(entityName, config, key, refresh, merge) {
+    async tryCache(entityName, config, key, refresh, merge, schema) {
         config ??= this.config.get('resultCache').global;
         if (!config) {
             return undefined;
@@ -2351,6 +2373,7 @@ export class EntityManager {
             merge: true,
             convertCustomTypes: false,
             refresh,
+            schema,
             recomputeSnapshot: true,
         };
         if (Array.isArray(cached) && merge) {

package/entity/EntityFactory.js

@@ -190,7 +190,7 @@ export class EntityFactory {
         const initialized = options.initialized || helper(entity).__initialized;
         this.hydrate(entity, meta, diff2, initialized ? { ...options, initialized } : options);
         // we need to update the entity data only with keys that were not present before
-        const nullVal = this.#config.get('forceUndefined') ? undefined : null;
+        const nullVal = (meta.forceUndefined ?? this.#config.get('forceUndefined')) ? undefined : null;
         Utils.keys(diff2).forEach(key => {
             const prop = meta.properties[key];
             if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) &&
@@ -336,7 +336,7 @@ export class EntityFactory {
                 prop.default == null &&
                 !prop.defaultRaw &&
                 entity[prop.name] === undefined) {
-                entity[prop.name] = (this.#config.get('forceUndefined') ? undefined : null);
+                entity[prop.name] = ((meta.forceUndefined ?? this.#config.get('forceUndefined')) ? undefined : null);
             }
             if (prop.kind === ReferenceKind.EMBEDDED && entity[prop.name]) {
                 const items = prop.array ? entity[prop.name] : [entity[prop.name]];

package/entity/EntityLoader.js

@@ -458,7 +458,8 @@ export class EntityLoader {
         if ([ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind) &&
             items.length !== children.length &&
             Utils.isEmpty(options.where)) {
-            const nullVal = this.#em.config.get('forceUndefined') ? undefined : null;
+            const ownerMeta = this.#metadata.find(prop.entity());
+            const nullVal = (ownerMeta.forceUndefined ?? this.#em.config.get('forceUndefined')) ? undefined : null;
             const itemsMap = new Set();
             const childrenMap = new Set();
             // `e` may be an unresolved reference here, so read the targetKey value directly instead of

package/entity/defineEntity.d.ts

@@ -631,7 +631,7 @@ type PartialWhere<TProperties, TBase> = string | FilterQuery<{
     [K in AllKeys<TProperties, TBase> & string]?: unknown;
 }>;
 /** Metadata descriptor for `defineEntity()`, combining entity options with property definitions. */
-export interface EntityMetadataWithProperties<TName extends string, TTableName extends string, TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never, TRepository = never, TForceObject extends boolean = false, TDiscriminatorColumn extends string | undefined = undefined, TDiscriminatorValue extends string | number | undefined = undefined, TBaseDiscriminatorColumn extends string | undefined = undefined, TEmbeddable extends boolean = false> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK, TBase, TRepository>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminator' | 'discriminatorColumn' | 'discriminatorValue' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques' | 'triggers' | 'repository' | 'filters' | 'orderBy'> {
+export interface EntityMetadataWithProperties<TName extends string, TTableName extends string, TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never, TRepository = never, TForceObject extends boolean = false, TDiscriminatorColumn extends string | undefined = undefined, TDiscriminatorValue extends string | number | undefined = undefined, TBaseDiscriminatorColumn extends string | undefined = undefined, TEmbeddable extends boolean = false, TForceUndefined extends boolean = false> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK, TBase, TRepository>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminator' | 'discriminatorColumn' | 'discriminatorValue' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques' | 'triggers' | 'repository' | 'filters' | 'orderBy'> {
     name: TName;
     tableName?: TTableName;
     extends?: {
@@ -656,6 +656,8 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
         };
     }>;
     forceObject?: TForceObject;
+    /** Hydrate `null` as `undefined` for this entity and infer nullable properties as `T | undefined`. */
+    forceUndefined?: TForceUndefined;
     embeddable?: TEmbeddable;
     inheritance?: 'tpt';
     orderBy?: {
@@ -707,7 +709,7 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
     }[];
 }
 /** Defines an entity schema using property builders, with full type inference from the property definitions. */
-export declare function defineEntity<const TName extends string, const TTableName extends string, const TProperties extends Record<string, any>, const TPK extends (keyof TProperties)[] | undefined = undefined, const TBase = never, const TRepository = never, const TForceObject extends boolean = false, const TDiscriminatorColumn extends string | undefined = undefined, const TDiscriminatorValue extends string | number | undefined = undefined, const TBaseDiscriminatorColumn extends string | undefined = undefined, const TEmbeddable extends boolean = false>(meta: EntityMetadataWithProperties<TName, TTableName, TProperties, TPK, TBase, TRepository, TForceObject, TDiscriminatorColumn, TDiscriminatorValue, TBaseDiscriminatorColumn, TEmbeddable>): EntitySchemaWithMeta<TName, TTableName, InferEntityFromProperties<TProperties, TPK, TBase, TRepository, TForceObject, TBaseDiscriminatorColumn, TDiscriminatorValue, TEmbeddable>, TBase, TProperties, EntityCtor<InferEntityFromProperties<TProperties, TPK, TBase, TRepository, TForceObject, TBaseDiscriminatorColumn, TDiscriminatorValue, TEmbeddable>>, TDiscriminatorColumn>;
+export declare function defineEntity<const TName extends string, const TTableName extends string, const TProperties extends Record<string, any>, const TPK extends (keyof TProperties)[] | undefined = undefined, const TBase = never, const TRepository = never, const TForceObject extends boolean = false, const TDiscriminatorColumn extends string | undefined = undefined, const TDiscriminatorValue extends string | number | undefined = undefined, const TBaseDiscriminatorColumn extends string | undefined = undefined, const TEmbeddable extends boolean = false, const TForceUndefined extends boolean = false>(meta: EntityMetadataWithProperties<TName, TTableName, TProperties, TPK, TBase, TRepository, TForceObject, TDiscriminatorColumn, TDiscriminatorValue, TBaseDiscriminatorColumn, TEmbeddable, TForceUndefined>): EntitySchemaWithMeta<TName, TTableName, MaybeForceUndefined<InferEntityFromProperties<TProperties, TPK, TBase, TRepository, TForceObject, TBaseDiscriminatorColumn, TDiscriminatorValue, TEmbeddable, TForceUndefined>, EffectiveForceUndefined<TForceUndefined, TBase>>, TBase, TProperties, EntityCtor<MaybeForceUndefined<InferEntityFromProperties<TProperties, TPK, TBase, TRepository, TForceObject, TBaseDiscriminatorColumn, TDiscriminatorValue, TEmbeddable, TForceUndefined>, EffectiveForceUndefined<TForceUndefined, TBase>>>, TDiscriminatorColumn>;
 export declare namespace defineEntity {
     export { propertyBuilders as properties };
 }
@@ -744,8 +746,17 @@ type InferColumnType<T extends string> = T extends 'int' | 'int4' | 'integer' |
 type BaseEntityMethodKeys = 'toObject' | 'toPOJO' | 'serialize' | 'assign' | 'populate' | 'init' | 'toReference';
 interface BaseEntityMethods<in out Entity extends object> extends Pick<IWrappedEntity<Entity>, BaseEntityMethodKeys> {
 }
+type MaybeForceUndefined<Entity, ForceUndefined> = [ForceUndefined] extends [true] ? {
+    [K in keyof Entity]: SwapNull<Entity[K]>;
+} : Entity;
+type SwapNull<Value> = [Value] extends [ScalarReference<infer Inner>] ? [Extract<keyof Value, symbol>] extends [never] ? ScalarReference<SwapNull<Inner>> : ScalarReference<SwapNull<Inner>> & Pick<Value, Extract<keyof Value, symbol>> : null extends Value ? Exclude<Value, null> | undefined : Value;
+type EffectiveForceUndefined<Flag, Base> = [Flag] extends [true] ? true : IsNever<Base> extends true ? false : [Base] extends [{
+    [Config]?: infer C;
+}] ? [NonNullable<C>] extends [{
+    forceUndefined: true;
+}] ? true : false : false;
 /** Infers the entity type from a `defineEntity()` properties map, resolving builders, base classes, and primary keys. */
-export type InferEntityFromProperties<Properties extends Record<string, any>, PK extends (keyof Properties)[] | undefined = undefined, Base = never, Repository = never, ForceObject extends boolean = false, BaseDiscriminatorColumn extends string | undefined = undefined, DiscriminatorValue extends string | number | undefined = undefined, Embeddable extends boolean = false> = (IsNever<Base> extends true ? {} : Base extends {
+export type InferEntityFromProperties<Properties extends Record<string, any>, PK extends (keyof Properties)[] | undefined = undefined, Base = never, Repository = never, ForceObject extends boolean = false, BaseDiscriminatorColumn extends string | undefined = undefined, DiscriminatorValue extends string | number | undefined = undefined, Embeddable extends boolean = false, ForceUndefined extends boolean = false> = (IsNever<Base> extends true ? {} : Base extends {
     toObject(...args: any[]): any;
 } ? BaseEntityMethods<{
     -readonly [K in keyof Properties]: InferBuilderValue<MaybeReturnType<Properties[K]>>;
@@ -763,6 +774,10 @@ export type InferEntityFromProperties<Properties extends Record<string, any>, PK
     [Config]?: DefineConfig<{
         forceObject: true;
     }>;
+} : {}) & (ForceUndefined extends true ? {
+    [Config]?: DefineConfig<{
+        forceUndefined: true;
+    }>;
 } : {}) & {
     [IndexHints]?: [Omit<ExtractBaseProperties<Base>, keyof Properties> & Properties];
 };

package/hydration/ObjectHydrator.js

@@ -50,6 +50,8 @@ export class ObjectHydrator extends Hydrator {
         const lines = [];
         const context = new Map();
         const props = this.getProperties(meta, type);
+        const forceUndefined = meta.forceUndefined ?? this.config.get('forceUndefined');
+        const nullVal = forceUndefined ? 'undefined' : 'null';
         context.set('isPrimaryKey', Utils.isPrimaryKey);
         context.set('isEntity', EntityHelper.isEntity);
         context.set('isScalarReference', ScalarReference.isScalarReference);
@@ -76,7 +78,6 @@ export class ObjectHydrator extends Hydrator {
                 .join('_');
             const ret = [];
             const idx = this.#tmpIndex++;
-            const nullVal = this.config.get('forceUndefined') ? 'undefined' : 'null';
             if (prop.getter && !prop.setter && prop.persist === false) {
                 return [];
             }
@@ -142,7 +143,6 @@ export class ObjectHydrator extends Hydrator {
         const hydrateToOne = (prop, dataKey, entityKey) => {
             const ret = [];
             const method = type === 'reference' ? 'createReference' : 'create';
-            const nullVal = this.config.get('forceUndefined') ? 'undefined' : 'null';
             ret.push(`  if (data${dataKey} === null) {\n    entity${entityKey} = ${nullVal};`);
             ret.push(`  } else if (typeof data${dataKey} !== 'undefined') {`);
             // For polymorphic: instanceof check; for regular: isPrimaryKey() check
@@ -341,8 +341,6 @@ export class ObjectHydrator extends Hydrator {
                     ...hydrateProperty(childProp, prop.object, [...path, childProp.embedded[1]], childDataKey).map(l => '  ' + l));
                 });
             }
-            /* v8 ignore next */
-            const nullVal = this.config.get('forceUndefined') ? 'undefined' : 'null';
             if (prop.object) {
                 ret.push(`  } else if (data${dataKey} === null) {`);
             }
@@ -365,8 +363,7 @@ export class ObjectHydrator extends Hydrator {
             ret.push(...hydrateEmbedded(prop, [...path, `[idx_${idx}]`], `${dataKey}[idx_${idx}]`).map(l => '    ' + l));
             ret.push(`    });`);
             ret.push(`  } else if (data${dataKey} === null) {`);
-            /* v8 ignore next */
-            ret.push(`    entity${entityKey} = ${this.config.get('forceUndefined') ? 'undefined' : 'null'};`);
+            ret.push(`    entity${entityKey} = ${nullVal};`);
             ret.push(`  }`);
             return ret;
         };
@@ -396,7 +393,7 @@ export class ObjectHydrator extends Hydrator {
                 // ReferenceKind.SCALAR
                 ret.push(...hydrateScalar(prop, path, dataKey));
             }
-            if (this.config.get('forceUndefined')) {
+            if (forceUndefined) {
                 ret.push(`  if (data${dataKey} === null) entity${entityKey} = undefined;`);
             }
             return ret;

package/metadata/MetadataDiscovery.js

@@ -1062,6 +1062,7 @@ export class MetadataDiscovery {
         });
         ownProps.forEach(prop => (meta.properties[prop.name] = prop));
         meta.filters = { ...base.filters, ...meta.filters };
+        meta.forceUndefined ??= base.forceUndefined;
         if (!meta.discriminatorValue) {
             Object.values(base.properties)
                 .filter(prop => !old.includes(prop.name))

package/metadata/types.d.ts

@@ -85,6 +85,8 @@ export type EntityOptions<T, E = T extends EntityClass<infer P> ? P : T> = {
     abstract?: boolean;
     /** Disables change tracking - such entities are ignored during flush. */
     readonly?: boolean;
+    /** Hydrate `null` values as `undefined` for this entity, overriding the global `forceUndefined` option. */
+    forceUndefined?: boolean;
     /** Marks entity as {@doclink virtual-entities | virtual}. This is set automatically when you use `expression` option (unless `view` is set). */
     virtual?: boolean;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.2.2-dev.9",
+  "version": "7.3.0-dev.1",
   "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

@@ -246,6 +246,8 @@ export type CleanTypeConfig<T> = Compute<Pick<T, Extract<keyof T, keyof TypeConf
 /** Configuration options that can be set on an entity via the `[Config]` symbol. */
 export interface TypeConfig {
     forceObject?: boolean;
+    /** Type-level marker of the `forceUndefined` entity option: `defineEntity` infers nullable properties as `T | undefined` instead of `T | null | undefined`. */
+    forceUndefined?: boolean;
 }
 declare const __selectedType: unique symbol;
 declare const __loadedType: unique symbol;
@@ -1223,6 +1225,8 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
     selfReferencing?: boolean;
     hasUniqueProps?: boolean;
     readonly?: boolean;
+    /** Per-entity override of the global `forceUndefined` option. */
+    forceUndefined?: boolean;
     polymorphs?: EntityMetadata[];
     root: EntityMetadata<Entity>;
     definedProperties: Dictionary;

package/unit-of-work/ChangeSetPersister.js

@@ -207,7 +207,7 @@ export class ChangeSetPersister {
         const keys = meta.getOwnConcurrencyCheckKeys();
         for (const key of keys) {
             cond[key] = changeSet.originalEntity[key];
-            if (changeSet.payload[key]) {
+            if (Object.hasOwn(changeSet.payload, key)) {
                 tmp.push(key);
             }
         }
@@ -322,17 +322,19 @@ export class ChangeSetPersister {
         }
         // skip entity references as they don't have version values loaded
         changeSets = changeSets.filter(cs => helper(cs.entity).__initialized);
-        const primaryKeys = meta.primaryKeys.concat(...concurrencyCheckKeys);
+        const fields = meta.primaryKeys.concat(...concurrencyCheckKeys);
         const $or = changeSets.map(cs => {
-            const cond = Utils.getPrimaryKeyCond(cs.originalEntity, primaryKeys);
+            const cond = Utils.getPrimaryKeyCond(cs.originalEntity, meta.primaryKeys);
+            for (const key of concurrencyCheckKeys) {
+                cond[key] = cs.originalEntity[key];
+            }
             if (meta.ownsVersionProperty()) {
-                // @ts-ignore
                 cond[meta.versionProperty] = this.#platform.convertVersionValue(cs.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
             }
             return cond;
         });
         options = this.prepareOptions(meta, options, {
-            fields: primaryKeys,
+            fields,
             orderBy: meta.primaryKeys.reduce((o, pk) => {
                 o[pk] = 'asc';
                 return o;
@@ -344,8 +346,8 @@ export class ChangeSetPersister {
         if (res.length !== changeSets.length) {
             // a FK pointing to a composite PK is an array, so the values need to be compared deeply
             const compare = (a, b, keys) => keys.every(k => equals(a[k], b[k]));
-            const entity = changeSets.find(cs => {
-                return !res.some(row => compare(Utils.getPrimaryKeyCond(cs.entity, primaryKeys), row, primaryKeys));
+            const entity = changeSets.find((_, index) => {
+                return !res.some(row => compare($or[index], row, meta.primaryKeys));
             }).entity;
             throw OptimisticLockError.lockFailed(entity);
         }

package/unit-of-work/UnitOfWork.js

@@ -79,7 +79,7 @@ export class UnitOfWork {
      * @internal
      */
     normalizeEntityData(meta, data) {
-        const forceUndefined = this.#em.config.get('forceUndefined');
+        const forceUndefined = meta.forceUndefined ?? this.#em.config.get('forceUndefined');
         for (const key of Utils.keys(data)) {
             const prop = meta.properties[key];
             if (!prop) {
@@ -467,7 +467,10 @@ export class UnitOfWork {
             }
             const groups = this.getChangeSetGroups();
             const platform = this.#em.getPlatform();
-            const runInTransaction = !this.#em.isInTransaction() && platform.supportsTransactions() && this.#em.config.get('implicitTransactions');
+            const runInTransaction = !this.#em.isInTransaction() &&
+                !this.#em.isTransactionDisabled() &&
+                platform.supportsTransactions() &&
+                this.#em.config.get('implicitTransactions');
             if (runInTransaction) {
                 const loggerContext = Utils.merge({ id: this.#em._id }, this.#em.getLoggerContext({ disableContextResolution: true }));
                 await this.#em.getConnection('write').transactional(trx => this.persistToDatabase(groups, trx), {

package/utils/QueryHelper.js

@@ -111,9 +111,17 @@ export class QueryHelper {
             const op = this.liftGroupOperators(value, prop.targetMeta, metadata, k);
             if (op) {
                 delete where[k];
-                where[op] = value[op].map((v) => {
+                const group = value[op].map((v) => {
                     return { [k]: v };
                 });
+                if (op in where) {
+                    // Sibling groups are conjunctive, even when both use `$or`.
+                    where.$and ??= [];
+                    where.$and.push({ [op]: group });
+                }
+                else {
+                    where[op] = group;
+                }
             }
         }
         return undefined;

package/utils/TransactionContext.d.ts

@@ -1,6 +1,7 @@
 import type { EntityManager } from '../EntityManager.js';
 /** Uses `AsyncLocalStorage` to maintain a transaction-scoped EntityManager context across async operations. */
 export declare class TransactionContext {
+    #private;
     readonly em: EntityManager;
     private static storage;
     readonly id: number;

package/utils/TransactionContext.js

@@ -1,8 +1,10 @@
+var _a;
 import { createAsyncContext } from './AsyncContext.js';
 /** Uses `AsyncLocalStorage` to maintain a transaction-scoped EntityManager context across async operations. */
 export class TransactionContext {
     em;
     static storage = createAsyncContext();
+    #parent = _a.currentTransactionContext();
     id;
     constructor(em) {
         this.em = em;
@@ -12,7 +14,7 @@ export class TransactionContext {
      * Creates new TransactionContext instance and runs the code inside its domain.
      */
     static create(em, next) {
-        const context = new TransactionContext(em);
+        const context = new _a(em);
         return this.storage.run(context, next);
     }
     /**
@@ -25,7 +27,11 @@ export class TransactionContext {
      * Returns current EntityManager (if available).
      */
     static getEntityManager(name = 'default') {
-        const context = TransactionContext.currentTransactionContext();
-        return context?.em.name === name ? context.em : undefined;
+        let context = _a.currentTransactionContext();
+        while (context && context.em.name !== name) {
+            context = context.#parent;
+        }
+        return context?.em;
     }
 }
+_a = TransactionContext;

package/utils/TransactionManager.js

@@ -81,10 +81,10 @@ export class TransactionManager {
      */
     async executeWithoutTransaction(em, cb, options) {
         const suspended = this.suspendTransaction(em);
-        const fork = this.createFork(em, { ...options, disableTransactions: true });
+        const fork = this.createFork(em, options);
         const propagateToUpperContext = this.shouldPropagateToUpperContext(em);
         try {
-            return await this.executeTransactionFlow(fork, cb, propagateToUpperContext, em);
+            return await TransactionContext.create(fork, () => this.executeTransactionFlow(fork, cb, propagateToUpperContext, em));
         }
         finally {
             this.resumeTransaction(em, suspended);

package/utils/Utils.js

@@ -153,7 +153,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.2.2-dev.9';
+    static #ORM_VERSION = '7.3.0-dev.1';
     /** Default session variable name backing an RLS filter argument (`current_setting('mikro.<filter>.<arg>')`). */
     static getRlsSettingName(filterName, argName) {
         return `mikro.${filterName}.${argName}`;