@mikro-orm/knex 6.5.10-dev.1 → 6.5.10-dev.11

package/AbstractSqlDriver.js

@@ -847,10 +847,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
      */
     joinedProps(meta, populate, options) {
         return populate.filter(hint => {
-            const [propName] = hint.field.split(':', 2);
+            const [propName, ref] = hint.field.split(':', 2);
             const prop = meta.properties[propName] || {};
             const strategy = (0, core_1.getLoadingStrategy)(hint.strategy || prop.strategy || options?.strategy || this.config.get('loadStrategy'), prop.kind);
-            if (hint.filter && [core_1.ReferenceKind.ONE_TO_ONE, core_1.ReferenceKind.MANY_TO_ONE].includes(prop.kind) && !prop.nullable) {
+            if (ref && [core_1.ReferenceKind.ONE_TO_ONE, core_1.ReferenceKind.MANY_TO_ONE].includes(prop.kind)) {
                 return true;
             }
             // skip redundant joins for 1:1 owner population hints when using `mapToPk`

package/dialects/postgresql/PostgreSqlTableCompiler.js

@@ -21,7 +21,7 @@ class PostgreSqlTableCompiler extends pg_tablecompiler_1.default {
         }
     }
     addColumn(col) {
-        const options = this.ormConfig.get('schemaGenerator');
+        const options = this.ormConfig?.get('schemaGenerator') ?? {};
         const quotedTableName = this.tableName();
         const type = col.getColumnType();
         const colName = this.client.wrapIdentifier(col.getColumnName(), col.columnBuilder.queryContext());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.5.10-dev.1",
+  "version": "6.5.10-dev.11",
   "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": "index.js",
   "module": "index.mjs",
@@ -66,7 +66,7 @@
     "@mikro-orm/core": "^6.5.9"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.5.10-dev.1",
+    "@mikro-orm/core": "6.5.10-dev.11",
     "better-sqlite3": "*",
     "libsql": "*",
     "mariadb": "*"

package/query/ArrayCriteriaNode.d.ts

@@ -7,4 +7,5 @@ export declare class ArrayCriteriaNode<T extends object> extends CriteriaNode<T>
     process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
     unwrap(): any;
     willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): any;
+    isStrict(): boolean;
 }

package/query/ArrayCriteriaNode.js

@@ -21,5 +21,8 @@ class ArrayCriteriaNode extends CriteriaNode_1.CriteriaNode {
             return node.willAutoJoin(qb, alias, options);
         });
     }
+    isStrict() {
+        return this.strict || this.payload.some((node) => node.isStrict());
+    }
 }
 exports.ArrayCriteriaNode = ArrayCriteriaNode;

package/query/CriteriaNode.d.ts

@@ -11,10 +11,11 @@ export declare class CriteriaNode<T extends object> implements ICriteriaNode<T>
     readonly entityName: string;
     readonly parent?: ICriteriaNode<T> | undefined;
     readonly key?: EntityKey<T> | undefined;
+    readonly strict: boolean;
     payload: any;
     prop?: EntityProperty<T>;
     index?: number;
-    constructor(metadata: MetadataStorage, entityName: string, parent?: ICriteriaNode<T> | undefined, key?: EntityKey<T> | undefined, validate?: boolean);
+    constructor(metadata: MetadataStorage, entityName: string, parent?: ICriteriaNode<T> | undefined, key?: EntityKey<T> | undefined, validate?: boolean, strict?: boolean);
     process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
     unwrap(): any;
     shouldInline(payload: any): boolean;
@@ -25,6 +26,7 @@ export declare class CriteriaNode<T extends object> implements ICriteriaNode<T>
     private isPivotJoin;
     getPivotPath(path: string): string;
     aliased(field: string, alias?: string): string;
+    isStrict(): boolean;
     /** @ignore */
     [inspect.custom](): string;
 }

package/query/CriteriaNode.js

