@mikro-orm/core 7.0.0-rc.2 → 7.0.0

package/metadata/MetadataDiscovery.js

@@ -12,68 +12,72 @@ import { colors } from '../logging/colors.js';
 import { raw, Raw } from '../utils/RawQueryFragment.js';
 import { BaseEntity } from '../entity/BaseEntity.js';
 export class MetadataDiscovery {
-    metadata;
-    platform;
-    config;
-    namingStrategy;
-    metadataProvider;
-    logger;
-    schemaHelper;
-    validator = new MetadataValidator();
-    discovered = [];
+    #namingStrategy;
+    #metadataProvider;
+    #logger;
+    #schemaHelper;
+    #validator = new MetadataValidator();
+    #discovered = [];
+    #metadata;
+    #platform;
+    #config;
     constructor(metadata, platform, config) {
-        this.metadata = metadata;
-        this.platform = platform;
-        this.config = config;
-        this.namingStrategy = this.config.getNamingStrategy();
-        this.metadataProvider = this.config.getMetadataProvider();
-        this.logger = this.config.getLogger();
-        this.schemaHelper = this.platform.getSchemaHelper();
+        this.#metadata = metadata;
+        this.#platform = platform;
+        this.#config = config;
+        this.#namingStrategy = this.#config.getNamingStrategy();
+        this.#metadataProvider = this.#config.getMetadataProvider();
+        this.#logger = this.#config.getLogger();
+        this.#schemaHelper = this.#platform.getSchemaHelper();
     }
     async discover(preferTs = true) {
-        this.discovered.length = 0;
+        this.#discovered.length = 0;
         const startTime = Date.now();
-        const suffix = this.metadataProvider.constructor === MetadataProvider ? '' : `, using ${colors.cyan(this.metadataProvider.constructor.name)}`;
-        this.logger.log('discovery', `ORM entity discovery started${suffix}`);
+        const suffix = this.#metadataProvider.constructor === MetadataProvider
+            ? ''
+            : `, using ${colors.cyan(this.#metadataProvider.constructor.name)}`;
+        this.#logger.log('discovery', `ORM entity discovery started${suffix}`);
         await this.findEntities(preferTs);
-        for (const meta of this.discovered) {
+        for (const meta of this.#discovered) {
             /* v8 ignore next */
-            await this.config.get('discovery').onMetadata?.(meta, this.platform);
+            await this.#config.get('discovery').onMetadata?.(meta, this.#platform);
         }
-        this.processDiscoveredEntities(this.discovered);
+        this.processDiscoveredEntities(this.#discovered);
         const diff = Date.now() - startTime;
-        this.logger.log('discovery', `- entity discovery finished, found ${colors.green('' + this.discovered.length)} entities, took ${colors.green(`${diff} ms`)}`);
+        this.#logger.log('discovery', `- entity discovery finished, found ${colors.green('' + this.#discovered.length)} entities, took ${colors.green(`${diff} ms`)}`);
         const storage = this.mapDiscoveredEntities();
         /* v8 ignore next */
-        await this.config.get('discovery').afterDiscovered?.(storage, this.platform);
+        await this.#config.get('discovery').afterDiscovered?.(storage, this.#platform);
         return storage;
     }
     discoverSync() {
-        this.discovered.length = 0;
+        this.#discovered.length = 0;
         const startTime = Date.now();
-        const suffix = this.metadataProvider.constructor === MetadataProvider ? '' : `, using ${colors.cyan(this.metadataProvider.constructor.name)}`;
-        this.logger.log('discovery', `ORM entity discovery started${suffix} in sync mode`);
-        const refs = this.config.get('entities');
+        const suffix = this.#metadataProvider.constructor === MetadataProvider
+            ? ''
+            : `, using ${colors.cyan(this.#metadataProvider.constructor.name)}`;
+        this.#logger.log('discovery', `ORM entity discovery started${suffix} in sync mode`);
+        const refs = this.#config.get('entities');
         this.discoverReferences(refs);
-        for (const meta of this.discovered) {
+        for (const meta of this.#discovered) {
             /* v8 ignore next */
-            void this.config.get('discovery').onMetadata?.(meta, this.platform);
+            void this.#config.get('discovery').onMetadata?.(meta, this.#platform);
         }
-        this.processDiscoveredEntities(this.discovered);
+        this.processDiscoveredEntities(this.#discovered);
         const diff = Date.now() - startTime;
-        this.logger.log('discovery', `- entity discovery finished, found ${colors.green('' + this.discovered.length)} entities, took ${colors.green(`${diff} ms`)}`);
+        this.#logger.log('discovery', `- entity discovery finished, found ${colors.green('' + this.#discovered.length)} entities, took ${colors.green(`${diff} ms`)}`);
         const storage = this.mapDiscoveredEntities();
         /* v8 ignore next */
-        void this.config.get('discovery').afterDiscovered?.(storage, this.platform);
+        void this.#config.get('discovery').afterDiscovered?.(storage, this.#platform);
         return storage;
     }
     mapDiscoveredEntities() {
         const discovered = new MetadataStorage();
-        this.discovered
+        this.#discovered
             .filter(meta => meta.root.name)
             .sort((a, b) => b.root.name.localeCompare(a.root.name))
             .forEach(meta => {
-            this.platform.validateMetadata(meta);
+            this.#platform.validateMetadata(meta);
             discovered.set(meta.class, meta);
         });
         for (const meta of discovered) {
@@ -91,6 +95,7 @@ export class MetadataDiscovery {
             }
             const desc = Object.getOwnPropertyDescriptor(meta.prototype, prop.name);
             if (desc?.get || desc?.set) {
+                this.initRelation(prop);
                 this.initFieldName(prop);
                 const accessor = prop.name;
                 prop.name = typeof prop.accessor === 'string' ? prop.accessor : prop.name;
@@ -106,7 +111,10 @@ export class MetadataDiscovery {
             }
             else {
                 const name = prop.name;
-                prop.name = prop.accessor;
+                if (prop.kind === ReferenceKind.SCALAR || prop.kind === ReferenceKind.EMBEDDED) {
+                    prop.name = prop.accessor;
+                }
+                this.initRelation(prop);
                 this.initFieldName(prop);
                 prop.serializedName ??= prop.accessor;
                 prop.name = name;
@@ -123,13 +131,13 @@ export class MetadataDiscovery {
         // ignore base entities (not annotated with @Entity)
         const filtered = discovered.filter(meta => meta.root.name);
         // sort so we discover entities first to get around issues with nested embeddables
-        filtered.sort((a, b) => !a.embeddable === !b.embeddable ? 0 : (a.embeddable ? 1 : -1));
+        filtered.sort((a, b) => (!a.embeddable === !b.embeddable ? 0 : a.embeddable ? 1 : -1));
         filtered.forEach(meta => this.initSingleTableInheritance(meta, filtered));
         filtered.forEach(meta => this.initTPTRelationships(meta, filtered));
         filtered.forEach(meta => this.defineBaseEntityProperties(meta));
         filtered.forEach(meta => {
             const newMeta = EntitySchema.fromMetadata(meta).init().meta;
-            return this.metadata.set(newMeta.class, newMeta);
+            return this.#metadata.set(newMeta.class, newMeta);
         });
         filtered.forEach(meta => this.initAutoincrement(meta));
         const forEachProp = (cb) => {
@@ -159,9 +167,9 @@ export class MetadataDiscovery {
             discovered.push(...this.processEntity(meta));
         }
         discovered.forEach(meta => meta.sync(true));
-        this.metadataProvider.combineCache();
+        this.#metadataProvider.combineCache();
         return discovered.map(meta => {
-            meta = this.metadata.get(meta.class);
+            meta = this.#metadata.get(meta.class);
             meta.sync(true);
             this.findReferencingProperties(meta, filtered);
             if (meta.inheritanceType === 'tpt') {
@@ -171,8 +179,8 @@ export class MetadataDiscovery {
         });
     }
     async findEntities(preferTs) {
-        const { entities, entitiesTs, baseDir } = this.config.getAll();
-        const targets = (preferTs && entitiesTs.length > 0) ? entitiesTs : entities;
+        const { entities, entitiesTs, baseDir } = this.#config.getAll();
+        const targets = preferTs && entitiesTs.length > 0 ? entitiesTs : entities;
         const processed = [];
         const paths = [];
         for (const entity of targets) {
@@ -185,7 +193,7 @@ export class MetadataDiscovery {
         }
         if (paths.length > 0) {
             const { discoverEntities } = await import('@mikro-orm/core/file-discovery');
-            processed.push(...await discoverEntities(paths, { baseDir }));
+            processed.push(...(await discoverEntities(paths, { baseDir })));
         }
         return this.discoverReferences(processed);
     }
@@ -195,21 +203,21 @@ export class MetadataDiscovery {
             .replace(/\[]$/, '') // remove array suffix
             .replace(/\((.*)\)/, '$1'); // unwrap union types
         const missing = [];
-        this.discovered.forEach(meta => Object.values(meta.properties).forEach(prop => {
+        this.#discovered.forEach(meta => Object.values(meta.properties).forEach(prop => {
             if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.pivotEntity) {
                 const pivotEntity = prop.pivotEntity;
                 const target = typeof pivotEntity === 'function' && !pivotEntity.prototype
                     ? pivotEntity()
                     : pivotEntity;
-                if (!this.discovered.find(m => m.className === Utils.className(target))) {
+                if (!this.#discovered.find(m => m.className === Utils.className(target))) {
                     missing.push(target);
                 }
             }
             if (prop.kind !== ReferenceKind.SCALAR) {
-                const target = typeof prop.entity === 'function' && !prop.entity.prototype
-                    ? prop.entity()
-                    : prop.type;
-                if (!unwrap(prop.type).split(/ ?\| ?/).every(type => this.discovered.find(m => m.className === type))) {
+                const target = typeof prop.entity === 'function' && !prop.entity.prototype ? prop.entity() : prop.type;
+                if (!unwrap(prop.type)
+                    .split(/ ?\| ?/)
+                    .every(type => this.#discovered.find(m => m.className === type))) {
                     missing.push(...Utils.asArray(target));
                 }
             }
@@ -225,7 +233,7 @@ export class MetadataDiscovery {
             if (isDiscoverable && target.name) {
                 // Get the actual class for EntitySchema, or use target directly for classes
                 const targetClass = schema ? schema.meta.class : target;
-                if (!this.metadata.has(targetClass)) {
+                if (!this.#metadata.has(targetClass)) {
                     this.discoverReferences([target], false);
                     this.discoverMissingTargets();
                 }
@@ -240,16 +248,16 @@ export class MetadataDiscovery {
             }
             const schema = this.getSchema(entity);
             const meta = schema.init().meta;
-            this.metadata.set(meta.class, meta);
+            this.#metadata.set(meta.class, meta);
             found.push(schema);
         }
         // discover parents (base entities) automatically
-        for (const meta of this.metadata) {
+        for (const meta of this.#metadata) {
             let parent = meta.extends;
-            if (parent instanceof EntitySchema && !this.metadata.has(parent.init().meta.class)) {
+            if (parent instanceof EntitySchema && !this.#metadata.has(parent.init().meta.class)) {
                 this.discoverReferences([parent], false);
             }
-            if (typeof parent === 'function' && parent.name && !this.metadata.has(parent)) {
+            if (typeof parent === 'function' && parent.name && !this.#metadata.has(parent)) {
                 this.discoverReferences([parent], false);
             }
             /* v8 ignore next */
@@ -258,7 +266,10 @@ export class MetadataDiscovery {
             }
             parent = Object.getPrototypeOf(meta.class);
             // Skip if parent is the auto-generated base class for the same entity (from setClass usage)
-            if (parent.name !== '' && parent.name !== meta.className && !this.metadata.has(parent) && parent !== BaseEntity) {
+            if (parent.name !== '' &&
+                parent.name !== meta.className &&
+                !this.#metadata.has(parent) &&
+                parent !== BaseEntity) {
                 this.discoverReferences([parent], false);
             }
         }
@@ -267,15 +278,15 @@ export class MetadataDiscovery {
         }
         this.discoverMissingTargets();
         if (validate) {
-            this.validator.validateDiscovered(this.discovered, this.config.get('discovery'));
+            this.#validator.validateDiscovered(this.#discovered, this.#config.get('discovery'));
         }
-        return this.discovered.filter(meta => found.find(m => m.name === meta.className));
+        return this.#discovered.filter(meta => found.find(m => m.name === meta.className));
     }
     reset(entityName) {
-        const exists = this.discovered.findIndex(m => m.class === entityName || m.className === Utils.className(entityName));
+        const exists = this.#discovered.findIndex(m => m.class === entityName || m.className === Utils.className(entityName));
         if (exists !== -1) {
-            this.metadata.reset(this.discovered[exists].class);
-            this.discovered.splice(exists, 1);
+            this.#metadata.reset(this.#discovered[exists].class);
+            this.#discovered.splice(exists, 1);
         }
     }
     getSchema(entity) {
@@ -290,18 +301,19 @@ export class MetadataDiscovery {
         if (path) {
             const meta = Utils.copy(MetadataStorage.getMetadata(entity.name, path), false);
             meta.path = path;
-            this.metadata.set(entity, meta);
+            this.#metadata.set(entity, meta);
         }
-        const exists = this.metadata.has(entity);
-        const meta = this.metadata.get(entity, true);
+        const exists = this.#metadata.has(entity);
+        const meta = this.#metadata.get(entity, true);
         meta.abstract ??= !(exists && meta.name);
         const schema = EntitySchema.fromMetadata(meta);
         schema.setClass(entity);
         return schema;
     }
     getRootEntity(meta) {
-        const base = meta.extends && this.metadata.find(meta.extends);
-        if (!base || base === meta) { // make sure we do not fall into infinite loop
+        const base = meta.extends && this.#metadata.find(meta.extends);
+        if (!base || base === meta) {
+            // make sure we do not fall into infinite loop
             return meta;
         }
         const root = this.getRootEntity(base);
@@ -315,13 +327,13 @@ export class MetadataDiscovery {
     discoverEntity(schema) {
         const meta = schema.meta;
         const path = meta.path;
-        this.logger.log('discovery', `- processing entity ${colors.cyan(meta.className)}${colors.grey(path ? ` (${path})` : '')}`);
+        this.#logger.log('discovery', `- processing entity ${colors.cyan(meta.className)}${colors.grey(path ? ` (${path})` : '')}`);
         const root = this.getRootEntity(meta);
         schema.meta.path = meta.path;
-        const cache = this.metadataProvider.getCachedMetadata(meta, root);
+        const cache = this.#metadataProvider.getCachedMetadata(meta, root);
         if (cache) {
-            this.logger.log('discovery', `- using cached metadata for entity ${colors.cyan(meta.className)}`);
-            this.discovered.push(meta);
+            this.#logger.log('discovery', `- using cached metadata for entity ${colors.cyan(meta.className)}`);
+            this.#discovered.push(meta);
             return;
         }
         // infer default value from property initializer early, as the metadata provider might use some defaults, e.g. string for reflect-metadata
@@ -329,14 +341,14 @@ export class MetadataDiscovery {
             this.inferDefaultValue(meta, prop);
         }
         // if the definition is using EntitySchema we still want it to go through the metadata provider to validate no types are missing
-        this.metadataProvider.loadEntityMetadata(meta);
+        this.#metadataProvider.loadEntityMetadata(meta);
         if (!meta.tableName && meta.name) {
             const entityName = root.discriminatorColumn ? root.name : meta.name;
-            meta.tableName = this.namingStrategy.classToTableName(entityName);
+            meta.tableName = this.#namingStrategy.classToTableName(entityName);
         }
-        this.metadataProvider.saveToCache(meta);
+        this.#metadataProvider.saveToCache(meta);
         meta.root = root;
-        this.discovered.push(meta);
+        this.#discovered.push(meta);
     }
     initNullability(prop) {
         if (prop.kind === ReferenceKind.ONE_TO_ONE) {
@@ -361,7 +373,10 @@ export class MetadataDiscovery {
     initOwnColumns(meta) {
         meta.sync();
         for (const prop of meta.props) {
-            if (!prop.joinColumns || !prop.columnTypes || prop.ownColumns || ![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+            if (!prop.joinColumns ||
+                !prop.columnTypes ||
+                prop.ownColumns ||
+                ![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
                 continue;
             }
             // For polymorphic relations, ownColumns should include all fieldNames
@@ -398,7 +413,7 @@ export class MetadataDiscovery {
             return;
         }
         if (prop.kind === ReferenceKind.SCALAR || prop.kind === ReferenceKind.EMBEDDED) {
-            prop.fieldNames = [this.namingStrategy.propertyToColumnName(prop.name, object)];
+            prop.fieldNames = [this.#namingStrategy.propertyToColumnName(prop.name, object)];
         }
         else if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && !prop.polymorphic) {
             prop.fieldNames = this.initManyToOneFieldName(prop, prop.name);
@@ -413,19 +428,19 @@ export class MetadataDiscovery {
         for (const primaryKey of meta2.primaryKeys) {
             this.initFieldName(meta2.properties[primaryKey]);
             for (const fieldName of meta2.properties[primaryKey].fieldNames) {
-                ret.push(this.namingStrategy.joinKeyColumnName(name, fieldName, meta2.compositePK, tableName));
+                ret.push(this.#namingStrategy.joinKeyColumnName(name, fieldName, meta2.compositePK, tableName));
             }
         }
         return ret;
     }
     initManyToManyFieldName(prop, name) {
         const meta2 = prop.targetMeta;
-        return meta2.primaryKeys.map(() => this.namingStrategy.propertyToColumnName(name));
+        return meta2.primaryKeys.map(() => this.#namingStrategy.propertyToColumnName(name));
     }
     initManyToManyFields(meta, prop) {
         const meta2 = prop.targetMeta;
         Utils.defaultValue(prop, 'fixedOrder', !!prop.fixedOrderColumn);
-        const pivotMeta = this.metadata.find(prop.pivotEntity);
+        const pivotMeta = this.#metadata.find(prop.pivotEntity);
         const props = Object.values(pivotMeta?.properties ?? {});
         const pks = props.filter(p => p.primary);
         const fks = props.filter(p => p.kind === ReferenceKind.MANY_TO_ONE);
@@ -443,8 +458,8 @@ export class MetadataDiscovery {
             prop.joinColumns ??= first.fieldNames;
             prop.inverseJoinColumns ??= second.fieldNames;
         }
-        if (!prop.pivotTable && prop.owner && this.platform.usesPivotTable()) {
-            prop.pivotTable = this.namingStrategy.joinTableName(meta.className, meta2.tableName, prop.name, meta.tableName);
+        if (!prop.pivotTable && prop.owner && this.#platform.usesPivotTable()) {
+            prop.pivotTable = this.#namingStrategy.joinTableName(meta.className, meta2.tableName, prop.name, meta.tableName);
         }
         if (prop.mappedBy) {
             const prop2 = meta2.properties[prop.mappedBy];
@@ -463,22 +478,22 @@ export class MetadataDiscovery {
         prop.referencedColumnNames ??= Utils.flatten(meta.primaryKeys.map(primaryKey => meta.properties[primaryKey].fieldNames));
         // For polymorphic M:N, use discriminator base name for FK column (e.g., taggable_id instead of post_id)
         if (prop.polymorphic && prop.discriminator) {
-            prop.joinColumns ??= prop.referencedColumnNames.map(referencedColumnName => this.namingStrategy.joinKeyColumnName(prop.discriminator, referencedColumnName, prop.referencedColumnNames.length > 1));
+            prop.joinColumns ??= prop.referencedColumnNames.map(referencedColumnName => this.#namingStrategy.joinKeyColumnName(prop.discriminator, referencedColumnName, prop.referencedColumnNames.length > 1));
         }
         else {
             const ownerTableName = this.isExplicitTableName(meta.root) ? meta.root.tableName : undefined;
-            prop.joinColumns ??= prop.referencedColumnNames.map(referencedColumnName => this.namingStrategy.joinKeyColumnName(meta.root.className, referencedColumnName, meta.compositePK, ownerTableName));
+            prop.joinColumns ??= prop.referencedColumnNames.map(referencedColumnName => this.#namingStrategy.joinKeyColumnName(meta.root.className, referencedColumnName, meta.compositePK, ownerTableName));
         }
         const inverseTableName = this.isExplicitTableName(meta2.root) ? meta2.root.tableName : undefined;
         prop.inverseJoinColumns ??= this.initManyToOneFieldName(prop, meta2.root.className, inverseTableName);
     }
     isExplicitTableName(meta) {
-        return meta.tableName !== this.namingStrategy.classToTableName(meta.className);
+        return meta.tableName !== this.#namingStrategy.classToTableName(meta.className);
     }
     initManyToOneFields(prop) {
         if (prop.polymorphic && prop.polymorphTargets) {
             const fieldNames1 = prop.targetMeta.getPrimaryProps().flatMap(pk => pk.fieldNames);
-            const idColumns = fieldNames1.map(fieldName => this.namingStrategy.joinKeyColumnName(prop.discriminator, fieldName, fieldNames1.length > 1));
+            const idColumns = fieldNames1.map(fieldName => this.#namingStrategy.joinKeyColumnName(prop.discriminator, fieldName, fieldNames1.length > 1));
             prop.fieldNames ??= [prop.discriminatorColumn, ...idColumns];
             prop.joinColumns ??= idColumns;
             prop.referencedColumnNames ??= fieldNames1;
@@ -497,7 +512,7 @@ export class MetadataDiscovery {
         }
         Utils.defaultValue(prop, 'referencedTableName', meta2.tableName);
         if (!prop.joinColumns) {
-            prop.joinColumns = fieldNames.map(fieldName => this.namingStrategy.joinKeyColumnName(prop.name, fieldName, fieldNames.length > 1));
+            prop.joinColumns = fieldNames.map(fieldName => this.#namingStrategy.joinKeyColumnName(prop.name, fieldName, fieldNames.length > 1));
         }
         if (!prop.referencedColumnNames) {
             prop.referencedColumnNames = fieldNames;
@@ -516,7 +531,7 @@ export class MetadataDiscovery {
     initOneToManyFields(prop) {
         const meta2 = prop.targetMeta;
         if (!prop.joinColumns) {
-            prop.joinColumns = [this.namingStrategy.joinColumnName(prop.name)];
+            prop.joinColumns = [this.#namingStrategy.joinColumnName(prop.name)];
         }
         if (!prop.referencedColumnNames) {
             meta2.getPrimaryProps().forEach(pk => this.applyNamingStrategy(meta2, pk));
@@ -537,7 +552,7 @@ export class MetadataDiscovery {
             }
         }
         meta.forceConstructor ??= this.shouldForceConstructorUsage(meta);
-        this.validator.validateEntityDefinition(this.metadata, meta.class, this.config.get('discovery'));
+        this.#validator.validateEntityDefinition(this.#metadata, meta.class, this.#config.get('discovery'));
         for (const prop of Object.values(meta.properties)) {
             this.initNullability(prop);
             this.applyNamingStrategy(meta, prop);
@@ -549,12 +564,13 @@ export class MetadataDiscovery {
             this.initRelation(prop);
         }
         this.initOwnColumns(meta);
-        meta.simplePK = pks.length === 1 && pks[0].kind === ReferenceKind.SCALAR && !pks[0].customType && pks[0].runtimeType !== 'Date';
+        meta.simplePK =
+            pks.length === 1 && pks[0].kind === ReferenceKind.SCALAR && !pks[0].customType && pks[0].runtimeType !== 'Date';
         meta.serializedPrimaryKey ??= meta.props.find(prop => prop.serializedPrimaryKey)?.name;
         if (meta.serializedPrimaryKey && meta.serializedPrimaryKey !== meta.primaryKeys[0]) {
             meta.properties[meta.serializedPrimaryKey].persist ??= false;
         }
-        if (this.platform.usesPivotTable()) {
+        if (this.#platform.usesPivotTable()) {
             return Object.values(meta.properties)
                 .filter(prop => prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && prop.pivotTable)
                 .map(prop => {
@@ -581,7 +597,7 @@ export class MetadataDiscovery {
         ['mappedBy', 'inversedBy', 'pivotEntity'].forEach(type => {
             const value = prop[type];
             if (value instanceof Function) {
-                const meta2 = prop.targetMeta ?? this.metadata.get(prop.target);
+                const meta2 = prop.targetMeta ?? this.#metadata.get(prop.target);
                 prop[type] = value(meta2.properties)?.name;
                 if (type === 'pivotEntity' && value) {
                     prop[type] = value(meta2.properties);
@@ -618,8 +634,8 @@ export class MetadataDiscovery {
     }
     definePivotTableEntity(meta, prop) {
         const pivotMeta = prop.pivotEntity
-            ? this.metadata.find(prop.pivotEntity)
-            : this.metadata.getByClassName(prop.pivotTable, false);
+            ? this.#metadata.find(prop.pivotEntity)
+            : this.#metadata.getByClassName(prop.pivotTable, false);
         // ensure inverse side exists so we can join it when populating via pivot tables
         if (!prop.inversedBy && prop.targetMeta) {
             const inverseName = `${meta.className}_${prop.name}__inverse`;
@@ -681,18 +697,19 @@ export class MetadataDiscovery {
             pivotMeta2.compositePK = true;
         }
         // handle self-referenced m:n with same default field names
-        if (meta.className === targetType && prop.joinColumns.every((joinColumn, idx) => joinColumn === prop.inverseJoinColumns[idx])) {
+        if (meta.className === targetType &&
+            prop.joinColumns.every((joinColumn, idx) => joinColumn === prop.inverseJoinColumns[idx])) {
             // use tableName only when explicitly provided by user, otherwise use className for backwards compatibility
             const baseName = this.isExplicitTableName(meta) ? meta.tableName : meta.className;
-            prop.joinColumns = prop.referencedColumnNames.map(name => this.namingStrategy.joinKeyColumnName(baseName + '_1', name, meta.compositePK));
-            prop.inverseJoinColumns = prop.referencedColumnNames.map(name => this.namingStrategy.joinKeyColumnName(baseName + '_2', name, meta.compositePK));
+            prop.joinColumns = prop.referencedColumnNames.map(name => this.#namingStrategy.joinKeyColumnName(baseName + '_1', name, meta.compositePK));
+            prop.inverseJoinColumns = prop.referencedColumnNames.map(name => this.#namingStrategy.joinKeyColumnName(baseName + '_2', name, meta.compositePK));
             if (prop.inversedBy) {
                 const prop2 = targetMeta.properties[prop.inversedBy];
                 prop2.inverseJoinColumns = prop.joinColumns;
                 prop2.joinColumns = prop.inverseJoinColumns;
             }
             // propagate updated joinColumns to all child entities that inherit this property (STI)
-            for (const childMeta of this.discovered.filter(m => m.root === meta && m !== meta)) {
+            for (const childMeta of this.#discovered.filter(m => m.root === meta && m !== meta)) {
                 const childProp = childMeta.properties[prop.name];
                 if (childProp) {
                     childProp.joinColumns = prop.joinColumns;
@@ -708,7 +725,7 @@ export class MetadataDiscovery {
             pivotMeta2.properties[meta.name + '_owner'] = this.definePivotProperty(prop, meta.name + '_owner', meta.class, targetType + '_inverse', true, meta.className === targetType);
             pivotMeta2.properties[targetType + '_inverse'] = this.definePivotProperty(prop, targetType + '_inverse', targetMeta.class, meta.name + '_owner', false, meta.className === targetType);
         }
-        return this.metadata.set(pivotMeta2.class, EntitySchema.fromMetadata(pivotMeta2).init().meta);
+        return this.#metadata.set(pivotMeta2.class, EntitySchema.fromMetadata(pivotMeta2).init().meta);
     }
     /**
      * Create a scalar property for a pivot table column.
@@ -764,14 +781,16 @@ export class MetadataDiscovery {
             pivotMeta.properties[primaryProp.name] = primaryProp;
             pivotMeta.compositePK = false;
         }
-        const discriminatorProp = this.createPivotScalarProperty(discriminatorColumn, [this.platform.getVarcharTypeDeclarationSQL(prop)], [discriminatorColumn], { type: 'string', primary: !isCompositePK, nullable: false });
+        const discriminatorProp = this.createPivotScalarProperty(discriminatorColumn, [this.#platform.getVarcharTypeDeclarationSQL(prop)], [discriminatorColumn], { type: 'string', primary: !isCompositePK, nullable: false });
         this.initFieldName(discriminatorProp);
         pivotMeta.properties[discriminatorColumn] = discriminatorProp;
         const columnTypes = this.getPrimaryKeyColumnTypes(meta);
         if (isCompositePK) {
             // Create separate properties for each PK column (nullable for other entity types)
             for (let i = 0; i < prop.joinColumns.length; i++) {
-                pivotMeta.properties[prop.joinColumns[i]] = this.createPivotScalarProperty(prop.joinColumns[i], [columnTypes[i]]);
+                pivotMeta.properties[prop.joinColumns[i]] = this.createPivotScalarProperty(prop.joinColumns[i], [
+                    columnTypes[i],
+                ]);
             }
             // Virtual property combining all columns (for compatibility)
             pivotMeta.properties[prop.discriminator] = this.createPivotScalarProperty(prop.discriminator, columnTypes, [...prop.joinColumns], { type: meta.className, persist: false });
@@ -815,21 +834,22 @@ export class MetadataDiscovery {
             ret.precision = pkProp.precision;
             ret.scale = pkProp.scale;
         }
-        const schema = targetMeta.schema ?? this.config.get('schema') ?? this.platform.getDefaultSchemaName();
+        const schema = targetMeta.schema ?? this.#config.get('schema') ?? this.#platform.getDefaultSchemaName();
         ret.referencedTableName = schema && schema !== '*' ? schema + '.' + targetMeta.tableName : targetMeta.tableName;
         this.initColumnType(ret);
         this.initRelation(ret);
         return ret;
     }
     defineFixedOrderProperty(prop, targetMeta) {
-        const pk = prop.fixedOrderColumn || this.namingStrategy.referenceColumnName();
+        const pk = prop.fixedOrderColumn || this.#namingStrategy.referenceColumnName();
         const primaryProp = {
             name: pk,
             type: 'number',
+            runtimeType: 'number',
             kind: ReferenceKind.SCALAR,
             primary: true,
             autoincrement: true,
-            unsigned: this.platform.supportsUnsigned(),
+            unsigned: this.#platform.supportsUnsigned(),
         };
         this.initFieldName(primaryProp);
         this.initColumnType(primaryProp);
@@ -850,21 +870,21 @@ export class MetadataDiscovery {
             cascade: [Cascade.ALL],
             fixedOrder: prop.fixedOrder,
             fixedOrderColumn: prop.fixedOrderColumn,
-            index: this.platform.indexForeignKeys(),
+            index: this.#platform.indexForeignKeys(),
             primary: !prop.fixedOrder,
             autoincrement: false,
             updateRule: prop.updateRule,
             deleteRule: prop.deleteRule,
             createForeignKeyConstraint: prop.createForeignKeyConstraint,
         };
-        const defaultRule = selfReferencing && !this.platform.supportsMultipleCascadePaths() ? 'no action' : 'cascade';
+        const defaultRule = selfReferencing && !this.#platform.supportsMultipleCascadePaths() ? 'no action' : 'cascade';
         ret.updateRule ??= defaultRule;
         ret.deleteRule ??= defaultRule;
-        const meta = this.metadata.get(type);
+        const meta = this.#metadata.get(type);
         ret.targetMeta = meta;
         ret.joinColumns = [];
         ret.inverseJoinColumns = [];
-        const schema = meta.schema ?? this.config.get('schema') ?? this.platform.getDefaultSchemaName();
+        const schema = meta.schema ?? this.#config.get('schema') ?? this.#platform.getDefaultSchemaName();
         ret.referencedTableName = schema && schema !== '*' ? schema + '.' + meta.tableName : meta.tableName;
         if (owner) {
             ret.owner = true;
@@ -910,8 +930,9 @@ export class MetadataDiscovery {
         });
     }
     defineBaseEntityProperties(meta) {
-        const base = meta.extends && this.metadata.get(meta.extends);
-        if (!base || base === meta) { // make sure we do not fall into infinite loop
+        const base = meta.extends && this.#metadata.get(meta.extends);
+        if (!base || base === meta) {
+            // make sure we do not fall into infinite loop
             return 0;
         }
         let order = this.defineBaseEntityProperties(base);
@@ -923,10 +944,12 @@ export class MetadataDiscovery {
                 meta.properties[prop.name] = prop;
             }
         });
-        ownProps.forEach(prop => meta.properties[prop.name] = prop);
+        ownProps.forEach(prop => (meta.properties[prop.name] = prop));
         meta.filters = { ...base.filters, ...meta.filters };
         if (!meta.discriminatorValue) {
-            Object.values(base.properties).filter(prop => !old.includes(prop.name)).forEach(prop => {
+            Object.values(base.properties)
+                .filter(prop => !old.includes(prop.name))
+                .forEach(prop => {
                 meta.properties[prop.name] = { ...prop };
                 meta.propertyOrder.set(prop.name, (order += 0.01));
             });
@@ -934,7 +957,9 @@ export class MetadataDiscovery {
         meta.indexes = Utils.unique([...base.indexes, ...meta.indexes]);
         meta.uniques = Utils.unique([...base.uniques, ...meta.uniques]);
         meta.checks = Utils.unique([...base.checks, ...meta.checks]);
-        const pks = Object.values(meta.properties).filter(p => p.primary).map(p => p.name);
+        const pks = Object.values(meta.properties)
+            .filter(p => p.primary)
+            .map(p => p.name);
         if (pks.length > 0 && meta.primaryKeys.length === 0) {
             meta.primaryKeys = pks;
         }
@@ -952,8 +977,8 @@ export class MetadataDiscovery {
         }
         visited.add(embeddedProp);
         const types = embeddedProp.type.split(/ ?\| ?/);
-        let embeddable = this.discovered.find(m => m.name === embeddedProp.type);
-        const polymorphs = this.discovered.filter(m => types.includes(m.name));
+        let embeddable = this.#discovered.find(m => m.name === embeddedProp.type);
+        const polymorphs = this.#discovered.filter(m => types.includes(m.name));
         // create virtual polymorphic entity
         if (!embeddable && polymorphs.length > 0) {
             const properties = {};
@@ -965,13 +990,17 @@ export class MetadataDiscovery {
                     if (properties[prop.name] && properties[prop.name].type !== prop.type) {
                         properties[prop.name].type = `${properties[prop.name].type} | ${prop.type}`;
                         properties[prop.name].runtimeType = 'any';
+                        properties[prop.name].stiMerged = true;
                         return properties[prop.name];
                     }
-                    return properties[prop.name] = prop;
+                    // Deep copy to prevent mutating the original entity's property —
+                    // both from the merge path above (GH #6522/#6523) and from
+                    // downstream code that mutates nested arrays like fieldNames.
+                    return (properties[prop.name] = Utils.copy(prop));
                 });
             };
             const processExtensions = (meta) => {
-                const parent = this.discovered.find(m => {
+                const parent = this.#discovered.find(m => {
                     return meta.extends && Utils.className(meta.extends) === m.className;
                 });
                 if (!parent) {
@@ -985,7 +1014,10 @@ export class MetadataDiscovery {
                 inlineProperties(meta);
                 processExtensions(meta);
             });
-            const name = polymorphs.map(t => t.className).sort().join(' | ');
+            const name = polymorphs
+                .map(t => t.className)
+                .sort()
+                .join(' | ');
             embeddable = new EntityMetadata({
                 name,
                 className: name,
@@ -997,7 +1029,7 @@ export class MetadataDiscovery {
             });
             embeddable.sync();
             discovered.push(embeddable);
-            polymorphs.forEach(meta => meta.root = embeddable);
+            polymorphs.forEach(meta => (meta.root = embeddable));
         }
     }
     initPolymorphicRelation(meta, prop, discovered) {
@@ -1006,7 +1038,7 @@ export class MetadataDiscovery {
         }
         prop.polymorphic = true;
         prop.discriminator ??= prop.name;
-        prop.discriminatorColumn ??= this.namingStrategy.discriminatorColumnName(prop.discriminator);
+        prop.discriminatorColumn ??= this.#namingStrategy.discriminatorColumnName(prop.discriminator);
         prop.createForeignKeyConstraint = false;
         const isToOne = [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind);
         if (isToOne) {
@@ -1018,7 +1050,7 @@ export class MetadataDiscovery {
         if (prop.discriminatorMap) {
             const normalizedMap = {};
             for (const [key, value] of Object.entries(prop.discriminatorMap)) {
-                const targetMeta = this.metadata.getByClassName(value, false);
+                const targetMeta = this.#metadata.getByClassName(value, false);
                 if (!targetMeta) {
                     throw MetadataError.fromUnknownEntity(value, `${meta.className}.${prop.name} discriminatorMap`);
                 }
@@ -1053,7 +1085,7 @@ export class MetadataDiscovery {
             return;
         }
         visited.add(embeddedProp);
-        const embeddable = this.discovered.find(m => m.name === embeddedProp.type);
+        const embeddable = this.#discovered.find(m => m.name === embeddedProp.type);
         if (!embeddable) {
             throw MetadataError.fromUnknownEntity(embeddedProp.type, `${meta.className}.${embeddedProp.name}`);
         }
@@ -1125,7 +1157,7 @@ export class MetadataDiscovery {
                 meta.properties[name].fieldNames = prop.fieldNames;
                 meta.properties[name].embeddedPath = path;
                 const targetProp = prop.targetMeta?.getPrimaryProp() ?? prop;
-                const fieldName = raw(this.platform.getSearchJsonPropertySQL(path.join('->'), targetProp.runtimeType ?? targetProp.type, true));
+                const fieldName = raw(this.#platform.getSearchJsonPropertySQL(path.join('->'), targetProp.runtimeType ?? targetProp.type, true));
                 meta.properties[name].fieldNameRaw = fieldName.sql; // for querying in SQL drivers
                 meta.properties[name].persist = false; // only virtual as we store the whole object
                 meta.properties[name].userDefined = false; // mark this as a generated/internal property, so we can distinguish from user-defined non-persist properties
@@ -1167,7 +1199,7 @@ export class MetadataDiscovery {
             const map = meta.root.discriminatorMap;
             Object.keys(map)
                 .filter(key => typeof map[key] === 'string')
-                .forEach(key => map[key] = this.metadata.getByClassName(map[key]).class);
+                .forEach(key => (map[key] = this.#metadata.getByClassName(map[key]).class));
         }
         else {
             meta.root.discriminatorMap = {};
@@ -1175,7 +1207,7 @@ export class MetadataDiscovery {
                 .filter(m => m.root.class === meta.root.class && !m.abstract)
                 .sort((a, b) => a.className.localeCompare(b.className));
             for (const m of children) {
-                const name = m.discriminatorValue ?? this.namingStrategy.classToTableName(m.className);
+                const name = m.discriminatorValue ?? this.#namingStrategy.classToTableName(m.className);
                 meta.root.discriminatorMap[name] = m.class;
             }
         }
@@ -1191,7 +1223,14 @@ export class MetadataDiscovery {
         Object.values(meta.properties).forEach(prop => {
             const newProp = { ...prop };
             const rootProp = meta.root.properties[prop.name];
-            if (rootProp && (rootProp.type !== prop.type || (rootProp.fieldNames && prop.fieldNames && !compareArrays(rootProp.fieldNames, prop.fieldNames)))) {
+            // stiMerged is set during inlineProperties when a property was merged
+            // from multiple polymorphic variants with different types. The flag is
+            // cleared implicitly when the first child claims the root property via
+            // addProperty below, so subsequent children correctly trigger renaming.
+            const typesMatch = rootProp?.type === prop.type || rootProp?.stiMerged === true;
+            if (rootProp &&
+                (!typesMatch ||
+                    (rootProp.fieldNames && prop.fieldNames && !compareArrays(rootProp.fieldNames, prop.fieldNames)))) {
                 const name = newProp.name;
                 this.initFieldName(newProp, newProp.object);
                 newProp.renamedFrom = name;
@@ -1205,8 +1244,9 @@ export class MetadataDiscovery {
                     rootProp.stiFieldNameMap = {};
                     // Find which discriminator owns the original fieldNames
                     for (const [discValue, childClass] of Object.entries(meta.root.discriminatorMap)) {
-                        const childMeta = this.metadata.find(childClass);
-                        if (childMeta?.properties[prop.name]?.fieldNames && compareArrays(childMeta.properties[prop.name].fieldNames, rootProp.fieldNames)) {
+                        const childMeta = this.#metadata.find(childClass);
+                        if (childMeta?.properties[prop.name]?.fieldNames &&
+                            compareArrays(childMeta.properties[prop.name].fieldNames, rootProp.fieldNames)) {
                             rootProp.stiFieldNameMap[discValue] = rootProp.fieldNames[0];
                             break;
                         }
@@ -1272,11 +1312,11 @@ export class MetadataDiscovery {
         if (meta.tptChildren) {
             meta.tptChildren = meta.tptChildren.map(child => metadata.find(m => m.class === child.class) ?? child);
         }
-        const registryMeta = this.metadata.get(meta.class);
+        const registryMeta = this.#metadata.get(meta.class);
         if (registryMeta && registryMeta !== meta) {
             registryMeta.inheritanceType = meta.inheritanceType;
-            registryMeta.tptParent = meta.tptParent ? this.metadata.get(meta.tptParent.class) : undefined;
-            registryMeta.tptChildren = meta.tptChildren?.map(child => this.metadata.get(child.class));
+            registryMeta.tptParent = meta.tptParent ? this.#metadata.get(meta.tptParent.class) : undefined;
+            registryMeta.tptChildren = meta.tptChildren?.map(child => this.#metadata.get(child.class));
         }
         this.initTPTDiscriminator(meta, metadata);
     }
@@ -1294,12 +1334,12 @@ export class MetadataDiscovery {
         }
         meta.root.discriminatorMap = {};
         for (const m of allDescendants) {
-            const name = this.namingStrategy.classToTableName(m.className);
+            const name = this.#namingStrategy.classToTableName(m.className);
             meta.root.discriminatorMap[name] = m.class;
             m.discriminatorValue = name;
         }
         if (!meta.abstract) {
-            const name = this.namingStrategy.classToTableName(meta.className);
+            const name = this.#namingStrategy.classToTableName(meta.className);
             meta.root.discriminatorMap[name] = meta.class;
             meta.discriminatorValue = name;
         }
@@ -1412,7 +1452,7 @@ export class MetadataDiscovery {
     }
     initAutoincrement(meta) {
         const pks = meta.getPrimaryProps();
-        if (pks.length === 1 && this.platform.isNumericProperty(pks[0])) {
+        if (pks.length === 1 && this.#platform.isNumericProperty(pks[0])) {
             /* v8 ignore next */
             pks[0].autoincrement ??= true;
         }
@@ -1431,19 +1471,22 @@ export class MetadataDiscovery {
         const table = this.createSchemaTable(meta);
         for (const check of meta.checks) {
             const fieldNames = check.property ? meta.properties[check.property].fieldNames : [];
-            check.name ??= this.namingStrategy.indexName(meta.tableName, fieldNames, 'check');
+            check.name ??= this.#namingStrategy.indexName(meta.tableName, fieldNames, 'check');
             if (check.expression instanceof Function) {
                 check.expression = check.expression(columns, table);
             }
         }
-        if (this.platform.usesEnumCheckConstraints() && !meta.embeddable) {
+        if (this.#platform.usesEnumCheckConstraints() && !meta.embeddable) {
             for (const prop of meta.props) {
-                if (prop.enum && !prop.nativeEnumName && prop.items?.every(item => typeof item === 'string')) {
+                if (prop.enum &&
+                    prop.persist !== false &&
+                    !prop.nativeEnumName &&
+                    prop.items?.every(item => typeof item === 'string')) {
                     this.initFieldName(prop);
                     meta.checks.push({
-                        name: this.namingStrategy.indexName(meta.tableName, prop.fieldNames, 'check'),
+                        name: this.#namingStrategy.indexName(meta.tableName, prop.fieldNames, 'check'),
                         property: prop.name,
-                        expression: `${this.platform.quoteIdentifier(prop.fieldNames[0])} in ('${prop.items.join("', '")}')`,
+                        expression: `${this.#platform.quoteIdentifier(prop.fieldNames[0])} in ('${prop.items.join("', '")}')`,
                     });
                 }
             }
@@ -1451,13 +1494,13 @@ export class MetadataDiscovery {
     }
     initGeneratedColumn(meta, prop) {
         if (!prop.generated && prop.columnTypes) {
-            const match = prop.columnTypes[0]?.match(/(.*) generated always as (.*)/i);
+            const match = /(.*) generated always as (.*)/i.exec(prop.columnTypes[0]);
             if (match) {
                 prop.columnTypes[0] = match[1];
                 prop.generated = match[2];
                 return;
             }
-            const match2 = prop.columnTypes[0]?.trim().match(/^as (.*)/i);
+            const match2 = /^as (.*)/i.exec(prop.columnTypes[0]?.trim());
             if (match2) {
                 prop.generated = match2[1];
             }
@@ -1474,13 +1517,13 @@ export class MetadataDiscovery {
         }
         /* v8 ignore next */
         if (prop.default != null) {
-            return '' + this.platform.convertVersionValue(prop.default, prop);
+            return '' + this.#platform.convertVersionValue(prop.default, prop);
         }
         this.initCustomType(meta, prop, true);
         const type = prop.customType?.runtimeType ?? prop.runtimeType ?? prop.type;
         if (type === 'Date') {
-            prop.length ??= this.platform.getDefaultVersionLength();
-            return this.platform.getCurrentTimestampSQL(prop.length);
+            prop.length ??= this.#platform.getDefaultVersionLength();
+            return this.#platform.getCurrentTimestampSQL(prop.length);
         }
         return '1';
     }
@@ -1491,7 +1534,11 @@ export class MetadataDiscovery {
             const entity1 = new meta.class();
             const entity2 = new meta.class();
             // we compare the two values by reference, this will discard things like `new Date()` or `Date.now()`
-            if (this.config.get('discovery').inferDefaultValues && prop.default === undefined && entity1[prop.name] != null && entity1[prop.name] === entity2[prop.name] && entity1[prop.name] !== now) {
+            if (this.#config.get('discovery').inferDefaultValues &&
+                prop.default === undefined &&
+                entity1[prop.name] != null &&
+                entity1[prop.name] === entity2[prop.name] &&
+                entity1[prop.name] !== now) {
                 prop.default ??= entity1[prop.name];
             }
             // if the default value is null, infer nullability
@@ -1514,11 +1561,11 @@ export class MetadataDiscovery {
         let val = prop.default;
         const raw = Raw.getKnownFragment(val);
         if (raw) {
-            prop.defaultRaw = this.platform.formatQuery(raw.sql, raw.params);
+            prop.defaultRaw = this.#platform.formatQuery(raw.sql, raw.params);
             return;
         }
         if (Array.isArray(prop.default) && prop.customType) {
-            val = prop.customType.convertToDatabaseValue(prop.default, this.platform);
+            val = prop.customType.convertToDatabaseValue(prop.default, this.#platform);
         }
         prop.defaultRaw = typeof val === 'string' ? `'${val}'` : '' + val;
     }
@@ -1558,7 +1605,9 @@ export class MetadataDiscovery {
             prop.type = prop.customType.constructor.name;
         }
         // `prop.type` might also be custom type class (not instance), so `typeof MyType` will give us `function`, not `object`
-        if (typeof prop.type === 'function' && Type.isMappedType(prop.type.prototype) && !prop.customType) {
+        if (typeof prop.type === 'function' &&
+            Type.isMappedType(prop.type.prototype) &&
+            !prop.customType) {
             // if the type is an ORM defined mapped type without `ensureComparable: true`,
             // we use just the type name, to have more performant hydration code
             const type = Utils.keys(t).find(type => {
@@ -1578,7 +1627,10 @@ export class MetadataDiscovery {
         if (!prop.customType && ['json', 'jsonb'].includes(prop.type?.toLowerCase())) {
             prop.customType = new t.json();
         }
-        if (prop.kind === ReferenceKind.SCALAR && !prop.customType && prop.columnTypes && ['json', 'jsonb'].includes(prop.columnTypes[0])) {
+        if (prop.kind === ReferenceKind.SCALAR &&
+            !prop.customType &&
+            prop.columnTypes &&
+            ['json', 'jsonb'].includes(prop.columnTypes[0])) {
             prop.customType = new t.json();
         }
         if (prop.kind === ReferenceKind.EMBEDDED && !prop.customType && (prop.object || prop.array)) {
@@ -1609,10 +1661,12 @@ export class MetadataDiscovery {
         if (prop.fieldNames?.length === 1 && !prop.customType) {
             [t.bigint, t.double, t.decimal, t.interval, t.date]
                 .filter(type => mappedType instanceof type)
-                .forEach((type) => prop.customType = new type());
+                .forEach((type) => (prop.customType = new type()));
         }
         if (prop.customType && !prop.columnTypes) {
-            const mappedType = this.getMappedType({ columnTypes: [prop.customType.getColumnType(prop, this.platform)] });
+            const mappedType = this.getMappedType({
+                columnTypes: [prop.customType.getColumnType(prop, this.#platform)],
+            });
             if (prop.customType.compareAsType() === 'any' && ![t.json].some(t => prop.customType instanceof t)) {
                 prop.runtimeType ??= mappedType.runtimeType;
             }
@@ -1627,27 +1681,37 @@ export class MetadataDiscovery {
             prop.runtimeType ??= mappedType.runtimeType;
         }
         if (prop.customType) {
-            prop.customType.platform = this.platform;
+            prop.customType.platform = this.#platform;
             prop.customType.meta = meta;
             prop.customType.prop = prop;
-            prop.columnTypes ??= [prop.customType.getColumnType(prop, this.platform)];
-            prop.hasConvertToJSValueSQL = !!prop.customType.convertToJSValueSQL && prop.customType.convertToJSValueSQL('', this.platform) !== '';
-            prop.hasConvertToDatabaseValueSQL = !!prop.customType.convertToDatabaseValueSQL && prop.customType.convertToDatabaseValueSQL('', this.platform) !== '';
-            if (prop.customType instanceof t.bigint && ['string', 'bigint', 'number'].includes(prop.runtimeType.toLowerCase())) {
+            prop.columnTypes ??= [prop.customType.getColumnType(prop, this.#platform)];
+            prop.hasConvertToJSValueSQL =
+                !!prop.customType.convertToJSValueSQL && prop.customType.convertToJSValueSQL('', this.#platform) !== '';
+            prop.hasConvertToDatabaseValueSQL =
+                !!prop.customType.convertToDatabaseValueSQL &&
+                    prop.customType.convertToDatabaseValueSQL('', this.#platform) !== '';
+            if (prop.customType instanceof t.bigint &&
+                ['string', 'bigint', 'number'].includes(prop.runtimeType.toLowerCase())) {
                 prop.customType.mode = prop.runtimeType.toLowerCase();
             }
         }
         if (Type.isMappedType(prop.customType) && prop.kind === ReferenceKind.SCALAR && !isArray) {
             prop.type = prop.customType.name;
         }
-        if (!prop.customType && [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind) && !prop.polymorphic && prop.targetMeta.compositePK) {
+        if (!prop.customType &&
+            [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind) &&
+            !prop.polymorphic &&
+            prop.targetMeta.compositePK) {
             prop.customTypes = [];
             for (const pk of prop.targetMeta.getPrimaryProps()) {
                 if (pk.customType) {
                     prop.customTypes.push(pk.customType);
-                    prop.hasConvertToJSValueSQL ||= !!pk.customType.convertToJSValueSQL && pk.customType.convertToJSValueSQL('', this.platform) !== '';
+                    prop.hasConvertToJSValueSQL ||=
+                        !!pk.customType.convertToJSValueSQL && pk.customType.convertToJSValueSQL('', this.#platform) !== '';
                     /* v8 ignore next */
-                    prop.hasConvertToDatabaseValueSQL ||= !!pk.customType.convertToDatabaseValueSQL && pk.customType.convertToDatabaseValueSQL('', this.platform) !== '';
+                    prop.hasConvertToDatabaseValueSQL ||=
+                        !!pk.customType.convertToDatabaseValueSQL &&
+                            pk.customType.convertToDatabaseValueSQL('', this.#platform) !== '';
                 }
                 else {
                     prop.customTypes.push(undefined);
@@ -1655,11 +1719,15 @@ export class MetadataDiscovery {
             }
         }
         if (prop.kind === ReferenceKind.SCALAR && !(mappedType instanceof t.unknown)) {
-            if (!prop.columnTypes && prop.nativeEnumName && meta.schema !== this.platform.getDefaultSchemaName() && meta.schema && !prop.nativeEnumName.includes('.')) {
+            if (!prop.columnTypes &&
+                prop.nativeEnumName &&
+                meta.schema !== this.#platform.getDefaultSchemaName() &&
+                meta.schema &&
+                !prop.nativeEnumName.includes('.')) {
                 prop.columnTypes = [`${meta.schema}.${prop.nativeEnumName}`];
             }
             else {
-                prop.columnTypes ??= [mappedType.getColumnType(prop, this.platform)];
+                prop.columnTypes ??= [mappedType.getColumnType(prop, this.#platform)];
             }
             // use only custom types provided by user, we don't need to use the ones provided by ORM,
             // with exception for ArrayType and JsonType, those two are handled in
@@ -1673,7 +1741,7 @@ export class MetadataDiscovery {
             return;
         }
         // when the target is a polymorphic embedded entity, `prop.target` is an array of classes, we need to get the metadata by the type name instead
-        const meta2 = this.metadata.find(prop.target) ?? this.metadata.getByClassName(prop.type);
+        const meta2 = this.#metadata.find(prop.target) ?? this.#metadata.getByClassName(prop.type);
         // If targetKey is specified, use that property instead of PKs for referencedPKs
         prop.referencedPKs = prop.targetKey ? [prop.targetKey] : meta2.primaryKeys;
         prop.targetMeta = meta2;
@@ -1682,10 +1750,13 @@ export class MetadataDiscovery {
         }
         // Auto-generate formula for persist: false relations, but only for single-column FKs
         // Composite FK relations need standard JOIN conditions, not formula-based
-        if (!prop.formula && prop.persist === false && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && !prop.embedded) {
+        if (!prop.formula &&
+            prop.persist === false &&
+            [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) &&
+            !prop.embedded) {
             this.initFieldName(prop);
             if (prop.fieldNames?.length === 1) {
-                prop.formula = table => `${table}.${this.platform.quoteIdentifier(prop.fieldNames[0])}`;
+                prop.formula = table => `${table}.${this.#platform.quoteIdentifier(prop.fieldNames[0])}`;
             }
         }
     }
@@ -1693,7 +1764,9 @@ export class MetadataDiscovery {
         this.initUnsigned(prop);
         // Get the target properties for FK relations - use targetKey property if specified, otherwise PKs
         const targetProps = prop.targetMeta
-            ? (prop.targetKey ? [prop.targetMeta.properties[prop.targetKey]] : prop.targetMeta.getPrimaryProps())
+            ? prop.targetKey
+                ? [prop.targetMeta.properties[prop.targetKey]]
+                : prop.targetMeta.getPrimaryProps()
             : [];
         targetProps.map(targetProp => {
             prop.length ??= targetProp.length;
@@ -1705,38 +1778,36 @@ export class MetadataDiscovery {
             const mappedType = this.getMappedType(prop);
             prop.type = mappedType.compareAsType();
         }
-        if (prop.columnTypes || !this.schemaHelper) {
+        if (prop.columnTypes || !this.#schemaHelper) {
             return;
         }
         if (prop.kind === ReferenceKind.SCALAR) {
             const mappedType = this.getMappedType(prop);
             const SCALAR_TYPES = ['string', 'number', 'boolean', 'bigint', 'Date', 'Buffer', 'RegExp', 'any', 'unknown'];
-            if (mappedType instanceof t.unknown
+            if (mappedType instanceof t.unknown &&
                 // it could be a runtime type from reflect-metadata
-                && !SCALAR_TYPES.includes(prop.type)
+                !SCALAR_TYPES.includes(prop.type) &&
                 // or it might be inferred via ts-morph to some generic type alias
-                && !prop.type.match(/[<>:"';{}]/)) {
+                !/[<>:"';{}]/.exec(prop.type)) {
                 const type = prop.length != null && !prop.type.endsWith(`(${prop.length})`) ? `${prop.type}(${prop.length})` : prop.type;
                 prop.columnTypes = [type];
             }
             else {
-                prop.columnTypes = [mappedType.getColumnType(prop, this.platform)];
+                prop.columnTypes = [mappedType.getColumnType(prop, this.#platform)];
             }
             return;
         }
         /* v8 ignore next */
         if (prop.kind === ReferenceKind.EMBEDDED && prop.object) {
-            prop.columnTypes = [this.platform.getJsonDeclarationSQL()];
+            prop.columnTypes = [this.#platform.getJsonDeclarationSQL()];
             return;
         }
         const targetMeta = prop.targetMeta;
         prop.columnTypes = [];
         // Use targetKey property if specified, otherwise use primary key properties
-        const referencedProps = prop.targetKey
-            ? [targetMeta.properties[prop.targetKey]]
-            : targetMeta.getPrimaryProps();
+        const referencedProps = prop.targetKey ? [targetMeta.properties[prop.targetKey]] : targetMeta.getPrimaryProps();
         if (prop.polymorphic && prop.polymorphTargets) {
-            prop.columnTypes.push(this.platform.getVarcharTypeDeclarationSQL(prop));
+            prop.columnTypes.push(this.#platform.getVarcharTypeDeclarationSQL(prop));
         }
         for (const referencedProp of referencedProps) {
             this.initCustomType(targetMeta, referencedProp);
@@ -1744,7 +1815,7 @@ export class MetadataDiscovery {
             const mappedType = this.getMappedType(referencedProp);
             let columnTypes = referencedProp.columnTypes;
             if (referencedProp.autoincrement) {
-                columnTypes = [mappedType.getColumnType({ ...referencedProp, autoincrement: false }, this.platform)];
+                columnTypes = [mappedType.getColumnType({ ...referencedProp, autoincrement: false }, this.#platform)];
             }
             prop.columnTypes.push(...columnTypes);
             if (!targetMeta.compositePK || prop.targetKey) {
@@ -1767,7 +1838,7 @@ export class MetadataDiscovery {
         if (t === 'Date') {
             t = 'datetime';
         }
-        return this.platform.getMappedType(t);
+        return this.#platform.getMappedType(t);
     }
     getPrefix(prop, parent) {
         const { embeddedPath = [], fieldNames, prefix = true, prefixMode } = prop;
@@ -1778,7 +1849,7 @@ export class MetadataDiscovery {
         if (prefix === false) {
             return prefixParent;
         }
-        const mode = prefixMode ?? this.config.get('embeddables').prefixMode;
+        const mode = prefixMode ?? this.#config.get('embeddables').prefixMode;
         return mode === 'absolute' ? prefix : prefixParent + prefix;
     }
     initUnsigned(prop) {
@@ -1792,16 +1863,17 @@ export class MetadataDiscovery {
             });
             return;
         }
-        prop.unsigned ??= (prop.primary || prop.unsigned) && this.platform.isNumericProperty(prop) && this.platform.supportsUnsigned();
+        prop.unsigned ??=
+            (prop.primary || prop.unsigned) && this.#platform.isNumericProperty(prop) && this.#platform.supportsUnsigned();
     }
     initIndexes(meta, prop) {
         const hasIndex = meta.indexes.some(idx => idx.properties?.length === 1 && idx.properties[0] === prop.name);
-        if (prop.kind === ReferenceKind.MANY_TO_ONE && this.platform.indexForeignKeys() && !hasIndex) {
+        if (prop.kind === ReferenceKind.MANY_TO_ONE && this.#platform.indexForeignKeys() && !hasIndex) {
             prop.index ??= true;
         }
     }
     shouldForceConstructorUsage(meta) {
-        const forceConstructor = this.config.get('forceEntityConstructor');
+        const forceConstructor = this.#config.get('forceEntityConstructor');
         if (Array.isArray(forceConstructor)) {
             return forceConstructor.some(cls => Utils.className(cls) === meta.className);
         }