@mikro-orm/sql 7.0.0-rc.2 → 7.0.0-rc.3

package/package.json

@@ -1,44 +1,44 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.0-rc.2",
+  "version": "7.0.0-rc.3",
   "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": {
-    "./package.json": "./package.json",
-    ".": "./index.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
-  },
   "keywords": [
-    "orm",
+    "data-mapper",
+    "ddd",
+    "entity",
+    "identity-map",
+    "javascript",
+    "js",
+    "mariadb",
+    "mikro-orm",
     "mongo",
     "mongodb",
     "mysql",
-    "mariadb",
+    "orm",
     "postgresql",
     "sqlite",
     "sqlite3",
     "ts",
     "typescript",
-    "js",
-    "javascript",
-    "entity",
-    "ddd",
-    "mikro-orm",
-    "unit-of-work",
-    "data-mapper",
-    "identity-map"
+    "unit-of-work"
   ],
-  "author": "Martin Adámek",
-  "license": "MIT",
+  "homepage": "https://mikro-orm.io",
   "bugs": {
     "url": "https://github.com/mikro-orm/mikro-orm/issues"
   },
-  "homepage": "https://mikro-orm.io",
-  "engines": {
-    "node": ">= 22.17.0"
+  "license": "MIT",
+  "author": "Martin Adámek",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
+  },
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./index.js"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {
     "build": "yarn compile && yarn copy",
@@ -46,16 +46,16 @@
     "compile": "yarn run -T tsc -p tsconfig.build.json",
     "copy": "node ../../scripts/copy.mjs"
   },
-  "publishConfig": {
-    "access": "public"
-  },
   "dependencies": {
     "kysely": "0.28.11"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.6.4"
+    "@mikro-orm/core": "^6.6.8"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-rc.2"
+    "@mikro-orm/core": "7.0.0-rc.3"
+  },
+  "engines": {
+    "node": ">= 22.17.0"
   }
 }

package/plugin/transformer.js

@@ -79,12 +79,8 @@ export class MikroTransformer extends OperationNodeTransformer {
                     }
                 }
             }
-            const nodeWithHooks = this.options.processOnCreateHooks && entityMeta
-                ? this.processOnCreateHooks(node, entityMeta)
-                : node;
-            const nodeWithConvertedValues = this.options.convertValues && entityMeta
-                ? this.processInsertValues(nodeWithHooks, entityMeta)
-                : nodeWithHooks;
+            const nodeWithHooks = this.options.processOnCreateHooks && entityMeta ? this.processOnCreateHooks(node, entityMeta) : node;
+            const nodeWithConvertedValues = this.options.convertValues && entityMeta ? this.processInsertValues(nodeWithHooks, entityMeta) : nodeWithHooks;
             // Handle ON CONFLICT clause
             let finalNode = nodeWithConvertedValues;
             if (node.onConflict?.updates && entityMeta) {
@@ -150,12 +146,8 @@ export class MikroTransformer extends OperationNodeTransformer {
                     this.processJoinNode(join, currentContext);
                 }
             }
