@mikro-orm/sql 7.0.0-dev.216 → 7.0.0-dev.217

package/AbstractSqlDriver.d.ts

@@ -5,7 +5,7 @@ import { QueryBuilder } from './query/QueryBuilder.js';
 import { type NativeQueryBuilder } from './query/NativeQueryBuilder.js';
 import { QueryType } from './query/enums.js';
 import { SqlEntityManager } from './SqlEntityManager.js';
-import type { Field } from './typings.js';
+import type { InternalField } from './typings.js';
 export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlConnection = AbstractSqlConnection, Platform extends AbstractSqlPlatform = AbstractSqlPlatform> extends DatabaseDriver<Connection> {
     [EntityManagerType]: SqlEntityManager<this>;
     protected readonly connection: Connection;
@@ -57,12 +57,12 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
      * @internal
      */
     mergeJoinedResult<T extends object>(rawResults: EntityData<T>[], meta: EntityMetadata<T>, joinedProps: PopulateOptions<T>[]): EntityData<T>[];
-    protected shouldHaveColumn<T, U>(meta: EntityMetadata<T>, prop: EntityProperty<U>, populate: readonly PopulateOptions<U>[], fields?: readonly Field<U>[], exclude?: readonly Field<U>[]): boolean;
-    protected getFieldsForJoinedLoad<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, options: FieldsForJoinedLoadOptions<T>): Field<T>[];
+    protected shouldHaveColumn<T, U>(meta: EntityMetadata<T>, prop: EntityProperty<U>, populate: readonly PopulateOptions<U>[], fields?: readonly InternalField<U>[], exclude?: readonly InternalField<U>[]): boolean;
+    protected getFieldsForJoinedLoad<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, options: FieldsForJoinedLoadOptions<T>): InternalField<T>[];
     /**
      * @internal
      */
-    mapPropToFieldNames<T extends object>(qb: QueryBuilder<T, any, any, any>, prop: EntityProperty<T>, tableAlias: string, meta: EntityMetadata<T>, schema?: string, explicitFields?: readonly Field<T>[]): Field<T>[];
+    mapPropToFieldNames<T extends object>(qb: QueryBuilder<T, any, any, any, any, any>, prop: EntityProperty<T>, tableAlias: string, meta: EntityMetadata<T>, schema?: string, explicitFields?: readonly InternalField<T>[]): InternalField<T>[];
     /** @internal */
     createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T, any, any, any>, ctx?: Transaction, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions, alias?: string, em?: SqlEntityManager): QueryBuilder<T, any, any, any>;
     protected resolveConnectionType(args: {
@@ -76,13 +76,13 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected buildOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], options: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>): QueryOrderMap<T>[];
     protected buildPopulateOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, populateOrderBy: QueryOrderMap<T>[], parentPath: string, explicit: boolean, parentAlias?: string): QueryOrderMap<T>[];
     protected buildJoinedPropsOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], options?: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>, parentPath?: string): QueryOrderMap<T>[];
