@mikro-orm/knex 7.0.0-dev.3 → 7.0.0-dev.31

package/PivotCollectionPersister.d.ts

@@ -1,16 +1,17 @@
-import { type EntityMetadata, type EntityProperty, type Primary, type Transaction } from '@mikro-orm/core';
+import { type Dictionary, type EntityMetadata, type EntityProperty, type Primary, type Transaction } from '@mikro-orm/core';
 import { type AbstractSqlDriver } from './AbstractSqlDriver.js';
 export declare class PivotCollectionPersister<Entity extends object> {
     private readonly meta;
     private readonly driver;
     private readonly ctx?;
     private readonly schema?;
+    private readonly loggerContext?;
     private readonly platform;
     private readonly inserts;
     private readonly deletes;
     private readonly batchSize;
     private order;
-    constructor(meta: EntityMetadata<Entity>, driver: AbstractSqlDriver, ctx?: Transaction | undefined, schema?: string | undefined);
+    constructor(meta: EntityMetadata<Entity>, driver: AbstractSqlDriver, ctx?: Transaction | undefined, schema?: string | undefined, loggerContext?: Dictionary | undefined);
     enqueueUpdate(prop: EntityProperty<Entity>, insertDiff: Primary<Entity>[][], deleteDiff: Primary<Entity>[][] | boolean, pks: Primary<Entity>[]): void;
     private enqueueInsert;
     private enqueueDelete;

package/PivotCollectionPersister.js

@@ -38,16 +38,18 @@ export class PivotCollectionPersister {
     driver;
     ctx;
     schema;
+    loggerContext;
     platform;
     inserts = new Map();
     deletes = new Map();
     batchSize;
     order = 0;
-    constructor(meta, driver, ctx, schema) {
+    constructor(meta, driver, ctx, schema, loggerContext) {
         this.meta = meta;
         this.driver = driver;
         this.ctx = ctx;
         this.schema = schema;
+        this.loggerContext = loggerContext;
         this.platform = this.driver.getPlatform();
         this.batchSize = this.driver.config.get('batchSize');
     }
@@ -99,6 +101,7 @@ export class PivotCollectionPersister {
                 await this.driver.nativeDelete(this.meta.className, cond, {
                     ctx: this.ctx,
                     schema: this.schema,
+                    loggerContext: this.loggerContext,
                 });
             }
         }
@@ -118,13 +121,14 @@ export class PivotCollectionPersister {
                     schema: this.schema,
                     convertCustomTypes: false,
                     processCollections: false,
+                    loggerContext: this.loggerContext,
                 });
             }
             /* v8 ignore start */
         }
         else {
             await Utils.runSerial(items, item => {
-                return this.driver.createQueryBuilder(this.meta.className, this.ctx, 'write')
+                return this.driver.createQueryBuilder(this.meta.className, this.ctx, 'write', false, this.loggerContext)
                     .withSchema(this.schema)
                     .insert(item)
                     .execute('run', false);

package/README.md

@@ -11,7 +11,6 @@ TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-or
 [![Chat on discord](https://img.shields.io/discord/1214904142443839538?label=discord&color=blue)](https://discord.gg/w8bjxFHS7X)
 [![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)
-[![Maintainability](https://api.codeclimate.com/v1/badges/27999651d3adc47cfa40/maintainability)](https://codeclimate.com/github/mikro-orm/mikro-orm/maintainability)
 [![Build Status](https://github.com/mikro-orm/mikro-orm/workflows/tests/badge.svg?branch=master)](https://github.com/mikro-orm/mikro-orm/actions?workflow=tests)
 
 ## 🤔 Unit of What?
@@ -141,7 +140,7 @@ There is also auto-generated [CHANGELOG.md](CHANGELOG.md) file based on commit m
 - [Composite and Foreign Keys as Primary Key](https://mikro-orm.io/docs/composite-keys)
 - [Filters](https://mikro-orm.io/docs/filters)
 - [Using `QueryBuilder`](https://mikro-orm.io/docs/query-builder)
-- [Preloading Deeply Nested Structures via populate](https://mikro-orm.io/docs/nested-populate)
+- [Populating relations](https://mikro-orm.io/docs/populating-relations)
 - [Property Validation](https://mikro-orm.io/docs/property-validation)
 - [Lifecycle Hooks](https://mikro-orm.io/docs/events#hooks)
 - [Vanilla JS Support](https://mikro-orm.io/docs/usage-with-js)

package/dialects/mssql/MsSqlNativeQueryBuilder.d.ts

@@ -5,6 +5,8 @@ export declare class MsSqlNativeQueryBuilder extends NativeQueryBuilder {
         sql: string;
         params: unknown[];
     };
+    protected compileInsert(): void;
+    private appendOutputTable;
     private compileUpsert;
     protected compileSelect(): void;
     protected addLockClause(): void;

package/dialects/mssql/MsSqlNativeQueryBuilder.js

@@ -12,6 +12,10 @@ export class MsSqlNativeQueryBuilder extends NativeQueryBuilder {
         if (this.options.flags?.has(QueryFlag.IDENTITY_INSERT)) {
             this.parts.push(`set identity_insert ${this.getTableName()} on;`);
         }
+        const { prefix, suffix } = this.appendOutputTable();
+        if (prefix) {
+            this.parts.push(prefix);
+        }
         if (this.options.comment) {
             this.parts.push(...this.options.comment.map(comment => `/* ${comment} */`));
         }
@@ -37,7 +41,11 @@ export class MsSqlNativeQueryBuilder extends NativeQueryBuilder {
                     this.compileTruncate();
                     break;
             }
-            if ([QueryType.INSERT, QueryType.UPDATE, QueryType.DELETE].includes(this.type)) {
+            if (suffix) {
+                this.parts[this.parts.length - 1] += ';';
+                this.parts.push(suffix);
+            }
+            else if ([QueryType.INSERT, QueryType.UPDATE, QueryType.DELETE].includes(this.type)) {
                 this.parts[this.parts.length - 1] += '; select @@rowcount;';
             }
         }
@@ -46,6 +54,37 @@ export class MsSqlNativeQueryBuilder extends NativeQueryBuilder {
         }
         return this.combineParts();
     }
+    compileInsert() {
+        if (!this.options.data) {
+            throw new Error('No data provided');
+        }
+        this.parts.push('insert');
+        this.addHintComment();
+        this.parts.push(`into ${this.getTableName()}`);
+        if (Object.keys(this.options.data).length === 0) {
+            this.addOutputClause('inserted');
+            this.parts.push('default values');
+            return;
+        }
+        const parts = this.processInsertData();
+        if (this.options.flags?.has(QueryFlag.OUTPUT_TABLE)) {
+            this.parts[this.parts.length - 2] += ' into #out ';
+        }
+        this.parts.push(parts.join(', '));
+    }
+    appendOutputTable() {
+        if (!this.options.flags?.has(QueryFlag.OUTPUT_TABLE)) {
+            return { prefix: '', suffix: '' };
+        }
+        const returningFields = this.options.returning;
+        const selections = returningFields
+            .map(field => `[t].${this.platform.quoteIdentifier(field)}`)
+            .join(',');
+        return {
+            prefix: `select top(0) ${selections} into #out from ${this.getTableName()} as t left join ${this.getTableName()} on 0 = 1;`,
+            suffix: `select ${selections} from #out as t; drop table #out`,
+        };
+    }
     compileUpsert() {
         const clause = this.options.onConflict;
         const dataAsArray = Utils.asArray(this.options.data);
@@ -65,9 +104,11 @@ export class MsSqlNativeQueryBuilder extends NativeQueryBuilder {
             this.params.push(...clause.fields.params);
         }
         else if (clause.fields.length > 0) {
-            // const fields = clause.fields.map(field => this.quote(field));
-            const conflictColumn = this.quote(clause.fields[0]);
-            this.parts.push(`on ${this.getTableName()}.${conflictColumn} = tsource.${conflictColumn}`);
+            const fields = clause.fields.map(field => {
+                const col = this.quote(field);
+                return `${this.getTableName()}.${col} = tsource.${col}`;
+            });
+            this.parts.push(`on ${fields.join(' and ')}`);
         }
         const sourceColumns = keys.map(field => `tsource.${this.quote(field)}`).join(', ');
         const destinationColumns = keys.map(field => this.quote(field)).join(', ');
@@ -80,7 +121,9 @@ export class MsSqlNativeQueryBuilder extends NativeQueryBuilder {
             }
             this.parts.push('then update set');
             if (!clause.merge || Array.isArray(clause.merge)) {
-                const parts = keys.map((column) => `${this.quote(column)} = tsource.${this.quote(column)}`);
+                const parts = (clause.merge || keys)
+                    .filter(field => !Array.isArray(clause.fields) || !clause.fields.includes(field))
+                    .map((column) => `${this.quote(column)} = tsource.${this.quote(column)}`);
                 this.parts.push(parts.join(', '));
             }
             else if (typeof clause.merge === 'object') {

package/dialects/mysql/MySqlPlatform.js

@@ -81,7 +81,8 @@ export class MySqlPlatform extends AbstractSqlPlatform {
         }
         const indexName = super.getIndexName(tableName, columns, type);
         if (indexName.length > 64) {
-            return `${indexName.substring(0, 56 - type.length)}_${Utils.hash(indexName, 5)}_${type}`;
+            const hashAlgorithm = this.config.get('hashAlgorithm');
+            return `${indexName.substring(0, 56 - type.length)}_${Utils.hash(indexName, 5, hashAlgorithm)}_${type}`;
         }
         return indexName;
     }

package/dialects/sqlite/BaseSqliteConnection.d.ts

@@ -1,5 +1,5 @@
 import { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
 export declare abstract class BaseSqliteConnection extends AbstractSqlConnection {
-    connect(): Promise<void>;
+    connect(simple?: boolean): Promise<void>;
     getClientUrl(): string;
 }

package/dialects/sqlite/BaseSqliteConnection.js

@@ -3,9 +3,15 @@ import { CompiledQuery } from 'kysely';
 import { Utils } from '@mikro-orm/core';
 import { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
 export class BaseSqliteConnection extends AbstractSqlConnection {
-    async connect() {
+    async connect(simple = false) {
         await super.connect();
-        Utils.ensureDir(dirname(this.config.get('dbName')));
+        if (simple) {
+            return;
+        }
+        const dbName = this.config.get('dbName');
+        if (dbName && dbName !== ':memory:') {
+            Utils.ensureDir(dirname(this.config.get('dbName')));
+        }
         await this.client.executeQuery(CompiledQuery.raw('pragma foreign_keys = on'));
     }
     getClientUrl() {

package/dialects/sqlite/BaseSqlitePlatform.d.ts

@@ -63,7 +63,6 @@ export declare abstract class BaseSqlitePlatform extends AbstractSqlPlatform {
      */
     processDateProperty(value: unknown): string | number | Date;
     getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence'): string;
-    supportsDownMigrations(): boolean;
     supportsDeferredUniqueConstraints(): boolean;
     getFullTextWhereClause(): string;
     quoteVersionValue(value: Date | number, prop: EntityProperty): Date | string | number;

package/dialects/sqlite/BaseSqlitePlatform.js

@@ -84,10 +84,6 @@ export class BaseSqlitePlatform extends AbstractSqlPlatform {
         }
         return super.getIndexName(tableName, columns, type);
     }
-    // TODO enable once tests are green
-    supportsDownMigrations() {
-        return false;
-    }
     supportsDeferredUniqueConstraints() {
         return false;
     }

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -167,7 +167,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
             if (col.hidden > 1) {
                 /* v8 ignore next */
                 const storage = col.hidden === 2 ? 'virtual' : 'stored';
-                const re = `(generated always)? as \\((.*)\\)( ${storage})?$`;
+                const re = new RegExp(`(generated always)? as \\((.*)\\)( ${storage})?$`, 'i');
                 const match = columnDefinitions[col.name].definition.match(re);
                 if (match) {
                     generated = `${match[2]} ${storage}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "7.0.0-dev.3",
+  "version": "7.0.0-dev.31",
   "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.",
   "type": "module",
   "exports": {
@@ -50,13 +50,13 @@
     "access": "public"
   },
   "dependencies": {
-    "kysely": "https://pkg.pr.new/kysely-org/kysely/kysely@2b7007e",
+    "kysely": "0.28.7",
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.4.5"
+    "@mikro-orm/core": "^6.5.7"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.3"
+    "@mikro-orm/core": "7.0.0-dev.31"
   }
 }

package/query/CriteriaNode.d.ts

@@ -20,7 +20,7 @@ export declare class CriteriaNode<T extends object> implements ICriteriaNode<T>
     shouldInline(payload: any): boolean;
     willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;
     shouldRename(payload: any): boolean;
-    renameFieldToPK<T>(qb: IQueryBuilder<T>): string;
+    renameFieldToPK<T>(qb: IQueryBuilder<T>, ownerAlias?: string): string;
     getPath(addIndex?: boolean): string;
     private isPivotJoin;
     getPivotPath(path: string): string;

package/query/CriteriaNode.js

@@ -65,20 +65,16 @@ export class CriteriaNode {
             default: return false;
         }
     }
-    renameFieldToPK(qb) {
-        let joinAlias = qb.getAliasForJoinPath(this.getPath());
+    renameFieldToPK(qb, ownerAlias) {
+        const joinAlias = qb.getAliasForJoinPath(this.getPath(), { matchPopulateJoins: true });
         if (!joinAlias && this.parent && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind) && this.prop.owner) {
-            joinAlias = qb.getAliasForJoinPath(this.parent.getPath());
-            return Utils.getPrimaryKeyHash(this.prop.joinColumns.map(col => `${joinAlias ?? qb.alias}.${col}`));
+            const alias = qb.getAliasForJoinPath(this.parent.getPath()) ?? ownerAlias ?? qb.alias;
+            return Utils.getPrimaryKeyHash(this.prop.joinColumns.map(col => `${alias}.${col}`));
         }
-        const alias = joinAlias ?? qb.alias;
+        const alias = joinAlias ?? ownerAlias ?? qb.alias;
         if (this.prop.kind === ReferenceKind.MANY_TO_MANY) {
             return Utils.getPrimaryKeyHash(this.prop.inverseJoinColumns.map(col => `${alias}.${col}`));
         }
-        // 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 Utils.getPrimaryKeyHash(this.prop.joinColumns.map(col => `${alias}.${col}`));
-        }
         return Utils.getPrimaryKeyHash(this.prop.referencedColumnNames.map(col => `${alias}.${col}`));
     }
     getPath(addIndex = false) {

package/query/CriteriaNodeFactory.js

@@ -46,10 +46,14 @@ export class CriteriaNodeFactory {
     static createObjectItemNode(metadata, entityName, node, payload, key, meta) {
         const prop = meta?.properties[key];
         const childEntity = prop && prop.kind !== ReferenceKind.SCALAR ? prop.type : entityName;
-        if (prop?.customType instanceof JsonType) {
+        const isNotEmbedded = prop?.kind !== ReferenceKind.EMBEDDED;
+        if (isNotEmbedded && prop?.customType instanceof JsonType) {
             return this.createScalarNode(metadata, childEntity, payload[key], node, key);
         }
-        if (prop?.kind !== ReferenceKind.EMBEDDED) {
+        if (prop?.kind === ReferenceKind.SCALAR && payload[key] != null && Object.keys(payload[key]).some(f => Utils.isGroupOperator(f))) {
+            throw ValidationError.cannotUseGroupOperatorsInsideScalars(entityName, prop.name, payload);
+        }
+        if (isNotEmbedded) {
             return this.createNode(metadata, childEntity, payload[key], node, key);
         }
         if (payload[key] == null) {
@@ -66,11 +70,12 @@ export class CriteriaNodeFactory {
             throw ValidationError.cannotUseOperatorsInsideEmbeddables(entityName, prop.name, payload);
         }
         const map = Object.keys(payload[key]).reduce((oo, k) => {
-            if (!prop.embeddedProps[k] && !allowedOperators.includes(k)) {
+            const embeddedProp = prop.embeddedProps[k] ?? Object.values(prop.embeddedProps).find(p => p.name === k);
+            if (!embeddedProp && !allowedOperators.includes(k)) {
                 throw ValidationError.invalidEmbeddableQuery(entityName, k, prop.type);
             }
-            if (prop.embeddedProps[k]) {
-                oo[prop.embeddedProps[k].name] = payload[key][k];
+            if (embeddedProp) {
+                oo[embeddedProp.name] = payload[key][k];
             }
             else if (typeof payload[key][k] === 'object') {
                 oo[k] = JSON.stringify(payload[key][k]);

package/query/NativeQueryBuilder.js

@@ -261,7 +261,7 @@ export class NativeQueryBuilder {
         }
         if (this.options.where?.sql.trim()) {
             this.parts.push(`where ${this.options.where.sql}`);
-            this.params.push(...this.options.where.params);
+            this.options.where.params.forEach(p => this.params.push(p));
         }
         if (this.options.groupBy) {
             const fields = this.options.groupBy.map(field => this.quote(field));

package/query/ObjectCriteriaNode.js

@@ -6,7 +6,8 @@ import { JoinType, QueryType } from './enums.js';
  */
 export class ObjectCriteriaNode extends CriteriaNode {
     process(qb, options) {
-        const nestedAlias = qb.getAliasForJoinPath(this.getPath(), options);
+        const matchPopulateJoins = options?.matchPopulateJoins || (this.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind));
+        const nestedAlias = qb.getAliasForJoinPath(this.getPath(), { ...options, matchPopulateJoins });
         const ownerAlias = options?.alias || qb.alias;
         const keys = Object.keys(this.payload);
         let alias = options?.alias;
@@ -55,7 +56,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
                 }
                 return { $and };
             }
-            alias = this.autoJoin(qb, ownerAlias);
+            alias = this.autoJoin(qb, ownerAlias, options);
         }
         return keys.reduce((o, field) => {
             const childNode = this.payload[field];
@@ -66,13 +67,14 @@ export class ObjectCriteriaNode extends CriteriaNode {
             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);
+            const isToOne = childNode.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(childNode.prop.kind);
             if (childNode.shouldInline(payload)) {
-                const childAlias = qb.getAliasForJoinPath(childNode.getPath(), options);
+                const childAlias = qb.getAliasForJoinPath(childNode.getPath(), { preferNoBranch: isToOne, ...options });
                 const a = qb.helper.isTableNameAliasRequired(qb.type) ? alias : undefined;
                 this.inlineChildPayload(o, payload, field, a, childAlias);
             }
             else if (childNode.shouldRename(payload)) {
-                this.inlineCondition(childNode.renameFieldToPK(qb), o, payload);
+                this.inlineCondition(childNode.renameFieldToPK(qb, alias), o, payload);
             }
             else if (isRawField) {
                 const rawField = RawQueryFragment.getKnownFragment(field);
@@ -193,23 +195,44 @@ export class ObjectCriteriaNode extends CriteriaNode {
         });
         return !primaryKeys && !nestedAlias && !operatorKeys && !embeddable;
     }
-    autoJoin(qb, alias) {
+    autoJoin(qb, alias, options) {
         const nestedAlias = qb.getNextAlias(this.prop?.pivotTable ?? this.entityName);
         const customExpression = RawQueryFragment.isKnownFragment(this.key);
         const scalar = Utils.isPrimaryKey(this.payload) || this.payload instanceof RegExp || this.payload instanceof Date || customExpression;
         const operator = Utils.isPlainObject(this.payload) && Object.keys(this.payload).every(k => Utils.isOperator(k, false));
         const field = `${alias}.${this.prop.name}`;
         const method = qb.hasFlag(QueryFlag.INFER_POPULATE) ? 'joinAndSelect' : 'join';
+        const path = this.getPath();
         if (this.prop.kind === ReferenceKind.MANY_TO_MANY && (scalar || operator)) {
-            qb.join(field, nestedAlias, undefined, JoinType.pivotJoin, this.getPath());
+            qb.join(field, nestedAlias, undefined, JoinType.pivotJoin, path);
         }
         else {
             const prev = qb._fields?.slice();
-            qb[method](field, nestedAlias, undefined, JoinType.leftJoin, this.getPath());
+            const toOneProperty = [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind);
+            const joinType = toOneProperty && !this.prop.nullable
+                ? JoinType.innerJoin
+                : JoinType.leftJoin;
+            qb[method](field, nestedAlias, undefined, joinType, path);
+            // if the property is nullable, we need to use left join, so we mimic the inner join behaviour
+            // with an exclusive condition on the join columns:
+            // - if the owning column is null, the row is missing, we don't apply the filter
+            // - if the target column is not null, the row is matched, we apply the filter
+            if (toOneProperty && this.prop.nullable && options?.filter) {
+                const key = this.prop.owner ? this.prop.name : this.prop.referencedPKs;
+                qb.andWhere({
+                    $or: [
+                        { [alias + '.' + key]: null },
+                        { [nestedAlias + '.' + Utils.getPrimaryKeyHash(this.prop.referencedPKs)]: { $ne: null } },
+                    ],
+                });
+            }
             if (!qb.hasFlag(QueryFlag.INFER_POPULATE)) {
                 qb._fields = prev;
             }
         }
+        if (!options || options.type !== 'orderBy') {
+            qb.scheduleFilterCheck(path);
+        }
         return nestedAlias;
     }
     isPrefixed(field) {

package/query/QueryBuilder.d.ts

@@ -1,5 +1,5 @@
 import { inspect } from 'node:util';
-import { type AnyEntity, type ConnectionType, type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityName, type EntityProperty, type ExpandProperty, type FlushMode, type GroupOperator, type Loaded, LockMode, type LoggingOptions, type MetadataStorage, type ObjectQuery, PopulateHint, type PopulateOptions, type QBFilterQuery, type QBQueryOrderMap, QueryFlag, type QueryOrderMap, type QueryResult, RawQueryFragment, type RequiredEntityData, type Transaction } from '@mikro-orm/core';
+import { type AnyEntity, type ConnectionType, type Dictionary, type EntityData, type EntityKey, type EntityManager, type EntityMetadata, type EntityName, type EntityProperty, type ExpandProperty, type FlushMode, type GroupOperator, type Loaded, LockMode, type LoggingOptions, type MetadataStorage, type ObjectQuery, PopulateHint, type PopulateOptions, type QBFilterQuery, type QBQueryOrderMap, QueryFlag, type QueryOrderMap, type QueryResult, RawQueryFragment, type RequiredEntityData, type Transaction } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums.js';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver.js';
 import { type Alias, type OnConflictClause, QueryBuilderHelper } from './QueryBuilderHelper.js';
@@ -141,6 +141,15 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * Apply filters to the QB where condition.
      */
     applyFilters(filterOptions?: Dictionary<boolean | Dictionary> | string[] | boolean): Promise<void>;
+    private readonly autoJoinedPaths;
+    /**
+     * @internal
+     */
+    scheduleFilterCheck(path: string): void;
+    /**
+     * @internal
+     */
+    applyJoinedFilters(em: EntityManager, filterOptions?: Dictionary<boolean | Dictionary> | string[] | boolean): Promise<void>;
     withSubQuery(subQuery: RawQueryFragment | NativeQueryBuilder, alias: string): this;
     where(cond: QBFilterQuery<Entity>, operator?: keyof typeof GroupOperator): this;
     where(cond: string, params?: any[], operator?: keyof typeof GroupOperator): this;
@@ -281,6 +290,11 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     processPopulateHint(): void;
     private processPopulateWhere;
     private mergeOnConditions;
+    /**
+     * When adding an inner join on a left joined relation, we need to nest them,
+     * otherwise the inner join could discard rows of the root table.
+     */
+    private processNestedJoins;
     private hasToManyJoins;
     protected wrapPaginateSubQuery(meta: EntityMetadata): void;
     private pruneExtraJoins;