@mikro-orm/core 7.1.0-dev.34 → 7.1.0-dev.36

package/EntityManager.js

@@ -656,7 +656,7 @@ export class EntityManager {
         where = await em.processWhere(entityName, where, options, 'read');
         validateEmptyWhere(where);
         em.checkLockRequirements(options.lockMode, meta);
-        const isOptimisticLocking = options.lockMode == null || options.lockMode === LockMode.OPTIMISTIC;
+        const isOptimisticLocking = options.lockMode == null || options.lockMode === LockMode.NONE || options.lockMode === LockMode.OPTIMISTIC;
         if (entity && !em.shouldRefresh(meta, entity, options) && isOptimisticLocking) {
             return em.lockAndPopulate(meta, entity, where, options);
         }

package/entity/EntityLoader.js

@@ -690,8 +690,11 @@ export class EntityLoader {
             }
             return ret;
         }, []);
-        // we need to automatically select the FKs too, e.g. for 1:m relations to be able to wire them with the items
-        if (prop.kind === ReferenceKind.ONE_TO_MANY || prop.kind === ReferenceKind.MANY_TO_MANY) {
+        // we need to automatically select the FKs too, e.g. for 1:m and inverse 1:1 relations
+        // to be able to wire them with the items
+        if (prop.kind === ReferenceKind.ONE_TO_MANY ||
+            prop.kind === ReferenceKind.MANY_TO_MANY ||
+            (prop.kind === ReferenceKind.ONE_TO_ONE && !prop.owner)) {
             const owner = prop.targetMeta.properties[prop.mappedBy];
             // when the owning FK is lazy, we need to explicitly select it even without user-provided fields,
             // otherwise the driver will exclude it and we won't be able to map children to their parent collections

package/metadata/MetadataDiscovery.js

@@ -1603,7 +1603,7 @@ export class MetadataDiscovery {
         const table = this.createSchemaTable(meta);
         for (const check of meta.checks) {
             const fieldNames = check.property ? meta.properties[check.property].fieldNames : [];
-            check.name ??= this.#namingStrategy.indexName(meta.tableName, fieldNames, 'check');
+            check.name ??= this.#platform.getIndexName(meta.tableName, fieldNames, 'check');
             if (check.expression instanceof Function) {
                 check.expression = check.expression(columns, table);
             }
@@ -1628,7 +1628,7 @@ export class MetadataDiscovery {
                 }
                 if (expression) {
                     meta.checks.push({
-                        name: this.#namingStrategy.indexName(meta.tableName, prop.fieldNames, 'check'),
+                        name: this.#platform.getIndexName(meta.tableName, prop.fieldNames, 'check'),
                         property: prop.name,
                         expression,
                     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.1.0-dev.34",
+  "version": "7.1.0-dev.36",
   "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",

package/platforms/Platform.d.ts

@@ -278,9 +278,17 @@ export declare abstract class Platform {
     /** Whether the platform supports unsigned integer columns. */
     supportsUnsigned(): boolean;
     /**
-     * Returns the default name of index for the given columns
+     * Maximum length of identifiers (table, column, index, constraint, …) the platform supports.
+     * Names produced by {@link getIndexName} above this limit are hash-truncated. Defaults to
+     * `Infinity` (no truncation); SQL platforms override with their engine's limit
+     * (PG 63, MySQL/MariaDB 64, MSSQL/Oracle 128).
      */
-    getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence'): string;
+    getMaxIdentifierLength(): number;
+    /**
+     * Returns the default name of index for the given columns, hash-truncated if it would
+     * exceed {@link getMaxIdentifierLength}.
+     */
+    getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence' | 'check'): string;
     /** Returns the default primary key constraint name. */
     getDefaultPrimaryName(tableName: string, columns: string[]): string;
     /** Whether the platform supports custom names for primary key constraints. */

package/platforms/Platform.js

@@ -630,10 +630,26 @@ export class Platform {
         return false;
     }
     /**
-     * Returns the default name of index for the given columns
+     * Maximum length of identifiers (table, column, index, constraint, …) the platform supports.
+     * Names produced by {@link getIndexName} above this limit are hash-truncated. Defaults to
+     * `Infinity` (no truncation); SQL platforms override with their engine's limit
+     * (PG 63, MySQL/MariaDB 64, MSSQL/Oracle 128).
+     */
+    getMaxIdentifierLength() {
+        return Infinity;
+    }
+    /**
+     * Returns the default name of index for the given columns, hash-truncated if it would
+     * exceed {@link getMaxIdentifierLength}.
      */
     getIndexName(tableName, columns, type) {
-        return this.namingStrategy.indexName(tableName, columns, type);
+        const indexName = this.namingStrategy.indexName(tableName, columns, type);
+        const max = this.getMaxIdentifierLength();
+        if (indexName.length > max) {
+            const suffix = type === 'primary' ? 'pkey' : type;
+            return `${indexName.substring(0, max - 8 - type.length)}_${Utils.hash(indexName, 5)}_${suffix}`;
+        }
+        return indexName;
     }
     /** Returns the default primary key constraint name. */
     getDefaultPrimaryName(tableName, columns) {

package/typings.js

@@ -193,9 +193,10 @@ export class EntityMetadata {
         // Virtual entities evaluate expressions at query time, view entities create actual database views.
         this.virtual = !!this.expression && !this.view;
         if (config) {
+            const platform = config.getPlatform();
             for (const prop of this.props) {
                 if (prop.enum && !prop.nativeEnumName && prop.items?.every(item => typeof item === 'string')) {
-                    const name = config.getNamingStrategy().indexName(this.tableName, prop.fieldNames, 'check');
+                    const name = platform.getIndexName(this.tableName, prop.fieldNames, 'check');
                     const exists = this.checks.findIndex(check => check.name === name);
                     if (exists !== -1) {
                         this.checks.splice(exists, 1);
@@ -203,9 +204,7 @@ export class EntityMetadata {
                     this.checks.push({
                         name,
                         property: prop.name,
-                        expression: config
-                            .getPlatform()
-                            .getEnumCheckConstraintExpression(prop.fieldNames[0], prop.items),
+                        expression: platform.getEnumCheckConstraintExpression(prop.fieldNames[0], prop.items),
                     });
                 }
             }

package/unit-of-work/UnitOfWork.js

@@ -470,7 +470,7 @@ export class UnitOfWork {
         if (options.lockMode === LockMode.OPTIMISTIC) {
             await this.lockOptimistic(entity, meta, options.lockVersion);
         }
-        else if (options.lockMode != null) {
+        else if (options.lockMode != null && options.lockMode !== LockMode.NONE) {
             await this.lockPessimistic(entity, options);
         }
     }

package/utils/Utils.js

@@ -141,7 +141,7 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.1.0-dev.34';
+    static #ORM_VERSION = '7.1.0-dev.36';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */