@mikro-orm/core 7.0.2-dev.13 → 7.0.2-dev.14

package/platforms/Platform.d.ts

@@ -9,27 +9,39 @@ 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';
+/** Symbol used to tag cloned embeddable data for JSON serialization handling. */
 export declare const JsonProperty: unique symbol;
+/** Abstract base class providing database-specific behavior and SQL dialect differences. */
 export declare abstract class Platform {
     protected readonly exceptionConverter: ExceptionConverter;
     protected config: Configuration;
     protected namingStrategy: NamingStrategy;
     protected timezone?: string;
+    /** Whether this driver uses pivot tables for M:N relations (SQL drivers do, MongoDB does not). */
     usesPivotTable(): boolean;
+    /** Whether this driver supports database transactions. */
     supportsTransactions(): boolean;
+    /** Whether the driver wraps operations in implicit transactions by default. */
     usesImplicitTransactions(): boolean;
+    /** Returns the default naming strategy constructor for this platform. */
     getNamingStrategy(): {
         new (): NamingStrategy;
     };
+    /** Whether the driver supports RETURNING clause (e.g. PostgreSQL). */
     usesReturningStatement(): boolean;
+    /** Whether the driver supports OUTPUT clause (e.g. MSSQL). */
     usesOutputStatement(): boolean;
+    /** Whether DELETE statements require explicit CASCADE keyword. */
     usesCascadeStatement(): boolean;
     /** for postgres native enums */
     supportsNativeEnums(): boolean;
     /** for postgres text enums (default) */
     usesEnumCheckConstraints(): boolean;
+    /** Whether this platform supports materialized views. */
     supportsMaterializedViews(): 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. */
     indexForeignKeys(): boolean;
     /**
      * Whether or not the driver supports retuning list of created PKs back when multi-inserting
@@ -39,6 +51,7 @@ export declare abstract class Platform {
      * Whether or not the driver supports updating many records at once
      */
     usesBatchUpdates(): boolean;
+    /** Whether the platform supports the DEFAULT keyword in INSERT statements. */
     usesDefaultKeyword(): boolean;
     /**
      * Normalizes primary key wrapper to scalar value (e.g. mongodb's ObjectId to string)
@@ -52,15 +65,23 @@ export declare abstract class Platform {
      * Returns the SQL specific for the platform to get the current timestamp
      */
     getCurrentTimestampSQL(length?: number): string;
+    /** Returns the SQL type declaration for datetime columns. */
     getDateTimeTypeDeclarationSQL(column: {
         length?: number;
     }): string;
+    /** Returns the default fractional seconds precision for datetime columns. */
     getDefaultDateTimeLength(): number;
+    /** Returns the default length for varchar columns. */
     getDefaultVarcharLength(): number;
+    /** Returns the default length for char columns. */
     getDefaultCharLength(): number;
+    /** Returns the SQL type declaration for date columns. */
     getDateTypeDeclarationSQL(length?: number): string;
+    /** Returns the SQL type declaration for time columns. */
     getTimeTypeDeclarationSQL(length?: number): string;
+    /** Returns the SQL operator used for regular expression matching. */
     getRegExpOperator(val?: unknown, flags?: string): string;
+    /** Builds the SQL clause and parameters for a regular expression condition. */
     mapRegExpCondition(mappedKey: string, value: {
         $re: string;
         $flags?: string;
@@ -68,19 +89,28 @@ export declare abstract class Platform {
         sql: string;
         params: unknown[];
     };
+    /** Converts a JavaScript RegExp into a platform-specific regex representation. */
     getRegExpValue(val: RegExp): {
         $re: string;
         $flags?: string;
     };
+    /** Whether the given operator is allowed at the top level of a query condition. */
     isAllowedTopLevelOperator(operator: string): boolean;
+    /** Converts a version field value for comparison in optimistic locking queries. */
     convertVersionValue(value: Date | number, prop: EntityProperty): Date | string | number | {
         $in: (string | number)[];
     };
+    /** Returns the default fractional seconds precision for version timestamp columns. */
     getDefaultVersionLength(): number;
+    /** Whether the platform supports tuple comparison in WHERE clauses. */
     allowsComparingTuples(): boolean;
+    /** Whether the given property maps to a bigint database column. */
     isBigIntProperty(prop: EntityProperty): boolean;
+    /** Returns the default schema name for this platform (e.g. "public" for PostgreSQL). */
     getDefaultSchemaName(): string | undefined;
+    /** Returns the SQL type declaration for boolean columns. */
     getBooleanTypeDeclarationSQL(): string;
+    /** Returns the SQL type declaration for integer columns. */
     getIntegerTypeDeclarationSQL(column: {
         length?: number;
         unsigned?: boolean;
@@ -134,6 +164,7 @@ export declare abstract class Platform {
     getUuidTypeDeclarationSQL(column: {
         length?: number;
     }): string;
+    /** Extracts the base type name from a full SQL type declaration (e.g. "varchar(255)" -> "varchar"). */
     extractSimpleType(type: string): string;
     /**
      * This should be used only to compare types, it can strip some information like the length.
@@ -143,18 +174,26 @@ export declare abstract class Platform {
         precision?: number;
         scale?: number;
     }): string;
+    /** Returns the mapped Type instance for a given SQL/runtime type string. */
     getMappedType(type: string): Type<unknown>;
+    /** Returns the default mapped Type for a given type string when no custom mapping is configured. */
     getDefaultMappedType(type: string): Type<unknown>;
+    /** Whether the platform supports multiple cascade paths to the same table. */
     supportsMultipleCascadePaths(): boolean;
     /**
      * Returns true if the platform supports ON UPDATE foreign key rules.
      * Oracle doesn't support ON UPDATE rules.
      */
     supportsOnUpdate(): boolean;
+    /** Whether the connection supports executing multiple SQL statements in a single call. */
     supportsMultipleStatements(): boolean;
+    /** Whether the platform supports the UNION WHERE optimization for multi-branch queries. */
     supportsUnionWhere(): boolean;
+    /** Returns the SQL type declaration used for array storage. */
     getArrayDeclarationSQL(): string;
+    /** Serializes a string array into its database storage format. */
     marshallArray(values: string[]): string;
+    /** Deserializes a database-stored array string back into a string array. */
     unmarshallArray(value: string): string[];
     getBlobDeclarationSQL(): string;
     getJsonDeclarationSQL(): string;
@@ -168,8 +207,11 @@ export declare abstract class Platform {
     getFullTextWhereClause(prop: EntityProperty): string;
     supportsCreatingFullTextIndex(): boolean;
     getFullTextIndexExpression(indexName: string, schemaName: string | undefined, tableName: string, columns: SimpleColumnMeta[]): string;
+    /** Whether the driver automatically parses JSON columns into JS objects. */
     convertsJsonAutomatically(): boolean;
+    /** Converts a JS value to its JSON database representation (typically JSON.stringify). */
     convertJsonToDatabaseValue(value: unknown, context?: TransformContext): unknown;
+    /** Converts a database JSON value to its JS representation. */
     convertJsonToJSValue(value: unknown, context?: TransformContext): unknown;
     convertDateToJSValue(value: string | Date): string;
     convertIntervalToJSValue(value: string): unknown;
@@ -182,9 +224,13 @@ export declare abstract class Platform {
     compareUuids(): string;
     convertUuidToJSValue(value: unknown): unknown;
     convertUuidToDatabaseValue(value: unknown): unknown;
+    /** Parses a string or numeric value into a Date object. */
     parseDate(value: string | number): Date;
+    /** Returns the default EntityRepository class used by this platform. */
     getRepositoryClass<T extends object>(): Constructor<EntityRepository<T>>;
+    /** Returns the default character set for this platform. */
     getDefaultCharset(): string;
+    /** Returns the exception converter for translating native errors to driver exceptions. */
     getExceptionConverter(): ExceptionConverter;
     /**
      * Allows registering extensions of the driver automatically (e.g. `SchemaGenerator` extension in SQL drivers).
@@ -192,35 +238,54 @@ export declare abstract class Platform {
     lookupExtensions(orm: MikroORM): void;
     /** @internal */
     init(orm: MikroORM): void;
+    /** Retrieves a registered extension (e.g. SchemaGenerator, Migrator), throwing if not found. */
     getExtension<T>(extensionName: string, extensionKey: string, moduleName: string, em: EntityManager): T;
     getSchemaGenerator(driver: IDatabaseDriver, em?: EntityManager): ISchemaGenerator;
+    /** Processes a date value before persisting, applying timezone or format conversions. */
     processDateProperty(value: unknown): string | number | Date;
+    /** Wraps a table or column identifier with the platform-specific quote character. */
     quoteIdentifier(id: string | {
         toString: () => string;
     }, quote?: string): string;
+    /** Quotes a literal value for safe embedding in SQL. */
     quoteValue(value: any): string;
     escape(value: any): string;
+    /** Replaces `?` placeholders in SQL with quoted parameter values. */
     formatQuery(sql: string, params: readonly any[]): string;
+    /** Deep-clones embeddable data and tags it for JSON serialization. */
     cloneEmbeddable<T>(data: T): T;
+    /** Initializes the platform with the ORM configuration. */
     setConfig(config: Configuration): void;
+    /** Returns the current ORM configuration. */
     getConfig(): Configuration;
+    /** Returns the configured timezone, or undefined if not set. */
     getTimezone(): string | undefined;
+    /** Whether the given property represents a numeric database column. */
     isNumericProperty(prop: EntityProperty, ignoreCustomType?: boolean): boolean;
+    /** Whether the given mapped type represents a numeric column. */
     isNumericColumn(mappedType: Type<unknown>): boolean;
+    /** Whether the platform supports unsigned integer columns. */
     supportsUnsigned(): boolean;
     /**
      * Returns the default name of index for the given columns
      */
     getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence'): string;
+    /** Returns the default primary key constraint name. */
     getDefaultPrimaryName(tableName: string, columns: string[]): string;
+    /** Whether the platform supports custom names for primary key constraints. */
     supportsCustomPrimaryKeyNames(): boolean;
+    /** Whether the given property key is included in the populate hint. */
     isPopulated<T>(key: string, populate: readonly PopulateOptions<T>[] | boolean): boolean;
+    /** Whether the given property should be included as a column in the SELECT query. */
     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)
      */
+    /** Whether the platform supports generating down migrations. */
     supportsDownMigrations(): boolean;
+    /** Whether the platform supports deferred unique constraints. */
     supportsDeferredUniqueConstraints(): boolean;
+    /** Platform-specific validation of entity metadata. */
     validateMetadata(meta: EntityMetadata): void;
     /**
      * Generates a custom order by statement given a set of in order values, eg.

package/platforms/Platform.js

@@ -6,30 +6,39 @@ import { ArrayType, BigIntType, BlobType, BooleanType, CharacterType, DateTimeTy
 import { parseJsonSafe, Utils } from '../utils/Utils.js';
 import { ReferenceKind } from '../enums.js';
 import { Raw } from '../utils/RawQueryFragment.js';
+/** Symbol used to tag cloned embeddable data for JSON serialization handling. */
 export const JsonProperty = Symbol('JsonProperty');
+/** Abstract base class providing database-specific behavior and SQL dialect differences. */
 export class Platform {
     exceptionConverter = new ExceptionConverter();
     config;
     namingStrategy;
     timezone;
+    /** Whether this driver uses pivot tables for M:N relations (SQL drivers do, MongoDB does not). */
     usesPivotTable() {
         return false;
     }
+    /** Whether this driver supports database transactions. */
     supportsTransactions() {
         return !this.config.get('disableTransactions');
     }
+    /** Whether the driver wraps operations in implicit transactions by default. */
     usesImplicitTransactions() {
         return true;
     }
+    /** Returns the default naming strategy constructor for this platform. */
     getNamingStrategy() {
         return UnderscoreNamingStrategy;
     }
+    /** Whether the driver supports RETURNING clause (e.g. PostgreSQL). */
     usesReturningStatement() {
         return false;
     }
+    /** Whether the driver supports OUTPUT clause (e.g. MSSQL). */
     usesOutputStatement() {
         return false;
     }
+    /** Whether DELETE statements require explicit CASCADE keyword. */
     usesCascadeStatement() {
         return false;
     }
@@ -41,12 +50,15 @@ export class Platform {
     usesEnumCheckConstraints() {
         return false;
     }
+    /** Whether this platform supports materialized views. */
     supportsMaterializedViews() {
         return false;
     }
+    /** Returns the schema helper instance for this platform, or undefined if not supported. */
     getSchemaHelper() {
         return undefined;
     }
+    /** Whether the platform automatically creates indexes on foreign key columns. */
     indexForeignKeys() {
         return false;
     }
@@ -62,6 +74,7 @@ export class Platform {
     usesBatchUpdates() {
         return true;
     }
+    /** Whether the platform supports the DEFAULT keyword in INSERT statements. */
     usesDefaultKeyword() {
         return true;
     }
@@ -83,59 +96,76 @@ export class Platform {
     getCurrentTimestampSQL(length) {
         return 'current_timestamp' + (length ? `(${length})` : '');
     }
+    /** Returns the SQL type declaration for datetime columns. */
     getDateTimeTypeDeclarationSQL(column) {
         return 'datetime' + (column.length ? `(${column.length})` : '');
     }
+    /** Returns the default fractional seconds precision for datetime columns. */
     getDefaultDateTimeLength() {
         return 0;
     }
+    /** Returns the default length for varchar columns. */
     getDefaultVarcharLength() {
         return 255;
     }
+    /** Returns the default length for char columns. */
     getDefaultCharLength() {
         return 1;
     }
+    /** Returns the SQL type declaration for date columns. */
     getDateTypeDeclarationSQL(length) {
         return 'date' + (length ? `(${length})` : '');
     }
+    /** Returns the SQL type declaration for time columns. */
     getTimeTypeDeclarationSQL(length) {
         return 'time' + (length ? `(${length})` : '');
     }
+    /** Returns the SQL operator used for regular expression matching. */
     getRegExpOperator(val, flags) {
         return 'regexp';
     }
+    /** Builds the SQL clause and parameters for a regular expression condition. */
     mapRegExpCondition(mappedKey, value) {
         const operator = this.getRegExpOperator(value.$re, value.$flags);
         const quotedKey = this.quoteIdentifier(mappedKey);
         return { sql: `${quotedKey} ${operator} ?`, params: [value.$re] };
     }
+    /** Converts a JavaScript RegExp into a platform-specific regex representation. */
     getRegExpValue(val) {
         if (val.flags.includes('i')) {
             return { $re: `(?i)${val.source}` };
         }
         return { $re: val.source };
     }
+    /** Whether the given operator is allowed at the top level of a query condition. */
     isAllowedTopLevelOperator(operator) {
         return operator === '$not';
     }
+    /** Converts a version field value for comparison in optimistic locking queries. */
     convertVersionValue(value, prop) {
         return value;
     }
+    /** Returns the default fractional seconds precision for version timestamp columns. */
     getDefaultVersionLength() {
         return 3;
     }
+    /** Whether the platform supports tuple comparison in WHERE clauses. */
     allowsComparingTuples() {
         return true;
     }
+    /** Whether the given property maps to a bigint database column. */
     isBigIntProperty(prop) {
         return prop.columnTypes?.[0] === 'bigint';
     }
+    /** Returns the default schema name for this platform (e.g. "public" for PostgreSQL). */
     getDefaultSchemaName() {
         return undefined;
     }
+    /** Returns the SQL type declaration for boolean columns. */
     getBooleanTypeDeclarationSQL() {
         return 'boolean';
     }
+    /** Returns the SQL type declaration for integer columns. */
     getIntegerTypeDeclarationSQL(column) {
         return 'int';
     }
@@ -184,6 +214,7 @@ export class Platform {
         column.length ??= 36;
         return this.getVarcharTypeDeclarationSQL(column);
     }
+    /** Extracts the base type name from a full SQL type declaration (e.g. "varchar(255)" -> "varchar"). */
     extractSimpleType(type) {
         return /[^(), ]+/.exec(type.toLowerCase())[0];
     }
@@ -193,10 +224,12 @@ export class Platform {
     normalizeColumnType(type, options) {
         return type.toLowerCase();
     }
+    /** Returns the mapped Type instance for a given SQL/runtime type string. */
     getMappedType(type) {
         const mappedType = this.config.get('discovery').getMappedType?.(type, this);
         return mappedType ?? this.getDefaultMappedType(type);
     }
+    /** Returns the default mapped Type for a given type string when no custom mapping is configured. */
     getDefaultMappedType(type) {
         if (type.endsWith('[]')) {
             return Type.getType(ArrayType);
@@ -257,6 +290,7 @@ export class Platform {
                 return Type.getType(UnknownType);
         }
     }
+    /** Whether the platform supports multiple cascade paths to the same table. */
     supportsMultipleCascadePaths() {
         return true;
     }
@@ -267,18 +301,23 @@ export class Platform {
     supportsOnUpdate() {
         return true;
     }
+    /** Whether the connection supports executing multiple SQL statements in a single call. */
     supportsMultipleStatements() {
         return this.config.get('multipleStatements');
     }
+    /** Whether the platform supports the UNION WHERE optimization for multi-branch queries. */
     supportsUnionWhere() {
         return false;
     }
+    /** Returns the SQL type declaration used for array storage. */
     getArrayDeclarationSQL() {
         return 'text';
     }
+    /** Serializes a string array into its database storage format. */
     marshallArray(values) {
         return values.join(',');
     }
+    /** Deserializes a database-stored array string back into a string array. */
     unmarshallArray(value) {
         if (value === '') {
             return [];
@@ -335,12 +374,15 @@ export class Platform {
     getFullTextIndexExpression(indexName, schemaName, tableName, columns) {
         throw new Error('Full text searching is not supported by this driver.');
     }
+    /** Whether the driver automatically parses JSON columns into JS objects. */
     convertsJsonAutomatically() {
         return true;
     }
+    /** Converts a JS value to its JSON database representation (typically JSON.stringify). */
     convertJsonToDatabaseValue(value, context) {
         return JSON.stringify(value);
     }
+    /** Converts a database JSON value to its JS representation. */
     convertJsonToJSValue(value, context) {
         return parseJsonSafe(value);
     }
@@ -369,6 +411,7 @@ export class Platform {
     convertUuidToDatabaseValue(value) {
         return value;
     }
+    /** Parses a string or numeric value into a Date object. */
     parseDate(value) {
         const date = new Date(value);
         /* v8 ignore next */
@@ -377,12 +420,15 @@ export class Platform {
         }
         return date;
     }
+    /** Returns the default EntityRepository class used by this platform. */
     getRepositoryClass() {
         return EntityRepository;
     }
+    /** Returns the default character set for this platform. */
     getDefaultCharset() {
         return 'utf8';
     }
+    /** Returns the exception converter for translating native errors to driver exceptions. */
     getExceptionConverter() {
         return this.exceptionConverter;
     }
@@ -396,6 +442,7 @@ export class Platform {
     init(orm) {
         this.lookupExtensions(orm);
     }
+    /** Retrieves a registered extension (e.g. SchemaGenerator, Migrator), throwing if not found. */
     getExtension(extensionName, extensionKey, moduleName, em) {
         const extension = this.config.getExtension(extensionKey);
         if (extension) {
@@ -408,9 +455,11 @@ export class Platform {
     getSchemaGenerator(driver, em) {
         throw new Error(`${driver.constructor.name} does not support SchemaGenerator`);
     }
+    /** Processes a date value before persisting, applying timezone or format conversions. */
     processDateProperty(value) {
         return value;
     }
+    /** Wraps a table or column identifier with the platform-specific quote character. */
     quoteIdentifier(id, quote = '`') {
         const raw = Raw.getKnownFragment(id);
         if (raw) {
@@ -418,6 +467,7 @@ export class Platform {
         }
         return `${quote}${id.toString().replace('.', `${quote}.${quote}`)}${quote}`;
     }
+    /** Quotes a literal value for safe embedding in SQL. */
     quoteValue(value) {
         return value;
     }
@@ -425,6 +475,7 @@ export class Platform {
     escape(value) {
         return value;
     }
+    /** Replaces `?` placeholders in SQL with quoted parameter values. */
     formatQuery(sql, params) {
         if (params.length === 0) {
             return sql;
@@ -464,12 +515,14 @@ export class Platform {
         }
         return ret;
     }
+    /** Deep-clones embeddable data and tags it for JSON serialization. */
     cloneEmbeddable(data) {
         const copy = clone(data);
         // tag the copy so we know it should be stringified when quoting (so we know how to treat JSON arrays)
         Object.defineProperty(copy, JsonProperty, { enumerable: false, value: true });
         return copy;
     }
+    /** Initializes the platform with the ORM configuration. */
     setConfig(config) {
         this.config = config;
         this.namingStrategy = config.getNamingStrategy();
@@ -480,19 +533,24 @@ export class Platform {
             this.timezone = this.config.get('timezone');
         }
     }
+    /** Returns the current ORM configuration. */
     getConfig() {
         return this.config;
     }
+    /** Returns the configured timezone, or undefined if not set. */
     getTimezone() {
         return this.timezone;
     }
+    /** Whether the given property represents a numeric database column. */
     isNumericProperty(prop, ignoreCustomType = false) {
         const numericMappedType = prop.columnTypes?.[0] && this.isNumericColumn(this.getMappedType(prop.columnTypes[0]));
         return numericMappedType || prop.type === 'number' || this.isBigIntProperty(prop);
     }
+    /** Whether the given mapped type represents a numeric column. */
     isNumericColumn(mappedType) {
         return [IntegerType, SmallIntType, BigIntType, TinyIntType].some(t => mappedType instanceof t);
     }
+    /** Whether the platform supports unsigned integer columns. */
     supportsUnsigned() {
         return false;
     }
@@ -502,15 +560,19 @@ export class Platform {
     getIndexName(tableName, columns, type) {
         return this.namingStrategy.indexName(tableName, columns, type);
     }
+    /** Returns the default primary key constraint name. */
     getDefaultPrimaryName(tableName, columns) {
         return 'primary';
     }
+    /** Whether the platform supports custom names for primary key constraints. */
     supportsCustomPrimaryKeyNames() {
         return false;
     }
+    /** Whether the given property key is included in the populate hint. */
     isPopulated(key, populate) {
         return populate === true || (populate !== false && populate.some(p => p.field === key || p.all));
     }
+    /** Whether the given property should be included as a column in the SELECT query. */
     shouldHaveColumn(prop, populate, exclude, includeFormulas = true, ignoreInlineEmbeddables = true) {
         if (exclude?.includes(prop.name)) {
             return false;
@@ -538,12 +600,15 @@ export class Platform {
     /**
      * Currently not supported due to how knex does complex sqlite diffing (always based on current schema)
      */
+    /** Whether the platform supports generating down migrations. */
     supportsDownMigrations() {
         return true;
     }
+    /** Whether the platform supports deferred unique constraints. */
     supportsDeferredUniqueConstraints() {
         return true;
     }
+    /** Platform-specific validation of entity metadata. */
     validateMetadata(meta) {
         return;
     }

package/serialization/EntitySerializer.d.ts

@@ -1,6 +1,8 @@
 import type { ArrayElement, AutoPath, CleanTypeConfig, SerializeDTO, FromEntityType, TypeConfig, UnboxArray } from '../typings.js';
 import { type PopulatePath } from '../enums.js';
+/** Converts entity instances to plain DTOs via `serialize()`, with fine-grained control over populate, exclude, and serialization groups. */
 export declare class EntitySerializer {
+    /** Serializes an entity to a plain DTO, with fine-grained control over population, exclusion, groups, and custom types. */
     static serialize<T extends object, P extends string = never, E extends string = never>(entity: T, options?: SerializeOptions<T, P, E>): SerializeDTO<T, P, E>;
     private static propertyName;
     private static processProperty;

package/serialization/EntitySerializer.js

@@ -30,7 +30,9 @@ function isPopulated(propName, options) {
     }
     return false;
 }
+/** Converts entity instances to plain DTOs via `serialize()`, with fine-grained control over populate, exclude, and serialization groups. */
 export class EntitySerializer {
+    /** Serializes an entity to a plain DTO, with fine-grained control over population, exclusion, groups, and custom types. */
     static serialize(entity, options = {}) {
         const wrapped = helper(entity);
         const meta = wrapped.__meta;

package/serialization/EntityTransformer.d.ts

@@ -1,5 +1,7 @@
 import type { EntityDTO, EntityKey } from '../typings.js';
+/** Converts entity instances to plain objects via `toObject()`, respecting populate hints, hidden fields, and serialization context. */
 export declare class EntityTransformer {
+    /** Converts an entity to a plain object, respecting populate hints, hidden fields, and custom serializers. */
     static toObject<Entity extends object, Ignored extends EntityKey<Entity> = never>(entity: Entity, ignoreFields?: Ignored[], raw?: boolean): Omit<EntityDTO<Entity>, Ignored>;
     private static propertyName;
     private static processProperty;

package/serialization/EntityTransformer.js

@@ -9,7 +9,9 @@ function isVisible(meta, propName, ignoreFields = []) {
     const prefixed = prop && !prop.primary && !prop.accessor && propName.startsWith('_'); // ignore prefixed properties, if it's not a PK
     return visible && !prefixed && !ignoreFields.includes(propName);
 }
+/** Converts entity instances to plain objects via `toObject()`, respecting populate hints, hidden fields, and serialization context. */
 export class EntityTransformer {
+    /** Converts an entity to a plain object, respecting populate hints, hidden fields, and custom serializers. */
     static toObject(entity, ignoreFields = [], raw = false) {
         if (!Array.isArray(ignoreFields)) {
             ignoreFields = [];

package/serialization/SerializationContext.d.ts

@@ -13,14 +13,19 @@ export declare class SerializationContext<T extends object> {
      * Returns true when there is a cycle detected.
      */
     visit(entityName: EntityName, prop: string): boolean;
+    /** Removes the last entry from the visit path after processing a property. */
     leave(entityName: EntityName, prop: string): void;
+    /** Cleans up the serialization context by removing root references from all tracked entities. */
     close(): void;
     /**
      * When initializing new context, we need to propagate it to the whole entity graph recursively.
      */
     static propagate(root: SerializationContext<any>, entity: AnyEntity, isVisible: (meta: EntityMetadata, prop: string) => boolean): void;
+    /** Checks whether a property is explicitly listed in the populate hints for the current path. */
     isMarkedAsPopulated(entityName: EntityName, prop: string): boolean;
+    /** Checks whether a property is excluded from serialization via the exclude list. */
     isExcluded(entityName: EntityName, prop: string): boolean;
+    /** Checks whether a property is included in the partial fields selection for the current path. */
     isPartiallyLoaded(entityName: EntityName, prop: string): boolean;
     private register;
 }

package/serialization/SerializationContext.js

@@ -32,6 +32,7 @@ export class SerializationContext {
         this.path.push([entityName, prop]);
         return false;
     }
+    /** Removes the last entry from the visit path after processing a property. */
     leave(entityName, prop) {
         const last = this.path.pop();
         /* v8 ignore next */
@@ -39,6 +40,7 @@ export class SerializationContext {
             throw new Error(`Trying to leave wrong property: ${entityName}.${prop} instead of ${last?.join('.')}`);
         }
     }
+    /** Cleans up the serialization context by removing root references from all tracked entities. */
     close() {
         for (const entity of this.#entities) {
             delete helper(entity).__serializationContext.root;
@@ -70,6 +72,7 @@ export class SerializationContext {
             }
         }
     }
+    /** Checks whether a property is explicitly listed in the populate hints for the current path. */
     isMarkedAsPopulated(entityName, prop) {
         let populate = this.#populate ?? [];
         for (const segment of this.path) {
@@ -90,6 +93,7 @@ export class SerializationContext {
         }
         return !!populate?.some(p => p.field === prop);
     }
+    /** Checks whether a property is excluded from serialization via the exclude list. */
     isExcluded(entityName, prop) {
         if (!this.#exclude || this.#exclude.length === 0) {
             return false;
@@ -97,6 +101,7 @@ export class SerializationContext {
         const fullPath = this.path.map(segment => segment[1] + '.').join('') + prop;
         return this.#exclude.includes(fullPath);
     }
+    /** Checks whether a property is included in the partial fields selection for the current path. */
     isPartiallyLoaded(entityName, prop) {
         if (!this.#fields) {
             return true;

package/types/ArrayType.d.ts

@@ -1,6 +1,7 @@
 import { type TransformContext, Type } from './Type.js';
 import type { EntityProperty } from '../typings.js';
 import type { Platform } from '../platforms/Platform.js';
+/** Maps a database text/array column to a JS array, using platform-specific marshalling (e.g., PostgreSQL arrays or comma-separated strings). */
 export declare class ArrayType<T = string> extends Type<T[] | null, string | null> {
     private readonly toJsValue;
     private readonly toDbValue;

package/types/ArrayType.js

@@ -1,5 +1,6 @@
 import { Type } from './Type.js';
 import { ValidationError } from '../errors.js';
+/** Maps a database text/array column to a JS array, using platform-specific marshalling (e.g., PostgreSQL arrays or comma-separated strings). */
 export class ArrayType extends Type {
     toJsValue;
     toDbValue;