@mikro-orm/core 7.1.0-dev.8 → 7.1.0

package/metadata/Routine.d.ts

@@ -0,0 +1,74 @@
+import type { RoutineArgsOf, RoutineConfig, RoutineDataAccess, RoutineIgnoreField, RoutineKind, RoutineParamMap, RoutineProperty, RoutineReturnOf, RoutineReturns, RoutineSecurity } from '../typings.js';
+import type { Type } from '../types/Type.js';
+import type { Raw } from '../utils/RawQueryFragment.js';
+/**
+ * Stored procedure or function declaration. Register instances via the `routines` config option
+ * passed to `MikroORM.init`, then call them through `em.callRoutine(routine, args)`.
+ *
+ * `TArgs` and `TReturn` are inferred from the literal config, so `em.callRoutine` is fully typed
+ * without threading generics through the call site. Reach for {@link Routine.create} when the
+ * inferred type is too loose — typically an `object` return that should be a concrete shape
+ * rather than `Dictionary`.
+ *
+ * @example
+ * ```ts
+ * const HashUser = new Routine({
+ *   name: 'hash_user',
+ *   type: 'function',
+ *   params: {
+ *     name: { type: 'varchar(255)' },
+ *     salt: { type: 'varchar(255)' },
+ *   },
+ *   returns: { runtimeType: 'string', columnType: 'char(40)' },
+ *   body: 'SELECT SHA1(CONCAT(name, salt))',
+ * });
+ *
+ * await MikroORM.init({ entities: [User], routines: [HashUser] });
+ *
+ * // args typed as `{ name: string; salt: string }`, result typed as `string`:
+ * const hash = await em.callRoutine(HashUser, { name: 'jon', salt: 'pepper' });
+ * ```
+ */
+export declare class Routine<const TConfig extends RoutineConfig = RoutineConfig, TArgs = RoutineArgsOf<TConfig>, TReturn = RoutineReturnOf<TConfig>> {
+    readonly name: string;
+    readonly type: RoutineKind;
+    readonly schema?: string;
+    readonly comment?: string;
+    readonly security?: RoutineSecurity;
+    readonly definer?: string;
+    readonly deterministic?: boolean;
+    readonly dataAccess?: RoutineDataAccess;
+    readonly language?: string;
+    readonly body?: string | Raw | ((params: RoutineParamMap<any>, em: any) => string | Raw);
+    readonly expression?: string;
+    readonly bodyJs?: (params: any) => unknown;
+    readonly returns?: RoutineReturns;
+    readonly returnCustomType?: Type<unknown>;
+    readonly ignoreSchemaChanges?: RoutineIgnoreField[];
+    readonly params: RoutineProperty[];
+    constructor(config: TConfig);
+    /** @internal */
+    createParamMappingObject(): Record<string, string>;
+    /**
+     * Overrides the inferred TArgs/TReturn. Omit a generic to keep inference; pass `never` in the
+     * args slot to refine only the return type.
+     *
+     * @example
+     * ```ts
+     * interface UserStats { totalOrders: number; lastOrderAt: Date }
+     * const GetStats = Routine.create<never, UserStats>({
+     *   name: 'get_user_stats',
+     *   type: 'function',
+     *   params: { user_id: { type: 'int', runtimeType: 'number' } },
+     *   returns: { runtimeType: 'object', columnType: 'json' },
+     *   body: '...',
+     * });
+     * ```
+     */
+    static create<TArgs = never, TReturn = never, const TConfig extends RoutineConfig = RoutineConfig>(config: TConfig): Routine<TConfig, [
+        TArgs
+    ] extends [never] ? RoutineArgsOf<TConfig> : TArgs, [
+        TReturn
+    ] extends [never] ? RoutineReturnOf<TConfig> : TReturn>;
+    static is(item: unknown): item is Routine;
+}

package/metadata/Routine.js

