@mikro-orm/core 7.1.0-dev.4 → 7.1.0-dev.40

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 } 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;
@@ -57,6 +100,15 @@ export type EntityOptions<T, E = T extends EntityClass<infer P> ? P : T> = {
     };
     /** Used to make ORM aware of externally defined triggers. This is needed for MS SQL Server multi inserts, ignored in other dialects. */
     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}. */
@@ -329,6 +381,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;
     /**
@@ -336,11 +393,11 @@ 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. */
-    entity?: () => EntityName<Target> | EntityName<Target>[];
+    entity?: () => EntityName<Target> | EntityName[];
     /** Set what actions on owning entity should be cascaded to the relationship. Defaults to [Cascade.PERSIST, Cascade.MERGE] (see {@doclink cascading}). */
     cascade?: Cascade[];
     /** Always load the relationship. Discouraged for use with to-many relations for performance reasons. */
@@ -505,7 +562,7 @@ export interface EmbeddableOptions<Owner> {
     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;
@@ -549,6 +606,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/naming-strategy/AbstractNamingStrategy.d.ts

@@ -4,7 +4,7 @@ import { type ReferenceKind } from '../enums.js';
 export declare abstract class AbstractNamingStrategy implements NamingStrategy {
     getClassName(file: string, separator?: string): string;
     classToMigrationName(timestamp: string, customMigrationName?: string): string;
-    indexName(tableName: string, columns: string[], type: 'primary' | 'foreign' | 'unique' | 'index' | 'sequence' | 'check' | 'default'): string;
+    indexName(tableName: string, columns: string[], type: 'primary' | 'foreign' | 'unique' | 'index' | 'sequence' | 'check' | 'default' | 'trigger'): string;
     /**
      * @inheritDoc
      */

package/naming-strategy/NamingStrategy.d.ts

@@ -75,7 +75,7 @@ export interface NamingStrategy {
     /**
      * Returns key/constraint name for the given type. Some drivers might not support all the types (e.g. mysql and sqlite enforce the PK name).
      */
-    indexName(tableName: string, columns: string[], type: 'primary' | 'foreign' | 'unique' | 'index' | 'sequence' | 'check' | 'default'): string;
+    indexName(tableName: string, columns: string[], type: 'primary' | 'foreign' | 'unique' | 'index' | 'sequence' | 'check' | 'default' | 'trigger'): string;
     /**
      * Returns alias name for given entity. The alias needs to be unique across the query, which is by default
      * ensured via appended index parameter. It is optional to use it as long as you ensure it will be unique.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.1.0-dev.4",
+  "version": "7.1.0-dev.40",
   "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.
@@ -211,6 +213,11 @@ export declare abstract class Platform {
     getFullTextWhereClause(prop: EntityProperty): string;
     supportsCreatingFullTextIndex(): boolean;
     getFullTextIndexExpression(indexName: string, schemaName: string | undefined, tableName: string, columns: SimpleColumnMeta[]): string;
+    /**
+     * Generates the SQL index hint clause for the given index names.
+     * Returns `undefined` when the platform does not support index hints (e.g. PostgreSQL, SQLite).
+     */
+    formatIndexHint(indexNames: string[]): string | undefined;
     /** Whether the driver automatically parses JSON columns into JS objects. */
     convertsJsonAutomatically(): boolean;
     /** Converts a JS value to its JSON database representation (typically JSON.stringify). */
@@ -271,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).
+     */
+    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'): string;
+    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':
@@ -415,6 +441,13 @@ export class Platform {
     getFullTextIndexExpression(indexName, schemaName, tableName, columns) {
         throw new Error('Full text searching is not supported by this driver.');
     }
+    /**
+     * Generates the SQL index hint clause for the given index names.
+     * Returns `undefined` when the platform does not support index hints (e.g. PostgreSQL, SQLite).
+     */
+    formatIndexHint(indexNames) {
+        return undefined;
+    }
     /** Whether the driver automatically parses JSON columns into JS objects. */
     convertsJsonAutomatically() {
         return true;
@@ -506,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) {
@@ -596,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) {
@@ -651,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)) {