@mikro-orm/knex 7.0.0-dev.2 → 7.0.0-dev.20

package/AbstractSqlConnection.d.ts

@@ -1,11 +1,11 @@
 import { type ControlledTransaction, type Dialect, Kysely } from 'kysely';
-import { type AnyEntity, Connection, type Dictionary, type EntityData, type IsolationLevel, type LoggingOptions, type QueryResult, RawQueryFragment, type Transaction, type TransactionEventBroadcaster } from '@mikro-orm/core';
+import { type AnyEntity, Connection, type Dictionary, type EntityData, type IsolationLevel, type LoggingOptions, type MaybePromise, type QueryResult, RawQueryFragment, type Transaction, type TransactionEventBroadcaster } from '@mikro-orm/core';
 import type { AbstractSqlPlatform } from './AbstractSqlPlatform.js';
 import { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
 export declare abstract class AbstractSqlConnection extends Connection {
     protected platform: AbstractSqlPlatform;
     protected client: Kysely<any>;
-    abstract createKyselyDialect(overrides: Dictionary): Dialect;
+    abstract createKyselyDialect(overrides: Dictionary): MaybePromise<Dialect>;
     connect(): Promise<void>;
     /**
      * @inheritDoc

package/AbstractSqlConnection.js

@@ -19,8 +19,7 @@ export class AbstractSqlConnection extends Connection {
         }
         else {
             this.client = new Kysely({
-                dialect: this.createKyselyDialect(driverOptions),
-                // log: m => console.log(m),
+                dialect: await this.createKyselyDialect(driverOptions),
             });
         }
         this.connected = true;
@@ -73,14 +72,17 @@ export class AbstractSqlConnection extends Connection {
     async begin(options = {}) {
         if (options.ctx) {
             const ctx = options.ctx;
+            await options.eventBroadcaster?.dispatchEvent(EventType.beforeTransactionStart, ctx);
             ctx.index ??= 0;
             const savepointName = `trx${ctx.index + 1}`;
             const trx = await options.ctx.savepoint(savepointName).execute();
             Reflect.defineProperty(trx, 'index', { value: ctx.index + 1 });
             Reflect.defineProperty(trx, 'savepointName', { value: savepointName });
             this.logQuery(this.platform.getSavepointSQL(savepointName));
+            await options.eventBroadcaster?.dispatchEvent(EventType.afterTransactionStart, trx);
             return trx;
         }
+        await this.ensureConnection();
         await options.eventBroadcaster?.dispatchEvent(EventType.beforeTransactionStart);
         let trxBuilder = this.client.startTransaction();
         if (options.isolationLevel) {
@@ -100,25 +102,27 @@ export class AbstractSqlConnection extends Connection {
         if (ctx.isRolledBack) {
             return;
         }
+        await eventBroadcaster?.dispatchEvent(EventType.beforeTransactionCommit, ctx);
         if ('savepointName' in ctx) {
             await ctx.releaseSavepoint(ctx.savepointName).execute();
             this.logQuery(this.platform.getReleaseSavepointSQL(ctx.savepointName));
-            return;
         }
-        await eventBroadcaster?.dispatchEvent(EventType.beforeTransactionCommit, ctx);
-        await ctx.commit().execute();
-        this.logQuery(this.platform.getCommitTransactionSQL());
+        else {
+            await ctx.commit().execute();
+            this.logQuery(this.platform.getCommitTransactionSQL());
+        }
         await eventBroadcaster?.dispatchEvent(EventType.afterTransactionCommit, ctx);
     }
     async rollback(ctx, eventBroadcaster) {
+        await eventBroadcaster?.dispatchEvent(EventType.beforeTransactionRollback, ctx);
         if ('savepointName' in ctx) {
             await ctx.rollbackToSavepoint(ctx.savepointName).execute();
             this.logQuery(this.platform.getRollbackToSavepointSQL(ctx.savepointName));
-            return;
         }
-        await eventBroadcaster?.dispatchEvent(EventType.beforeTransactionRollback, ctx);
-        await ctx.rollback().execute();
-        this.logQuery(this.platform.getRollbackTransactionSQL());
+        else {
+            await ctx.rollback().execute();
+            this.logQuery(this.platform.getRollbackTransactionSQL());
+        }
         await eventBroadcaster?.dispatchEvent(EventType.afterTransactionRollback, ctx);
     }
     async execute(query, params = [], method = 'all', ctx, loggerContext) {

package/AbstractSqlDriver.d.ts

@@ -14,12 +14,12 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected constructor(config: Configuration, platform: Platform, connection: Constructor<Connection>, connector: string[]);
     getPlatform(): Platform;
     createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
-    find<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
-    findOne<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
+    find<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: string, where: ObjectQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
+    findOne<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: string, where: ObjectQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
     protected hasToManyJoins<T extends object>(hint: PopulateOptions<T>, meta: EntityMetadata<T>): boolean;
-    findVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
-    countVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: CountOptions<T, any>): Promise<number>;
-    protected findFromVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any> | CountOptions<T, any>, type: QueryType): Promise<EntityData<T>[] | number>;
+    findVirtual<T extends object>(entityName: string, where: ObjectQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
+    countVirtual<T extends object>(entityName: string, where: ObjectQuery<T>, options: CountOptions<T, any>): Promise<number>;
+    protected findFromVirtual<T extends object>(entityName: string, where: ObjectQuery<T>, options: FindOptions<T, any> | CountOptions<T, any>, type: QueryType): Promise<EntityData<T>[] | number>;
     protected wrapVirtualExpressionInSubquery<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any>, type: QueryType): Promise<T[] | number>;
     mapResult<T extends object>(result: EntityData<T>, meta: EntityMetadata<T>, populate?: PopulateOptions<T>[], qb?: QueryBuilder<T, any, any, any>, map?: Dictionary): EntityData<T> | null;
     private mapJoinedProps;

package/AbstractSqlDriver.js

@@ -63,6 +63,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (options.lockMode) {
             qb.setLockMode(options.lockMode, options.lockTableAliases);
         }
+        if (options.em) {
+            await qb.applyJoinedFilters(options.em, options.filters);
+        }
         const result = await this.rethrow(qb.execute('all'));
         if (isCursorPagination && !first && !!last) {
             result.reverse();
@@ -252,6 +255,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 : meta2.props.filter(prop => this.platform.shouldHaveColumn(prop, hint.children || []));
             const tz = this.platform.getTimezone();
             for (const prop of targetProps) {
+                if (prop.fieldNames.every(name => typeof root[`${relationAlias}__${name}`] === 'undefined')) {
+                    continue;
+                }
                 if (prop.fieldNames.length > 1) { // composite keys
                     const fk = prop.fieldNames.map(name => root[`${relationAlias}__${name}`]);
                     const pk = Utils.mapFlatCompositePrimaryKey(fk, prop);
@@ -434,7 +440,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     else {
                         const field = prop.fieldNames[0];
                         if (!duplicates.includes(field) || !usedDups.includes(field)) {
-                            if (prop.customType && !prop.object && 'convertToDatabaseValueSQL' in prop.customType && !isRaw(row[prop.name])) {
+                            if (prop.customType && !prop.object && 'convertToDatabaseValueSQL' in prop.customType && row[prop.name] != null && !isRaw(row[prop.name])) {
                                 keys.push(prop.customType.convertToDatabaseValueSQL('?', this.platform));
                             }
                             else {
@@ -585,7 +591,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     if (key in data[idx]) {
                         const pks = Utils.getOrderedPrimaryKeys(cond, meta);
                         sql += ` when (${pkCond}) then `;
-                        if (prop.customType && !prop.object && 'convertToDatabaseValueSQL' in prop.customType && !isRaw(data[idx][key])) {
+                        if (prop.customType && !prop.object && 'convertToDatabaseValueSQL' in prop.customType && data[idx][prop.name] != null && !isRaw(data[idx][key])) {
                             sql += prop.customType.convertToDatabaseValueSQL('?', this.platform);
                         }
                         else {
@@ -725,8 +731,14 @@ export class AbstractSqlDriver extends DatabaseDriver {
             const pivotMeta = this.metadata.find(coll.property.pivotEntity);
             let schema = pivotMeta.schema;
             if (schema === '*') {
-                const ownerSchema = wrapped.getSchema() === '*' ? this.config.get('schema') : wrapped.getSchema();
-                schema = coll.property.owner ? ownerSchema : this.config.get('schema');
+                if (coll.property.owner) {
+                    schema = wrapped.getSchema() === '*' ? options?.schema ?? this.config.get('schema') : wrapped.getSchema();
+                }
+                else {
+                    const targetMeta = coll.property.targetMeta;
+                    const targetSchema = (coll[0] ?? snap?.[0]) && helper(coll[0] ?? snap?.[0]).getSchema();
+                    schema = targetMeta.schema === '*' ? options?.schema ?? targetSchema ?? this.config.get('schema') : targetMeta.schema;
+                }
             }
             else if (schema == null) {
                 schema = this.config.get('schema');
@@ -777,13 +789,15 @@ export class AbstractSqlDriver extends DatabaseDriver {
             const targetSchema = this.getSchemaName(prop.targetMeta, options) ?? this.platform.getDefaultSchemaName();
             qb.innerJoin(pivotProp1.name, targetAlias, {}, targetSchema);
             const targetFields = this.buildFields(prop.targetMeta, (options.populate ?? []), [], qb, targetAlias, options);
+            const additionalFields = [];
             for (const field of targetFields) {
                 const f = field.toString();
-                fields.unshift(f.includes('.') ? field : `${targetAlias}.${f}`);
+                additionalFields.push(f.includes('.') ? field : `${targetAlias}.${f}`);
                 if (RawQueryFragment.isKnownFragment(field)) {
                     qb.rawFragments.add(f);
                 }
             }
+            fields.unshift(...additionalFields);
             // we need to handle 1:1 owner auto-joins explicitly, as the QB type is the pivot table, not the target
             populate.forEach(hint => {
                 const alias = qb.getNextAlias(prop.targetMeta.tableName);
@@ -927,11 +941,11 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const fields = [];
         const populate = options.populate ?? [];
         const joinedProps = this.joinedProps(meta, populate, options);
-        const shouldHaveColumn = (prop, populate, fields) => {
+        const shouldHaveColumn = (meta, prop, populate, fields) => {
             if (!this.platform.shouldHaveColumn(prop, populate, options.exclude)) {
                 return false;
             }
-            if (!fields || fields.includes('*') || prop.primary) {
+            if (!fields || fields.includes('*') || prop.primary || meta.root.discriminatorColumn === prop.name) {
                 return true;
             }
             return fields.some(f => f === prop.name || f.toString().startsWith(prop.name + '.'));
@@ -941,7 +955,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (options.parentJoinPath) {
             // alias all fields in the primary table
             meta.props
-                .filter(prop => shouldHaveColumn(prop, populate, options.explicitFields))
+                .filter(prop => shouldHaveColumn(meta, prop, populate, options.explicitFields))
                 .forEach(prop => fields.push(...this.mapPropToFieldNames(qb, prop, options.parentTableAlias)));
         }
         for (const hint of joinedProps) {
@@ -1289,6 +1303,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
             if (!options.fields.includes('*') && !options.fields.includes(`${qb.alias}.*`)) {
                 ret.unshift(...meta.primaryKeys.filter(pk => !options.fields.includes(pk)));
             }
+            if (meta.root.discriminatorColumn && !options.fields.includes(`${qb.alias}.${meta.root.discriminatorColumn}`)) {
+                ret.push(meta.root.discriminatorColumn);
+            }
         }
         else if (!Utils.isEmpty(options.exclude) || lazyProps.some(p => !p.formula && (p.kind !== '1:1' || p.owner))) {
             const props = meta.props.filter(prop => this.platform.shouldHaveColumn(prop, populate, options.exclude, false));

package/dialects/mssql/MsSqlNativeQueryBuilder.js

@@ -65,9 +65,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 +82,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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "7.0.0-dev.2",
+  "version": "7.0.0-dev.20",
   "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.2",
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.4.5"
+    "@mikro-orm/core": "^6.4.15"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.2"
+    "@mikro-orm/core": "7.0.0-dev.20"
   }
 }

package/query/CriteriaNode.js

@@ -75,10 +75,6 @@ export class CriteriaNode {
         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/ObjectCriteriaNode.js

@@ -55,7 +55,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];
@@ -193,23 +193,27 @@ 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());
+            qb[method](field, nestedAlias, undefined, JoinType.leftJoin, path);
             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;
@@ -256,10 +265,6 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * Executes the query, returning both array of results and total count query (without offset and limit).
      */
     getResultAndCount(): Promise<[Entity[], 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<Loaded<Entity, Hint>[] | number | QueryResult<Entity>>;
     /**
      * Returns native query builder 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
@@ -303,14 +308,12 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
 export interface RunQueryBuilder<Entity extends object> extends Omit<QueryBuilder<Entity, any, any>, 'getResult' | 'getSingleResult' | 'getResultList' | 'where'> {
     where(cond: QBFilterQuery<Entity> | string, params?: keyof typeof GroupOperator | any[], operator?: keyof typeof GroupOperator): this;
     execute<Result = QueryResult<Entity>>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<Result>;
-    then<TResult1 = QueryResult<Entity>, TResult2 = never>(onfulfilled?: ((value: QueryResult<Entity>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<QueryResult<Entity>>;
 }
 export interface SelectQueryBuilder<Entity extends object = AnyEntity, RootAlias extends string = never, Hint extends string = never, Context extends object = never> extends QueryBuilder<Entity, RootAlias, Hint, Context> {
     execute<Result = Entity[]>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<Result>;
     execute<Result = Entity[]>(method: 'all', mapResults?: boolean): Promise<Result>;
     execute<Result = Entity>(method: 'get', mapResults?: boolean): Promise<Result>;
     execute<Result = QueryResult<Entity>>(method: 'run', mapResults?: boolean): Promise<Result>;
-    then<TResult1 = Entity[], TResult2 = never>(onfulfilled?: ((value: Loaded<Entity, Hint>[]) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<Loaded<Entity, Hint>[]>;
 }
 export interface CountQueryBuilder<Entity extends object> extends QueryBuilder<Entity, any, any> {
     execute<Result = {
@@ -325,7 +328,6 @@ export interface CountQueryBuilder<Entity extends object> extends QueryBuilder<E
     execute<Result = QueryResult<{
         count: number;
     }>>(method: 'run', mapResults?: boolean): Promise<Result>;
-    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 object> extends RunQueryBuilder<T> {
 }

package/query/QueryBuilder.js

@@ -240,9 +240,12 @@ export class QueryBuilder {
             }
         }
         prop.targetMeta.props
-            .filter(prop => explicitFields
-            ? explicitFields.includes(prop.name) || explicitFields.includes(`${alias}.${prop.name}`) || prop.primary
-            : this.platform.shouldHaveColumn(prop, populate))
+            .filter(prop => {
+            if (!explicitFields) {
+                return this.platform.shouldHaveColumn(prop, populate);
+            }
+            return prop.primary && !explicitFields.includes(prop.name) && !explicitFields.includes(`${alias}.${prop.name}`);
+        })
             .forEach(prop => fields.push(...this.driver.mapPropToFieldNames(this, prop, alias)));
         return fields;
     }
@@ -257,6 +260,40 @@ export class QueryBuilder {
         const cond = await this.em.applyFilters(this.mainAlias.entityName, {}, filterOptions, 'read');
         this.andWhere(cond);
     }
+    autoJoinedPaths = [];
+    /**
+     * @internal
+     */
+    scheduleFilterCheck(path) {
+        this.autoJoinedPaths.push(path);
+    }
+    /**
+     * @internal
+     */
+    async applyJoinedFilters(em, filterOptions = {}) {
+        for (const path of this.autoJoinedPaths) {
+            const join = this.getJoinForPath(path);
+            if (join.type === JoinType.pivotJoin) {
+                continue;
+            }
+            const cond = await em.applyFilters(join.prop.type, join.cond, filterOptions, 'read');
+            if (Utils.hasObjectKeys(cond)) {
+                // remove nested filters, we only care about scalars here, nesting would require another join branch
+                for (const key of Object.keys(cond)) {
+                    if (Utils.isPlainObject(cond[key]) && Object.keys(cond[key]).every(k => !(Utils.isOperator(k) && !['$some', '$none', '$every'].includes(k)))) {
+                        delete cond[key];
+                    }
+                }
+                if (Utils.hasObjectKeys(join.cond)) {
+                    /* istanbul ignore next */
+                    join.cond = { $and: [join.cond, cond] };
+                }
+                else {
+                    join.cond = { ...cond };
+                }
+            }
+        }
+    }
     withSubQuery(subQuery, alias) {
         this.ensureNotFinalized();
         if (subQuery instanceof RawQueryFragment) {
@@ -335,7 +372,7 @@ export class QueryBuilder {
                 convertCustomTypes: false,
                 type: 'orderBy',
             });
-            this._orderBy.push(CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, processed).process(this, { matchPopulateJoins: true }));
+            this._orderBy.push(CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, processed).process(this, { matchPopulateJoins: true, type: 'orderBy' }));
         });
         return this;
     }