@@ -0,0 +1,140 @@
+// Resolve a `Type<unknown> | Constructor<Type<unknown>>` to an instance. Each built-in `Type` has
+// `__mappedType` on its prototype so any constructed instance carries it; a missing brand means a
+// raw constructor that we instantiate.
+const toTypeInstance = (value) => {
+    return value.__mappedType ? value : new value();
+};
+/**
+ * Stored procedure or function declaration. Register instances via the `routines` config option
+ * passed to `MikroORM.init`, then call them through `em.callRoutine(routine, args)`.
+ *
+ * `TArgs` and `TReturn` are inferred from the literal config, so `em.callRoutine` is fully typed
+ * without threading generics through the call site. Reach for {@link Routine.create} when the
+ * inferred type is too loose — typically an `object` return that should be a concrete shape
+ * rather than `Dictionary`.
+ *
+ * @example
+ * ```ts
+ * const HashUser = new Routine({
+ *   name: 'hash_user',
+ *   type: 'function',
+ *   params: {
+ *     name: { type: 'varchar(255)' },
+ *     salt: { type: 'varchar(255)' },
+ *   },
+ *   returns: { runtimeType: 'string', columnType: 'char(40)' },
+ *   body: 'SELECT SHA1(CONCAT(name, salt))',
+ * });
+ *
+ * await MikroORM.init({ entities: [User], routines: [HashUser] });
+ *
+ * // args typed as `{ name: string; salt: string }`, result typed as `string`:
+ * const hash = await em.callRoutine(HashUser, { name: 'jon', salt: 'pepper' });
+ * ```
+ */
+export class Routine {
+    name;
+    type;
+    schema;
+    comment;
+    security;
+    definer;
+    deterministic;
+    dataAccess;
+    language;
+    body;
+    expression;
+    bodyJs;
+    returns;
+    returnCustomType;
+    ignoreSchemaChanges;
+    params;
+    constructor(config) {
+        this.name = config.name;
+        this.type = config.type;
+        this.schema = config.schema;
+        this.comment = config.comment;
+        this.security = config.security;
+        this.definer = config.definer;
+        this.deterministic = config.deterministic;
+        this.dataAccess = config.dataAccess;
+        this.language = config.language;
+        this.body = config.body;
+        this.expression = config.expression;
+        this.bodyJs = config.bodyJs;
+        this.returns = config.returns;
+        this.ignoreSchemaChanges = config.ignoreSchemaChanges;
+        this.params = Object.entries(config.params ?? {}).map(([name, opts], index) => {
+            const explicitCustom = opts.customType ? toTypeInstance(opts.customType) : undefined;
+            const rawType = opts.type;
+            let type;
+            let customType;
+            if (rawType == null || typeof rawType === 'string') {
+                type = rawType ?? 'string';
+                customType = explicitCustom;
+            }
+            else {
+                // A `Type` instance or constructor at `type` both defines the column (via
+                // `getColumnType` at schema-gen time) and acts as the default `customType` for
+                // marshalling. An explicit `customType` on the same param overrides the marshalling side.
+                const instance = toTypeInstance(rawType);
+                type = instance;
+                customType = explicitCustom ?? instance;
+            }
+            return {
+                name,
+                direction: opts.direction ?? 'in',
+                type,
+                runtimeType: opts.runtimeType ?? 'any',
+                columnTypes: [typeof type === 'string' ? type : ''],
+                customType,
+                ref: opts.ref,
+                length: opts.length,
+                precision: opts.precision,
+                scale: opts.scale,
+                nullable: opts.nullable,
+                defaultRaw: opts.defaultRaw,
+                index,
+            };
+        });
+        if (config.returns && typeof config.returns === 'object') {
+            // `returns: { type: SomeType }` is the canonical scalar-return shape — the Type drives
+            // both the column type (via `getColumnType` at schema-gen time) and the marshalling.
+            if ('type' in config.returns && config.returns.type) {
+                this.returnCustomType = toTypeInstance(config.returns.type);
+            }
+            else if ('customType' in config.returns && config.returns.customType) {
+                this.returnCustomType = toTypeInstance(config.returns.customType);
+            }
+        }
+    }
+    /** @internal */
+    createParamMappingObject() {
+        return this.params.reduce((o, p) => {
+            o[p.name] = p.name;
+            return o;
+        }, {});
+    }
+    /**
+     * Overrides the inferred TArgs/TReturn. Omit a generic to keep inference; pass `never` in the
+     * args slot to refine only the return type.
+     *
+     * @example
+     * ```ts
+     * interface UserStats { totalOrders: number; lastOrderAt: Date }
+     * const GetStats = Routine.create<never, UserStats>({
+     *   name: 'get_user_stats',
+     *   type: 'function',
+     *   params: { user_id: { type: 'int', runtimeType: 'number' } },
+     *   returns: { runtimeType: 'object', columnType: 'json' },
+     *   body: '...',
+     * });
+     * ```
+     */
+    static create(config) {
+        return new Routine(config);
+    }
+    static is(item) {
+        return item instanceof Routine;
+    }
+}

package/metadata/index.d.ts

@@ -1,5 +1,6 @@
 export type * from './types.js';
 export * from './EntitySchema.js';
+export * from './Routine.js';
 export * from './MetadataDiscovery.js';
 export * from './MetadataStorage.js';
 export * from './MetadataProvider.js';

package/metadata/index.js

@@ -1,4 +1,5 @@
 export * from './EntitySchema.js';
