@mikro-orm/core 7.0.0-rc.3 → 7.0.1-dev.0

package/metadata/MetadataDiscovery.js

@@ -12,72 +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
+        const suffix = this.#metadataProvider.constructor === MetadataProvider
             ? ''
-            : `, using ${colors.cyan(this.metadataProvider.constructor.name)}`;
-        this.logger.log('discovery', `ORM entity discovery started${suffix}`);
+            : `, 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
+        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');
+            : `, 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) {
@@ -137,7 +137,7 @@ export class MetadataDiscovery {
         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) => {
@@ -167,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') {
@@ -179,7 +179,7 @@ export class MetadataDiscovery {
         });
     }
     async findEntities(preferTs) {
-        const { entities, entitiesTs, baseDir } = this.config.getAll();
+        const { entities, entitiesTs, baseDir } = this.#config.getAll();
         const targets = preferTs && entitiesTs.length > 0 ? entitiesTs : entities;
         const processed = [];
         const paths = [];
@@ -203,13 +203,13 @@ 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);
                 }
             }
@@ -217,7 +217,7 @@ export class MetadataDiscovery {
                 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))) {
+                    .every(type => this.#discovered.find(m => m.className === type))) {
                     missing.push(...Utils.asArray(target));
                 }
             }
@@ -233,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();
                 }
@@ -248,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 */
@@ -266,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);
             }
         }
@@ -275,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) {
@@ -298,17 +301,17 @@ 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);
+        const base = meta.extends && this.#metadata.find(meta.extends);
         if (!base || base === meta) {
             // make sure we do not fall into infinite loop
             return meta;
@@ -324,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
@@ -338,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) {
@@ -410,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);
@@ -425,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);
@@ -455,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];
@@ -475,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;
@@ -509,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;
@@ -528,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));
@@ -549,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);
@@ -567,7 +570,7 @@ export class MetadataDiscovery {
         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 => {
@@ -594,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);
@@ -631,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`;
@@ -698,15 +701,15 @@ export class MetadataDiscovery {
             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;
@@ -722,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.
@@ -778,7 +781,7 @@ 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);
@@ -831,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);
@@ -866,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;
@@ -926,7 +930,7 @@ export class MetadataDiscovery {
         });
     }
     defineBaseEntityProperties(meta) {
-        const base = meta.extends && this.metadata.get(meta.extends);
+        const base = meta.extends && this.#metadata.get(meta.extends);
         if (!base || base === meta) {
             // make sure we do not fall into infinite loop
             return 0;
@@ -973,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 = {};
@@ -986,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) {
@@ -1030,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) {
@@ -1042,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`);
                 }
@@ -1077,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}`);
         }
@@ -1149,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
@@ -1191,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 = {};
@@ -1199,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;
             }
         }
@@ -1215,8 +1223,13 @@ export class MetadataDiscovery {
         Object.values(meta.properties).forEach(prop => {
             const newProp = { ...prop };
             const rootProp = meta.root.properties[prop.name];
+            // 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 &&
-                (rootProp.type !== prop.type ||
+                (!typesMatch ||
                     (rootProp.fieldNames && prop.fieldNames && !compareArrays(rootProp.fieldNames, prop.fieldNames)))) {
                 const name = newProp.name;
                 this.initFieldName(newProp, newProp.object);
@@ -1231,7 +1244,7 @@ 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);
+                        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];
@@ -1299,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);
     }
@@ -1321,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;
         }
@@ -1439,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;
         }
@@ -1458,12 +1471,12 @@ 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.persist !== false &&
@@ -1471,9 +1484,9 @@ export class MetadataDiscovery {
                     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("', '")}')`,
                     });
                 }
             }
@@ -1481,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];
             }
@@ -1504,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';
     }
@@ -1521,7 +1534,7 @@ 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 &&
+            if (this.#config.get('discovery').inferDefaultValues &&
                 prop.default === undefined &&
                 entity1[prop.name] != null &&
                 entity1[prop.name] === entity2[prop.name] &&
@@ -1548,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;
     }
@@ -1652,7 +1665,7 @@ export class MetadataDiscovery {
         }
         if (prop.customType && !prop.columnTypes) {
             const mappedType = this.getMappedType({
-                columnTypes: [prop.customType.getColumnType(prop, this.platform)],
+                columnTypes: [prop.customType.getColumnType(prop, this.#platform)],
             });
             if (prop.customType.compareAsType() === 'any' && ![t.json].some(t => prop.customType instanceof t)) {
                 prop.runtimeType ??= mappedType.runtimeType;
@@ -1668,15 +1681,15 @@ 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.columnTypes ??= [prop.customType.getColumnType(prop, this.#platform)];
             prop.hasConvertToJSValueSQL =
-                !!prop.customType.convertToJSValueSQL && prop.customType.convertToJSValueSQL('', this.platform) !== '';
+                !!prop.customType.convertToJSValueSQL && prop.customType.convertToJSValueSQL('', this.#platform) !== '';
             prop.hasConvertToDatabaseValueSQL =
                 !!prop.customType.convertToDatabaseValueSQL &&
-                    prop.customType.convertToDatabaseValueSQL('', this.platform) !== '';
+                    prop.customType.convertToDatabaseValueSQL('', this.#platform) !== '';
             if (prop.customType instanceof t.bigint &&
                 ['string', 'bigint', 'number'].includes(prop.runtimeType.toLowerCase())) {
                 prop.customType.mode = prop.runtimeType.toLowerCase();
@@ -1694,11 +1707,11 @@ export class MetadataDiscovery {
                 if (pk.customType) {
                     prop.customTypes.push(pk.customType);
                     prop.hasConvertToJSValueSQL ||=
-                        !!pk.customType.convertToJSValueSQL && pk.customType.convertToJSValueSQL('', this.platform) !== '';
+                        !!pk.customType.convertToJSValueSQL && pk.customType.convertToJSValueSQL('', this.#platform) !== '';
                     /* v8 ignore next */
                     prop.hasConvertToDatabaseValueSQL ||=
                         !!pk.customType.convertToDatabaseValueSQL &&
-                            pk.customType.convertToDatabaseValueSQL('', this.platform) !== '';
+                            pk.customType.convertToDatabaseValueSQL('', this.#platform) !== '';
                 }
                 else {
                     prop.customTypes.push(undefined);
@@ -1708,13 +1721,13 @@ export class MetadataDiscovery {
         if (prop.kind === ReferenceKind.SCALAR && !(mappedType instanceof t.unknown)) {
             if (!prop.columnTypes &&
                 prop.nativeEnumName &&
-                meta.schema !== this.platform.getDefaultSchemaName() &&
+                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
@@ -1728,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;
@@ -1743,7 +1756,7 @@ export class MetadataDiscovery {
             !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])}`;
             }
         }
     }
@@ -1765,7 +1778,7 @@ 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) {
@@ -1775,18 +1788,18 @@ export class MetadataDiscovery {
                 // it could be a runtime type from reflect-metadata
                 !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;
@@ -1794,7 +1807,7 @@ export class MetadataDiscovery {
         // Use targetKey property if specified, otherwise use primary key properties
         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);
@@ -1802,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) {
@@ -1825,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;
@@ -1836,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) {
@@ -1851,16 +1864,16 @@ export class MetadataDiscovery {
             return;
         }
         prop.unsigned ??=
-            (prop.primary || prop.unsigned) && this.platform.isNumericProperty(prop) && this.platform.supportsUnsigned();
+            (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);
         }