@mikro-orm/sql 7.0.0-dev.97 → 7.0.0-dev.99

package/query/NativeQueryBuilder.js

@@ -0,0 +1,425 @@
+import { LockMode, raw, RawQueryFragment, Utils } from '@mikro-orm/core';
+import { QueryType } from './enums.js';
+/** @internal */
+export class NativeQueryBuilder {
+    platform;
+    type;
+    parts = [];
+    params = [];
+    options = {};
+    constructor(platform) {
+        this.platform = platform;
+    }
+    select(fields) {
+        this.type = QueryType.SELECT;
+        this.options.select ??= [];
+        this.options.select.push(...Utils.asArray(fields));
+        return this;
+    }
+    count(fields = '*', distinct) {
+        this.type = QueryType.COUNT;
+        this.options.select = Utils.asArray(fields);
+        this.options.distinct = distinct;
+        return this;
+    }
+    into(tableName, options) {
+        return this.from(tableName, options);
+    }
+    from(tableName, options) {
+        if (tableName instanceof NativeQueryBuilder) {
+            const { sql, params } = tableName.compile();
+            tableName = raw(sql, params);
+        }
+        if (typeof tableName === 'string') {
+            const alias = options?.alias ? ` as ${this.platform.quoteIdentifier(options.alias)}` : '';
+            const schema = options?.schema && options.schema !== this.platform.getDefaultSchemaName() ? `${options.schema}.` : '';
+            tableName = this.quote(schema + tableName) + alias;
+        }
+        this.options.tableName = tableName;
+        this.options.indexHint = options?.indexHint;
+        return this;
+    }
+    where(sql, params) {
+        this.options.where = { sql, params };
+        return this;
+    }
+    having(sql, params) {
+        this.options.having = { sql, params };
+        return this;
+    }
+    groupBy(groupBy) {
+        this.options.groupBy = groupBy;
+        return this;
+    }
+    join(sql, params) {
+        this.options.joins ??= [];
+        this.options.joins.push({ sql, params });
+        return this;
+    }
+    orderBy(orderBy) {
+        this.options.orderBy = orderBy;
+        return this;
+    }
+    toString() {
+        const { sql, params } = this.compile();
+        return this.platform.formatQuery(sql, params);
+    }
+    compile() {
+        if (!this.type) {
+            throw new Error('No query type provided');
+        }
+        this.parts.length = 0;
+        this.params.length = 0;
+        if (this.options.comment) {
+            this.parts.push(...this.options.comment.map(comment => `/* ${comment} */`));
+        }
+        switch (this.type) {
+            case QueryType.SELECT:
+            case QueryType.COUNT:
+                this.compileSelect();
+                break;
+            case QueryType.INSERT:
+                this.compileInsert();
+                break;
+            case QueryType.UPDATE:
+                this.compileUpdate();
+                break;
+            case QueryType.DELETE:
+                this.compileDelete();
+                break;
+            case QueryType.TRUNCATE:
+                this.compileTruncate();
+                break;
+        }
+        this.addOnConflictClause();
+        if (this.options.returning && this.platform.usesReturningStatement()) {
+            const fields = this.options.returning.map(field => this.quote(field));
+            this.parts.push(`returning ${fields.join(', ')}`);
+        }
+        this.addLockClause();
+        return this.combineParts();
+    }
+    addLockClause() {
+        if (!this.options.lockMode) {
+            return;
+        }
+        if ([LockMode.PESSIMISTIC_READ, LockMode.PESSIMISTIC_PARTIAL_READ, LockMode.PESSIMISTIC_READ_OR_FAIL].includes(this.options.lockMode)) {
+            this.parts.push('for share');
+        }
+        if ([LockMode.PESSIMISTIC_WRITE, LockMode.PESSIMISTIC_PARTIAL_WRITE, LockMode.PESSIMISTIC_WRITE_OR_FAIL].includes(this.options.lockMode)) {
+            this.parts.push('for update');
+        }
+        if (this.options.lockTables?.length) {
+            const fields = this.options.lockTables.map(field => this.quote(field));
+            this.parts.push(`of ${fields.join(', ')}`);
+        }
+        if ([LockMode.PESSIMISTIC_PARTIAL_READ, LockMode.PESSIMISTIC_PARTIAL_WRITE].includes(this.options.lockMode)) {
+            this.parts.push('skip locked');
+        }
+        if ([LockMode.PESSIMISTIC_READ_OR_FAIL, LockMode.PESSIMISTIC_WRITE_OR_FAIL].includes(this.options.lockMode)) {
+            this.parts.push('nowait');
+        }
+    }
+    addOnConflictClause() {
+        const clause = this.options.onConflict;
+        if (!clause) {
+            return;
+        }
+        this.parts.push('on conflict');
+        if (clause.fields instanceof RawQueryFragment) {
+            this.parts.push(clause.fields.sql);
+            this.params.push(...clause.fields.params);
+        }
+        else if (clause.fields.length > 0) {
+            const fields = clause.fields.map(field => this.quote(field));
+            this.parts.push(`(${fields.join(', ')})`);
+        }
+        if (clause.ignore) {
+            this.parts.push('do nothing');
+        }
+        if (Utils.isObject(clause.merge)) {
+            this.parts.push('do update set');
+            const fields = Object.keys(clause.merge).map(field => {
+                this.params.push(clause.merge[field]);
+                return `${this.quote(field)} = ?`;
+            });
+            this.parts.push(fields.join(', '));
+        }
+        else if (clause.merge) {
+            this.parts.push('do update set');
+            if (clause.merge.length) {
+                const fields = clause.merge.map(field => `${this.quote(field)} = excluded.${this.quote(field)}`);
+                this.parts.push(fields.join(', '));
+            }
+            else {
+                const dataAsArray = Utils.asArray(this.options.data);
+                const keys = Object.keys(dataAsArray[0]);
+                const fields = keys.map(field => `${this.quote(field)} = excluded.${this.quote(field)}`);
+                this.parts.push(fields.join(', '));
+            }
+        }
+        if (clause.where) {
+            this.parts.push(`where ${clause.where.sql}`);
+            this.params.push(...clause.where.params);
+        }
+    }
+    combineParts() {
+        let sql = this.parts.join(' ');
+        if (this.options.wrap) {
+            const [a, b] = this.options.wrap;
+            sql = `${a}${sql}${b}`;
+        }
+        return { sql, params: this.params };
+    }
+    limit(limit) {
+        this.options.limit = limit;
+        return this;
+    }
+    offset(offset) {
+        this.options.offset = offset;
+        return this;
+    }
+    insert(data) {
+        this.type = QueryType.INSERT;
+        this.options.data = data;
+        return this;
+    }
+    update(data) {
+        this.type = QueryType.UPDATE;
+        this.options.data ??= {};
+        Object.assign(this.options.data, data);
+        return this;
+    }
+    delete() {
+        this.type = QueryType.DELETE;
+        return this;
+    }
+    truncate() {
+        this.type = QueryType.TRUNCATE;
+        return this;
+    }
+    distinct() {
+        this.options.distinct = true;
+        return this;
+    }
+    distinctOn(fields) {
+        this.options.distinctOn = fields;
+        return this;
+    }
+    onConflict(options) {
+        this.options.onConflict = options;
+        return options;
+    }
+    returning(fields) {
+        this.options.returning = fields;
+        return this;
+    }
+    lockMode(lockMode, lockTables) {
+        this.options.lockMode = lockMode;
+        this.options.lockTables = lockTables;
+        return this;
+    }
+    comment(comment) {
+        this.options.comment ??= [];
+        this.options.comment.push(...Utils.asArray(comment));
+        return this;
+    }
+    hintComment(comment) {
+        this.options.hintComment ??= [];
+        this.options.hintComment.push(...Utils.asArray(comment));
+        return this;
+    }
+    setFlags(flags) {
+        this.options.flags = flags;
+        return this;
+    }
+    clear(clause) {
+        delete this.options[clause];
+        return this;
+    }
+    wrap(prefix, suffix) {
+        this.options.wrap = [prefix, suffix];
+        return this;
+    }
+    as(alias) {
+        this.wrap('(', `) as ${this.platform.quoteIdentifier(alias)}`);
+        return this;
+    }
+    toRaw() {
+        const { sql, params } = this.compile();
+        return raw(sql, params);
+    }
+    compileSelect() {
+        this.parts.push('select');
+        this.addHintComment();
+        this.parts.push(`${this.getFields()} from ${this.getTableName()}`);
+        if (this.options.joins) {
+            for (const join of this.options.joins) {
+                this.parts.push(join.sql);
+                this.params.push(...join.params);
+            }
+        }
+        if (this.options.where?.sql.trim()) {
+            this.parts.push(`where ${this.options.where.sql}`);
+            this.options.where.params.forEach(p => this.params.push(p));
+        }
+        if (this.options.groupBy) {
+            const fields = this.options.groupBy.map(field => this.quote(field));
+            this.parts.push(`group by ${fields.join(', ')}`);
+        }
+        if (this.options.having) {
+            this.parts.push(`having ${this.options.having.sql}`);
+            this.params.push(...this.options.having.params);
+        }
+        if (this.options.orderBy) {
+            this.parts.push(`order by ${this.options.orderBy}`);
+        }
+        if (this.options.limit != null) {
+            this.parts.push(`limit ?`);
+            this.params.push(this.options.limit);
+        }
+        if (this.options.offset != null) {
+            this.parts.push(`offset ?`);
+            this.params.push(this.options.offset);
+        }
+    }
+    getFields() {
+        if (!this.options.select || this.options.select.length === 0) {
+            throw new Error('No fields selected');
+        }
+        let fields = this.options.select.map(field => this.quote(field)).join(', ');
+        if (this.options.distinct) {
+            fields = `distinct ${fields}`;
+        }
+        else if (this.options.distinctOn) {
+            fields = `distinct on (${this.options.distinctOn.map(field => this.quote(field)).join(', ')}) ${fields}`;
+        }
+        if (this.type === QueryType.COUNT) {
+            fields = `count(${fields}) as ${this.quote('count')}`;
+        }
+        return fields;
+    }
+    compileInsert() {
+        if (!this.options.data) {
+            throw new Error('No data provided');
+        }
+        this.parts.push('insert');
+        this.addHintComment();
+        this.parts.push(`into ${this.getTableName()}`);
+        if (Object.keys(this.options.data).length === 0) {
+            this.addOutputClause('inserted');
+            this.parts.push('default values');
+            return;
+        }
+        const parts = this.processInsertData();
+        this.parts.push(parts.join(', '));
+    }
+    addOutputClause(type) {
+        if (this.options.returning && this.platform.usesOutputStatement()) {
+            const fields = this.options.returning.map(field => `${type}.${this.quote(field)}`);
+            this.parts.push(`output ${fields.join(', ')}`);
+        }
+    }
+    processInsertData() {
+        const dataAsArray = Utils.asArray(this.options.data);
+        const keys = Object.keys(dataAsArray[0]);
+        const values = keys.map(() => '?');
+        const parts = [];
+        this.parts.push(`(${keys.map(key => this.quote(key)).join(', ')})`);
+        this.addOutputClause('inserted');
+        this.parts.push('values');
+        for (const data of dataAsArray) {
+            for (const key of keys) {
+                if (typeof data[key] === 'undefined') {
+                    this.params.push(this.platform.usesDefaultKeyword() ? raw('default') : null);
+                }
+                else {
+                    this.params.push(data[key]);
+                }
+            }
+            parts.push(`(${values.join(', ')})`);
+        }
+        return parts;
+    }
+    compileUpdate() {
+        if (!this.options.data || Object.keys(this.options.data).length === 0) {
+            throw new Error('No data provided');
+        }
+        this.parts.push('update');
+        this.addHintComment();
+        this.parts.push(this.getTableName());
+        if (this.options.joins) {
+            for (const join of this.options.joins) {
+                this.parts.push(join.sql);
+                this.params.push(...join.params);
+            }
+        }
+        this.parts.push('set');
+        if (this.options.data) {
+            const parts = [];
+            for (const key of Object.keys(this.options.data)) {
+                parts.push(`${this.quote(key)} = ?`);
+                this.params.push(this.options.data[key]);
+            }
+            this.parts.push(parts.join(', '));
+        }
+        this.addOutputClause('inserted');
+        if (this.options.where?.sql.trim()) {
+            this.parts.push(`where ${this.options.where.sql}`);
+            this.params.push(...this.options.where.params);
+        }
+    }
+    compileDelete() {
+        this.parts.push('delete');
+        this.addHintComment();
+        this.parts.push(`from ${this.getTableName()}`);
+        this.addOutputClause('deleted');
+        if (this.options.where?.sql.trim()) {
+            this.parts.push(`where ${this.options.where.sql}`);
+            this.params.push(...this.options.where.params);
+        }
+    }
+    compileTruncate() {
+        const sql = `truncate table ${this.getTableName()}`;
+        this.parts.push(sql);
+    }
+    addHintComment() {
+        if (this.options.hintComment) {
+            this.parts.push(`/*+ ${this.options.hintComment.join(' ')} */`);
+        }
+    }
+    getTableName() {
+        if (!this.options.tableName) {
+            throw new Error('No table name provided');
+        }
+        const indexHint = this.options.indexHint ? ' ' + this.options.indexHint : '';
+        if (this.options.tableName instanceof RawQueryFragment) {
+            this.params.push(...this.options.tableName.params);
+            return this.options.tableName.sql + indexHint;
+        }
+        return this.options.tableName + indexHint;
+    }
+    quote(id) {
+        if (id instanceof RawQueryFragment) {
+            return this.platform.formatQuery(id.sql, id.params);
+        }
+        if (id instanceof NativeQueryBuilder) {
+            const { sql, params } = id.compile();
+            return this.platform.formatQuery(sql, params);
+        }
+        if (id.endsWith('.*')) {
+            const schema = this.platform.quoteIdentifier(id.substring(0, id.indexOf('.')));
+            return schema + '.*';
+        }
+        if (id.toLowerCase().includes(' as ')) {
+            const parts = id.split(/ as /i);
+            const a = this.platform.quoteIdentifier(parts[0]);
+            const b = this.platform.quoteIdentifier(parts[1]);
+            return `${a} as ${b}`;
+        }
+        if (id === '*') {
+            return id;
+        }
+        return this.platform.quoteIdentifier(id);
+    }
+}

