@mikro-orm/core 7.0.17-dev.9 → 7.0.18-dev.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) {
@@ -171,6 +394,15 @@ export class MetadataValidator {
     }
     validatePolymorphicTargets(meta, prop) {
         const targets = prop.polymorphTargets;
+        // Union-target M:N stores one scalar target FK per pivot row, so composite-PK targets
+        // can't round-trip through this schema.
+        if (prop.kind === ReferenceKind.MANY_TO_MANY && targets.length > 1) {
+            for (const target of targets) {
+                if (target.compositePK) {
+                    throw MetadataError.incompatiblePolymorphicTargets(meta, prop, targets[0], target, `${target.className} has a composite primary key; union-target polymorphic M:N does not support composite-PK targets.`);
+                }
+            }
+        }
         // Validate targetKey exists and is compatible across all targets
         if (prop.targetKey) {
             for (const target of targets) {
@@ -349,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 } 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}. */
@@ -202,6 +254,12 @@ export interface PropertyOptions<Owner> {
      * @see https://mikro-orm.io/docs/defining-entities#lazy-scalar-properties
      */
     lazy?: boolean;
+    /**
+     * Marks this property as an array. When used with a custom type, the type is automatically
+     * wrapped in an `ArrayType` that delegates element conversion to the inner type.
+     * The column type is inferred as `innerType[]` (e.g. `int[]`, `time[]`).
+     */
+    array?: boolean;
     /**
      * Set true to define entity's unique primary key identifier.
      * Alias for `@PrimaryKey()` decorator
@@ -323,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;
     /**
@@ -330,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. */
@@ -499,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;
@@ -543,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.