@mikro-orm/knex 6.0.0-dev.19 → 6.0.0-dev.191

package/query/ObjectCriteriaNode.js

@@ -11,17 +11,38 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
     process(qb, alias) {
         const nestedAlias = qb.getAliasForJoinPath(this.getPath());
         const ownerAlias = alias || qb.alias;
+        const keys = Object.keys(this.payload);
         if (nestedAlias) {
             alias = nestedAlias;
         }
         if (this.shouldAutoJoin(nestedAlias)) {
+            if (keys.some(k => ['$some', '$none', '$every'].includes(k))) {
+                const $and = [];
+                const primaryKeys = this.metadata.find(this.entityName).primaryKeys.map(pk => `${alias}.${pk}`);
+                for (const key of keys) {
+                    const payload = this.payload[key].unwrap();
+                    const sub = qb.clone(true).innerJoin(this.key, qb.getNextAlias(this.prop.type));
+                    sub.select(this.prop.targetMeta.primaryKeys);
+                    if (key === '$every') {
+                        sub.where({ $not: { [this.key]: payload } });
+                    }
+                    else {
+                        sub.where({ [this.key]: payload });
+                    }
+                    const op = key === '$some' ? '$in' : '$nin';
+                    $and.push({
+                        [core_1.Utils.getPrimaryKeyHash(primaryKeys)]: { [op]: sub.getKnexQuery() },
+                    });
+                }
+                return { $and };
+            }
             alias = this.autoJoin(qb, ownerAlias);
         }
-        return Object.keys(this.payload).reduce((o, field) => {
+        return keys.reduce((o, field) => {
             const childNode = this.payload[field];
             const payload = childNode.process(qb, this.prop ? alias : ownerAlias);
             const operator = core_1.Utils.isOperator(field);
-            const customExpression = ObjectCriteriaNode.isCustomExpression(field);
+            const isRawField = core_1.RawQueryFragment.isKnownFragment(field);
             // we need to keep the prefixing for formulas otherwise we would lose aliasing context when nesting inside group operators
             const virtual = childNode.prop?.persist === false && !childNode.prop?.formula;
             // if key is missing, we are inside group operator and we need to prefix with alias
@@ -33,8 +54,12 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
             else if (childNode.shouldRename(payload)) {
                 o[childNode.renameFieldToPK(qb)] = payload;
             }
-            else if (primaryKey || virtual || operator || customExpression || field.includes('.') || ![enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(qb.type ?? enums_1.QueryType.SELECT)) {
-                o[field.replace(/\[::alias::]/g, alias)] = payload;
+            else if (isRawField) {
+                const rawField = core_1.RawQueryFragment.getKnownFragment(field);
+                o[(0, core_1.raw)(rawField.sql.replaceAll(core_1.ALIAS_REPLACEMENT, alias), rawField.params)] = payload;
+            }
+            else if (primaryKey || virtual || operator || field.includes('.') || ![enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(qb.type ?? enums_1.QueryType.SELECT)) {
+                o[field.replaceAll(core_1.ALIAS_REPLACEMENT, alias)] = payload;
             }
             else {
                 o[`${alias}.${field}`] = payload;
@@ -42,16 +67,23 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
             return o;
         }, {});
     }
+    unwrap() {
+        return Object.keys(this.payload).reduce((o, field) => {
+            o[field] = this.payload[field].unwrap();
+            return o;
+        }, {});
+    }
     willAutoJoin(qb, alias) {
         const nestedAlias = qb.getAliasForJoinPath(this.getPath());
         const ownerAlias = alias || qb.alias;
+        const keys = Object.keys(this.payload);
         if (nestedAlias) {
             alias = nestedAlias;
         }
         if (this.shouldAutoJoin(nestedAlias)) {
-            return true;
+            return !keys.some(k => ['$some', '$none', '$every'].includes(k));
         }
-        return Object.keys(this.payload).some(field => {
+        return keys.some(field => {
             const childNode = this.payload[field];
             return childNode.willAutoJoin(qb, this.prop ? alias : ownerAlias);
         });
@@ -60,7 +92,7 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
         const customExpression = ObjectCriteriaNode.isCustomExpression(this.key);
         const scalar = core_1.Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
         const operator = core_1.Utils.isObject(payload) && Object.keys(payload).every(k => core_1.Utils.isOperator(k, false));
-        return !!this.prop && this.prop.reference !== core_1.ReferenceType.SCALAR && !scalar && !operator;
+        return !!this.prop && this.prop.kind !== core_1.ReferenceKind.SCALAR && !scalar && !operator;
     }
     inlineChildPayload(o, payload, field, alias, childAlias) {
         const prop = this.metadata.find(this.entityName).properties[field];
@@ -72,7 +104,7 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
             }
             else if (this.isPrefixed(k) || core_1.Utils.isOperator(k) || !childAlias) {
                 const idx = prop.referencedPKs.indexOf(k);
-                const key = idx !== -1 && !childAlias ? prop.joinColumns[idx] : k;
+                const key = idx !== -1 && !childAlias && ![core_1.ReferenceKind.ONE_TO_MANY, core_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind) ? prop.joinColumns[idx] : k;
                 if (key in o) {
                     const $and = o.$and ?? [];
                     $and.push({ [key]: o[key] }, { [key]: payload[k] });
@@ -81,9 +113,7 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
                 }
                 else if (core_1.Utils.isOperator(k) && Array.isArray(payload[k])) {
                     o[key] = payload[k].map((child) => Object.keys(child).reduce((o, childKey) => {
-                        const key = (this.isPrefixed(childKey) || core_1.Utils.isOperator(childKey))
-                            ? childKey
-                            : `${childAlias}.${childKey}`;
+                        const key = (this.isPrefixed(childKey) || core_1.Utils.isOperator(childKey)) ? childKey : `${childAlias}.${childKey}`;
                         o[key] = child[childKey];
                         return o;
                     }, {}));
@@ -104,15 +134,15 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
         if (!this.prop || !this.parent) {
             return false;
         }
-        const embeddable = this.prop.reference === core_1.ReferenceType.EMBEDDED;
-        const knownKey = [core_1.ReferenceType.SCALAR, core_1.ReferenceType.MANY_TO_ONE, core_1.ReferenceType.EMBEDDED].includes(this.prop.reference) || (this.prop.reference === core_1.ReferenceType.ONE_TO_ONE && this.prop.owner);
+        const embeddable = this.prop.kind === core_1.ReferenceKind.EMBEDDED;
+        const knownKey = [core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.EMBEDDED].includes(this.prop.kind) || (this.prop.kind === core_1.ReferenceKind.ONE_TO_ONE && this.prop.owner);
         const operatorKeys = knownKey && Object.keys(this.payload).every(key => core_1.Utils.isOperator(key, false));
         const primaryKeys = knownKey && Object.keys(this.payload).every(key => {
             const meta = this.metadata.find(this.entityName);
             if (!meta.primaryKeys.includes(key)) {
                 return false;
             }
-            if (!core_1.Utils.isPlainObject(this.payload[key].payload) || ![core_1.ReferenceType.ONE_TO_ONE, core_1.ReferenceType.MANY_TO_ONE].includes(meta.properties[key].reference)) {
+            if (!core_1.Utils.isPlainObject(this.payload[key].payload) || ![core_1.ReferenceKind.ONE_TO_ONE, core_1.ReferenceKind.MANY_TO_ONE].includes(meta.properties[key].kind)) {
                 return true;
             }
             return Object.keys(this.payload[key].payload).every(k => meta.properties[key].targetMeta.primaryKeys.includes(k));
@@ -125,13 +155,16 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
         const scalar = core_1.Utils.isPrimaryKey(this.payload) || this.payload instanceof RegExp || this.payload instanceof Date || customExpression;
         const operator = core_1.Utils.isPlainObject(this.payload) && Object.keys(this.payload).every(k => core_1.Utils.isOperator(k, false));
         const field = `${alias}.${this.prop.name}`;
-        if (this.prop.reference === core_1.ReferenceType.MANY_TO_MANY && (scalar || operator)) {
-            qb.join(field, nestedAlias, undefined, 'pivotJoin', this.getPath());
+        const method = qb.hasFlag(core_1.QueryFlag.INFER_POPULATE) ? 'joinAndSelect' : 'join';
+        if (this.prop.kind === core_1.ReferenceKind.MANY_TO_MANY && (scalar || operator)) {
+            qb.join(field, nestedAlias, undefined, enums_1.JoinType.pivotJoin, this.getPath());
         }
         else {
             const prev = qb._fields?.slice();
-            qb.join(field, nestedAlias, undefined, 'leftJoin', this.getPath());
-            qb._fields = prev;
+            qb[method](field, nestedAlias, undefined, enums_1.JoinType.leftJoin, this.getPath());
+            if (!qb.hasFlag(core_1.QueryFlag.INFER_POPULATE)) {
+                qb._fields = prev;
+            }
         }
         return nestedAlias;
     }

package/query/QueryBuilder.d.ts

@@ -1,14 +1,17 @@
 /// <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 { QueryType } from './enums';
+import { type AnyEntity, type ConnectionType, type Dictionary, type EntityData, type EntityName, type EntityProperty, type FlushMode, type GroupOperator, LockMode, type LoggingOptions, type MetadataStorage, type ObjectQuery, PopulateHint, type PopulateOptions, type QBFilterQuery, type QBQueryOrderMap, QueryFlag, type QueryResult, type RequiredEntityData } from '@mikro-orm/core';
+import { QueryType, JoinType } from './enums';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
-import { QueryBuilderHelper } from './QueryBuilderHelper';
-import type { Alias } from './QueryBuilderHelper';
+import { type Alias, QueryBuilderHelper } from './QueryBuilderHelper';
 import type { SqlEntityManager } from '../SqlEntityManager';
 import type { Field } from '../typings';
+import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
+export interface ExecuteOptions {
+    mapResults?: boolean;
+    mergeResults?: boolean;
+}
 /**
  * SQL query builder with fluent interface.
  *
@@ -29,12 +32,14 @@ import type { Field } from '../typings';
  * ```
  */
 export declare class QueryBuilder<T extends object = AnyEntity> {
+    #private;
     private readonly metadata;
     private readonly driver;
     private readonly context?;
     private connectionType?;
     private readonly em?;
-    get mainAlias(): Alias;
+    private readonly logging?;
+    get mainAlias(): Alias<T>;
     get alias(): string;
     get helper(): QueryBuilderHelper;
     /** @internal */
@@ -44,7 +49,7 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     /** @internal */
     _populate: PopulateOptions<T>[];
     /** @internal */
-    _populateWhere?: ObjectQuery<T> | PopulateHint;
+    _populateWhere?: ObjectQuery<T> | PopulateHint | `${PopulateHint}`;
     /** @internal */
     _populateMap: Dictionary<string>;
     private aliasCounter;
@@ -58,6 +63,7 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     private _orderBy;
     private _groupBy;
     private _having;
+    private _returning?;
     private _onConflict?;
     private _limit?;
     private _offset?;
@@ -65,6 +71,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?;
@@ -77,7 +85,7 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     /**
      * @internal
      */
-    constructor(entityName: EntityName<T> | QueryBuilder<T>, metadata: MetadataStorage, driver: AbstractSqlDriver, context?: Knex.Transaction<any, any[]> | undefined, alias?: string, connectionType?: ConnectionType | undefined, em?: SqlEntityManager<AbstractSqlDriver<import("../AbstractSqlConnection").AbstractSqlConnection, import("../AbstractSqlPlatform").AbstractSqlPlatform>> | undefined);
+    constructor(entityName: EntityName<T> | QueryBuilder<T>, metadata: MetadataStorage, driver: AbstractSqlDriver, context?: Knex.Transaction<any, any[]> | undefined, alias?: string, connectionType?: ConnectionType | undefined, em?: SqlEntityManager<AbstractSqlDriver<import("..").AbstractSqlConnection, AbstractSqlPlatform>> | undefined, logging?: LoggingOptions | undefined);
     select(fields: Field<T> | Field<T>[], distinct?: boolean): SelectQueryBuilder<T>;
     addSelect(fields: Field<T> | Field<T>[]): SelectQueryBuilder<T>;
     distinct(): SelectQueryBuilder<T>;
@@ -88,11 +96,17 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     delete(cond?: QBFilterQuery): DeleteQueryBuilder<T>;
     truncate(): TruncateQueryBuilder<T>;
     count(field?: string | string[], distinct?: boolean): CountQueryBuilder<T>;
-    join(field: string, alias: string, cond?: QBFilterQuery, type?: 'leftJoin' | 'innerJoin' | 'pivotJoin', path?: string): this;
-    leftJoin(field: string, alias: string, cond?: QBFilterQuery): this;
-    joinAndSelect(field: string, alias: string, cond?: QBFilterQuery, type?: 'leftJoin' | 'innerJoin' | 'pivotJoin', path?: string): SelectQueryBuilder<T>;
-    leftJoinAndSelect(field: string, alias: string, cond?: QBFilterQuery): SelectQueryBuilder<T>;
-    protected getFieldsForJoinedLoad<U extends object>(prop: EntityProperty<U>, alias: string): Field<U>[];
+    join(field: string | Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, type?: JoinType, path?: string, schema?: string): this;
+    innerJoin(field: string | Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, schema?: string): this;
+    innerJoinLateral(field: string | Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, schema?: string): this;
+    leftJoin(field: string | Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, schema?: string): this;
+    leftJoinLateral(field: string | Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, schema?: string): this;
+    joinAndSelect(field: string | [field: string, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: string, cond?: QBFilterQuery, type?: JoinType, path?: string, fields?: string[], schema?: string): SelectQueryBuilder<T>;
+    leftJoinAndSelect(field: string | [field: string, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: string, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<T>;
+    leftJoinLateralAndSelect(field: string | [field: string, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: string, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<T>;
+    innerJoinAndSelect(field: string | [field: string, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: string, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<T>;
+    innerJoinLateralAndSelect(field: string | [field: string, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: string, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<T>;
+    protected getFieldsForJoinedLoad(prop: EntityProperty<T>, alias: string, explicitFields?: string[]): Field<T>[];
     withSubQuery(subQuery: Knex.QueryBuilder, alias: string): this;
     where(cond: QBFilterQuery<T>, operator?: keyof typeof GroupOperator): this;
     where(cond: string, params?: any[], operator?: keyof typeof GroupOperator): this;
@@ -106,17 +120,11 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     onConflict(fields?: Field<T> | Field<T>[]): this;
     ignore(): this;
     merge(data?: EntityData<T> | Field<T>[]): this;
+    returning(fields?: Field<T> | Field<T>[]): this;
     /**
      * @internal
      */
-    populate(populate: PopulateOptions<T>[], populateWhere?: ObjectQuery<T> | PopulateHint): this;
-    /**
-     * @internal
-     */
-    ref(field: string): Knex.Ref<string, {
-        [x: string]: string;
-    }>;
-    raw<R = Knex.Raw>(sql: string, bindings?: Knex.RawBinding[] | Knex.ValueDict): R;
+    populate(populate: PopulateOptions<T>[], populateWhere?: ObjectQuery<T> | PopulateHint | `${PopulateHint}`): this;
     limit(limit?: number, offset?: number): this;
     offset(offset?: number): this;
     withSchema(schema?: string): this;
@@ -124,11 +132,22 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     setFlushMode(flushMode?: FlushMode): this;
     setFlag(flag: QueryFlag): this;
     unsetFlag(flag: QueryFlag): this;
+    hasFlag(flag: QueryFlag): boolean;
     cache(config?: boolean | number | [string, number]): this;
     /**
      * 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.
@@ -140,6 +159,11 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
      * Returns the query with parameters as wildcards.
      */
     getQuery(): string;
+    toQuery(): {
+        sql: string;
+        _sql: Knex.Sql;
+        params: readonly unknown[];
+    };
     /**
      * Returns the list of all parameters for this query.
      */
@@ -164,7 +188,7 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
      * Executes this QB and returns the raw results, mapped to the property names (unless disabled via last parameter).
      * Use `method` to specify what kind of result you want to get (array/single/meta).
      */
-    execute<U = any>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<U>;
+    execute<U = any>(method?: 'all' | 'get' | 'run', options?: ExecuteOptions | boolean): Promise<U>;
     /**
      * Alias for `qb.getResultList()`
      */
@@ -194,17 +218,18 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
      * You can provide `EntityName.propName` as alias, then the field name will be used based on the metadata
      */
     as(alias: string): Knex.QueryBuilder;
-    clone(): QueryBuilder<T>;
+    clone(reset?: boolean): QueryBuilder<T>;
     getKnex(): Knex.QueryBuilder;
     private joinReference;
     private prepareFields;
     private init;
     private getQueryBase;
+    private applyDiscriminatorCondition;
     private finalize;
+    private processPopulateWhere;
     private hasToManyJoins;
     private wrapPaginateSubQuery;
     private wrapModifySubQuery;
-    private autoJoinPivotTable;
     private getSchema;
     private createAlias;
     private createMainAlias;
@@ -213,6 +238,7 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     private createQueryBuilderHelper;
     private ensureFromClause;
     private ensureNotFinalized;
+    /** @ignore */
     [inspect.custom](depth: number): string;
 }
 export interface RunQueryBuilder<T extends object> extends Omit<QueryBuilder<T>, 'getResult' | 'getSingleResult' | 'getResultList' | 'where'> {