@mikro-orm/knex 5.7.15-dev.9 → 5.8.1-dev.0

package/AbstractSqlConnection.d.ts

@@ -1,6 +1,5 @@
-import type { Knex } from 'knex';
-import type { AnyEntity, Configuration, ConnectionOptions, EntityData, IsolationLevel, QueryResult, Transaction, TransactionEventBroadcaster } from '@mikro-orm/core';
-import { Connection } from '@mikro-orm/core';
+import { type Knex } from 'knex';
+import { Connection, type AnyEntity, type Configuration, type ConnectionOptions, type EntityData, type IsolationLevel, type QueryResult, type Transaction, type TransactionEventBroadcaster } from '@mikro-orm/core';
 import type { AbstractSqlPlatform } from './AbstractSqlPlatform';
 export declare abstract class AbstractSqlConnection extends Connection {
     private static __patched;
@@ -12,11 +11,13 @@ export declare abstract class AbstractSqlConnection extends Connection {
     isConnected(): Promise<boolean>;
     transactional<T>(cb: (trx: Transaction<Knex.Transaction>) => Promise<T>, options?: {
         isolationLevel?: IsolationLevel;
+        readOnly?: boolean;
         ctx?: Knex.Transaction;
         eventBroadcaster?: TransactionEventBroadcaster;
     }): Promise<T>;
     begin(options?: {
         isolationLevel?: IsolationLevel;
+        readOnly?: boolean;
         ctx?: Knex.Transaction;
         eventBroadcaster?: TransactionEventBroadcaster;
     }): Promise<Knex.Transaction>;

package/AbstractSqlConnection.js

@@ -46,7 +46,10 @@ class AbstractSqlConnection extends core_1.Connection {
         if (!options.ctx) {
             await options.eventBroadcaster?.dispatchEvent(core_1.EventType.beforeTransactionStart);
         }
-        const trx = await (options.ctx || this.client).transaction(null, { isolationLevel: options.isolationLevel });
+        const trx = await (options.ctx || this.client).transaction(null, {
+            isolationLevel: options.isolationLevel,
+            readOnly: options.readOnly,
+        });
         if (!options.ctx) {
             await options.eventBroadcaster?.dispatchEvent(core_1.EventType.afterTransactionStart, trx);
         }

package/AbstractSqlDriver.d.ts

@@ -1,6 +1,5 @@
 import type { Knex } from 'knex';
-import type { AnyEntity, Collection, ConnectionType, Configuration, Constructor, CountOptions, DeleteOptions, Dictionary, DriverMethodOptions, EntityData, EntityDictionary, EntityField, EntityMetadata, EntityName, EntityProperty, FilterQuery, FindOneOptions, FindOptions, IDatabaseDriver, LockOptions, NativeInsertUpdateManyOptions, NativeInsertUpdateOptions, PopulateOptions, Primary, QueryOrderMap, QueryResult, Transaction } from '@mikro-orm/core';
-import { DatabaseDriver, EntityManagerType } from '@mikro-orm/core';
+import { type AnyEntity, type Collection, type Configuration, type ConnectionType, type Constructor, type CountOptions, DatabaseDriver, type DeleteOptions, type Dictionary, type DriverMethodOptions, type EntityData, type EntityDictionary, type EntityField, EntityManagerType, type EntityMetadata, type EntityName, type EntityProperty, type FilterQuery, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type PopulateOptions, type Primary, type QueryOrderMap, type QueryResult, type Transaction, type UpsertManyOptions, type UpsertOptions } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from './AbstractSqlConnection';
 import type { AbstractSqlPlatform } from './AbstractSqlPlatform';
 import { QueryBuilder, QueryType } from './query';
@@ -27,8 +26,8 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     count<T extends object>(entityName: string, where: any, options?: CountOptions<T>): Promise<number>;
     nativeInsert<T extends object>(entityName: string, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
     nativeInsertMany<T extends object>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
-    nativeUpdate<T extends object>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
-    nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
+    nativeUpdate<T extends object>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T> & UpsertOptions<T>): Promise<QueryResult<T>>;
+    nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T> & UpsertManyOptions<T>): Promise<QueryResult<T>>;
     nativeDelete<T extends object>(entityName: string, where: FilterQuery<T> | string | any, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
     syncCollection<T extends object, O extends object>(coll: Collection<T, O>, options?: DriverMethodOptions): Promise<void>;
     loadFromPivotTable<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where?: FilterQuery<any>, orderBy?: QueryOrderMap<T>[], ctx?: Transaction, options?: FindOptions<T, any>): Promise<Dictionary<T[]>>;
@@ -41,7 +40,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     /**
      * @internal
      */
-    mergeJoinedResult<T extends object>(rawResults: EntityData<T>[], meta: EntityMetadata<T>): EntityData<T>[];
+    mergeJoinedResult<T extends object>(rawResults: EntityData<T>[], meta: EntityMetadata<T>, joinedProps: PopulateOptions<T>[]): EntityData<T>[];
     protected getFieldsForJoinedLoad<T extends object>(qb: QueryBuilder<T>, meta: EntityMetadata<T>, explicitFields?: Field<T>[], populate?: PopulateOptions<T>[], parentTableAlias?: string, parentJoinPath?: string): Field<T>[];
     /**
      * @internal

package/AbstractSqlDriver.js

@@ -38,6 +38,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             .orderBy([...core_1.Utils.asArray(options.orderBy), ...joinedPropsOrderBy])
             .groupBy(options.groupBy)
             .having(options.having)
+            .indexHint(options.indexHint)
+            .comment(options.comments)
+            .hintComment(options.hintComments)
             .withSchema(this.getSchemaName(meta, options));
         if (options.limit !== undefined) {
             qb.limit(options.limit, options.offset);
@@ -48,7 +51,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         core_1.Utils.asArray(options.flags).forEach(flag => qb.setFlag(flag));
         const result = await this.rethrow(qb.execute('all'));
         if (joinedProps.length > 0) {
-            return this.mergeJoinedResult(result, meta);
+            return this.mergeJoinedResult(result, meta, joinedProps);
         }
         return result;
     }
@@ -105,7 +108,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
     }
     async wrapVirtualExpressionInSubquery(meta, expression, where, options, type = query_1.QueryType.SELECT) {
         const qb = this.createQueryBuilder(meta.className, options?.ctx, options.connectionType, options.convertCustomTypes)
-            .limit(options?.limit, options?.offset);
+            .limit(options?.limit, options?.offset)
+            .indexHint(options.indexHint)
+            .comment(options.comments)
+            .hintComment(options.hintComments);
         if (options.orderBy) {
             qb.orderBy(options.orderBy);
         }
@@ -207,6 +213,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             return this.countVirtual(entityName, where, options);
         }
         const qb = this.createQueryBuilder(entityName, options.ctx, options.connectionType, false)
+            .indexHint(options.indexHint)
+            .comment(options.comments)
+            .hintComment(options.hintComments)
             .groupBy(options.groupBy)
             .having(options.having)
             .populate(options.populate ?? [])
@@ -332,12 +341,18 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 .withSchema(this.getSchemaName(meta, options));
             if (options.upsert) {
                 /* istanbul ignore next */
-                const uniqueFields = core_1.Utils.isPlainObject(where) ? Object.keys(where) : meta.primaryKeys;
-                /* istanbul ignore next */
+                const uniqueFields = options.onConflictFields ?? (core_1.Utils.isPlainObject(where) ? Object.keys(where) : meta.primaryKeys);
+                const returning = (0, core_1.getOnConflictReturningFields)(meta, data, uniqueFields, options);
                 qb.insert(data)
-                    .onConflict(uniqueFields.map(p => meta?.properties[p]?.fieldNames[0] ?? p))
-                    .merge(Object.keys(data).filter(f => !uniqueFields.includes(f)))
-                    .returning(meta?.comparableProps.filter(p => !p.lazy && !p.embeddable && !(p.name in data)).map(p => p.name) ?? '*');
+                    .onConflict(uniqueFields)
+                    .returning(returning);
+                if (!options.onConflictAction || options.onConflictAction === 'merge') {
+                    const fields = (0, core_1.getOnConflictFields)(data, uniqueFields, options);
+                    qb.merge(fields);
+                }
+                if (options.onConflictAction === 'ignore') {
+                    qb.ignore();
+                }
             }
             else {
                 qb.update(data).where(where);
@@ -354,12 +369,19 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         options.convertCustomTypes ?? (options.convertCustomTypes = true);
         const meta = this.metadata.get(entityName);
         if (options.upsert) {
-            const uniqueFields = core_1.Utils.isPlainObject(where[0]) ? Object.keys(where[0]) : meta.primaryKeys;
+            const uniqueFields = options.onConflictFields ?? (core_1.Utils.isPlainObject(where[0]) ? Object.keys(where[0]) : meta.primaryKeys);
             const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes).withSchema(this.getSchemaName(meta, options));
+            const returning = (0, core_1.getOnConflictReturningFields)(meta, data[0], uniqueFields, options);
             qb.insert(data)
-                .onConflict(uniqueFields.map(p => meta.properties[p]?.fieldNames[0] ?? p))
-                .merge(Object.keys(data[0]).filter(f => !uniqueFields.includes(f)))
-                .returning(meta.comparableProps.filter(p => !p.lazy && !p.embeddable && !(p.name in data[0])).map(p => p.name) ?? '*');
+                .onConflict(uniqueFields)
+                .returning(returning);
+            if (!options.onConflictAction || options.onConflictAction === 'merge') {
+                const fields = (0, core_1.getOnConflictFields)(data[0], uniqueFields, options);
+                qb.merge(fields);
+            }
+            if (options.onConflictAction === 'ignore') {
+                qb.ignore();
+            }
             return qb.execute('run', false);
         }
         const collections = options.processCollections ? data.map(d => this.extractManyToMany(entityName, d)) : [];
@@ -461,11 +483,23 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (coll.property.reference === core_1.ReferenceType.ONE_TO_MANY) {
             const cols = coll.property.referencedColumnNames;
             const qb = this.createQueryBuilder(coll.property.type, ctx, 'write')
-                .withSchema(this.getSchemaName(meta, options))
-                .update({ [coll.property.mappedBy]: pks })
+                .withSchema(this.getSchemaName(meta, options));
+            if (coll.getSnapshot() === undefined) {
+                if (coll.property.orphanRemoval) {
+                    const kqb = qb.delete({ [coll.property.mappedBy]: pks })
+                        .getKnexQuery()
+                        .whereNotIn(cols, insertDiff);
+                    return this.rethrow(this.execute(kqb));
+                }
+                const kqb = qb.update({ [coll.property.mappedBy]: null })
+                    .getKnexQuery()
+                    .whereNotIn(cols, insertDiff);
+                return this.rethrow(this.execute(kqb));
+            }
+            const kqb = qb.update({ [coll.property.mappedBy]: pks })
                 .getKnexQuery()
                 .whereIn(cols, insertDiff);
-            return this.rethrow(this.execute(qb));
+            return this.rethrow(this.execute(kqb));
         }
         /* istanbul ignore next */
         const ownerSchema = wrapped.getSchema() === '*' ? this.config.get('schema') : wrapped.getSchema();
@@ -489,17 +523,22 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         else {
             where = { ...where, ...cond };
         }
+        /* istanbul ignore if */
+        options = { ...options };
         orderBy = this.getPivotOrderBy(prop, orderBy);
-        const qb = this.createQueryBuilder(prop.type, ctx, options?.connectionType)
+        const qb = this.createQueryBuilder(prop.type, ctx, options.connectionType)
+            .indexHint(options.indexHint)
+            .comment(options.comments)
+            .hintComment(options.hintComments)
             .unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES)
             .withSchema(this.getSchemaName(prop.targetMeta, options));
         const populate = this.autoJoinOneToOneOwner(prop.targetMeta, [{ field: prop.pivotEntity }]);