+export * from './Routine.js';
 export * from './MetadataDiscovery.js';
 export * from './MetadataStorage.js';
 export * from './MetadataProvider.js';

package/metadata/types.d.ts

@@ -1,9 +1,52 @@
-import type { AnyEntity, Constructor, EntityName, AnyString, CheckCallback, GeneratedColumnCallback, FormulaCallback, FilterQuery, Dictionary, AutoPath, EntityClass, IndexCallback, ObjectQuery, Raw, TriggerDef } from '../typings.js';
+import type { AnyEntity, Constructor, EntityName, AnyString, CheckCallback, GeneratedColumnCallback, FormulaCallback, FilterQuery, Dictionary, AutoPath, EntityClass, IndexCallback, ObjectQuery, Raw, SchemaColumns, TriggerDef } from '../typings.js';
 import type { Cascade, LoadStrategy, DeferMode, QueryOrderMap, EmbeddedPrefixMode } from '../enums.js';
 import type { Type, types } from '../types/index.js';
 import type { EntityManager } from '../EntityManager.js';
 import type { FilterOptions, FindOptions } from '../drivers/IDatabaseDriver.js';
 import type { SerializeOptions } from '../serialization/EntitySerializer.js';
+/** Supported PostgreSQL partitioning strategies. */
+export type EntityPartitionType = 'hash' | 'list' | 'range';
+/**
+ * Partition key expression for PostgreSQL partitioned tables.
+ *
+ * You can use:
+ * - a property name, e.g. `'type'`
+ * - a list of property names for composite expressions, e.g. `['tenant', 'createdAt']`
+ * - a raw SQL expression string, e.g. `"date_trunc('month', created_at)"`
+ * - a callback that receives schema column mappings and returns SQL
+ */
+export type EntityPartitionExpression<E = AnyEntity> = (keyof E & string) | readonly (keyof E & string)[] | AnyString | ((columns: SchemaColumns<E>) => string);
+/** Explicit child partition definition for PostgreSQL `list` and `range` partitioning. */
+export interface EntityPartition<E = AnyEntity> {
+    /**
+     * Optional child table name. Defaults to `<tableName>_<index>`. A single `.` is treated as a
+     * `schema.table` separator; names with more than one `.` are rejected to avoid ambiguity.
+     */
+    name?: string;
+    /** Partition bound clause, either as `for values ...` or the trailing part such as `in (...)`, `from ... to ...`, or `default`. */
+    values: string;
+}
+/**
+ * PostgreSQL table partitioning definition.
+ *
+ * - `hash` partitions generate child tables automatically from the partition count
+ * - `list` and `range` partitions require explicit child partition definitions
+ */
+export type EntityPartitionBy<E = AnyEntity> = {
+    type: Extract<EntityPartitionType, 'hash'>;
+    expression: EntityPartitionExpression<E>;
+    /**
+     * Hash partition fan-out: either a number (auto-named as `${tableName}_N`) or an array of
+     * explicit partition names in remainder order. Names may be `schema.name` to create the
+     * child in a non-default schema.
+     */
+    partitions: number | readonly string[];
+} | {
+    type: Exclude<EntityPartitionType, 'hash'>;
+    expression: EntityPartitionExpression<E>;
+    /** Explicit child partitions created in the order provided. */
+    partitions: EntityPartition<E>[];
+};
 export type EntityOptions<T, E = T extends EntityClass<infer P> ? P : T> = {
     /** Override default collection/table name. Alias for `collection`. */
     tableName?: string;
@@ -22,8 +65,10 @@ export type EntityOptions<T, E = T extends EntityClass<infer P> ? P : T> = {
      * 3. Entity-level `@Entity({ orderBy })`
      */
     orderBy?: QueryOrderMap<E> | QueryOrderMap<E>[];
-    /** For {@doclink inheritance-mapping#single-table-inheritance | Single Table Inheritance}. */
-    discriminatorColumn?: (T extends EntityClass<infer P> ? keyof P : string) | AnyString;
+    /** For {@doclink inheritance-mapping#single-table-inheritance | Single Table Inheritance}. Property name on the entity that stores the discriminator value. */
+    discriminator?: (T extends EntityClass<infer P> ? keyof P : string) | AnyString;
+    /** For {@doclink inheritance-mapping#single-table-inheritance | Single Table Inheritance}. Override the discriminator column name (the property is named via `discriminator`; defaults to the naming-strategy-derived column). */
+    discriminatorColumn?: string;
     /** For {@doclink inheritance-mapping#single-table-inheritance | Single Table Inheritance}. */
     discriminatorMap?: Dictionary<string>;
     /** For {@doclink inheritance-mapping#single-table-inheritance | Single Table Inheritance}. */
@@ -59,6 +104,13 @@ export type EntityOptions<T, E = T extends EntityClass<infer P> ? P : T> = {
     hasTriggers?: boolean;
     /** Database triggers to create for this entity's table. (SQL drivers only) */
     triggers?: TriggerDef<E>[];
+    /**
+     * PostgreSQL partitioning definition for this table.
+     *
+     * Partitioned tables are tracked by the schema generator and introspected back from PostgreSQL.
+     * Changing an existing partition layout still requires a manual migration.
+     */
+    partitionBy?: EntityPartitionBy<E>;
     /** SQL query that maps to a {@doclink virtual-entities | virtual entity}, or for view entities, the view definition. */
     expression?: string | ((em: any, where: ObjectQuery<E>, options: FindOptions<E, any, any, any>, stream?: boolean) => object);
     /** Set {@doclink repositories#custom-repository | custom repository class}. */
@@ -331,6 +383,11 @@ export interface PropertyOptions<Owner> {
      * Specify comment of column for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
      */
     comment?: string;
+    /**
+     * Specify column-level collation for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
+     * Emits a `COLLATE` clause on the column definition; the accepted collation names are dialect-specific.
+     */
+    collation?: string;
     /** mysql only */
     extra?: string;
     /**
@@ -338,7 +395,7 @@ export interface PropertyOptions<Owner> {
      *
      * @see https://mikro-orm.io/docs/defining-entities#sql-generated-columns
      */
-    ignoreSchemaChanges?: ('type' | 'extra' | 'default')[];
+    ignoreSchemaChanges?: ('type' | 'extra' | 'default' | 'collation')[];
 }
 export interface ReferenceOptions<Owner, Target> extends PropertyOptions<Owner> {
     /** Set target entity type. For polymorphic relations, pass an array of entity types. */
@@ -498,16 +555,16 @@ export interface EmbeddedOptions<Owner, Target> extends PropertyOptions<Owner> {
 export interface EmbeddableOptions<Owner> {
     /** Specify constructor parameters to be used in `em.create` or when `forceConstructor` is enabled. Those should be names of declared entity properties in the same order as your constructor uses them. The ORM tries to infer those automatically, use this option in case the inference fails. */
     constructorParams?: (Owner extends EntityClass<infer P> ? keyof P : string)[];
-    /** For polymorphic embeddables. Specify the property name that stores the discriminator value. Alias for `discriminatorColumn`. */
+    /** For polymorphic embeddables. Property name on the embeddable class that stores the discriminator value. */
     discriminator?: (Owner extends EntityClass<infer P> ? keyof P : string) | AnyString;
-    /** For polymorphic embeddables. @deprecated Use `discriminator` instead. */
-    discriminatorColumn?: (Owner extends EntityClass<infer P> ? keyof P : string) | AnyString;
+    /** For polymorphic embeddables. Override the discriminator column name (the property is named via `discriminator`; defaults to the naming-strategy-derived column). */
+    discriminatorColumn?: string;
     discriminatorMap?: Dictionary<string>;
     discriminatorValue?: number | string;
     abstract?: boolean;
 }
 export interface EnumOptions<T> extends PropertyOptions<T> {
-    items?: readonly (number | string)[] | (() => Dictionary);
+    items?: readonly (number | string)[] | Dictionary | (() => Dictionary);
     array?: boolean;
     /** for postgres, by default it uses text column with check constraint */
     nativeEnumName?: string;
@@ -551,6 +608,16 @@ interface BaseOptions<T, H extends string> {
     include?: T extends EntityClass<infer P> ? Properties<P, H> : Properties<T, H>;
     /** Fill factor for the index as a percentage 0-100 (PostgreSQL, MSSQL). */
     fillFactor?: number;
+    /**
+     * Predicate for partial indexes. Object form is a `FilterQuery` and is portable across
+     * SQL drivers and MongoDB; string form is a raw SQL fragment (SQL drivers only).
+     *
+     * Native support: PostgreSQL, SQLite, MSSQL (`WHERE`), MongoDB (`partialFilterExpression`).
+     * MySQL 8.0.13+ / Oracle: emulated via `CASE WHEN` functional index (uniqueness only enforced
+     * where the predicate holds). MariaDB is not supported — it has no inline expression indexes;
+     * define a virtual generated column and index that instead.
+     */
+    where?: string | FilterQuery<NoInfer<T> extends EntityClass<infer P> ? P : NoInfer<T>>;
 }
 export interface UniqueOptions<T, H extends string = string> extends BaseOptions<T, H> {
     deferMode?: DeferMode | `${DeferMode}`;

package/package.json

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

@@ -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;