@mikro-orm/core 7.0.0-dev.99 → 7.0.0-rc.1

package/metadata/types.d.ts

@@ -1,4 +1,4 @@
-import type { AnyEntity, Constructor, EntityName, AnyString, CheckCallback, GeneratedColumnCallback, FilterQuery, Dictionary, AutoPath, EntityClass, IndexCallback, ObjectQuery } from '../typings.js';
+import type { AnyEntity, Constructor, EntityName, AnyString, CheckCallback, GeneratedColumnCallback, FormulaCallback, FilterQuery, Dictionary, AutoPath, EntityClass, IndexCallback, ObjectQuery, Raw } 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';
@@ -11,12 +11,25 @@ export type EntityOptions<T, E = T extends EntityClass<infer P> ? P : T> = {
     schema?: string;
     /** Override default collection/table name. Alias for `tableName`. */
     collection?: string;
+    /**
+     * Set default ordering for this entity. This ordering is applied when:
+     * - Querying the entity directly via `em.find()`, `em.findAll()`, etc.
+     * - Populating the entity as a relation
+     *
+     * All orderings are combined together. Precedence (highest to lowest):
+     * 1. Runtime `FindOptions.orderBy`
+     * 2. Relation-level `@OneToMany({ orderBy })` / `@ManyToMany({ orderBy })`
+     * 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}. */
     discriminatorMap?: Dictionary<string>;
     /** For {@doclink inheritance-mapping#single-table-inheritance | Single Table Inheritance}. */
     discriminatorValue?: number | string;
+    /** Set inheritance strategy: 'tpt' for {@doclink inheritance-mapping#table-per-type-inheritance-tpt | Table-Per-Type} inheritance. When set on the root entity, each entity in the hierarchy gets its own table with a FK from child PK to parent PK. */
+    inheritance?: 'tpt';
     /**	Enforce use of constructor when creating managed entity instances. */
     forceConstructor?: boolean;
     /** 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. */
@@ -27,11 +40,24 @@ export type EntityOptions<T, E = T extends EntityClass<infer P> ? P : T> = {
     abstract?: boolean;
     /** Disables change tracking - such entities are ignored during flush. */
     readonly?: boolean;
-    /** Marks entity as {@doclink virtual-entities | virtual}. This is set automatically when you use `expression` option. */
+    /** Marks entity as {@doclink virtual-entities | virtual}. This is set automatically when you use `expression` option (unless `view` is set). */
     virtual?: boolean;
+    /**
+     * Marks entity as a database view. Unlike virtual entities which evaluate expressions at query time,
+     * view entities create actual database views. The `expression` option must be provided when `view` is true.
+     * View entities are read-only by default.
+     *
+     * Use `view: true` for regular views, or `view: { materialized: true }` for materialized views (PostgreSQL only).
+     * Materialized views store the query results and must be refreshed to update data.
+     * Use `view: { materialized: true, withData: false }` to create an unpopulated materialized view.
+     */
+    view?: boolean | {
+        materialized?: boolean;
+        withData?: boolean;
+    };
     /** Used to make ORM aware of externally defined triggers. This is needed for MS SQL Server multi inserts, ignored in other dialects. */
     hasTriggers?: boolean;
-    /** SQL query that maps to a {@doclink virtual-entities | virtual entity}. */
+    /** 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}. */
     repository?: () => Constructor;
@@ -108,22 +134,22 @@ export interface PropertyOptions<Owner> {
      * Specify default column value for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}.
      * This is a runtime value, assignable to the entity property. (SQL only)
      */
-    default?: string | string[] | number | number[] | boolean | null;
+    default?: string | string[] | number | number[] | boolean | null | Date | Raw;
     /**
      * Specify SQL functions for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
      * Since v4 you should use defaultRaw for SQL functions. e.g. now()
      */
-    defaultRaw?: string;
+    defaultRaw?: string | Raw;
     /**
      * Set to map some SQL snippet for the entity.
      *
      * @see https://mikro-orm.io/docs/defining-entities#formulas Formulas
      */
-    formula?: string | ((alias: string) => string);
+    formula?: string | FormulaCallback<Owner>;
     /**
      * For generated columns. This will be appended to the column type after the `generated always` clause.
      */
-    generated?: string | GeneratedColumnCallback<Owner>;
+    generated?: string | Raw | GeneratedColumnCallback<Owner>;
     /**
      * Set column as nullable for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}.
      */
@@ -307,8 +333,8 @@ export interface PropertyOptions<Owner> {
     ignoreSchemaChanges?: ('type' | 'extra' | 'default')[];
 }
 export interface ReferenceOptions<Owner, Target> extends PropertyOptions<Owner> {
-    /** Set target entity type. */
-    entity?: string | (() => EntityName<Target>);
+    /** Set target entity type. For polymorphic relations, pass an array of entity types. */
+    entity?: () => EntityName<Target> | EntityName<Target>[];
     /** 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. */
@@ -323,7 +349,20 @@ export interface ReferenceOptions<Owner, Target> extends PropertyOptions<Owner>
  * @ignore
  */
 export type ColumnType = 'int' | 'int4' | 'integer' | 'bigint' | 'int8' | 'int2' | 'tinyint' | 'smallint' | 'mediumint' | 'double' | 'double precision' | 'real' | 'float8' | 'decimal' | 'numeric' | 'float' | 'float4' | 'datetime' | 'time' | 'time with time zone' | 'timestamp' | 'timestamp with time zone' | 'timetz' | 'timestamptz' | 'date' | 'interval' | 'character varying' | 'varchar' | 'char' | 'character' | 'uuid' | 'text' | 'tinytext' | 'mediumtext' | 'longtext' | 'boolean' | 'bool' | 'bit' | 'enum' | 'blob' | 'tinyblob' | 'mediumblob' | 'longblob' | 'bytea' | 'point' | 'line' | 'lseg' | 'box' | 'circle' | 'path' | 'polygon' | 'geometry' | 'tsvector' | 'tsquery' | 'json' | 'jsonb';
-export interface ManyToOneOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
+interface PolymorphicOptions {
+    /**
+     * For polymorphic relations. Specifies the property name that stores the entity type discriminator.
+     * Defaults to the property name. Only used when `entity` returns an array of types.
+     * For M:N relations, this is the column name in the pivot table.
+     */
+    discriminator?: string;
+    /**
+     * For polymorphic relations. Custom mapping of discriminator values to entity class names.
+     * If not provided, table names are used as discriminator values.
+     */
+    discriminatorMap?: Dictionary<string>;
+}
+export interface ManyToOneOptions<Owner, Target> extends ReferenceOptions<Owner, Target>, PolymorphicOptions {
     /** Point to the inverse side property name. */
     inversedBy?: (string & keyof Target) | ((e: Target) => any);
     /** Wrap the entity in {@apilink Reference} wrapper. */
@@ -342,6 +381,8 @@ export interface ManyToOneOptions<Owner, Target> extends ReferenceOptions<Owner,
     referenceColumnName?: string;
     /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
     referencedColumnNames?: string[];
+    /** Specify the property name on the target entity that this FK references instead of the primary key. */
+    targetKey?: string & keyof Target;
     /** What to do when the target entity gets deleted. */
     deleteRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
     /** What to do when the reference to the target entity gets updated. */
@@ -375,7 +416,7 @@ export interface OneToManyOptions<Owner, Target> extends ReferenceOptions<Owner,
     /** Point to the owning side property name. */
     mappedBy: (string & keyof Target) | ((e: Target) => any);
 }
-export interface OneToOneOptions<Owner, Target> extends Partial<Omit<OneToManyOptions<Owner, Target>, 'orderBy'>> {
+export interface OneToOneOptions<Owner, Target> extends Partial<Omit<OneToManyOptions<Owner, Target>, 'orderBy'>>, PolymorphicOptions {
     /** Set this side as owning. Owning side is where the foreign key is defined. This option is not required if you use `inversedBy` or `mappedBy` to distinguish owning and inverse side. */
     owner?: boolean;
     /** Point to the inverse side property name. */
@@ -388,6 +429,8 @@ export interface OneToOneOptions<Owner, Target> extends Partial<Omit<OneToManyOp
     mapToPk?: boolean;
     /** When a part of a composite column is shared in other properties, use this option to specify what columns are considered as owned by this property. This is useful when your composite property is nullable, but parts of it are not. */
     ownColumns?: string[];
+    /** Specify the property name on the target entity that this FK references instead of the primary key. */
+    targetKey?: string & keyof Target;
     /** What to do when the target entity gets deleted. */
     deleteRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
     /** What to do when the reference to the target entity gets updated. */
@@ -399,7 +442,7 @@ export interface OneToOneOptions<Owner, Target> extends Partial<Omit<OneToManyOp
     /** Enable/disable foreign key constraint creation on this relation */
     createForeignKeyConstraint?: boolean;
 }
-export interface ManyToManyOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
+export interface ManyToManyOptions<Owner, Target> extends ReferenceOptions<Owner, Target>, PolymorphicOptions {
     /** Set this side as owning. Owning side is where the foreign key is defined. This option is not required if you use `inversedBy` or `mappedBy` to distinguish owning and inverse side. */
     owner?: boolean;
     /** Point to the inverse side property name. */
@@ -417,7 +460,7 @@ export interface ManyToManyOptions<Owner, Target> extends ReferenceOptions<Owner
     /** Override default name for pivot table (see {@doclink naming-strategy | Naming Strategy}). */
     pivotTable?: string;
     /** Set pivot entity for this relation (see {@doclink collections#custom-pivot-table-entity | Custom pivot table entity}). */
-    pivotEntity?: string | (() => EntityName<any>);
+    pivotEntity?: () => EntityName;
     /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
     joinColumn?: string;
     /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
@@ -438,7 +481,7 @@ export interface ManyToManyOptions<Owner, Target> extends ReferenceOptions<Owner
     createForeignKeyConstraint?: boolean;
 }
 export interface EmbeddedOptions<Owner, Target> extends PropertyOptions<Owner> {
-    entity?: string | (() => EntityName<Target> | EntityName<Target>[]);
+    entity?: () => EntityName<Target> | EntityName[];
     prefix?: string | boolean;
     prefixMode?: EmbeddedPrefixMode;
     object?: boolean;
@@ -447,6 +490,9 @@ 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`. */
+    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;
     discriminatorMap?: Dictionary<string>;
     discriminatorValue?: number | string;
@@ -465,16 +511,67 @@ export interface SerializedPrimaryKeyOptions<T> extends PropertyOptions<T> {
 }
 type MaybeArray<T> = T | T[];
 type Properties<T, H extends string> = MaybeArray<AutoPath<T, H>>;
+/** Options for column within an index, supporting advanced index features like prefix length and collation. */
+export interface IndexColumnOptions {
+    /** Column name or property path. */
+    name: string;
+    /** Sort order for the column (default: ASC). */
+    sort?: 'ASC' | 'DESC' | 'asc' | 'desc';
+    /** NULLS ordering for the column (PostgreSQL). */
+    nulls?: 'FIRST' | 'LAST' | 'first' | 'last';
+    /** Prefix length for the column (MySQL, MariaDB). */
+    length?: number;
+    /** Collation for the column (PostgreSQL, SQLite, or MySQL/MariaDB via expression). */
+    collation?: string;
+}
 interface BaseOptions<T, H extends string> {
     name?: string;
     properties?: (T extends EntityClass<infer P> ? Properties<P, H> : Properties<T, H>);
     options?: Dictionary;
     expression?: string | (T extends EntityClass<infer P> ? IndexCallback<P> : IndexCallback<T>);
+    /**
+     * Advanced column options for the index.
+     * When specified, allows fine-grained control over each column in the index including
+     * sort order, nulls ordering, prefix length, and collation.
+     * If both `columns` and `properties` are specified, `columns` takes precedence for index creation.
+     */
+    columns?: IndexColumnOptions[];
+    /**
+     * Columns to include in the index but not as part of the key (PostgreSQL, MSSQL).
+     * These columns are stored in the leaf level of the index but not used for searching.
+     */
+    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;
 }
 export interface UniqueOptions<T, H extends string = string> extends BaseOptions<T, H> {
     deferMode?: DeferMode | `${DeferMode}`;
+    /**
+     * Whether the index is disabled (MSSQL only).
+     * A disabled index is not used for query planning and is not maintained on writes.
+     * It can be re-enabled later using `ALTER INDEX ... REBUILD`.
+     */
+    disabled?: boolean;
 }
 export interface IndexOptions<T, H extends string = string> extends BaseOptions<T, H> {
     type?: string;
+    /**
+     * Whether the index is invisible/hidden from the query optimizer (MySQL 8+, MariaDB 10.6+, MongoDB).
+     * An invisible index is still maintained on writes but not used for query planning.
+     * Useful for testing the impact of removing an index before actually dropping it.
+     */
+    invisible?: boolean;
+    /**
+     * Whether the index is disabled (MSSQL only).
+     * A disabled index is not used for query planning and is not maintained on writes.
+     * It can be re-enabled later using `ALTER INDEX ... REBUILD`.
+     */
+    disabled?: boolean;
+    /**
+     * Whether the index should be clustered (MariaDB, MSSQL).
+     * A clustered index determines the physical order of data in the table.
+     * Only one clustered index can exist per table.
+     */
+    clustered?: boolean;
 }
 export {};

package/naming-strategy/AbstractNamingStrategy.d.ts

@@ -26,10 +26,18 @@ export declare abstract class AbstractNamingStrategy implements NamingStrategy {
      * @inheritDoc
      */
     inverseSideName(entityName: string, propertyName: string, kind: ReferenceKind): string;
-    abstract classToTableName(entityName: string): string;
+    /**
+     * @inheritDoc
+     */
+    manyToManyPropertyName(ownerEntityName: string, targetEntityName: string, pivotTableName: string, ownerTableName: string, schemaName?: string): string;
+    /**
+     * @inheritDoc
+     */
+    discriminatorColumnName(baseName: string): string;
+    abstract classToTableName(entityName: string, tableName?: string): string;
     abstract joinColumnName(propertyName: string): string;
-    abstract joinKeyColumnName(entityName: string, referencedColumnName?: string): string;
-    abstract joinTableName(sourceEntity: string, targetEntity: string, propertyName?: string): string;
+    abstract joinKeyColumnName(entityName: string, referencedColumnName?: string, composite?: boolean, tableName?: string): string;
+    abstract joinTableName(sourceEntity: string, targetEntity: string, propertyName?: string, tableName?: string): string;
     abstract propertyToColumnName(propertyName: string, object?: boolean): string;
     abstract referenceColumnName(): string;
 }

package/naming-strategy/AbstractNamingStrategy.js

@@ -79,4 +79,16 @@ export class AbstractNamingStrategy {
         }
         return entityName[0].toLowerCase() + entityName.substring(1) + suffix;
     }
+    /**
+     * @inheritDoc
+     */
+    manyToManyPropertyName(ownerEntityName, targetEntityName, pivotTableName, ownerTableName, schemaName) {
+        return this.columnNameToProperty(pivotTableName.replace(new RegExp('^' + ownerTableName + '_'), ''));
+    }
+    /**
+     * @inheritDoc
+     */
+    discriminatorColumnName(baseName) {
+        return this.propertyToColumnName(baseName + 'Type');
+    }
 }

package/naming-strategy/EntityCaseNamingStrategy.d.ts

@@ -3,10 +3,10 @@ import { AbstractNamingStrategy } from './AbstractNamingStrategy.js';
  * This strategy keeps original entity/property names for table/column.
  */
 export declare class EntityCaseNamingStrategy extends AbstractNamingStrategy {
-    classToTableName(entityName: string): string;
+    classToTableName(entityName: string, tableName?: string): string;
     joinColumnName(propertyName: string): string;
-    joinKeyColumnName(entityName: string, referencedColumnName?: string, composite?: boolean): string;
-    joinTableName(sourceEntity: string, targetEntity: string, propertyName: string): string;
+    joinKeyColumnName(entityName: string, referencedColumnName?: string, composite?: boolean, tableName?: string): string;
+    joinTableName(sourceEntity: string, targetEntity: string, propertyName: string, tableName?: string): string;
     propertyToColumnName(propertyName: string): string;
     referenceColumnName(): string;
 }

package/naming-strategy/EntityCaseNamingStrategy.js

@@ -3,21 +3,22 @@ import { AbstractNamingStrategy } from './AbstractNamingStrategy.js';
  * This strategy keeps original entity/property names for table/column.
  */
 export class EntityCaseNamingStrategy extends AbstractNamingStrategy {
-    classToTableName(entityName) {
-        return entityName;
+    classToTableName(entityName, tableName) {
+        return tableName ?? entityName;
     }
     joinColumnName(propertyName) {
         return propertyName;
     }
-    joinKeyColumnName(entityName, referencedColumnName, composite = false) {
+    joinKeyColumnName(entityName, referencedColumnName, composite, tableName) {
+        entityName = this.classToTableName(entityName, tableName);
         const name = entityName.substr(0, 1).toLowerCase() + entityName.substr(1);
         if (composite && referencedColumnName) {
             return name + '_' + referencedColumnName;
         }
         return name;
     }
-    joinTableName(sourceEntity, targetEntity, propertyName) {
-        return this.classToTableName(sourceEntity) + '_' + this.propertyToColumnName(propertyName);
+    joinTableName(sourceEntity, targetEntity, propertyName, tableName) {
+        return this.classToTableName(sourceEntity, tableName) + '_' + this.propertyToColumnName(propertyName);
     }
     propertyToColumnName(propertyName) {
         return propertyName;

package/naming-strategy/MongoNamingStrategy.d.ts

@@ -1,9 +1,9 @@
 import { AbstractNamingStrategy } from './AbstractNamingStrategy.js';
 export declare class MongoNamingStrategy extends AbstractNamingStrategy {
-    classToTableName(entityName: string): string;
+    classToTableName(entityName: string, tableName?: string): string;
     joinColumnName(propertyName: string): string;
-    joinKeyColumnName(entityName: string, referencedColumnName?: string): string;
-    joinTableName(sourceEntity: string, targetEntity: string, propertyName: string): string;
+    joinKeyColumnName(entityName: string, referencedColumnName?: string, composite?: boolean, tableName?: string): string;
+    joinTableName(sourceEntity: string, targetEntity: string, propertyName: string, tableName?: string): string;
     propertyToColumnName(propertyName: string): string;
     referenceColumnName(): string;
 }

package/naming-strategy/MongoNamingStrategy.js

@@ -1,16 +1,16 @@
 import { AbstractNamingStrategy } from './AbstractNamingStrategy.js';
 export class MongoNamingStrategy extends AbstractNamingStrategy {
-    classToTableName(entityName) {
-        return entityName.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+    classToTableName(entityName, tableName) {
+        return tableName ?? entityName.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
     }
     joinColumnName(propertyName) {
         return propertyName;
     }
-    joinKeyColumnName(entityName, referencedColumnName) {
-        return entityName;
+    joinKeyColumnName(entityName, referencedColumnName, composite, tableName) {
+        return tableName ?? entityName;
     }
-    joinTableName(sourceEntity, targetEntity, propertyName) {
-        return this.classToTableName(sourceEntity) + '_' + this.propertyToColumnName(propertyName);
+    joinTableName(sourceEntity, targetEntity, propertyName, tableName) {
+        return this.classToTableName(sourceEntity, tableName) + '_' + this.propertyToColumnName(propertyName);
     }
     propertyToColumnName(propertyName) {
         return propertyName;

package/naming-strategy/NamingStrategy.d.ts

@@ -7,7 +7,7 @@ export interface NamingStrategy {
     /**
      * Return a table name for an entity class
      */
-    classToTableName(entityName: string): string;
+    classToTableName(entityName: string, tableName?: string): string;
     /**
      * Return a migration name. This name should allow ordering.
      */
@@ -67,11 +67,11 @@ export interface NamingStrategy {
     /**
      * Return a join table name
      */
-    joinTableName(sourceEntity: string, targetEntity: string, propertyName: string): string;
+    joinTableName(sourceEntity: string, targetEntity: string, propertyName: string, tableName?: string): string;
     /**
      * Return the foreign key column name for the given parameters
      */
-    joinKeyColumnName(entityName: string, referencedColumnName?: string, composite?: boolean): string;
+    joinKeyColumnName(entityName: string, referencedColumnName?: string, composite?: boolean, tableName?: string): string;
     /**
      * 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).
      */
@@ -85,4 +85,18 @@ export interface NamingStrategy {
      * Returns the name of the inverse side property. Used in the `EntityGenerator` with `bidirectionalRelations` option.
      */
     inverseSideName(entityName: string, propertyName: string, kind: ReferenceKind): string;
+    /**
+     * Return a property name for a many-to-many relation (used in `EntityGenerator`).
+     *
+     * @param ownerEntityName - The owner entity class name
+     * @param targetEntityName - The target entity class name
+     * @param pivotTableName - The pivot table name
+     * @param ownerTableName - The owner table name
+     * @param schemaName - The schema name (if any)
+     */
+    manyToManyPropertyName(ownerEntityName: string, targetEntityName: string, pivotTableName: string, ownerTableName: string, schemaName?: string): string;
+    /**
+     * Returns the discriminator column name for polymorphic relations.
+     */
+    discriminatorColumnName(baseName: string): string;
 }

package/naming-strategy/UnderscoreNamingStrategy.d.ts

@@ -1,9 +1,9 @@
 import { AbstractNamingStrategy } from './AbstractNamingStrategy.js';
 export declare class UnderscoreNamingStrategy extends AbstractNamingStrategy {
-    classToTableName(entityName: string): string;
+    classToTableName(entityName: string, tableName?: string): string;
     joinColumnName(propertyName: string): string;
-    joinKeyColumnName(entityName: string, referencedColumnName?: string): string;
-    joinTableName(sourceEntity: string, targetEntity: string, propertyName: string): string;
+    joinKeyColumnName(entityName: string, referencedColumnName?: string, composite?: boolean, tableName?: string): string;
+    joinTableName(sourceEntity: string, targetEntity: string, propertyName: string, tableName?: string): string;
     propertyToColumnName(propertyName: string, object?: boolean): string;
     referenceColumnName(): string;
     private underscore;

package/naming-strategy/UnderscoreNamingStrategy.js

@@ -1,16 +1,16 @@
 import { AbstractNamingStrategy } from './AbstractNamingStrategy.js';
 export class UnderscoreNamingStrategy extends AbstractNamingStrategy {
-    classToTableName(entityName) {
-        return this.underscore(entityName);
+    classToTableName(entityName, tableName) {
+        return tableName ?? this.underscore(entityName);
     }
     joinColumnName(propertyName) {
         return this.underscore(propertyName) + '_' + this.referenceColumnName();
     }
-    joinKeyColumnName(entityName, referencedColumnName) {
-        return this.classToTableName(entityName) + '_' + (referencedColumnName || this.referenceColumnName());
+    joinKeyColumnName(entityName, referencedColumnName, composite, tableName) {
+        return this.classToTableName(entityName, tableName) + '_' + (referencedColumnName || this.referenceColumnName());
     }
-    joinTableName(sourceEntity, targetEntity, propertyName) {
-        return this.classToTableName(sourceEntity) + '_' + this.classToTableName(propertyName);
+    joinTableName(sourceEntity, targetEntity, propertyName, tableName) {
+        return this.classToTableName(sourceEntity, tableName) + '_' + this.classToTableName(propertyName);
     }
     propertyToColumnName(propertyName, object) {
         return this.underscore(propertyName);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.99",
+  "version": "7.0.0-rc.1",
   "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.",
   "exports": {
     "./package.json": "./package.json",
@@ -50,7 +50,7 @@
     "node": ">= 22.17.0"
   },
   "scripts": {
-    "build": "yarn clean && yarn compile && yarn copy",
+    "build": "yarn compile && yarn copy",
     "clean": "yarn run -T rimraf ./dist",
     "compile": "yarn run -T tsc -p tsconfig.build.json",
     "copy": "node ../../scripts/copy.mjs"

package/platforms/Platform.d.ts

@@ -8,6 +8,7 @@ import type { IDatabaseDriver } from '../drivers/IDatabaseDriver.js';
 import { Type } from '../types/index.js';
 import type { MikroORM } from '../MikroORM.js';
 import type { TransformContext } from '../types/Type.js';
+import { Raw } from '../utils/RawQueryFragment.js';
 export declare const JsonProperty: unique symbol;
 export declare abstract class Platform {
     protected readonly exceptionConverter: ExceptionConverter;
@@ -27,6 +28,7 @@ export declare abstract class Platform {
     supportsNativeEnums(): boolean;
     /** for postgres text enums (default) */
     usesEnumCheckConstraints(): boolean;
+    supportsMaterializedViews(): boolean;
     getSchemaHelper(): unknown;
     indexForeignKeys(): boolean;
     /**
@@ -141,8 +143,8 @@ export declare abstract class Platform {
     unmarshallArray(value: string): string[];
     getBlobDeclarationSQL(): string;
     getJsonDeclarationSQL(): string;
-    getSearchJsonPropertySQL(path: string, type: string, aliased: boolean): string;
-    getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean, value?: unknown): string;
+    getSearchJsonPropertySQL(path: string, type: string, aliased: boolean): string | Raw;
+    getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean, value?: unknown): string | Raw;
     getJsonIndexDefinition(index: {
         columnNames: string[];
     }): string[];

package/platforms/Platform.js

@@ -5,7 +5,7 @@ import { ExceptionConverter } from './ExceptionConverter.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 } from '../utils/Utils.js';
 import { ReferenceKind } from '../enums.js';
-import { RawQueryFragment } from '../utils/RawQueryFragment.js';
+import { Raw } from '../utils/RawQueryFragment.js';
 export const JsonProperty = Symbol('JsonProperty');
 export class Platform {
     exceptionConverter = new ExceptionConverter();
@@ -41,6 +41,9 @@ export class Platform {
     usesEnumCheckConstraints() {
         return false;
     }
+    supportsMaterializedViews() {
+        return false;
+    }
     getSchemaHelper() {
         return undefined;
     }
@@ -330,7 +333,7 @@ export class Platform {
         return value;
     }
     quoteIdentifier(id, quote = '`') {
-        const raw = RawQueryFragment.getKnownFragment(id);
+        const raw = Raw.getKnownFragment(id);
         if (raw) {
             return this.formatQuery(raw.sql, raw.params);
         }

package/serialization/EntitySerializer.d.ts

@@ -4,6 +4,7 @@ export declare class EntitySerializer {
     static serialize<T extends object, P extends string = never, E extends string = never>(entity: T, options?: SerializeOptions<T, P, E>): EntityDTO<Loaded<T, P>>;
     private static propertyName;
     private static processProperty;
+    private static processCustomType;
     private static extractChildOptions;
     private static processEntity;
     private static processCollection;
@@ -23,6 +24,8 @@ export interface SerializeOptions<T, P extends string = never, E extends string
     skipNull?: boolean;
     /** Only include properties for a specific group. If a property does not specify any group, it will be included, otherwise only properties with a matching group are included. */
     groups?: string[];
+    /** Convert custom types to their database representation. By default, the `Type.toJSON` method is invoked instead. */
+    convertCustomTypes?: boolean;
 }
 /**
  * Converts entity instance to POJO, converting the `Collection`s to arrays and unwrapping the `Reference` wrapper, while respecting the serialization options.

package/serialization/EntitySerializer.js

@@ -69,13 +69,13 @@ export class EntitySerializer {
             if (!isVisible(meta, prop, options)) {
                 continue;
             }
-            const cycle = root.visit(meta.className, prop);
+            const cycle = root.visit(meta.class, prop);
             if (cycle && visited) {
                 continue;
             }
             const val = this.processProperty(prop, entity, options);
             if (!cycle) {
-                root.leave(meta.className, prop);
+                root.leave(meta.class, prop);
             }
             if (options.skipNull && Utils.isPlainObject(val)) {
                 Utils.dropUndefinedProperties(val, null);
@@ -159,12 +159,20 @@ export class EntitySerializer {
                 return helper(value).toJSON();
             }
         }
-        const customType = property?.customType;
-        if (customType) {
-            return customType.toJSON(value, wrapped.__platform);
+        if (property.customType) {
+            return this.processCustomType(value, property, wrapped.__platform, options.convertCustomTypes);
         }
         return wrapped.__platform.normalizePrimaryKey(value);
     }
+    static processCustomType(value, prop, platform, convertCustomTypes) {
+        if (!prop.customType) {
+            return value;
+        }
+        if (convertCustomTypes) {
+            return prop.customType.convertToDatabaseValue(value, platform, { mode: 'serialization' });
+        }
+        return prop.customType.toJSON(value, platform);
+    }
     static extractChildOptions(options, prop) {
         return {
             ...options,
@@ -183,10 +191,7 @@ export class EntitySerializer {
         if (expand) {
             return this.serialize(child, childOptions);
         }
-        let pk = wrapped.getPrimaryKey();
-        if (prop.customType) {
-            pk = prop.customType.toJSON(pk, wrapped.__platform);
-        }
+        const pk = this.processCustomType(wrapped.getPrimaryKey(), prop, wrapped.__platform, options.convertCustomTypes);
         if (options.forceObject || wrapped.__config.get('serialization').forceObject) {
             return Utils.primaryKeyToObject(meta, pk, visible);
         }
@@ -210,10 +215,7 @@ export class EntitySerializer {
             if (populated || !wrapped.__managed) {
                 return this.serialize(item, this.extractChildOptions(options, prop.name));
             }
-            let pk = wrapped.getPrimaryKey();
-            if (prop.customType) {
-                pk = prop.customType.toJSON(pk, wrapped.__platform);
-            }
+            const pk = this.processCustomType(wrapped.getPrimaryKey(), prop, wrapped.__platform, options.convertCustomTypes);
             if (options.forceObject || wrapped.__config.get('serialization').forceObject) {
                 return Utils.primaryKeyToObject(wrapped.__meta, pk);
             }