@mikro-orm/core 7.1.0-dev.9 → 7.1.1-dev.0

package/platforms/Platform.d.ts

@@ -43,6 +43,8 @@ export declare abstract class Platform {
     getEnumArrayCheckConstraintExpression(column: string, items: string[]): string | null;
     /** Whether this platform supports materialized views. */
     supportsMaterializedViews(): boolean;
+    /** Whether this platform supports declarative table partitioning in schema generation. */
+    supportsPartitionedTables(): boolean;
     /** Returns the schema helper instance for this platform, or undefined if not supported. */
     getSchemaHelper(): unknown;
     /** Whether the platform automatically creates indexes on foreign key columns. */
@@ -168,7 +170,7 @@ export declare abstract class Platform {
     getUuidTypeDeclarationSQL(column: {
         length?: number;
     }): string;
-    /** Extracts the base type name from a full SQL type declaration (e.g. "varchar(255)" -> "varchar"). */
+    /** Extracts the base type name from a full SQL type declaration (e.g. `varchar(255)` -> `varchar`). */
     extractSimpleType(type: string): string;
     /**
      * This should be used only to compare types, it can strip some information like the length.
@@ -276,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

@@ -2,12 +2,22 @@ import { clone } from '../utils/clone.js';
 import { EntityRepository } from '../entity/EntityRepository.js';
 import { UnderscoreNamingStrategy } from '../naming-strategy/UnderscoreNamingStrategy.js';
 import { ExceptionConverter } from './ExceptionConverter.js';
+import { MetadataError } from '../errors.js';
 import { ArrayType, BigIntType, BlobType, BooleanType, CharacterType, DateTimeType, DateType, DecimalType, DoubleType, EnumType, FloatType, IntegerType, IntervalType, JsonType, MediumIntType, SmallIntType, StringType, TextType, TimeType, TinyIntType, Type, Uint8ArrayType, UnknownType, UuidType, } from '../types/index.js';
 import { parseJsonSafe, Utils } from '../utils/Utils.js';
 import { ReferenceKind } from '../enums.js';
 import { Raw } from '../utils/RawQueryFragment.js';
 /** Symbol used to tag cloned embeddable data for JSON serialization handling. */
 export const JsonProperty = Symbol('JsonProperty');
+const MULTI_WORD_SQL_TYPES = [
+    'timestamp with time zone',
+    'timestamp without time zone',
+    'time with time zone',
+    'time without time zone',
+    'character varying',
+    'double precision',
+    'bit varying',
+];
 /** Abstract base class providing database-specific behavior and SQL dialect differences. */
 export class Platform {
     exceptionConverter = new ExceptionConverter();
@@ -62,6 +72,10 @@ export class Platform {
     supportsMaterializedViews() {
         return false;
     }
+    /** Whether this platform supports declarative table partitioning in schema generation. */
+    supportsPartitionedTables() {
+        return false;
+    }
     /** Returns the schema helper instance for this platform, or undefined if not supported. */
     getSchemaHelper() {
         return undefined;
@@ -222,9 +236,15 @@ export class Platform {
         column.length ??= 36;
         return this.getVarcharTypeDeclarationSQL(column);
     }
-    /** Extracts the base type name from a full SQL type declaration (e.g. "varchar(255)" -> "varchar"). */
+    /** Extracts the base type name from a full SQL type declaration (e.g. `varchar(255)` -> `varchar`). */
     extractSimpleType(type) {
-        return /[^(), ]+/.exec(type.toLowerCase())[0];
+        const lower = type.toLowerCase();
+        for (const multiWord of MULTI_WORD_SQL_TYPES) {
+            if (lower.startsWith(multiWord)) {
+                return multiWord;
+            }
+        }
+        return /[^(), ]+/.exec(lower)[0];
     }
     /**
      * This should be used only to compare types, it can strip some information like the length.
@@ -248,6 +268,7 @@ export class Platform {
                 return Type.getType(CharacterType);
             case 'string':
             case 'varchar':
+            case 'character varying':
                 return Type.getType(StringType);
             case 'interval':
                 return Type.getType(IntervalType);
@@ -267,6 +288,7 @@ export class Platform {
             case 'float':
                 return Type.getType(FloatType);
             case 'double':
+            case 'double precision':
                 return Type.getType(DoubleType);
             case 'integer':
                 return Type.getType(IntegerType);
@@ -286,8 +308,12 @@ export class Platform {
                 return Type.getType(DateType);
             case 'datetime':
             case 'timestamp':
+            case 'timestamp with time zone':
+            case 'timestamp without time zone':
                 return Type.getType(DateTimeType);
             case 'time':
+            case 'time with time zone':
+            case 'time without time zone':
                 return Type.getType(TimeType);
             case 'object':
             case 'json':
@@ -513,7 +539,8 @@ export class Platform {
         if (raw) {
             return this.formatQuery(raw.sql, raw.params);
         }
-        return `${quote}${id.toString().replace('.', `${quote}.${quote}`)}${quote}`;
+        const escaped = id.toString().replaceAll(quote, quote + quote);
+        return `${quote}${escaped.replace('.', `${quote}.${quote}`)}${quote}`;
     }
     /** Quotes a literal value for safe embedding in SQL. */
     quoteValue(value) {
@@ -603,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) {
@@ -658,7 +701,9 @@ export class Platform {
     }
     /** Platform-specific validation of entity metadata. */
     validateMetadata(meta) {
-        return;
+        if (meta.partitionBy && !this.supportsPartitionedTables()) {
+            throw new MetadataError(`Entity ${meta.className} uses partitionBy, but ${this.constructor.name} does not support partitioned tables`);
+        }
     }
     /**
      * Generates a custom order by statement given a set of in order values, eg.

package/serialization/EntitySerializer.js

@@ -16,7 +16,8 @@ function isVisible(meta, propName, options) {
     if (Array.isArray(options.fields) && options.fields.length > 0 && !matchesPath(options.fields, propName)) {
         return false;
     }
-    if (Array.isArray(options.populate) && matchesPath(options.populate, propName)) {
+    if (Array.isArray(options.populate) &&
+        options.populate.find(item => item === propName || item.startsWith(propName + '.'))) {
         return true;
     }
     if (options.exclude?.find(item => item === propName)) {
@@ -224,7 +225,7 @@ export class EntitySerializer {
             return this.serialize(child, childOptions);
         }
         const pk = this.processCustomType(wrapped.getPrimaryKey(), prop, wrapped.__platform, options.convertCustomTypes);
-        if (options.forceObject || wrapped.__config.get('serialization').forceObject) {
+        if (options.forceObject ?? wrapped.__config.get('serialization').forceObject) {
             return Utils.primaryKeyToObject(meta, pk, visible);
         }
         if (Utils.isPlainObject(pk)) {
@@ -248,7 +249,7 @@ export class EntitySerializer {
                 return this.serialize(item, this.extractChildOptions(options, prop.name));
             }
             const pk = this.processCustomType(wrapped.getPrimaryKey(), prop, wrapped.__platform, options.convertCustomTypes);
-            if (options.forceObject || wrapped.__config.get('serialization').forceObject) {
+            if (options.forceObject ?? wrapped.__config.get('serialization').forceObject) {
                 return Utils.primaryKeyToObject(wrapped.__meta, pk);
             }
             return pk;