-    protected normalizeFields<T extends object>(fields: Field<T>[], prefix?: string): string[];
-    protected processField<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T> | undefined, field: string, ret: Field<T>[]): void;
-    protected buildFields<T extends object>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T, any, any, any>, alias: string, options: Pick<FindOptions<T, any, any, any>, 'strategy' | 'fields' | 'exclude'>, schema?: string): Field<T>[];
+    protected normalizeFields<T extends object>(fields: InternalField<T>[], prefix?: string): string[];
+    protected processField<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T> | undefined, field: string, ret: InternalField<T>[]): void;
+    protected buildFields<T extends object>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T, any, any, any>, alias: string, options: Pick<FindOptions<T, any, any, any>, 'strategy' | 'fields' | 'exclude'>, schema?: string): InternalField<T>[];
 }
 interface FieldsForJoinedLoadOptions<T extends object> {
-    explicitFields?: readonly Field<T>[];
-    exclude?: readonly Field<T>[];
+    explicitFields?: readonly InternalField<T>[];
+    exclude?: readonly InternalField<T>[];
     populate?: readonly PopulateOptions<T>[];
     strategy?: Options['loadStrategy'];
     populateWhere?: FindOptions<any>['populateWhere'];

package/AbstractSqlDriver.js

@@ -26,8 +26,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const populate = this.autoJoinOneToOneOwner(meta, options.populate, options.fields);
         const joinedProps = this.joinedProps(meta, populate, options);
         const schema = this.getSchemaName(meta, options);
-        const qb = this.createQueryBuilder(meta.class, options.ctx, connectionType, false, options.logging, undefined, options.em)
-            .withSchema(schema);
+        const qb = this.createQueryBuilder(meta.class, options.ctx, connectionType, false, options.logging, undefined, options.em).withSchema(schema);
         const fields = this.buildFields(meta, populate, joinedProps, qb, qb.alias, options, schema);
         const orderBy = this.buildOrderBy(qb, meta, populate, options);
         const populateWhere = this.buildPopulateWhere(meta, joinedProps, options);
@@ -168,19 +167,10 @@ export class AbstractSqlDriver extends DatabaseDriver {
     async wrapVirtualExpressionInSubquery(meta, expression, where, options, type) {
         const qb = await this.createQueryBuilderFromOptions(meta, where, options);
         qb.setFlag(QueryFlag.DISABLE_PAGINATE);
-        const isCursorPagination = [
-            options.first,
-            options.last,
-            options.before,
-            options.after,
-        ].some(v => v != null);
+        const isCursorPagination = [options.first, options.last, options.before, options.after].some(v => v != null);
         const native = qb.getNativeQuery(false);
         if (type === QueryType.COUNT) {
-            native
-                .clear('select')
-                .clear('limit')
-                .clear('offset')
-                .count();
+            native.clear('select').clear('limit').clear('offset').count();
         }
         native.from(raw(`(${expression}) as ${this.platform.quoteIdentifier(qb.alias)}`));
         const query = native.compile();
@@ -243,7 +233,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
             // pivot ref joins via joined strategy need to be handled separately here, as they dont join the target entity
             if (pivotRefJoin) {
                 let item;
-                if (prop.inverseJoinColumns.length > 1) { // composite keys
+                if (prop.inverseJoinColumns.length > 1) {
+                    // composite keys
                     item = prop.inverseJoinColumns.map(name => root[`${relationAlias}__${name}`]);
                 }
                 else {
@@ -259,9 +250,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 return;
             }
             const mapToPk = !hint.dataOnly && !!(ref || prop.mapToPk);
-            const targetProps = mapToPk
-                ? meta2.getPrimaryProps()
-                : meta2.props.filter(prop => this.platform.shouldHaveColumn(prop, hint.children || []));
+            const targetProps = mapToPk ? meta2.getPrimaryProps() : meta2.props.filter(prop => this.platform.shouldHaveColumn(prop, hint.children || []));
             // If the primary key value for the relation is null, we know we haven't joined to anything
             // and therefore we don't return any record (since all values would be null)
             const hasPK = meta2.getPrimaryProps().every(pk => pk.fieldNames.every(name => {
@@ -286,7 +275,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 .filter(prop => !ref && prop.persist === false && prop.fieldNames)
                 .forEach(prop => {
                 /* v8 ignore next */
-                if (prop.fieldNames.length > 1) { // composite keys
+                if (prop.fieldNames.length > 1) {
+                    // composite keys
                     relationPojo[prop.name] = prop.fieldNames.map(name => root[`${relationAlias}__${name}`]);
                 }
                 else {
@@ -299,7 +289,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 if (prop.fieldNames.every(name => typeof root[`${relationAlias}__${name}`] === 'undefined')) {
                     continue;
                 }
-                if (prop.fieldNames.length > 1) { // composite keys
+                if (prop.fieldNames.length > 1) {
+                    // composite keys
                     const fk = prop.fieldNames.map(name => root[`${relationAlias}__${name}`]);
                     const pk = Utils.mapFlatCompositePrimaryKey(fk, prop);
                     relationPojo[prop.name] = pk.every(val => val != null) ? pk : null;
@@ -323,7 +314,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     if (prop.kind === ReferenceKind.EMBEDDED && (prop.object || meta.embeddable)) {
                         const item = parseJsonSafe(relationPojo[prop.name]);
                         if (Array.isArray(item)) {
-                            relationPojo[prop.name] = item.map(row => row == null ? row : this.comparator.mapResult(prop.targetMeta, row));
+                            relationPojo[prop.name] = item.map(row => (row == null ? row : this.comparator.mapResult(prop.targetMeta, row)));
                         }
                         else {
                             relationPojo[prop.name] = item == null ? item : this.comparator.mapResult(prop.targetMeta, item);
@@ -390,7 +381,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const res = await this.rethrow(qb.insert(data).execute('run', false));
         res.row = res.row || {};
         let pk;
-        if (meta.primaryKeys.length > 1) { // owner has composite pk
+        if (meta.primaryKeys.length > 1) {
+            // owner has composite pk
             pk = Utils.getPrimaryKeyCond(data, meta.primaryKeys);
         }
         else {
@@ -422,7 +414,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         sql += fields.length > 0 ? '(' + fields.map(k => this.platform.quoteIdentifier(k)).join(', ') + ')' : `(${this.platform.quoteIdentifier(pks[0])})`;
         if (this.platform.usesOutputStatement()) {
             const returningProps = meta.props
-                .filter(prop => prop.persist !== false && prop.defaultRaw || prop.autoincrement || prop.generated)
+                .filter(prop => (prop.persist !== false && prop.defaultRaw) || prop.autoincrement || prop.generated)
                 .filter(prop => !(prop.name in data[0]) || isRaw(data[0][prop.name]));
             const returningFields = Utils.flatten(returningProps.map(prop => prop.fieldNames));
             sql += returningFields.length > 0 ? ` output ${returningFields.map(field => 'inserted.' + this.platform.quoteIdentifier(field)).join(', ')}` : '';
@@ -463,7 +455,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
             params.push(value);
         };
         if (fields.length > 0 || this.platform.usesDefaultKeyword()) {
-            sql += data.map(row => {
+            sql += data
+                .map(row => {
                 const keys = [];
                 const usedDups = [];
                 props.forEach(prop => {
@@ -516,11 +509,12 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     }
                 });
                 return '(' + (keys.join(', ') || 'default') + ')';
-            }).join(', ');
+            })
+                .join(', ');
         }
         if (meta && this.platform.usesReturningStatement()) {
             const returningProps = meta.props
-                .filter(prop => prop.persist !== false && prop.defaultRaw || prop.autoincrement || prop.generated)
+                .filter(prop => (prop.persist !== false && prop.defaultRaw) || prop.autoincrement || prop.generated)
                 .filter(prop => !(prop.name in data[0]) || isRaw(data[0][prop.name]));
             const returningFields = Utils.flatten(returningProps.map(prop => prop.fieldNames));
             /* v8 ignore next */
@@ -532,7 +526,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const res = await this.execute(sql, params, 'run', options.ctx, options.loggerContext);
         let pk;
         /* v8 ignore next */
-        if (pks.length > 1) { // owner has composite pk
+        if (pks.length > 1) {
+            // owner has composite pk
             pk = data.map(d => Utils.getPrimaryKeyCond(d, pks));
         }
         else {
@@ -557,8 +552,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             where = { [meta.primaryKeys[0] ?? pks[0]]: where };
         }
         if (Utils.hasObjectKeys(data)) {
-            const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes, options.loggerContext)
-                .withSchema(this.getSchemaName(meta, options));
+            const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(meta, options));
             if (options.upsert) {
                 /* v8 ignore next */
                 const uniqueFields = options.onConflictFields ?? (Utils.isPlainObject(where) ? Utils.keys(where) : meta.primaryKeys);
@@ -581,9 +575,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 qb.update(data).where(where);
                 // reload generated columns and version fields
                 const returning = [];
-                meta.props
-                    .filter(prop => (prop.generated && !prop.primary) || prop.version)
-                    .forEach(prop => returning.push(prop.name));
+                meta.props.filter(prop => (prop.generated && !prop.primary) || prop.version).forEach(prop => returning.push(prop.name));
                 qb.returning(returning);
             }
             res = await this.rethrow(qb.execute('run', false));
@@ -598,7 +590,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
         options.convertCustomTypes ??= true;
         const meta = this.metadata.get(entityName);
         if (options.upsert) {
-            const uniqueFields = options.onConflictFields ?? (Utils.isPlainObject(where[0]) ? Object.keys(where[0]).flatMap(key => Utils.splitPrimaryKeys(key)) : meta.primaryKeys);
+            const uniqueFields = options.onConflictFields ??
+                (Utils.isPlainObject(where[0]) ? Object.keys(where[0]).flatMap(key => Utils.splitPrimaryKeys(key)) : meta.primaryKeys);
             const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(meta, options));
             const returning = getOnConflictReturningFields(meta, data[0], uniqueFields, options);
             qb.insert(data)
@@ -629,10 +622,10 @@ export class AbstractSqlDriver extends DatabaseDriver {
             }
         }
         // reload generated columns and version fields
-        meta.props
-            .filter(prop => prop.generated || prop.version || prop.primary)
-            .forEach(prop => returning.add(prop.name));
-        const pkCond = Utils.flatten(meta.primaryKeys.map(pk => meta.properties[pk].fieldNames)).map(pk => `${this.platform.quoteIdentifier(pk)} = ?`).join(' and ');
+        meta.props.filter(prop => prop.generated || prop.version || prop.primary).forEach(prop => returning.add(prop.name));
+        const pkCond = Utils.flatten(meta.primaryKeys.map(pk => meta.properties[pk].fieldNames))
+            .map(pk => `${this.platform.quoteIdentifier(pk)} = ?`)
+            .join(' and ');
         const params = [];
         let sql = `update ${this.getTableName(meta, options)} set `;
         const addParams = (prop, value) => {
@@ -727,7 +720,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (Utils.isPrimaryKey(where) && pks.length === 1) {
             where = { [pks[0]]: where };
         }
-        const qb = this.createQueryBuilder(entityName, options.ctx, 'write', false, options.loggerContext).delete(where).withSchema(this.getSchemaName(meta, options));
+        const qb = this.createQueryBuilder(entityName, options.ctx, 'write', false, options.loggerContext)
+            .delete(where)
+            .withSchema(this.getSchemaName(meta, options));
         return this.rethrow(qb.execute('run', false));
     }
     /**
@@ -776,24 +771,22 @@ export class AbstractSqlDriver extends DatabaseDriver {
             }
             if (coll.property.kind === ReferenceKind.ONE_TO_MANY) {
                 const cols = coll.property.referencedColumnNames;
-                const qb = this.createQueryBuilder(coll.property.targetMeta.class, options?.ctx, 'write')
-                    .withSchema(this.getSchemaName(meta, options));
+                const qb = this.createQueryBuilder(coll.property.targetMeta.class, options?.ctx, 'write').withSchema(this.getSchemaName(meta, options));
                 if (coll.getSnapshot() === undefined) {
                     if (coll.property.orphanRemoval) {
-                        const query = qb.delete({ [coll.property.mappedBy]: pks })
-                            .andWhere({ [cols.join(Utils.PK_SEPARATOR)]: { $nin: insertDiff } });
+                        const query = qb.delete({ [coll.property.mappedBy]: pks }).andWhere({ [cols.join(Utils.PK_SEPARATOR)]: { $nin: insertDiff } });
                         await this.rethrow(query.execute());
                         continue;
                     }
-                    const query = qb.update({ [coll.property.mappedBy]: null })
+                    const query = qb
+                        .update({ [coll.property.mappedBy]: null })
                         .where({ [coll.property.mappedBy]: pks })
                         .andWhere({ [cols.join(Utils.PK_SEPARATOR)]: { $nin: insertDiff } });
                     await this.rethrow(query.execute());
                     continue;
                 }
                 /* v8 ignore next */
-                const query = qb.update({ [coll.property.mappedBy]: pks })
-                    .where({ [cols.join(Utils.PK_SEPARATOR)]: { $in: insertDiff } });
+                const query = qb.update({ [coll.property.mappedBy]: pks }).where({ [cols.join(Utils.PK_SEPARATOR)]: { $in: insertDiff } });
                 await this.rethrow(query.execute());
                 continue;
             }
@@ -801,19 +794,19 @@ export class AbstractSqlDriver extends DatabaseDriver {
             let schema = pivotMeta.schema;
             if (schema === '*') {
                 if (coll.property.owner) {
-                    schema = wrapped.getSchema() === '*' ? options?.schema ?? this.config.get('schema') : wrapped.getSchema();
+                    schema = wrapped.getSchema() === '*' ? (options?.schema ?? this.config.get('schema')) : wrapped.getSchema();
                 }
                 else {
                     const targetMeta = coll.property.targetMeta;
                     const targetSchema = (coll[0] ?? snap?.[0]) && helper(coll[0] ?? snap?.[0]).getSchema();
-                    schema = targetMeta.schema === '*' ? options?.schema ?? targetSchema ?? this.config.get('schema') : targetMeta.schema;
+                    schema = targetMeta.schema === '*' ? (options?.schema ?? targetSchema ?? this.config.get('schema')) : targetMeta.schema;
                 }
             }
             else if (schema == null) {
                 schema = this.config.get('schema');
             }
             const tableName = `${schema ?? '_'}.${pivotMeta.tableName}`;
-            const persister = groups[tableName] ??= new PivotCollectionPersister(pivotMeta, this, options?.ctx, schema, options?.loggerContext);
+            const persister = (groups[tableName] ??= new PivotCollectionPersister(pivotMeta, this, options?.ctx, schema, options?.loggerContext));
             persister.enqueueUpdate(coll.property, insertDiff, deleteDiff, pks, coll.isInitialized());
         }
         for (const persister of Utils.values(groups)) {
@@ -839,20 +832,28 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const populate = this.autoJoinOneToOneOwner(prop.targetMeta, options?.populate ?? [], options?.fields);
         const childFields = !Utils.isEmpty(options?.fields) ? options.fields.map(f => `${pivotProp1.name}.${f}`) : [];
         const childExclude = !Utils.isEmpty(options?.exclude) ? options.exclude.map(f => `${pivotProp1.name}.${f}`) : [];
-        const fields = pivotJoin
-            ? [pivotProp1.name, pivotProp2.name]
-            : [pivotProp1.name, pivotProp2.name, ...childFields];
+        const fields = pivotJoin ? [pivotProp1.name, pivotProp2.name] : [pivotProp1.name, pivotProp2.name, ...childFields];
         const res = await this.find(pivotMeta.class, where, {
             ctx,
             ...options,
             fields,
             exclude: childExclude,
             orderBy: this.getPivotOrderBy(prop, pivotProp1, orderBy, options?.orderBy),
-            populate: [{ field: populateField, strategy: LoadStrategy.JOINED, joinType: JoinType.innerJoin, children: populate, dataOnly: pivotProp1.mapToPk && !pivotJoin }],
+            populate: [
+                {
+                    field: populateField,
+                    strategy: LoadStrategy.JOINED,
+                    joinType: JoinType.innerJoin,
+                    children: populate,
+                    dataOnly: pivotProp1.mapToPk && !pivotJoin,
+                },
+            ],
             populateWhere: undefined,
             // @ts-ignore
             _populateWhere: 'infer',
-            populateFilter: !Utils.isEmpty(options?.populateFilter) || RawQueryFragment.hasObjectFragments(options?.populateFilter) ? { [pivotProp2.name]: options?.populateFilter } : undefined,
+            populateFilter: !Utils.isEmpty(options?.populateFilter) || RawQueryFragment.hasObjectFragments(options?.populateFilter)
+                ? { [pivotProp2.name]: options?.populateFilter }
+                : undefined,
         });
         const map = {};
         for (const owner of owners) {
@@ -1041,7 +1042,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     : (hint.filter && !prop.nullable) || mandatoryToOneProperty
                         ? JoinType.innerJoin
                         : JoinType.leftJoin;
-            const schema = prop.targetMeta.schema === '*' ? options?.schema ?? this.config.get('schema') : prop.targetMeta.schema;
+            const schema = prop.targetMeta.schema === '*' ? (options?.schema ?? this.config.get('schema')) : prop.targetMeta.schema;
             qb.join(field, tableAlias, {}, joinType, path, schema);
             if (pivotRefJoin) {
                 fields.push(...prop.joinColumns.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)), ...prop.inverseJoinColumns.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)));
@@ -1119,7 +1120,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 toString: () => alias.toString(),
             };
             const columns = meta.createColumnMappingObject();
-            return [raw(`${(prop.formula(table, columns))} as ${aliased}`)];
+            return [raw(`${prop.formula(table, columns)} as ${aliased}`)];
         }
         return prop.fieldNames.map(fieldName => {
             return `${tableAlias}.${fieldName} as ${tableAlias}__${fieldName}`;
@@ -1171,7 +1172,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const meta = helper(entity).__meta;
         const qb = this.createQueryBuilder(meta.class, options.ctx, undefined, undefined, options.logging).withSchema(options.schema ?? meta.schema);
         const cond = Utils.getPrimaryKeyCond(entity, meta.primaryKeys);
-        qb.select(raw('1')).where(cond).setLockMode(options.lockMode, options.lockTableAliases);
+        qb.select(raw('1'))
+            .where(cond)
+            .setLockMode(options.lockMode, options.lockTableAliases);
         await this.rethrow(qb.execute());
     }
     buildPopulateWhere(meta, joinedProps, options) {
@@ -1228,7 +1231,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 }
                 let path = parentPath;
                 const meta2 = prop.targetMeta;
-                if (prop.kind !== ReferenceKind.SCALAR && (![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) || !prop.owner || Utils.isPlainObject(childOrder))) {
+                if (prop.kind !== ReferenceKind.SCALAR &&
+                    (![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) || !prop.owner || Utils.isPlainObject(childOrder))) {
                     path += `.${field}`;
                 }
                 if (prop.kind === ReferenceKind.MANY_TO_MANY && typeof childOrder !== 'object') {
@@ -1403,7 +1407,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                         qualifiedName,
                         toString: () => a.toString(),
                     };
-                    ret.push(raw(`${(prop.formula(table, columns))} as ${aliased}`));
+                    ret.push(raw(`${prop.formula(table, columns)} as ${aliased}`));
                 }
                 if (!prop.object && (prop.hasConvertToDatabaseValueSQL || prop.hasConvertToJSValueSQL)) {
                     ret.push(prop.name);

package/AbstractSqlPlatform.d.ts

@@ -1,4 +1,4 @@
-import { type Constructor, type EntityManager, type EntityRepository, type IDatabaseDriver, type IsolationLevel, type MikroORM, Platform } from '@mikro-orm/core';
+import { type RawQueryFragment, type Constructor, type EntityManager, type EntityRepository, type IDatabaseDriver, type IsolationLevel, type MikroORM, Platform } from '@mikro-orm/core';
 import { SqlSchemaGenerator } from './schema/SqlSchemaGenerator.js';
 import { type SchemaHelper } from './schema/SchemaHelper.js';
 import type { IndexDef } from './typings.js';
@@ -24,8 +24,8 @@ export declare abstract class AbstractSqlPlatform extends Platform {
     getRollbackToSavepointSQL(savepointName: string): string;
     getReleaseSavepointSQL(savepointName: string): string;
     quoteValue(value: any): string;
-    getSearchJsonPropertySQL(path: string, type: string, aliased: boolean): string;
-    getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean, value?: unknown): string;
+    getSearchJsonPropertySQL(path: string, type: string, aliased: boolean): string | RawQueryFragment;
+    getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean, value?: unknown): string | RawQueryFragment;
     getJsonIndexDefinition(index: IndexDef): string[];
     supportsSchemas(): boolean;
     /** @inheritDoc */

package/SqlEntityManager.d.ts

@@ -20,7 +20,7 @@ export declare class SqlEntityManager<Driver extends AbstractSqlDriver = Abstrac
     /**
      * Shortcut for `createQueryBuilder()`
      */
-    qb<Entity extends object, RootAlias extends string = never>(entityName: EntityName<Entity>, alias?: RootAlias, type?: ConnectionType, loggerContext?: LoggingOptions): QueryBuilder<Entity, RootAlias, never, never>;
+    qb<Entity extends object, RootAlias extends string = never>(entityName: EntityName<Entity>, alias?: RootAlias, type?: ConnectionType, loggerContext?: LoggingOptions): QueryBuilder<Entity, RootAlias, never, never, never, "*">;
     /**
      * Returns configured Kysely instance.
      */

package/dialects/postgresql/BasePostgreSqlPlatform.d.ts

@@ -1,4 +1,4 @@
-import { type EntityProperty, type IsolationLevel, type SimpleColumnMeta, Type } from '@mikro-orm/core';
+import { type EntityProperty, type IsolationLevel, RawQueryFragment, type SimpleColumnMeta, Type } from '@mikro-orm/core';
 import { AbstractSqlPlatform } from '../../AbstractSqlPlatform.js';
 import type { IndexDef } from '../../typings.js';
 import { PostgreSqlNativeQueryBuilder } from './PostgreSqlNativeQueryBuilder.js';
@@ -78,7 +78,7 @@ export declare class BasePostgreSqlPlatform extends AbstractSqlPlatform {
     }): string;
     getBlobDeclarationSQL(): string;
     getJsonDeclarationSQL(): string;
-    getSearchJsonPropertyKey(path: string[], type: string | undefined | Type, aliased: boolean, value?: unknown): string;
+    getSearchJsonPropertyKey(path: string[], type: string | undefined | Type, aliased: boolean, value?: unknown): string | RawQueryFragment;
     getJsonIndexDefinition(index: IndexDef): string[];
     quoteIdentifier(id: string | {
         toString: () => string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.0-dev.216",
+  "version": "7.0.0-dev.217",
   "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.",
   "type": "module",
   "exports": {
@@ -56,6 +56,6 @@
     "@mikro-orm/core": "^6.6.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.216"
+    "@mikro-orm/core": "7.0.0-dev.217"
   }
 }

package/query/CriteriaNode.d.ts

@@ -10,6 +10,7 @@ export declare class CriteriaNode<T extends object> implements ICriteriaNode<T>
     readonly entityName: EntityName<T>;
     readonly parent?: ICriteriaNode<T> | undefined;
     readonly key?: (EntityKey<T> | RawQueryFragmentSymbol) | undefined;
+    readonly validate: boolean;
     readonly strict: boolean;
     payload: any;
     prop?: EntityProperty<T>;

package/query/CriteriaNode.js

@@ -9,6 +9,7 @@ export class CriteriaNode {
     entityName;
     parent;
     key;
+    validate;
     strict;
     payload;
     prop;
@@ -18,6 +19,7 @@ export class CriteriaNode {
         this.entityName = entityName;
         this.parent = parent;
         this.key = key;
+        this.validate = validate;
         this.strict = strict;
         const meta = parent && metadata.find(parent.entityName);
         if (meta && key && !RawQueryFragment.isKnownFragmentSymbol(key)) {

package/query/CriteriaNodeFactory.d.ts

@@ -4,9 +4,9 @@ import type { ICriteriaNode } from '../typings.js';
  * @internal
  */
 export declare class CriteriaNodeFactory {
-    static createNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T> | RawQueryFragmentSymbol): ICriteriaNode<T>;
-    static createScalarNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T> | RawQueryFragmentSymbol): ICriteriaNode<T>;
-    static createArrayNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, payload: any[], parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
-    static createObjectNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, payload: Dictionary, parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
-    static createObjectItemNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, node: ICriteriaNode<T>, payload: Dictionary, key: EntityKey<T> | RawQueryFragmentSymbol, meta?: EntityMetadata<T>): ICriteriaNode<T>;
+    static createNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T> | RawQueryFragmentSymbol, validate?: boolean): ICriteriaNode<T>;
+    static createScalarNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T> | RawQueryFragmentSymbol, validate?: boolean): ICriteriaNode<T>;
+    static createArrayNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, payload: any[], parent?: ICriteriaNode<T>, key?: EntityKey<T>, validate?: boolean): ICriteriaNode<T>;
+    static createObjectNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, payload: Dictionary, parent?: ICriteriaNode<T>, key?: EntityKey<T>, validate?: boolean): ICriteriaNode<T>;
+    static createObjectItemNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, node: ICriteriaNode<T>, payload: Dictionary, key: EntityKey<T> | RawQueryFragmentSymbol, meta?: EntityMetadata<T>, validate?: boolean): ICriteriaNode<T>;
 }

package/query/CriteriaNodeFactory.js

@@ -6,26 +6,26 @@ import { ScalarCriteriaNode } from './ScalarCriteriaNode.js';
  * @internal
  */
 export class CriteriaNodeFactory {
-    static createNode(metadata, entityName, payload, parent, key) {
+    static createNode(metadata, entityName, payload, parent, key, validate = true) {
         const rawField = RawQueryFragment.isKnownFragmentSymbol(key);
         const scalar = Utils.isPrimaryKey(payload) || isRaw(payload) || payload instanceof RegExp || payload instanceof Date || rawField;
         if (Array.isArray(payload) && !scalar) {
-            return this.createArrayNode(metadata, entityName, payload, parent, key);
+            return this.createArrayNode(metadata, entityName, payload, parent, key, validate);
         }
         if (Utils.isPlainObject(payload) && !scalar) {
-            return this.createObjectNode(metadata, entityName, payload, parent, key);
+            return this.createObjectNode(metadata, entityName, payload, parent, key, validate);
         }
-        return this.createScalarNode(metadata, entityName, payload, parent, key);
+        return this.createScalarNode(metadata, entityName, payload, parent, key, validate);
     }
-    static createScalarNode(metadata, entityName, payload, parent, key) {
-        const node = new ScalarCriteriaNode(metadata, entityName, parent, key);
+    static createScalarNode(metadata, entityName, payload, parent, key, validate = true) {
+        const node = new ScalarCriteriaNode(metadata, entityName, parent, key, validate);
         node.payload = payload;
         return node;
     }
-    static createArrayNode(metadata, entityName, payload, parent, key) {
-        const node = new ArrayCriteriaNode(metadata, entityName, parent, key);
+    static createArrayNode(metadata, entityName, payload, parent, key, validate = true) {
+        const node = new ArrayCriteriaNode(metadata, entityName, parent, key, validate);
         node.payload = payload.map((item, index) => {
-            const n = this.createNode(metadata, entityName, item, node);
+            const n = this.createNode(metadata, entityName, item, node, undefined, validate);
             // we care about branching only for $and
             if (key === '$and' && payload.length > 1) {
                 n.index = index;
@@ -34,36 +34,36 @@ export class CriteriaNodeFactory {
         });
         return node;
     }
-    static createObjectNode(metadata, entityName, payload, parent, key) {
+    static createObjectNode(metadata, entityName, payload, parent, key, validate = true) {
         const meta = metadata.find(entityName);
-        const node = new ObjectCriteriaNode(metadata, entityName, parent, key, true, payload.__strict);
+        const node = new ObjectCriteriaNode(metadata, entityName, parent, key, validate, payload.__strict);
         node.payload = {};
         for (const k of Utils.getObjectQueryKeys(payload)) {
-            node.payload[k] = this.createObjectItemNode(metadata, entityName, node, payload, k, meta);
+            node.payload[k] = this.createObjectItemNode(metadata, entityName, node, payload, k, meta, validate);
         }
         return node;
     }
-    static createObjectItemNode(metadata, entityName, node, payload, key, meta) {
+    static createObjectItemNode(metadata, entityName, node, payload, key, meta, validate = true) {
         const rawField = RawQueryFragment.isKnownFragmentSymbol(key);
         const prop = rawField ? null : meta?.properties[key];
         const childEntity = prop && prop.kind !== ReferenceKind.SCALAR ? prop.targetMeta.class : entityName;
         const isNotEmbedded = rawField || prop?.kind !== ReferenceKind.EMBEDDED;
         const val = payload[key];
         if (isNotEmbedded && prop?.customType instanceof JsonType) {
-            return this.createScalarNode(metadata, childEntity, val, node, key);
+            return this.createScalarNode(metadata, childEntity, val, node, key, validate);
         }
         if (prop?.kind === ReferenceKind.SCALAR && val != null && Object.keys(val).some(f => f in GroupOperator)) {
             throw ValidationError.cannotUseGroupOperatorsInsideScalars(entityName, prop.name, payload);
         }
         if (isNotEmbedded) {
-            return this.createNode(metadata, childEntity, val, node, key);
+            return this.createNode(metadata, childEntity, val, node, key, validate);
         }
         if (val == null) {
             const map = Object.keys(prop.embeddedProps).reduce((oo, k) => {
                 oo[prop.embeddedProps[k].name] = null;
                 return oo;
             }, {});
-            return this.createNode(metadata, entityName, map, node, key);
+            return this.createNode(metadata, entityName, map, node, key, validate);
         }
         // array operators can be used on embedded properties
         const allowedOperators = ['$contains', '$contained', '$overlap'];
@@ -87,6 +87,6 @@ export class CriteriaNodeFactory {
             }
             return oo;
         }, {});
-        return this.createNode(metadata, entityName, map, node, key);
+        return this.createNode(metadata, entityName, map, node, key, validate);
     }
 }

package/query/NativeQueryBuilder.d.ts

@@ -1,4 +1,4 @@
-import { type Dictionary, LockMode, type QueryFlag, RawQueryFragment } from '@mikro-orm/core';
+import { type Dictionary, LockMode, type QueryFlag, RawQueryFragment, type Subquery } from '@mikro-orm/core';
 import { QueryType } from './enums.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 interface Options {
@@ -48,8 +48,9 @@ interface OnConflictClause {
     };
 }
 /** @internal */
-export declare class NativeQueryBuilder {
+export declare class NativeQueryBuilder implements Subquery {
     protected readonly platform: AbstractSqlPlatform;
+    readonly __subquery: true;
     protected type?: QueryType;
     protected parts: string[];
     protected params: unknown[];

package/query/ObjectCriteriaNode.js

@@ -106,6 +106,11 @@ export class ObjectCriteriaNode extends CriteriaNode {
                 const rawField = RawQueryFragment.getKnownFragment(field);
                 o[raw(rawField.sql.replaceAll(ALIAS_REPLACEMENT, alias), rawField.params)] = payload;
             }
+            else if (!childNode.validate && !childNode.prop && !field.includes('.') && !operator) {
+                // wrap unknown fields in raw() to prevent alias prefixing (e.g. raw SQL aliases in HAVING)
+                // use '??' placeholder to properly quote the identifier
+                o[raw('??', [field])] = payload;
+            }
             else if (primaryKey || virtual || operator || field.includes('.') || ![QueryType.SELECT, QueryType.COUNT].includes(qb.type)) {
                 this.inlineCondition(field.replaceAll(ALIAS_REPLACEMENT, alias), o, payload);
             }