@mikro-orm/core 7.0.0-dev.23 → 7.0.0-dev.231

package/naming-strategy/AbstractNamingStrategy.js

@@ -14,7 +14,7 @@ export class AbstractNamingStrategy {
         return migrationName;
     }
     indexName(tableName, columns, type) {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (tableName.includes('.')) {
             tableName = tableName.substring(tableName.indexOf('.') + 1);
         }
@@ -48,7 +48,13 @@ export class AbstractNamingStrategy {
      * @inheritDoc
      */
     getEnumClassName(columnName, tableName, schemaName) {
-        return this.getEntityName(`${tableName}_${columnName}`, schemaName);
+        return this.getEntityName(tableName ? `${tableName}_${columnName}` : columnName, schemaName);
+    }
+    /**
+     * @inheritDoc
+     */
+    getEnumTypeName(columnName, tableName, schemaName) {
+        return 'T' + this.getEnumClassName(columnName, tableName, schemaName);
     }
     /**
      * @inheritDoc
@@ -73,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.
      */
@@ -25,7 +25,17 @@ export interface NamingStrategy {
      *
      * @return A new class name that will be used for the enum.
      */
-    getEnumClassName(columnName: string, tableName: string, schemaName?: string): string;
+    getEnumClassName(columnName: string, tableName: string | undefined, schemaName?: string): string;
+    /**
+     * Get an enum type name. Used with `enumType: 'dictionary'` and `enumType: 'union-type'` entity generator option.
+     *
+     * @param columnName The column name which has the enum.
+     * @param tableName The table name of the column.
+     * @param schemaName The schema name of the column.
+     *
+     * @return A new type name that will be used for the enum.
+     */
+    getEnumTypeName(columnName: string, tableName: string | undefined, schemaName?: string): string;
     /**
      * Get an enum option name for a given enum value.
      *
@@ -57,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).
      */
@@ -75,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/not-supported.d.ts

@@ -0,0 +1,2 @@
+export declare function discoverEntities(): void;
+export declare const fs: {};

package/not-supported.js

@@ -0,0 +1,4 @@
+export function discoverEntities() {
+    throw new Error('Folder-based discovery is not supported in this environment.');
+}
+export const fs = new Proxy({}, { get: () => { throw new Error('File system is not supported in this environment.'); } });

package/package.json

@@ -1,11 +1,19 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.23",
+  "version": "7.0.0-dev.231",
   "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",
-    ".": "./index.js"
+    ".": "./index.js",
+    "./file-discovery": {
+      "node": "./metadata/discover-entities.js",
+      "browser": "./not-supported.js"
+    },
+    "./fs-utils": {
+      "node": "./utils/fs-utils.js",
+      "browser": "./not-supported.js"
+    }
   },
   "repository": {
     "type": "git",
@@ -39,10 +47,10 @@
   },
   "homepage": "https://mikro-orm.io",
   "engines": {
-    "node": ">= 22.11.0"
+    "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"
@@ -50,12 +58,12 @@
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {
-    "dataloader": "2.2.3",
-    "dotenv": "17.2.1",
-    "esprima": "4.0.1",
-    "mikro-orm": "7.0.0-dev.23",
-    "reflect-metadata": "0.2.2",
-    "tinyglobby": "0.2.13"
+  "peerDependencies": {
+    "dataloader": "2.2.3"
+  },
+  "peerDependenciesMeta": {
+    "dataloader": {
+      "optional": true
+    }
   }
 }

package/platforms/ExceptionConverter.js

@@ -1,6 +1,6 @@
 import { DriverException } from '../exceptions.js';
 export class ExceptionConverter {
-    /* v8 ignore next 3 */
+    /* v8 ignore next */
     convertException(exception) {
         return new DriverException(exception);
     }

package/platforms/Platform.d.ts

@@ -1,7 +1,6 @@
-import { inspect } from 'node:util';
 import { EntityRepository } from '../entity/EntityRepository.js';
 import { type NamingStrategy } from '../naming-strategy/NamingStrategy.js';
-import type { Constructor, EntityProperty, IPrimaryKey, ISchemaGenerator, PopulateOptions, Primary, EntityMetadata, SimpleColumnMeta } from '../typings.js';
+import type { Constructor, EntityMetadata, EntityProperty, IPrimaryKey, ISchemaGenerator, PopulateOptions, Primary, SimpleColumnMeta } from '../typings.js';
 import { ExceptionConverter } from './ExceptionConverter.js';
 import type { EntityManager } from '../EntityManager.js';
 import type { Configuration } from '../utils/Configuration.js';
@@ -9,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;
@@ -28,9 +28,9 @@ export declare abstract class Platform {
     supportsNativeEnums(): boolean;
     /** for postgres text enums (default) */
     usesEnumCheckConstraints(): boolean;
+    supportsMaterializedViews(): boolean;
     getSchemaHelper(): unknown;
     indexForeignKeys(): boolean;
-    allowsMultiInsert(): boolean;
     /**
      * Whether or not the driver supports retuning list of created PKs back when multi-inserting
      */
@@ -48,11 +48,6 @@ export declare abstract class Platform {
      * Converts scalar primary key representation to native driver wrapper (e.g. string to mongodb's ObjectId)
      */
     denormalizePrimaryKey(data: IPrimaryKey): IPrimaryKey;
-    /**
-     * Used when serializing via toObject and toJSON methods, allows to use different PK field name (like `id` instead of `_id`)
-     */
-    getSerializedPrimaryKeyField(field: string): string;
-    usesDifferentSerializedPrimaryKey(): boolean;
     /**
      * Returns the SQL specific for the platform to get the current timestamp
      */
@@ -148,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[];
@@ -158,7 +153,7 @@ export declare abstract class Platform {
     getFullTextIndexExpression(indexName: string, schemaName: string | undefined, tableName: string, columns: SimpleColumnMeta[]): string;
     convertsJsonAutomatically(): boolean;
     convertJsonToDatabaseValue(value: unknown, context?: TransformContext): unknown;
-    convertJsonToJSValue(value: unknown, prop: EntityProperty): unknown;
+    convertJsonToJSValue(value: unknown, context?: TransformContext): unknown;
     convertDateToJSValue(value: string | Date): string;
     convertIntervalToJSValue(value: string): unknown;
     convertIntervalToDatabaseValue(value: unknown): unknown;
@@ -195,7 +190,7 @@ export declare abstract class Platform {
     getDefaultPrimaryName(tableName: string, columns: string[]): string;
     supportsCustomPrimaryKeyNames(): boolean;
     isPopulated<T>(key: string, populate: readonly PopulateOptions<T>[] | boolean): boolean;
-    shouldHaveColumn<T>(prop: EntityProperty<T>, populate: readonly PopulateOptions<T>[] | boolean, exclude?: string[], includeFormulas?: boolean): boolean;
+    shouldHaveColumn<T>(prop: EntityProperty<T>, populate: readonly PopulateOptions<T>[] | boolean, exclude?: string[], includeFormulas?: boolean, ignoreInlineEmbeddables?: boolean): boolean;
     /**
      * Currently not supported due to how knex does complex sqlite diffing (always based on current schema)
      */
@@ -227,6 +222,4 @@ export declare abstract class Platform {
      * @internal
      */
     clone(): this;
-    /** @ignore */
-    [inspect.custom](): string;
 }

package/platforms/Platform.js

@@ -1,12 +1,11 @@
-import { inspect } from 'node:util';
 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 { ArrayType, BigIntType, BlobType, Uint8ArrayType, BooleanType, CharacterType, DateType, DecimalType, DoubleType, JsonType, SmallIntType, TimeType, TinyIntType, Type, UuidType, StringType, IntegerType, FloatType, DateTimeType, TextType, EnumType, UnknownType, MediumIntType, IntervalType, } from '../types/index.js';
-import { parseJsonSafe, Utils } from '../utils/Utils.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();
@@ -42,15 +41,15 @@ export class Platform {
     usesEnumCheckConstraints() {
         return false;
     }
+    supportsMaterializedViews() {
+        return false;
+    }
     getSchemaHelper() {
         return undefined;
     }
     indexForeignKeys() {
         return false;
     }
-    allowsMultiInsert() {
-        return true;
-    }
     /**
      * Whether or not the driver supports retuning list of created PKs back when multi-inserting
      */
@@ -78,15 +77,6 @@ export class Platform {
     denormalizePrimaryKey(data) {
         return data;
     }
-    /**
-     * Used when serializing via toObject and toJSON methods, allows to use different PK field name (like `id` instead of `_id`)
-     */
-    getSerializedPrimaryKeyField(field) {
-        return field;
-    }
-    usesDifferentSerializedPrimaryKey() {
-        return false;
-    }
     /**
      * Returns the SQL specific for the platform to get the current timestamp
      */
@@ -133,7 +123,7 @@ export class Platform {
         return true;
     }
     isBigIntProperty(prop) {
-        return prop.columnTypes && prop.columnTypes[0] === 'bigint';
+        return prop.columnTypes?.[0] === 'bigint';
     }
     getDefaultSchemaName() {
         return undefined;
@@ -169,7 +159,7 @@ export class Platform {
         return `text`;
     }
     getEnumTypeDeclarationSQL(column) {
-        if (column.items?.every(item => Utils.isString(item))) {
+        if (column.items?.every(item => typeof item === 'string')) {
             return `enum('${column.items.join("','")}')`;
         }
         return this.getTinyIntTypeDeclarationSQL(column);
@@ -269,7 +259,7 @@ export class Platform {
     getSearchJsonPropertyKey(path, type, aliased, value) {
         return path.join('.');
     }
-    /* v8 ignore next 3 */
+    /* v8 ignore next */
     getJsonIndexDefinition(index) {
         return index.columnNames;
     }
@@ -288,11 +278,7 @@ export class Platform {
     convertJsonToDatabaseValue(value, context) {
         return JSON.stringify(value);
     }
-    convertJsonToJSValue(value, prop) {
-        const isObjectEmbedded = prop.embedded && prop.object;
-        if ((this.convertsJsonAutomatically() || isObjectEmbedded) && ['json', 'jsonb', this.getJsonDeclarationSQL()].includes(prop.columnTypes[0])) {
-            return value;
-        }
+    convertJsonToJSValue(value, context) {
         return parseJsonSafe(value);
     }
     convertDateToJSValue(value) {
@@ -306,7 +292,7 @@ export class Platform {
     }
     parseDate(value) {
         const date = new Date(value);
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (isNaN(date.getTime())) {
             return value;
         }
@@ -336,19 +322,10 @@ export class Platform {
         if (extension) {
             return extension;
         }
-        /* v8 ignore next 4 */
-        const module = Utils.tryRequire({
-            module: moduleName,
-            warning: `Please install ${moduleName} package.`,
-        });
-        /* v8 ignore next 3 */
-        if (module) {
-            return this.config.getCachedService(module[extensionName], em);
-        }
-        /* v8 ignore next 2 */
-        throw new Error(`${extensionName} extension not registered.`);
+        /* v8 ignore next */
+        throw new Error(`${extensionName} extension not registered. Provide it in the ORM config, or use the async \`MikroORM.init()\` method to load extensions automatically.`);
     }
-    /* v8 ignore next 3: kept for type inference only */
+    /* v8 ignore next: kept for type inference only */
     getSchemaGenerator(driver, em) {
         throw new Error(`${driver.constructor.name} does not support SchemaGenerator`);
     }
@@ -356,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);
         }
@@ -365,7 +342,7 @@ export class Platform {
     quoteValue(value) {
         return value;
     }
-    /* v8 ignore next 3 */
+    /* v8 ignore next */
     escape(value) {
         return value;
     }
@@ -455,7 +432,7 @@ export class Platform {
     isPopulated(key, populate) {
         return populate === true || (populate !== false && populate.some(p => p.field === key || p.all));
     }
-    shouldHaveColumn(prop, populate, exclude, includeFormulas = true) {
+    shouldHaveColumn(prop, populate, exclude, includeFormulas = true, ignoreInlineEmbeddables = true) {
         if (exclude?.includes(prop.name)) {
             return false;
         }
@@ -475,7 +452,7 @@ export class Platform {
             return true;
         }
         if (prop.kind === ReferenceKind.EMBEDDED) {
-            return !!prop.object;
+            return prop.object || ignoreInlineEmbeddables;
         }
         return prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner;
     }
@@ -522,9 +499,9 @@ export class Platform {
     clone() {
         return this;
     }
-    /* v8 ignore next 4 */
     /** @ignore */
-    [inspect.custom]() {
+    /* v8 ignore next */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
         return `[${this.constructor.name}]`;
     }
 }

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;
@@ -17,10 +18,14 @@ export interface SerializeOptions<T, P extends string = never, E extends string
     forceObject?: boolean;
     /** Ignore custom property serializers. */
     ignoreSerializers?: boolean;
+    /** Include properties marked as `hidden`. */
+    includeHidden?: boolean;
     /** Skip properties with `null` value. */
     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.