@mikro-orm/knex 6.0.0-dev.91 → 6.0.0-dev.93

package/AbstractSqlConnection.d.ts

@@ -1,6 +1,5 @@
-import type { Knex } from 'knex';
-import type { AnyEntity, Configuration, ConnectionOptions, EntityData, IsolationLevel, LoggingOptions, 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, type LoggingOptions } from '@mikro-orm/core';
 import type { AbstractSqlPlatform } from './AbstractSqlPlatform';
 export declare abstract class AbstractSqlConnection extends Connection {
     private static __patched;
@@ -15,11 +14,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

@@ -10,6 +10,7 @@ function isRootTransaction(trx) {
     return !Object.getOwnPropertySymbols(trx).includes(parentTransactionSymbol);
 }
 class AbstractSqlConnection extends core_1.Connection {
+    static { this.__patched = false; }
     constructor(config, options, type) {
         super(config, options, type);
         this.patchKnexClient();
@@ -53,7 +54,10 @@ class AbstractSqlConnection extends core_1.Connection {
         if (!options.ctx) {
             await options.eventBroadcaster?.dispatchEvent(core_1.EventType.beforeTransactionStart);
         }
-        const trx = await (options.ctx || this.getKnex()).transaction(null, { isolationLevel: options.isolationLevel });
+        const trx = await (options.ctx || this.getKnex()).transaction(null, {
+            isolationLevel: options.isolationLevel,
+            readOnly: options.readOnly,
+        });
         if (!options.ctx) {
             await options.eventBroadcaster?.dispatchEvent(core_1.EventType.afterTransactionStart, trx);
         }
@@ -186,4 +190,3 @@ class AbstractSqlConnection extends core_1.Connection {
     }
 }
 exports.AbstractSqlConnection = AbstractSqlConnection;
-AbstractSqlConnection.__patched = false;

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, OrderDefinition, LoggingOptions } 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 LoggingOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type PopulateOptions, type Primary, type QueryOrderMap, type QueryResult, type Transaction, type UpsertManyOptions, type UpsertOptions, type OrderDefinition } 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?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any>): Promise<Dictionary<T[]>>;
@@ -42,7 +41,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

@@ -40,6 +40,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             .where(where)
             .groupBy(options.groupBy)
             .having(options.having)
+            .indexHint(options.indexHint)
+            .comment(options.comments)
+            .hintComment(options.hintComments)
             .withSchema(this.getSchemaName(meta, options));
         if (isCursorPagination) {
             const { orderBy: newOrderBy, where } = this.processCursorOptions(meta, options, orderBy);
@@ -60,7 +63,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             result.reverse();
         }
         if (joinedProps.length > 0) {
-            return this.mergeJoinedResult(result, meta);
+            return this.mergeJoinedResult(result, meta, joinedProps);
         }
         return result;
     }
@@ -117,7 +120,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);
         }