@@ -647,7 +684,7 @@ export class QueryBuilder {
         }
         const query = this.toQuery();
         const cached = await this.em?.tryCache(this.mainAlias.entityName, this._cache, ['qb.execute', query.sql, query.params, method]);
-        if (cached?.data) {
+        if (cached?.data !== undefined) {
             return cached.data;
         }
         const write = method === 'run' || !this.platform.getConfig().get('preferReadReplicas');
@@ -753,26 +790,6 @@ export class QueryBuilder {
             await this.clone().getCount(),
         ];
     }
-    /**
-     * Provides promise-like interface so we can await the QB instance.
-     */
-    then(onfulfilled, onrejected) {
-        let type = this.type;
-        if (this.flags.has(QueryFlag.UPDATE_SUB_QUERY) || this.flags.has(QueryFlag.DELETE_SUB_QUERY)) {
-            type = QueryType.UPDATE;
-        }
-        switch (type) {
-            case QueryType.INSERT:
-            case QueryType.UPDATE:
-            case QueryType.DELETE:
-            case QueryType.UPSERT:
-            case QueryType.TRUNCATE:
-                return this.execute('run').then(onfulfilled, onrejected);
-            case QueryType.COUNT:
-                return this.getCount().then(onfulfilled, onrejected);
-            case QueryType.SELECT: return this.getResultList().then(onfulfilled, onrejected);
-        }
-    }
     /**
      * Returns native query builder 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
@@ -1158,6 +1175,7 @@ export class QueryBuilder {
                 this._joins[aliasedName] = this.helper.joinOneToReference(prop, this.mainAlias.aliasName, alias, JoinType.leftJoin);
                 this._joins[aliasedName].path = `${(Object.values(this._joins).find(j => j.alias === fromAlias)?.path ?? meta.className)}.${prop.name}`;
                 this._populateMap[aliasedName] = this._joins[aliasedName].alias;
+                this.createAlias(prop.type, alias);
             }
         });
         this.processPopulateWhere(false);
@@ -1172,7 +1190,7 @@ export class QueryBuilder {
         let joins = Object.values(this._joins);
         for (const join of joins) {
             join.cond_ ??= join.cond;
-            join.cond = filter ? { ...join.cond } : {};
+            join.cond = { ...join.cond };
         }
         if (typeof this[key] === 'object') {
             const cond = CriteriaNodeFactory
@@ -1219,9 +1237,7 @@ export class QueryBuilder {
         }
     }
     hasToManyJoins() {
-        // console.log(this._joins);
         return Object.values(this._joins).some(join => {
-            // console.log(join.prop.name, join.prop.kind, [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(join.prop.kind));
             return [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(join.prop.kind);
         });
     }

package/query/QueryBuilderHelper.js

@@ -39,9 +39,6 @@ export class QueryBuilderHelper {
                 const prop = this.getProperty(f, a);
                 const fkIdx2 = prop?.fieldNames.findIndex(name => name === f) ?? -1;
                 if (fkIdx2 !== -1) {
-                    if (prop?.ownColumns && !prop.ownColumns.includes(f)) {
-                        continue;
-                    }
                     parts.push(this.mapper(a !== this.alias ? `${a}.${prop.fieldNames[fkIdx2]}` : prop.fieldNames[fkIdx2], type, value, alias));
                 }
                 else if (prop) {
@@ -62,9 +59,6 @@ export class QueryBuilderHelper {
                     }
                 });
             }
-            if (parts.length === 1) {
-                return parts[0];
-            }
             return raw('(' + parts.map(part => this.platform.quoteIdentifier(part)).join(', ') + ')');
         }
         const rawField = RawQueryFragment.getKnownFragment(field);
@@ -257,6 +251,105 @@ export class QueryBuilderHelper {
         }
         return { sql, params };
     }
+    // <<<<<<< HEAD
+    //   private processJoinClause(key: string, value: unknown, alias: string, params: Knex.Value[], operator = '$eq'): string {
+    //     if (Utils.isGroupOperator(key) && Array.isArray(value)) {
+    //       const parts = value.map(sub => {
+    //         return this.wrapQueryGroup(Object.keys(sub).map(k => this.processJoinClause(k, sub[k], alias, params)));
+    //       });
+    //       return this.wrapQueryGroup(parts, key);
+    //     }
+    //
+    //     const rawField = RawQueryFragment.getKnownFragment(key);
+    //
+    //     if (!rawField && !Utils.isOperator(key, false) && !this.isPrefixed(key)) {
+    //       key = `${alias}.${key}`;
+    //     }
+    //
+    //     if (this.isSimpleRegExp(value)) {
+    //       params.push(this.getRegExpParam(value));
+    //       return `${this.knex.ref(this.mapper(key))} like ?`;
+    //     }
+    //
+    //     if (value instanceof RegExp) {
+    //       value = this.platform.getRegExpValue(value);
+    //     }
+    //
+    //     if (Utils.isOperator(key, false) && Utils.isPlainObject(value)) {
+    //       const parts = Object.keys(value).map(k => this.processJoinClause(k, (value as Dictionary)[k], alias, params, key));
+    //
+    //       return key === '$not' ? `not ${this.wrapQueryGroup(parts)}` : this.wrapQueryGroup(parts);
+    //     }
+    //
+    //     if (Utils.isPlainObject(value) && Object.keys(value).every(k => Utils.isOperator(k, false))) {
+    //       const parts = Object.keys(value).map(op => this.processJoinClause(key, (value as Dictionary)[op], alias, params, op));
+    //
+    //       return this.wrapQueryGroup(parts);
+    //     }
+    //
+    //     const [fromAlias, fromField] = this.splitField(key as EntityKey);
+    //     const prop = this.getProperty(fromField, fromAlias);
+    //     operator = operator === '$not' ? '$eq' : operator;
+    //     const column = this.mapper(key, undefined, undefined, null);
+    //
+    //     if (value === null) {
+    //       return `${this.knex.ref(column)} is ${operator === '$ne' ? 'not ' : ''}null`;
+    //     }
+    //
+    //     if (operator === '$fulltext' && prop) {
+    //       const query = this.knex.raw(this.platform.getFullTextWhereClause(prop), {
+    //         column,
+    //         query: this.knex.raw('?'),
+    //       }).toSQL().toNative();
+    //       params.push(value as Knex.Value);
+    //
+    //       return query.sql;
+    //     }
+    //
+    //     const replacement = this.getOperatorReplacement(operator, { [operator]: value });
+    //
+    //     if (['$in', '$nin'].includes(operator) && Array.isArray(value)) {
+    //       params.push(...value as Knex.Value[]);
+    //       return `${this.knex.ref(column)} ${replacement} (${value.map(() => '?').join(', ')})`;
+    //     }
+    //
+    //     if (operator === '$exists') {
+    //       value = null;
+    //     }
+    //
+    //     if (rawField) {
+    //       let sql = rawField.sql.replaceAll(ALIAS_REPLACEMENT, alias);
+    //       params.push(...rawField.params as Knex.Value[]);
+    //       params.push(...Utils.asArray(value) as Knex.Value[]);
+    //
+    //       if ((Utils.asArray(value) as Knex.Value[]).length > 0) {
+    //         sql += ' = ?';
+    //       }
+    //
+    //       return sql;
+    //     }
+    //
+    //     if (value !== null) {
+    //       if (prop?.customType) {
+    //         value = prop.customType.convertToDatabaseValue(value, this.platform, { fromQuery: true, key, mode: 'query' });
+    //       }
+    //
+    //       params.push(value as Knex.Value);
+    //     }
+    //
+    //     return `${this.knex.ref(column)} ${replacement} ${value === null ? 'null' : '?'}`;
+    //   }
+    //
+    //   private wrapQueryGroup(parts: string[], operator = '$and') {
+    //     if (parts.length === 1) {
+    //       return parts[0];
+    //     }
+    //
+    //     return `(${parts.join(` ${GroupOperator[operator as keyof typeof GroupOperator]} `)})`;
+    //   }
+    //
+    //   mapJoinColumns(type: QueryType, join: JoinOptions): (string | Knex.Raw)[] {
+    // =======
     mapJoinColumns(type, join) {
         if (join.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(join.prop.kind)) {
             return join.prop.fieldNames.map((_fieldName, idx) => {
@@ -473,8 +566,8 @@ export class QueryBuilderHelper {
             parts.push(sql);
             params.push(...params2);
         }
-        else if (op === '$in' && Array.isArray(value[op]) && value[op].length === 0) {
-            parts.push(`1 = 0`);
+        else if (['$in', '$nin'].includes(op) && Array.isArray(value[op]) && value[op].length === 0) {
+            parts.push(`1 = ${op === '$in' ? 0 : 1}`);
         }
         else if (value[op] instanceof RawQueryFragment || value[op] instanceof NativeQueryBuilder) {
             const query = value[op] instanceof NativeQueryBuilder ? value[op].toRaw() : value[op];

package/schema/DatabaseTable.js

@@ -97,11 +97,14 @@ export class DatabaseTable {
                 ignoreSchemaChanges: prop.ignoreSchemaChanges,
             };
             this.columns[field].unsigned ??= this.columns[field].autoincrement;
+            if (this.nativeEnums[type]) {
+                this.columns[field].enumItems ??= this.nativeEnums[type].items;
+            }
             const defaultValue = this.platform.getSchemaHelper().normalizeDefaultValue(prop.defaultRaw, prop.length);
             this.columns[field].default = defaultValue;
         });
         if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
-            const constraintName = this.getIndexName(true, prop.fieldNames, 'foreign');
+            const constraintName = this.getIndexName(prop.foreignKeyName ?? true, prop.fieldNames, 'foreign');
             let schema = prop.targetMeta.root.schema === '*' ? this.schema : (prop.targetMeta.root.schema ?? config.get('schema', this.platform.getDefaultSchemaName()));
             if (prop.referencedTableName.includes('.')) {
                 schema = undefined;
@@ -699,16 +702,28 @@ export class DatabaseTable {
     }
     addIndex(meta, index, type) {
         const properties = Utils.unique(Utils.flatten(Utils.asArray(index.properties).map(prop => {
-            const root = prop.replace(/\..+$/, '');
+            const parts = prop.split('.');
+            const root = parts[0];
             if (meta.properties[prop]) {
                 if (meta.properties[prop].embeddedPath) {
                     return [meta.properties[prop].embeddedPath.join('.')];
                 }
                 return meta.properties[prop].fieldNames;
             }
+            const rootProp = meta.properties[root];
+            // inline embedded property index, we need to find the field name of the child property
+            if (rootProp?.embeddable && !rootProp.object && parts.length > 1) {
+                const expand = (p, i) => {
+                    if (parts.length === i) {
+                        return p.fieldNames[0];
+                    }
+                    return expand(p.embeddedProps[parts[i]], i + 1);
+                };
+                return [expand(rootProp, 1)];
+            }
             // json index, we need to rename the column only
-            if (meta.properties[root]) {
-                return [prop.replace(root, meta.properties[root].fieldNames[0])];
+            if (rootProp) {
+                return [prop.replace(root, rootProp.fieldNames[0])];
             }
             /* v8 ignore next */
             return [prop];

