@mikro-orm/core 6.2.10-dev.99 → 6.3.1-dev.0

package/EntityManager.js

@@ -1218,6 +1218,7 @@ class EntityManager {
             ...options,
         };
         entityName = utils_1.Utils.className(entityName);
+        await em.tryFlush(entityName, options);
         where = await em.processWhere(entityName, where, options, 'read');
         options.populate = await em.preparePopulate(entityName, options);
         em.validator.validateParams(where);

package/MikroORM.js

@@ -43,7 +43,7 @@ class MikroORM {
         orm.config.set('allowGlobalContext', true);
         await orm.discoverEntities();
         orm.config.set('allowGlobalContext', allowGlobalContext);
-        orm.driver.getPlatform().lookupExtensions(orm);
+        orm.driver.getPlatform().init(orm);
         if (orm.config.get('connect')) {
             await orm.connect();
         }
@@ -79,7 +79,7 @@ class MikroORM {
         orm.config.set('allowGlobalContext', true);
         orm.discoverEntitiesSync();
         orm.config.set('allowGlobalContext', allowGlobalContext);
-        orm.driver.getPlatform().lookupExtensions(orm);
+        orm.driver.getPlatform().init(orm);
         for (const extension of orm.config.get('extensions')) {
             extension.register(orm);
         }

package/drivers/IDatabaseDriver.d.ts

@@ -157,6 +157,7 @@ export interface CountOptions<T extends object, P extends string = never> {
     populate?: Populate<T, P>;
     ctx?: Transaction;
     connectionType?: ConnectionType;
+    flushMode?: FlushMode | `${FlushMode}`;
     /** sql only */
     indexHint?: string;
     /** sql only */

package/hydration/ObjectHydrator.js

@@ -226,12 +226,27 @@ class ObjectHydrator extends Hydrator_1.Hydrator {
                 ret.push(`    };`);
             }
             if (prop.targetMeta?.polymorphs) {
-                prop.targetMeta.polymorphs.forEach(meta => {
+                prop.targetMeta.polymorphs.forEach(childMeta => {
                     const childProp = prop.embeddedProps[prop.targetMeta.discriminatorColumn];
                     const childDataKey = prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
                     // weak comparison as we can have numbers that might have been converted to strings due to being object keys
-                    ret.push(`    if (data${childDataKey} == '${meta.discriminatorValue}' && entity${entityKey} == null) {`);
-                    ret.push(`      entity${entityKey} = factory.createEmbeddable('${meta.className}', embeddedData, { newEntity, convertCustomTypes });`);
+                    ret.push(`    if (data${childDataKey} == '${childMeta.discriminatorValue}') {`);
+                    ret.push(`      if (entity${entityKey} == null) {`);
+                    ret.push(`        entity${entityKey} = factory.createEmbeddable('${childMeta.className}', embeddedData, { newEntity, convertCustomTypes });`);
+                    ret.push(`      }`);
+                    meta.props
+                        .filter(p => p.embedded?.[0] === prop.name)
+                        .forEach(childProp => {
+                        const childDataKey = prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
+                        const prop2 = childMeta.properties[childProp.embedded[1]];
+                        const prop3 = {
+                            ...prop2,
+                            name: childProp.name,
+                            embedded: childProp.embedded,
+                        };
+                        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                        ret.push(...hydrateProperty(prop3, childProp.object, [...path, childProp.embedded[1]], childDataKey).map(l => '    ' + l));
+                    });
                     ret.push(`    }`);
                 });
             }
@@ -239,14 +254,14 @@ class ObjectHydrator extends Hydrator_1.Hydrator {
                 ret.push(`    if (entity${entityKey} == null) {`);
                 ret.push(`      entity${entityKey} = factory.createEmbeddable('${prop.targetMeta.className}', embeddedData, { newEntity, convertCustomTypes });`);
                 ret.push(`    }`);
+                meta.props
+                    .filter(p => p.embedded?.[0] === prop.name)
+                    .forEach(childProp => {
+                    const childDataKey = prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
+                    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                    ret.push(...hydrateProperty(childProp, prop.object, [...path, childProp.embedded[1]], childDataKey).map(l => '  ' + l));
+                });
             }
-            meta.props
-                .filter(p => p.embedded?.[0] === prop.name)
-                .forEach(childProp => {
-                const childDataKey = prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
-                // eslint-disable-next-line @typescript-eslint/no-use-before-define
-                ret.push(...hydrateProperty(childProp, prop.object, [...path, childProp.embedded[1]], childDataKey).map(l => '  ' + l));
-            });
             /* istanbul ignore next */
             const nullVal = this.config.get('forceUndefined') ? 'undefined' : 'null';
             if (prop.object) {
@@ -316,19 +331,14 @@ class ObjectHydrator extends Hydrator_1.Hydrator {
         const meta = this.metadata.get(prop.type);
         const lines = [];
         lines.push(`  const createCollectionItem_${this.safeKey(prop.name)} = (value, entity) => {`);
-        const prop2 = prop.targetMeta?.properties[prop.mappedBy];
-        if (prop2?.primary) {
+        const prop2 = prop.targetMeta.properties[prop.mappedBy];
+        if (prop.kind === enums_1.ReferenceKind.ONE_TO_MANY && prop2.primary) {
             lines.push(`    if (typeof value === 'object' && value?.['${prop2.name}'] == null) {`);
             lines.push(`      value = { ...value, ['${prop2.name}']: Reference.wrapReference(entity, { ref: ${prop2.ref} }) };`);
             lines.push(`    }`);
         }
         lines.push(`    if (isPrimaryKey(value, ${meta.compositePK})) return factory.createReference('${prop.type}', value, { convertCustomTypes, schema, merge: true });`);
         lines.push(`    if (value && value.__entity) return value;`);
-        if (prop2 && !prop2.primary) {
-            lines.push(`    if (typeof value === 'object' && value?.['${prop2.name}'] == null) {`);
-            lines.push(`      value = { ...value, ['${prop2.name}']: Reference.wrapReference(entity, { ref: ${prop2.ref} }) };`);
-            lines.push(`    }`);
-        }
         lines.push(`    return factory.create('${prop.type}', value, { newEntity, convertCustomTypes, schema, merge: true });`);
         lines.push(`  }`);
         return lines;

package/metadata/EntitySchema.d.ts

@@ -8,6 +8,11 @@ type TypeDef<Target> = {
 } | {
     entity: string | (() => string | EntityName<Target>);
 };
+type EmbeddedTypeDef<Target> = {
+    type: TypeType;
+} | {
+    entity: string | (() => string | EntityName<Target> | EntityName<Target>[]);
+};
 export type EntitySchemaProperty<Target, Owner> = ({
     kind: ReferenceKind.MANY_TO_ONE | 'm:1';
 } & TypeDef<Target> & ManyToOneOptions<Owner, Target>) | ({
@@ -18,7 +23,7 @@ export type EntitySchemaProperty<Target, Owner> = ({
     kind: ReferenceKind.MANY_TO_MANY | 'm:n';
 } & TypeDef<Target> & ManyToManyOptions<Owner, Target>) | ({
     kind: ReferenceKind.EMBEDDED | 'embedded';
-} & TypeDef<Target> & EmbeddedOptions & PropertyOptions<Owner>) | ({
+} & EmbeddedTypeDef<Target> & EmbeddedOptions & PropertyOptions<Owner>) | ({
     enum: true;
 } & EnumOptions<Owner>) | (TypeDef<Target> & PropertyOptions<Owner>);
 type OmitBaseProps<Entity, Base> = IsNever<Base> extends true ? Entity : Omit<Entity, keyof Base>;

package/metadata/MetadataDiscovery.js

@@ -721,6 +721,15 @@ class MetadataDiscovery {
         if (!embeddable && polymorphs.length > 0) {
             const properties = {};
             let discriminatorColumn;
+            const inlineProperties = (meta) => {
+                Object.values(meta.properties).forEach(prop => {
+                    if (properties[prop.name] && properties[prop.name].type !== prop.type) {
+                        properties[prop.name].type = `${properties[prop.name].type} | ${prop.type}`;
+                        return properties[prop.name];
+                    }
+                    return properties[prop.name] = prop;
+                });
+            };
             const processExtensions = (meta) => {
                 const parent = this.discovered.find(m => {
                     return meta.extends && Utils_1.Utils.className(meta.extends) === m.className;
@@ -729,11 +738,11 @@ class MetadataDiscovery {
                     return;
                 }
                 discriminatorColumn ??= parent.discriminatorColumn;
-                Object.values(parent.properties).forEach(prop => properties[prop.name] = prop);
+                inlineProperties(parent);
                 processExtensions(parent);
             };
             polymorphs.forEach(meta => {
-                Object.values(meta.properties).forEach(prop => properties[prop.name] = prop);
+                inlineProperties(meta);
                 processExtensions(meta);
             });
             const name = polymorphs.map(t => t.className).sort().join(' | ');
@@ -873,13 +882,21 @@ class MetadataDiscovery {
         if (meta.root === meta) {
             return;
         }
+        let i = 1;
         Object.values(meta.properties).forEach(prop => {
-            const exists = meta.root.properties[prop.name];
+            if (meta.root.properties[prop.name] && meta.root.properties[prop.name].type !== prop.type) {
+                const name = prop.name;
+                this.initFieldName(prop, prop.object);
+                prop.name = name + '_' + (i++);
+                meta.root.addProperty(prop);
+                prop.nullable = true;
+                prop.name = name;
+                prop.hydrate = false;
+                return;
+            }
             prop = Utils_1.Utils.copy(prop, false);
             prop.nullable = true;
-            if (!exists) {
-                prop.inherited = true;
-            }
+            prop.inherited = true;
             meta.root.addProperty(prop);
         });
         meta.collection = meta.root.collection;
@@ -964,7 +981,7 @@ class MetadataDiscovery {
             const entity1 = new meta.class();
             const entity2 = new meta.class();
             // we compare the two values by reference, this will discard things like `new Date()` or `Date.now()`
-            if (this.config.get('discovery').inferDefaultValues && prop.default === undefined && entity1[prop.name] != null && entity1[prop.name] === entity2[prop.name] && entity1[prop.name] !== now) {
+            if (!meta.embeddable && this.config.get('discovery').inferDefaultValues && prop.default === undefined && entity1[prop.name] != null && entity1[prop.name] === entity2[prop.name] && entity1[prop.name] !== now) {
                 prop.default ??= entity1[prop.name];
             }
             // if the default value is null, infer nullability

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.2.10-dev.99",
+  "version": "6.3.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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -64,7 +64,7 @@
     "esprima": "4.0.1",
     "fs-extra": "11.2.0",
     "globby": "11.1.0",
-    "mikro-orm": "6.2.10-dev.99",
+    "mikro-orm": "6.3.1-dev.0",
     "reflect-metadata": "0.2.2"
   }
 }

package/platforms/Platform.d.ts

@@ -160,6 +160,8 @@ export declare abstract class Platform {
      * Allows registering extensions of the driver automatically (e.g. `SchemaGenerator` extension in SQL drivers).
      */
     lookupExtensions(orm: MikroORM): void;
+    /** @internal */
+    init(orm: MikroORM): void;
     getExtension<T>(extensionName: string, extensionKey: string, moduleName: string, em: EntityManager): T;
     getSchemaGenerator(driver: IDatabaseDriver, em?: EntityManager): ISchemaGenerator;
     processDateProperty(value: unknown): string | number | Date;

package/platforms/Platform.js

@@ -320,6 +320,10 @@ class Platform {
     lookupExtensions(orm) {
         // no extensions by default
     }
+    /** @internal */
+    init(orm) {
+        this.lookupExtensions(orm);
+    }
     getExtension(extensionName, extensionKey, moduleName, em) {
         const extension = this.config.getExtension(extensionKey);
         if (extension) {

package/serialization/EntitySerializer.js

@@ -7,7 +7,6 @@ const Utils_1 = require("../utils/Utils");
 const enums_1 = require("../enums");
 const Reference_1 = require("../entity/Reference");
 const SerializationContext_1 = require("./SerializationContext");
-const RawQueryFragment_1 = require("../utils/RawQueryFragment");
 function isVisible(meta, propName, options) {
     const prop = meta.properties[propName];
     if (options.groups && prop?.groups) {
@@ -51,12 +50,13 @@ class EntitySerializer {
         if (!visited) {
             root.visited.add(entity);
         }
-        [...keys]
-            .filter(prop => isVisible(meta, prop, options))
-            .map(prop => {
+        for (const prop of keys) {
+            if (!isVisible(meta, prop, options)) {
+                continue;
+            }
             const cycle = root.visit(meta.className, prop);
             if (cycle && visited) {
-                return [prop, undefined];
+                continue;
             }
             const val = this.processProperty(prop, entity, options);
             if (!cycle) {
@@ -65,29 +65,36 @@ class EntitySerializer {
             if (options.skipNull && Utils_1.Utils.isPlainObject(val)) {
                 Utils_1.Utils.dropUndefinedProperties(val, null);
             }
-            if (val instanceof RawQueryFragment_1.RawQueryFragment) {
+            if (Utils_1.Utils.isRawSql(val)) {
                 throw new Error(`Trying to serialize raw SQL fragment: '${val.sql}'`);
             }
-            return [prop, val];
-        })
-            .filter(([, value]) => typeof value !== 'undefined' && !(value === null && options.skipNull))
-            .forEach(([prop, value]) => ret[this.propertyName(meta, prop, wrapped.__platform)] = value);
+            const visible = typeof val !== 'undefined' && !(val === null && options.skipNull);
+            if (visible) {
+                ret[this.propertyName(meta, prop, wrapped.__platform)] = val;
+            }
+        }
         if (contextCreated) {
             root.close();
         }
         if (!wrapped.isInitialized()) {
             return ret;
         }
-        // decorated getters
-        meta.props
-            .filter(prop => prop.getter && prop.getterName === undefined && typeof entity[prop.name] !== 'undefined' && isVisible(meta, prop.name, options))
-            // @ts-ignore
-            .forEach(prop => ret[this.propertyName(meta, prop.name, wrapped.__platform)] = this.processProperty(prop.name, entity, options));
-        // decorated get methods
-        meta.props
-            .filter(prop => prop.getterName && entity[prop.getterName] instanceof Function && isVisible(meta, prop.name, options))
-            // @ts-ignore
-            .forEach(prop => ret[this.propertyName(meta, prop.name, wrapped.__platform)] = this.processProperty(prop.getterName, entity, options));
+        for (const prop of meta.getterProps) {
+            // decorated get methods
+            if (prop.getterName != null) {
+                const visible = entity[prop.getterName] instanceof Function && isVisible(meta, prop.name, options);
+                if (visible) {
+                    ret[this.propertyName(meta, prop.name, wrapped.__platform)] = this.processProperty(prop.getterName, entity, options);
+                }
+            }
+            else {
+                // decorated getters
+                const visible = typeof entity[prop.name] !== 'undefined' && isVisible(meta, prop.name, options);
+                if (visible) {
+                    ret[this.propertyName(meta, prop.name, wrapped.__platform)] = this.processProperty(prop.name, entity, options);
+                }
+            }
+        }
         return ret;
     }
     static propertyName(meta, prop, platform) {

package/serialization/EntityTransformer.js

@@ -5,7 +5,6 @@ const wrap_1 = require("../entity/wrap");
 const Utils_1 = require("../utils/Utils");
 const enums_1 = require("../enums");
 const SerializationContext_1 = require("./SerializationContext");
-const RawQueryFragment_1 = require("../utils/RawQueryFragment");
 function isVisible(meta, propName, ignoreFields = []) {
     const prop = meta.properties[propName];
     const visible = prop && !prop.hidden;
@@ -38,49 +37,61 @@ class EntityTransformer {
             Utils_1.Utils.keys(entity).forEach(prop => keys.add(prop));
         }
         const visited = root.visited.has(entity);
+        const includePrimaryKeys = wrapped.__config.get('serialization').includePrimaryKeys;
         if (!visited) {
             root.visited.add(entity);
         }
-        [...keys]
-            .filter(prop => raw ? meta.properties[prop] : isVisible(meta, prop, ignoreFields))
-            .map(prop => {
+        for (const prop of keys) {
+            const visible = raw ? meta.properties[prop] : isVisible(meta, prop, ignoreFields);
+            if (!visible) {
+                continue;
+            }
             const populated = root.isMarkedAsPopulated(meta.className, prop);
             const partiallyLoaded = root.isPartiallyLoaded(meta.className, prop);
-            const isPrimary = wrapped.__config.get('serialization').includePrimaryKeys && meta.properties[prop].primary;
+            const isPrimary = includePrimaryKeys && meta.properties[prop].primary;
             if (!partiallyLoaded && !populated && !isPrimary) {
-                return [prop, undefined];
+                continue;
             }
             const cycle = root.visit(meta.className, prop);
             if (cycle && visited) {
-                return [prop, undefined];
+                continue;
             }
             const val = EntityTransformer.processProperty(prop, entity, raw, populated);
             if (!cycle) {
                 root.leave(meta.className, prop);
             }
-            if (val instanceof RawQueryFragment_1.RawQueryFragment) {
+            if (Utils_1.Utils.isRawSql(val)) {
                 throw new Error(`Trying to serialize raw SQL fragment: '${val.sql}'`);
             }
-            return [prop, val];
-        })
-            .filter(([, value]) => typeof value !== 'undefined')
-            .forEach(([prop, value]) => ret[this.propertyName(meta, prop, wrapped.__platform, raw)] = value);
+            if (typeof val === 'undefined') {
+                continue;
+            }
+            ret[this.propertyName(meta, prop, wrapped.__platform, raw)] = val;
+        }
         if (!visited) {
             root.visited.delete(entity);
         }
         if (!wrapped.isInitialized() && wrapped.hasPrimaryKey()) {
             return ret;
         }
-        // decorated getters
-        meta.props
-            .filter(prop => prop.getter && prop.getterName === undefined && !prop.hidden && typeof entity[prop.name] !== 'undefined')
-            // @ts-ignore
-            .forEach(prop => ret[this.propertyName(meta, prop.name, wrapped.__platform, raw)] = this.processProperty(prop.name, entity, raw));
-        // decorated get methods
-        meta.props
-            .filter(prop => prop.getterName && !prop.hidden && entity[prop.getterName] instanceof Function)
-            // @ts-ignore
-            .forEach(prop => ret[this.propertyName(meta, prop.name, wrapped.__platform, raw)] = this.processProperty(prop.getterName, entity, raw));
+        for (const prop of meta.getterProps) {
+            // decorated get methods
+            if (prop.getterName != null) {
+                const visible = !prop.hidden && entity[prop.getterName] instanceof Function;
+                const populated = root.isMarkedAsPopulated(meta.className, prop.name);
+                if (visible) {
+                    ret[this.propertyName(meta, prop.name, wrapped.__platform, raw)] = this.processProperty(prop.getterName, entity, raw, populated);
+                }
+            }
+            else {
+                // decorated getters
+                const visible = !prop.hidden && typeof entity[prop.name] !== 'undefined';
+                const populated = root.isMarkedAsPopulated(meta.className, prop.name);
+                if (visible) {
+                    ret[this.propertyName(meta, prop.name, wrapped.__platform, raw)] = this.processProperty(prop.name, entity, raw, populated);
+                }
+            }
+        }
         if (contextCreated) {
             root.close();
         }

package/serialization/SerializationContext.js

@@ -45,9 +45,9 @@ class SerializationContext {
         }
     }
     close() {
-        this.entities.forEach(entity => {
+        for (const entity of this.entities) {
             delete (0, wrap_1.helper)(entity).__serializationContext.root;
-        });
+        }
     }
     /**
      * When initializing new context, we need to propagate it to the whole entity graph recursively.
@@ -55,20 +55,25 @@ class SerializationContext {
     static propagate(root, entity, isVisible) {
         root.register(entity);
         const meta = (0, wrap_1.helper)(entity).__meta;
-        const items = [];
-        Object.keys(entity)
-            .filter(key => isVisible(meta, key))
-            .forEach(key => {
-            if (Utils_1.Utils.isEntity(entity[key], true)) {
-                items.push(entity[key]);
+        for (const key of Object.keys(entity)) {
+            if (!isVisible(meta, key)) {
+                continue;
             }
-            else if (Utils_1.Utils.isCollection(entity[key])) {
-                items.push(...entity[key].getItems(false));
+            const target = entity[key];
+            if (Utils_1.Utils.isEntity(target, true)) {
+                if (!target.__helper.__serializationContext.root) {
+                    this.propagate(root, target, isVisible);
+                }
+                continue;
             }
-        });
-        items
-            .filter(item => !item.__helper.__serializationContext.root)
-            .forEach(item => this.propagate(root, item, isVisible));
+            if (Utils_1.Utils.isCollection(target)) {
+                for (const item of target.getItems(false)) {
+                    if (!item.__helper.__serializationContext.root) {
+                        this.propagate(root, item, isVisible);
+                    }
+                }
+            }
+        }
     }
     isMarkedAsPopulated(entityName, prop) {
         let populate = this.populate;

package/typings.d.ts

@@ -223,7 +223,7 @@ type ExplicitlyOptionalProps<T> = (T extends {
 type NullableKeys<T, V = null> = {
     [K in keyof T]: V extends T[K] ? K : never;
 }[keyof T];
-type ProbablyOptionalProps<T> = PrimaryProperty<T> | ExplicitlyOptionalProps<T> | NonNullable<NullableKeys<T>>;
+type ProbablyOptionalProps<T> = PrimaryProperty<T> | ExplicitlyOptionalProps<T> | NonNullable<NullableKeys<T, null | undefined>>;
 type IsOptional<T, K extends keyof T, I> = T[K] extends Collection<any, any> ? true : ExtractType<T[K]> extends I ? true : K extends ProbablyOptionalProps<T> ? true : false;
 type RequiredKeys<T, K extends keyof T, I> = IsOptional<T, K, I> extends false ? CleanKeys<T, K> : never;
 type OptionalKeys<T, K extends keyof T, I> = IsOptional<T, K, I> extends false ? never : CleanKeys<T, K>;
@@ -432,6 +432,7 @@ export interface EntityMetadata<T = any> {
     trackingProps: EntityProperty<T>[];
     hydrateProps: EntityProperty<T>[];
     uniqueProps: EntityProperty<T>[];
+    getterProps: EntityProperty<T>[];
     indexes: {
         properties: EntityKey<T> | EntityKey<T>[];
         name?: string;

package/typings.js

@@ -63,6 +63,7 @@ class EntityMetadata {
         this.relations = this.props.filter(prop => typeof prop.kind !== 'undefined' && prop.kind !== enums_1.ReferenceKind.SCALAR && prop.kind !== enums_1.ReferenceKind.EMBEDDED);
         this.bidirectionalRelations = this.relations.filter(prop => prop.mappedBy || prop.inversedBy);
         this.uniqueProps = this.props.filter(prop => prop.unique);
+        this.getterProps = this.props.filter(prop => prop.getter);
         this.comparableProps = this.props.filter(prop => EntityComparator_1.EntityComparator.isComparable(prop, this));
         this.hydrateProps = this.props.filter(prop => {
             // `prop.userDefined` is either `undefined` or `false`

package/utils/EntityComparator.js

@@ -221,11 +221,11 @@ class EntityComparator {
             // traverse all parents, mapping my field name to each parent's field name until we reach the root
             for (let i = parents.length - 1; i >= 0; i--) {
                 const parent = parents[i];
-                // look for the field name in the parent's referencedColumnNames, except for M:N without a custom pivot entity
-                //   (in that case, the field names are the referenced PK's )
-                const target = parent.kind === enums_1.ReferenceKind.MANY_TO_MANY && parent.pivotEntity === parent.pivotTable ?
-                    parent.referencedPKs : parent.referencedColumnNames;
-                const idx = target.indexOf(fieldName);
+                // skip m:n since it does not represent any column directly
+                if (parent.pivotEntity) {
+                    continue;
+                }
+                const idx = parent.referencedColumnNames.indexOf(fieldName);
                 fieldName = parent.fieldNames[idx];
             }
             return this.propName(fieldName);

package/utils/QueryHelper.js

@@ -6,6 +6,7 @@ const Utils_1 = require("./Utils");
 const enums_1 = require("../enums");
 const JsonType_1 = require("../types/JsonType");
 const wrap_1 = require("../entity/wrap");
+const RawQueryFragment_1 = require("./RawQueryFragment");
 class QueryHelper {
     static SUPPORTED_OPERATORS = ['>', '<', '<=', '>=', '!', '!='];
     static processParams(params) {
@@ -102,6 +103,10 @@ class QueryHelper {
             const prop = this.findProperty(key, options);
             const keys = prop?.joinColumns?.length ?? 0;
             const composite = keys > 1;
+            if (Array.isArray(value) && value.length === 0 && RawQueryFragment_1.RawQueryFragment.isKnownFragment(key)) {
+                o[key] = value;
+                return o;
+            }
             if (key in enums_1.GroupOperator) {
                 o[key] = value.map((sub) => QueryHelper.processWhere({ ...options, where: sub, root }));
                 return o;

package/utils/RawQueryFragment.d.ts

@@ -70,7 +70,7 @@ export declare const ALIAS_REPLACEMENT_RE = "\\[::alias::\\]";
  * @Filter({ name: 'long', cond: () => ({ [raw('length(perex)')]: { $gt: 10000 } }) })
  * ```
  */
-export declare function raw<T extends object = any, R = any>(sql: EntityKey<T> | EntityKey<T>[] | AnyString | ((alias: string) => string) | RawQueryFragment, params?: unknown[] | Dictionary<unknown>): R;
+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;
 /**
  * Alternative to the `raw()` helper allowing to use it as a tagged template function for the simple cases.
  *

package/utils/RawQueryFragment.js

@@ -147,11 +147,12 @@ function raw(sql, params) {
     }
     if (typeof params === 'object' && !Array.isArray(params)) {
         const pairs = Object.entries(params);
-        params = [];
+        const objectParams = [];
         for (const [key, value] of pairs) {
             sql = sql.replace(':' + key, '?');
-            params.push(value);
+            objectParams.push(value);
         }
+        return new RawQueryFragment(sql, objectParams);
     }
     return new RawQueryFragment(sql, params);
 }