@@ -13,14 +13,16 @@ class CriteriaNode {
     entityName;
     parent;
     key;
+    strict;
     payload;
     prop;
     index;
-    constructor(metadata, entityName, parent, key, validate = true) {
+    constructor(metadata, entityName, parent, key, validate = true, strict = false) {
         this.metadata = metadata;
         this.entityName = entityName;
         this.parent = parent;
         this.key = key;
+        this.strict = strict;
         const meta = parent && metadata.find(parent.entityName);
         if (meta && key) {
             const pks = core_1.Utils.splitPrimaryKeys(key);
@@ -109,6 +111,9 @@ class CriteriaNode {
     aliased(field, alias) {
         return alias ? `${alias}.${field}` : field;
     }
+    isStrict() {
+        return this.strict;
+    }
     /** @ignore */
     [node_util_1.inspect.custom]() {
         const o = {};

package/query/CriteriaNodeFactory.js

@@ -39,7 +39,7 @@ class CriteriaNodeFactory {
     }
     static createObjectNode(metadata, entityName, payload, parent, key) {
         const meta = metadata.find(entityName);
-        const node = new ObjectCriteriaNode_1.ObjectCriteriaNode(metadata, entityName, parent, key);
+        const node = new ObjectCriteriaNode_1.ObjectCriteriaNode(metadata, entityName, parent, key, true, payload.__strict);
         node.payload = Object.keys(payload).reduce((o, item) => {
             o[item] = this.createObjectItemNode(metadata, entityName, node, payload, item, meta);
             return o;

package/query/ObjectCriteriaNode.d.ts

@@ -5,6 +5,7 @@ import type { ICriteriaNodeProcessOptions, IQueryBuilder } from '../typings';
  */
 export declare class ObjectCriteriaNode<T extends object> extends CriteriaNode<T> {
     process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
+    isStrict(): boolean;
     unwrap(): any;
     willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;
     shouldInline(payload: any): boolean;

package/query/ObjectCriteriaNode.js

@@ -61,6 +61,22 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
             }
             alias = this.autoJoin(qb, ownerAlias, options);
         }
+        if (this.prop && nestedAlias) {
+            const toOneProperty = [core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(this.prop.kind);
+            // if the property is nullable and the filter is strict, 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 && this.isStrict()) {
+                const key = this.prop.owner ? this.prop.name : this.prop.referencedPKs;
+                qb.andWhere({
+                    $or: [
+                        { [ownerAlias + '.' + key]: null },
+                        { [nestedAlias + '.' + core_1.Utils.getPrimaryKeyHash(this.prop.referencedPKs)]: { $ne: null } },
+                    ],
+                });
+            }
+        }
         return keys.reduce((o, field) => {
             const childNode = this.payload[field];
             const payload = childNode.process(qb, { ...options, alias: this.prop ? alias : ownerAlias });
@@ -92,6 +108,11 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
             return o;
         }, {});
     }
+    isStrict() {
+        return this.strict || Object.keys(this.payload).some(key => {
+            return this.payload[key].isStrict();
+        });
+    }
     unwrap() {
         return Object.keys(this.payload).reduce((o, field) => {
             o[field] = this.payload[field].unwrap();
@@ -216,19 +237,6 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
                 ? enums_1.JoinType.innerJoin
                 : enums_1.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 + '.' + core_1.Utils.getPrimaryKeyHash(this.prop.referencedPKs)]: { $ne: null } },
-                    ],
-                });
-            }
             if (!qb.hasFlag(core_1.QueryFlag.INFER_POPULATE)) {
                 qb._fields = prev;
             }

package/query/QueryBuilder.js

@@ -572,7 +572,7 @@ class QueryBuilder {
             return this._query.qb = this.knex.raw(qb.toSQL().toNative().sql + ' cascade');
         }
         if (this.lockMode) {
-            this.helper.getLockSQL(qb, this.lockMode, this.lockTables);
+            this.helper.getLockSQL(qb, this.lockMode, this.lockTables, this._joins);
         }
         this.helper.finalize(type, qb, this.mainAlias.metadata, this._data, this._returning);
         this.clearRawFragmentsCache();

package/query/QueryBuilderHelper.d.ts

@@ -51,7 +51,7 @@ export declare class QueryBuilderHelper {
     getQueryOrderFromObject(type: QueryType, orderBy: FlatQueryOrderMap, populate: Dictionary<string>): string[];
     finalize(type: QueryType, qb: Knex.QueryBuilder, meta?: EntityMetadata, data?: Dictionary, returning?: Field<any>[]): void;
     splitField<T>(field: EntityKey<T>, greedyAlias?: boolean): [string, EntityKey<T>, string | undefined];
-    getLockSQL(qb: Knex.QueryBuilder, lockMode: LockMode, lockTables?: string[]): void;
+    getLockSQL(qb: Knex.QueryBuilder, lockMode: LockMode, lockTables?: string[], joinsMap?: Dictionary<JoinOptions>): void;
     updateVersionProperty(qb: Knex.QueryBuilder, data: Dictionary): void;
     private prefix;
     private appendGroupCondition;

package/query/QueryBuilderHelper.js

@@ -629,11 +629,18 @@ class QueryBuilderHelper {
         const fromField = parts.join('.');
         return [fromAlias, fromField, ref];
     }
-    getLockSQL(qb, lockMode, lockTables = []) {
+    getLockSQL(qb, lockMode, lockTables = [], joinsMap) {
         const meta = this.metadata.find(this.entityName);
         if (lockMode === core_1.LockMode.OPTIMISTIC && meta && !meta.versionProperty) {
             throw core_1.OptimisticLockError.lockFailed(this.entityName);
         }
+        if (lockMode !== core_1.LockMode.OPTIMISTIC && lockTables.length === 0 && joinsMap) {
+            const joins = Object.values(joinsMap);
+            const innerJoins = joins.filter(join => [enums_1.JoinType.innerJoin, enums_1.JoinType.innerJoinLateral, enums_1.JoinType.nestedInnerJoin].includes(join.type));
+            if (joins.length > innerJoins.length) {
+                lockTables.push(this.alias, ...innerJoins.map(join => join.alias));
+            }
+        }
         switch (lockMode) {
             case core_1.LockMode.PESSIMISTIC_READ: return void qb.forShare(...lockTables);
             case core_1.LockMode.PESSIMISTIC_WRITE: return void qb.forUpdate(...lockTables);

package/typings.d.ts

@@ -178,6 +178,7 @@ export interface ICriteriaNode<T extends object> {
     readonly entityName: string;
     readonly parent?: ICriteriaNode<T> | undefined;
     readonly key?: string | undefined;
+    readonly strict?: boolean;
     payload: any;
     prop?: EntityProperty;
     index?: number;