package/query/ObjectCriteriaNode.d.ts

@@ -0,0 +1,19 @@
+import { CriteriaNode } from './CriteriaNode.js';
+import type { ICriteriaNodeProcessOptions, IQueryBuilder } from '../typings.js';
+/**
+ * @internal
+ */
+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;
+    private getChildKey;
+    private inlineArrayChildPayload;
+    private inlineChildPayload;
+    private inlineCondition;
+    private shouldAutoJoin;
+    private autoJoin;
+    private isPrefixed;
+}

package/query/ObjectCriteriaNode.js

@@ -0,0 +1,249 @@
+import { ALIAS_REPLACEMENT, GroupOperator, QueryFlag, raw, RawQueryFragment, ReferenceKind, Utils, } from '@mikro-orm/core';
+import { CriteriaNode } from './CriteriaNode.js';
+import { JoinType, QueryType } from './enums.js';
+/**
+ * @internal
+ */
+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 nestedAlias = qb.getAliasForJoinPath(this.getPath(), { ...options, matchPopulateJoins });
+        const ownerAlias = options?.alias || qb.alias;
+        const keys = Object.keys(this.payload);
+        let alias = options?.alias;
+        if (nestedAlias) {
+            alias = nestedAlias;
+        }
+        if (this.shouldAutoJoin(qb, nestedAlias)) {
+            if (keys.some(k => ['$some', '$none', '$every'].includes(k))) {
+                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
+                        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 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;
+                });
+                for (const key of keys) {
+                    if (!['$some', '$none', '$every'].includes(key)) {
+                        throw new Error('Mixing collection operators with other filters is not allowed.');
+                    }
+                    const payload = this.payload[key].unwrap();
+                    const qb2 = qb.clone(true);
+                    const sub = qb2
+                        .from(parentMeta.className)
+                        .innerJoin(this.key, qb2.getNextAlias(this.prop.type))
+                        .select(parentMeta.primaryKeys);
+                    if (key === '$every') {
+                        sub.where({ $not: { [this.key]: payload } });
+                    }
+                    else {
+                        sub.where({ [this.key]: payload });
+                    }
+                    const op = key === '$some' ? '$in' : '$nin';
+                    $and.push({
+                        [Utils.getPrimaryKeyHash(primaryKeys)]: { [op]: sub.getNativeQuery().toRaw() },
+                    });
+                }
+                if ($and.length === 1) {
+                    return $and[0];
+                }
+                return { $and };
+            }
+            alias = this.autoJoin(qb, ownerAlias, options);
+        }
+        if (this.prop && nestedAlias) {
+            const toOneProperty = [ReferenceKind.MANY_TO_ONE, 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 + '.' + 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 });
+            const operator = Utils.isOperator(field);
+            const isRawField = RawQueryFragment.isKnownFragment(field);
+            // we need to keep the prefixing for formulas otherwise we would lose aliasing context when nesting inside group operators
+            const virtual = childNode.prop?.persist === false && !childNode.prop?.formula;
+            // if key is missing, we are inside group operator and we need to prefix with alias
+            const primaryKey = this.key && this.metadata.find(this.entityName)?.primaryKeys.includes(field);
+            const isToOne = childNode.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(childNode.prop.kind);
+            if (childNode.shouldInline(payload)) {
+                const childAlias = qb.getAliasForJoinPath(childNode.getPath(), { preferNoBranch: isToOne, ...options });
+                const a = qb.helper.isTableNameAliasRequired(qb.type) ? alias : undefined;
+                this.inlineChildPayload(o, payload, field, a, childAlias);
+            }
+            else if (childNode.shouldRename(payload)) {
+                this.inlineCondition(childNode.renameFieldToPK(qb, alias), o, payload);
+            }
+            else if (isRawField) {
+                const rawField = RawQueryFragment.getKnownFragment(field);
+                o[raw(rawField.sql.replaceAll(ALIAS_REPLACEMENT, alias), rawField.params)] = payload;
+            }
+            else if (primaryKey || virtual || operator || field.includes('.') || ![QueryType.SELECT, QueryType.COUNT].includes(qb.type)) {
+                this.inlineCondition(field.replaceAll(ALIAS_REPLACEMENT, alias), o, payload);
+            }
+            else {
+                this.inlineCondition(`${alias}.${field}`, o, payload);
+            }
+            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();
+            return o;
+        }, {});
+    }
+    willAutoJoin(qb, alias, options) {
+        const nestedAlias = qb.getAliasForJoinPath(this.getPath(), options);
+        const ownerAlias = alias || qb.alias;
+        const keys = Object.keys(this.payload);
+        if (nestedAlias) {
+            alias = nestedAlias;
+        }
+        if (this.shouldAutoJoin(qb, nestedAlias)) {
+            return !keys.some(k => ['$some', '$none', '$every'].includes(k));
+        }
+        return keys.some(field => {
+            const childNode = this.payload[field];
+            return childNode.willAutoJoin(qb, this.prop ? alias : ownerAlias, options);
+        });
+    }
+    shouldInline(payload) {
+        const customExpression = RawQueryFragment.isKnownFragment(this.key);
+        const scalar = Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
+        const operator = Utils.isObject(payload) && Object.keys(payload).every(k => Utils.isOperator(k, false));
+        return !!this.prop && this.prop.kind !== ReferenceKind.SCALAR && !scalar && !operator;
+    }
+    getChildKey(k, prop, childAlias, alias) {
+        const idx = prop.referencedPKs.indexOf(k);
+        return idx !== -1 && !childAlias && ![ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind)
+            ? this.aliased(prop.joinColumns[idx], alias)
+            : k;
+    }
+    inlineArrayChildPayload(obj, payload, k, prop, childAlias, alias) {
+        const key = this.getChildKey(k, prop, childAlias);
+        const value = payload.map((child) => Object.keys(child).reduce((inner, childKey) => {
+            const key = (this.isPrefixed(childKey) || Utils.isOperator(childKey)) ? childKey : this.aliased(childKey, childAlias);
+            inner[key] = child[childKey];
+            return inner;
+        }, {}));
+        this.inlineCondition(key, obj, value);
+    }
+    inlineChildPayload(o, payload, field, alias, childAlias) {
+        const prop = this.metadata.find(this.entityName).properties[field];
+        for (const k of Object.keys(payload)) {
+            if (Utils.isOperator(k, false)) {
+                const tmp = payload[k];
+                delete payload[k];
+                o[this.aliased(field, alias)] = { [k]: tmp, ...o[this.aliased(field, alias)] };
+            }
+            else if (k in GroupOperator && Array.isArray(payload[k])) {
+                this.inlineArrayChildPayload(o, payload[k], k, prop, childAlias, alias);
+            }
+            else if (this.isPrefixed(k) || Utils.isOperator(k) || !childAlias) {
+                const key = this.getChildKey(k, prop, childAlias, alias);
+                this.inlineCondition(key, o, payload[k]);
+            }
+            else if (RawQueryFragment.isKnownFragment(k)) {
+                o[k] = payload[k];
+            }
+            else {
+                o[this.aliased(k, childAlias)] = payload[k];
+            }
+        }
+    }
+    inlineCondition(key, o, value) {
+        if (!(key in o)) {
+            o[key] = value;
+            return;
+        }
+        /* v8 ignore next */
+        if (key === '$and') {
+            o.$and.push({ [key]: value });
+            return;
+        }
+        const $and = o.$and ?? [];
+        $and.push({ [key]: o[key] }, { [key]: value });
+        delete o[key];
+        o.$and = $and;
+    }
+    shouldAutoJoin(qb, nestedAlias) {
+        if (!this.prop || !this.parent) {
+            return false;
+        }
+        const keys = Object.keys(this.payload);
+        if (keys.every(k => k.includes('.') && k.startsWith(`${qb.alias}.`))) {
+            return false;
+        }
+        if (keys.some(k => ['$some', '$none', '$every'].includes(k))) {
+            return true;
+        }
+        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 (!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 Object.keys(this.payload[key].payload).every(k => meta.properties[key].targetMeta.primaryKeys.includes(k));
+        });
+        return !primaryKeys && !nestedAlias && !operatorKeys && !embeddable;
+    }
+    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, path);
+        }
+        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;
+            qb[method](field, nestedAlias, undefined, joinType, path);
+            if (!qb.hasFlag(QueryFlag.INFER_POPULATE)) {
+                qb._fields = prev;
+            }
+        }
+        if (options?.type !== 'orderBy') {
+            qb.scheduleFilterCheck(path);
+        }
+        return nestedAlias;
+    }
+    isPrefixed(field) {
+        return !!field.match(/\w+\./);
+    }
+}