@mikro-orm/core 6.4.17-dev.1 → 6.4.17-dev.100

package/typings.js

@@ -47,12 +47,29 @@ class EntityMetadata {
             this.sync();
         }
     }
-    getPrimaryProps() {
-        return this.primaryKeys.map(pk => this.properties[pk]);
+    getPrimaryProps(flatten = false) {
+        const pks = this.primaryKeys.map(pk => this.properties[pk]);
+        if (flatten) {
+            return pks.flatMap(pk => {
+                if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(pk.kind)) {
+                    return pk.targetMeta.getPrimaryProps(true);
+                }
+                return [pk];
+            });
+        }
+        return pks;
     }
     getPrimaryProp() {
         return this.properties[this.primaryKeys[0]];
     }
+    createColumnMappingObject() {
+        return Object.values(this.properties).reduce((o, prop) => {
+            if (prop.fieldNames) {
+                o[prop.name] = prop.fieldNames[0];
+            }
+            return o;
+        }, {});
+    }
     get tableName() {
         return this.collection;
     }
@@ -72,7 +89,7 @@ class EntityMetadata {
             // `prop.userDefined` is either `undefined` or `false`
             const discriminator = this.root.discriminatorColumn === prop.name && prop.userDefined === false;
             // even if we don't have a setter, do not ignore value from database!
-            const onlyGetter = prop.getter && !prop.setter;
+            const onlyGetter = prop.getter && !prop.setter && prop.persist === false;
             return !prop.inherited && prop.hydrate !== false && !discriminator && !prop.embedded && !onlyGetter;
         });
         this.trackingProps = this.hydrateProps
