@mikro-orm/sql 7.2.2-dev.8 → 7.2.2

package/AbstractSqlDriver.js

@@ -850,9 +850,13 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 props.forEach(prop => {
                     // For STI with conflicting fieldNames, use discriminator to determine which field gets value
                     if (prop.stiFieldNames && prop.stiFieldNameMap && meta.discriminatorColumn) {
-                        const activeField = prop.stiFieldNameMap[row[meta.discriminatorColumn]];
+                        // the map misses subtypes whose props were not initialized yet during discovery (root column owner, grandchildren)
+                        const discriminator = row[meta.discriminatorColumn];
+                        const childClass = meta.discriminatorMap?.[discriminator];
+                        const activeField = prop.stiFieldNameMap[discriminator] ??
+                            (childClass && this.metadata.find(childClass)?.properties[prop.name]?.fieldNames[0]);
                         for (const field of prop.stiFieldNames) {
-                            params.push(field === activeField ? row[prop.name] : null);
+                            params.push(field === activeField ? (row[prop.name] ?? null) : null);
                             keys.push('?');
                         }
                         return;
@@ -1809,7 +1813,11 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (!this.platform.shouldHaveColumn(prop, populate, exclude)) {
             return false;
         }
-        if (!fields || fields.includes('*') || prop.primary || meta.root.discriminatorColumn === prop.name) {
+        if (!fields ||
+            fields.includes('*') ||
+            prop.primary ||
+            meta.root.discriminatorColumn === prop.name ||
+            meta.root.targetKeys?.includes(prop.name)) {
             return true;
         }
         return fields.some(f => f === prop.name || f.toString().startsWith(prop.name + '.'));
@@ -1865,11 +1873,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
                         const tptMeta = this.metadata.get(targetMeta.class);
                         this.addTPTPolymorphicJoinsForRelation(qb, tptMeta, tableAlias, fields);
                     }
-                    if (ref) {
-                        // For filter :ref hints, schedule filter check for each target (no field selection)
-                        qb.scheduleFilterCheck(targetPath);
-                    }
-                    else {
+                    // target filters apply per target, both for filter :ref hints and populated relations
+                    qb.scheduleFilterCheck(targetPath);
+                    if (!ref) {
                         // Select fields from each target table
                         fields.push(...this.getFieldsForJoinedLoad(qb, targetMeta, {
                             ...options,
@@ -2469,6 +2475,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
             }
             if (!options.fields.includes('*') && !options.fields.includes(`${qb.alias}.*`)) {
                 ret.unshift(...meta.primaryKeys.filter(pk => !options.fields.includes(pk)));
+                // `targetKey` values identify the entity like its PK, references resolve it by them
+                ret.push(...(meta.root.targetKeys ?? []).filter(key => meta.properties[key] && !options.fields.includes(key)));
             }
             if (meta.root.inheritanceType === 'sti' &&
                 !options.fields.includes(`${qb.alias}.${meta.root.discriminatorColumn}`)) {

package/SqlEntityManager.js

@@ -1,4 +1,4 @@
-import { EntityManager, raw, Utils, } from '@mikro-orm/core';
+import { EntityManager, QueryFlag, raw, Utils, } from '@mikro-orm/core';
 import { MikroKyselyPlugin } from './plugin/index.js';
 /**
  * @inheritDoc
@@ -87,6 +87,7 @@ export class SqlEntityManager extends EntityManager {
         // match `em.count()` semantics: an active transaction always wins over the requested connection type
         const connectionType = em.getTransactionContext() ? 'write' : options.connectionType;
         const qb = em.createQueryBuilder(meta.class, undefined, connectionType);
+        qb.unsetFlag(QueryFlag.CONVERT_CUSTOM_TYPES);
         qb
             .select([...fields, raw('count(*) as cnt')])
             .where(where)

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -419,7 +419,11 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             if ((col.udt_name === 'geometry' || col.udt_name === 'geography') && col.format_type) {
                 type = col.format_type;
             }
-            if (type === 'vector' && col.length == null && col.custom_length != null && col.custom_length !== -1) {
+            // pgvector stores the dimension in atttypmod for all three of its vector types
+            if (['vector', 'halfvec', 'sparsevec'].includes(type) &&
+                col.length == null &&
+                col.custom_length != null &&
+                col.custom_length !== -1) {
                 col.length = col.custom_length;
             }
             if (col.length != null && !type.endsWith(`(${col.length})`) && !['text', 'date'].includes(type)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.2.2-dev.8",
+  "version": "7.2.2",
   "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.",
   "keywords": [
     "data-mapper",
@@ -50,10 +50,10 @@
     "kysely": "0.29.6"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.2.1"
+    "@mikro-orm/core": "^7.2.2"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.2.2-dev.8"
+    "@mikro-orm/core": "7.2.2"
   },
   "engines": {
     "node": ">= 22.17.0"

package/plugin/transformer.d.ts

@@ -92,6 +92,7 @@ export declare class MikroTransformer extends OperationNodeTransformer {
      * This is called for SELECT queries when columnNamingStrategy is 'property'
      */
     transformResult(rows: Record<string, any>[] | undefined, entityMap: Map<string, EntityMetadata>): Record<string, any>[] | undefined;
+    private getResultMaps;
     buildGlobalFieldMap(entityMap: Map<string, EntityMetadata>): Record<string, EntityProperty>;
     buildGlobalRelationFieldMap(entityMap: Map<string, EntityMetadata>): Record<string, string>;
     /**
@@ -108,6 +109,6 @@ export declare class MikroTransformer extends OperationNodeTransformer {
     /**
      * Transform a single row by mapping column names to property names
      */
-    transformRow(row: Record<string, any>, fieldToPropertyMap: Record<string, EntityProperty>, relationFieldMap: Record<string, string>): Record<string, any>;
+    transformRow(row: Record<string, any>, fieldEntries: [string, EntityProperty][], relationEntries: [string, string][]): Record<string, any>;
     prepareOutputValue(prop: EntityProperty | undefined, value: unknown): unknown;
 }

package/plugin/transformer.js

@@ -1,5 +1,12 @@
 import { ReferenceKind, isRaw, } from '@mikro-orm/core';
 import { AliasNode, ColumnNode, ColumnUpdateNode, IdentifierNode, OperationNodeTransformer, PrimitiveValueListNode, RawNode, ReferenceNode, SchemableIdentifierNode, SelectAllNode, SelectionNode, TableNode, ValueListNode, ValueNode, ValuesNode, } from 'kysely';
+/** Past this many query shapes the cache of one metadata storage starts over, so generated aliases cannot grow it. */
+const RESULT_MAPS_LIMIT = 1000;
+/**
+ * Result maps per query shape (the aliases and entities of its entity map). They are derived from metadata alone, so
+ * they are built once and shared by every transformer, as `getKysely()` creates a new one per call.
+ */
+const resultMapsCache = new WeakMap();
 const EXPANDABLE_KINDS = new Set([
     ReferenceKind.SCALAR,
     ReferenceKind.EMBEDDED,
@@ -884,12 +891,7 @@ export class MikroTransformer extends OperationNodeTransformer {
         if (byEntity) {
             return byEntity;
         }
-        const allMetadata = Array.from(this.#metadata);
-        const byTable = allMetadata.find(m => m.tableName === name);
-        if (byTable) {
-            return byTable;
-        }
-        return undefined;
+        return this.#metadata.getByTableName(name);
     }
     /**
      * Transform result rows by mapping database column names to property names
@@ -906,11 +908,35 @@ export class MikroTransformer extends OperationNodeTransformer {
         if (entityMap.size === 0) {
             return rows;
         }
-        // Build a global mapping from database field names to property objects
-        const fieldToPropertyMap = this.buildGlobalFieldMap(entityMap);
-        const relationFieldMap = this.buildGlobalRelationFieldMap(entityMap);
+        // The global mapping from database field names to property objects, built once per query shape
+        const { fields, relations } = this.getResultMaps(entityMap);
         // Transform each row
-        return rows.map(row => this.transformRow(row, fieldToPropertyMap, relationFieldMap));
+        return rows.map(row => this.transformRow(row, fields, relations));
+    }
+    getResultMaps(entityMap) {
+        let byShape = resultMapsCache.get(this.#metadata);
+        if (!byShape) {
+            byShape = new Map();
+            resultMapsCache.set(this.#metadata, byShape);
+        }
+        let shape = '';
+        for (const [alias, meta] of entityMap) {
+            shape += `${alias}\0${meta._id}\0`;
+        }
+        const cached = byShape.get(shape);
+        if (cached && Array.from(entityMap.values()).every((meta, i) => meta.props === cached.props[i])) {
+            return cached;
+        }
+        if (byShape.size >= RESULT_MAPS_LIMIT) {
+            byShape.clear();
+        }
+        const maps = {
+            props: Array.from(entityMap.values(), meta => meta.props),
+            fields: Object.entries(this.buildGlobalFieldMap(entityMap)),
+            relations: Object.entries(this.buildGlobalRelationFieldMap(entityMap)),
+        };
+        byShape.set(shape, maps);
+        return maps;
     }
     buildGlobalFieldMap(entityMap) {
         const map = {};
@@ -986,10 +1012,10 @@ export class MikroTransformer extends OperationNodeTransformer {
     /**
      * Transform a single row by mapping column names to property names
      */
-    transformRow(row, fieldToPropertyMap, relationFieldMap) {
+    transformRow(row, fieldEntries, relationEntries) {
         const transformed = { ...row };
         // First pass: map regular fields from fieldName to propertyName and convert values
-        for (const [fieldName, prop] of Object.entries(fieldToPropertyMap)) {
+        for (const [fieldName, prop] of fieldEntries) {
             if (!(fieldName in transformed)) {
                 continue;
             }
@@ -1011,7 +1037,7 @@ export class MikroTransformer extends OperationNodeTransformer {
         // Second pass: handle relation fields
         // Only run if columnNamingStrategy is 'property', as we don't want to rename FKs otherwise
         if (this.#options.columnNamingStrategy === 'property') {
-            for (const [fieldName, relationPropertyName] of Object.entries(relationFieldMap)) {
+            for (const [fieldName, relationPropertyName] of relationEntries) {
                 if (fieldName in transformed && !(relationPropertyName in transformed)) {
                     // Move the foreign key value to the relation property name
                     transformed[relationPropertyName] = transformed[fieldName];

package/query/NativeQueryBuilder.d.ts

@@ -127,7 +127,7 @@ export declare class NativeQueryBuilder implements Subquery {
     as(alias: string): this;
     toRaw(): RawQueryFragment;
     protected compileSelect(): void;
-    /** Whether this COUNT query needs a subquery wrapper for multi-column distinct. */
+    /** Whether this COUNT query needs a subquery wrapper: multi-column distinct, or `distinct on` (keeps the null group). */
     protected needsCountSubquery(): boolean;
     protected getFields(countSubquery?: boolean): string;
     protected compileInsert(): void;

package/query/NativeQueryBuilder.js

@@ -330,12 +330,12 @@ export class NativeQueryBuilder {
             this.parts.push(`)${asKeyword}${this.quote('dcnt')}`);
         }
     }
-    /** Whether this COUNT query needs a subquery wrapper for multi-column distinct. */
+    /** Whether this COUNT query needs a subquery wrapper: multi-column distinct, or `distinct on` (keeps the null group). */
     needsCountSubquery() {
         return (this.type === QueryType.COUNT &&
             !!this.options.distinct &&
-            this.options.select.length > 1 &&
-            !this.platform.supportsMultiColumnCountDistinct());
+            ((this.options.select.length > 1 && !this.platform.supportsMultiColumnCountDistinct()) ||
+                !!this.options.distinctOn));
     }
     getFields(countSubquery) {
         if (!this.options.select || this.options.select.length === 0) {

package/query/ObjectCriteriaNode.js

@@ -186,8 +186,9 @@ export class ObjectCriteriaNode extends CriteriaNode {
         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));
+                    // $not wrapping non-operator conditions (entity props) or an empty one should be inlined
+                    const inner = Utils.getObjectQueryKeys(payload[k]);
+                    return inner.length > 0 && inner.every(ik => Utils.isOperator(ik, false));
                 }
                 return Utils.isOperator(k, false);
             });
@@ -218,9 +219,12 @@ export class ObjectCriteriaNode extends CriteriaNode {
             }
             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]);
+                (!Utils.hasObjectKeys(payload[k]) ||
+                    Utils.getObjectQueryKeys(payload[k]).some(ik => !Utils.isOperator(ik, false)))) {
+                // $not wraps entity conditions (from auto-join) or an empty one, inline at current level with the same key mapping
+                const inner = {};
+                this.inlineChildPayload(inner, payload[k], field, alias, childAlias);
+                this.inlineCondition(k, o, inner);
             }
             else if (Utils.isOperator(k, false)) {
                 const tmp = payload[k];
@@ -291,6 +295,13 @@ export class ObjectCriteriaNode extends CriteriaNode {
             });
         const primaryKeys = knownKey &&
             keys.every(key => {
+                if (key === '$not') {
+                    // e.g. `{ author: { $not: { id: 1 } } }` compares the FK column, relation PKs still need the join
+                    const childPayload = this.payload[key].payload;
+                    return (Utils.isPlainObject(childPayload) &&
+                        Utils.getObjectQueryKeys(childPayload).every(k => meta.primaryKeys.includes(k) &&
+                            meta.properties[k].kind === ReferenceKind.SCALAR));
+                }
                 if (typeof key !== 'string' || !meta.primaryKeys.includes(key)) {
                     return false;
                 }
@@ -320,7 +331,9 @@ export class ObjectCriteriaNode extends CriteriaNode {
         else {
             const prev = qb.state.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;
+            // ordering must not drop rows whose polymorphic relation points to another target
+            const orderByPolymorphic = this.prop.polymorphic && options?.type === 'orderBy';
+            const joinType = toOneProperty && !this.prop.nullable && !orderByPolymorphic ? JoinType.innerJoin : JoinType.leftJoin;
             qb[method](field, nestedAlias, undefined, joinType, path);
             if (!qb.hasFlag(QueryFlag.INFER_POPULATE)) {
                 qb.state.fields = prev;

package/query/QueryBuilder.js

@@ -257,7 +257,11 @@ export class QueryBuilder {
         if (field) {
             this.#state.fields = Utils.asArray(field);
         }
-        else if (distinct || this.hasToManyJoins()) {
+        else if (this.#state.distinctOn) {
+            this.#state.fields = this.#state.distinctOn;
+            distinct = true;
+        }
+        else if (distinct || this.#state.flags.has(QueryFlag.DISTINCT) || this.hasToManyJoins()) {
             this.#state.fields = this.mainAlias.meta.primaryKeys;
         }
         else {
@@ -1028,9 +1032,11 @@ export class QueryBuilder {
      * @internal
      */
     addPolymorphicJoin(prop, targetMeta, ownerAlias, alias, type, path, schema) {
-        // Override referencedColumnNames to use the specific target's PK columns
+        // Override referencedColumnNames to use the specific target's PK (or `targetKey`) columns
         // (polymorphic targets may have different PK column names, e.g. org_id vs user_id)
-        const referencedColumnNames = targetMeta.getPrimaryProps().flatMap(pk => pk.fieldNames);
+        const referencedColumnNames = prop.targetKey
+            ? targetMeta.properties[prop.targetKey].fieldNames
+            : targetMeta.getPrimaryProps().flatMap(pk => pk.fieldNames);
         const targetProp = { ...prop, targetMeta, referencedColumnNames };
         const aliasedName = `${ownerAlias}.${prop.name}[${targetMeta.className}]#${alias}`;
         this.#state.joins[aliasedName] = this.helper.joinManyToOneReference(targetProp, ownerAlias, alias, type, {}, schema);
@@ -1566,7 +1572,7 @@ export class QueryBuilder {
                 return;
             }
             if (prop?.embedded || (prop?.kind === ReferenceKind.EMBEDDED && prop.object)) {
-                const name = prop.embeddedPath?.join('.') ?? prop.fieldNames[0];
+                const name = prop.formula ? prop.name : (prop.embeddedPath?.join('.') ?? prop.fieldNames[0]);
                 const aliased = this.#state.aliases[a] ? `${a}.${name}` : name;
                 ret.push(getFieldName(aliased, customAlias));
                 return;
@@ -1581,11 +1587,11 @@ export class QueryBuilder {
                 }
                 const nest = (prop) => {
                     for (const childProp of Object.values(prop.embeddedProps)) {
-                        if (childProp.persist === false) {
+                        if (childProp.persist === false && !childProp.formula) {
                             continue;
                         }
                         if (childProp.fieldNames && (childProp.kind !== ReferenceKind.EMBEDDED || childProp.object)) {
-                            const name = childProp.fieldNames[0];
+                            const name = childProp.formula ? childProp.name : childProp.fieldNames[0];
                             ret.push(getFieldName(this.#state.aliases[a] ? `${a}.${name}` : name));
                         }
                         else {
@@ -1666,7 +1672,8 @@ export class QueryBuilder {
                         return `${currentAlias}.${embeddedProp.fieldNames[0]}`;
                     }
                 }
-                return `${currentAlias}.${embeddedProp?.fieldNames?.[0] ?? propName}`;
+                const name = embeddedProp?.formula ? embeddedProp.name : (embeddedProp?.fieldNames?.[0] ?? propName);
+                return `${currentAlias}.${name}`;
             }
             // Handle relations - auto-join if not the last part
             if (prop.kind === ReferenceKind.MANY_TO_ONE ||
@@ -1759,6 +1766,9 @@ export class QueryBuilder {
             case QueryType.COUNT: {
                 const fields = this.#state.fields.map(f => this.helper.mapper(f, this.type, undefined, undefined, schema));
                 qb.count(fields, this.#state.flags.has(QueryFlag.DISTINCT));
+                if (this.#state.distinctOn && this.#state.flags.has(QueryFlag.DISTINCT)) {
+                    qb.distinctOn(this.prepareFields(this.#state.distinctOn, 'where', schema));
+                }
                 this.helper.processJoins(qb, this.#state.joins, joinSchema, schemaOverride);
                 break;
             }
@@ -2322,7 +2332,10 @@ export class QueryBuilder {
                     const fieldName = this.helper.mapper(field, this.type, undefined, null);
                     // virtual fields (e.g. `qb.as(...)`) have no column to reference inside `min()`; inline their
                     // expression instead, as a select alias is not resolvable there on some dialects (e.g. PostgreSQL)
-                    const virtual = !prop?.persist && !prop?.formula && !prop?.hasConvertToJSValueSQL && !pks.includes(fieldName)
+                    const virtual = (!prop || prop.persist === false) &&
+                        !prop?.formula &&
+                        !prop?.hasConvertToJSValueSQL &&
+                        !pks.includes(fieldName)
                         ? this.resolveVirtualField(f, fieldName)
                         : undefined;
                     const expr = virtual ? virtual.expr : this.platform.quoteIdentifier(fieldName);

package/query/QueryBuilderHelper.js

@@ -112,7 +112,7 @@ export class QueryBuilderHelper {
         const aliasPrefix = isTableNameAliasRequired ? resolvedAlias + '.' : '';
         const fkIdx2 = prop?.fieldNames.findIndex(name => name === f) ?? -1;
         const fkIdx = fkIdx2 === -1 ? 0 : fkIdx2;
-        if (a === prop?.embedded?.[0]) {
+        if (a === prop?.embedded?.[0] && !prop.formula) {
             return aliasPrefix + prop.fieldNames[fkIdx];
         }
         const noPrefix = prop?.persist === false;
@@ -120,12 +120,13 @@ export class QueryBuilderHelper {
             return raw(this.prefix(field, isTableNameAliasRequired));
         }
         if (prop?.formula) {
-            const alias2 = this.#platform.quoteIdentifier(a).toString();
+            const formulaAlias = isTableAlias ? a : this.#alias;
+            const alias2 = this.#platform.quoteIdentifier(formulaAlias).toString();
             const aliasName = alias === undefined ? prop.fieldNames[0] : alias;
             const as = aliasName === null ? '' : ` as ${this.#platform.quoteIdentifier(aliasName)}`;
             const meta = this.#aliasMap[a]?.meta ?? this.#metadata.get(this.#entityName);
             const table = this.createFormulaTable(alias2, meta, schema);
-            const columns = meta.createColumnMappingObject(p => this.getTPTAliasForProperty(p.name, a), alias2);
+            const columns = meta.createColumnMappingObject(p => this.getTPTAliasForProperty(p.name, formulaAlias), alias2);
             let value = this.#driver.evaluateFormula(prop.formula, columns, table);
             if (!this.isTableNameAliasRequired(type)) {
                 value = value.replaceAll(alias2 + '.', '');