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

package/{dist/AbstractSqlPlatform.js → AbstractSqlPlatform.js}

@@ -18,20 +18,18 @@ class AbstractSqlPlatform extends core_1.Platform {
     getSchemaHelper() {
         return this.schemaHelper;
     }
-    getSchemaGenerator(driver) {
-        return new schema_1.SchemaGenerator(driver); // cast as `any` to get around circular dependencies
-    }
-    getEntityGenerator(em) {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const { EntityGenerator } = require('@mikro-orm/entity-generator');
-        return new EntityGenerator(em);
+    /** @inheritDoc */
+    lookupExtensions(orm) {
+        schema_1.SchemaGenerator.register(orm);
     }
-    getMigrator(em) {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const { Migrator } = require('@mikro-orm/migrations');
-        return new Migrator(em);
+    /* istanbul ignore next: kept for type inference only */
+    getSchemaGenerator(driver, em) {
+        return new schema_1.SchemaGenerator(em ?? driver);
     }
     quoteValue(value) {
+        if (this.isRaw(value)) {
+            return value;
+        }
         /* istanbul ignore if */
         if (core_1.Utils.isPlainObject(value) || value?.[core_1.JsonProperty]) {
             return (0, sqlstring_1.escape)(JSON.stringify(value));
@@ -68,11 +66,11 @@ class AbstractSqlPlatform extends core_1.Platform {
         }
         return ret;
     }
-    getSearchJsonPropertySQL(path, type) {
-        return this.getSearchJsonPropertyKey(path.split('->'), type);
+    getSearchJsonPropertySQL(path, type, aliased) {
+        return this.getSearchJsonPropertyKey(path.split('->'), type, aliased);
     }
     isRaw(value) {
-        return super.isRaw(value) || (typeof value === 'object' && value !== null && value.client && value.ref && value.constructor.name === 'Ref');
+        return super.isRaw(value) || (typeof value === 'object' && value !== null && value.client && ['Ref', 'Raw'].includes(value.constructor.name));
     }
     supportsSchemas() {
         return false;

package/{dist/README.md → README.md}

@@ -8,8 +8,8 @@ MariaDB, PostgreSQL and SQLite databases.
 
 > Heavily inspired by [Doctrine](https://www.doctrine-project.org/) and [Nextras Orm](https://nextras.org/orm/).
 
-[![NPM version](https://img.shields.io/npm/v/mikro-orm.svg)](https://www.npmjs.com/package/@mikro-orm/core)
-[![NPM dev version](https://img.shields.io/npm/v/mikro-orm/next.svg)](https://www.npmjs.com/package/@mikro-orm/core)
+[![NPM version](https://img.shields.io/npm/v/@mikro-orm/core.svg)](https://www.npmjs.com/package/@mikro-orm/core)
+[![NPM dev version](https://img.shields.io/npm/v/@mikro-orm/core/next.svg)](https://www.npmjs.com/package/@mikro-orm/core)
 [![Chat on slack](https://img.shields.io/badge/chat-on%20slack-blue.svg)](https://join.slack.com/t/mikroorm/shared_invite/enQtNTM1ODYzMzM4MDk3LWM4ZDExMjU5ZDhmNjA2MmM3MWMwZmExNjhhNDdiYTMwNWM0MGY5ZTE3ZjkyZTMzOWExNDgyYmMzNDE1NDI5NjA)
 [![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://www.npmjs.com/package/@mikro-orm/core)
 [![Coverage Status](https://img.shields.io/coveralls/mikro-orm/mikro-orm.svg)](https://coveralls.io/r/mikro-orm/mikro-orm?branch=master)

package/{dist/SqlEntityManager.d.ts → SqlEntityManager.d.ts}

@@ -1,5 +1,5 @@
 import type { Knex } from 'knex';
-import type { AnyEntity, EntityData, EntityName, EntityRepository, GetRepository, QueryResult } from '@mikro-orm/core';
+import type { AnyEntity, ConnectionType, EntityData, EntityName, EntityRepository, GetRepository, QueryResult } from '@mikro-orm/core';
 import { EntityManager } from '@mikro-orm/core';
 import type { AbstractSqlDriver } from './AbstractSqlDriver';
 import { QueryBuilder } from './query';
@@ -11,11 +11,11 @@ export declare class SqlEntityManager<D extends AbstractSqlDriver = AbstractSqlD
     /**
      * Creates a QueryBuilder instance
      */
-    createQueryBuilder<T>(entityName: EntityName<T>, alias?: string, type?: 'read' | 'write'): QueryBuilder<T>;
+    createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T>, alias?: string, type?: ConnectionType): QueryBuilder<T>;
     /**
      * Shortcut for `createQueryBuilder()`
      */
-    qb<T>(entityName: EntityName<T>, alias?: string, type?: 'read' | 'write'): QueryBuilder<T>;
+    qb<T extends object>(entityName: EntityName<T>, alias?: string, type?: ConnectionType): QueryBuilder<T>;
     /**
      * Creates raw SQL query that won't be escaped when used as a parameter.
      */
@@ -23,7 +23,7 @@ export declare class SqlEntityManager<D extends AbstractSqlDriver = AbstractSqlD
     /**
      * Returns configured knex instance.
      */
-    getKnex(type?: 'read' | 'write'): Knex<any, Record<string, any>[]>;
+    getKnex(type?: ConnectionType): Knex<any, any[]>;
     execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(queryOrKnex: string | Knex.QueryBuilder | Knex.Raw, params?: any[], method?: 'all' | 'get' | 'run'): Promise<T>;
-    getRepository<T extends AnyEntity<T>, U extends EntityRepository<T> = SqlEntityRepository<T>>(entityName: EntityName<T>): GetRepository<T, U>;
+    getRepository<T extends object, U extends EntityRepository<T> = SqlEntityRepository<T>>(entityName: EntityName<T>): GetRepository<T, U>;
 }

package/{dist/SqlEntityManager.js → SqlEntityManager.js}

@@ -11,7 +11,6 @@ class SqlEntityManager extends core_1.EntityManager {
      * Creates a QueryBuilder instance
      */
     createQueryBuilder(entityName, alias, type) {
-        entityName = core_1.Utils.className(entityName);
         const context = this.getContext();
         return new query_1.QueryBuilder(entityName, this.getMetadata(), this.getDriver(), context.getTransactionContext(), alias, type, context);
     }

package/{dist/SqlEntityRepository.d.ts → SqlEntityRepository.d.ts}

@@ -1,9 +1,9 @@
 import type { Knex } from 'knex';
-import type { EntityName } from '@mikro-orm/core';
+import type { ConnectionType, EntityName } from '@mikro-orm/core';
 import { EntityRepository } from '@mikro-orm/core';
 import type { SqlEntityManager } from './SqlEntityManager';
 import type { QueryBuilder } from './query';
-export declare class SqlEntityRepository<T> extends EntityRepository<T> {
+export declare class SqlEntityRepository<T extends object> extends EntityRepository<T> {
     protected readonly _em: SqlEntityManager;
     protected readonly entityName: EntityName<T>;
     constructor(_em: SqlEntityManager, entityName: EntityName<T>);
@@ -18,6 +18,6 @@ export declare class SqlEntityRepository<T> extends EntityRepository<T> {
     /**
      * Returns configured knex instance.
      */
-    getKnex(type?: 'read' | 'write'): Knex;
+    getKnex(type?: ConnectionType): Knex;
     protected get em(): SqlEntityManager;
 }

package/{dist/SqlEntityRepository.js → SqlEntityRepository.js}

@@ -27,7 +27,7 @@ class SqlEntityRepository extends core_1.EntityRepository {
         return this.em.getConnection(type).getKnex();
     }
     get em() {
-        return this._em.getContext();
+        return this._em.getContext(false);
     }
 }
 exports.SqlEntityRepository = SqlEntityRepository;

package/{dist/index.js → index.js}

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/package.json

@@ -1,15 +1,18 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.0.0-dev.4+5d8bf0c0c2",
+  "version": "6.0.0-dev.6",
   "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": "dist/index.js",
-  "module": "dist/index.mjs",
-  "typings": "dist/index.d.ts",
+  "main": "index.js",
+  "module": "index.mjs",
+  "typings": "index.d.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
+      "import": {
+        "types": "./index.d.ts",
+        "default": "./index.mjs"
+      },
+      "require": "./index.js"
     }
   },
   "repository": {
@@ -43,58 +46,26 @@
   },
   "homepage": "https://mikro-orm.io",
   "engines": {
-    "node": ">= 14.0.0"
+    "node": ">= 16.0.0"
   },
   "scripts": {
-    "build": "yarn clean && yarn compile && yarn copy",
-    "postbuild": "yarn gen-esm-wrapper dist/index.js dist/index.mjs",
+    "build": "yarn clean && yarn compile && yarn copy && yarn run -T gen-esm-wrapper index.js index.mjs",
     "clean": "rimraf ./dist",
     "compile": "tsc -p tsconfig.build.json",
-    "copy": "ts-node -T ../../scripts/copy.ts"
+    "copy": "node ../../scripts/copy.mjs"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "fs-extra": "10.0.0",
-    "knex": "1.0.1",
-    "sqlstring": "2.3.2"
+    "fs-extra": "11.1.0",
+    "knex": "2.3.0",
+    "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.0.0-dev.4+5d8bf0c0c2"
+    "@mikro-orm/core": "^5.5.3"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "^5.0.0",
-    "@mikro-orm/entity-generator": "^5.0.0",
-    "@mikro-orm/migrations": "^5.0.0",
-    "@vscode/sqlite3": "^5.0.0",
-    "mssql": "^7.0.0",
-    "mysql": "^2.18.1",
-    "mysql2": "^2.1.0",
-    "pg": "^8.0.3"
-  },
-  "peerDependenciesMeta": {
-    "@mikro-orm/entity-generator": {
-      "optional": true
-    },
-    "@mikro-orm/migrations": {
-      "optional": true
-    },
-    "@vscode/sqlite3": {
-      "optional": true
-    },
-    "mssql": {
-      "optional": true
-    },
-    "mysql": {
-      "optional": true
-    },
-    "mysql2": {
-      "optional": true
-    },
-    "pg": {
-      "optional": true
-    }
-  },
-  "gitHead": "5d8bf0c0c2254b0bcc0160827108ee17a8d63442"
+    "@mikro-orm/core": "~6.0.0-dev.6"
+  }
 }

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

@@ -21,9 +21,10 @@ class CriteriaNode {
                 return;
             }
             pks.forEach(k => {
-                this.prop = meta.props.find(prop => prop.name === k || (prop.fieldNames || []).includes(k));
+                this.prop = meta.props.find(prop => prop.name === k || (prop.fieldNames?.length === 1 && prop.fieldNames[0] === k));
+                const isProp = this.prop || meta.props.find(prop => (prop.fieldNames || []).includes(k));
                 // do not validate if the key is prefixed or type casted (e.g. `k::text`)
-                if (validate && !this.prop && !k.includes('.') && !k.includes('::') && !core_1.Utils.isOperator(k) && !CriteriaNode.isCustomExpression(k)) {
+                if (validate && !isProp && !k.includes('.') && !k.includes('::') && !core_1.Utils.isOperator(k) && !CriteriaNode.isCustomExpression(k)) {
                     throw new Error(`Trying to query by not existing property ${entityName}.${k}`);
                 }
             });
@@ -56,11 +57,13 @@ class CriteriaNode {
         }
     }
     renameFieldToPK(qb) {
-        const alias = qb.getAliasForJoinPath(this.getPath()) ?? qb.alias;
+        const joinAlias = qb.getAliasForJoinPath(this.getPath());
+        const alias = joinAlias ?? qb.alias;
         if (this.prop.reference === core_1.ReferenceType.MANY_TO_MANY) {
             return core_1.Utils.getPrimaryKeyHash(this.prop.inverseJoinColumns.map(col => `${alias}.${col}`));
         }
-        if (this.prop.joinColumns.length > 1) {
+        // if we found a matching join, we need to use the target table column names, as we use that alias instead of the root
+        if (!joinAlias && this.prop.owner && this.prop.joinColumns.length > 1) {
             return core_1.Utils.getPrimaryKeyHash(this.prop.joinColumns.map(col => `${alias}.${col}`));
         }
         return core_1.Utils.getPrimaryKeyHash(this.prop.referencedColumnNames.map(col => `${alias}.${col}`));

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)) {
@@ -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];
             }

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

@@ -1,8 +1,10 @@
 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 +26,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 +59,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 +67,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>> | 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 +88,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<U extends object>(prop: EntityProperty<U>, alias: string): Field<U>[];
     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 +98,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 +127,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 +146,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).
@@ -157,7 +183,6 @@ export declare class QueryBuilder<T extends AnyEntity<T> = AnyEntity> {
      * 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 +195,32 @@ export declare class QueryBuilder<T extends AnyEntity<T> = AnyEntity> {
     private init;
     private getQueryBase;
     private finalize;
+    private hasToManyJoins;
     private wrapPaginateSubQuery;
     private wrapModifySubQuery;
     private autoJoinPivotTable;
+    private getSchema;
+    private createAlias;
+    private createMainAlias;
+    private fromSubQuery;
+    private fromEntityName;
+    private createQueryBuilderHelper;
+    private ensureFromClause;
+    private ensureNotFinalized;
 }
-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 +235,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> {
 }