@mikro-orm/core 7.1.0-dev.2 → 7.1.0-dev.20

package/metadata/MetadataValidator.d.ts

@@ -7,6 +7,30 @@ import type { MetadataStorage } from './MetadataStorage.js';
 export declare class MetadataValidator {
     validateEntityDefinition<T>(metadata: MetadataStorage, name: EntityName<T>, options: MetadataDiscoveryOptions): void;
     validateDiscovered(discovered: EntityMetadata[], options: MetadataDiscoveryOptions): void;
+    private validatePartitioning;
+    /**
+     * 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.
+     */
+    private findDuplicatePartitionName;
+    /**
+     * Partition names may be bare (`child`), schema-qualified (`schema.child`), or use quoted
+     * identifiers (`"my.schema"."child"`). Reject anything with more than one unquoted `.`.
+     */
+    private hasValidPartitionName;
+    private hasPartitionExpression;
+    private validatePartitionKeyConstraints;
+    /**
+     * 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.
+     */
+    private getPartitionKeyFields;
+    private resolvePartitionKeyField;
+    private getConstraintFields;
     private validateReference;
     private validateTargetKey;
     /**

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) {
@@ -111,6 +116,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 +359,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 +546,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/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
@@ -334,7 +392,7 @@ export interface PropertyOptions<Owner> {
 }
 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 +557,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 +601,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.2",
+  "version": "7.1.0-dev.20",
   "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. */
@@ -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). */

package/platforms/Platform.js

@@ -2,6 +2,7 @@ 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';
@@ -62,6 +63,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;
@@ -415,6 +420,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;
@@ -651,7 +663,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.