@mikro-orm/knex 7.0.0-dev.6 → 7.0.0-dev.8

package/AbstractSqlConnection.js

@@ -81,6 +81,7 @@ export class AbstractSqlConnection extends Connection {
             this.logQuery(this.platform.getSavepointSQL(savepointName));
             return trx;
         }
+        await this.ensureConnection();
         await options.eventBroadcaster?.dispatchEvent(EventType.beforeTransactionStart);
         let trxBuilder = this.client.startTransaction();
         if (options.isolationLevel) {

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();
@@ -437,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 {
@@ -588,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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "7.0.0-dev.6",
+  "version": "7.0.0-dev.8",
   "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": {
@@ -54,9 +54,9 @@
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.4.7"
+    "@mikro-orm/core": "^6.4.9"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.6"
+    "@mikro-orm/core": "7.0.0-dev.8"
   }
 }

package/query/CriteriaNode.js

@@ -69,7 +69,7 @@ export class CriteriaNode {
         let joinAlias = qb.getAliasForJoinPath(this.getPath());
         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.ownColumns.map(col => `${joinAlias ?? qb.alias}.${col}`));
+            return Utils.getPrimaryKeyHash(this.prop.joinColumns.map(col => `${joinAlias ?? qb.alias}.${col}`));
         }
         const alias = joinAlias ?? qb.alias;
         if (this.prop.kind === ReferenceKind.MANY_TO_MANY) {

package/query/ObjectCriteriaNode.js

@@ -200,16 +200,18 @@ export class ObjectCriteriaNode extends CriteriaNode {
         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;
             }
         }
+        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;

package/query/QueryBuilder.js

@@ -257,6 +257,34 @@ 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)) {
+                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) {
@@ -1152,7 +1180,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

package/schema/DatabaseTable.js

@@ -699,16 +699,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/typings.d.ts

@@ -163,6 +163,7 @@ 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;