-        const fields = this.buildFields(prop.targetMeta, (options?.populate ?? []), [], qb, options?.fields);
-        qb.select(fields).populate(populate).where(where).orderBy(orderBy).setLockMode(options?.lockMode, options?.lockTableAliases);
-        if (owners.length === 1 && (options?.offset != null || options?.limit != null)) {
+        const fields = this.buildFields(prop.targetMeta, (options.populate ?? []), [], qb, options.fields);
+        qb.select(fields).populate(populate).where(where).orderBy(orderBy).setLockMode(options.lockMode, options.lockTableAliases);
+        if (owners.length === 1 && (options.offset != null || options.limit != null)) {
             qb.limit(options.limit, options.offset);
         }
-        if (prop.targetMeta.schema !== '*' && pivotMeta.schema === '*' && options?.schema) {
+        if (prop.targetMeta.schema !== '*' && pivotMeta.schema === '*' && options.schema) {
             // eslint-disable-next-line dot-notation
             qb['finalize']();
             // eslint-disable-next-line dot-notation
@@ -554,17 +593,21 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
     /**
      * @internal
      */
-    mergeJoinedResult(rawResults, meta) {
+    mergeJoinedResult(rawResults, meta, joinedProps) {
         // group by the root entity primary key first
         const map = {};
         const res = [];
         rawResults.forEach(item => {
             const pk = core_1.Utils.getCompositeKeyHash(item, meta);
             if (map[pk]) {
-                map[pk].push(item);
+                joinedProps.forEach(hint => {
+                    if (Array.isArray(map[pk][hint.field]) && Array.isArray(item[hint.field])) {
+                        map[pk][hint.field].push(...item[hint.field]);
+                    }
+                });
             }
             else {
-                map[pk] = [item];
+                map[pk] = item;
                 res.push(item);
             }
         });
@@ -672,9 +715,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (!deleteDiff) {
             deleteDiff = [];
         }
+        const pivotMeta = this.metadata.find(prop.pivotEntity);
         if (deleteDiff === true || deleteDiff.length > 0) {
             const qb1 = this.createQueryBuilder(prop.pivotEntity, options?.ctx, 'write')
-                .withSchema(this.getSchemaName(meta, options))
+                .withSchema(this.getSchemaName(pivotMeta, options))
                 .unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES);
             const knex = qb1.getKnex();
             if (Array.isArray(deleteDiff)) {
@@ -700,7 +744,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             await core_1.Utils.runSerial(items, item => {
                 return this.createQueryBuilder(prop.pivotEntity, options?.ctx, 'write')
                     .unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES)
-                    .withSchema(this.getSchemaName(meta, options))
+                    .withSchema(this.getSchemaName(pivotMeta, options))
                     .insert(item)
                     .execute('run', false);
             });
@@ -754,7 +798,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         if (prop.reference === core_1.ReferenceType.EMBEDDED) {
             if (prop.object) {
-                ret.push(prop.fieldNames[0]);
+                ret.push(prop.name);
                 return;
             }
             const parts = field.split('.');
@@ -766,13 +810,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             }
             return;
         }
-        if (prop.formula) {
-            ret.push(prop.name);
-            return;
-        }
-        if (prop.fieldNames) {
-            ret.push(...prop.fieldNames);
-        }
+        ret.push(prop.name);
     }
     buildFields(meta, populate, joinedProps, qb, fields) {
         const lazyProps = meta.props.filter(prop => prop.lazy && !populate.some(p => p.field === prop.name || p.all));

package/AbstractSqlPlatform.d.ts

@@ -1,7 +1,5 @@
-import type { Constructor, EntityManager, EntityRepository, IDatabaseDriver, MikroORM } from '@mikro-orm/core';
-import { Platform } from '@mikro-orm/core';
-import type { SchemaHelper } from './schema';
-import { SchemaGenerator } from './schema';
+import { Platform, type Constructor, type EntityManager, type EntityRepository, type IDatabaseDriver, type MikroORM } from '@mikro-orm/core';
+import { SchemaGenerator, type SchemaHelper } from './schema';
 export declare abstract class AbstractSqlPlatform extends Platform {
     protected readonly schemaHelper?: SchemaHelper;
     usesPivotTable(): boolean;

package/SqlEntityManager.d.ts

@@ -1,6 +1,5 @@
 import type { Knex } from 'knex';
-import type { AnyEntity, ConnectionType, EntityData, EntityName, EntityRepository, GetRepository, QueryResult } from '@mikro-orm/core';
-import { EntityManager } from '@mikro-orm/core';
+import { EntityManager, type AnyEntity, type ConnectionType, type EntityData, type EntityName, type EntityRepository, type GetRepository, type QueryResult } from '@mikro-orm/core';
 import type { AbstractSqlDriver } from './AbstractSqlDriver';
 import { QueryBuilder } from './query';
 import type { SqlEntityRepository } from './SqlEntityRepository';

package/SqlEntityRepository.d.ts

@@ -1,6 +1,5 @@
 import type { Knex } from 'knex';
-import type { ConnectionType, EntityName } from '@mikro-orm/core';
-import { EntityRepository } from '@mikro-orm/core';
+import { EntityRepository, type ConnectionType, type EntityName } from '@mikro-orm/core';
 import type { SqlEntityManager } from './SqlEntityManager';
 import type { QueryBuilder } from './query';
 export declare class SqlEntityRepository<T extends object> extends EntityRepository<T> {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "5.7.15-dev.9",
+  "version": "5.8.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",
@@ -63,12 +63,12 @@
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^5.7.14"
+    "@mikro-orm/core": "^5.8.0"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "~5.7.15-dev.9",
-    "@mikro-orm/entity-generator": "~5.7.15-dev.9",
-    "@mikro-orm/migrations": "~5.7.15-dev.9",
+    "@mikro-orm/core": "~5.8.1-dev.0",
+    "@mikro-orm/entity-generator": "~5.8.1-dev.0",
+    "@mikro-orm/migrations": "~5.8.1-dev.0",
     "better-sqlite3": "*",
     "mssql": "*",
     "mysql": "*",

package/query/CriteriaNode.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { inspect } from 'util';
-import type { EntityProperty, MetadataStorage } from '@mikro-orm/core';
+import { type EntityProperty, type MetadataStorage } from '@mikro-orm/core';
 import type { ICriteriaNode, IQueryBuilder } from '../typings';
 /**
  * Helper for working with deeply nested where/orderBy/having criteria. Uses composite pattern to build tree from the payload.

package/query/CriteriaNodeFactory.d.ts

@@ -1,4 +1,4 @@
-import type { Dictionary, EntityMetadata, MetadataStorage } from '@mikro-orm/core';
+import { type Dictionary, type EntityMetadata, type MetadataStorage } from '@mikro-orm/core';
 import type { ICriteriaNode } from '../typings';
 /**
  * @internal

package/query/QueryBuilder.d.ts

@@ -1,12 +1,10 @@
 /// <reference types="node" />
 import { inspect } from 'util';
 import type { Knex } from 'knex';
-import type { AnyEntity, ConnectionType, Dictionary, EntityData, EntityName, EntityProperty, FlushMode, GroupOperator, MetadataStorage, ObjectQuery, PopulateOptions, QBFilterQuery, QBQueryOrderMap, QueryResult, RequiredEntityData } from '@mikro-orm/core';
-import { LockMode, PopulateHint, QueryFlag } from '@mikro-orm/core';
+import { LockMode, PopulateHint, QueryFlag, type AnyEntity, type ConnectionType, type Dictionary, type EntityData, type EntityName, type EntityProperty, type FlushMode, type GroupOperator, type MetadataStorage, type ObjectQuery, type PopulateOptions, type QBFilterQuery, type QBQueryOrderMap, type QueryResult, type RequiredEntityData } from '@mikro-orm/core';
 import { QueryType } from './enums';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
-import type { Alias } from './QueryBuilderHelper';
-import { QueryBuilderHelper } from './QueryBuilderHelper';
+import { QueryBuilderHelper, type Alias } from './QueryBuilderHelper';
 import type { SqlEntityManager } from '../SqlEntityManager';
 import type { Field } from '../typings';
 /**
@@ -34,7 +32,7 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     private readonly context?;
     private connectionType?;
     private readonly em?;
-    get mainAlias(): Alias;
+    get mainAlias(): Alias<T>;
     get alias(): string;
     get helper(): QueryBuilderHelper;
     /** @internal */
@@ -66,6 +64,8 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     private _joinedProps;
     private _cache?;
     private _indexHint?;
+    private _comments;
+    private _hintComments;
     private flushMode?;
     private lockMode?;
     private lockTables?;
@@ -132,6 +132,16 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
      * Adds index hint to the FROM clause.
      */
     indexHint(sql: string): this;
+    /**
+     * Prepend comment to the sql query using the syntax `/* ... *&#8205;/`. Some characters are forbidden such as `/*, *&#8205;/` and `?`.
+     */
+    comment(comment: string | string[]): this;
+    /**
+     * Add hints to the query using comment-like syntax `/*+ ... *&#8205;/`. MySQL and Oracle use this syntax for optimizer hints.
+     * Also various DB proxies and routers use this syntax to pass hints to alter their behavior. In other dialects the hints
+     * are ignored as simple comments.
+     */
+    hintComment(comment: string | string[]): this;
     /**
      * Specifies FROM which entity's table select/update/delete will be executed, removing all previously set FROM-s.
      * Allows setting a main string alias of the selection data.
@@ -204,6 +214,7 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     private init;
     private getQueryBase;
     private finalize;
+    private processPopulateWhere;
     private hasToManyJoins;
     private wrapPaginateSubQuery;
     private wrapModifySubQuery;

package/query/QueryBuilder.js

@@ -60,6 +60,8 @@ class QueryBuilder {
         this._groupBy = [];
         this._having = {};
         this._joinedProps = new Map();
+        this._comments = [];
+        this._hintComments = [];
         this.subQueries = {};
         this._aliases = {};
         this.platform = this.driver.getPlatform();
@@ -244,9 +246,16 @@ class QueryBuilder {
         return this;
     }
     onConflict(fields = []) {
+        const meta = this.mainAlias.metadata;
         this.ensureNotFinalized();
-        this._onConflict = this._onConflict || [];
-        this._onConflict.push({ fields: core_1.Utils.asArray(fields).map(f => f.toString()) });
+        this._onConflict ?? (this._onConflict = []);
+        this._onConflict.push({
+            fields: core_1.Utils.asArray(fields).flatMap(f => {
+                const key = f.toString();
+                /* istanbul ignore next */
+                return meta.properties[key]?.fieldNames ?? [key];
+            }),
+        });
         return this;
     }
     ignore() {
@@ -345,6 +354,24 @@ class QueryBuilder {
         this._indexHint = sql;
         return this;
     }
+    /**
+     * Prepend comment to the sql query using the syntax `/* ... *‍/`. Some characters are forbidden such as `/*, *‍/` and `?`.
+     */
+    comment(comment) {
+        this.ensureNotFinalized();
+        this._comments.push(...core_1.Utils.asArray(comment));
+        return this;
+    }
+    /**
+     * Add hints to the query using comment-like syntax `/*+ ... *‍/`. MySQL and Oracle use this syntax for optimizer hints.
+     * Also various DB proxies and routers use this syntax to pass hints to alter their behavior. In other dialects the hints
+     * are ignored as simple comments.
+     */
+    hintComment(comment) {
+        this.ensureNotFinalized();
+        this._hintComments.push(...core_1.Utils.asArray(comment));
+        return this;
+    }
     from(target, aliasName) {
         this.ensureNotFinalized();
         if (target instanceof QueryBuilder) {
@@ -374,6 +401,8 @@ class QueryBuilder {
         }, this._orderBy);
         core_1.Utils.runIfNotEmpty(() => qb.limit(this._limit), this._limit != null);
         core_1.Utils.runIfNotEmpty(() => qb.offset(this._offset), this._offset);
+        core_1.Utils.runIfNotEmpty(() => this._comments.forEach(comment => qb.comment(comment)), this._comments);
+        core_1.Utils.runIfNotEmpty(() => this._hintComments.forEach(comment => qb.hintComment(comment)), this._hintComments);
         core_1.Utils.runIfNotEmpty(() => this.helper.appendOnConflictClause(this.type ?? enums_1.QueryType.SELECT, this._onConflict, qb), this._onConflict);
         if (this.type === enums_1.QueryType.TRUNCATE && this.platform.usesCascadeStatement()) {
             return this.knex.raw(qb.toSQL().toNative().sql + ' cascade');
@@ -471,7 +500,7 @@ class QueryBuilder {
         await this.em.tryFlush(this.mainAlias.entityName, { flushMode: this.flushMode });
         let res = await this.execute('all', true);
         if (this._joinedProps.size > 0) {
-            res = this.driver.mergeJoinedResult(res, this.mainAlias.metadata);
+            res = this.driver.mergeJoinedResult(res, this.mainAlias.metadata, [...this._joinedProps.values()]);
         }
         const entities = [];
         function propagatePopulateHint(entity, hint) {
@@ -570,6 +599,7 @@ class QueryBuilder {
         const properties = [
             'flags', '_populate', '_populateWhere', '_populateMap', '_joins', '_joinedProps', '_cond', '_data', '_orderBy',
             '_schema', '_indexHint', '_cache', 'subQueries', 'lockMode', 'lockTables', '_groupBy', '_having', '_returning',
+            '_comments', '_hintComments',
         ];
         properties.forEach(prop => qb[prop] = core_1.Utils.copy(this[prop]));
         /* istanbul ignore else */
@@ -686,6 +716,10 @@ class QueryBuilder {
                 }
                 return;
             }
+            if (prop && prop.fieldNames.length > 1) {
+                ret.push(...prop.fieldNames.map(f => this.helper.mapper(f, this.type)));
+                return;
+            }
             ret.push(this.helper.mapper(field, this.type));
         });
         const meta = this.mainAlias.metadata;
@@ -816,6 +850,7 @@ class QueryBuilder {
                 .filter(field => !this._fields.includes(field))
                 .forEach(field => this.addSelect(field));
         }
+        this.processPopulateWhere();
         core_1.QueryHelper.processObjectParams(this._data);
         core_1.QueryHelper.processObjectParams(this._cond);
         core_1.QueryHelper.processObjectParams(this._having);
@@ -831,6 +866,40 @@ class QueryBuilder {
         }
         this.finalized = true;
     }
+    processPopulateWhere() {
+        if (this._populateWhere == null || this._populateWhere === core_1.PopulateHint.ALL) {
+            return;
+        }
+        const joins = Object.values(this._joins);
+        joins.forEach(join => {
+            join.cond_ = join.cond;
+            join.cond = {};
+        });
+        const replaceOnConditions = (cond) => {
+            Object.keys(cond).forEach(k => {
+                if (core_1.Utils.isOperator(k)) {
+                    if (Array.isArray(cond[k])) {
+                        return cond[k].forEach((c) => replaceOnConditions(c));
+                    }
+                    return replaceOnConditions(cond[k]);
+                }
+                const [a] = this.helper.splitField(k);
+                const join = joins.find(j => j.alias === a);
+                if (join) {
+                    join.cond = { ...join.cond, [k]: cond[k] };
+                }
+            });
+        };
+        if (this._populateWhere === core_1.PopulateHint.INFER) {
+            replaceOnConditions(this._cond);
+        }
+        else if (typeof this._populateWhere === 'object') {
+            const cond = CriteriaNodeFactory_1.CriteriaNodeFactory
+                .createNode(this.metadata, this.mainAlias.entityName, this._populateWhere)
+                .process(this);
+            replaceOnConditions(cond);
+        }
+    }
     hasToManyJoins() {
         return Object.values(this._joins).some(join => {
             return [core_1.ReferenceType.ONE_TO_MANY, core_1.ReferenceType.MANY_TO_MANY].includes(join.prop.reference);
@@ -839,6 +908,8 @@ class QueryBuilder {
     wrapPaginateSubQuery(meta) {
         const pks = this.prepareFields(meta.primaryKeys, 'sub-query');
         const subQuery = this.clone().select(pks).groupBy(pks).limit(this._limit);
+        // revert the on conditions added via populateWhere, we want to apply those only once
+        Object.values(subQuery._joins).forEach(join => join.cond = join.cond_ ?? {});
         if (this._offset) {
             subQuery.offset(this._offset);
         }
@@ -881,14 +952,7 @@ class QueryBuilder {
         subSubQuery.__raw = true; // tag it as there is now way to check via `instanceof`
         this._limit = undefined;
         this._offset = undefined;
-        const cond = this._cond;
         this.select(this._fields).where({ [core_1.Utils.getPrimaryKeyHash(meta.primaryKeys)]: { $in: subSubQuery } });
-        if (this._populateWhere === core_1.PopulateHint.INFER) {
-            this.andWhere(cond);
-        }
-        else if (typeof this._populateWhere === 'object') {
-            this.andWhere(this._populateWhere);
-        }
     }
     wrapModifySubQuery(meta) {
         const subQuery = this.clone();

package/query/QueryBuilderHelper.d.ts

@@ -1,6 +1,5 @@
 import type { Knex } from 'knex';
-import type { Dictionary, EntityData, EntityMetadata, EntityProperty, FlatQueryOrderMap, QBFilterQuery } from '@mikro-orm/core';
-import { LockMode } from '@mikro-orm/core';
+import { LockMode, type Dictionary, type EntityData, type EntityMetadata, type EntityProperty, type FlatQueryOrderMap, type QBFilterQuery } from '@mikro-orm/core';
 import { QueryType } from './enums';
 import type { Field, JoinOptions } from '../typings';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
@@ -16,7 +15,7 @@ export declare class QueryBuilderHelper {
     private readonly driver;
     private readonly platform;
     private readonly metadata;
-    constructor(entityName: string, alias: string, aliasMap: Dictionary<Alias>, subQueries: Dictionary<string>, knex: Knex, driver: AbstractSqlDriver);
+    constructor(entityName: string, alias: string, aliasMap: Dictionary<Alias<any>>, subQueries: Dictionary<string>, knex: Knex, driver: AbstractSqlDriver);
     mapper(field: string | Knex.Raw, type?: QueryType): string;
     mapper(field: string | Knex.Raw, type?: QueryType, value?: any, alias?: string | null): string;
     processData(data: Dictionary, convertCustomTypes: boolean, multi?: boolean): any;
@@ -61,9 +60,9 @@ export declare class QueryBuilderHelper {
     isTableNameAliasRequired(type?: QueryType): boolean;
     private mapData;
 }
-export interface Alias {
+export interface Alias<T> {
     aliasName: string;
     entityName: string;
-    metadata?: EntityMetadata;
+    metadata?: EntityMetadata<T>;
     subQuery?: Knex.QueryBuilder;
 }

package/query/QueryBuilderHelper.js

@@ -128,12 +128,13 @@ class QueryBuilderHelper {
         const pivotMeta = this.metadata.find(prop.pivotEntity);
         const ret = {
             [`${ownerAlias}.${prop.name}#${pivotAlias}`]: {
-                prop, type, cond, ownerAlias,
+                prop, type, ownerAlias,
                 alias: pivotAlias,
                 inverseAlias: alias,
                 joinColumns: prop.joinColumns,
                 inverseJoinColumns: prop.inverseJoinColumns,
                 primaryKeys: prop.referencedColumnNames,
+                cond: {},
                 table: pivotMeta.tableName,
                 schema: this.driver.getSchemaName(pivotMeta),
                 path: path.endsWith('[pivot]') ? path : `${path}[pivot]`,
@@ -143,7 +144,7 @@ class QueryBuilderHelper {
             return ret;
         }
         const prop2 = prop.owner ? pivotMeta.relations[1] : pivotMeta.relations[0];
-        ret[`${pivotAlias}.${prop2.name}#${alias}`] = this.joinManyToOneReference(prop2, pivotAlias, alias, type);
+        ret[`${pivotAlias}.${prop2.name}#${alias}`] = this.joinManyToOneReference(prop2, pivotAlias, alias, type, cond);
         ret[`${pivotAlias}.${prop2.name}#${alias}`].path = path;
         return ret;
     }

package/schema/DatabaseSchema.d.ts

@@ -1,4 +1,4 @@
-import type { Configuration, Dictionary, EntityMetadata } from '@mikro-orm/core';
+import { type Configuration, type Dictionary, type EntityMetadata } from '@mikro-orm/core';
 import { DatabaseTable } from './DatabaseTable';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';

package/schema/DatabaseTable.d.ts

@@ -1,4 +1,4 @@
-import type { Dictionary, EntityMetadata, EntityProperty, NamingStrategy } from '@mikro-orm/core';
+import { type Dictionary, type EntityMetadata, type EntityProperty, type NamingStrategy } from '@mikro-orm/core';
 import type { SchemaHelper } from './SchemaHelper';
 import type { Check, Column, ForeignKey, Index } from '../typings';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
@@ -17,6 +17,7 @@ export declare class DatabaseTable {
     constructor(platform: AbstractSqlPlatform, name: string, schema?: string | undefined);
     getColumns(): Column[];
     getColumn(name: string): Column | undefined;
+    removeColumn(name: string): void;
     getIndexes(): Index[];
     getChecks(): Check[];
     init(cols: Column[], indexes: Index[] | undefined, checks: Check<unknown>[] | undefined, pks: string[], fks?: Dictionary<ForeignKey>, enums?: Dictionary<string[]>): void;

package/schema/DatabaseTable.js

@@ -24,6 +24,9 @@ class DatabaseTable {
     getColumn(name) {
         return this.columns[name];
     }
+    removeColumn(name) {
+        delete this.columns[name];
+    }
     getIndexes() {
         return this.indexes;
     }
@@ -227,6 +230,8 @@ class DatabaseTable {
             primary: column.primary,
             fieldName: column.name,
             length: column.length,
+            precision: column.precision,
+            scale: column.scale,
             index: index ? index.keyName : undefined,
             unique: unique ? unique.keyName : undefined,
             enum: !!column.enumItems?.length,

package/schema/SchemaGenerator.d.ts

@@ -1,5 +1,4 @@
-import type { MikroORM } from '@mikro-orm/core';
-import { AbstractSchemaGenerator } from '@mikro-orm/core';
+import { AbstractSchemaGenerator, type MikroORM } from '@mikro-orm/core';
 import type { SchemaDifference } from '../typings';
 import { DatabaseSchema } from './DatabaseSchema';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';

package/schema/SchemaHelper.d.ts

@@ -1,5 +1,5 @@
 import type { Knex } from 'knex';
-import type { Connection, Dictionary } from '@mikro-orm/core';
+import { type Connection, type Dictionary } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
 import type { Check, Column, Index, Table, TableDifference } from '../typings';

package/typings.d.ts

@@ -25,6 +25,7 @@ export interface JoinOptions {
     path?: string;
     prop: EntityProperty;
     cond: Dictionary;
+    cond_?: Dictionary;
 }
 export interface Column {
     name: string;