package/schema/SchemaHelper.js

@@ -119,9 +119,8 @@ export class SchemaHelper {
                 }
             }
             Utils.removeDuplicates(changedNativeEnums).forEach(([enumName, itemsNew, itemsOld]) => {
-                // postgres allows only adding new items, the values are case insensitive
-                itemsOld = itemsOld.map(v => v.toLowerCase());
-                const newItems = itemsNew.filter(val => !itemsOld.includes(val.toLowerCase()));
+                // postgres allows only adding new items
+                const newItems = itemsNew.filter(val => !itemsOld.includes(val));
                 if (enumName.includes('.')) {
                     const [enumSchemaName, rawEnumName] = enumName.split('.');
                     ret.push(...newItems.map(val => this.getAlterNativeEnumSQL(rawEnumName, enumSchemaName, val, itemsNew, itemsOld)));

package/schema/SqlSchemaGenerator.js

@@ -103,24 +103,14 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
             return super.clearDatabase(options);
         }
         await this.execute(this.helper.disableForeignKeysSQL());
-        for (const meta of this.getOrderedMetadata(options?.schema).reverse()) {
+        const schema = options?.schema ?? this.config.get('schema', this.platform.getDefaultSchemaName());
+        for (const meta of this.getOrderedMetadata(schema).reverse()) {
             await this.driver.createQueryBuilder(meta.className, this.em?.getTransactionContext(), 'write', false)
-                .withSchema(options?.schema)
-                .truncate();
+                .withSchema(schema)
+                .truncate()
+                .execute();
         }
         await this.execute(this.helper.enableForeignKeysSQL());
-        // const parts: string[] = [this.helper.disableForeignKeysSQL()];
-        //
-        // for (const meta of this.getOrderedMetadata(options?.schema).reverse()) {
-        //   const query = this.driver.createQueryBuilder(meta.className, this.em?.getTransactionContext(), 'write', false)
-        //     .withSchema(options?.schema)
-        //     .truncate()
-        //     .getFormattedQuery();
-        //   parts.push(query);
-        // }
-        //
-        // parts.push(this.helper.enableForeignKeysSQL());
-        // await this.execute(parts.join(';\n'));
         this.clearIdentityMap();
     }
     async getDropSchemaSQL(options = {}) {

package/typings.d.ts

@@ -163,12 +163,14 @@ export interface IQueryBuilder<T> {
     setFlag(flag: QueryFlag): this;
     unsetFlag(flag: QueryFlag): this;
     hasFlag(flag: QueryFlag): boolean;
+    scheduleFilterCheck(path: string): void;
 }
 export interface ICriteriaNodeProcessOptions {
     alias?: string;
     matchPopulateJoins?: boolean;
     ignoreBranching?: boolean;
     preferNoBranch?: boolean;
+    type?: 'orderBy';
 }
 export interface ICriteriaNode<T extends object> {
     readonly entityName: string;