@mikro-orm/knex 6.0.0-dev.4 → 6.0.0-dev.40

package/{dist/query → query}/CriteriaNodeFactory.js

@@ -37,7 +37,7 @@ class CriteriaNodeFactory {
     }
     static createObjectNode(metadata, entityName, payload, parent, key) {
         const meta = metadata.find(entityName);
-        if (!parent && Object.keys(payload).every(k => meta?.properties[k]?.reference === core_1.ReferenceType.SCALAR)) {
+        if (!parent && Object.keys(payload).every(k => meta?.properties[k]?.kind === core_1.ReferenceKind.SCALAR)) {
             return this.createScalarNode(metadata, entityName, payload, parent, key);
         }
         const node = new ObjectCriteriaNode_1.ObjectCriteriaNode(metadata, entityName, parent, key);
@@ -47,24 +47,24 @@ class CriteriaNodeFactory {
         }, {});
         return node;
     }
-    static createObjectItemNode(metadata, entityName, node, payload, item, meta) {
-        const prop = meta?.properties[item];
-        if (prop?.reference !== core_1.ReferenceType.EMBEDDED) {
-            const childEntity = prop && prop.reference !== core_1.ReferenceType.SCALAR ? prop.type : entityName;
-            return this.createNode(metadata, childEntity, payload[item], node, item);
+    static createObjectItemNode(metadata, entityName, node, payload, key, meta) {
+        const prop = meta?.properties[key];
+        if (prop?.kind !== core_1.ReferenceKind.EMBEDDED) {
+            const childEntity = prop && prop.kind !== core_1.ReferenceKind.SCALAR ? prop.type : entityName;
+            return this.createNode(metadata, childEntity, payload[key], node, key);
         }
-        const operator = Object.keys(payload[item]).some(f => core_1.Utils.isOperator(f));
+        const operator = Object.keys(payload[key]).some(f => core_1.Utils.isOperator(f));
         if (operator) {
             throw core_1.ValidationError.cannotUseOperatorsInsideEmbeddables(entityName, prop.name, payload);
         }
-        const map = Object.keys(payload[item]).reduce((oo, k) => {
+        const map = Object.keys(payload[key]).reduce((oo, k) => {
             if (!prop.embeddedProps[k]) {
                 throw core_1.ValidationError.invalidEmbeddableQuery(entityName, k, prop.type);
             }
-            oo[prop.embeddedProps[k].name] = payload[item][k];
+            oo[prop.embeddedProps[k].name] = payload[key][k];
             return oo;
         }, {});
-        return this.createNode(metadata, entityName, map, node, item);
+        return this.createNode(metadata, entityName, map, node, key);
     }
 }
 exports.CriteriaNodeFactory = CriteriaNodeFactory;

package/{dist/query → query}/ObjectCriteriaNode.d.ts

@@ -3,9 +3,9 @@ import type { IQueryBuilder } from '../typings';
 /**
  * @internal
  */
-export declare class ObjectCriteriaNode extends CriteriaNode {
-    process<T>(qb: IQueryBuilder<T>, alias?: string): any;
-    willAutoJoin<T>(qb: IQueryBuilder<T>, alias?: string): boolean;
+export declare class ObjectCriteriaNode<T extends object> extends CriteriaNode<T> {
+    process(qb: IQueryBuilder<T>, alias?: string): any;
+    willAutoJoin(qb: IQueryBuilder<T>, alias?: string): boolean;
     shouldInline(payload: any): boolean;
     private inlineChildPayload;
     private shouldAutoJoin;

package/{dist/query → query}/ObjectCriteriaNode.js

@@ -22,7 +22,8 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
             const payload = childNode.process(qb, this.prop ? alias : ownerAlias);
             const operator = core_1.Utils.isOperator(field);
             const customExpression = ObjectCriteriaNode.isCustomExpression(field);
-            const virtual = childNode.prop?.persist === false;
+            // 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
             const primaryKey = this.key && this.metadata.find(this.entityName).primaryKeys.includes(field);
             if (childNode.shouldInline(payload)) {
@@ -59,7 +60,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];
@@ -78,10 +79,22 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
                     delete o[key];
                     o.$and = $and;
                 }
+                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}`;
+                        o[key] = child[childKey];
+                        return o;
+                    }, {}));
+                }
                 else {
                     o[key] = payload[k];
                 }
             }
+            else if (ObjectCriteriaNode.isCustomExpression(k)) {
+                o[k] = payload[k];
+            }
             else {
                 o[`${childAlias}.${k}`] = payload[k];
             }
@@ -91,15 +104,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));
@@ -112,7 +125,7 @@ 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)) {
+        if (this.prop.kind === core_1.ReferenceKind.MANY_TO_MANY && (scalar || operator)) {
             qb.join(field, nestedAlias, undefined, 'pivotJoin', this.getPath());
         }
         else {

package/{dist/query → query}/QueryBuilder.d.ts

@@ -1,8 +1,12 @@
+/// <reference types="node" />
+import { inspect } from 'util';
 import type { Knex } from 'knex';
-import type { AnyEntity, Dictionary, EntityData, EntityProperty, RequiredEntityData, GroupOperator, MetadataStorage, PopulateOptions, QBFilterQuery, QueryOrderMap, QueryResult, FlushMode } from '@mikro-orm/core';
-import { LockMode, QueryFlag } from '@mikro-orm/core';
+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 { AbstractSqlDriver } from '../AbstractSqlDriver';
+import { QueryBuilderHelper } from './QueryBuilderHelper';
+import type { Alias } from './QueryBuilderHelper';
 import type { SqlEntityManager } from '../SqlEntityManager';
 import type { Field } from '../typings';
 /**
@@ -24,27 +28,30 @@ import type { Field } from '../typings';
  * const publisher = await qb.getSingleResult();
  * ```
  */
-export declare class QueryBuilder<T extends AnyEntity<T> = AnyEntity> {
-    private readonly entityName;
+export declare class QueryBuilder<T extends object = AnyEntity> {
     private readonly metadata;
     private readonly driver;
     private readonly context?;
     private connectionType?;
     private readonly em?;
-    readonly alias: string;
+    get mainAlias(): Alias;
+    get alias(): string;
+    get helper(): QueryBuilderHelper;
     /** @internal */
-    type: QueryType;
+    type?: QueryType;
     /** @internal */
     _fields?: Field<T>[];
     /** @internal */
     _populate: PopulateOptions<T>[];
     /** @internal */
+    _populateWhere?: ObjectQuery<T> | PopulateHint;
+    /** @internal */
     _populateMap: Dictionary<string>;
     private aliasCounter;
     private flags;
     private finalized;
     private _joins;
-    private _aliasMap;
+    private _explicitAlias;
     private _schema?;
     private _cond;
     private _data;
@@ -54,6 +61,7 @@ export declare class QueryBuilder<T extends AnyEntity<T> = AnyEntity> {
     private _onConflict?;
     private _limit?;
     private _offset?;
+    private _distinctOn?;
     private _joinedProps;
     private _cache?;
     private _indexHint?;
@@ -61,16 +69,20 @@ export declare class QueryBuilder<T extends AnyEntity<T> = AnyEntity> {
     private lockMode?;
     private lockTables?;
     private subQueries;
-    private innerPromise?;
+    private _mainAlias?;
+    private _aliases;
+    private _helper?;
     private readonly platform;
     private readonly knex;
-    private readonly helper;
     /**
      * @internal
      */
-    constructor(entityName: string, metadata: MetadataStorage, driver: AbstractSqlDriver, context?: Knex.Transaction<any, any[]> | undefined, alias?: string, connectionType?: "write" | "read" | undefined, em?: SqlEntityManager<AbstractSqlDriver<import("..").AbstractSqlConnection>> | 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").AbstractSqlConnection, import("../AbstractSqlPlatform").AbstractSqlPlatform>> | undefined);
     select(fields: Field<T> | Field<T>[], distinct?: boolean): SelectQueryBuilder<T>;
     addSelect(fields: Field<T> | Field<T>[]): SelectQueryBuilder<T>;
+    distinct(): SelectQueryBuilder<T>;
+    /** postgres only */
+    distinctOn(fields: string | string[]): SelectQueryBuilder<T>;
     insert(data: RequiredEntityData<T> | RequiredEntityData<T>[]): InsertQueryBuilder<T>;
     update(data: EntityData<T>): UpdateQueryBuilder<T>;
     delete(cond?: QBFilterQuery): DeleteQueryBuilder<T>;
@@ -78,9 +90,9 @@ export declare class QueryBuilder<T extends AnyEntity<T> = AnyEntity> {
     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): this;
-    leftJoinAndSelect(field: string, alias: string, cond?: QBFilterQuery): this;
-    protected getFieldsForJoinedLoad<U extends AnyEntity<U>>(prop: EntityProperty<U>, alias: string): Field<U>[];
+    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(prop: EntityProperty<T>, alias: 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;
@@ -88,16 +100,16 @@ export declare class QueryBuilder<T extends AnyEntity<T> = AnyEntity> {
     andWhere(cond: string, params?: any[]): this;
     orWhere(cond: QBFilterQuery<T>): this;
     orWhere(cond: string, params?: any[]): this;
-    orderBy(orderBy: QueryOrderMap<unknown> | QueryOrderMap<unknown>[]): this;
+    orderBy(orderBy: QBQueryOrderMap<T> | QBQueryOrderMap<T>[]): this;
     groupBy(fields: (string | keyof T) | readonly (string | keyof T)[]): this;
     having(cond?: QBFilterQuery | string, params?: any[]): this;
-    onConflict(fields?: string | string[]): this;
+    onConflict(fields?: Field<T> | Field<T>[]): this;
     ignore(): this;
     merge(data?: EntityData<T> | Field<T>[]): this;
     /**
      * @internal
      */
-    populate(populate: PopulateOptions<T>[]): this;
+    populate(populate: PopulateOptions<T>[], populateWhere?: ObjectQuery<T> | PopulateHint): this;
     /**
      * @internal
      */
@@ -117,6 +129,12 @@ export declare class QueryBuilder<T extends AnyEntity<T> = AnyEntity> {
      * Adds index hint to the FROM clause.
      */
     indexHint(sql: 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.
+     */
+    from<T extends AnyEntity<T> = AnyEntity>(target: QueryBuilder<T>, aliasName?: string): QueryBuilder<T>;
+    from<T extends AnyEntity<T> = AnyEntity>(target: EntityName<T>): QueryBuilder<T>;
     getKnexQuery(): Knex.QueryBuilder;
     /**
      * Returns the query with parameters as wildcards.
@@ -130,8 +148,18 @@ export declare class QueryBuilder<T extends AnyEntity<T> = AnyEntity> {
      * Returns raw interpolated query string with all the parameters inlined.
      */
     getFormattedQuery(): string;
+    /**
+     * @internal
+     */
     getAliasForJoinPath(path?: string): string | undefined;
+    /**
+     * @internal
+     */
     getNextAlias(entityName?: string): string;
+    /**
+     * @internal
+     */
+    getAliasMap(): Dictionary<string>;
     /**
      * 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).
@@ -153,11 +181,14 @@ export declare class QueryBuilder<T extends AnyEntity<T> = AnyEntity> {
      * Executes count query (without offset and limit), returning total count of results
      */
     getCount(field?: string | string[], distinct?: boolean): Promise<number>;
+    /**
+     * Executes the query, returning both array of results and total count query (without offset and limit).
+     */
+    getResultAndCount(): Promise<[T[], number]>;
     /**
      * Provides promise-like interface so we can await the QB instance.
      */
     then<TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<T[] | number | QueryResult<T>>;
-    private getInnerPromise;
     /**
      * Returns knex instance with sub-query aliased with given alias.
      * You can provide `EntityName.propName` as alias, then the field name will be used based on the metadata
@@ -170,23 +201,34 @@ export declare class QueryBuilder<T extends AnyEntity<T> = AnyEntity> {
     private init;
     private getQueryBase;
     private finalize;
+    private processPopulateWhere;
+    private hasToManyJoins;
     private wrapPaginateSubQuery;
     private wrapModifySubQuery;
     private autoJoinPivotTable;
+    private getSchema;
+    private createAlias;
+    private createMainAlias;
+    private fromSubQuery;
+    private fromEntityName;
+    private createQueryBuilderHelper;
+    private ensureFromClause;
+    private ensureNotFinalized;
+    [inspect.custom](depth: number): string;
 }
-export interface RunQueryBuilder<T> extends Omit<QueryBuilder<T>, 'getResult' | 'getSingleResult' | 'getResultList' | 'where'> {
+export interface RunQueryBuilder<T extends object> extends Omit<QueryBuilder<T>, 'getResult' | 'getSingleResult' | 'getResultList' | 'where'> {
     where(cond: QBFilterQuery<T> | string, params?: keyof typeof GroupOperator | any[], operator?: keyof typeof GroupOperator): this;
     execute<U = QueryResult<T>>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<U>;
     then<TResult1 = QueryResult<T>, TResult2 = never>(onfulfilled?: ((value: QueryResult<T>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<QueryResult<T>>;
 }
-export interface SelectQueryBuilder<T> extends QueryBuilder<T> {
+export interface SelectQueryBuilder<T extends object> extends QueryBuilder<T> {
     execute<U = T[]>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<U>;
     execute<U = T[]>(method: 'all', mapResults?: boolean): Promise<U>;
     execute<U = T>(method: 'get', mapResults?: boolean): Promise<U>;
     execute<U = QueryResult<T>>(method: 'run', mapResults?: boolean): Promise<U>;
     then<TResult1 = T[], TResult2 = never>(onfulfilled?: ((value: T[]) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<T[]>;
 }
-export interface CountQueryBuilder<T> extends QueryBuilder<T> {
+export interface CountQueryBuilder<T extends object> extends QueryBuilder<T> {
     execute<U = {
         count: number;
     }[]>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<U>;
@@ -201,11 +243,11 @@ export interface CountQueryBuilder<T> extends QueryBuilder<T> {
     }>>(method: 'run', mapResults?: boolean): Promise<U>;
     then<TResult1 = number, TResult2 = never>(onfulfilled?: ((value: number) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<number>;
 }
-export interface InsertQueryBuilder<T> extends RunQueryBuilder<T> {
+export interface InsertQueryBuilder<T extends object> extends RunQueryBuilder<T> {
 }
-export interface UpdateQueryBuilder<T> extends RunQueryBuilder<T> {
+export interface UpdateQueryBuilder<T extends object> extends RunQueryBuilder<T> {
 }
-export interface DeleteQueryBuilder<T> extends RunQueryBuilder<T> {
+export interface DeleteQueryBuilder<T extends object> extends RunQueryBuilder<T> {
 }
-export interface TruncateQueryBuilder<T> extends RunQueryBuilder<T> {
+export interface TruncateQueryBuilder<T extends object> extends RunQueryBuilder<T> {
 }