-            const nodeWithHooks = this.options.processOnUpdateHooks && entityMeta
-                ? this.processOnUpdateHooks(node, entityMeta)
-                : node;
-            const nodeWithConvertedValues = this.options.convertValues && entityMeta
-                ? this.processUpdateValues(nodeWithHooks, entityMeta)
-                : nodeWithHooks;
+            const nodeWithHooks = this.options.processOnUpdateHooks && entityMeta ? this.processOnUpdateHooks(node, entityMeta) : node;
+            const nodeWithConvertedValues = this.options.convertValues && entityMeta ? this.processUpdateValues(nodeWithHooks, entityMeta) : nodeWithHooks;
             return super.transformUpdateQuery(nodeWithConvertedValues, queryId);
         }
         finally {
@@ -217,7 +209,9 @@ export class MikroTransformer extends OperationNodeTransformer {
         }
         // Transform column names when columnNamingStrategy is 'property'
         // Support ColumnNode, ColumnUpdateNode, and ReferenceNode (for JOIN conditions)
-        if (this.options.columnNamingStrategy === 'property' && parent && (ColumnNode.is(parent) || ColumnUpdateNode.is(parent) || ReferenceNode.is(parent))) {
+        if (this.options.columnNamingStrategy === 'property' &&
+            parent &&
+            (ColumnNode.is(parent) || ColumnUpdateNode.is(parent) || ReferenceNode.is(parent))) {
             const ownerMeta = this.findOwnerEntityInContext();
             if (ownerMeta) {
                 const prop = ownerMeta.properties[node.name];
@@ -480,7 +474,11 @@ export class MikroTransformer extends OperationNodeTransformer {
             }
         }
         if (prop.customType && !isRaw(value)) {
-            return prop.customType.convertToDatabaseValue(value, this.platform, { fromQuery: true, key: prop.name, mode: 'query-data' });
+            return prop.customType.convertToDatabaseValue(value, this.platform, {
+                fromQuery: true,
+                key: prop.name,
+                mode: 'query-data',
+            });
         }
         if (value instanceof Date) {
             return this.platform.processDateProperty(value);
@@ -723,7 +721,9 @@ export class MikroTransformer extends OperationNodeTransformer {
      */
     transformResult(rows, entityMap) {
         // Only transform if columnNamingStrategy is 'property' or convertValues is true, and we have data
-        if ((this.options.columnNamingStrategy !== 'property' && !this.options.convertValues) || !rows || rows.length === 0) {
+        if ((this.options.columnNamingStrategy !== 'property' && !this.options.convertValues) ||
+            !rows ||
+            rows.length === 0) {
             return rows;
         }
         // If no entities found (e.g. raw query without known tables), return rows as is
@@ -870,7 +870,8 @@ export class MikroTransformer extends OperationNodeTransformer {
             }
             // For non-local timezone, check if value already has timezone info
             // Number (timestamp) doesn't need timezone handling, string needs check
-            if (typeof value === 'number' || (typeof value === 'string' && (value.includes('+') || value.lastIndexOf('-') > 10 || value.endsWith('Z')))) {
+            if (typeof value === 'number' ||
+                (typeof value === 'string' && (value.includes('+') || value.lastIndexOf('-') > 10 || value.endsWith('Z')))) {
                 return this.platform.parseDate(value);
             }
             // Append timezone if not present (only for string values)

package/query/CriteriaNode.js

@@ -53,22 +53,34 @@ export class CriteriaNode {
         const type = this.prop ? this.prop.kind : null;
         const composite = this.prop?.joinColumns ? this.prop.joinColumns.length > 1 : false;
         const rawField = RawQueryFragment.isKnownFragmentSymbol(this.key);
-        const scalar = payload === null || Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || rawField;
+        const scalar = payload === null ||
+            Utils.isPrimaryKey(payload) ||
+            payload instanceof RegExp ||
+            payload instanceof Date ||
+            rawField;
         const operator = Utils.isPlainObject(payload) && Utils.getObjectQueryKeys(payload).every(k => Utils.isOperator(k, false));
         if (composite) {
             return true;
         }
         switch (type) {
-            case ReferenceKind.MANY_TO_ONE: return false;
-            case ReferenceKind.ONE_TO_ONE: return !this.prop.owner;
-            case ReferenceKind.ONE_TO_MANY: return scalar || operator;
-            case ReferenceKind.MANY_TO_MANY: return scalar || operator;
-            default: return false;
+            case ReferenceKind.MANY_TO_ONE:
+                return false;
+            case ReferenceKind.ONE_TO_ONE:
+                return !this.prop.owner;
+            case ReferenceKind.ONE_TO_MANY:
+                return scalar || operator;
+            case ReferenceKind.MANY_TO_MANY:
+                return scalar || operator;
+            default:
+                return false;
         }
     }
     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) {
+        if (!joinAlias &&
+            this.parent &&
+            [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind) &&
+            this.prop.owner) {
             const alias = qb.getAliasForJoinPath(this.parent.getPath()) ?? ownerAlias ?? qb.alias;
             return Utils.getPrimaryKeyHash(this.prop.joinColumns.map(col => `${alias}.${col}`));
         }
@@ -84,7 +96,9 @@ export class CriteriaNode {
         const parentPath = opts?.parentPath ?? this.parent?.getPath({ addIndex: addParentIndex }) ?? Utils.className(this.entityName);
         const index = opts?.addIndex && this.index != null ? `[${this.index}]` : '';
         // ignore group operators to allow easier mapping (e.g. for orderBy)
-        const key = this.key && !RawQueryFragment.isKnownFragmentSymbol(this.key) && !['$and', '$or', '$not'].includes(this.key) ? '.' + this.key : '';
+        const key = this.key && !RawQueryFragment.isKnownFragmentSymbol(this.key) && !['$and', '$or', '$not'].includes(this.key)
+            ? '.' + this.key
+            : '';
         const ret = parentPath + index + key;
         if (this.isPivotJoin()) {
             // distinguish pivot table join from target entity join
@@ -97,7 +111,11 @@ export class CriteriaNode {
             return false;
         }
         const rawField = RawQueryFragment.isKnownFragmentSymbol(this.key);
-        const scalar = this.payload === null || Utils.isPrimaryKey(this.payload) || this.payload instanceof RegExp || this.payload instanceof Date || rawField;
+        const scalar = this.payload === null ||
+            Utils.isPrimaryKey(this.payload) ||
+            this.payload instanceof RegExp ||
+            this.payload instanceof Date ||
+            rawField;
         const operator = Utils.isObject(this.payload) && Utils.getObjectQueryKeys(this.payload).every(k => Utils.isOperator(k, false));
         return this.prop.kind === ReferenceKind.MANY_TO_MANY && (scalar || operator);
     }
@@ -116,7 +134,7 @@ export class CriteriaNode {
         const o = {};
         ['entityName', 'key', 'index', 'payload']
             .filter(k => this[k] !== undefined)
-            .forEach(k => o[k] = this[k]);
+            .forEach(k => (o[k] = this[k]));
         return `${this.constructor.name} ${inspect(o)}`;
     }
 }

package/query/CriteriaNodeFactory.js

@@ -8,7 +8,11 @@ import { ScalarCriteriaNode } from './ScalarCriteriaNode.js';
 export class CriteriaNodeFactory {
     static createNode(metadata, entityName, payload, parent, key, validate = true) {
         const rawField = RawQueryFragment.isKnownFragmentSymbol(key);
-        const scalar = Utils.isPrimaryKey(payload) || isRaw(payload) || payload instanceof RegExp || payload instanceof Date || rawField;
+        const scalar = Utils.isPrimaryKey(payload) ||
+            isRaw(payload) ||
+            payload instanceof RegExp ||
+            payload instanceof Date ||
+            rawField;
         if (Array.isArray(payload) && !scalar) {
             return this.createArrayNode(metadata, entityName, payload, parent, key, validate);
         }

package/query/NativeQueryBuilder.d.ts

@@ -1,6 +1,17 @@
 import { type Dictionary, LockMode, type QueryFlag, RawQueryFragment, type Subquery } from '@mikro-orm/core';
 import { QueryType } from './enums.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
+export interface CteOptions {
+    columns?: string[];
+    /** PostgreSQL: MATERIALIZED / NOT MATERIALIZED */
+    materialized?: boolean;
+}
+interface CteClause extends CteOptions {
+    name: string;
+    sql: string;
+    params: unknown[];
+    recursive?: boolean;
+}
 interface Options {
     tableName?: string | RawQueryFragment;
     indexHint?: string;
@@ -32,6 +43,7 @@ interface Options {
     hintComment?: string[];
     flags?: Set<QueryFlag>;
     wrap?: [prefix: string, suffix: string];
+    ctes?: CteClause[];
 }
 interface TableOptions {
     schema?: string;
@@ -65,6 +77,17 @@ export declare class NativeQueryBuilder implements Subquery {
     groupBy(groupBy: (string | RawQueryFragment)[]): this;
     join(sql: string, params: unknown[]): this;
     orderBy(orderBy: string): this;
+    /**
+     * The sub-query is compiled eagerly at call time — later mutations to the
+     * sub-query builder will not be reflected in this CTE.
+     */
+    with(name: string, query: NativeQueryBuilder | RawQueryFragment, options?: CteOptions): this;
+    /**
+     * Adds a recursive CTE (`WITH RECURSIVE` on PostgreSQL/MySQL/SQLite, plain `WITH` on MSSQL).
+     * The sub-query is compiled eagerly — later mutations will not be reflected.
+     */
+    withRecursive(name: string, query: NativeQueryBuilder | RawQueryFragment, options?: CteOptions): this;
+    private addCte;
     toString(): string;
     compile(): {
         sql: string;
@@ -103,6 +126,8 @@ export declare class NativeQueryBuilder implements Subquery {
     protected compileDelete(): void;
     protected compileTruncate(): void;
     protected addHintComment(): void;
+    protected compileCtes(): void;
+    protected getCteKeyword(hasRecursive: boolean): string;
     protected getTableName(): string;
     protected quote(id: string | RawQueryFragment | NativeQueryBuilder): string;
 }

package/query/NativeQueryBuilder.js

@@ -1,4 +1,4 @@
-import { LockMode, raw, RawQueryFragment, Utils } from '@mikro-orm/core';
+import { LockMode, raw, RawQueryFragment, Utils, } from '@mikro-orm/core';
 import { QueryType } from './enums.js';
 /** @internal */
 export class NativeQueryBuilder {
@@ -59,6 +59,36 @@ export class NativeQueryBuilder {
         this.options.orderBy = orderBy;
         return this;
     }
+    /**
+     * The sub-query is compiled eagerly at call time — later mutations to the
+     * sub-query builder will not be reflected in this CTE.
+     */
+    with(name, query, options) {
+        return this.addCte(name, query, options);
+    }
+    /**
+     * Adds a recursive CTE (`WITH RECURSIVE` on PostgreSQL/MySQL/SQLite, plain `WITH` on MSSQL).
+     * The sub-query is compiled eagerly — later mutations will not be reflected.
+     */
+    withRecursive(name, query, options) {
+        return this.addCte(name, query, options, true);
+    }
+    addCte(name, query, options, recursive) {
+        this.options.ctes ??= [];
+        if (this.options.ctes.some(cte => cte.name === name)) {
+            throw new Error(`CTE with name '${name}' already exists`);
+        }
+        const { sql, params } = query instanceof NativeQueryBuilder ? query.compile() : { sql: query.sql, params: [...query.params] };
+        this.options.ctes.push({
+            name,
+            sql,
+            params,
+            recursive,
+            columns: options?.columns,
+            materialized: options?.materialized,
+        });
+        return this;
+    }
     toString() {
         const { sql, params } = this.compile();
         return this.platform.formatQuery(sql, params);
@@ -72,6 +102,7 @@ export class NativeQueryBuilder {
         if (this.options.comment) {
             this.parts.push(...this.options.comment.map(comment => `/* ${comment} */`));
         }
+        this.compileCtes();
         switch (this.type) {
             case QueryType.SELECT:
             case QueryType.COUNT:
@@ -387,6 +418,35 @@ export class NativeQueryBuilder {
             this.parts.push(`/*+ ${this.options.hintComment.join(' ')} */`);
         }
     }
+    compileCtes() {
+        const ctes = this.options.ctes;
+        if (!ctes || ctes.length === 0) {
+            return;
+        }
+        const hasRecursive = ctes.some(cte => cte.recursive);
+        const keyword = this.getCteKeyword(hasRecursive);
+        const cteParts = [];
+        for (const cte of ctes) {
+            let part = this.quote(cte.name);
+            if (cte.columns?.length) {
+                part += ` (${cte.columns.map(c => this.quote(c)).join(', ')})`;
+            }
+            part += ' as';
+            if (cte.materialized === true) {
+                part += ' materialized';
+            }
+            else if (cte.materialized === false) {
+                part += ' not materialized';
+            }
+            part += ` (${cte.sql})`;
+            this.params.push(...cte.params);
+            cteParts.push(part);
+        }
+        this.parts.push(`${keyword} ${cteParts.join(', ')}`);
+    }
+    getCteKeyword(hasRecursive) {
+        return hasRecursive ? 'with recursive' : 'with';
+    }
     getTableName() {
         if (!this.options.tableName) {
             throw new Error('No table name provided');

package/query/ObjectCriteriaNode.js

@@ -7,7 +7,8 @@ const COLLECTION_OPERATORS = ['$some', '$none', '$every', '$size'];
  */
 export class ObjectCriteriaNode extends CriteriaNode {
     process(qb, options) {
-        const matchPopulateJoins = options?.matchPopulateJoins || (this.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind));
+        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), { ...options, matchPopulateJoins });
         const ownerAlias = options?.alias || qb.alias;
         const keys = Utils.getObjectQueryKeys(this.payload);
@@ -20,13 +21,15 @@ export class ObjectCriteriaNode extends CriteriaNode {
                 if (![ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(this.prop.kind)) {
                     // ignore collection operators when used on a non-relational property - this can happen when they get into
                     // populateWhere via `infer` on m:n properties with select-in strategy
-                    if (this.parent?.parent) { // we validate only usage on top level
+                    if (this.parent?.parent) {
+                        // we validate only usage on top level
                         return {};
                     }
                     throw new Error(`Collection operators can be used only inside a collection property context, but it was used for ${this.getPath()}.`);
                 }
                 const $and = [];
-                const knownKey = [ReferenceKind.SCALAR, ReferenceKind.MANY_TO_ONE, ReferenceKind.EMBEDDED].includes(this.prop.kind) || (this.prop.kind === ReferenceKind.ONE_TO_ONE && this.prop.owner);
+                const knownKey = [ReferenceKind.SCALAR, ReferenceKind.MANY_TO_ONE, ReferenceKind.EMBEDDED].includes(this.prop.kind) ||
+                    (this.prop.kind === ReferenceKind.ONE_TO_ONE && this.prop.owner);
                 const parentMeta = this.metadata.find(this.parent.entityName);
                 const primaryKeys = parentMeta.primaryKeys.map(pk => {
                     return [QueryType.SELECT, QueryType.COUNT].includes(qb.type) ? `${knownKey ? alias : ownerAlias}.${pk}` : pk;
@@ -48,7 +51,9 @@ export class ObjectCriteriaNode extends CriteriaNode {
                         const pks = this.prop.referencedColumnNames;
                         const countExpr = raw(`count(${pks.map(() => '??').join(', ')})`, pks.map(pk => `${joinAlias}.${pk}`));
                         sub.groupBy(parentMeta.primaryKeys);
-                        sub.having({ $and: Object.keys(sizeCondition).map(op => ({ [countExpr]: { [op]: sizeCondition[op] } })) });
+                        sub.having({
+                            $and: Object.keys(sizeCondition).map(op => ({ [countExpr]: { [op]: sizeCondition[op] } })),
+                        });
                     }
                     else if (key === '$every') {
                         sub.where({ $not: { [this.key]: payload } });
@@ -111,7 +116,11 @@ export class ObjectCriteriaNode extends CriteriaNode {
                 // use '??' placeholder to properly quote the identifier
                 o[raw('??', [field])] = payload;
             }
-            else if (primaryKey || virtual || operator || field.includes('.') || ![QueryType.SELECT, QueryType.COUNT].includes(qb.type)) {
+            else if (primaryKey ||
+                virtual ||
+                operator ||
+                field.includes('.') ||
+                ![QueryType.SELECT, QueryType.COUNT].includes(qb.type)) {
                 this.inlineCondition(field.replaceAll(ALIAS_REPLACEMENT, alias), o, payload);
             }
             else {
@@ -121,9 +130,10 @@ export class ObjectCriteriaNode extends CriteriaNode {
         }, {});
     }
     isStrict() {
-        return this.strict || Utils.getObjectQueryKeys(this.payload).some(key => {
-            return this.payload[key].isStrict();
-        });
+        return (this.strict ||
+            Utils.getObjectQueryKeys(this.payload).some(key => {
+                return this.payload[key].isStrict();
+            }));
     }
     unwrap() {
         return Utils.getObjectQueryKeys(this.payload).reduce((o, field) => {
@@ -148,8 +158,18 @@ export class ObjectCriteriaNode extends CriteriaNode {
     }
     shouldInline(payload) {
         const rawField = RawQueryFragment.isKnownFragmentSymbol(this.key);
-        const scalar = Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || rawField;
-        const operator = Utils.isObject(payload) && Utils.getObjectQueryKeys(payload).every(k => Utils.isOperator(k, false));
+        const scalar = Utils.isPrimaryKey(payload) ||
+            payload instanceof RegExp ||
+            payload instanceof Date ||
+            rawField;
+        const operator = Utils.isObject(payload) &&
+            Utils.getObjectQueryKeys(payload).every(k => {
+                if (k === '$not' && Utils.isPlainObject(payload[k])) {
+                    // $not wrapping non-operator conditions (entity props) should be inlined
+                    return Utils.getObjectQueryKeys(payload[k]).every(ik => Utils.isOperator(ik, false));
+                }
+                return Utils.isOperator(k, false);
+            });
         return !!this.prop && this.prop.kind !== ReferenceKind.SCALAR && !scalar && !operator;
     }
     getChildKey(k, prop, childAlias, alias) {
@@ -161,7 +181,9 @@ export class ObjectCriteriaNode extends CriteriaNode {
     inlineArrayChildPayload(obj, payload, k, prop, childAlias, alias) {
         const key = this.getChildKey(k, prop, childAlias);
         const value = payload.map((child) => Utils.getObjectQueryKeys(child).reduce((inner, childKey) => {
-            const key = (RawQueryFragment.isKnownFragmentSymbol(childKey) || this.isPrefixed(childKey) || Utils.isOperator(childKey)) ? childKey : this.aliased(childKey, childAlias);
+            const key = RawQueryFragment.isKnownFragmentSymbol(childKey) || this.isPrefixed(childKey) || Utils.isOperator(childKey)
+                ? childKey
+                : this.aliased(childKey, childAlias);
             inner[key] = child[childKey];
             return inner;
         }, {}));
@@ -173,6 +195,12 @@ export class ObjectCriteriaNode extends CriteriaNode {
             if (RawQueryFragment.isKnownFragmentSymbol(k)) {
                 o[k] = payload[k];
             }
+            else if (k === '$not' &&
+                Utils.isPlainObject(payload[k]) &&
+                Utils.getObjectQueryKeys(payload[k]).some(ik => !Utils.isOperator(ik, false))) {
+                // $not wraps entity conditions (from auto-join), inline at current level
+                this.inlineCondition(k, o, payload[k]);
+            }
             else if (Utils.isOperator(k, false)) {
                 const tmp = payload[k];
                 delete payload[k];
@@ -218,24 +246,42 @@ export class ObjectCriteriaNode extends CriteriaNode {
         }
         const meta = this.metadata.find(this.entityName);
         const embeddable = this.prop.kind === ReferenceKind.EMBEDDED;
-        const knownKey = [ReferenceKind.SCALAR, ReferenceKind.MANY_TO_ONE, ReferenceKind.EMBEDDED].includes(this.prop.kind) || (this.prop.kind === ReferenceKind.ONE_TO_ONE && this.prop.owner);
-        const operatorKeys = knownKey && keys.every(key => Utils.isOperator(key, false));
-        const primaryKeys = knownKey && keys.every(key => {
-            if (typeof key !== 'string' || !meta.primaryKeys.includes(key)) {
-                return false;
-            }
-            if (!Utils.isPlainObject(this.payload[key].payload) || ![ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(meta.properties[key].kind)) {
-                return true;
-            }
-            return Utils.getObjectQueryKeys(this.payload[key].payload).every(k => typeof k === 'string' && meta.properties[key].targetMeta.primaryKeys.includes(k));
-        });
+        const knownKey = [ReferenceKind.SCALAR, ReferenceKind.MANY_TO_ONE, ReferenceKind.EMBEDDED].includes(this.prop.kind) ||
+            (this.prop.kind === ReferenceKind.ONE_TO_ONE && this.prop.owner);
+        const operatorKeys = knownKey &&
+            keys.every(key => {
+                if (key === '$not') {
+                    // $not wraps conditions like $and/$or, check if it wraps entity property conditions (needs auto-join)
+                    // vs simple operator conditions on the FK (doesn't need auto-join)
+                    const childPayload = this.payload[key].payload;
+                    if (Utils.isPlainObject(childPayload)) {
+                        return Utils.getObjectQueryKeys(childPayload).every(k => Utils.isOperator(k, false));
+                    }
+                }
+                return Utils.isOperator(key, false);
+            });
+        const primaryKeys = knownKey &&
+            keys.every(key => {
+                if (typeof key !== 'string' || !meta.primaryKeys.includes(key)) {
+                    return false;
+                }
+                if (!Utils.isPlainObject(this.payload[key].payload) ||
+                    ![ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(meta.properties[key].kind)) {
+                    return true;
+                }
+                return Utils.getObjectQueryKeys(this.payload[key].payload).every(k => typeof k === 'string' && meta.properties[key].targetMeta.primaryKeys.includes(k));
+            });
         return !primaryKeys && !nestedAlias && !operatorKeys && !embeddable;
     }
     autoJoin(qb, alias, options) {
         const nestedAlias = qb.getNextAlias(this.prop?.pivotEntity ?? this.entityName);
         const rawField = RawQueryFragment.isKnownFragmentSymbol(this.key);
-        const scalar = Utils.isPrimaryKey(this.payload) || this.payload instanceof RegExp || this.payload instanceof Date || rawField;
-        const operator = Utils.isPlainObject(this.payload) && Utils.getObjectQueryKeys(this.payload).every(k => Utils.isOperator(k, false));
+        const scalar = Utils.isPrimaryKey(this.payload) ||
+            this.payload instanceof RegExp ||
+            this.payload instanceof Date ||
+            rawField;
+        const operator = Utils.isPlainObject(this.payload) &&
+            Utils.getObjectQueryKeys(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();
@@ -245,9 +291,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
         else {
             const prev = qb._fields?.slice();
             const toOneProperty = [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind);
-            const joinType = toOneProperty && !this.prop.nullable
-                ? JoinType.innerJoin
-                : JoinType.leftJoin;
+            const joinType = toOneProperty && !this.prop.nullable ? JoinType.innerJoin : JoinType.leftJoin;
             qb[method](field, nestedAlias, undefined, joinType, path);
             if (!qb.hasFlag(QueryFlag.INFER_POPULATE)) {
                 qb._fields = prev;