@@ -225,6 +231,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 ?? [])
@@ -289,7 +298,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 const keys = [];
                 props.forEach(prop => {
                     if (prop.fieldNames.length > 1) {
-                        const param = row[prop.name] ?? prop.fieldNames.map(() => null);
+                        const param = [...row[prop.name] ?? prop.fieldNames.map(() => null)];
                         const key = (row[prop.name] ?? prop.fieldNames).map(() => '?');
                         prop.fieldNames.forEach((field, idx) => {
                             if (duplicates.includes(field)) {
@@ -352,12 +361,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) ? core_1.Utils.keys(where) : meta.primaryKeys;
-                /* istanbul ignore next */
+                const uniqueFields = options.onConflictFields ?? (core_1.Utils.isPlainObject(where) ? core_1.Utils.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(core_1.Utils.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);
@@ -374,12 +389,19 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         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)) : [];
@@ -494,11 +516,23 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (coll.property.kind === core_1.ReferenceKind.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();
@@ -515,7 +549,12 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const prop2 = prop.targetMeta.properties[prop.mappedBy ?? prop.inversedBy];
         const ownerMeta = this.metadata.find(pivotProp2.type);
         const pivotMeta = this.metadata.find(prop.pivotEntity);
-        const qb = this.createQueryBuilder(prop.type, ctx, options?.connectionType).withSchema(this.getSchemaName(prop.targetMeta, options));
+        options = { ...options };
+        const qb = this.createQueryBuilder(prop.type, ctx, options.connectionType)
+            .withSchema(this.getSchemaName(prop.targetMeta, options))
+            .indexHint(options.indexHint)
+            .comment(options.comments)
+            .hintComment(options.hintComments);
         const pivotAlias = qb.getNextAlias(pivotMeta.tableName);
         const pivotKey = pivotProp2.joinColumns.map(column => `${pivotAlias}.${column}`).join(core_1.Utils.PK_SEPARATOR);
         const cond = {
@@ -530,7 +569,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         orderBy = this.getPivotOrderBy(prop, pivotAlias, orderBy);
         const populate = this.autoJoinOneToOneOwner(prop.targetMeta, []);
-        const fields = this.buildFields(prop.targetMeta, (options?.populate ?? []), [], qb, options?.fields);
+        const fields = this.buildFields(prop.targetMeta, (options.populate ?? []), [], qb, options.fields);
         const k1 = !prop.owner ? 'joinColumns' : 'inverseJoinColumns';
         const k2 = prop.owner ? 'joinColumns' : 'inverseJoinColumns';
         const cols = [
@@ -539,16 +578,16 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         ];
         fields.push(...cols);
         qb.select(fields)
-            .join(prop2.name, pivotAlias, {}, 'pivotJoin', undefined, options?.schema)
+            .join(prop2.name, pivotAlias, {}, 'pivotJoin', undefined, options.schema)
             .populate(populate)
             .where(where)
             .orderBy(orderBy)
-            .setLockMode(options?.lockMode, options?.lockTableAliases);
-        if (owners.length === 1 && (options?.offset != null || options?.limit != null)) {
+            .setLockMode(options.lockMode, options.lockTableAliases);
+        if (owners.length === 1 && (options.offset != null || options.limit != null)) {
             qb.limit(options.limit, options.offset);
         }
         const schema = this.config.get('schema');
-        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
@@ -615,17 +654,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);
             }
         });
@@ -734,8 +777,9 @@ 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));
+            const qb1 = this.createQueryBuilder(prop.pivotEntity, options?.ctx, 'write').withSchema(this.getSchemaName(pivotMeta, options));
             const knex = qb1.getKnex();
             if (Array.isArray(deleteDiff)) {
                 knex.whereIn(prop.inverseJoinColumns, deleteDiff);
@@ -763,7 +807,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         else {
             await core_1.Utils.runSerial(items, item => {
                 return this.createQueryBuilder(prop.pivotEntity, options?.ctx, 'write')
-                    .withSchema(this.getSchemaName(meta, options))
+                    .withSchema(this.getSchemaName(pivotMeta, options))
                     .insert(item)
                     .execute('run', false);
             });
@@ -817,7 +861,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         if (prop.kind === core_1.ReferenceKind.EMBEDDED) {
             if (prop.object) {
-                ret.push(prop.fieldNames[0]);
+                ret.push(prop.name);
                 return;
             }
             const parts = field.split('.');
@@ -829,13 +873,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 { SqlSchemaGenerator } from './schema';
+import { Platform, type Constructor, type EntityManager, type EntityRepository, type IDatabaseDriver, type MikroORM } from '@mikro-orm/core';
+import { SqlSchemaGenerator, 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, FilterQuery } 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, type FilterQuery } 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/index.mjs

@@ -193,6 +193,8 @@ export const compareBuffers = mod.compareBuffers;
 export const compareObjects = mod.compareObjects;
 export const defineConfig = mod.defineConfig;
 export const equals = mod.equals;
+export const getOnConflictFields = mod.getOnConflictFields;
+export const getOnConflictReturningFields = mod.getOnConflictReturningFields;
 export const helper = mod.helper;
 export const knex = mod.knex;
 export const parseJsonSafe = mod.parseJsonSafe;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.0.0-dev.91",
+  "version": "6.0.0-dev.93",
   "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",
@@ -46,7 +46,7 @@
   },
   "homepage": "https://mikro-orm.io",
   "engines": {
-    "node": ">= 16.0.0"
+    "node": ">= 18.12.0"
   },
   "scripts": {
     "build": "yarn clean && yarn compile && yarn copy && yarn run -T gen-esm-wrapper index.js index.mjs",
@@ -59,13 +59,13 @@
   },
   "dependencies": {
     "fs-extra": "11.1.1",
-    "knex": "2.4.2",
+    "knex": "2.5.1",
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^5.7.12"
+    "@mikro-orm/core": "^5.8.0"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "~6.0.0-dev.91"
+    "@mikro-orm/core": "~6.0.0-dev.93"
   }
 }

package/query/CriteriaNode.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { inspect } from 'util';
-import type { EntityKey, EntityProperty, MetadataStorage } from '@mikro-orm/core';
+import { type EntityProperty, type MetadataStorage, type EntityKey } 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, EntityKey, EntityMetadata, MetadataStorage } from '@mikro-orm/core';
+import { type Dictionary, type EntityMetadata, type MetadataStorage, type EntityKey } 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, LoggingOptions, 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, type LoggingOptions } 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';
 /**
@@ -36,7 +34,7 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     private connectionType?;
     private readonly em?;
     private readonly logging?;
-    get mainAlias(): Alias;
+    get mainAlias(): Alias<T>;
     get alias(): string;
     get helper(): QueryBuilderHelper;
     /** @internal */
@@ -68,6 +66,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?;
@@ -127,6 +127,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.

package/query/QueryBuilder.js

@@ -1,16 +1,4 @@
 "use strict";
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var _QueryBuilder_query;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryBuilder = void 0;
 const util_1 = require("util");
