@mikro-orm/knex 6.4.6-dev.9 → 7.0.0-dev.0

package/query/QueryBuilderHelper.d.ts

@@ -1,35 +1,32 @@
-import type { Knex } from 'knex';
 import { type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityProperty, type FlatQueryOrderMap, LockMode, type QBFilterQuery, RawQueryFragment } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums';
 import type { Field, JoinOptions } from '../typings';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
+import { NativeQueryBuilder } from './NativeQueryBuilder';
 /**
  * @internal
  */
 export declare class QueryBuilderHelper {
     private readonly entityName;
-    private readonly alias;
+    private alias;
     private readonly aliasMap;
     private readonly subQueries;
-    private readonly knex;
     private readonly driver;
     private readonly platform;
     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;
+    constructor(entityName: string, alias: string, aliasMap: Dictionary<Alias<any>>, subQueries: Dictionary<string>, driver: AbstractSqlDriver);
+    mapper(field: string | RawQueryFragment, type?: QueryType): string;
+    mapper(field: string | RawQueryFragment, type?: QueryType, value?: any, alias?: string | null): string;
     processData(data: Dictionary, convertCustomTypes: boolean, multi?: boolean): any;
     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;
+    processJoins(qb: NativeQueryBuilder, joins: Dictionary<JoinOptions>, schema?: string): void;
     createJoinExpression(join: JoinOptions, joins: Dictionary<JoinOptions>, schema?: string): {
         sql: string;
-        params: Knex.Value[];
+        params: unknown[];
     };
-    private processJoinClause;
-    private wrapQueryGroup;
-    mapJoinColumns(type: QueryType, join: JoinOptions): (string | Knex.Raw)[];
+    mapJoinColumns(type: QueryType, join: JoinOptions): (string | RawQueryFragment)[];
     isOneToOneInverse(field: string, meta?: EntityMetadata): boolean;
     getTableName(entityName: string): string;
     /**
@@ -37,33 +34,40 @@ export declare class QueryBuilderHelper {
      */
     isSimpleRegExp(re: any): re is RegExp;
     getRegExpParam(re: RegExp): string;
-    appendOnConflictClause<T>(type: QueryType, onConflict: {
-        fields: string[] | RawQueryFragment;
-        ignore?: boolean;
-        merge?: EntityData<T> | Field<T>[];
-        where?: QBFilterQuery<T>;
-    }[], qb: Knex.QueryBuilder): void;
-    appendQueryCondition(type: QueryType, cond: any, qb: Knex.QueryBuilder, operator?: '$and' | '$or', method?: 'where' | 'having'): void;
+    appendOnConflictClause<T>(type: QueryType, onConflict: OnConflictClause<T>[], qb: NativeQueryBuilder): void;
+    appendQueryCondition(type: QueryType, cond: any, qb: NativeQueryBuilder, operator?: '$and' | '$or', method?: 'where' | 'having'): void;
+    _appendQueryCondition(type: QueryType, cond: any, operator?: '$and' | '$or'): {
+        sql: string;
+        params: unknown[];
+    };
+    private append;
     private appendQuerySubCondition;
     private processObjectSubCondition;
+    private getValueReplacement;
     private getOperatorReplacement;
     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;
+    finalize(type: QueryType, qb: NativeQueryBuilder, 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;
+    getLockSQL(qb: NativeQueryBuilder, lockMode: LockMode, lockTables?: string[]): void;
+    updateVersionProperty(qb: NativeQueryBuilder, data: Dictionary): void;
     private prefix;
     private appendGroupCondition;
     private isPrefixed;
     private fieldName;
     getProperty(field: string, alias?: string): EntityProperty | undefined;
-    isTableNameAliasRequired(type?: QueryType): boolean;
+    isTableNameAliasRequired(type: QueryType): boolean;
     processOnConflictCondition(cond: QBFilterQuery, schema?: string): QBFilterQuery;
 }
 export interface Alias<T> {
     aliasName: string;
     entityName: string;
     metadata?: EntityMetadata<T>;
-    subQuery?: Knex.QueryBuilder;
+    subQuery?: NativeQueryBuilder;
+}
+export interface OnConflictClause<T> {
+    fields: string[] | RawQueryFragment;
+    ignore?: boolean;
+    merge?: EntityData<T> | Field<T>[];
+    where?: QBFilterQuery<T>;
 }