@mikro-orm/core 7.0.0-rc.3 → 7.0.1-dev.0

package/metadata/MetadataStorage.d.ts

@@ -1,12 +1,8 @@
 import { type Dictionary, EntityMetadata, type EntityName } from '../typings.js';
 import type { EntityManager } from '../EntityManager.js';
 export declare class MetadataStorage {
+    #private;
     static readonly PATH_SYMBOL: unique symbol;
-    private static readonly metadata;
-    private readonly metadata;
-    private readonly idMap;
-    private readonly classNameMap;
-    private readonly uniqueNameMap;
     constructor(metadata?: Dictionary<EntityMetadata>);
     static getMetadata(): Dictionary<EntityMetadata>;
     static getMetadata<T = any>(entity: string, path: string): EntityMetadata<T>;

package/metadata/MetadataStorage.js

@@ -10,39 +10,39 @@ function getGlobalStorage(namespace) {
 }
 export class MetadataStorage {
     static PATH_SYMBOL = Symbol.for('@mikro-orm/core/MetadataStorage.PATH_SYMBOL');
-    static metadata = getGlobalStorage('metadata');
-    metadata = new Map();
-    idMap;
-    classNameMap;
-    uniqueNameMap;
+    static #metadata = getGlobalStorage('metadata');
+    #metadataMap = new Map();
+    #idMap;
+    #classNameMap;
+    #uniqueNameMap;
     constructor(metadata = {}) {
-        this.idMap = {};
-        this.uniqueNameMap = {};
-        this.classNameMap = Utils.copy(metadata, false);
-        for (const meta of Object.values(this.classNameMap)) {
-            this.idMap[meta._id] = meta;
-            this.uniqueNameMap[meta.uniqueName] = meta;
-            this.metadata.set(meta.class, meta);
+        this.#idMap = {};
+        this.#uniqueNameMap = {};
+        this.#classNameMap = Utils.copy(metadata, false);
+        for (const meta of Object.values(this.#classNameMap)) {
+            this.#idMap[meta._id] = meta;
+            this.#uniqueNameMap[meta.uniqueName] = meta;
+            this.#metadataMap.set(meta.class, meta);
         }
     }
     static getMetadata(entity, path) {
         const key = entity && path ? entity + '-' + Utils.hash(path) : null;
-        if (key && !MetadataStorage.metadata[key]) {
-            MetadataStorage.metadata[key] = new EntityMetadata({ className: entity, path });
+        if (key && !MetadataStorage.#metadata[key]) {
+            MetadataStorage.#metadata[key] = new EntityMetadata({ className: entity, path });
         }
         if (key) {
-            return MetadataStorage.metadata[key];
+            return MetadataStorage.#metadata[key];
         }
-        return MetadataStorage.metadata;
+        return MetadataStorage.#metadata;
     }
     static isKnownEntity(name) {
-        return !!Object.values(this.metadata).find(meta => meta.className === name);
+        return !!Object.values(this.#metadata).find(meta => meta.className === name);
     }
     static clear() {
-        Object.keys(this.metadata).forEach(k => delete this.metadata[k]);
+        Object.keys(this.#metadata).forEach(k => delete this.#metadata[k]);
     }
     getAll() {
-        return this.metadata;
+        return this.#metadataMap;
     }
     get(entityName, init = false) {
         const exists = this.find(entityName);
@@ -61,50 +61,50 @@ export class MetadataStorage {
         if (!entityName) {
             return;
         }
-        const meta = this.metadata.get(entityName);
+        const meta = this.#metadataMap.get(entityName);
         if (meta) {
             return meta;
         }
         if (entityName instanceof EntitySchema) {
-            return this.metadata.get(entityName.meta.class) ?? entityName.meta;
+            return this.#metadataMap.get(entityName.meta.class) ?? entityName.meta;
         }
-        return this.classNameMap[Utils.className(entityName)];
+        return this.#classNameMap[Utils.className(entityName)];
     }
     has(entityName) {
-        return this.metadata.has(entityName);
+        return this.#metadataMap.has(entityName);
     }
     set(entityName, meta) {
-        this.metadata.set(entityName, meta);
-        this.idMap[meta._id] = meta;
-        this.uniqueNameMap[meta.uniqueName] = meta;
-        this.classNameMap[Utils.className(entityName)] = meta;
+        this.#metadataMap.set(entityName, meta);
+        this.#idMap[meta._id] = meta;
+        this.#uniqueNameMap[meta.uniqueName] = meta;
+        this.#classNameMap[Utils.className(entityName)] = meta;
         return meta;
     }
     reset(entityName) {
         const meta = this.find(entityName);
         if (meta) {
-            this.metadata.delete(meta.class);
-            delete this.idMap[meta._id];
-            delete this.uniqueNameMap[meta.uniqueName];
-            delete this.classNameMap[meta.className];
+            this.#metadataMap.delete(meta.class);
+            delete this.#idMap[meta._id];
+            delete this.#uniqueNameMap[meta.uniqueName];
+            delete this.#classNameMap[meta.className];
         }
     }
     decorate(em) {
-        [...this.metadata.values()].filter(meta => meta.prototype).forEach(meta => EntityHelper.decorate(meta, em));
+        [...this.#metadataMap.values()].filter(meta => meta.prototype).forEach(meta => EntityHelper.decorate(meta, em));
     }
     *[Symbol.iterator]() {
-        for (const meta of this.metadata.values()) {
+        for (const meta of this.#metadataMap.values()) {
             yield meta;
         }
     }
     getById(id) {
-        return this.idMap[id];
+        return this.#idMap[id];
     }
     getByClassName(className, validate = true) {
-        return this.validate(this.classNameMap[className], className, validate);
+        return this.validate(this.#classNameMap[className], className, validate);
     }
     getByUniqueName(uniqueName, validate = true) {
-        return this.validate(this.uniqueNameMap[uniqueName], uniqueName, validate);
+        return this.validate(this.#uniqueNameMap[uniqueName], uniqueName, validate);
     }
     validate(meta, id, validate) {
         if (!meta && validate) {

package/metadata/discover-entities.js

@@ -31,7 +31,7 @@ export async function discoverEntities(paths, options) {
     const found = new Map();
     for (const filepath of files) {
         const filename = basename(filepath);
-        if (!filename.match(/\.[cm]?[jt]s$/) || filename.match(/\.d\.[cm]?ts/)) {
+        if (!/\.[cm]?[jt]s$/.exec(filename) || /\.d\.[cm]?ts/.exec(filename)) {
             continue;
         }
         await getEntityClassOrSchema(filepath, found, baseDir);

package/metadata/index.d.ts

@@ -1,4 +1,4 @@
-export * from './types.js';
+export type * from './types.js';
 export * from './EntitySchema.js';
 export * from './MetadataDiscovery.js';
 export * from './MetadataStorage.js';

package/metadata/index.js

@@ -1,4 +1,3 @@
-export * from './types.js';
 export * from './EntitySchema.js';
 export * from './MetadataDiscovery.js';
 export * from './MetadataStorage.js';

package/naming-strategy/AbstractNamingStrategy.js

@@ -34,7 +34,7 @@ export class AbstractNamingStrategy {
      * @inheritDoc
      */
     getEntityName(tableName, schemaName) {
-        const name = tableName.match(/^[^$_\p{ID_Start}]/u) ? `E_${tableName}` : tableName;
+        const name = /^[^$_\p{ID_Start}]/u.exec(tableName) ? `E_${tableName}` : tableName;
         return this.getClassName(name.replaceAll(/[^\u200C\u200D\p{ID_Continue}]+/gu, r => r
             .split('')
             .map(c => `$${c.codePointAt(0)}`)

package/naming-strategy/EntityCaseNamingStrategy.js

@@ -11,7 +11,7 @@ export class EntityCaseNamingStrategy extends AbstractNamingStrategy {
     }
     joinKeyColumnName(entityName, referencedColumnName, composite, tableName) {
         entityName = this.classToTableName(entityName, tableName);
-        const name = entityName.substr(0, 1).toLowerCase() + entityName.substr(1);
+        const name = entityName.substring(0, 1).toLowerCase() + entityName.substring(1);
         if (composite && referencedColumnName) {
             return name + '_' + referencedColumnName;
         }

package/naming-strategy/index.d.ts

@@ -1,4 +1,4 @@
-export * from './NamingStrategy.js';
+export type * from './NamingStrategy.js';
 export * from './AbstractNamingStrategy.js';
 export * from './MongoNamingStrategy.js';
 export * from './UnderscoreNamingStrategy.js';

package/naming-strategy/index.js

@@ -1,4 +1,3 @@
-export * from './NamingStrategy.js';
 export * from './AbstractNamingStrategy.js';
 export * from './MongoNamingStrategy.js';
 export * from './UnderscoreNamingStrategy.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.0.0-rc.3",
+  "version": "7.0.1-dev.0",
   "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/platforms/Platform.d.ts

@@ -1,6 +1,6 @@
 import { EntityRepository } from '../entity/EntityRepository.js';
 import { type NamingStrategy } from '../naming-strategy/NamingStrategy.js';
-import type { Constructor, EntityMetadata, EntityProperty, IPrimaryKey, ISchemaGenerator, PopulateOptions, Primary, SimpleColumnMeta } from '../typings.js';
+import type { Constructor, EntityMetadata, EntityProperty, IPrimaryKey, ISchemaGenerator, PopulateOptions, Primary, SimpleColumnMeta, FilterQuery, EntityValue, EntityKey } from '../typings.js';
 import { ExceptionConverter } from './ExceptionConverter.js';
 import type { EntityManager } from '../EntityManager.js';
 import type { Configuration } from '../utils/Configuration.js';
@@ -61,6 +61,13 @@ export declare abstract class Platform {
     getDateTypeDeclarationSQL(length?: number): string;
     getTimeTypeDeclarationSQL(length?: number): string;
     getRegExpOperator(val?: unknown, flags?: string): string;
+    mapRegExpCondition(mappedKey: string, value: {
+        $re: string;
+        $flags?: string;
+    }): {
+        sql: string;
+        params: unknown[];
+    };
     getRegExpValue(val: RegExp): {
         $re: string;
         $flags?: string;
@@ -139,6 +146,11 @@ export declare abstract class Platform {
     getMappedType(type: string): Type<unknown>;
     getDefaultMappedType(type: string): Type<unknown>;
     supportsMultipleCascadePaths(): boolean;
+    /**
+     * Returns true if the platform supports ON UPDATE foreign key rules.
+     * Oracle doesn't support ON UPDATE rules.
+     */
+    supportsOnUpdate(): boolean;
     supportsMultipleStatements(): boolean;
     supportsUnionWhere(): boolean;
     getArrayDeclarationSQL(): string;
@@ -148,6 +160,8 @@ export declare abstract class Platform {
     getJsonDeclarationSQL(): string;
     getSearchJsonPropertySQL(path: string, type: string, aliased: boolean): string | Raw;
     getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean, value?: unknown): string | Raw;
+    processJsonCondition<T extends object>(o: FilterQuery<T>, value: EntityValue<T>, path: EntityKey<T>[], alias: boolean): FilterQuery<T>;
+    protected getJsonValueType(value: unknown): string;
     getJsonIndexDefinition(index: {
         columnNames: string[];
     }): string[];
@@ -160,6 +174,14 @@ export declare abstract class Platform {
     convertDateToJSValue(value: string | Date): string;
     convertIntervalToJSValue(value: string): unknown;
     convertIntervalToDatabaseValue(value: unknown): unknown;
+    usesAsKeyword(): boolean;
+    /**
+     * Determines how UUID values are compared in the change set tracking.
+     * Return `'string'` for inline string comparison (fast), or `'any'` for deep comparison via type methods.
+     */
+    compareUuids(): string;
+    convertUuidToJSValue(value: unknown): unknown;
+    convertUuidToDatabaseValue(value: unknown): unknown;
     parseDate(value: string | number): Date;
     getRepositoryClass<T extends object>(): Constructor<EntityRepository<T>>;
     getDefaultCharset(): string;

package/platforms/Platform.js

@@ -3,7 +3,7 @@ import { EntityRepository } from '../entity/EntityRepository.js';
 import { UnderscoreNamingStrategy } from '../naming-strategy/UnderscoreNamingStrategy.js';
 import { ExceptionConverter } from './ExceptionConverter.js';
 import { ArrayType, BigIntType, BlobType, BooleanType, CharacterType, DateTimeType, DateType, DecimalType, DoubleType, EnumType, FloatType, IntegerType, IntervalType, JsonType, MediumIntType, SmallIntType, StringType, TextType, TimeType, TinyIntType, Type, Uint8ArrayType, UnknownType, UuidType, } from '../types/index.js';
-import { parseJsonSafe } from '../utils/Utils.js';
+import { parseJsonSafe, Utils } from '../utils/Utils.js';
 import { ReferenceKind } from '../enums.js';
 import { Raw } from '../utils/RawQueryFragment.js';
 export const JsonProperty = Symbol('JsonProperty');
@@ -104,6 +104,11 @@ export class Platform {
     getRegExpOperator(val, flags) {
         return 'regexp';
     }
+    mapRegExpCondition(mappedKey, value) {
+        const operator = this.getRegExpOperator(value.$re, value.$flags);
+        const quotedKey = this.quoteIdentifier(mappedKey);
+        return { sql: `${quotedKey} ${operator} ?`, params: [value.$re] };
+    }
     getRegExpValue(val) {
         if (val.flags.includes('i')) {
             return { $re: `(?i)${val.source}` };
@@ -156,7 +161,7 @@ export class Platform {
         return 'interval' + (column.length ? `(${column.length})` : '');
     }
     getTextTypeDeclarationSQL(_column) {
-        return `text`;
+        return 'text';
     }
     getEnumTypeDeclarationSQL(column) {
         if (column.items?.every(item => typeof item === 'string')) {
@@ -180,7 +185,7 @@ export class Platform {
         return this.getVarcharTypeDeclarationSQL(column);
     }
     extractSimpleType(type) {
-        return type.toLowerCase().match(/[^(), ]+/)[0];
+        return /[^(), ]+/.exec(type.toLowerCase())[0];
     }
     /**
      * This should be used only to compare types, it can strip some information like the length.
@@ -255,6 +260,13 @@ export class Platform {
     supportsMultipleCascadePaths() {
         return true;
     }
+    /**
+     * Returns true if the platform supports ON UPDATE foreign key rules.
+     * Oracle doesn't support ON UPDATE rules.
+     */
+    supportsOnUpdate() {
+        return true;
+    }
     supportsMultipleStatements() {
         return this.config.get('multipleStatements');
     }
@@ -285,6 +297,31 @@ export class Platform {
     getSearchJsonPropertyKey(path, type, aliased, value) {
         return path.join('.');
     }
+    processJsonCondition(o, value, path, alias) {
+        if (Utils.isPlainObject(value) && !Object.keys(value).some(k => Utils.isOperator(k))) {
+            Utils.keys(value).forEach(k => {
+                this.processJsonCondition(o, value[k], [...path, k], alias);
+            });
+            return o;
+        }
+        if (path.length === 1) {
+            o[path[0]] = value;
+            return o;
+        }
+        const type = this.getJsonValueType(value);
+        const k = this.getSearchJsonPropertyKey(path, type, alias, value);
+        o[k] = value;
+        return o;
+    }
+    getJsonValueType(value) {
+        if (Array.isArray(value)) {
+            return typeof value[0];
+        }
+        if (Utils.isPlainObject(value) && Object.keys(value).every(k => Utils.isOperator(k))) {
+            return this.getJsonValueType(Object.values(value)[0]);
+        }
+        return typeof value;
+    }
     /* v8 ignore next */
     getJsonIndexDefinition(index) {
         return index.columnNames;
@@ -316,6 +353,22 @@ export class Platform {
     convertIntervalToDatabaseValue(value) {
         return value;
     }
+    usesAsKeyword() {
+        return true;
+    }
+    /**
+     * Determines how UUID values are compared in the change set tracking.
+     * Return `'string'` for inline string comparison (fast), or `'any'` for deep comparison via type methods.
+     */
+    compareUuids() {
+        return 'string';
+    }
+    convertUuidToJSValue(value) {
+        return value;
+    }
+    convertUuidToDatabaseValue(value) {
+        return value;
+    }
     parseDate(value) {
         const date = new Date(value);
         /* v8 ignore next */
@@ -380,7 +433,7 @@ export class Platform {
         let j = 0;
         let pos = 0;
         let ret = '';
-        if (sql[0] === '?') {
+        if (sql.startsWith('?')) {
             if (sql[1] === '?') {
                 ret += this.quoteIdentifier(params[j++]);
                 pos = 2;

package/serialization/EntitySerializer.js

@@ -36,7 +36,7 @@ export class EntitySerializer {
         const meta = wrapped.__meta;
         let contextCreated = false;
         if (!wrapped.__serializationContext.root) {
-            const root = new SerializationContext(wrapped.__config);
+            const root = new SerializationContext();
             SerializationContext.propagate(root, entity, (meta, prop) => meta.properties[prop]?.kind !== ReferenceKind.SCALAR);
             options.populate = (options.populate ? Utils.asArray(options.populate) : options.populate);
             contextCreated = true;

package/serialization/EntityTransformer.js

@@ -20,7 +20,7 @@ export class EntityTransformer {
             return entity;
         }
         if (!wrapped.__serializationContext.root) {
-            const root = new SerializationContext(wrapped.__config, wrapped.__serializationContext.populate, wrapped.__serializationContext.fields, wrapped.__serializationContext.exclude);
+            const root = new SerializationContext(wrapped.__serializationContext.populate, wrapped.__serializationContext.fields, wrapped.__serializationContext.exclude);
             SerializationContext.propagate(root, entity, isVisible);
             contextCreated = true;
         }
@@ -64,6 +64,9 @@ export class EntityTransformer {
                 if (!partiallyLoaded && !populated && !isPrimary) {
                     continue;
                 }
+                if (root.isExcluded(meta.class, prop) && !populated) {
+                    continue;
+                }
             }
             const cycle = root.visit(meta.class, prop);
             if (cycle && visited) {

package/serialization/SerializationContext.d.ts

@@ -1,19 +1,14 @@
 import type { AnyEntity, EntityMetadata, EntityName, PopulateOptions } from '../typings.js';
-import type { Configuration } from '../utils/Configuration.js';
 /**
  * Helper that allows to keep track of where we are currently at when serializing complex entity graph with cycles.
  * Before we process a property, we call `visit` that checks if it is not a cycle path (but allows to pass cycles that
  * are defined in populate hint). If not, we proceed and call `leave` afterwards.
  */
 export declare class SerializationContext<T extends object> {
-    private readonly config;
-    private readonly populate;
-    private readonly fields?;
-    private readonly exclude?;
+    #private;
     readonly path: [EntityName, string][];
-    readonly visited: Set<Partial<any>>;
-    private entities;
-    constructor(config: Configuration, populate?: PopulateOptions<T>[], fields?: Set<string> | undefined, exclude?: string[] | undefined);
+    readonly visited: Set<AnyEntity>;
+    constructor(populate?: PopulateOptions<T>[], fields?: Set<string>, exclude?: readonly string[]);
     /**
      * Returns true when there is a cycle detected.
      */
@@ -25,6 +20,7 @@ export declare class SerializationContext<T extends object> {
      */
     static propagate(root: SerializationContext<any>, entity: AnyEntity, isVisible: (meta: EntityMetadata, prop: string) => boolean): void;
     isMarkedAsPopulated(entityName: EntityName, prop: string): boolean;
+    isExcluded(entityName: EntityName, prop: string): boolean;
     isPartiallyLoaded(entityName: EntityName, prop: string): boolean;
     private register;
 }

package/serialization/SerializationContext.js

@@ -6,18 +6,16 @@ import { helper } from '../entity/wrap.js';
  * are defined in populate hint). If not, we proceed and call `leave` afterwards.
  */
 export class SerializationContext {
-    config;
-    populate;
-    fields;
-    exclude;
     path = [];
     visited = new Set();
-    entities = new Set();
-    constructor(config, populate = [], fields, exclude) {
-        this.config = config;
-        this.populate = populate;
-        this.fields = fields;
-        this.exclude = exclude;
+    #entities = new Set();
+    #populate;
+    #fields;
+    #exclude;
+    constructor(populate = [], fields, exclude) {
+        this.#populate = populate;
+        this.#fields = fields;
+        this.#exclude = exclude;
     }
     /**
      * Returns true when there is a cycle detected.
@@ -42,7 +40,7 @@ export class SerializationContext {
         }
     }
     close() {
-        for (const entity of this.entities) {
+        for (const entity of this.#entities) {
             delete helper(entity).__serializationContext.root;
         }
     }
@@ -73,7 +71,7 @@ export class SerializationContext {
         }
     }
     isMarkedAsPopulated(entityName, prop) {
-        let populate = this.populate ?? [];
+        let populate = this.#populate ?? [];
         for (const segment of this.path) {
             const hints = populate.filter(p => p.field === segment[1]);
             if (hints.length > 0) {
@@ -92,11 +90,18 @@ export class SerializationContext {
         }
         return !!populate?.some(p => p.field === prop);
     }
+    isExcluded(entityName, prop) {
+        if (!this.#exclude || this.#exclude.length === 0) {
+            return false;
+        }
+        const fullPath = this.path.map(segment => segment[1] + '.').join('') + prop;
+        return this.#exclude.includes(fullPath);
+    }
     isPartiallyLoaded(entityName, prop) {
-        if (!this.fields) {
+        if (!this.#fields) {
             return true;
         }
-        let fields = [...this.fields];
+        let fields = [...this.#fields];
         for (const segment of this.path) {
             /* v8 ignore next */
             if (fields.length === 0) {
@@ -110,6 +115,6 @@ export class SerializationContext {
     }
     register(entity) {
         helper(entity).__serializationContext.root = this;
-        this.entities.add(entity);
+        this.#entities.add(entity);
     }
 }

package/types/UuidType.d.ts

@@ -4,5 +4,7 @@ import type { EntityProperty } from '../typings.js';
 export declare class UuidType extends Type<string | null | undefined> {
     getColumnType(prop: EntityProperty, platform: Platform): string;
     compareAsType(): string;
+    convertToDatabaseValue(value: string | null | undefined, platform: Platform): string | null;
+    convertToJSValue(value: string | null | undefined, platform: Platform): string | null | undefined;
     ensureComparable(): boolean;
 }

package/types/UuidType.js

@@ -4,9 +4,21 @@ export class UuidType extends Type {
         return platform.getUuidTypeDeclarationSQL(prop);
     }
     compareAsType() {
-        return 'string';
+        return this.platform?.compareUuids() ?? 'string';
+    }
+    convertToDatabaseValue(value, platform) {
+        if (value == null) {
+            return value;
+        }
+        return platform.convertUuidToDatabaseValue(value);
+    }
+    convertToJSValue(value, platform) {
+        if (value == null) {
+            return value;
+        }
+        return platform.convertUuidToJSValue(value);
     }
     ensureComparable() {
-        return false;
+        return this.platform?.compareUuids() !== 'string';
     }
 }

package/types/index.d.ts

@@ -23,7 +23,8 @@ import { type IType, type TransformContext, Type } from './Type.js';
 import { Uint8ArrayType } from './Uint8ArrayType.js';
 import { UnknownType } from './UnknownType.js';
 import { UuidType } from './UuidType.js';
-export { Type, DateType, TimeType, DateTimeType, BigIntType, BlobType, Uint8ArrayType, ArrayType, EnumArrayType, EnumType, JsonType, IntegerType, SmallIntType, TinyIntType, MediumIntType, FloatType, DoubleType, BooleanType, DecimalType, StringType, UuidType, TextType, UnknownType, TransformContext, IntervalType, IType, CharacterType, };
+export type { TransformContext, IType };
+export { Type, DateType, TimeType, DateTimeType, BigIntType, BlobType, Uint8ArrayType, ArrayType, EnumArrayType, EnumType, JsonType, IntegerType, SmallIntType, TinyIntType, MediumIntType, FloatType, DoubleType, BooleanType, DecimalType, StringType, UuidType, TextType, UnknownType, IntervalType, CharacterType, };
 export declare const types: {
     readonly date: typeof DateType;
     readonly time: typeof TimeType;

package/typings.d.ts

@@ -234,8 +234,18 @@ export type FilterItemValue<T> = T | ExpandScalar<T> | Primary<T> | Raw;
 export type FilterValue<T> = OperatorMap<FilterItemValue<T>> | FilterItemValue<T> | FilterItemValue<T>[] | null;
 type FilterObjectProp<T, K extends PropertyKey> = K extends keyof MergeUnion<T> ? MergeUnion<T>[K] : K extends keyof T ? T[K] : never;
 type ExpandQueryMerged<T> = [T] extends [object] ? [T] extends [Scalar] ? never : FilterQuery<MergeUnion<T>> : FilterValue<T>;
+type ElemMatchCondition<T extends Record<string, any>> = {
+    [K in keyof T]?: T[K] | OperatorMap<T[K]>;
+} & {
+    $or?: ElemMatchCondition<T>[];
+    $and?: ElemMatchCondition<T>[];
+    $not?: ElemMatchCondition<T>;
+};
+type ElemMatchFilter<T> = T extends readonly (infer E)[] ? E extends Record<string, any> ? {
+    $elemMatch: ElemMatchCondition<E>;
+} : never : never;
 export type FilterObject<T> = {
-    -readonly [K in EntityKey<T>]?: ExpandQuery<ExpandProperty<FilterObjectProp<T, K>>> | ExpandQueryMerged<ExpandProperty<FilterObjectProp<T, K>>> | FilterValue<ExpandProperty<FilterObjectProp<T, K>>> | null;
+    -readonly [K in EntityKey<T>]?: ExpandQuery<ExpandProperty<FilterObjectProp<T, K>>> | ExpandQueryMerged<ExpandProperty<FilterObjectProp<T, K>>> | FilterValue<ExpandProperty<FilterObjectProp<T, K>>> | ElemMatchFilter<FilterObjectProp<T, K>> | null;
 };
 export type ExpandQuery<T> = T extends object ? (T extends Scalar ? never : FilterQuery<T>) : FilterValue<T>;
 export type EntityProps<T> = {
@@ -523,6 +533,7 @@ export interface EntityProperty<Owner = any, Target = any> {
     nullable?: boolean;
     inherited?: boolean;
     renamedFrom?: string;
+    stiMerged?: boolean;
     stiFieldNames?: string[];
     stiFieldNameMap?: Dictionary<string>;
     unsigned?: boolean;

package/unit-of-work/ChangeSetComputer.d.ts

@@ -3,12 +3,7 @@ import { ChangeSet } from './ChangeSet.js';
 import { type Collection } from '../entity/Collection.js';
 import type { EntityManager } from '../EntityManager.js';
 export declare class ChangeSetComputer {
-    private readonly em;
-    private readonly collectionUpdates;
-    private readonly comparator;
-    private readonly metadata;
-    private readonly platform;
-    private readonly config;
+    #private;
     constructor(em: EntityManager, collectionUpdates: Set<Collection<AnyEntity>>);
     computeChangeSet<T extends object>(entity: T): ChangeSet<T> | null;
     /**