@@ -73,11 +61,12 @@ class QueryBuilder {
         this._groupBy = [];
         this._having = {};
         this._joinedProps = new Map();
+        this._comments = [];
+        this._hintComments = [];
         this.subQueries = {};
         this._aliases = {};
         this.platform = this.driver.getPlatform();
         this.knex = this.driver.getConnection(this.connectionType).getKnex();
-        _QueryBuilder_query.set(this, void 0);
         if (alias) {
             this.aliasCounter++;
             this._explicitAlias = true;
@@ -264,9 +253,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.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() {
@@ -354,6 +350,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) {
@@ -384,6 +398,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');
@@ -400,13 +416,14 @@ class QueryBuilder {
     getQuery() {
         return this.toQuery().sql;
     }
+    #query;
     toQuery() {
-        if (__classPrivateFieldGet(this, _QueryBuilder_query, "f")) {
-            return __classPrivateFieldGet(this, _QueryBuilder_query, "f");
+        if (this.#query) {
+            return this.#query;
         }
         const sql = this.getKnexQuery().toSQL();
         const query = sql.toNative();
-        return __classPrivateFieldSet(this, _QueryBuilder_query, { sql: query.sql, params: query.bindings ?? [], _sql: sql }, "f");
+        return this.#query = { sql: query.sql, params: query.bindings ?? [], _sql: sql };
     }
     /**
      * Returns the list of all parameters for this query.
@@ -489,7 +506,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) {
@@ -587,6 +604,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 */
@@ -711,6 +729,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;
@@ -1020,7 +1042,7 @@ class QueryBuilder {
         }
     }
     /* istanbul ignore next */
-    [(_QueryBuilder_query = new WeakMap(), util_1.inspect.custom)](depth) {
+    [util_1.inspect.custom](depth) {
         const object = { ...this };
         const hidden = ['metadata', 'driver', 'context', 'platform', 'knex', 'type'];
         Object.keys(object).filter(k => k.startsWith('_')).forEach(k => delete object[k]);

package/query/QueryBuilderHelper.d.ts

@@ -1,6 +1,5 @@
 import type { Knex } from 'knex';
-import type { Dictionary, EntityData, EntityKey, EntityMetadata, EntityProperty, FlatQueryOrderMap, QBFilterQuery } from '@mikro-orm/core';
-import { LockMode } from '@mikro-orm/core';
+import { LockMode, type Dictionary, type EntityData, type EntityKey, 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;
@@ -58,9 +57,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

@@ -112,10 +112,10 @@ class QueryBuilderHelper {
         const joinColumns = prop.owner ? prop.referencedColumnNames : prop2.joinColumns;
         const inverseJoinColumns = prop.referencedColumnNames;
         const primaryKeys = prop.owner ? prop.joinColumns : prop2.referencedColumnNames;
+        schema ??= prop.targetMeta?.schema === '*' ? '*' : this.driver.getSchemaName(prop.targetMeta);
         return {
-            prop, type, cond, ownerAlias, alias, table,
+            prop, type, cond, ownerAlias, alias, table, schema,
             joinColumns, inverseJoinColumns, primaryKeys,
-            schema: this.driver.getSchemaName(prop.targetMeta, { schema }),
         };
     }
     joinManyToOneReference(prop, ownerAlias, alias, type, cond = {}, schema) {
@@ -131,12 +131,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, { schema }),
                 path: path.endsWith('[pivot]') ? path : `${path}[pivot]`,
@@ -146,7 +147,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, undefined, schema);
+        ret[`${pivotAlias}.${prop2.name}#${alias}`] = this.joinManyToOneReference(prop2, pivotAlias, alias, type, cond, schema);
         ret[`${pivotAlias}.${prop2.name}#${alias}`].path = path;
         return ret;
     }
@@ -622,7 +623,7 @@ class QueryBuilderHelper {
             if (prop.hasConvertToDatabaseValueSQL && !this.platform.isRaw(data[k])) {
                 const quoted = this.platform.quoteValue(data[k]);
                 const sql = prop.customType.convertToDatabaseValueSQL(quoted, this.platform);
-                data[k] = this.knex.raw(sql.replace(/\?/, '\\?'));
+                data[k] = this.knex.raw(sql.replace(/\?/g, '\\?'));
             }
             if (!prop.customType && (Array.isArray(data[k]) || core_1.Utils.isPlainObject(data[k]))) {
                 data[k] = JSON.stringify(data[k]);

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 { CheckDef, Column, ForeignKey, IndexDef } from '../typings';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
@@ -18,6 +18,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(): IndexDef[];
     getChecks(): CheckDef[];
     init(cols: Column[], indexes: IndexDef[] | undefined, checks: CheckDef<unknown>[] | undefined, pks: string[], fks?: Dictionary<ForeignKey>, enums?: Dictionary<string[]>): void;

package/schema/DatabaseTable.js

@@ -25,6 +25,9 @@ class DatabaseTable {
     getColumn(name) {
         return this.columns[name];
     }
+    removeColumn(name) {
+        delete this.columns[name];
+    }
     getIndexes() {
         return this.indexes;
     }
@@ -228,6 +231,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/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 { CheckDef, Column, IndexDef, Table, TableDifference } from '../typings';

package/schema/SqlSchemaGenerator.d.ts

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