@mikro-orm/sql 7.3.0-dev.5 → 7.3.0-dev.7

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;

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

@@ -387,6 +387,8 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
       data_type,
       is_identity,
       identity_generation,
+      identity_start,
+      identity_increment,
       generation_expression,
       pg_catalog.col_description(pgc.oid, cols.ordinal_position::int) column_comment,
       coll.collname as collation_name
@@ -433,6 +435,14 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                 type += `(${col.numeric_precision},${col.numeric_scale})`;
             }
             const length = this.inferLengthFromColumnType(type) === -1 ? -1 : col.length;
+            // a descending sequence starts at -1 by default
+            const defaultIdentityStart = col.identity_increment?.startsWith('-') ? '-1' : '1';
+            // read back non-default identity options, so `identity (start with 1000)` does not diff against plain `identity`
+            const identityOptions = [
+                col.identity_start !== defaultIdentityStart && `start with ${col.identity_start}`,
+                col.identity_increment !== '1' && `increment by ${col.identity_increment}`,
+            ].filter(Boolean);
+            const identitySuffix = identityOptions.length > 0 ? ` (${identityOptions.join(' ')})` : '';
             const column = {
                 name: col.column_name,
                 type,
@@ -445,9 +455,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                 unsigned: increments,
                 autoincrement: increments,
                 generated: col.is_identity === 'YES'
-                    ? col.identity_generation === 'BY DEFAULT'
-                        ? 'by default as identity'
-                        : 'identity'
+                    ? (col.identity_generation === 'BY DEFAULT' ? 'by default as identity' : 'identity') + identitySuffix
                     : col.generation_expression
                         ? col.generation_expression + ' stored'
                         : undefined,
@@ -1032,7 +1040,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                     columnType = this.quote(columnType);
                 }
             }
-            if (column.generated === 'by default as identity') {
+            if (column.generated?.startsWith('by default as identity')) {
                 columnType += ` generated ${column.generated}`;
             }
             else if (column.generated) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.3.0-dev.5",
+  "version": "7.3.0-dev.7",
   "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.3.0-dev.5"
+    "@mikro-orm/core": "7.3.0-dev.7"
   },
   "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/ObjectCriteriaNode.js

@@ -368,7 +368,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/schema/SchemaHelper.js

@@ -478,6 +478,15 @@ export class SchemaHelper {
             ret.push(this.createIndex(index, diff.toTable));
         }
         for (const index of Object.values(diff.changedIndexes)) {
+            const addedColumn = diff.addedColumns[index.columnNames[0]];
+            // an added autoincrement PK column already declares the primary key inline
+            if (index.primary &&
+                !index.composite &&
+                addedColumn?.autoincrement &&
+                addedColumn.primary &&
+                !this.hasNonDefaultPrimaryKeyName(diff.toTable)) {
+                continue;
+            }
             ret.push(this.createIndex(index, diff.toTable, true));
         }
         for (const [oldIndexName, index] of Object.entries(diff.renamedIndexes)) {