@mikro-orm/knex 6.0.0-dev.2 → 6.0.0-dev.200

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

@@ -1,8 +1,8 @@
 import type { Knex } from 'knex';
-import type { Dictionary, EntityData, EntityMetadata, EntityProperty, FlatQueryOrderMap, MetadataStorage, Platform, QBFilterQuery } from '@mikro-orm/core';
-import { LockMode } from '@mikro-orm/core';
-import { QueryType } from './enums';
+import { type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityProperty, type FlatQueryOrderMap, LockMode, type QBFilterQuery } from '@mikro-orm/core';
+import { JoinType, QueryType } from './enums';
 import type { Field, JoinOptions } from '../typings';
+import type { AbstractSqlDriver } from '../AbstractSqlDriver';
 /**
  * @internal
  */
@@ -11,25 +11,27 @@ export declare class QueryBuilderHelper {
     private readonly alias;
     private readonly aliasMap;
     private readonly subQueries;
-    private readonly metadata;
     private readonly knex;
+    private readonly driver;
     private readonly platform;
-    constructor(entityName: string, alias: string, aliasMap: Dictionary<string>, subQueries: Dictionary<string>, metadata: MetadataStorage, knex: Knex, platform: Platform);
-    mapper(field: string, type?: QueryType): string;
-    mapper(field: string, type?: QueryType, value?: any, alias?: string | null): string;
+    private readonly metadata;
+    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;
-    joinOneToReference(prop: EntityProperty, ownerAlias: string, alias: string, type: 'leftJoin' | 'innerJoin' | 'pivotJoin', cond?: Dictionary): JoinOptions;
-    joinManyToOneReference(prop: EntityProperty, ownerAlias: string, alias: string, type: 'leftJoin' | 'innerJoin' | 'pivotJoin', cond?: Dictionary): JoinOptions;
-    joinManyToManyReference(prop: EntityProperty, ownerAlias: string, alias: string, pivotAlias: string, type: 'leftJoin' | 'innerJoin' | 'pivotJoin', cond: Dictionary, path: string): Dictionary<JoinOptions>;
-    joinPivotTable(field: string, prop: EntityProperty, ownerAlias: string, alias: string, type: 'leftJoin' | 'innerJoin' | 'pivotJoin', cond?: Dictionary): JoinOptions;
+    joinOneToReference(prop: EntityProperty, ownerAlias: string, alias: string, type: JoinType, cond?: Dictionary, schema?: string): JoinOptions;
+    joinManyToOneReference(prop: EntityProperty, ownerAlias: string, alias: string, type: JoinType, cond?: Dictionary, schema?: string): JoinOptions;
+    joinManyToManyReference(prop: EntityProperty, ownerAlias: string, alias: string, pivotAlias: string, type: JoinType, cond: Dictionary, path: string, schema?: string): Dictionary<JoinOptions>;
     processJoins(qb: Knex.QueryBuilder, joins: Dictionary<JoinOptions>, schema?: string): void;
+    private processJoinClause;
+    private wrapQueryGroup;
     mapJoinColumns(type: QueryType, join: JoinOptions): (string | Knex.Raw)[];
-    isOneToOneInverse(field: string): boolean;
+    isOneToOneInverse(field: string, meta?: EntityMetadata): boolean;
     getTableName(entityName: string): string;
     /**
      * Checks whether the RE can be rewritten to simple LIKE query
      */
-    isSimpleRegExp(re: any): boolean;
+    isSimpleRegExp(re: any): re is RegExp;
     getRegExpParam(re: RegExp): string;
     appendOnConflictClause<T>(type: QueryType, onConflict: {
         fields: string[];
@@ -39,23 +41,24 @@ export declare class QueryBuilderHelper {
     }[], qb: Knex.QueryBuilder): void;
     appendQueryCondition(type: QueryType, cond: any, qb: Knex.QueryBuilder, operator?: '$and' | '$or', method?: 'where' | 'having'): void;
     private appendQuerySubCondition;
-    private processCustomExpression;
     private processObjectSubCondition;
     private getOperatorReplacement;
-    private appendJoinClause;
-    private appendJoinSubClause;
-    private processObjectSubClause;
-    getQueryOrder(type: QueryType, orderBy: FlatQueryOrderMap | FlatQueryOrderMap[], populate: Dictionary<string>): string;
-    getQueryOrderFromObject(type: QueryType, orderBy: FlatQueryOrderMap, populate: Dictionary<string>): string;
-    finalize(type: QueryType, qb: Knex.QueryBuilder, meta?: EntityMetadata): void;
-    splitField(field: string): [string, string];
+    getQueryOrder(type: QueryType, orderBy: FlatQueryOrderMap | FlatQueryOrderMap[], populate: Dictionary<string>): string[];
+    getQueryOrderFromObject(type: QueryType, orderBy: FlatQueryOrderMap, populate: Dictionary<string>): string[];
+    finalize(type: QueryType, qb: Knex.QueryBuilder, meta?: EntityMetadata, data?: Dictionary, returning?: Field<any>[]): void;
+    splitField<T>(field: EntityKey<T>, greedyAlias?: boolean): [string, EntityKey<T>, string | undefined];
     getLockSQL(qb: Knex.QueryBuilder, lockMode: LockMode, lockTables?: string[]): void;
     updateVersionProperty(qb: Knex.QueryBuilder, data: Dictionary): void;
-    static isCustomExpression(field: string, hasAlias?: boolean): boolean;
     private prefix;
     private appendGroupCondition;
     private isPrefixed;
     private fieldName;
     getProperty(field: string, alias?: string): EntityProperty | undefined;
-    isTableNameAliasRequired(type: QueryType): boolean;
+    isTableNameAliasRequired(type?: QueryType): boolean;
+}
+export interface Alias<T> {
+    aliasName: string;
+    entityName: string;
+    metadata?: EntityMetadata<T>;
+    subQuery?: Knex.QueryBuilder;
 }