@mikro-orm/core 7.3.0-dev.2 → 7.3.0-dev.20

package/unit-of-work/UnitOfWork.js

@@ -89,7 +89,10 @@ export class UnitOfWork {
                 Utils.isPlainObject(data[prop.name])) {
                 // Skip polymorphic relations - they use PolymorphicRef wrapper
                 if (!prop.polymorphic) {
-                    data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
+                    // with `targetKey`, the FK holds that value instead of the PK
+                    data[prop.name] = prop.targetKey
+                        ? data[prop.name][prop.targetKey]
+                        : Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
                 }
             }
             else if (prop.kind === ReferenceKind.EMBEDDED && !prop.object && Utils.isPlainObject(data[prop.name])) {
@@ -205,7 +208,18 @@ export class UnitOfWork {
             value = prop.customType.convertToJSValue(value, this.#platform, { mode: 'hydration' });
         }
         const hash = this.#identityMap.getKeyHash(key, '' + value, schema);
-        return this.#identityMap.getByHash(meta, hash);
+        const entity = this.#identityMap.getByHash(meta, hash);
+        // the entry is stale when the key changed via refresh or merge, unless only the unflushed value differs
+        if (entity && '' + entity[key] !== '' + value) {
+            // the snapshot holds the database value
+            const dbValue = prop?.customType
+                ? prop.customType.convertToDatabaseValue(value, this.#platform, { mode: 'serialization' })
+                : value;
+            if ('' + helper(entity).__originalEntityData?.[key] !== '' + dbValue) {
+                return undefined;
+            }
+        }
+        return entity;
     }
     /**
      * Stores an entity in the identity map under an alternate key (non-PK property).
@@ -368,6 +382,10 @@ export class UnitOfWork {
     }
     /** Marks an entity for removal, cascading to related entities. */
     remove(entity, visited, options = {}) {
+        // a reference known only by its `targetKey` has no PK, so the delete would match nothing
+        if (!helper(entity).__initialized && !helper(entity).hasPrimaryKey()) {
+            throw ValidationError.referenceWithoutPK(entity);
+        }
         // allow removing not managed entities if they are not part of the persist stack
         if (helper(entity).__managed || !this.#persistStack.has(entity)) {
             this.#removeStack.add(entity);
@@ -582,19 +600,27 @@ export class UnitOfWork {
                 this.findEarlyUpdates(cs, inserts[cs.meta.uniqueName]);
             }
         }
+        // hashes of the inserts' PKs and unique values per type, built lazily, so matching a removed entity is a set lookup
+        const insertHashes = {};
         for (const entity of this.#removeStack) {
             const wrapped = helper(entity);
             /* v8 ignore next */
             if (wrapped.__processing) {
                 continue;
             }
-            const deletePkHash = [wrapped.getSerializedPrimaryKey(), ...this.expandUniqueProps(entity)];
-            let type = ChangeSetType.DELETE;
-            for (const cs of inserts[wrapped.__meta.uniqueName] ?? []) {
-                if (deletePkHash.some(hash => hash === cs.getSerializedPrimaryKey() || this.expandUniqueProps(cs.entity).find(child => hash === child))) {
-                    type = ChangeSetType.DELETE_EARLY;
+            const uniqueName = wrapped.__meta.uniqueName;
+            let hashes = insertHashes[uniqueName];
+            if (!hashes) {
+                hashes = insertHashes[uniqueName] = new Set();
+                for (const cs of inserts[uniqueName] ?? []) {
+                    hashes.add(cs.getSerializedPrimaryKey());
+                    for (const hash of this.expandUniqueProps(cs.entity)) {
+                        hashes.add(hash);
+                    }
                 }
             }
+            const deletePkHash = [wrapped.getSerializedPrimaryKey(), ...this.expandUniqueProps(entity)];
+            const type = deletePkHash.some(hash => hashes.has(hash)) ? ChangeSetType.DELETE_EARLY : ChangeSetType.DELETE;
             this.computeChangeSet(entity, type);
         }
     }
@@ -1118,6 +1144,11 @@ export class UnitOfWork {
         for (const changeSet of changeSets) {
             const wrapped = helper(changeSet.entity);
             wrapped.__originalEntityData = this.#comparator.prepareEntity(changeSet.entity);
+            // re-index so the entity is found by its new `targetKey` values instead of the old ones
+            if (changeSet.meta.root.targetKeys?.some(key => key in changeSet.payload)) {
+                this.#identityMap.delete(changeSet.entity);
+                this.#identityMap.store(changeSet.entity);
+            }
             if (!wrapped.__initialized) {
                 for (const prop of changeSet.meta.relations) {
                     if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind) &&
@@ -1260,6 +1291,13 @@ export class UnitOfWork {
                         calc.discoverProperty({ ...prop, targetMeta }, meta._id);
                     }
                 }
+                else if (prop.targetMeta?.inheritanceType === 'tpt') {
+                    calc.discoverProperty(prop, meta._id);
+                    // a TPT subclass delete has only a leaf change set that also removes the target row; weak edge so it can't break insert order
+                    for (const targetMeta of this.#metadata.find(prop.targetMeta.class).allTPTDescendants ?? []) {
+                        calc.discoverProperty({ ...prop, targetMeta, nullable: true }, meta._id);
+                    }
+                }
                 else {
                     calc.discoverProperty(prop, meta._id);
                 }

package/utils/Configuration.d.ts

@@ -218,6 +218,17 @@ export type MigrationsOptions = {
      * @default true
      */
     allOrNothing?: boolean;
+    /**
+     * Serialize concurrent `migrator.up()`/`migrator.down()` runs (e.g. several replicas migrating on start) with a
+     * database lock, held on a pooled connection of its own for the whole run (so `pool.max` needs to be at least 2).
+     * Supported on PostgreSQL, MySQL, MariaDB and MSSQL, ignored elsewhere.
+     * @default false
+     */
+    lock?: boolean;
+    /**
+     * How long to wait for the migration lock (in milliseconds) before failing. Waits indefinitely by default.
+     */
+    lockTimeout?: number;
     /**
      * Allow dropping tables during schema diff.
      * @default true
@@ -593,7 +604,7 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
     /**
      * Force `Date` values to be stored in UTC for datetime columns without timezone.
      * Works for MySQL (`datetime` type), PostgreSQL (`timestamp` type), and MSSQL (`datetime`/`datetime2` types).
-     * SQLite does this by default.
+     * SQLite does this by default. MySQL and MariaDB also get their session time zone set on every new connection.
      * @default true
      */
     forceUtcTimezone: boolean;

package/utils/EntityComparator.d.ts

@@ -19,6 +19,11 @@ export declare class EntityComparator {
     diffEntities<T extends object>(entityName: EntityName<T>, a: EntityData<T>, b: EntityData<T>, options?: {
         includeInverseSides?: boolean;
     }): EntityData<T>;
+    /**
+     * Returns true if the comparator checks this property with `!==`, so matching values are identical primitives.
+     * @internal
+     */
+    isStrictlyCompared<T>(prop: EntityProperty<T>): boolean;
     /** Returns true if two entity snapshots are identical (no differences). */
     matching<T extends object>(entityName: EntityName<T>, a: EntityData<T>, b: EntityData<T>): boolean;
     /**

package/utils/EntityComparator.js

@@ -1,6 +1,7 @@
 import { clone } from './clone.js';
 import { ReferenceKind } from '../enums.js';
 import { compareArrays, compareBooleans, compareBuffers, compareObjects, equals, parseJsonSafe, Utils, } from './Utils.js';
+import { DateType } from '../types/DateType.js';
 import { JsonType } from '../types/JsonType.js';
 import { Raw } from './RawQueryFragment.js';
 import { EntityIdentifier } from '../entity/EntityIdentifier.js';
@@ -29,6 +30,17 @@ export class EntityComparator {
         const comparator = this.getEntityComparator(entityName);
         return Utils.callCompiledFunction(comparator, a, b, options);
     }
+    /**
+     * Returns true if the comparator checks this property with `!==`, so matching values are identical primitives.
+     * @internal
+     */
+    isStrictlyCompared(prop) {
+        if (prop.kind !== ReferenceKind.SCALAR || prop.customType?.compareValues) {
+            return false;
+        }
+        const type = (prop.customType ? prop.customType.compareAsType() : prop.type).toLowerCase();
+        return ['string', 'number', 'bigint'].includes(type);
+    }
     /** Returns true if two entity snapshots are identical (no differences). */
     matching(entityName, a, b) {
         const diff = this.diffEntities(entityName, a, b);
@@ -95,7 +107,7 @@ export class EntityComparator {
             lines.push(`  return entity${this.wrap(pk)};`);
         }
         const code = `// compiled pk getter for entity ${meta.className}\n` + `return function(entity) {\n${lines.join('\n')}\n}`;
-        const fnKey = `pkGetter-${meta.uniqueName}`;
+        const fnKey = `pkGetter-${meta.compiledName}`;
         const pkSerializer = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
         this.#pkGetters.set(meta, pkSerializer);
         return pkSerializer;
@@ -147,7 +159,7 @@ export class EntityComparator {
         }
         const code = `// compiled pk getter (with converted custom types) for entity ${meta.className}\n` +
             `return function(entity) {\n${lines.join('\n')}\n}`;
-        const fnKey = `pkGetterConverted-${meta.uniqueName}`;
+        const fnKey = `pkGetterConverted-${meta.compiledName}`;
         const pkSerializer = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
         this.#pkGettersConverted.set(meta, pkSerializer);
         return pkSerializer;
@@ -206,7 +218,7 @@ export class EntityComparator {
             }
         }
         const code = `// compiled pk serializer for entity ${meta.className}\n` + `return function(entity) {\n${lines.join('\n')}\n}`;
-        const fnKey = `pkSerializer-${meta.uniqueName}`;
+        const fnKey = `pkSerializer-${meta.compiledName}`;
         const pkSerializer = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
         this.#pkSerializers.set(meta, pkSerializer);
         return pkSerializer;
@@ -236,7 +248,7 @@ export class EntityComparator {
         })
             .forEach(prop => lines.push(this.getPropertySnapshot(meta, prop, context, this.wrap(prop.name), this.wrap(prop.name), [prop.name])));
         const code = `return function(entity) {\n  const ret = {};\n${lines.join('\n')}\n  return ret;\n}`;
-        const fnKey = `snapshotGenerator-${meta.uniqueName}`;
+        const fnKey = `snapshotGenerator-${meta.compiledName}`;
         const snapshotGenerator = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
         this.#snapshotGenerators.set(meta, snapshotGenerator);
         return snapshotGenerator;
@@ -350,19 +362,48 @@ export class EntityComparator {
                 if (prop.embedded && (meta.embeddable || meta.properties[prop.embedded[0]].object)) {
                     continue;
                 }
+                let defined = `typeof ${this.propName(prop.fieldNames[0])} !== 'undefined'`;
+                // STI subtypes with conflicting columns share the property, so another subtype's null column must not override it
+                if (prop.renamedFrom) {
+                    lines.push(`${padding}  ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
+                    defined = `${this.propName(prop.fieldNames[0])} != null`;
+                    const sharesColumn = meta.props.some(p => p !== prop && p.name === prop.name && p.fieldNames?.[0] === prop.fieldNames[0]);
+                    // hydrators expect mapped embeddable keys, so a shared object embeddable is mapped only for its own subtypes
+                    if (sharesColumn && prop.kind === ReferenceKind.EMBEDDED && prop.object && meta.discriminatorMap) {
+                        const owners = Object.entries(meta.discriminatorMap)
+                            .filter(([, cls]) => this.#metadata.find(cls)?.properties[prop.name]?.targetMeta === prop.targetMeta)
+                            .map(([value]) => `${this.propName(meta.discriminatorColumn)} == ${JSON.stringify(value)}`);
+                        defined += ` && (${owners.join(' || ')})`;
+                    }
+                    else if (sharesColumn) {
+                        // a column shared with a differently typed subtype is left for each subtype's hydrator to convert
+                        lines.push(`${padding}  if (${defined}) {`);
+                        lines.push(`${padding}    ret${this.wrap(prop.name)} = ${this.propName(prop.fieldNames[0])};`);
+                        lines.push(`${padding}  }`);
+                        continue;
+                    }
+                }
                 if (prop.runtimeType === 'boolean') {
-                    lines.push(`${padding}  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
+                    lines.push(`${padding}  if (${defined}) {`);
                     lines.push(`${padding}    ret${this.wrap(prop.name)} = ${this.propName(prop.fieldNames[0])} == null ? ${this.propName(prop.fieldNames[0])} : !!${this.propName(prop.fieldNames[0])};`);
                     lines.push(`${padding}    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
                     lines.push(`${padding}  }`);
                 }
                 else if (prop.runtimeType === 'Date' && !this.#platform.isNumericProperty(prop)) {
-                    lines.push(`${padding}  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
+                    lines.push(`${padding}  if (${defined}) {`);
                     context.set('parseDate', (value) => this.#platform.parseDate(value));
                     parseDate('ret' + this.wrap(prop.name), this.propName(prop.fieldNames[0]), padding);
                     lines.push(`${padding}    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
                     lines.push(`${padding}  }`);
                 }
+                else if (prop.customType instanceof DateType) {
+                    // tedious returns DATE columns as `Date`, map them to the string the entity holds, so the snapshot matches it
+                    context.set('convertDateToJSValue', (value) => this.#platform.convertDateToJSValue(value));
+                    lines.push(`${padding}  if (${defined}) {`);
+                    lines.push(`${padding}    ret${this.wrap(prop.name)} = ${this.propName(prop.fieldNames[0])} instanceof Date ? convertDateToJSValue(${this.propName(prop.fieldNames[0])}) : ${this.propName(prop.fieldNames[0])};`);
+                    lines.push(`${padding}    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
+                    lines.push(`${padding}  }`);
+                }
                 else if (prop.kind === ReferenceKind.EMBEDDED && (prop.object || meta.embeddable)) {
                     const idx = this.#tmpIndex++;
                     context.set(`mapEmbeddedResult_${idx}`, (data) => {
@@ -372,13 +413,13 @@ export class EntityComparator {
                         }
                         return item == null ? item : this.getResultMapper(prop.targetMeta)(item);
                     });
-                    lines.push(`${padding}  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
+                    lines.push(`${padding}  if (${defined}) {`);
                     lines.push(`${padding}    ret${this.wrap(prop.name)} = ${this.propName(prop.fieldNames[0])} == null ? ${this.propName(prop.fieldNames[0])} : mapEmbeddedResult_${idx}(${this.propName(prop.fieldNames[0])});`);
                     lines.push(`${padding}    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
                     lines.push(`${padding}  }`);
                 }
                 else if (prop.kind !== ReferenceKind.EMBEDDED) {
-                    lines.push(`${padding}  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
+                    lines.push(`${padding}  if (${defined}) {`);
                     lines.push(`${padding}    ret${this.wrap(prop.name)} = ${this.propName(prop.fieldNames[0])};`);
                     lines.push(`${padding}    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
                     lines.push(`${padding}  }`);
@@ -420,7 +461,7 @@ export class EntityComparator {
         lines.push(`  for (let k in result) { if (Object.hasOwn(result, k) && !mapped[k] && ret[k] === undefined${knownKeysGuard}) ret[k] = result[k]; }`);
         const code = `// compiled mapper for entity ${meta.className}\n` +
             `return function(result) {\n  const ret = {};\n${lines.join('\n')}\n  return ret;\n}`;
-        const fnKey = `resultMapper-${meta.uniqueName}`;
+        const fnKey = `resultMapper-${meta.compiledName}`;
         const resultMapper = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
         this.#mappers.set(meta, resultMapper);
         return resultMapper;
@@ -499,11 +540,22 @@ export class EntityComparator {
             }
             return true;
         }
+        // a same-named property of a different kind in another polymorphic variant applies only to its own variants
+        const guard = (childProp, code) => {
+            const variants = prop.targetMeta?.polymorphs?.filter(m => m.properties[childProp.embedded[1]]) ?? [];
+            const owners = variants.filter(m => Utils.isSameKind(m.properties[childProp.embedded[1]], childProp));
+            if (owners.length === variants.length) {
+                return code;
+            }
+            const discriminator = `entity${[...path, prop.targetMeta.discriminatorColumn].map(k => this.wrap(k)).join('')}`;
+            const conds = owners.map(m => `${discriminator} == ${JSON.stringify(m.discriminatorValue)}`);
+            return `${padding}  if (${conds.join(' || ')}) {\n${code}\n${padding}  }`;
+        };
+        const childProps = meta.props.filter(p => p.embedded?.[0] === prop.name &&
+            // object for JSON embeddable
+            (p.object || p.persist !== false));
         ret +=
-            meta.props
-                .filter(p => p.embedded?.[0] === prop.name &&
-                // object for JSON embeddable
-                (p.object || p.persist !== false))
+            childProps
                 .map(childProp => {
                 const childDataKey = meta.embeddable || prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
                 const childEntityKey = [...path, childProp.embedded[1]].map(k => this.wrap(k)).join('');
@@ -526,6 +578,7 @@ export class EntityComparator {
                 }
                 return `${padding}  if (${childCond}) ret${childDataKey} = clone(entity${childEntityKey});`;
             })
+                .map((code, i) => guard(childProps[i], code))
                 .join('\n') + `\n`;
         if (this.shouldSerialize(prop, dataKey)) {
             return `${ret + padding}  ret${dataKey} = cloneEmbeddable(ret${dataKey});\n${padding}}`;
@@ -608,9 +661,24 @@ export class EntityComparator {
                 ret += `        if (discriminator !== undefined) break;\n`;
                 ret += `        __cls${level} = Object.getPrototypeOf(__cls${level});\n`;
                 ret += `      }\n`;
-                ret += `      const pk = val${level}?.__helper?.__identifier && !val${level}?.__helper?.hasPrimaryKey()\n`;
-                ret += `        ? val${level}.__helper.__identifier\n`;
-                ret += `        : toArray(val${level}?.__helper?.getPrimaryKey(true));\n`;
+                if (prop.targetKey) {
+                    // the FK holds the `targetKey` value in the format of the actual target's column
+                    const targetKey = prop.targetKey;
+                    const targetKeyValueKey = `targetKeyValue_${this.safeKey(prop.name)}`;
+                    context.set(targetKeyValueKey, (val) => {
+                        const customType = val.__meta.properties[targetKey]?.customType;
+                        const value = val[targetKey];
+                        return customType
+                            ? customType.convertToDatabaseValue(value, this.#platform, { mode: 'serialization' })
+                            : value;
+                    });
+                    ret += `      const pk = ${targetKeyValueKey}(val${level});\n`;
+                }
+                else {
+                    ret += `      const pk = val${level}?.__helper?.__identifier && !val${level}?.__helper?.hasPrimaryKey()\n`;
+                    ret += `        ? val${level}.__helper.__identifier\n`;
+                    ret += `        : toArray(val${level}?.__helper?.getPrimaryKey(true));\n`;
+                }
                 ret += `      ret${dataKey} = new PolymorphicRef(discriminator, pk);\n`;
                 ret += `    }\n`;
             }
@@ -624,8 +692,8 @@ export class EntityComparator {
                 ret += `    } else if (typeof entity${entityKey} !== 'undefined') {\n`;
                 ret += `      const val${level} = entity${entityKey}${unwrap};\n`;
                 if (targetProp?.customType) {
-                    // If targetKey property has a custom type, convert to database value
-                    const convertorKey = this.registerCustomType(targetProp, context);
+                    // keyed by the relation name to avoid clashing with a same-named owner prop, the relation itself lacks the custom type with an explicit `columnType`
+                    const convertorKey = this.registerCustomType({ ...prop, customType: targetProp.customType }, context);
                     ret += `      ret${dataKey} = convertToDatabaseValue_${convertorKey}(val${level}${targetAccess});\n`;
                 }
                 else {
@@ -688,7 +756,7 @@ export class EntityComparator {
         lines.push(`}`);
         const code = `// compiled comparator for entity ${meta.className}\n` +
             `return function(last, current, options) {\n  const diff = {};\n${lines.join('\n')}\n  return diff;\n}`;
-        const fnKey = `comparator-${meta.uniqueName}`;
+        const fnKey = `comparator-${meta.compiledName}`;
         const comparator = Utils.createFunction(context, code, this.#config?.get('compiledFunctions'), fnKey);
         this.#comparators.set(meta, comparator);
         return comparator;

package/utils/QueryHelper.d.ts

@@ -35,11 +35,19 @@ export declare class QueryHelper {
      */
     static liftGroupOperators<T extends object>(where: Dictionary, meta: EntityMetadata<T>, metadata: MetadataStorage, key?: string): string | undefined;
     static inlinePrimaryKeyObjects<T extends object>(where: Dictionary, meta: EntityMetadata<T>, metadata: MetadataStorage, key?: string): boolean;
+    /**
+     * A bare value on a polymorphic relation would be compared to the discriminator column, so PK values are turned
+     * into a PK condition instead, e.g. `1` becomes `{ id: 1 }` and `[{ id: 1 }, { id: 2 }]` becomes `{ id: { $in: [1, 2] } }`.
+     * Null checks and `[type, id]` tuples keep their meaning.
+     */
+    private static inlinePolymorphicPrimaryKeys;
     /** Copies the plain object and array structure of the condition, keeping the leaf values (e.g. entities) by reference. */
     private static cloneWhere;
     static processWhere<T extends object>(options: ProcessWhereOptions<T>): FilterQuery<T>;
     /** @internal Splits a polymorphic target key like `imageable[Article]` into the property and target class names. */
     static splitPolymorphicKey(key: string): [string, string?];
+    /** @internal Resolves the targets of a polymorphic target key like `imageable[Article]` or `imageable[Product,Article]`. */
+    static findTargetMetas(prop: EntityProperty | null | undefined, key: string): EntityMetadata[];
     /** @internal Resolves the target entity of a condition key, including polymorphic target keys like `imageable[Article]`. */
     static findTargetMeta(prop: EntityProperty | null | undefined, key: string): EntityMetadata | undefined;
     /**
@@ -48,6 +56,12 @@ export declare class QueryHelper {
      * when more targets match. The first target alone keeps the regular relation join.
      */
     private static splitPolymorphicConditions;
+    /**
+     * Routes ordering by properties of polymorphic to-one relations to the targets that define them, e.g.
+     * `{ imageable: { name: 'asc' } }` becomes `{ 'imageable[Product,Article]': { name: 'asc' } }`, ordered by
+     * the first non-null value. Nested relations and formulas are ordered via the first target defining them.
+     */
+    private static splitPolymorphicOrderBy;
     /** Property names used in a condition, including those nested in group operators. */
     private static collectConditionKeys;
     static getActiveFilters<T>(meta: EntityMetadata<T>, options: FilterOptions | undefined, filters: Dictionary<FilterDef>): FilterDef[];

package/utils/QueryHelper.js

@@ -3,8 +3,8 @@ import { DANGEROUS_PROPERTY_NAMES, Utils } from './Utils.js';
 import { ARRAY_OPERATORS, GroupOperator, JSON_KEY_OPERATORS, ReferenceKind } from '../enums.js';
 import { JsonType } from '../types/JsonType.js';
 import { helper } from '../entity/wrap.js';
-import { isRaw, Raw } from './RawQueryFragment.js';
-import { MetadataError } from '../errors.js';
+import { isRaw, isSubquery, Raw } from './RawQueryFragment.js';
+import { MetadataError, ValidationError } from '../errors.js';
 /** @internal */
 export class QueryHelper {
     static SUPPORTED_OPERATORS = ['>', '<', '<=', '>=', '!', '!='];
@@ -102,10 +102,7 @@ export class QueryHelper {
         for (const k of keys) {
             const value = where[k];
             const prop = meta.properties[k];
-            // Polymorphic relations use multiple columns (discriminator + FK), so they cannot
-            // participate in the standard single-column FK expansion. Query by discriminator
-            // column directly instead, e.g. { likeableType: 'post', likeableId: 1 }.
-            if (!prop || ![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) || prop.polymorphic) {
+            if (!prop || ![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
                 continue;
             }
             const op = this.liftGroupOperators(value, prop.targetMeta, metadata, k);
@@ -130,7 +127,7 @@ export class QueryHelper {
         if (Array.isArray(where)) {
             where.forEach((item, i) => {
                 if (this.inlinePrimaryKeyObjects(item, meta, metadata, key)) {
-                    where[i] = Utils.getPrimaryKeyValues(item, meta, false);
+                    where[i] = Utils.getPrimaryKeyValues(item, meta, true);
                 }
             });
         }
@@ -160,6 +157,9 @@ export class QueryHelper {
         Object.keys(where).forEach(k => {
             const prop = meta.properties[QueryHelper.splitPolymorphicKey(k)[0]];
             const meta2 = metadata.find(QueryHelper.findTargetMeta(prop, k)?.class) || meta;
+            if (prop?.polymorphic) {
+                where[k] = this.inlinePolymorphicPrimaryKeys(where[k], meta2, prop);
+            }
             if (this.inlinePrimaryKeyObjects(where[k], meta2, metadata, k)) {
                 // Skip the PK collapse when an owning M:1/1:1 relation's FK column count does not match
                 // the target's PK column count (e.g. FK references target PK + an extra unique column).
@@ -177,6 +177,37 @@ export class QueryHelper {
         });
         return false;
     }
+    /**
+     * A bare value on a polymorphic relation would be compared to the discriminator column, so PK values are turned
+     * into a PK condition instead, e.g. `1` becomes `{ id: 1 }` and `[{ id: 1 }, { id: 2 }]` becomes `{ id: { $in: [1, 2] } }`.
+     * Null checks and `[type, id]` tuples keep their meaning.
+     */
+    static inlinePolymorphicPrimaryKeys(value, meta, prop) {
+        const pk = meta.primaryKeys[0];
+        const isScalar = (v) => v != null && !Array.isArray(v) && Utils.isPrimaryKey(v);
+        const isPrimaryKeyObject = (v) => Utils.isPlainObject(v) && Utils.getObjectKeysSize(v) === 1 && pk in v;
+        // lists of plain values are how `[type, id]` tuples get normalized (`{ $in: [type, id] }`), so only PK objects are inlined
+        const isList = (v) => Array.isArray(v) && v.length > 0 && v.every(isPrimaryKeyObject);
+        let cond;
+        if (isScalar(value)) {
+            cond = value;
+        }
+        else if (isList(value)) {
+            cond = { $in: value.map(v => v[pk]) };
+        }
+        else if (Utils.isPlainObject(value) &&
+            Utils.hasObjectKeys(value) &&
+            Object.entries(value).every(([op, v]) => Utils.isOperator(op) && !(op in GroupOperator) && op !== '$not' && (isScalar(v) || isList(v)))) {
+            cond = Object.fromEntries(Object.entries(value).map(([op, v]) => [op, isList(v) ? v.map(i => i[pk]) : v]));
+        }
+        else {
+            return value;
+        }
+        if (meta.compositePK) {
+            throw new ValidationError(`Polymorphic relation ${prop.name} targets entities with a composite primary key, use PK objects or entity references in the condition instead.`);
+        }
+        return { [pk]: cond };
+    }
     /** Copies the plain object and array structure of the condition, keeping the leaf values (e.g. entities) by reference. */
     static cloneWhere(where) {
         if (Array.isArray(where)) {
@@ -231,8 +262,10 @@ export class QueryHelper {
         if (!Utils.isPlainObject(where)) {
             return where;
         }
-        if (meta && options.type !== 'orderBy') {
-            where = QueryHelper.splitPolymorphicConditions(meta, where);
+        if (meta) {
+            where = (options.type === 'orderBy'
+                ? QueryHelper.splitPolymorphicOrderBy(meta, where)
+                : QueryHelper.splitPolymorphicConditions(meta, where));
         }
         return Utils.getObjectQueryKeys(where).reduce((o, key) => {
             let value = where[key];
@@ -280,6 +313,13 @@ export class QueryHelper {
                 o[key] = { [op]: value };
                 return o;
             }
+            // `$all` items are matched like separate `$some` payloads, so they need the same processing
+            if (key === '$all' && Array.isArray(value)) {
+                o[key] = value.map(item => Utils.isPlainObject(item)
+                    ? QueryHelper.processWhere({ ...options, where: item, entityName, root: false })
+                    : item);
+                return o;
+            }
             if (Utils.isPlainObject(value)) {
                 const targetMeta = customExpression ? undefined : QueryHelper.findTargetMeta(prop, key);
                 o[key] = QueryHelper.processWhere({
@@ -297,13 +337,18 @@ export class QueryHelper {
     }
     /** @internal Splits a polymorphic target key like `imageable[Article]` into the property and target class names. */
     static splitPolymorphicKey(key) {
-        const match = /^(\w+)\[(\w+)]$/.exec(key);
+        const match = /^(\w+)\[([\w,]+)]$/.exec(key);
         return match ? [match[1], match[2]] : [key];
     }
+    /** @internal Resolves the targets of a polymorphic target key like `imageable[Article]` or `imageable[Product,Article]`. */
+    static findTargetMetas(prop, key) {
+        const [, targetNames] = QueryHelper.splitPolymorphicKey(key);
+        const targets = targetNames?.split(',').map(name => prop?.polymorphTargets?.find(t => t.className === name));
+        return targets?.every(Boolean) ? targets : [];
+    }
     /** @internal Resolves the target entity of a condition key, including polymorphic target keys like `imageable[Article]`. */
     static findTargetMeta(prop, key) {
-        const [, targetName] = QueryHelper.splitPolymorphicKey(key);
-        return targetName ? prop?.polymorphTargets?.find(t => t.className === targetName) : prop?.targetMeta;
+        return QueryHelper.splitPolymorphicKey(key)[1] ? QueryHelper.findTargetMetas(prop, key)[0] : prop?.targetMeta;
     }
     /**
      * Routes conditions on polymorphic to-one relations to the targets that define all the queried properties,
@@ -342,6 +387,34 @@ export class QueryHelper {
         }
         return ret;
     }
+    /**
+     * Routes ordering by properties of polymorphic to-one relations to the targets that define them, e.g.
+     * `{ imageable: { name: 'asc' } }` becomes `{ 'imageable[Product,Article]': { name: 'asc' } }`, ordered by
+     * the first non-null value. Nested relations and formulas are ordered via the first target defining them.
+     */
+    static splitPolymorphicOrderBy(meta, orderBy) {
+        const ret = {};
+        for (const key of Utils.getObjectQueryKeys(orderBy)) {
+            const prop = meta.properties[key];
+            const value = orderBy[key];
+            if (!prop?.polymorphTargets ||
+                ![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) ||
+                !Utils.isPlainObject(value)) {
+                ret[key] = value;
+                continue;
+            }
+            for (const field of Utils.getObjectQueryKeys(value)) {
+                const found = prop.polymorphTargets.filter(target => field in target.properties);
+                const sharedPK = found.length === prop.polymorphTargets.length && found.every(target => target.primaryKeys.includes(field));
+                const single = Utils.isPlainObject(value[field]) || found.some(target => target.properties[field].formula);
+                const targets = found.length === 0 ? [prop.targetMeta] : single ? [found[0]] : found;
+                // shared PKs are ordered by the FK column without a join
+                const targetKey = sharedPK ? key : `${key}[${targets.map(target => target.className).join(',')}]`;
+                ret[targetKey] = { ...ret[targetKey], [field]: value[field] };
+            }
+        }
+        return ret;
+    }
     /** Property names used in a condition, including those nested in group operators. */
     static collectConditionKeys(payload) {
         return Object.keys(payload).flatMap(k => {
@@ -480,7 +553,8 @@ export class QueryHelper {
         if (Array.isArray(cond) && !(key && ARRAY_OPERATORS.includes(key))) {
             return cond.map(v => QueryHelper.processCustomType(prop, v, platform, key, fromQuery));
         }
-        if (isRaw(cond)) {
+        // a query builder renders as a sub-query, not as a value of the property type
+        if (isRaw(cond) || isSubquery(cond)) {
             return cond;
         }
         return prop.customType.convertToDatabaseValue(cond, platform, { fromQuery, key, mode: 'query' });
@@ -555,6 +629,9 @@ export class QueryHelper {
             if (expanded !== w) {
                 where[k] = expanded;
             }
+            else if (Array.isArray(w)) {
+                where[k] = w.map(expandItem);
+            }
             else if (Utils.isPlainObject(w)) {
                 for (const op of Object.keys(w)) {
                     if (!Utils.isOperator(op, false)) {

package/utils/RawQueryFragment.d.ts

@@ -1,11 +1,15 @@
-import type { AnyString, Dictionary, EntityKey } from '../typings.js';
+import type { AnyString, Dictionary, EntityKey, Subquery } from '../typings.js';
 declare const rawFragmentSymbolBrand: unique symbol;
 /** Branded symbol type used as a unique key for tracking raw SQL fragments in object properties. */
 export type RawQueryFragmentSymbol = symbol & {
     readonly [rawFragmentSymbolBrand]: true;
 };
+/** Prototype brand of query builders usable as sub-queries; a symbol so JSON payloads cannot carry it, `Symbol.for` so package copies agree. */
+export declare const SUBQUERY_BRAND: unique symbol;
 /** Checks whether the given value is a `RawQueryFragment` instance. */
 export declare function isRaw(value: unknown): value is RawQueryFragment;
+/** Checks whether the given value is a query builder usable as a sub-query (its prototype carries the `SUBQUERY_BRAND`). */
+export declare function isSubquery(value: unknown): value is Subquery;
 /** Represents a raw SQL fragment with optional parameters, usable as both a value and an object key via Symbol coercion. */
 export declare class RawQueryFragment<Alias extends string = string> {
     #private;