@@ -115,7 +132,7 @@ class EntityMetadata {
                         wrapped.__data[prop.name] = entity_1.Reference.wrapReference(val, prop);
                         // when propagation from inside hydration, we set the FK to the entity data immediately
                         if (val && hydrator.isRunning() && wrapped.__originalEntityData && prop.owner) {
-                            wrapped.__originalEntityData[prop.name] = Utils_1.Utils.getPrimaryKeyValues(val, prop.targetMeta.primaryKeys, true);
+                            wrapped.__originalEntityData[prop.name] = Utils_1.Utils.getPrimaryKeyValues(val, prop.targetMeta, true);
                         }
                         else {
                             wrapped.__touched = !hydrator.isRunning();

package/unit-of-work/ChangeSetComputer.js

@@ -144,7 +144,9 @@ class ChangeSetComputer {
         if (!target.isDirty() && changeSet.type !== ChangeSet_1.ChangeSetType.CREATE) {
             return;
         }
-        this.collectionUpdates.add(target);
+        if (target.isDirty()) {
+            this.collectionUpdates.add(target);
+        }
         if (prop.owner && !this.platform.usesPivotTable()) {
             changeSet.payload[prop.name] = target.getItems(false).map((item) => item.__helper.__identifier ?? item.__helper.getPrimaryKey());
         }

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

@@ -4,6 +4,7 @@ import { type EntityFactory, type EntityValidator } from '../entity';
 import { type ChangeSet } from './ChangeSet';
 import { type Configuration } from '../utils';
 import type { DriverMethodOptions, IDatabaseDriver } from '../drivers';
+import type { EntityManager } from '../EntityManager';
 export declare class ChangeSetPersister {
     private readonly driver;
     private readonly metadata;
@@ -11,10 +12,11 @@ export declare class ChangeSetPersister {
     private readonly factory;
     private readonly validator;
     private readonly config;
+    private readonly em;
     private readonly platform;
     private readonly comparator;
     private readonly usesReturningStatement;
-    constructor(driver: IDatabaseDriver, metadata: MetadataStorage, hydrator: IHydrator, factory: EntityFactory, validator: EntityValidator, config: Configuration);
+    constructor(driver: IDatabaseDriver, metadata: MetadataStorage, hydrator: IHydrator, factory: EntityFactory, validator: EntityValidator, config: Configuration, em: EntityManager);
     executeInserts<T extends object>(changeSets: ChangeSet<T>[], options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;
     executeUpdates<T extends object>(changeSets: ChangeSet<T>[], batched: boolean, options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;
     executeDeletes<T extends object>(changeSets: ChangeSet<T>[], options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;
@@ -22,7 +24,7 @@ export declare class ChangeSetPersister {
     private processProperties;
     private persistNewEntity;
     private persistNewEntities;
-    private propagateSchemaFromMetadata;
+    private prepareOptions;
     private persistNewEntitiesBatch;
     private persistManagedEntity;
     private persistManagedEntities;

package/unit-of-work/ChangeSetPersister.js

@@ -13,16 +13,18 @@ class ChangeSetPersister {
     factory;
     validator;
     config;
+    em;
     platform;
     comparator;
     usesReturningStatement;
-    constructor(driver, metadata, hydrator, factory, validator, config) {
+    constructor(driver, metadata, hydrator, factory, validator, config, em) {
         this.driver = driver;
         this.metadata = metadata;
         this.hydrator = hydrator;
         this.factory = factory;
         this.validator = validator;
         this.config = config;
+        this.em = em;
         this.platform = this.driver.getPlatform();
         this.comparator = this.config.getComparator(this.metadata);
         this.usesReturningStatement = this.platform.usesReturningStatement() || this.platform.usesOutputStatement();
@@ -63,7 +65,7 @@ class ChangeSetPersister {
         for (let i = 0; i < changeSets.length; i += size) {
             const chunk = changeSets.slice(i, i + size);
             const pks = chunk.map(cs => cs.getPrimaryKey());
-            options = this.propagateSchemaFromMetadata(meta, options);
+            options = this.prepareOptions(meta, options);
             await this.driver.nativeDelete(meta.root.className, { [pk]: { $in: pks } }, options);
         }
     }
@@ -91,7 +93,7 @@ class ChangeSetPersister {
     }
     async persistNewEntity(meta, changeSet, options) {
         const wrapped = (0, entity_1.helper)(changeSet.entity);
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(meta, options, {
             convertCustomTypes: false,
         });
         const res = await this.driver.nativeInsertMany(meta.className, [changeSet.payload], options);
@@ -117,15 +119,17 @@ class ChangeSetPersister {
             }
         }
     }
-    propagateSchemaFromMetadata(meta, options, additionalOptions) {
+    prepareOptions(meta, options, additionalOptions) {
+        const loggerContext = utils_1.Utils.merge({ id: this.em._id }, this.em.getLoggerContext({ disableContextResolution: true }));
         return {
             ...options,
             ...additionalOptions,
             schema: options?.schema ?? meta.schema,
+            loggerContext,
         };
     }
     async persistNewEntitiesBatch(meta, changeSets, options) {
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(meta, options, {
             convertCustomTypes: false,
             processCollections: false,
         });
@@ -176,7 +180,7 @@ class ChangeSetPersister {
     }
     async persistManagedEntitiesBatch(meta, changeSets, options) {
         await this.checkOptimisticLocks(meta, changeSets, options);
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(meta, options, {
             convertCustomTypes: false,
             processCollections: false,
         });
@@ -236,7 +240,7 @@ class ChangeSetPersister {
     }
     async updateEntity(meta, changeSet, options) {
         const cond = changeSet.getPrimaryKey(true);
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(meta, options, {
             convertCustomTypes: false,
         });
         if (meta.concurrencyCheckKeys.size === 0 && (!meta.versionProperty || changeSet.entity[meta.versionProperty] == null)) {
@@ -263,7 +267,7 @@ class ChangeSetPersister {
             return cond;
         });
         const primaryKeys = meta.primaryKeys.concat(...meta.concurrencyCheckKeys);
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(meta, options, {
             fields: primaryKeys,
         });
         const res = await this.driver.find(meta.root.className, { $or }, options);
@@ -322,12 +326,12 @@ class ChangeSetPersister {
             }
             return val;
         });
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(meta, options, {
             fields: utils_1.Utils.unique(reloadProps.map(prop => prop.name)),
         });
         const data = await this.driver.find(meta.className, { [pk]: { $in: pks } }, options);
         const map = new Map();
-        data.forEach(item => map.set(utils_1.Utils.getCompositeKeyHash(item, meta, true, this.platform, true), item));
+        data.forEach(item => map.set(utils_1.Utils.getCompositeKeyHash(item, meta, false, this.platform, true), item));
         for (const changeSet of changeSets) {
             const data = map.get((0, entity_1.helper)(changeSet.entity).getSerializedPrimaryKey());
             this.hydrator.hydrate(changeSet.entity, meta, data, this.factory, 'full', false, true);

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

@@ -38,7 +38,7 @@ export declare class UnitOfWork {
     /**
      * Returns entity from the identity map. For composite keys, you need to pass an array of PKs in the same order as they are defined in `meta.primaryKeys`.
      */
-    getById<T extends object>(entityName: string, id: Primary<T> | Primary<T>[], schema?: string): T | undefined;
+    getById<T extends object>(entityName: string, id: Primary<T> | Primary<T>[], schema?: string, convertCustomTypes?: boolean): T | undefined;
     tryGetById<T extends object>(entityName: string, where: FilterQuery<T>, schema?: string, strict?: boolean): T | null;
     /**
      * Returns map of all managed entities.
@@ -102,6 +102,7 @@ export declare class UnitOfWork {
     private commitDeleteChangeSets;
     private commitExtraUpdates;
     private commitCollectionUpdates;
+    private filterCollectionUpdates;
     /**
      * Orders change sets so FK constrains are maintained, ensures stable order (needed for node < 11)
      */

package/unit-of-work/UnitOfWork.js

@@ -42,7 +42,7 @@ class UnitOfWork {
         this.eventManager = this.em.getEventManager();
         this.comparator = this.em.getComparator();
         this.changeSetComputer = new ChangeSetComputer_1.ChangeSetComputer(this.em.getValidator(), this.collectionUpdates, this.metadata, this.platform, this.em.config, this.em);
-        this.changeSetPersister = new ChangeSetPersister_1.ChangeSetPersister(this.em.getDriver(), this.metadata, this.em.config.getHydrator(this.metadata), this.em.getEntityFactory(), this.em.getValidator(), this.em.config);
+        this.changeSetPersister = new ChangeSetPersister_1.ChangeSetPersister(this.em.getDriver(), this.metadata, this.em.config.getHydrator(this.metadata), this.em.getEntityFactory(), this.em.getValidator(), this.em.config, this.em);
     }
     merge(entity, visited) {
         const wrapped = (0, entity_1.helper)(entity);
@@ -88,7 +88,7 @@ class UnitOfWork {
                 }
                 wrapped.__loadedProperties.add(key);
                 if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils_1.Utils.isPlainObject(data[prop.name])) {
-                    data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta.primaryKeys, true);
+                    data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
                 }
                 else if (prop.kind === enums_1.ReferenceKind.EMBEDDED && !prop.object && Utils_1.Utils.isPlainObject(data[prop.name])) {
                     for (const p of prop.targetMeta.props) {
@@ -96,7 +96,7 @@ class UnitOfWork {
                         const prefix = prop.prefix === false ? '' : prop.prefix === true ? prop.name + '_' : prop.prefix;
                         data[prefix + p.name] = data[prop.name][p.name];
                     }
-                    data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta.primaryKeys, true);
+                    data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
                 }
                 if (forceUndefined) {
                     if (data[key] === null) {
@@ -124,7 +124,7 @@ class UnitOfWork {
     /**
      * Returns entity from the identity map. For composite keys, you need to pass an array of PKs in the same order as they are defined in `meta.primaryKeys`.
      */
-    getById(entityName, id, schema) {
+    getById(entityName, id, schema, convertCustomTypes) {
         if (id == null || (Array.isArray(id) && id.length === 0)) {
             return undefined;
         }
@@ -134,7 +134,16 @@ class UnitOfWork {
             hash = '' + id;
         }
         else {
-            const keys = Array.isArray(id) ? Utils_1.Utils.flatten(id) : [id];
+            let keys = Array.isArray(id) ? Utils_1.Utils.flatten(id) : [id];
+            keys = meta.getPrimaryProps(true).map((p, i) => {
+                if (!convertCustomTypes && p.customType) {
+                    return p.customType.convertToDatabaseValue(keys[i], this.platform, {
+                        key: p.name,
+                        mode: 'hydration',
+                    });
+                }
+                return keys[i];
+            });
             hash = Utils_1.Utils.getPrimaryKeyHash(keys);
         }
         schema ??= meta.schema ?? this.em.config.getSchema();
@@ -303,6 +312,7 @@ class UnitOfWork {
                 cs.entity.__helper.__processing = true;
             }
             await this.eventManager.dispatchEvent(enums_1.EventType.onFlush, { em: this.em, uow: this });
+            this.filterCollectionUpdates();
             // nothing to do, do not start transaction
             if (this.changeSets.size === 0 && this.collectionUpdates.size === 0 && this.extraUpdates.size === 0) {
                 return void await this.eventManager.dispatchEvent(enums_1.EventType.afterFlush, { em: this.em, uow: this });
@@ -311,9 +321,11 @@ class UnitOfWork {
             const platform = this.em.getPlatform();
             const runInTransaction = !this.em.isInTransaction() && platform.supportsTransactions() && this.em.config.get('implicitTransactions');
             if (runInTransaction) {
+                const loggerContext = Utils_1.Utils.merge({ id: this.em._id }, this.em.getLoggerContext({ disableContextResolution: true }));
                 await this.em.getConnection('write').transactional(trx => this.persistToDatabase(groups, trx), {
                     ctx: oldTx,
                     eventBroadcaster: new events_1.TransactionEventBroadcaster(this.em, this),
+                    loggerContext,
                 });
             }
             else {
@@ -886,23 +898,34 @@ class UnitOfWork {
         }
     }
     async commitCollectionUpdates(ctx) {
-        const collectionUpdates = [];
+        this.filterCollectionUpdates();
+        const loggerContext = Utils_1.Utils.merge({ id: this.em._id }, this.em.getLoggerContext({ disableContextResolution: true }));
+        await this.em.getDriver().syncCollections(this.collectionUpdates, {
+            ctx,
+            schema: this.em.schema,
+            loggerContext,
+        });
+        for (const coll of this.collectionUpdates) {
+            coll.takeSnapshot();
+        }
+    }
+    filterCollectionUpdates() {
         for (const coll of this.collectionUpdates) {
+            let skip = true;
             if (coll.property.owner || coll.getItems(false).filter(item => !item.__helper.__initialized).length > 0) {
                 if (this.platform.usesPivotTable()) {
-                    collectionUpdates.push(coll);
+                    skip = false;
                 }
             }
             else if (coll.property.kind === enums_1.ReferenceKind.ONE_TO_MANY && coll.getSnapshot() === undefined) {
-                collectionUpdates.push(coll);
+                skip = false;
             }
             else if (coll.property.kind === enums_1.ReferenceKind.MANY_TO_MANY && !coll.property.owner) {
-                collectionUpdates.push(coll);
+                skip = false;
+            }
+            if (skip) {
+                this.collectionUpdates.delete(coll);
             }
-        }
-        await this.em.getDriver().syncCollections(collectionUpdates, { ctx, schema: this.em.schema });
-        for (const coll of this.collectionUpdates) {
-            coll.takeSnapshot();
         }
     }
     /**

package/utils/Configuration.d.ts

@@ -77,6 +77,7 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
         upsertManaged: true;
         forceEntityConstructor: false;
         forceUndefined: false;
+        processOnCreateHooksEarly: false;
         ensureDatabase: true;
         ensureIndexes: false;
         batchSize: number;
@@ -345,6 +346,11 @@ export interface MikroORMOptions<D extends IDatabaseDriver = IDatabaseDriver, EM
     upsertManaged: boolean;
     forceEntityConstructor: boolean | (Constructor<AnyEntity> | string)[];
     forceUndefined: boolean;
+    /**
+     * Property `onCreate` hooks are normally executed during `flush` operation.
+     * With this option, they will be processed early inside `em.create()` method.
+     */
+    processOnCreateHooksEarly: boolean;
     forceUtcTimezone?: boolean;
     timezone?: string;
     ensureDatabase: boolean | EnsureDatabaseOptions;
@@ -353,7 +359,7 @@ export interface MikroORMOptions<D extends IDatabaseDriver = IDatabaseDriver, EM
     useBatchUpdates?: boolean;
     batchSize: number;
     hydrator: HydratorConstructor;
-    loadStrategy: LoadStrategy | 'select-in' | 'joined';
+    loadStrategy: LoadStrategy | `${LoadStrategy}`;
     dataloader: DataloaderType | boolean;
     populateWhere?: PopulateHint | `${PopulateHint}`;
     flushMode: FlushMode | 'commit' | 'auto' | 'always';

package/utils/Configuration.js

@@ -71,6 +71,7 @@ class Configuration {
         upsertManaged: true,
         forceEntityConstructor: false,
         forceUndefined: false,
+        processOnCreateHooksEarly: false,
         ensureDatabase: true,
         ensureIndexes: false,
         batchSize: 300,

package/utils/ConfigurationLoader.js

@@ -213,7 +213,7 @@ class ConfigurationLoader {
         const baseDir = options instanceof Configuration_1.Configuration ? options.get('baseDir') : options?.baseDir;
         const path = process.env.MIKRO_ORM_ENV ?? ((baseDir ?? process.cwd()) + '/.env');
         const env = {};
-        dotenv_1.default.config({ path, processEnv: env });
+        dotenv_1.default.config({ path, processEnv: env, quiet: true });
         // only propagate known env vars
         for (const key of Object.keys(env)) {
             if (key.startsWith('MIKRO_ORM_')) {
@@ -347,7 +347,7 @@ class ConfigurationLoader {
     // inspired by https://github.com/facebook/docusaurus/pull/3386
     static checkPackageVersion() {
         const coreVersion = Utils_1.Utils.getORMVersion();
-        if (process.env.MIKRO_ORM_ALLOW_VERSION_MISMATCH) {
+        if (process.env.MIKRO_ORM_ALLOW_VERSION_MISMATCH || coreVersion === 'N/A') {
             return coreVersion;
         }
         const deps = this.getORMPackages();

package/utils/Cursor.js

@@ -110,6 +110,9 @@ class Cursor {
             if (Utils_1.Utils.isEntity(value, true)) {
                 value = (0, wrap_1.helper)(value).getPrimaryKey();
             }
+            if (Utils_1.Utils.isScalarReference(value)) {
+                value = value.unwrap();
+            }
             if (object) {
                 return ({ [prop]: value });
             }

package/utils/EntityComparator.d.ts

@@ -1,6 +1,8 @@
 import type { EntityData, EntityDictionary, EntityMetadata, EntityProperty, IMetadataStorage } from '../typings';
 import type { Platform } from '../platforms';
-type Comparator<T> = (a: T, b: T) => EntityData<T>;
+type Comparator<T> = (a: T, b: T, options?: {
+    includeInverseSides?: boolean;
+}) => EntityData<T>;
 type ResultMapper<T> = (result: EntityData<T>) => EntityData<T> | null;
 type SnapshotGenerator<T> = (entity: T) => EntityData<T>;
 type CompositeKeyPart = string | CompositeKeyPart[];
@@ -18,7 +20,9 @@ export declare class EntityComparator {
     /**
      * Computes difference between two entities.
      */
-    diffEntities<T>(entityName: string, a: EntityData<T>, b: EntityData<T>): EntityData<T>;
+    diffEntities<T>(entityName: string, a: EntityData<T>, b: EntityData<T>, options?: {
+        includeInverseSides?: boolean;
+    }): EntityData<T>;
     matching<T>(entityName: string, a: EntityData<T>, b: EntityData<T>): boolean;
     /**
      * Removes ORM specific code from entities and prepares it for serializing. Used before change set computation.

package/utils/EntityComparator.js

@@ -23,9 +23,9 @@ class EntityComparator {
     /**
      * Computes difference between two entities.
      */
-    diffEntities(entityName, a, b) {
+    diffEntities(entityName, a, b, options) {
         const comparator = this.getEntityComparator(entityName);
-        return Utils_1.Utils.callCompiledFunction(comparator, a, b);
+        return Utils_1.Utils.callCompiledFunction(comparator, a, b, options);
     }
     matching(entityName, a, b) {
         const diff = this.diffEntities(entityName, a, b);
@@ -158,6 +158,7 @@ class EntityComparator {
         const lines = [];
         const context = new Map();
         context.set('getCompositeKeyValue', (val) => Utils_1.Utils.flatten(Utils_1.Utils.getCompositeKeyValue(val, meta, 'convertToDatabaseValue', this.platform)));
+        context.set('getPrimaryKeyHash', (val) => Utils_1.Utils.getPrimaryKeyHash(Utils_1.Utils.asArray(val)));
         if (meta.primaryKeys.length > 1) {
             lines.push(`  const pks = entity.__helper.__pk ? getCompositeKeyValue(entity.__helper.__pk) : [`);
             meta.primaryKeys.forEach(pk => {
@@ -173,14 +174,23 @@ class EntityComparator {
         }
         else {
             const pk = meta.primaryKeys[0];
-            if (meta.properties[pk].kind !== enums_1.ReferenceKind.SCALAR) {
+            const prop = meta.properties[pk];
+            if (prop.kind !== enums_1.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();`);
             }
             const serializedPrimaryKey = meta.props.find(p => p.serializedPrimaryKey);
             if (serializedPrimaryKey) {
                 lines.push(`  return '' + entity.${serializedPrimaryKey.name};`);
             }
-            lines.push(`  return '' + entity.${meta.primaryKeys[0]};`);
+            else if (prop.customType) {
+                const convertorKey = this.registerCustomType(meta.properties[pk], context);
+                const idx = this.tmpIndex++;
+                lines.push(`  const val_${idx} = convertToDatabaseValue_${convertorKey}(entity${this.wrap(pk)});`);
+                lines.push(`  return getPrimaryKeyHash(val_${idx});`);
+            }
+            else {
+                lines.push(`  return '' + entity${this.wrap(pk)};`);
+            }
         }
         const code = `// compiled pk serializer for entity ${meta.className}\n`
             + `return function(entity) {\n${lines.join('\n')}\n}`;
@@ -534,11 +544,22 @@ class EntityComparator {
         context.set('compareBuffers', Utils_1.compareBuffers);
         context.set('compareObjects', Utils_1.compareObjects);
         context.set('equals', Utils_1.equals);
-        meta.comparableProps.forEach(prop => {
-            lines.push(this.getPropertyComparator(prop, context));
-        });
+        for (const prop of meta.comparableProps) {
+            // skip properties that are not hydrated
+            if (prop.hydrate !== false) {
+                lines.push(this.getPropertyComparator(prop, context));
+            }
+        }
+        // also compare 1:1 inverse sides, important for `factory.mergeData`
+        lines.push(`if (options?.includeInverseSides) {`);
+        for (const prop of meta.bidirectionalRelations) {
+            if (prop.kind === enums_1.ReferenceKind.ONE_TO_ONE && !prop.owner && prop.hydrate !== false) {
+                lines.push(this.getPropertyComparator(prop, context));
+            }
+        }
+        lines.push(`}`);
         const code = `// compiled comparator for entity ${meta.className}\n`
-            + `return function(last, current) {\n  const diff = {};\n${lines.join('\n')}\n  return diff;\n}`;
+            + `return function(last, current, options) {\n  const diff = {};\n${lines.join('\n')}\n  return diff;\n}`;
         const comparator = Utils_1.Utils.createFunction(context, code);
         this.comparators.set(entityName, comparator);
         return comparator;

package/utils/QueryHelper.d.ts

@@ -1,10 +1,16 @@
 import type { Dictionary, EntityMetadata, EntityProperty, FilterDef, FilterQuery } from '../typings';
 import type { Platform } from '../platforms';
 import type { MetadataStorage } from '../metadata/MetadataStorage';
+/** @internal */
 export declare class QueryHelper {
     static readonly SUPPORTED_OPERATORS: string[];
     static processParams(params: unknown): any;
     static processObjectParams<T extends object>(params?: T): T;
+    /**
+     * converts `{ account: { $or: [ [Object], [Object] ] } }`
+     * to `{ $or: [ { account: [Object] }, { account: [Object] } ] }`
+     */
+    static liftGroupOperators<T extends object>(where: Dictionary, meta: EntityMetadata<T>, metadata: MetadataStorage, key?: string): string | undefined;
     static inlinePrimaryKeyObjects<T extends object>(where: Dictionary, meta: EntityMetadata<T>, metadata: MetadataStorage, key?: string): boolean;
     static processWhere<T extends object>(options: ProcessWhereOptions<T>): FilterQuery<T>;
     static getActiveFilters(entityName: string, options: Dictionary<boolean | Dictionary> | string[] | boolean, filters: Dictionary<FilterDef>): FilterDef[];

package/utils/QueryHelper.js

@@ -7,6 +7,7 @@ const enums_1 = require("../enums");
 const JsonType_1 = require("../types/JsonType");
 const wrap_1 = require("../entity/wrap");
 const RawQueryFragment_1 = require("./RawQueryFragment");
+/** @internal */
 class QueryHelper {
     static SUPPORTED_OPERATORS = ['>', '<', '<=', '>=', '!', '!='];
     static processParams(params) {
@@ -36,11 +37,52 @@ class QueryHelper {
         });
         return params;
     }
+    /**
+     * converts `{ account: { $or: [ [Object], [Object] ] } }`
+     * to `{ $or: [ { account: [Object] }, { account: [Object] } ] }`
+     */
+    static liftGroupOperators(where, meta, metadata, key) {
+        if (!Utils_1.Utils.isPlainObject(where)) {
+            return undefined;
+        }
+        const keys = Object.keys(where);
+        const groupOperator = keys.find(k => {
+            return Utils_1.Utils.isGroupOperator(k) && Array.isArray(where[k]) && where[k].every(cond => {
+                return Utils_1.Utils.isPlainObject(cond) && Object.keys(cond).every(k2 => {
+                    if (Utils_1.Utils.isOperator(k2, false)) {
+                        if (k2 === '$not') {
+                            return Object.keys(cond[k2]).every(k3 => meta.primaryKeys.includes(k3));
+                        }
+                        return true;
+                    }
+                    return meta.primaryKeys.includes(k2);
+                });
+            });
+        });
+        if (groupOperator) {
+            return groupOperator;
+        }
+        for (const k of keys) {
+            const value = where[k];
+            const prop = meta.properties[k];
+            if (!prop || ![enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+                continue;
+            }
+            const op = this.liftGroupOperators(value, prop.targetMeta, metadata, k);
+            if (op) {
+                delete where[k];
+                where[op] = value[op].map((v) => {
+                    return { [k]: v };
+                });
+            }
+        }
+        return undefined;
+    }
     static inlinePrimaryKeyObjects(where, meta, metadata, key) {
         if (Array.isArray(where)) {
             where.forEach((item, i) => {
                 if (this.inlinePrimaryKeyObjects(item, meta, metadata, key)) {
-                    where[i] = Utils_1.Utils.getPrimaryKeyValues(item, meta.primaryKeys, false);
+                    where[i] = Utils_1.Utils.getPrimaryKeyValues(item, meta, false);
                 }
             });
         }
@@ -50,7 +92,7 @@ class QueryHelper {
         if (meta.primaryKeys.every(pk => pk in where) && Utils_1.Utils.getObjectKeysSize(where) === meta.primaryKeys.length) {
             return !!key && !enums_1.GroupOperator[key] && key !== '$not' && Object.keys(where).every(k => !Utils_1.Utils.isPlainObject(where[k]) || Object.keys(where[k]).every(v => {
                 if (Utils_1.Utils.isOperator(v, false)) {
-                    return false;
+                    return true;
                 }
                 if (meta.properties[k].primary && [enums_1.ReferenceKind.ONE_TO_ONE, enums_1.ReferenceKind.MANY_TO_ONE].includes(meta.properties[k].kind)) {
                     return this.inlinePrimaryKeyObjects(where[k], meta.properties[k].targetMeta, metadata, v);
@@ -61,7 +103,7 @@ class QueryHelper {
         Object.keys(where).forEach(k => {
             const meta2 = metadata.find(meta.properties[k]?.type) || meta;
             if (this.inlinePrimaryKeyObjects(where[k], meta2, metadata, k)) {
-                where[k] = Utils_1.Utils.getPrimaryKeyValues(where[k], meta2.primaryKeys, true);
+                where[k] = Utils_1.Utils.getPrimaryKeyValues(where[k], meta2, true);
             }
         });
         return false;
@@ -72,6 +114,7 @@ class QueryHelper {
         const meta = metadata.find(entityName);
         // inline PK-only objects in M:N queries, so we don't join the target entity when not needed
         if (meta && root) {
+            QueryHelper.liftGroupOperators(where, meta, metadata);
             QueryHelper.inlinePrimaryKeyObjects(where, meta, metadata);
         }
         if (options.platform.getConfig().get('ignoreUndefinedInQuery') && where && typeof where === 'object') {
@@ -121,7 +164,7 @@ class QueryHelper {
                 value = QueryHelper.processCustomType(prop, value, platform, undefined, true);
             }
             const isJsonProperty = prop?.customType instanceof JsonType_1.JsonType && Utils_1.Utils.isPlainObject(value) && !platform.isRaw(value) && Object.keys(value)[0] !== '$eq';
-            if (isJsonProperty) {
+            if (isJsonProperty && prop?.kind !== enums_1.ReferenceKind.EMBEDDED) {
                 return this.processJsonCondition(o, value, [prop.fieldNames[0]], platform, aliased);
             }
             if (Array.isArray(value) && !Utils_1.Utils.isOperator(key) && !QueryHelper.isSupportedOperator(key) && !key.includes('?') && options.type !== 'orderBy') {

package/utils/RawQueryFragment.d.ts

@@ -70,6 +70,24 @@ export declare const ALIAS_REPLACEMENT_RE = "\\[::alias::\\]";
  * ```ts
  * @Filter({ name: 'long', cond: () => ({ [raw('length(perex)')]: { $gt: 10000 } }) })
  * ```
+ *
+ * The `raw` helper can be used within indexes and uniques to write database-agnostic SQL expressions. In that case, you can use `'??'` to tag your database identifiers (table name, column names, index name, ...) inside your expression, and pass those identifiers as a second parameter to the `raw` helper. Internally, those will automatically be quoted according to the database in use:
+ *
+ * ```ts
+ * // On postgres, will produce: create index "index custom_idx_on_name" on "library.author" ("country")
+ * // On mysql, will produce: create index `index custom_idx_on_name` on `library.author` (`country`)
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => raw(`create index ?? on ?? (??)`, ['custom_idx_on_name', table, columns.name]) })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ *
+ * You can also use the `quote` tag function to write database-agnostic SQL expressions. The end-result is the same as using the `raw` function regarding database identifiers quoting, only to have a more elegant expression syntax:
+ *
+ * ```ts
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => quote`create index ${'custom_idx_on_name'} on ${table} (${columns.name})` })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
  */
 export declare function raw<T extends object = any, R = any>(sql: EntityKey<T> | EntityKey<T>[] | AnyString | ((alias: string) => string) | RawQueryFragment, params?: readonly unknown[] | Dictionary<unknown>): R;
 /**
@@ -94,3 +112,19 @@ export declare namespace sql {
     var upper: <T extends object>(key: string | ((alias: string) => string)) => string;
 }
 export declare function createSqlFunction<T extends object, R = string>(func: string, key: string | ((alias: string) => string)): R;
+/**
+ * Tag function providing quoting of db identifiers (table name, columns names, index names, ...).
+ *
+ * Within the template literal on which the tag function is applied, all placeholders are considered to be database identifiers, and will thus be quoted as so according to the database in use.
+ *
+ * ```ts
+ * // On postgres, will produce: create index "index custom_idx_on_name" on "library.author" ("name")
+ * // On mysql, will produce: create index `index custom_idx_on_name` on `library.author` (`name`)
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => quote`create index ${'custom_idx_on_name'} on ${table} (${columns.name})` })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ */
+export declare function quote(expParts: readonly string[], ...values: (string | {
+    toString(): string;
+})[]): any;