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

package/metadata/MetadataValidator.js

@@ -1,4 +1,5 @@
 import { Utils } from '../utils/Utils.js';
+import { normalizePartitionNameForComparison, splitCommaSeparatedIdentifiers } from '../utils/partition-utils.js';
 import { MetadataError } from '../errors.js';
 import { ReferenceKind } from '../enums.js';
 /**
@@ -28,6 +29,9 @@ export class MetadataValidator {
         // Virtual entities (expression without view flag) have restrictions - no PKs, limited relation types
         // Note: meta.virtual is set later in sync(), so we check for expression && !view here
         if (meta.virtual || (meta.expression && !meta.view)) {
+            if (meta.partitionBy) {
+                throw new MetadataError(`Virtual entity ${meta.className} cannot define partitionBy`);
+            }
             for (const prop of Utils.values(meta.properties)) {
                 if (![ReferenceKind.SCALAR, ReferenceKind.EMBEDDED, ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
                     throw new MetadataError(`Only scalars, embedded properties and to-many relations are allowed inside virtual entity. Found '${prop.kind}' in ${meta.className}.${prop.name}`);
@@ -46,6 +50,7 @@ export class MetadataValidator {
         this.validateDuplicateFieldNames(meta, options);
         this.validateIndexes(meta, meta.indexes ?? [], 'index');
         this.validateIndexes(meta, meta.uniques ?? [], 'unique');
+        this.validatePartitioning(meta);
         this.validatePropertyNames(meta);
         for (const prop of Utils.values(meta.properties)) {
             if (prop.kind !== ReferenceKind.SCALAR) {
@@ -57,6 +62,41 @@ export class MetadataValidator {
             }
         }
     }
+    validateRoutineDefinition(routine) {
+        if (typeof routine.name !== 'string' || routine.name.trim() === '') {
+            throw new MetadataError(`Routine is missing the required 'name' option.`);
+        }
+        if (!routine.type) {
+            throw new MetadataError(`Routine ${routine.name} is missing the required 'type' option ('procedure' | 'function').`);
+        }
+        if (routine.body != null && routine.expression != null) {
+            throw new MetadataError(`Routine ${routine.name} defines both 'body' and 'expression'. Use one or the other.`);
+        }
+        if (routine.body == null && routine.expression == null && routine.bodyJs == null) {
+            throw new MetadataError(`Routine ${routine.name} must define a 'body', 'expression', or 'bodyJs'.`);
+        }
+        if (routine.type === 'function' && routine.returns == null) {
+            throw new MetadataError(`Function routine ${routine.name} must declare a 'returns' option.`);
+        }
+        if (routine.type === 'procedure' && routine.bodyJs != null) {
+            throw new MetadataError(`Routine ${routine.name} declares 'bodyJs' on a procedure. JS fallbacks are only supported for functions — SQLite has no analog for stored procedures.`);
+        }
+        for (const param of routine.params) {
+            const dir = param.direction;
+            if (dir !== 'in' && dir !== 'out' && dir !== 'inout') {
+                throw new MetadataError(`Routine ${routine.name}.${param.name} has invalid direction '${dir}'. Expected 'in', 'out', or 'inout'.`);
+            }
+            if ((dir === 'out' || dir === 'inout') && !param.ref) {
+                throw new MetadataError(`Routine ${routine.name}.${param.name} is declared as '${dir}' but missing 'ref: true'. OUT/INOUT parameters must be passed as ScalarReference.`);
+            }
+            if (dir === 'in' && param.ref) {
+                throw new MetadataError(`Routine ${routine.name}.${param.name} declares 'ref: true' on an IN parameter. ScalarReference wrapping is only meaningful for OUT/INOUT parameters.`);
+            }
+            if (routine.type === 'function' && dir !== 'in') {
+                throw new MetadataError(`Function routine ${routine.name}.${param.name} declares direction '${dir}'. Functions only support IN parameters — use a procedure for OUT/INOUT semantics.`);
+            }
+        }
+    }
     validateDiscovered(discovered, options) {
         if (discovered.length === 0 && options.warnWhenNoEntities) {
             throw MetadataError.noEntityDiscovered();
@@ -111,6 +151,189 @@ export class MetadataValidator {
             }
         });
     }
+    validatePartitioning(meta) {
+        if (!meta.partitionBy) {
+            return;
+        }
+        if (!this.hasPartitionExpression(meta.partitionBy.expression)) {
+            throw new MetadataError(`Entity ${meta.className} has invalid partitionBy option: missing expression`);
+        }
+        // Inheritance (STI/TPT) and partitioning both drive table layout, so combining them would
+        // require non-trivial DDL coordination that the schema generator does not produce today.
+        const hasInheritance = !!meta.root.discriminatorColumn || meta.root.inheritanceType === 'tpt' || meta.root.inheritance === 'tpt';
+        if (hasInheritance) {
+            throw new MetadataError(`Entity ${meta.className} has invalid partitionBy option: combining partitioning with inheritance is not supported`);
+        }
+        this.validatePartitionKeyConstraints(meta);
+        if (meta.partitionBy.type === 'hash') {
+            const { partitions } = meta.partitionBy;
+            if (Array.isArray(partitions)) {
+                if (partitions.length === 0) {
+                    throw new MetadataError(`Entity ${meta.className} has invalid partitionBy option: hash partition name list must not be empty`);
+                }
+                const blank = partitions.find(name => typeof name !== 'string' || !name.trim());
+                if (blank !== undefined) {
+                    throw new MetadataError(`Entity ${meta.className} has invalid partitionBy option: hash partition names must be non-empty strings`);
+                }
+                const ambiguous = partitions.find(name => !this.hasValidPartitionName(name));
+                if (ambiguous) {
+                    throw new MetadataError(`Entity ${meta.className} has invalid partitionBy option: partition name '${ambiguous}' contains more than one '.' — use at most one '.' to separate schema from table`);
+                }
+                const duplicate = this.findDuplicatePartitionName(partitions);
+                if (duplicate !== undefined) {
+                    throw new MetadataError(`Entity ${meta.className} has invalid partitionBy option: duplicate hash partition name '${duplicate}'`);
+                }
+                return;
+            }
+            if (typeof partitions !== 'number' || !Number.isInteger(partitions) || partitions < 1) {
+                throw new MetadataError(`Entity ${meta.className} has invalid partitionBy option: hash partition count must be a positive integer`);
+            }
+            return;
+        }
+        if (!Array.isArray(meta.partitionBy.partitions) || meta.partitionBy.partitions.length === 0) {
+            throw new MetadataError(`Entity ${meta.className} has invalid partitionBy option: list/range partitions must be a non-empty array`);
+        }
+        if (meta.partitionBy.partitions.some(partition => !partition.values?.trim())) {
+            throw new MetadataError(`Entity ${meta.className} has invalid partitionBy option: every partition must define values`);
+        }
+        const ambiguousName = meta.partitionBy.partitions.find(partition => partition.name != null && !this.hasValidPartitionName(partition.name));
+        if (ambiguousName) {
+            throw new MetadataError(`Entity ${meta.className} has invalid partitionBy option: partition name '${ambiguousName.name}' contains more than one '.' — use at most one '.' to separate schema from table`);
+        }
+        // Include auto-generated default names (`${tableName}_${index}`, matching
+        // `createExplicitPartitions` in the sql package) so an explicit name that collides with
+        // an unnamed peer's default is caught here rather than at DDL execution time.
+        const resolvedNames = meta.partitionBy.partitions.map((partition, index) => partition.name ?? `${meta.tableName}_${index}`);
+        const duplicate = this.findDuplicatePartitionName(resolvedNames);
+        if (duplicate !== undefined) {
+            throw new MetadataError(`Entity ${meta.className} has invalid partitionBy option: duplicate partition name '${duplicate}'`);
+        }
+    }
+    /**
+     * Find the first partition name whose normalized form (case-folded for unquoted segments,
+     * quoted segments preserved) has already been seen. Returns the offending name in its
+     * original form for the error message.
+     */
+    findDuplicatePartitionName(names) {
+        const seen = new Set();
+        for (const name of names) {
+            const normalized = normalizePartitionNameForComparison(name);
+            if (seen.has(normalized)) {
+                return name;
+            }
+            seen.add(normalized);
+        }
+        return undefined;
+    }
+    /**
+     * Partition names may be bare (`child`), schema-qualified (`schema.child`), or use quoted
+     * identifiers (`"my.schema"."child"`). Reject anything with more than one unquoted `.`.
+     */
+    hasValidPartitionName(name) {
+        let depth = 0;
+        let dots = 0;
+        for (let i = 0; i < name.length; i++) {
+            const ch = name[i];
+            if (ch === '"') {
+                if (name[i + 1] === '"') {
+                    i++;
+                    continue;
+                }
+                depth = depth === 0 ? 1 : 0;
+                continue;
+            }
+            if (ch === '.' && depth === 0) {
+                dots++;
+            }
+        }
+        return dots <= 1;
+    }
+    hasPartitionExpression(expression) {
+        if (expression == null) {
+            return false;
+        }
+        if (typeof expression === 'function') {
+            return true;
+        }
+        if (Array.isArray(expression)) {
+            return expression.length > 0 && expression.every(key => typeof key === 'string' && key.trim().length > 0);
+        }
+        return String(expression).trim().length > 0;
+    }
+    validatePartitionKeyConstraints(meta) {
+        const partitionFields = this.getPartitionKeyFields(meta);
+        if (!partitionFields?.length) {
+            return;
+        }
+        const primaryKeyFields = meta.root.getPrimaryProps().flatMap(prop => prop.fieldNames);
+        if (partitionFields.some(field => !primaryKeyFields.includes(field))) {
+            throw new MetadataError(`Entity ${meta.className} has invalid partitionBy option: primary key must include partition key columns '${partitionFields.join("', '")}'`);
+        }
+        for (const prop of Object.values(meta.root.properties)) {
+            if (!prop.unique || !prop.fieldNames?.length) {
+                continue;
+            }
+            if (partitionFields.some(field => !prop.fieldNames.includes(field))) {
+                throw new MetadataError(`Entity ${meta.root.className} has invalid partitionBy option: unique property ${meta.root.className}.${prop.name} must include partition key columns '${partitionFields.join("', '")}'`);
+            }
+        }
+        for (const unique of meta.root.uniques ?? []) {
+            const fields = this.getConstraintFields(meta.root, unique.properties);
+            if (!fields?.length) {
+                continue;
+            }
+            if (partitionFields.some(field => !fields.includes(field))) {
+                const constraint = unique.name ? `unique constraint '${unique.name}'` : 'unique constraint';
+                throw new MetadataError(`Entity ${meta.root.className} has invalid partitionBy option: ${constraint} must include partition key columns '${partitionFields.join("', '")}'`);
+            }
+        }
+    }
+    /**
+     * Returns the list of physical field names that a partition expression references, or
+     * `undefined` when the expression is opaque (callback, or raw SQL like `date_trunc('day', x)`
+     * that we cannot statically parse). Opaque expressions intentionally bypass the primary-key /
+     * unique-constraint coverage checks — users are trusted to ensure the referenced columns are
+     * part of the partition key, since PostgreSQL will surface the violation at DDL execution.
+     */
+    getPartitionKeyFields(meta) {
+        const expression = meta.partitionBy?.expression;
+        if (!expression || typeof expression === 'function') {
+            return undefined;
+        }
+        if (Array.isArray(expression)) {
+            return expression.map(key => this.resolvePartitionKeyField(meta, key));
+        }
+        const keys = splitCommaSeparatedIdentifiers(String(expression).trim());
+        if (!keys) {
+            return undefined;
+        }
+        return keys.map(key => this.resolvePartitionKeyField(meta, key));
+    }
+    resolvePartitionKeyField(meta, key) {
+        const trimmed = key.trim().replaceAll('"', '');
+        if (!trimmed) {
+            throw new MetadataError(`Entity ${meta.className} has invalid partitionBy option: empty partition key`);
+        }
+        const prop = meta.root.properties[trimmed] ??
+            Object.values(meta.root.properties).find(candidate => candidate.fieldNames?.length === 1 && candidate.fieldNames[0] === trimmed);
+        if (!prop) {
+            throw new MetadataError(`Entity ${meta.className} has invalid partitionBy option: unknown partition key '${key.trim()}'`);
+        }
+        if (prop.fieldNames?.length !== 1) {
+            throw new MetadataError(`Entity ${meta.className} has invalid partitionBy option: partition key '${key.trim()}' maps to multiple columns ('${prop.fieldNames?.join("', '")}'); list them explicitly as partition keys`);
+        }
+        return prop.fieldNames[0];
+    }
+    getConstraintFields(meta, properties) {
+        if (!properties) {
+            return undefined;
+        }
+        const fields = Utils.asArray(properties).flatMap(propName => {
+            const prop = meta.root.properties[propName];
+            return prop?.fieldNames ?? [];
+        });
+        return fields.length > 0 ? fields : undefined;
+    }
     validateReference(meta, prop, options) {
         // references do have types
         if (!prop.type) {
@@ -160,7 +383,7 @@ export class MetadataValidator {
      * Composite unique constraints are not sufficient for targetKey.
      */
     isPropertyUnique(prop, meta) {
-        if (prop.unique) {
+        if (prop.unique || (prop.primary && meta.primaryKeys.length === 1)) {
             return true;
         }
         // Check for single-property unique constraint via @Unique decorator
@@ -358,6 +581,10 @@ export class MetadataValidator {
         if (!meta.expression) {
             throw MetadataError.viewEntityWithoutExpression(meta);
         }
+        // Views are not partitionable - reject explicitly instead of silently ignoring
+        if (meta.partitionBy) {
+            throw new MetadataError(`View entity ${meta.className} cannot define partitionBy`);
+        }
         // Validate indexes if present
         this.validateIndexes(meta, meta.indexes ?? [], 'index');
         this.validateIndexes(meta, meta.uniques ?? [], 'unique');

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.9",
+  "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",