@mikro-orm/core 7.0.14-dev.8 → 7.0.14

package/metadata/MetadataDiscovery.js

@@ -1,4 +1,4 @@
-import { EntityMetadata, } from '../typings.js';
+import { EntityMetadata } from '../typings.js';
 import { compareArrays, Utils } from '../utils/Utils.js';
 import { QueryHelper } from '../utils/QueryHelper.js';
 import { MetadataValidator } from './MetadataValidator.js';
@@ -13,1946 +13,2028 @@ import { raw, Raw } from '../utils/RawQueryFragment.js';
 import { BaseEntity } from '../entity/BaseEntity.js';
 /** Discovers, validates, and processes entity metadata from configured sources. */
 export class MetadataDiscovery {
-    #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();
-    }
-    /** Discovers all entities asynchronously and returns the populated MetadataStorage. */
-    async discover(preferTs = true) {
-        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}`);
-        await this.findEntities(preferTs);
-        for (const meta of this.#discovered) {
-            /* v8 ignore next */
-            await this.#config.get('discovery').onMetadata?.(meta, this.#platform);
-        }
-        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`)}`);
-        const storage = this.mapDiscoveredEntities();
-        /* v8 ignore next */
-        await this.#config.get('discovery').afterDiscovered?.(storage, this.#platform);
-        return storage;
-    }
-    /** Discovers all entities synchronously and returns the populated MetadataStorage. */
-    discoverSync() {
-        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');
-        this.discoverReferences(refs);
-        for (const meta of this.#discovered) {
-            /* v8 ignore next */
-            void this.#config.get('discovery').onMetadata?.(meta, this.#platform);
-        }
-        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`)}`);
-        const storage = this.mapDiscoveredEntities();
-        /* v8 ignore next */
-        void this.#config.get('discovery').afterDiscovered?.(storage, this.#platform);
-        return storage;
-    }
-    mapDiscoveredEntities() {
-        const discovered = new MetadataStorage();
-        this.#discovered
-            .filter(meta => meta.root.name)
-            .sort((a, b) => b.root.name.localeCompare(a.root.name))
-            .forEach(meta => {
-            this.#platform.validateMetadata(meta);
-            discovered.set(meta.class, meta);
+  #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();
+  }
+  /** Discovers all entities asynchronously and returns the populated MetadataStorage. */
+  async discover(preferTs = true) {
+    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}`);
+    await this.findEntities(preferTs);
+    for (const meta of this.#discovered) {
+      /* v8 ignore next */
+      await this.#config.get('discovery').onMetadata?.(meta, this.#platform);
+    }
+    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`)}`,
+    );
+    const storage = this.mapDiscoveredEntities();
+    /* v8 ignore next */
+    await this.#config.get('discovery').afterDiscovered?.(storage, this.#platform);
+    return storage;
+  }
+  /** Discovers all entities synchronously and returns the populated MetadataStorage. */
+  discoverSync() {
+    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');
+    this.discoverReferences(refs);
+    for (const meta of this.#discovered) {
+      /* v8 ignore next */
+      void this.#config.get('discovery').onMetadata?.(meta, this.#platform);
+    }
+    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`)}`,
+    );
+    const storage = this.mapDiscoveredEntities();
+    /* v8 ignore next */
+    void this.#config.get('discovery').afterDiscovered?.(storage, this.#platform);
+    return storage;
+  }
+  mapDiscoveredEntities() {
+    const discovered = new MetadataStorage();
+    this.#discovered
+      .filter(meta => meta.root.name)
+      .sort((a, b) => b.root.name.localeCompare(a.root.name))
+      .forEach(meta => {
+        this.#platform.validateMetadata(meta);
+        discovered.set(meta.class, meta);
+      });
+    for (const meta of discovered) {
+      meta.root = discovered.get(meta.root.class);
+      if (meta.inheritanceType === 'tpt') {
+        this.computeTPTOwnProps(meta);
+      }
+    }
+    return discovered;
+  }
+  initAccessors(meta) {
+    for (const prop of Object.values(meta.properties)) {
+      if (!prop.accessor || meta.properties[prop.accessor]) {
+        continue;
+      }
+      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;
+        if (prop.accessor === true) {
+          prop.getter = prop.setter = true;
+        } else {
+          prop.getter = prop.setter = false;
+        }
+        prop.accessor = accessor;
+        prop.serializedName ??= accessor;
+        Utils.renameKey(meta.properties, accessor, prop.name);
+      } else {
+        const name = prop.name;
+        // For to-one relations, only swap to the accessor for the documented
+        // backing-field convention (a `_`-prefixed property like `_draft` paired
+        // with `accessor: 'draft'`). The non-prefixed sibling-helper pattern
+        // (`author` + `accessor: 'authorId'`) keeps the property name as the
+        // canonical FK column source, so this stays non-breaking.
+        if (prop.kind === ReferenceKind.SCALAR || prop.kind === ReferenceKind.EMBEDDED || name.startsWith('_')) {
+          prop.name = prop.accessor;
+        }
+        this.initRelation(prop);
+        this.initFieldName(prop);
+        prop.serializedName ??= prop.accessor;
+        prop.name = name;
+      }
+    }
+  }
+  /** Processes discovered entities: initializes relations, embeddables, indexes, and inheritance. */
+  processDiscoveredEntities(discovered) {
+    for (const meta of discovered) {
+      let i = 1;
+      Object.values(meta.properties).forEach(prop => meta.propertyOrder.set(prop.name, i++));
+      Object.values(meta.properties).forEach(prop => this.initPolyEmbeddables(prop, discovered));
+      this.initAccessors(meta);
+    }
+    // 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.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);
+    });
+    filtered.forEach(meta => this.initAutoincrement(meta));
+    const forEachProp = cb => {
+      filtered.forEach(meta => Object.values(meta.properties).forEach(prop => cb(meta, prop)));
+    };
+    forEachProp((m, p) => this.initFactoryField(m, p));
+    forEachProp((m, p) => this.initPolymorphicRelation(m, p, filtered));
+    forEachProp((_m, p) => this.initRelation(p));
+    forEachProp((m, p) => this.initEmbeddables(m, p));
+    forEachProp((_m, p) => this.initFieldName(p));
+    filtered.forEach(meta => this.finalizeTPTInheritance(meta, filtered));
+    filtered.forEach(meta => this.computeTPTOwnProps(meta));
+    forEachProp((m, p) => this.initVersionProperty(m, p));
+    forEachProp((m, p) => this.initCustomType(m, p));
+    forEachProp((m, p) => this.initGeneratedColumn(m, p));
+    filtered.forEach(meta => this.initAutoincrement(meta)); // once again after we init custom types
+    filtered.forEach(meta => this.initCheckConstraints(meta));
+    forEachProp((_m, p) => {
+      this.initDefaultValue(p);
+      this.inferTypeFromDefault(p);
+      this.initRelation(p);
+      this.initColumnType(p);
+    });
+    forEachProp((m, p) => this.initIndexes(m, p));
+    filtered.forEach(meta => this.autoWireBidirectionalProperties(meta));
+    for (const meta of filtered) {
+      discovered.push(...this.processEntity(meta));
+    }
+    discovered.forEach(meta => meta.sync(true));
+    this.#metadataProvider.combineCache();
+    return discovered.map(meta => {
+      meta = this.#metadata.get(meta.class);
+      meta.sync(true);
+      this.findReferencingProperties(meta, filtered);
+      if (meta.inheritanceType === 'tpt') {
+        this.computeTPTOwnProps(meta);
+      }
+      return meta;
+    });
+  }
+  async findEntities(preferTs) {
+    const { entities, entitiesTs, baseDir } = this.#config.getAll();
+    const targets = preferTs && entitiesTs.length > 0 ? entitiesTs : entities;
+    const processed = [];
+    const paths = [];
+    for (const entity of targets) {
+      if (typeof entity === 'string') {
+        paths.push(entity);
+      } else {
+        processed.push(entity);
+      }
+    }
+    if (paths.length > 0) {
+      const { discoverEntities } = await import('@mikro-orm/core/file-discovery');
+      processed.push(...(await discoverEntities(paths, { baseDir })));
+    }
+    return this.discoverReferences(processed);
+  }
+  discoverMissingTargets() {
+    const unwrap = type =>
+      type
+        .replace(/Array<(.*)>/, '$1') // unwrap array
+        .replace(/\[]$/, '') // remove array suffix
+        .replace(/\((.*)\)/, '$1'); // unwrap union types
+    const missing = [];
+    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))) {
+            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))
+          ) {
+            missing.push(...Utils.asArray(target));
+          }
+        }
+      }),
+    );
+    if (missing.length > 0) {
+      this.tryDiscoverTargets(missing);
+    }
+  }
+  tryDiscoverTargets(targets) {
+    for (const target of targets) {
+      const schema = EntitySchema.is(target) ? target : undefined;
+      const isDiscoverable = typeof target === 'function' || schema;
+      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)) {
+          this.discoverReferences([target], false);
+          this.discoverMissingTargets();
+        }
+      }
+    }
+  }
+  discoverReferences(refs, validate = true) {
+    const found = [];
+    for (const entity of refs) {
+      if (typeof entity === 'string') {
+        throw new Error('Folder based discovery requires the async `MikroORM.init()` method.');
+      }
+      const schema = this.getSchema(entity);
+      const meta = schema.init().meta;
+      this.#metadata.set(meta.class, meta);
+      found.push(schema);
+    }
+    // discover parents (base entities) automatically
+    for (const meta of this.#metadata) {
+      let parent = meta.extends;
+      if (EntitySchema.is(parent) && !this.#metadata.has(parent.init().meta.class)) {
+        this.discoverReferences([parent], false);
+      }
+      if (typeof parent === 'function' && parent.name && !this.#metadata.has(parent)) {
+        this.discoverReferences([parent], false);
+      }
+      /* v8 ignore next */
+      if (!meta.class) {
+        continue;
+      }
+      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
+      ) {
+        this.discoverReferences([parent], false);
+      }
+    }
+    for (const schema of found) {
+      this.discoverEntity(schema);
+    }
+    this.discoverMissingTargets();
+    if (validate) {
+      this.#validator.validateDiscovered(this.#discovered, this.#config.get('discovery'));
+    }
+    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),
+    );
+    if (exists !== -1) {
+      this.#metadata.reset(this.#discovered[exists].class);
+      this.#discovered.splice(exists, 1);
+    }
+  }
+  getSchema(entity) {
+    if (EntitySchema.REGISTRY.has(entity)) {
+      entity = EntitySchema.REGISTRY.get(entity);
+    }
+    if (EntitySchema.is(entity)) {
+      const meta = Utils.copy(entity.meta, false);
+      return EntitySchema.fromMetadata(meta);
+    }
+    // After the EntitySchema check, entity must be an EntityClass
+    const cls = entity;
+    const path = cls[MetadataStorage.PATH_SYMBOL];
+    if (path) {
+      const meta = Utils.copy(MetadataStorage.getMetadata(cls.name, path), false);
+      meta.path = path;
+      this.#metadata.set(cls, meta);
+    }
+    const exists = this.#metadata.has(cls);
+    const meta = this.#metadata.get(cls, true);
+    meta.abstract ??= !(exists && meta.name);
+    const schema = EntitySchema.fromMetadata(meta);
+    schema.setClass(cls);
+    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
+      return meta;
+    }
+    const root = this.getRootEntity(base);
+    // For STI or TPT, use the root entity.
+    // Check both `inheritanceType` (set during discovery) and raw `inheritance` option (set before discovery).
+    if (root.discriminatorColumn || root.inheritanceType || root.inheritance === 'tpt') {
+      return root;
+    }
+    return meta;
+  }
+  discoverEntity(schema) {
+    const meta = schema.meta;
+    const path = meta.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);
+    if (cache) {
+      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
+    for (const prop of meta.props) {
+      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);
+    if (!meta.tableName && meta.name) {
+      const entityName = root.discriminatorColumn ? root.name : meta.name;
+      meta.tableName = this.#namingStrategy.classToTableName(entityName);
+    }
+    this.#metadataProvider.saveToCache(meta);
+    meta.root = root;
+    this.#discovered.push(meta);
+  }
+  initNullability(prop) {
+    if (prop.kind === ReferenceKind.ONE_TO_ONE) {
+      return Utils.defaultValue(prop, 'nullable', prop.optional || !prop.owner);
+    }
+    return Utils.defaultValue(prop, 'nullable', prop.optional);
+  }
+  applyNamingStrategy(meta, prop) {
+    if (!prop.fieldNames) {
+      this.initFieldName(prop);
+    }
+    if (prop.kind === ReferenceKind.MANY_TO_MANY) {
+      this.initManyToManyFields(meta, prop);
+    }
+    if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+      this.initManyToOneFields(prop);
+    }
+    if (prop.kind === ReferenceKind.ONE_TO_MANY) {
+      this.initOneToManyFields(prop);
+    }
+  }
+  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)
+      ) {
+        continue;
+      }
+      // For polymorphic relations, ownColumns should include all fieldNames
+      // (discriminator + ID columns) since they are all owned by this relation
+      if (prop.polymorphic) {
+        prop.ownColumns = prop.fieldNames;
+        continue;
+      }
+      if (prop.joinColumns.length > 1) {
+        prop.ownColumns = prop.joinColumns.filter(col => {
+          return !meta.props.find(p => p.name !== prop.name && p.fieldNames?.includes(col));
         });
-        for (const meta of discovered) {
-            meta.root = discovered.get(meta.root.class);
-            if (meta.inheritanceType === 'tpt') {
-                this.computeTPTOwnProps(meta);
-            }
-        }
-        return discovered;
-    }
-    initAccessors(meta) {
-        for (const prop of Object.values(meta.properties)) {
-            if (!prop.accessor || meta.properties[prop.accessor]) {
-                continue;
-            }
-            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;
-                if (prop.accessor === true) {
-                    prop.getter = prop.setter = true;
-                }
-                else {
-                    prop.getter = prop.setter = false;
-                }
-                prop.accessor = accessor;
-                prop.serializedName ??= accessor;
-                Utils.renameKey(meta.properties, accessor, prop.name);
-            }
-            else {
-                const name = prop.name;
-                // For to-one relations, only swap to the accessor for the documented
-                // backing-field convention (a `_`-prefixed property like `_draft` paired
-                // with `accessor: 'draft'`). The non-prefixed sibling-helper pattern
-                // (`author` + `accessor: 'authorId'`) keeps the property name as the
-                // canonical FK column source, so this stays non-breaking.
-                if (prop.kind === ReferenceKind.SCALAR || prop.kind === ReferenceKind.EMBEDDED || name.startsWith('_')) {
-                    prop.name = prop.accessor;
-                }
-                this.initRelation(prop);
-                this.initFieldName(prop);
-                prop.serializedName ??= prop.accessor;
-                prop.name = name;
-            }
-        }
-    }
-    /** Processes discovered entities: initializes relations, embeddables, indexes, and inheritance. */
-    processDiscoveredEntities(discovered) {
-        for (const meta of discovered) {
-            let i = 1;
-            Object.values(meta.properties).forEach(prop => meta.propertyOrder.set(prop.name, i++));
-            Object.values(meta.properties).forEach(prop => this.initPolyEmbeddables(prop, discovered));
-            this.initAccessors(meta);
-        }
-        // 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.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);
+      }
+      if (!prop.ownColumns || prop.ownColumns.length === 0) {
+        prop.ownColumns = prop.joinColumns;
+      }
+      if (prop.joinColumns.length !== prop.columnTypes.length) {
+        prop.columnTypes = prop.joinColumns.flatMap(field => {
+          const matched = meta.props.find(p => p.fieldNames?.includes(field));
+          /* v8 ignore next */
+          if (!matched) {
+            throw MetadataError.fromWrongForeignKey(meta, prop, 'columnTypes');
+          }
+          return matched.columnTypes;
         });
-        filtered.forEach(meta => this.initAutoincrement(meta));
-        const forEachProp = (cb) => {
-            filtered.forEach(meta => Object.values(meta.properties).forEach(prop => cb(meta, prop)));
-        };
-        forEachProp((m, p) => this.initFactoryField(m, p));
-        forEachProp((m, p) => this.initPolymorphicRelation(m, p, filtered));
-        forEachProp((_m, p) => this.initRelation(p));
-        forEachProp((m, p) => this.initEmbeddables(m, p));
-        forEachProp((_m, p) => this.initFieldName(p));
-        filtered.forEach(meta => this.finalizeTPTInheritance(meta, filtered));
-        filtered.forEach(meta => this.computeTPTOwnProps(meta));
-        forEachProp((m, p) => this.initVersionProperty(m, p));
-        forEachProp((m, p) => this.initCustomType(m, p));
-        forEachProp((m, p) => this.initGeneratedColumn(m, p));
-        filtered.forEach(meta => this.initAutoincrement(meta)); // once again after we init custom types
-        filtered.forEach(meta => this.initCheckConstraints(meta));
-        forEachProp((_m, p) => {
-            this.initDefaultValue(p);
-            this.inferTypeFromDefault(p);
-            this.initRelation(p);
-            this.initColumnType(p);
+      }
+      if (prop.joinColumns.length !== prop.referencedColumnNames.length) {
+        throw MetadataError.fromWrongForeignKey(meta, prop, 'referencedColumnNames');
+      }
+    }
+  }
+  initFieldName(prop, object = false) {
+    if (prop.fieldNames && prop.fieldNames.length > 0) {
+      return;
+    }
+    if (prop.kind === ReferenceKind.SCALAR || prop.kind === ReferenceKind.EMBEDDED) {
+      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);
+    } else if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner) {
+      prop.fieldNames = this.initManyToManyFieldName(prop, prop.name);
+    }
+  }
+  initManyToOneFieldName(prop, name) {
+    const meta2 = prop.targetMeta;
+    const ret = [];
+    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));
+      }
+    }
+    return ret;
+  }
+  initManyToManyFieldName(prop, name) {
+    const meta2 = prop.targetMeta;
+    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 props = Object.values(pivotMeta?.properties ?? {});
+    const pks = props.filter(p => p.primary);
+    const fks = props.filter(p => p.kind === ReferenceKind.MANY_TO_ONE);
+    if (pivotMeta) {
+      pivotMeta.pivotTable = true;
+      prop.pivotTable = pivotMeta.tableName;
+      if (pks.length === 1) {
+        prop.fixedOrder = true;
+        prop.fixedOrderColumn = pks[0].name;
+      }
+    }
+    if (pivotMeta && (pks.length === 2 || fks.length >= 2)) {
+      const owner = prop.mappedBy ? meta2.properties[prop.mappedBy] : prop;
+      const [first, second] = this.ensureCorrectFKOrderInPivotEntity(pivotMeta, owner);
+      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.mappedBy) {
+      const prop2 = meta2.properties[prop.mappedBy];
+      this.initManyToManyFields(meta2, prop2);
+      prop.pivotTable = prop2.pivotTable;
+      prop.pivotEntity = prop2.pivotEntity;
+      prop.fixedOrder = prop2.fixedOrder;
+      prop.fixedOrderColumn = prop2.fixedOrderColumn;
+      prop.joinColumns = prop2.inverseJoinColumns;
+      prop.inverseJoinColumns = prop2.joinColumns;
+      prop.polymorphic = prop2.polymorphic;
+      prop.discriminator = prop2.discriminator;
+      prop.discriminatorColumn = prop2.discriminatorColumn;
+      prop.discriminatorValue = prop2.discriminatorValue;
+    }
+    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,
+        ),
+      );
+    } else {
+      prop.joinColumns ??= prop.referencedColumnNames.map(referencedColumnName =>
+        this.#namingStrategy.joinKeyColumnName(meta.root.className, referencedColumnName, meta.compositePK),
+      );
+    }
+    prop.inverseJoinColumns ??= this.initManyToOneFieldName(prop, meta2.root.className);
+  }
+  isExplicitTableName(meta) {
+    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),
+      );
+      prop.fieldNames ??= [prop.discriminatorColumn, ...idColumns];
+      prop.joinColumns ??= idColumns;
+      prop.referencedColumnNames ??= fieldNames1;
+      prop.referencedTableName ??= prop.targetMeta.tableName;
+      return;
+    }
+    const meta2 = prop.targetMeta;
+    let fieldNames;
+    // If targetKey is specified, use that property's field names instead of PKs
+    if (prop.targetKey) {
+      const targetProp = meta2.properties[prop.targetKey];
+      fieldNames = targetProp.fieldNames;
+    } else {
+      fieldNames = Utils.flatten(meta2.primaryKeys.map(primaryKey => meta2.properties[primaryKey].fieldNames));
+    }
+    Utils.defaultValue(prop, 'referencedTableName', meta2.tableName);
+    if (!prop.joinColumns) {
+      prop.joinColumns = fieldNames.map(fieldName =>
+        this.#namingStrategy.joinKeyColumnName(prop.name, fieldName, fieldNames.length > 1),
+      );
+    }
+    if (!prop.referencedColumnNames) {
+      prop.referencedColumnNames = fieldNames;
+    }
+    // Relations to composite PK targets need cascade update by default,
+    // since composite PKs are more likely to have mutable components
+    if (meta2.compositePK) {
+      prop.updateRule ??= 'cascade';
+    }
+    // Nullable relations default to 'set null' on delete - when the referenced
+    // entity is deleted, set the FK to null rather than failing
+    if (prop.nullable) {
+      prop.deleteRule ??= 'set null';
+    }
+  }
+  initOneToManyFields(prop) {
+    const meta2 = prop.targetMeta;
+    if (!prop.joinColumns) {
+      prop.joinColumns = [this.#namingStrategy.joinColumnName(prop.name)];
+    }
+    if (!prop.referencedColumnNames) {
+      meta2.getPrimaryProps().forEach(pk => this.applyNamingStrategy(meta2, pk));
+      prop.referencedColumnNames = Utils.flatten(meta2.getPrimaryProps().map(pk => pk.fieldNames));
+    }
+  }
+  processEntity(meta) {
+    const pks = Object.values(meta.properties).filter(prop => prop.primary);
+    meta.primaryKeys = pks.map(prop => prop.name);
+    meta.compositePK = pks.length > 1;
+    // FK used as PK, we need to cascade - applies to both single FK-as-PK
+    // and composite PKs where all PKs are FKs (e.g., pivot-like entities)
+    const fkPks = pks.filter(pk => pk.kind !== ReferenceKind.SCALAR);
+    if (fkPks.length > 0 && fkPks.length === pks.length) {
+      for (const pk of fkPks) {
+        pk.deleteRule ??= 'cascade';
+        pk.updateRule ??= 'cascade';
+      }
+    }
+    meta.forceConstructor ??= this.shouldForceConstructorUsage(meta);
+    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);
+      this.initDefaultValue(prop);
+      this.inferTypeFromDefault(prop);
+      this.initVersionProperty(meta, prop);
+      this.initCustomType(meta, prop);
+      this.initColumnType(prop);
+      this.initRelation(prop);
+    }
+    this.initOwnColumns(meta);
+    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()) {
+      return Object.values(meta.properties)
+        .filter(prop => prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && prop.pivotTable)
+        .map(prop => {
+          const pivotMeta = this.definePivotTableEntity(meta, prop);
+          prop.pivotEntity = pivotMeta.class;
+          if (prop.inversedBy) {
+            prop.targetMeta.properties[prop.inversedBy].pivotEntity = pivotMeta.class;
+          }
+          return pivotMeta;
         });
-        forEachProp((m, p) => this.initIndexes(m, p));
-        filtered.forEach(meta => this.autoWireBidirectionalProperties(meta));
-        for (const meta of filtered) {
-            discovered.push(...this.processEntity(meta));
-        }
-        discovered.forEach(meta => meta.sync(true));
-        this.#metadataProvider.combineCache();
-        return discovered.map(meta => {
-            meta = this.#metadata.get(meta.class);
-            meta.sync(true);
-            this.findReferencingProperties(meta, filtered);
-            if (meta.inheritanceType === 'tpt') {
-                this.computeTPTOwnProps(meta);
-            }
-            return meta;
-        });
-    }
-    async findEntities(preferTs) {
-        const { entities, entitiesTs, baseDir } = this.#config.getAll();
-        const targets = preferTs && entitiesTs.length > 0 ? entitiesTs : entities;
-        const processed = [];
-        const paths = [];
-        for (const entity of targets) {
-            if (typeof entity === 'string') {
-                paths.push(entity);
-            }
-            else {
-                processed.push(entity);
-            }
-        }
-        if (paths.length > 0) {
-            const { discoverEntities } = await import('@mikro-orm/core/file-discovery');
-            processed.push(...(await discoverEntities(paths, { baseDir })));
-        }
-        return this.discoverReferences(processed);
-    }
-    discoverMissingTargets() {
-        const unwrap = (type) => type
-            .replace(/Array<(.*)>/, '$1') // unwrap array
-            .replace(/\[]$/, '') // remove array suffix
-            .replace(/\((.*)\)/, '$1'); // unwrap union types
-        const missing = [];
-        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))) {
-                    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))) {
-                    missing.push(...Utils.asArray(target));
-                }
-            }
-        }));
-        if (missing.length > 0) {
-            this.tryDiscoverTargets(missing);
-        }
-    }
-    tryDiscoverTargets(targets) {
-        for (const target of targets) {
-            const schema = EntitySchema.is(target) ? target : undefined;
-            const isDiscoverable = typeof target === 'function' || schema;
-            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)) {
-                    this.discoverReferences([target], false);
-                    this.discoverMissingTargets();
-                }
-            }
-        }
-    }
-    discoverReferences(refs, validate = true) {
-        const found = [];
-        for (const entity of refs) {
-            if (typeof entity === 'string') {
-                throw new Error('Folder based discovery requires the async `MikroORM.init()` method.');
-            }
-            const schema = this.getSchema(entity);
-            const meta = schema.init().meta;
-            this.#metadata.set(meta.class, meta);
-            found.push(schema);
-        }
-        // discover parents (base entities) automatically
-        for (const meta of this.#metadata) {
-            let parent = meta.extends;
-            if (EntitySchema.is(parent) && !this.#metadata.has(parent.init().meta.class)) {
-                this.discoverReferences([parent], false);
-            }
-            if (typeof parent === 'function' && parent.name && !this.#metadata.has(parent)) {
-                this.discoverReferences([parent], false);
-            }
-            /* v8 ignore next */
-            if (!meta.class) {
-                continue;
-            }
-            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) {
-                this.discoverReferences([parent], false);
-            }
-        }
-        for (const schema of found) {
-            this.discoverEntity(schema);
-        }
-        this.discoverMissingTargets();
-        if (validate) {
-            this.#validator.validateDiscovered(this.#discovered, this.#config.get('discovery'));
-        }
-        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));
-        if (exists !== -1) {
-            this.#metadata.reset(this.#discovered[exists].class);
-            this.#discovered.splice(exists, 1);
-        }
-    }
-    getSchema(entity) {
-        if (EntitySchema.REGISTRY.has(entity)) {
-            entity = EntitySchema.REGISTRY.get(entity);
-        }
-        if (EntitySchema.is(entity)) {
-            const meta = Utils.copy(entity.meta, false);
-            return EntitySchema.fromMetadata(meta);
-        }
-        // After the EntitySchema check, entity must be an EntityClass
-        const cls = entity;
-        const path = cls[MetadataStorage.PATH_SYMBOL];
-        if (path) {
-            const meta = Utils.copy(MetadataStorage.getMetadata(cls.name, path), false);
-            meta.path = path;
-            this.#metadata.set(cls, meta);
-        }
-        const exists = this.#metadata.has(cls);
-        const meta = this.#metadata.get(cls, true);
-        meta.abstract ??= !(exists && meta.name);
-        const schema = EntitySchema.fromMetadata(meta);
-        schema.setClass(cls);
-        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
-            return meta;
-        }
-        const root = this.getRootEntity(base);
-        // For STI or TPT, use the root entity.
-        // Check both `inheritanceType` (set during discovery) and raw `inheritance` option (set before discovery).
-        if (root.discriminatorColumn || root.inheritanceType || root.inheritance === 'tpt') {
-            return root;
-        }
-        return meta;
-    }
-    discoverEntity(schema) {
-        const meta = schema.meta;
-        const path = meta.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);
-        if (cache) {
-            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
-        for (const prop of meta.props) {
-            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);
-        if (!meta.tableName && meta.name) {
-            const entityName = root.discriminatorColumn ? root.name : meta.name;
-            meta.tableName = this.#namingStrategy.classToTableName(entityName);
-        }
-        this.#metadataProvider.saveToCache(meta);
-        meta.root = root;
-        this.#discovered.push(meta);
-    }
-    initNullability(prop) {
-        if (prop.kind === ReferenceKind.ONE_TO_ONE) {
-            return Utils.defaultValue(prop, 'nullable', prop.optional || !prop.owner);
-        }
-        return Utils.defaultValue(prop, 'nullable', prop.optional);
-    }
-    applyNamingStrategy(meta, prop) {
-        if (!prop.fieldNames) {
-            this.initFieldName(prop);
-        }
-        if (prop.kind === ReferenceKind.MANY_TO_MANY) {
-            this.initManyToManyFields(meta, prop);
-        }
-        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
-            this.initManyToOneFields(prop);
-        }
-        if (prop.kind === ReferenceKind.ONE_TO_MANY) {
-            this.initOneToManyFields(prop);
-        }
-    }
-    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)) {
-                continue;
-            }
-            // For polymorphic relations, ownColumns should include all fieldNames
-            // (discriminator + ID columns) since they are all owned by this relation
-            if (prop.polymorphic) {
-                prop.ownColumns = prop.fieldNames;
-                continue;
-            }
-            if (prop.joinColumns.length > 1) {
-                prop.ownColumns = prop.joinColumns.filter(col => {
-                    return !meta.props.find(p => p.name !== prop.name && p.fieldNames?.includes(col));
-                });
-            }
-            if (!prop.ownColumns || prop.ownColumns.length === 0) {
-                prop.ownColumns = prop.joinColumns;
-            }
-            if (prop.joinColumns.length !== prop.columnTypes.length) {
-                prop.columnTypes = prop.joinColumns.flatMap(field => {
-                    const matched = meta.props.find(p => p.fieldNames?.includes(field));
-                    /* v8 ignore next */
-                    if (!matched) {
-                        throw MetadataError.fromWrongForeignKey(meta, prop, 'columnTypes');
-                    }
-                    return matched.columnTypes;
-                });
-            }
-            if (prop.joinColumns.length !== prop.referencedColumnNames.length) {
-                throw MetadataError.fromWrongForeignKey(meta, prop, 'referencedColumnNames');
-            }
-        }
-    }
-    initFieldName(prop, object = false) {
-        if (prop.fieldNames && prop.fieldNames.length > 0) {
-            return;
-        }
-        if (prop.kind === ReferenceKind.SCALAR || prop.kind === ReferenceKind.EMBEDDED) {
-            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);
-        }
-        else if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner) {
-            prop.fieldNames = this.initManyToManyFieldName(prop, prop.name);
-        }
     }
-    initManyToOneFieldName(prop, name) {
-        const meta2 = prop.targetMeta;
-        const ret = [];
-        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));
-            }
-        }
-        return ret;
-    }
-    initManyToManyFieldName(prop, name) {
-        const meta2 = prop.targetMeta;
-        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 props = Object.values(pivotMeta?.properties ?? {});
-        const pks = props.filter(p => p.primary);
-        const fks = props.filter(p => p.kind === ReferenceKind.MANY_TO_ONE);
-        if (pivotMeta) {
-            pivotMeta.pivotTable = true;
-            prop.pivotTable = pivotMeta.tableName;
-            if (pks.length === 1) {
-                prop.fixedOrder = true;
-                prop.fixedOrderColumn = pks[0].name;
-            }
-        }
-        if (pivotMeta && (pks.length === 2 || fks.length >= 2)) {
-            const owner = prop.mappedBy ? meta2.properties[prop.mappedBy] : prop;
-            const [first, second] = this.ensureCorrectFKOrderInPivotEntity(pivotMeta, owner);
-            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.mappedBy) {
-            const prop2 = meta2.properties[prop.mappedBy];
-            this.initManyToManyFields(meta2, prop2);
-            prop.pivotTable = prop2.pivotTable;
-            prop.pivotEntity = prop2.pivotEntity;
-            prop.fixedOrder = prop2.fixedOrder;
-            prop.fixedOrderColumn = prop2.fixedOrderColumn;
-            prop.joinColumns = prop2.inverseJoinColumns;
-            prop.inverseJoinColumns = prop2.joinColumns;
-            prop.polymorphic = prop2.polymorphic;
-            prop.discriminator = prop2.discriminator;
-            prop.discriminatorColumn = prop2.discriminatorColumn;
-            prop.discriminatorValue = prop2.discriminatorValue;
-        }
-        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));
-        }
-        else {
-            prop.joinColumns ??= prop.referencedColumnNames.map(referencedColumnName => this.#namingStrategy.joinKeyColumnName(meta.root.className, referencedColumnName, meta.compositePK));
-        }
-        prop.inverseJoinColumns ??= this.initManyToOneFieldName(prop, meta2.root.className);
-    }
-    isExplicitTableName(meta) {
-        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));
-            prop.fieldNames ??= [prop.discriminatorColumn, ...idColumns];
-            prop.joinColumns ??= idColumns;
-            prop.referencedColumnNames ??= fieldNames1;
-            prop.referencedTableName ??= prop.targetMeta.tableName;
-            return;
-        }
-        const meta2 = prop.targetMeta;
-        let fieldNames;
-        // If targetKey is specified, use that property's field names instead of PKs
-        if (prop.targetKey) {
-            const targetProp = meta2.properties[prop.targetKey];
-            fieldNames = targetProp.fieldNames;
-        }
-        else {
-            fieldNames = Utils.flatten(meta2.primaryKeys.map(primaryKey => meta2.properties[primaryKey].fieldNames));
-        }
-        Utils.defaultValue(prop, 'referencedTableName', meta2.tableName);
-        if (!prop.joinColumns) {
-            prop.joinColumns = fieldNames.map(fieldName => this.#namingStrategy.joinKeyColumnName(prop.name, fieldName, fieldNames.length > 1));
-        }
-        if (!prop.referencedColumnNames) {
-            prop.referencedColumnNames = fieldNames;
-        }
-        // Relations to composite PK targets need cascade update by default,
-        // since composite PKs are more likely to have mutable components
-        if (meta2.compositePK) {
-            prop.updateRule ??= 'cascade';
-        }
-        // Nullable relations default to 'set null' on delete - when the referenced
-        // entity is deleted, set the FK to null rather than failing
-        if (prop.nullable) {
-            prop.deleteRule ??= 'set null';
-        }
-    }
-    initOneToManyFields(prop) {
-        const meta2 = prop.targetMeta;
-        if (!prop.joinColumns) {
-            prop.joinColumns = [this.#namingStrategy.joinColumnName(prop.name)];
-        }
-        if (!prop.referencedColumnNames) {
-            meta2.getPrimaryProps().forEach(pk => this.applyNamingStrategy(meta2, pk));
-            prop.referencedColumnNames = Utils.flatten(meta2.getPrimaryProps().map(pk => pk.fieldNames));
-        }
-    }
-    processEntity(meta) {
-        const pks = Object.values(meta.properties).filter(prop => prop.primary);
-        meta.primaryKeys = pks.map(prop => prop.name);
-        meta.compositePK = pks.length > 1;
-        // FK used as PK, we need to cascade - applies to both single FK-as-PK
-        // and composite PKs where all PKs are FKs (e.g., pivot-like entities)
-        const fkPks = pks.filter(pk => pk.kind !== ReferenceKind.SCALAR);
-        if (fkPks.length > 0 && fkPks.length === pks.length) {
-            for (const pk of fkPks) {
-                pk.deleteRule ??= 'cascade';
-                pk.updateRule ??= 'cascade';
-            }
-        }
-        meta.forceConstructor ??= this.shouldForceConstructorUsage(meta);
-        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);
-            this.initDefaultValue(prop);
-            this.inferTypeFromDefault(prop);
-            this.initVersionProperty(meta, prop);
-            this.initCustomType(meta, prop);
-            this.initColumnType(prop);
-            this.initRelation(prop);
-        }
-        this.initOwnColumns(meta);
-        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()) {
-            return Object.values(meta.properties)
-                .filter(prop => prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && prop.pivotTable)
-                .map(prop => {
-                const pivotMeta = this.definePivotTableEntity(meta, prop);
-                prop.pivotEntity = pivotMeta.class;
-                if (prop.inversedBy) {
-                    prop.targetMeta.properties[prop.inversedBy].pivotEntity = pivotMeta.class;
-                }
-                return pivotMeta;
-            });
-        }
-        return [];
-    }
-    findReferencingProperties(meta, metadata) {
-        for (const meta2 of metadata) {
-            for (const prop2 of meta2.relations) {
-                if (prop2.kind !== ReferenceKind.SCALAR && prop2.type === meta.className) {
-                    meta.referencingProperties.push({ meta: meta2, prop: prop2 });
-                }
-            }
-        }
-    }
-    initFactoryField(meta, prop) {
-        ['mappedBy', 'inversedBy', 'pivotEntity'].forEach(type => {
-            const value = prop[type];
-            if (value instanceof Function) {
-                const meta2 = prop.targetMeta ?? this.#metadata.get(prop.target);
-                prop[type] = value(meta2.properties)?.name;
-                if (type === 'pivotEntity' && value) {
-                    prop[type] = value(meta2.properties);
-                }
-                if (prop[type] == null) {
-                    throw MetadataError.fromWrongReference(meta, prop, type);
-                }
-            }
-        });
-    }
-    ensureCorrectFKOrderInPivotEntity(meta, owner) {
-        const pks = Object.values(meta.properties).filter(p => p.primary);
-        const fks = Object.values(meta.properties).filter(p => p.kind === ReferenceKind.MANY_TO_ONE);
-        let first, second;
-        if (pks.length === 2) {
-            [first, second] = pks;
-        }
-        else if (fks.length >= 2) {
-            [first, second] = fks;
-        }
-        else {
-            /* v8 ignore next */
-            return [];
-        }
-        // wrong FK order, first FK needs to point to the owning side
-        // (note that we can detect this only if the FKs target different types)
-        if (owner.type === first.type && first.type !== second.type) {
-            delete meta.properties[first.name];
-            meta.removeProperty(first.name, false);
-            meta.addProperty(first);
-            [first, second] = [second, first];
-        }
-        return [first, second];
-    }
-    definePivotTableEntity(meta, prop) {
-        const pivotMeta = prop.pivotEntity
-            ? 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`;
-            prop.inversedBy = inverseName;
-            const inverseProp = {
-                name: inverseName,
-                kind: ReferenceKind.MANY_TO_MANY,
-                type: meta.className,
-                target: meta.class,
-                targetMeta: meta,
-                mappedBy: prop.name,
-                pivotEntity: prop.pivotEntity,
-                pivotTable: prop.pivotTable,
-                persist: false,
-                hydrate: false,
-            };
-            this.applyNamingStrategy(prop.targetMeta, inverseProp);
-            this.initCustomType(prop.targetMeta, inverseProp);
-            prop.targetMeta.properties[inverseName] = inverseProp;
-        }
-        if (pivotMeta) {
-            prop.pivotEntity = pivotMeta.class;
-            this.ensureCorrectFKOrderInPivotEntity(pivotMeta, prop);
-            if (prop.polymorphic && prop.discriminatorValue) {
-                pivotMeta.polymorphicDiscriminatorMap ??= {};
-                pivotMeta.polymorphicDiscriminatorMap[prop.discriminatorValue] = meta.class;
-                // For composite PK entities sharing a polymorphic pivot table,
-                // we need to add columns for each entity type's PKs
-                this.addPolymorphicPivotColumns(pivotMeta, meta, prop);
-                // Add virtual M:1 relation for this polymorphic owner (for join loading)
-                const ownerRelationName = `${prop.discriminator}_${meta.tableName}`;
-                if (!pivotMeta.properties[ownerRelationName]) {
-                    pivotMeta.properties[ownerRelationName] = this.definePolymorphicOwnerRelation(prop, ownerRelationName, meta);
-                }
-            }
-            return pivotMeta;
-        }
-        let tableName = prop.pivotTable;
-        let schemaName;
-        if (prop.pivotTable.includes('.')) {
-            [schemaName, tableName] = prop.pivotTable.split('.');
-        }
-        schemaName ??= meta.schema;
-        const targetMeta = prop.targetMeta;
-        const targetType = targetMeta.className;
-        const pivotMeta2 = new EntityMetadata({
-            name: prop.pivotTable,
-            className: prop.pivotTable,
-            collection: tableName,
-            schema: schemaName,
-            pivotTable: true,
-        });
-        prop.pivotEntity = pivotMeta2.class;
-        if (prop.fixedOrder) {
-            const primaryProp = this.defineFixedOrderProperty(prop, targetMeta);
-            pivotMeta2.properties[primaryProp.name] = primaryProp;
-        }
-        else {
-            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])) {
-            // 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));
-            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)) {
-                const childProp = childMeta.properties[prop.name];
-                if (childProp) {
-                    childProp.joinColumns = prop.joinColumns;
-                    childProp.inverseJoinColumns = prop.inverseJoinColumns;
-                }
-            }
-        }
-        // For polymorphic M:N, create discriminator column and polymorphic FK
-        if (prop.polymorphic && prop.discriminatorColumn) {
-            this.definePolymorphicPivotProperties(pivotMeta2, meta, prop, targetMeta);
-        }
-        else {
-            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);
-    }
-    /**
-     * Create a scalar property for a pivot table column.
-     */
-    createPivotScalarProperty(name, columnTypes, fieldNames = [name], options = {}) {
-        return {
-            name,
-            fieldNames,
-            columnTypes,
-            type: options.type ?? 'number',
-            kind: ReferenceKind.SCALAR,
-            primary: options.primary ?? false,
-            nullable: options.nullable ?? true,
-            ...(options.persist !== undefined && { persist: options.persist }),
-        };
-    }
-    /**
-     * Get column types for an entity's primary keys, initializing them if needed.
-     */
-    getPrimaryKeyColumnTypes(meta) {
-        const columnTypes = [];
-        for (const pk of meta.primaryKeys) {
-            const pkProp = meta.properties[pk];
-            this.initCustomType(meta, pkProp);
-            this.initColumnType(pkProp);
-            columnTypes.push(...pkProp.columnTypes);
-        }
-        return columnTypes;
-    }
-    /**
-     * Add missing FK columns for a polymorphic entity to an existing pivot table.
-     */
-    addPolymorphicPivotColumns(pivotMeta, meta, prop) {
-        const existingFieldNames = new Set(Object.values(pivotMeta.properties).flatMap(p => p.fieldNames ?? []));
-        const columnTypes = this.getPrimaryKeyColumnTypes(meta);
-        for (let i = 0; i < prop.joinColumns.length; i++) {
-            const joinColumn = prop.joinColumns[i];
-            if (!existingFieldNames.has(joinColumn)) {
-                pivotMeta.properties[joinColumn] = this.createPivotScalarProperty(joinColumn, [columnTypes[i]]);
-            }
-        }
-    }
-    /**
-     * Define properties for a polymorphic pivot table.
-     */
-    definePolymorphicPivotProperties(pivotMeta, meta, prop, targetMeta) {
-        const discriminatorColumn = prop.discriminatorColumn;
-        const isCompositePK = meta.compositePK;
-        // For composite PK polymorphic M:N, we need fixedOrder (auto-increment PK)
-        if (isCompositePK && !prop.fixedOrder) {
-            prop.fixedOrder = true;
-            const primaryProp = this.defineFixedOrderProperty(prop, targetMeta);
-            pivotMeta.properties[primaryProp.name] = primaryProp;
-            pivotMeta.compositePK = 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],
-                ]);
-            }
-            // Virtual property combining all columns (for compatibility)
-            pivotMeta.properties[prop.discriminator] = this.createPivotScalarProperty(prop.discriminator, columnTypes, [...prop.joinColumns], { type: meta.className, persist: false });
-        }
-        else {
-            pivotMeta.properties[prop.discriminator] = this.createPivotScalarProperty(prop.discriminator, columnTypes, [...prop.joinColumns], { type: meta.className, primary: true, nullable: false });
-        }
-        pivotMeta.properties[targetMeta.className + '_inverse'] = this.definePivotProperty(prop, targetMeta.className + '_inverse', targetMeta.class, prop.discriminator, false, false);
-        // Create virtual M:1 relation to the polymorphic owner for single-query join loading
-        const ownerRelationName = `${prop.discriminator}_${meta.tableName}`;
-        pivotMeta.properties[ownerRelationName] = this.definePolymorphicOwnerRelation(prop, ownerRelationName, meta);
+    return [];
+  }
+  findReferencingProperties(meta, metadata) {
+    for (const meta2 of metadata) {
+      for (const prop2 of meta2.relations) {
+        if (prop2.kind !== ReferenceKind.SCALAR && prop2.type === meta.className) {
+          meta.referencingProperties.push({ meta: meta2, prop: prop2 });
+        }
+      }
+    }
+  }
+  initFactoryField(meta, prop) {
+    ['mappedBy', 'inversedBy', 'pivotEntity'].forEach(type => {
+      const value = prop[type];
+      if (value instanceof Function) {
+        const meta2 = prop.targetMeta ?? this.#metadata.get(prop.target);
+        prop[type] = value(meta2.properties)?.name;
+        if (type === 'pivotEntity' && value) {
+          prop[type] = value(meta2.properties);
+        }
+        if (prop[type] == null) {
+          throw MetadataError.fromWrongReference(meta, prop, type);
+        }
+      }
+    });
+  }
+  ensureCorrectFKOrderInPivotEntity(meta, owner) {
+    const pks = Object.values(meta.properties).filter(p => p.primary);
+    const fks = Object.values(meta.properties).filter(p => p.kind === ReferenceKind.MANY_TO_ONE);
+    let first, second;
+    if (pks.length === 2) {
+      [first, second] = pks;
+    } else if (fks.length >= 2) {
+      [first, second] = fks;
+    } else {
+      /* v8 ignore next */
+      return [];
+    }
+    // wrong FK order, first FK needs to point to the owning side
+    // (note that we can detect this only if the FKs target different types)
+    if (owner.type === first.type && first.type !== second.type) {
+      delete meta.properties[first.name];
+      meta.removeProperty(first.name, false);
+      meta.addProperty(first);
+      [first, second] = [second, first];
+    }
+    return [first, second];
+  }
+  definePivotTableEntity(meta, prop) {
+    const pivotMeta = prop.pivotEntity
+      ? 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`;
+      prop.inversedBy = inverseName;
+      const inverseProp = {
+        name: inverseName,
+        kind: ReferenceKind.MANY_TO_MANY,
+        type: meta.className,
+        target: meta.class,
+        targetMeta: meta,
+        mappedBy: prop.name,
+        pivotEntity: prop.pivotEntity,
+        pivotTable: prop.pivotTable,
+        persist: false,
+        hydrate: false,
+      };
+      this.applyNamingStrategy(prop.targetMeta, inverseProp);
+      this.initCustomType(prop.targetMeta, inverseProp);
+      prop.targetMeta.properties[inverseName] = inverseProp;
+    }
+    if (pivotMeta) {
+      prop.pivotEntity = pivotMeta.class;
+      this.ensureCorrectFKOrderInPivotEntity(pivotMeta, prop);
+      if (prop.polymorphic && prop.discriminatorValue) {
         pivotMeta.polymorphicDiscriminatorMap ??= {};
         pivotMeta.polymorphicDiscriminatorMap[prop.discriminatorValue] = meta.class;
-    }
-    /**
-     * Create a virtual M:1 relation from pivot to a polymorphic owner entity.
-     * This enables single-query join loading for inverse-side polymorphic M:N.
-     */
-    definePolymorphicOwnerRelation(prop, name, targetMeta) {
-        const ret = {
-            name,
-            type: targetMeta.className,
-            target: targetMeta.class,
-            kind: ReferenceKind.MANY_TO_ONE,
-            nullable: true,
-            owner: true,
-            primary: false,
-            createForeignKeyConstraint: false,
-            persist: false,
-            index: false,
-        };
-        ret.targetMeta = targetMeta;
-        ret.fieldNames = ret.joinColumns = ret.ownColumns = [...prop.joinColumns];
-        ret.referencedColumnNames = [];
-        ret.inverseJoinColumns = [];
-        for (const primaryKey of targetMeta.primaryKeys) {
-            const pkProp = targetMeta.properties[primaryKey];
-            ret.referencedColumnNames.push(...pkProp.fieldNames);
-            ret.inverseJoinColumns.push(...pkProp.fieldNames);
-            ret.length = pkProp.length;
-            ret.precision = pkProp.precision;
-            ret.scale = pkProp.scale;
-        }
-        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 primaryProp = {
-            name: pk,
-            type: 'number',
-            runtimeType: 'number',
-            kind: ReferenceKind.SCALAR,
-            primary: true,
-            autoincrement: true,
-            unsigned: this.#platform.supportsUnsigned(),
-        };
-        this.initFieldName(primaryProp);
-        this.initColumnType(primaryProp);
-        prop.fixedOrderColumn = pk;
-        if (prop.inversedBy) {
-            const prop2 = targetMeta.properties[prop.inversedBy];
-            prop2.fixedOrder = true;
-            prop2.fixedOrderColumn = pk;
-        }
-        return primaryProp;
-    }
-    definePivotProperty(prop, name, type, inverse, owner, selfReferencing) {
-        const ret = {
-            name,
-            type: Utils.className(type),
-            target: type,
-            kind: ReferenceKind.MANY_TO_ONE,
-            cascade: [Cascade.ALL],
-            fixedOrder: prop.fixedOrder,
-            fixedOrderColumn: prop.fixedOrderColumn,
-            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';
-        ret.updateRule ??= defaultRule;
-        ret.deleteRule ??= defaultRule;
-        const meta = this.#metadata.get(type);
-        ret.targetMeta = meta;
-        ret.joinColumns = [];
-        ret.inverseJoinColumns = [];
-        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;
-            ret.inversedBy = inverse;
-            ret.referencedColumnNames = prop.referencedColumnNames;
-            ret.fieldNames = ret.joinColumns = prop.joinColumns;
-            ret.inverseJoinColumns = prop.referencedColumnNames;
-            meta.primaryKeys.forEach(primaryKey => {
-                const prop2 = meta.properties[primaryKey];
-                ret.length = prop2.length;
-                ret.precision = prop2.precision;
-                ret.scale = prop2.scale;
-            });
-        }
-        else {
-            ret.owner = false;
-            ret.mappedBy = inverse;
-            ret.fieldNames = ret.joinColumns = prop.inverseJoinColumns;
-            ret.referencedColumnNames = [];
-            ret.inverseJoinColumns = [];
-            meta.primaryKeys.forEach(primaryKey => {
-                const prop2 = meta.properties[primaryKey];
-                ret.referencedColumnNames.push(...prop2.fieldNames);
-                ret.inverseJoinColumns.push(...prop2.fieldNames);
-                ret.length = prop2.length;
-                ret.precision = prop2.precision;
-                ret.scale = prop2.scale;
-            });
-        }
-        this.initColumnType(ret);
-        this.initRelation(ret);
-        return ret;
-    }
-    autoWireBidirectionalProperties(meta) {
-        Object.values(meta.properties)
-            .filter(prop => prop.kind !== ReferenceKind.SCALAR && !prop.owner && prop.mappedBy)
-            .forEach(prop => {
-            const meta2 = prop.targetMeta;
-            const prop2 = meta2.properties[prop.mappedBy];
-            if (prop2 && !prop2.inversedBy) {
-                prop2.inversedBy = prop.name;
-            }
-        });
-    }
-    defineBaseEntityProperties(meta) {
-        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);
-        const ownProps = Object.values(meta.properties);
-        const old = ownProps.map(x => x.name);
-        meta.properties = {};
-        Object.values(base.properties).forEach(prop => {
-            if (!prop.inherited) {
-                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 => {
-                meta.properties[prop.name] = { ...prop };
-                meta.propertyOrder.set(prop.name, (order += 0.01));
-            });
-        }
-        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);
-        if (pks.length > 0 && meta.primaryKeys.length === 0) {
-            meta.primaryKeys = pks;
-        }
-        Utils.keys(base.hooks).forEach(type => {
-            meta.hooks[type] = Utils.unique([...base.hooks[type], ...(meta.hooks[type] || [])]);
+        // For composite PK entities sharing a polymorphic pivot table,
+        // we need to add columns for each entity type's PKs
+        this.addPolymorphicPivotColumns(pivotMeta, meta, prop);
+        // Add virtual M:1 relation for this polymorphic owner (for join loading)
+        const ownerRelationName = `${prop.discriminator}_${meta.tableName}`;
+        if (!pivotMeta.properties[ownerRelationName]) {
+          pivotMeta.properties[ownerRelationName] = this.definePolymorphicOwnerRelation(prop, ownerRelationName, meta);
+        }
+      }
+      return pivotMeta;
+    }
+    let tableName = prop.pivotTable;
+    let schemaName;
+    if (prop.pivotTable.includes('.')) {
+      [schemaName, tableName] = prop.pivotTable.split('.');
+    }
+    schemaName ??= meta.schema;
+    const targetMeta = prop.targetMeta;
+    const targetType = targetMeta.className;
+    const pivotMeta2 = new EntityMetadata({
+      name: prop.pivotTable,
+      className: prop.pivotTable,
+      collection: tableName,
+      schema: schemaName,
+      pivotTable: true,
+    });
+    prop.pivotEntity = pivotMeta2.class;
+    if (prop.fixedOrder) {
+      const primaryProp = this.defineFixedOrderProperty(prop, targetMeta);
+      pivotMeta2.properties[primaryProp.name] = primaryProp;
+    } else {
+      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])
+    ) {
+      // 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),
+      );
+      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)) {
+        const childProp = childMeta.properties[prop.name];
+        if (childProp) {
+          childProp.joinColumns = prop.joinColumns;
+          childProp.inverseJoinColumns = prop.inverseJoinColumns;
+        }
+      }
+    }
+    // For polymorphic M:N, create discriminator column and polymorphic FK
+    if (prop.polymorphic && prop.discriminatorColumn) {
+      this.definePolymorphicPivotProperties(pivotMeta2, meta, prop, targetMeta);
+    } else {
+      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);
+  }
+  /**
+   * Create a scalar property for a pivot table column.
+   */
+  createPivotScalarProperty(name, columnTypes, fieldNames = [name], options = {}) {
+    return {
+      name,
+      fieldNames,
+      columnTypes,
+      type: options.type ?? 'number',
+      kind: ReferenceKind.SCALAR,
+      primary: options.primary ?? false,
+      nullable: options.nullable ?? true,
+      ...(options.persist !== undefined && { persist: options.persist }),
+    };
+  }
+  /**
+   * Get column types for an entity's primary keys, initializing them if needed.
+   */
+  getPrimaryKeyColumnTypes(meta) {
+    const columnTypes = [];
+    for (const pk of meta.primaryKeys) {
+      const pkProp = meta.properties[pk];
+      this.initCustomType(meta, pkProp);
+      this.initColumnType(pkProp);
+      columnTypes.push(...pkProp.columnTypes);
+    }
+    return columnTypes;
+  }
+  /**
+   * Add missing FK columns for a polymorphic entity to an existing pivot table.
+   */
+  addPolymorphicPivotColumns(pivotMeta, meta, prop) {
+    const existingFieldNames = new Set(Object.values(pivotMeta.properties).flatMap(p => p.fieldNames ?? []));
+    const columnTypes = this.getPrimaryKeyColumnTypes(meta);
+    for (let i = 0; i < prop.joinColumns.length; i++) {
+      const joinColumn = prop.joinColumns[i];
+      if (!existingFieldNames.has(joinColumn)) {
+        pivotMeta.properties[joinColumn] = this.createPivotScalarProperty(joinColumn, [columnTypes[i]]);
+      }
+    }
+  }
+  /**
+   * Define properties for a polymorphic pivot table.
+   */
+  definePolymorphicPivotProperties(pivotMeta, meta, prop, targetMeta) {
+    const discriminatorColumn = prop.discriminatorColumn;
+    const isCompositePK = meta.compositePK;
+    // For composite PK polymorphic M:N, we need fixedOrder (auto-increment PK)
+    if (isCompositePK && !prop.fixedOrder) {
+      prop.fixedOrder = true;
+      const primaryProp = this.defineFixedOrderProperty(prop, targetMeta);
+      pivotMeta.properties[primaryProp.name] = primaryProp;
+      pivotMeta.compositePK = 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],
+        ]);
+      }
+      // Virtual property combining all columns (for compatibility)
+      pivotMeta.properties[prop.discriminator] = this.createPivotScalarProperty(
+        prop.discriminator,
+        columnTypes,
+        [...prop.joinColumns],
+        { type: meta.className, persist: false },
+      );
+    } else {
+      pivotMeta.properties[prop.discriminator] = this.createPivotScalarProperty(
+        prop.discriminator,
+        columnTypes,
+        [...prop.joinColumns],
+        { type: meta.className, primary: true, nullable: false },
+      );
+    }
+    pivotMeta.properties[targetMeta.className + '_inverse'] = this.definePivotProperty(
+      prop,
+      targetMeta.className + '_inverse',
+      targetMeta.class,
+      prop.discriminator,
+      false,
+      false,
+    );
+    // Create virtual M:1 relation to the polymorphic owner for single-query join loading
+    const ownerRelationName = `${prop.discriminator}_${meta.tableName}`;
+    pivotMeta.properties[ownerRelationName] = this.definePolymorphicOwnerRelation(prop, ownerRelationName, meta);
+    pivotMeta.polymorphicDiscriminatorMap ??= {};
+    pivotMeta.polymorphicDiscriminatorMap[prop.discriminatorValue] = meta.class;
+  }
+  /**
+   * Create a virtual M:1 relation from pivot to a polymorphic owner entity.
+   * This enables single-query join loading for inverse-side polymorphic M:N.
+   */
+  definePolymorphicOwnerRelation(prop, name, targetMeta) {
+    const ret = {
+      name,
+      type: targetMeta.className,
+      target: targetMeta.class,
+      kind: ReferenceKind.MANY_TO_ONE,
+      nullable: true,
+      owner: true,
+      primary: false,
+      createForeignKeyConstraint: false,
+      persist: false,
+      index: false,
+    };
+    ret.targetMeta = targetMeta;
+    ret.fieldNames = ret.joinColumns = ret.ownColumns = [...prop.joinColumns];
+    ret.referencedColumnNames = [];
+    ret.inverseJoinColumns = [];
+    for (const primaryKey of targetMeta.primaryKeys) {
+      const pkProp = targetMeta.properties[primaryKey];
+      ret.referencedColumnNames.push(...pkProp.fieldNames);
+      ret.inverseJoinColumns.push(...pkProp.fieldNames);
+      ret.length = pkProp.length;
+      ret.precision = pkProp.precision;
+      ret.scale = pkProp.scale;
+    }
+    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 primaryProp = {
+      name: pk,
+      type: 'number',
+      runtimeType: 'number',
+      kind: ReferenceKind.SCALAR,
+      primary: true,
+      autoincrement: true,
+      unsigned: this.#platform.supportsUnsigned(),
+    };
+    this.initFieldName(primaryProp);
+    this.initColumnType(primaryProp);
+    prop.fixedOrderColumn = pk;
+    if (prop.inversedBy) {
+      const prop2 = targetMeta.properties[prop.inversedBy];
+      prop2.fixedOrder = true;
+      prop2.fixedOrderColumn = pk;
+    }
+    return primaryProp;
+  }
+  definePivotProperty(prop, name, type, inverse, owner, selfReferencing) {
+    const ret = {
+      name,
+      type: Utils.className(type),
+      target: type,
+      kind: ReferenceKind.MANY_TO_ONE,
+      cascade: [Cascade.ALL],
+      fixedOrder: prop.fixedOrder,
+      fixedOrderColumn: prop.fixedOrderColumn,
+      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';
+    ret.updateRule ??= defaultRule;
+    ret.deleteRule ??= defaultRule;
+    const meta = this.#metadata.get(type);
+    ret.targetMeta = meta;
+    ret.joinColumns = [];
+    ret.inverseJoinColumns = [];
+    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;
+      ret.inversedBy = inverse;
+      ret.referencedColumnNames = prop.referencedColumnNames;
+      ret.fieldNames = ret.joinColumns = prop.joinColumns;
+      ret.inverseJoinColumns = prop.referencedColumnNames;
+      meta.primaryKeys.forEach(primaryKey => {
+        const prop2 = meta.properties[primaryKey];
+        ret.length = prop2.length;
+        ret.precision = prop2.precision;
+        ret.scale = prop2.scale;
+      });
+    } else {
+      ret.owner = false;
+      ret.mappedBy = inverse;
+      ret.fieldNames = ret.joinColumns = prop.inverseJoinColumns;
+      ret.referencedColumnNames = [];
+      ret.inverseJoinColumns = [];
+      meta.primaryKeys.forEach(primaryKey => {
+        const prop2 = meta.properties[primaryKey];
+        ret.referencedColumnNames.push(...prop2.fieldNames);
+        ret.inverseJoinColumns.push(...prop2.fieldNames);
+        ret.length = prop2.length;
+        ret.precision = prop2.precision;
+        ret.scale = prop2.scale;
+      });
+    }
+    this.initColumnType(ret);
+    this.initRelation(ret);
+    return ret;
+  }
+  autoWireBidirectionalProperties(meta) {
+    Object.values(meta.properties)
+      .filter(prop => prop.kind !== ReferenceKind.SCALAR && !prop.owner && prop.mappedBy)
+      .forEach(prop => {
+        const meta2 = prop.targetMeta;
+        const prop2 = meta2.properties[prop.mappedBy];
+        if (prop2 && !prop2.inversedBy) {
+          prop2.inversedBy = prop.name;
+        }
+      });
+  }
+  defineBaseEntityProperties(meta) {
+    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);
+    const ownProps = Object.values(meta.properties);
+    const old = ownProps.map(x => x.name);
+    meta.properties = {};
+    Object.values(base.properties).forEach(prop => {
+      if (!prop.inherited) {
+        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 => {
+          meta.properties[prop.name] = { ...prop };
+          meta.propertyOrder.set(prop.name, (order += 0.01));
         });
-        if ((meta.constructorParams?.length ?? 0) === 0 && (base.constructorParams?.length ?? 0) > 0) {
-            meta.constructorParams = [...base.constructorParams];
-        }
-        return order;
     }
-    initPolyEmbeddables(embeddedProp, discovered, visited = new Set()) {
-        if (embeddedProp.kind !== ReferenceKind.EMBEDDED || visited.has(embeddedProp)) {
-            return;
-        }
-        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));
-        // create virtual polymorphic entity
-        if (!embeddable && polymorphs.length > 0) {
-            const properties = {};
-            let discriminatorColumn;
-            const inlineProperties = (meta) => {
-                Object.values(meta.properties).forEach(prop => {
-                    // defaults on db level would mess up with change tracking
-                    delete prop.default;
-                    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];
-                    }
-                    // 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 => {
-                    return meta.extends && Utils.className(meta.extends) === m.className;
-                });
-                if (!parent) {
-                    return;
-                }
-                discriminatorColumn ??= parent.discriminatorColumn;
-                inlineProperties(parent);
-                processExtensions(parent);
-            };
-            polymorphs.forEach(meta => {
-                inlineProperties(meta);
-                processExtensions(meta);
-            });
-            const name = polymorphs
-                .map(t => t.className)
-                .sort()
-                .join(' | ');
-            embeddable = new EntityMetadata({
-                name,
-                className: name,
-                embeddable: true,
-                abstract: true,
-                properties,
-                polymorphs,
-                discriminatorColumn,
-            });
-            embeddable.sync();
-            discovered.push(embeddable);
-            polymorphs.forEach(meta => (meta.root = embeddable));
-        }
-    }
-    initPolymorphicRelation(meta, prop, discovered) {
-        if (!prop.discriminator && !prop.discriminatorColumn && !prop.discriminatorMap && !Array.isArray(prop.target)) {
-            return;
-        }
-        prop.polymorphic = true;
-        prop.discriminator ??= prop.name;
-        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) {
-            const types = prop.type.split(/ ?\| ?/);
-            prop.polymorphTargets = discovered.filter(m => types.includes(m.className) && !m.embeddable);
-            prop.targetMeta = prop.polymorphTargets[0];
-            prop.referencedPKs = prop.targetMeta?.primaryKeys;
-        }
-        if (prop.discriminatorMap) {
-            const normalizedMap = {};
-            for (const [key, value] of Object.entries(prop.discriminatorMap)) {
-                const targetMeta = this.#metadata.getByClassName(value, false);
-                if (!targetMeta) {
-                    throw MetadataError.fromUnknownEntity(value, `${meta.className}.${prop.name} discriminatorMap`);
-                }
-                normalizedMap[key] = targetMeta.class;
-                if (targetMeta.class === meta.class) {
-                    prop.discriminatorValue = key;
-                }
-            }
-            prop.discriminatorMap = normalizedMap;
-        }
-        else if (isToOne) {
-            prop.discriminatorMap = {};
-            const tableNameToTarget = new Map();
-            for (const target of prop.polymorphTargets) {
-                const existing = tableNameToTarget.get(target.tableName);
-                if (existing) {
-                    throw MetadataError.incompatiblePolymorphicTargets(meta, prop, existing, target, `both use table '${target.tableName}'. Use separate properties instead of a single polymorphic relation.`);
-                }
-                tableNameToTarget.set(target.tableName, target);
-                prop.discriminatorMap[target.tableName] = target.class;
-            }
-        }
-        else {
-            prop.discriminatorValue ??= meta.tableName;
-            if (!prop.discriminatorMap) {
-                prop.discriminatorMap = { [prop.discriminatorValue]: meta.class };
-            }
-        }
-    }
-    initEmbeddables(meta, embeddedProp, visited = new Set()) {
-        if (embeddedProp.kind !== ReferenceKind.EMBEDDED || visited.has(embeddedProp)) {
-            return;
-        }
-        visited.add(embeddedProp);
-        const embeddable = this.#discovered.find(m => m.name === embeddedProp.type);
-        if (!embeddable) {
-            throw MetadataError.fromUnknownEntity(embeddedProp.type, `${meta.className}.${embeddedProp.name}`);
-        }
-        embeddedProp.embeddable = embeddable.class;
-        embeddedProp.embeddedProps = {};
-        let order = meta.propertyOrder.get(embeddedProp.name);
-        const getRootProperty = (prop) => prop.embedded ? getRootProperty(meta.properties[prop.embedded[0]]) : prop;
-        const isParentObject = (prop) => {
-            if (prop.object || prop.array) {
-                return true;
-            }
-            return prop.embedded ? isParentObject(meta.properties[prop.embedded[0]]) : false;
-        };
-        const isParentArray = (prop) => {
-            if (prop.array) {
-                return true;
-            }
-            return prop.embedded ? isParentArray(meta.properties[prop.embedded[0]]) : false;
-        };
-        const rootProperty = getRootProperty(embeddedProp);
-        const parentProperty = meta.properties[embeddedProp.embedded?.[0] ?? ''];
-        const object = isParentObject(embeddedProp);
-        const array = isParentArray(embeddedProp);
-        this.initFieldName(embeddedProp, rootProperty !== embeddedProp && object);
-        // the prefix of the parent cannot be a boolean; it already passed here
-        const prefix = this.getPrefix(embeddedProp, parentProperty);
-        const glue = object ? '~' : '_';
-        for (const prop of Object.values(embeddable.properties)) {
-            const name = (embeddedProp.embeddedPath?.join(glue) ?? embeddedProp.fieldNames[0] + glue) + prop.name;
-            meta.properties[name] = Utils.copy(prop);
-            meta.properties[name].name = name;
-            meta.properties[name].embedded = [embeddedProp.name, prop.name];
-            meta.propertyOrder.set(name, (order += 0.01));
-            embeddedProp.embeddedProps[prop.name] = meta.properties[name];
-            meta.properties[name].persist ??= embeddedProp.persist;
-            const refInArray = array && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && prop.owner;
-            if (embeddedProp.nullable || refInArray) {
-                meta.properties[name].nullable = true;
-            }
-            if (meta.properties[name].fieldNames) {
-                meta.properties[name].fieldNames[0] = prefix + meta.properties[name].fieldNames[0];
-            }
-            else {
-                const name2 = meta.properties[name].name;
-                meta.properties[name].name = prefix + prop.name;
-                this.initFieldName(meta.properties[name]);
-                meta.properties[name].name = name2;
-            }
-            if (object) {
-                embeddedProp.object = true;
-                let path = [];
-                let tmp = embeddedProp;
-                while (tmp.embedded && tmp.object) {
-                    path.unshift(tmp.embedded[1]);
-                    tmp = meta.properties[tmp.embedded[0]];
-                }
-                if (tmp === rootProperty) {
-                    path.unshift(rootProperty.fieldNames[0]);
-                }
-                else if (embeddedProp.embeddedPath) {
-                    path = [...embeddedProp.embeddedPath];
-                }
-                else {
-                    path = [embeddedProp.fieldNames[0]];
-                }
-                this.initFieldName(prop, true);
-                this.initRelation(prop);
-                path.push(prop.fieldNames[0]);
-                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));
-                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
-                meta.properties[name].object = true;
-                this.initCustomType(meta, meta.properties[name], false, true);
-            }
-            this.initEmbeddables(meta, meta.properties[name], visited);
-        }
-        for (const index of embeddable.indexes) {
-            meta.indexes.push({
-                ...index,
-                properties: Utils.asArray(index.properties).map(p => {
-                    return embeddedProp.embeddedProps[p].name;
-                }),
-            });
-        }
-        for (const unique of embeddable.uniques) {
-            meta.uniques.push({
-                ...unique,
-                properties: Utils.asArray(unique.properties).map(p => {
-                    return embeddedProp.embeddedProps[p].name;
-                }),
-            });
-        }
-    }
-    sameRelationTargetRoot(rootProp, prop) {
-        if (!rootProp || rootProp.kind !== prop.kind) {
-            return false;
-        }
-        if (prop.kind !== ReferenceKind.MANY_TO_ONE &&
-            prop.kind !== ReferenceKind.ONE_TO_ONE &&
-            prop.kind !== ReferenceKind.ONE_TO_MANY &&
-            prop.kind !== ReferenceKind.MANY_TO_MANY) {
-            return false;
-        }
-        const aRoot = this.#metadata.getByClassName(prop.type, false)?.root;
-        return aRoot != null && aRoot === this.#metadata.getByClassName(rootProp.type, false)?.root;
-    }
-    initSingleTableInheritance(meta, metadata) {
-        if (meta.root !== meta && !meta.__processed) {
-            meta.root = metadata.find(m => m.class === meta.root.class);
-            meta.root.__processed = true;
-        }
-        else {
-            delete meta.root.__processed;
-        }
-        if (!meta.root.discriminatorColumn) {
-            return;
-        }
-        meta.root.inheritanceType = 'sti';
-        if (meta.root.discriminatorMap) {
-            const map = meta.root.discriminatorMap;
-            Object.keys(map)
-                .filter(key => typeof map[key] === 'string')
-                .forEach(key => (map[key] = this.#metadata.getByClassName(map[key]).class));
-        }
-        else {
-            meta.root.discriminatorMap = {};
-            const children = metadata
-                .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);
-                meta.root.discriminatorMap[name] = m.class;
-            }
-        }
-        meta.discriminatorValue = QueryHelper.findDiscriminatorValue(meta.root.discriminatorMap, meta.class);
-        if (!meta.root.properties[meta.root.discriminatorColumn]) {
-            this.createDiscriminatorProperty(meta.root);
-        }
-        Utils.defaultValue(meta.root.properties[meta.root.discriminatorColumn], 'items', Object.keys(meta.root.discriminatorMap));
-        Utils.defaultValue(meta.root.properties[meta.root.discriminatorColumn], 'index', true);
-        if (meta.root === meta) {
-            return;
-        }
+    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);
+    if (pks.length > 0 && meta.primaryKeys.length === 0) {
+      meta.primaryKeys = pks;
+    }
+    Utils.keys(base.hooks).forEach(type => {
+      meta.hooks[type] = Utils.unique([...base.hooks[type], ...(meta.hooks[type] || [])]);
+    });
+    if ((meta.constructorParams?.length ?? 0) === 0 && (base.constructorParams?.length ?? 0) > 0) {
+      meta.constructorParams = [...base.constructorParams];
+    }
+    return order;
+  }
+  initPolyEmbeddables(embeddedProp, discovered, visited = new Set()) {
+    if (embeddedProp.kind !== ReferenceKind.EMBEDDED || visited.has(embeddedProp)) {
+      return;
+    }
+    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));
+    // create virtual polymorphic entity
+    if (!embeddable && polymorphs.length > 0) {
+      const properties = {};
+      let discriminatorColumn;
+      const inlineProperties = meta => {
         Object.values(meta.properties).forEach(prop => {
-            const newProp = { ...prop };
-            const rootProp = meta.root.properties[prop.name];
-            // A child that narrows a relation to a subclass of the root's declared
-            // target (same STI hierarchy) shares the FK column with the root; treat
-            // that as matching so the rename branch below doesn't run (which would
-            // crash — `targetMeta` is only populated later, in `initRelation`).
-            const narrowedRelationOverride = rootProp != null && rootProp.type !== prop.type && this.sameRelationTargetRoot(rootProp, prop);
-            // 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 || narrowedRelationOverride;
-            // Inverse-side relations (1:m, inverse m:n) have no FK column on this
-            // entity, so the rename branch — which exists to disambiguate physical
-            // columns shared across STI children — doesn't apply. Skipping it also
-            // avoids crashing on `[...rootProp.fieldNames]` since fieldNames is
-            // never populated for inverse-side properties.
-            const isInverseSideRelation = prop.kind === ReferenceKind.ONE_TO_MANY || (prop.kind === ReferenceKind.MANY_TO_MANY && !prop.owner);
-            if (rootProp &&
-                !isInverseSideRelation &&
-                (!typesMatch ||
-                    (rootProp.fieldNames && prop.fieldNames && !compareArrays(rootProp.fieldNames, prop.fieldNames)))) {
-                const name = newProp.name;
-                this.initFieldName(newProp, newProp.object);
-                newProp.renamedFrom = name;
-                newProp.name = `${name}_${meta._id}`;
-                meta.root.addProperty(newProp);
-                this.initFieldName(prop, prop.object);
-                // Track all field variants and map discriminator values to field names
-                if (!rootProp.stiFieldNames) {
-                    this.initFieldName(rootProp, rootProp.object);
-                    rootProp.stiFieldNames = [...rootProp.fieldNames];
-                    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)) {
-                            rootProp.stiFieldNameMap[discValue] = rootProp.fieldNames[0];
-                            break;
-                        }
-                    }
-                }
-                rootProp.stiFieldNameMap[meta.discriminatorValue] = prop.fieldNames[0];
-                rootProp.stiFieldNames.push(...prop.fieldNames);
-                newProp.nullable = true;
-                newProp.name = name;
-                newProp.hydrate = false;
-                newProp.inherited = true;
-                return;
-            }
-            if (prop.enum && prop.items && rootProp?.items) {
-                newProp.items = Utils.unique([...rootProp.items, ...prop.items]);
-            }
-            // When multiple STI children share the same unique relation (OneToOne/ManyToOne),
-            // replace the simple unique with a composite one including the discriminator column
-            // so different subtypes can independently reference the same target row.
-            if (rootProp?.unique &&
-                newProp.unique &&
-                [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(newProp.kind)) {
-                newProp.unique = false;
-                rootProp.unique = false;
-                meta.root.uniques.push({
-                    properties: [prop.name, meta.root.discriminatorColumn],
-                });
-            }
-            newProp.nullable = true;
-            newProp.inherited = !rootProp;
-            // For narrowed relation overrides, keep the root's declaration intact so
-            // the full target union (e.g. `Food`) is preserved for populates from the
-            // abstract root — otherwise the last child processed would win.
-            if (narrowedRelationOverride) {
-                return;
-            }
-            // STI siblings can declare the same property name on inverse-side relations
-            // pointing to disjoint targets (e.g. `Dog.items → DogItem` and
-            // `Cat.items → CatItem` with no shared base). There's no physical column
-            // to manage at root, and propagating would clobber the first child's
-            // declaration; each child keeps its local typed property instead.
-            if (isInverseSideRelation && rootProp && rootProp.type !== prop.type) {
-                return;
-            }
-            meta.root.addProperty(newProp);
+          // defaults on db level would mess up with change tracking
+          delete prop.default;
+          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];
+          }
+          // 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));
         });
-        meta.tableName = meta.root.tableName;
-        meta.root.indexes = Utils.unique([...meta.root.indexes, ...meta.indexes]);
-        meta.root.uniques = Utils.unique([...meta.root.uniques, ...meta.uniques]);
-        meta.root.checks = Utils.unique([...meta.root.checks, ...meta.checks]);
-    }
-    /**
-     * First pass of TPT initialization: sets up hierarchy relationships
-     * (inheritanceType, tptParent, tptChildren) before properties have fieldNames.
-     */
-    initTPTRelationships(meta, metadata) {
-        if (meta.root !== meta) {
-            meta.root = metadata.find(m => m.class === meta.root.class);
-        }
-        // init the root eagerly so children iterated before the root (e.g. alphabetical glob order) still get linked
-        if (meta.root.inheritance === 'tpt' && meta.root.inheritanceType !== 'tpt') {
-            meta.root.inheritanceType = 'tpt';
-            meta.root.tptChildren ??= [];
-        }
-        if (meta.root.inheritanceType !== 'tpt') {
-            return;
-        }
-        const parent = this.getTPTParent(meta, metadata);
-        if (parent) {
-            meta.tptParent = parent;
-            meta.inheritanceType = 'tpt';
-            parent.tptChildren ??= [];
-            if (!parent.tptChildren.includes(meta)) {
-                parent.tptChildren.push(meta);
-            }
-        }
-    }
-    /**
-     * Second pass of TPT initialization: re-resolves metadata references after fieldNames
-     * are set, syncs to registry metadata, and sets up discriminators.
-     */
-    finalizeTPTInheritance(meta, metadata) {
-        if (meta.inheritanceType !== 'tpt') {
-            return;
-        }
-        if (meta.tptParent) {
-            meta.tptParent = metadata.find(m => m.class === meta.tptParent.class) ?? meta.tptParent;
-        }
-        if (meta.tptChildren) {
-            meta.tptChildren = meta.tptChildren.map(child => metadata.find(m => m.class === child.class) ?? child);
-        }
-        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));
-        }
-        this.initTPTDiscriminator(meta, metadata);
-    }
-    /**
-     * Initialize TPT discriminator map and virtual discriminator property.
-     * Unlike STI where the discriminator is a persisted column, TPT discriminator is computed
-     * at query time using CASE WHEN expressions based on which child table has data.
-     */
-    initTPTDiscriminator(meta, metadata) {
-        const allDescendants = this.collectAllTPTDescendants(meta, metadata);
-        allDescendants.sort((a, b) => this.getTPTDepth(b) - this.getTPTDepth(a));
-        meta.allTPTDescendants = allDescendants;
-        if (meta.root !== meta) {
-            return;
-        }
-        meta.root.discriminatorMap = {};
-        for (const m of allDescendants) {
-            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);
-            meta.root.discriminatorMap[name] = meta.class;
-            meta.discriminatorValue = name;
-        }
-        // Virtual discriminator property - computed at query time via CASE WHEN, not persisted
-        const discriminatorColumn = '__tpt_type';
-        if (!meta.root.properties[discriminatorColumn]) {
-            meta.root.addProperty({
-                name: discriminatorColumn,
-                type: 'string',
-                kind: ReferenceKind.SCALAR,
-                persist: false,
-                userDefined: false,
-                hidden: true,
-            });
-        }
-        meta.root.tptDiscriminatorColumn = discriminatorColumn;
-    }
-    /**
-     * Recursively collect all TPT descendants (children, grandchildren, etc.)
-     */
-    collectAllTPTDescendants(meta, metadata) {
-        const descendants = [];
-        const collect = (parent) => {
-            for (const child of parent.tptChildren ?? []) {
-                const resolved = metadata.find(m => m.class === child.class) ?? child;
-                if (!resolved.abstract) {
-                    descendants.push(resolved);
-                }
-                collect(resolved);
-            }
-        };
-        collect(meta);
-        return descendants;
-    }
-    /**
-     * Computes ownProps for TPT entities - only properties defined in THIS entity,
-     * not inherited from parent. Also creates synthetic join properties for parent/child relationships.
-     *
-     * Called multiple times during discovery as metadata is progressively built.
-     * Each pass overwrites earlier results to reflect the final state of properties.
-     */
-    computeTPTOwnProps(meta) {
-        if (meta.inheritanceType !== 'tpt') {
-            return;
-        }
-        const belongsToTable = (prop) => prop.persist !== false || prop.primary;
-        // Use meta.properties (object) since meta.props (array) may not be populated yet
-        const allProps = Object.values(meta.properties);
-        if (!meta.tptParent) {
-            meta.ownProps = allProps.filter(belongsToTable);
-            return;
-        }
-        const parentPropNames = new Set(Object.values(meta.tptParent.properties).map(p => p.name));
-        meta.ownProps = allProps.filter(prop => !parentPropNames.has(prop.name) && belongsToTable(prop));
-        // Create synthetic join properties for the parent-child relationship
-        const childFieldNames = meta.getPrimaryProps().flatMap(p => p.fieldNames);
-        const parentFieldNames = meta.tptParent.getPrimaryProps().flatMap(p => p.fieldNames);
-        meta.tptParentProp = {
-            name: '[tpt:parent]',
-            kind: ReferenceKind.MANY_TO_ONE,
-            targetMeta: meta.tptParent,
-            fieldNames: childFieldNames,
-            referencedColumnNames: parentFieldNames,
-            persist: false,
-        };
-        meta.tptInverseProp = {
-            name: '[tpt:child]',
-            kind: ReferenceKind.ONE_TO_ONE,
-            owner: true,
-            targetMeta: meta,
-            fieldNames: parentFieldNames,
-            joinColumns: parentFieldNames,
-            referencedColumnNames: childFieldNames,
-            persist: false,
-        };
-    }
-    /** Returns the depth of a TPT entity in its hierarchy (0 for root). */
-    getTPTDepth(meta) {
-        let depth = 0;
-        let current = meta;
-        while (current.tptParent) {
-            depth++;
-            current = current.tptParent;
-        }
-        return depth;
-    }
-    /**
-     * Find the direct TPT parent entity for the given entity.
-     */
-    getTPTParent(meta, metadata) {
-        if (meta.root === meta) {
-            return undefined;
-        }
-        return metadata.find(m => {
-            const ext = meta.extends;
-            if (EntitySchema.is(ext)) {
-                return m.class === ext.meta.class || m.className === ext.meta.className;
-            }
-            return m.class === ext || m.className === Utils.className(ext);
-        });
-    }
-    createDiscriminatorProperty(meta) {
-        meta.addProperty({
-            name: meta.discriminatorColumn,
-            type: 'string',
-            enum: true,
-            kind: ReferenceKind.SCALAR,
-            userDefined: false,
+      };
+      const processExtensions = meta => {
+        const parent = this.#discovered.find(m => {
+          return meta.extends && Utils.className(meta.extends) === m.className;
         });
-    }
-    initAutoincrement(meta) {
-        const pks = meta.getPrimaryProps();
-        if (pks.length === 1 && this.#platform.isNumericProperty(pks[0])) {
-            /* v8 ignore next */
-            pks[0].autoincrement ??= true;
-        }
-    }
-    createSchemaTable(meta) {
-        const qualifiedName = meta.schema ? `${meta.schema}.${meta.tableName}` : meta.tableName;
-        return {
-            name: meta.tableName,
-            schema: meta.schema,
-            qualifiedName,
-            toString: () => qualifiedName,
-        };
-    }
-    initCheckConstraints(meta) {
-        const columns = meta.createSchemaColumnMappingObject();
-        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');
-            if (check.expression instanceof Function) {
-                check.expression = check.expression(columns, table);
-            }
-        }
-        if (this.#platform.usesEnumCheckConstraints() && !meta.embeddable) {
-            // Iterate `meta.properties` rather than `meta.props` — by this point in
-            // the discovery pipeline `initEmbeddables` has added flattened embedded
-            // properties to `meta.properties`, but `meta.sync()` has not yet been
-            // called, so `meta.props` is still the pre-flatten array and would miss
-            // enum properties that live inside embeddables.
-            for (const prop of Object.values(meta.properties)) {
-                if (prop.persist === false || prop.nativeEnumName || !prop.items?.every(item => typeof item === 'string')) {
-                    continue;
-                }
-                this.initFieldName(prop);
-                let expression = null;
-                if (prop.enum) {
-                    expression = this.#platform.getEnumCheckConstraintExpression(prop.fieldNames[0], prop.items);
-                }
-                else if (prop.array) {
-                    expression = this.#platform.getEnumArrayCheckConstraintExpression(prop.fieldNames[0], prop.items);
-                }
-                if (expression) {
-                    meta.checks.push({
-                        name: this.#namingStrategy.indexName(meta.tableName, prop.fieldNames, 'check'),
-                        property: prop.name,
-                        expression,
-                    });
-                }
-            }
-        }
-    }
-    initGeneratedColumn(meta, prop) {
-        if (!prop.generated && prop.columnTypes) {
-            const match = /(.*) generated always as (.*)/i.exec(prop.columnTypes[0]);
-            if (match) {
-                prop.columnTypes[0] = match[1];
-                prop.generated = match[2];
-                return;
-            }
-            const match2 = /^as (.*)/i.exec(prop.columnTypes[0]?.trim());
-            if (match2) {
-                prop.generated = match2[1];
-            }
-            return;
-        }
-        if (prop.generated instanceof Function) {
-            const columns = meta.createSchemaColumnMappingObject();
-            prop.generated = prop.generated(columns, this.createSchemaTable(meta));
-        }
-    }
-    getDefaultVersionValue(meta, prop) {
-        if (typeof prop.defaultRaw !== 'undefined') {
-            return prop.defaultRaw;
-        }
-        /* v8 ignore next */
-        if (prop.default != null) {
-            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);
-        }
-        return '1';
-    }
-    inferDefaultValue(meta, prop) {
-        try {
-            // try to create two entity instances to detect the value is stable
-            const now = Date.now();
-            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) {
-                prop.default ??= entity1[prop.name];
-            }
-            // if the default value is null, infer nullability
-            if (entity1[prop.name] === null) {
-                prop.nullable ??= true;
-            }
-            // but still use object values for type inference if not explicitly set, e.g. `createdAt = new Date()`
-            if (prop.kind === ReferenceKind.SCALAR && prop.type == null && entity1[prop.name] != null) {
-                prop.type = prop.runtimeType = Utils.getObjectType(entity1[prop.name]);
-            }
-        }
-        catch {
-            // ignore
-        }
-    }
-    initDefaultValue(prop) {
-        if (prop.defaultRaw || !('default' in prop)) {
-            return;
-        }
-        let val = prop.default;
-        const raw = Raw.getKnownFragment(val);
-        if (raw) {
-            prop.defaultRaw = this.#platform.formatQuery(raw.sql, raw.params);
-            return;
-        }
-        // TODO(v8): always convert the default via the custom type — the `compareAsType() !== 'any'`
-        // guard preserves the legacy convention where JSON defaults are passed pre-stringified.
-        // Array defaults are converted unconditionally (e.g. `default: []` on a JSON-backed embedded array).
-        if (prop.customType && (Array.isArray(prop.default) || prop.customType.compareAsType() !== 'any')) {
-            val = prop.customType.convertToDatabaseValue(prop.default, this.#platform);
-        }
-        prop.defaultRaw = typeof val === 'string' ? `'${val}'` : '' + val;
-    }
-    inferTypeFromDefault(prop) {
-        if ((prop.defaultRaw == null && prop.default == null) || prop.type !== 'any') {
-            return;
-        }
-        switch (typeof prop.default) {
-            case 'string':
-                prop.type = prop.runtimeType = 'string';
-                break;
-            case 'number':
-                prop.type = prop.runtimeType = 'number';
-                break;
-            case 'boolean':
-                prop.type = prop.runtimeType = 'boolean';
-                break;
-        }
-        if (prop.defaultRaw?.startsWith('current_timestamp')) {
-            prop.type = prop.runtimeType = 'Date';
-        }
-    }
-    initVersionProperty(meta, prop) {
-        if (prop.version) {
-            this.initDefaultValue(prop);
-            meta.versionProperty = prop.name;
-            prop.defaultRaw = this.getDefaultVersionValue(meta, prop);
-        }
-        if (prop.concurrencyCheck && !prop.primary) {
-            meta.concurrencyCheckKeys.add(prop.name);
-        }
-    }
-    initCustomType(meta, prop, simple = false, objectEmbeddable = false) {
-        // `prop.type` might be actually instance of custom type class
-        if (Type.isMappedType(prop.type) && !prop.customType) {
-            prop.customType = prop.type;
-            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 the type is an ORM defined mapped type without `ensureComparable: true`,
-            // we use just the type name, to have more performant hydration code
-            const brand = Type.getOrmType(prop.type);
-            const type = Utils.keys(t).find(type => {
-                return (!Type.getType(t[type]).ensureComparable(meta, prop) && (prop.type === t[type] || brand === type));
-            });
-            if (type) {
-                prop.type = type === 'datetime' ? 'Date' : type;
-            }
-            else {
-                prop.customType = new prop.type();
-                prop.type = prop.customType.constructor.name;
-            }
-        }
-        if (simple) {
-            return;
-        }
-        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])) {
-            prop.customType = new t.json();
-        }
-        if (prop.kind === ReferenceKind.EMBEDDED && !prop.customType && (prop.object || prop.array)) {
-            prop.customType = new t.json();
-        }
-        if (!prop.customType && prop.array && prop.items) {
-            prop.customType = new t.enumArray(`${meta.className}.${prop.name}`, prop.items);
-        }
-        const isArray = prop.type?.toLowerCase() === 'array' || prop.type?.toString().endsWith('[]');
-        if (objectEmbeddable && !prop.customType && isArray) {
-            prop.customType = new t.json();
-        }
-        // for number arrays we make sure to convert the items to numbers
-        if (!prop.customType && prop.type === 'number[]') {
-            prop.customType = new t.array(i => +i);
-        }
-        // `string[]` can be returned via ts-morph, while reflect metadata will give us just `array`
-        if (!prop.customType && isArray) {
-            prop.customType = new t.array();
-        }
-        if (!prop.customType && prop.type?.toLowerCase() === 'buffer') {
-            prop.customType = new t.blob();
-        }
-        if (!prop.customType && prop.type?.toLowerCase() === 'uint8array') {
-            prop.customType = new t.uint8array();
-        }
-        const mappedType = this.getMappedType(prop);
-        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()));
-        }
-        if (prop.customType && !prop.columnTypes) {
-            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;
-            }
-            else {
-                prop.runtimeType ??= prop.customType.runtimeType;
-            }
-        }
-        else if (prop.runtimeType === 'object') {
-            prop.runtimeType = mappedType.runtimeType;
-        }
-        else {
-            prop.runtimeType ??= mappedType.runtimeType;
-        }
-        if (prop.customType) {
-            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.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) {
-            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) !== '';
-                    /* v8 ignore next */
-                    prop.hasConvertToDatabaseValueSQL ||=
-                        !!pk.customType.convertToDatabaseValueSQL &&
-                            pk.customType.convertToDatabaseValueSQL('', this.#platform) !== '';
-                }
-                else {
-                    prop.customTypes.push(undefined);
-                }
-            }
-        }
-        if (prop.kind === ReferenceKind.SCALAR && !(mappedType instanceof t.unknown)) {
-            if (prop.nativeEnumName &&
-                meta.schema !== this.#platform.getDefaultSchemaName() &&
-                meta.schema &&
-                !prop.nativeEnumName.includes('.')) {
-                const suffix = prop.columnTypes?.[0]?.endsWith('[]') ? '[]' : '';
-                prop.columnTypes = [`${meta.schema}.${prop.nativeEnumName}${suffix}`];
-            }
-            else {
-                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
-            if (!Object.values(t).some(type => type === mappedType.constructor)) {
-                prop.customType ??= mappedType;
-            }
-        }
-    }
-    initRelation(prop) {
-        if (prop.kind === ReferenceKind.SCALAR || prop.polymorphTargets) {
-            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);
-        // If targetKey is specified, use that property instead of PKs for referencedPKs
-        prop.referencedPKs = prop.targetKey ? [prop.targetKey] : meta2.primaryKeys;
-        prop.targetMeta = meta2;
-        if (meta2.view) {
-            prop.createForeignKeyConstraint = false;
-        }
-        // 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) {
-            this.initFieldName(prop);
-            if (prop.fieldNames?.length === 1) {
-                prop.formula = table => `${table}.${this.#platform.quoteIdentifier(prop.fieldNames[0])}`;
-            }
-        }
-    }
-    initColumnType(prop) {
-        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()
-            : [];
-        targetProps.map(targetProp => {
-            prop.length ??= targetProp.length;
-            prop.precision ??= targetProp.precision;
-            prop.scale ??= targetProp.scale;
+        if (!parent) {
+          return;
+        }
+        discriminatorColumn ??= parent.discriminatorColumn;
+        inlineProperties(parent);
+        processExtensions(parent);
+      };
+      polymorphs.forEach(meta => {
+        inlineProperties(meta);
+        processExtensions(meta);
+      });
+      const name = polymorphs
+        .map(t => t.className)
+        .sort()
+        .join(' | ');
+      embeddable = new EntityMetadata({
+        name,
+        className: name,
+        embeddable: true,
+        abstract: true,
+        properties,
+        polymorphs,
+        discriminatorColumn,
+      });
+      embeddable.sync();
+      discovered.push(embeddable);
+      polymorphs.forEach(meta => (meta.root = embeddable));
+    }
+  }
+  initPolymorphicRelation(meta, prop, discovered) {
+    if (!prop.discriminator && !prop.discriminatorColumn && !prop.discriminatorMap && !Array.isArray(prop.target)) {
+      return;
+    }
+    prop.polymorphic = true;
+    prop.discriminator ??= prop.name;
+    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) {
+      const types = prop.type.split(/ ?\| ?/);
+      prop.polymorphTargets = discovered.filter(m => types.includes(m.className) && !m.embeddable);
+      prop.targetMeta = prop.polymorphTargets[0];
+      prop.referencedPKs = prop.targetMeta?.primaryKeys;
+    }
+    if (prop.discriminatorMap) {
+      const normalizedMap = {};
+      for (const [key, value] of Object.entries(prop.discriminatorMap)) {
+        const targetMeta = this.#metadata.getByClassName(value, false);
+        if (!targetMeta) {
+          throw MetadataError.fromUnknownEntity(value, `${meta.className}.${prop.name} discriminatorMap`);
+        }
+        normalizedMap[key] = targetMeta.class;
+        if (targetMeta.class === meta.class) {
+          prop.discriminatorValue = key;
+        }
+      }
+      prop.discriminatorMap = normalizedMap;
+    } else if (isToOne) {
+      prop.discriminatorMap = {};
+      const tableNameToTarget = new Map();
+      for (const target of prop.polymorphTargets) {
+        const existing = tableNameToTarget.get(target.tableName);
+        if (existing) {
+          throw MetadataError.incompatiblePolymorphicTargets(
+            meta,
+            prop,
+            existing,
+            target,
+            `both use table '${target.tableName}'. Use separate properties instead of a single polymorphic relation.`,
+          );
+        }
+        tableNameToTarget.set(target.tableName, target);
+        prop.discriminatorMap[target.tableName] = target.class;
+      }
+    } else {
+      prop.discriminatorValue ??= meta.tableName;
+      if (!prop.discriminatorMap) {
+        prop.discriminatorMap = { [prop.discriminatorValue]: meta.class };
+      }
+    }
+  }
+  initEmbeddables(meta, embeddedProp, visited = new Set()) {
+    if (embeddedProp.kind !== ReferenceKind.EMBEDDED || visited.has(embeddedProp)) {
+      return;
+    }
+    visited.add(embeddedProp);
+    const embeddable = this.#discovered.find(m => m.name === embeddedProp.type);
+    if (!embeddable) {
+      throw MetadataError.fromUnknownEntity(embeddedProp.type, `${meta.className}.${embeddedProp.name}`);
+    }
+    embeddedProp.embeddable = embeddable.class;
+    embeddedProp.embeddedProps = {};
+    let order = meta.propertyOrder.get(embeddedProp.name);
+    const getRootProperty = prop => (prop.embedded ? getRootProperty(meta.properties[prop.embedded[0]]) : prop);
+    const isParentObject = prop => {
+      if (prop.object || prop.array) {
+        return true;
+      }
+      return prop.embedded ? isParentObject(meta.properties[prop.embedded[0]]) : false;
+    };
+    const isParentArray = prop => {
+      if (prop.array) {
+        return true;
+      }
+      return prop.embedded ? isParentArray(meta.properties[prop.embedded[0]]) : false;
+    };
+    const rootProperty = getRootProperty(embeddedProp);
+    const parentProperty = meta.properties[embeddedProp.embedded?.[0] ?? ''];
+    const object = isParentObject(embeddedProp);
+    const array = isParentArray(embeddedProp);
+    this.initFieldName(embeddedProp, rootProperty !== embeddedProp && object);
+    // the prefix of the parent cannot be a boolean; it already passed here
+    const prefix = this.getPrefix(embeddedProp, parentProperty);
+    const glue = object ? '~' : '_';
+    for (const prop of Object.values(embeddable.properties)) {
+      const name = (embeddedProp.embeddedPath?.join(glue) ?? embeddedProp.fieldNames[0] + glue) + prop.name;
+      meta.properties[name] = Utils.copy(prop);
+      meta.properties[name].name = name;
+      meta.properties[name].embedded = [embeddedProp.name, prop.name];
+      meta.propertyOrder.set(name, (order += 0.01));
+      embeddedProp.embeddedProps[prop.name] = meta.properties[name];
+      meta.properties[name].persist ??= embeddedProp.persist;
+      const refInArray =
+        array && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && prop.owner;
+      if (embeddedProp.nullable || refInArray) {
+        meta.properties[name].nullable = true;
+      }
+      if (meta.properties[name].fieldNames) {
+        meta.properties[name].fieldNames[0] = prefix + meta.properties[name].fieldNames[0];
+      } else {
+        const name2 = meta.properties[name].name;
+        meta.properties[name].name = prefix + prop.name;
+        this.initFieldName(meta.properties[name]);
+        meta.properties[name].name = name2;
+      }
+      if (object) {
+        embeddedProp.object = true;
+        let path = [];
+        let tmp = embeddedProp;
+        while (tmp.embedded && tmp.object) {
+          path.unshift(tmp.embedded[1]);
+          tmp = meta.properties[tmp.embedded[0]];
+        }
+        if (tmp === rootProperty) {
+          path.unshift(rootProperty.fieldNames[0]);
+        } else if (embeddedProp.embeddedPath) {
+          path = [...embeddedProp.embeddedPath];
+        } else {
+          path = [embeddedProp.fieldNames[0]];
+        }
+        this.initFieldName(prop, true);
+        this.initRelation(prop);
+        path.push(prop.fieldNames[0]);
+        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),
+        );
+        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
+        meta.properties[name].object = true;
+        this.initCustomType(meta, meta.properties[name], false, true);
+      }
+      this.initEmbeddables(meta, meta.properties[name], visited);
+    }
+    for (const index of embeddable.indexes) {
+      meta.indexes.push({
+        ...index,
+        properties: Utils.asArray(index.properties).map(p => {
+          return embeddedProp.embeddedProps[p].name;
+        }),
+      });
+    }
+    for (const unique of embeddable.uniques) {
+      meta.uniques.push({
+        ...unique,
+        properties: Utils.asArray(unique.properties).map(p => {
+          return embeddedProp.embeddedProps[p].name;
+        }),
+      });
+    }
+  }
+  sameRelationTargetRoot(rootProp, prop) {
+    if (!rootProp || rootProp.kind !== prop.kind) {
+      return false;
+    }
+    if (
+      prop.kind !== ReferenceKind.MANY_TO_ONE &&
+      prop.kind !== ReferenceKind.ONE_TO_ONE &&
+      prop.kind !== ReferenceKind.ONE_TO_MANY &&
+      prop.kind !== ReferenceKind.MANY_TO_MANY
+    ) {
+      return false;
+    }
+    const aRoot = this.#metadata.getByClassName(prop.type, false)?.root;
+    return aRoot != null && aRoot === this.#metadata.getByClassName(rootProp.type, false)?.root;
+  }
+  initSingleTableInheritance(meta, metadata) {
+    if (meta.root !== meta && !meta.__processed) {
+      meta.root = metadata.find(m => m.class === meta.root.class);
+      meta.root.__processed = true;
+    } else {
+      delete meta.root.__processed;
+    }
+    if (!meta.root.discriminatorColumn) {
+      return;
+    }
+    meta.root.inheritanceType = 'sti';
+    if (meta.root.discriminatorMap) {
+      const map = meta.root.discriminatorMap;
+      Object.keys(map)
+        .filter(key => typeof map[key] === 'string')
+        .forEach(key => (map[key] = this.#metadata.getByClassName(map[key]).class));
+    } else {
+      meta.root.discriminatorMap = {};
+      const children = metadata
+        .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);
+        meta.root.discriminatorMap[name] = m.class;
+      }
+    }
+    meta.discriminatorValue = QueryHelper.findDiscriminatorValue(meta.root.discriminatorMap, meta.class);
+    if (!meta.root.properties[meta.root.discriminatorColumn]) {
+      this.createDiscriminatorProperty(meta.root);
+    }
+    Utils.defaultValue(
+      meta.root.properties[meta.root.discriminatorColumn],
+      'items',
+      Object.keys(meta.root.discriminatorMap),
+    );
+    Utils.defaultValue(meta.root.properties[meta.root.discriminatorColumn], 'index', true);
+    if (meta.root === meta) {
+      return;
+    }
+    Object.values(meta.properties).forEach(prop => {
+      const newProp = { ...prop };
+      const rootProp = meta.root.properties[prop.name];
+      // A child that narrows a relation to a subclass of the root's declared
+      // target (same STI hierarchy) shares the FK column with the root; treat
+      // that as matching so the rename branch below doesn't run (which would
+      // crash — `targetMeta` is only populated later, in `initRelation`).
+      const narrowedRelationOverride =
+        rootProp != null && rootProp.type !== prop.type && this.sameRelationTargetRoot(rootProp, prop);
+      // 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 || narrowedRelationOverride;
+      // Inverse-side relations (1:m, inverse m:n) have no FK column on this
+      // entity, so the rename branch — which exists to disambiguate physical
+      // columns shared across STI children — doesn't apply. Skipping it also
+      // avoids crashing on `[...rootProp.fieldNames]` since fieldNames is
+      // never populated for inverse-side properties.
+      const isInverseSideRelation =
+        prop.kind === ReferenceKind.ONE_TO_MANY || (prop.kind === ReferenceKind.MANY_TO_MANY && !prop.owner);
+      if (
+        rootProp &&
+        !isInverseSideRelation &&
+        (!typesMatch ||
+          (rootProp.fieldNames && prop.fieldNames && !compareArrays(rootProp.fieldNames, prop.fieldNames)))
+      ) {
+        const name = newProp.name;
+        this.initFieldName(newProp, newProp.object);
+        newProp.renamedFrom = name;
+        newProp.name = `${name}_${meta._id}`;
+        meta.root.addProperty(newProp);
+        this.initFieldName(prop, prop.object);
+        // Track all field variants and map discriminator values to field names
+        if (!rootProp.stiFieldNames) {
+          this.initFieldName(rootProp, rootProp.object);
+          rootProp.stiFieldNames = [...rootProp.fieldNames];
+          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)
+            ) {
+              rootProp.stiFieldNameMap[discValue] = rootProp.fieldNames[0];
+              break;
+            }
+          }
+        }
+        rootProp.stiFieldNameMap[meta.discriminatorValue] = prop.fieldNames[0];
+        rootProp.stiFieldNames.push(...prop.fieldNames);
+        newProp.nullable = true;
+        newProp.name = name;
+        newProp.hydrate = false;
+        newProp.inherited = true;
+        return;
+      }
+      if (prop.enum && prop.items && rootProp?.items) {
+        newProp.items = Utils.unique([...rootProp.items, ...prop.items]);
+      }
+      // When multiple STI children share the same unique relation (OneToOne/ManyToOne),
+      // replace the simple unique with a composite one including the discriminator column
+      // so different subtypes can independently reference the same target row.
+      if (
+        rootProp?.unique &&
+        newProp.unique &&
+        [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(newProp.kind)
+      ) {
+        newProp.unique = false;
+        rootProp.unique = false;
+        meta.root.uniques.push({
+          properties: [prop.name, meta.root.discriminatorColumn],
         });
-        if (prop.kind === ReferenceKind.SCALAR && (prop.type == null || prop.type === 'object') && prop.columnTypes?.[0]) {
-            delete prop.type;
-            const mappedType = this.getMappedType(prop);
-            prop.type = mappedType.compareAsType();
-        }
-        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 &&
-                // 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
-                !/[<>:"';{}]/.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)];
-            }
-            return;
-        }
-        /* v8 ignore next */
-        if (prop.kind === ReferenceKind.EMBEDDED && prop.object) {
-            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();
-        if (prop.polymorphic && prop.polymorphTargets) {
-            prop.columnTypes.push(this.#platform.getVarcharTypeDeclarationSQL(prop));
-        }
-        for (const referencedProp of referencedProps) {
-            this.initCustomType(targetMeta, referencedProp);
-            this.initColumnType(referencedProp);
-            const mappedType = this.getMappedType(referencedProp);
-            let columnTypes = referencedProp.columnTypes;
-            if (referencedProp.autoincrement) {
-                columnTypes = [mappedType.getColumnType({ ...referencedProp, autoincrement: false }, this.#platform)];
-            }
-            prop.columnTypes.push(...columnTypes);
-            if (!targetMeta.compositePK || prop.targetKey) {
-                prop.customType = referencedProp.customType;
-            }
-        }
-    }
-    getMappedType(prop) {
-        if (prop.customType) {
-            return prop.customType;
-        }
-        /* v8 ignore next */
-        let t = prop.columnTypes?.[0] ?? prop.type ?? '';
-        if (prop.nativeEnumName) {
-            t = 'enum';
-        }
-        else if (prop.enum) {
-            t = prop.items?.every(item => typeof item === 'string') ? 'enum' : 'tinyint';
-        }
-        if (t === 'Date') {
-            t = 'datetime';
-        }
-        return this.#platform.getMappedType(t);
-    }
-    getPrefix(prop, parent) {
-        const { embeddedPath = [], fieldNames, prefix = true, prefixMode } = prop;
-        if (prefix === true) {
-            return (embeddedPath.length ? embeddedPath.join('_') : fieldNames[0]) + '_';
-        }
-        const prefixParent = parent ? this.getPrefix(parent, null) : '';
-        if (prefix === false) {
-            return prefixParent;
-        }
-        const mode = prefixMode ?? this.#config.get('embeddables').prefixMode;
-        return mode === 'absolute' ? prefix : prefixParent + prefix;
-    }
-    initUnsigned(prop) {
-        if (prop.unsigned != null) {
-            return;
-        }
-        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
-            prop.unsigned = prop.targetMeta.getPrimaryProps().some(pk => {
-                this.initUnsigned(pk);
-                return pk.unsigned;
-            });
-            return;
-        }
-        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) {
-            prop.index ??= true;
-        }
-    }
-    shouldForceConstructorUsage(meta) {
-        const forceConstructor = this.#config.get('forceEntityConstructor');
-        if (Array.isArray(forceConstructor)) {
-            return forceConstructor.some(cls => Utils.className(cls) === meta.className);
-        }
-        return forceConstructor;
-    }
+      }
+      newProp.nullable = true;
+      newProp.inherited = !rootProp;
+      // For narrowed relation overrides, keep the root's declaration intact so
+      // the full target union (e.g. `Food`) is preserved for populates from the
+      // abstract root — otherwise the last child processed would win.
+      if (narrowedRelationOverride) {
+        return;
+      }
+      // STI siblings can declare the same property name on inverse-side relations
+      // pointing to disjoint targets (e.g. `Dog.items → DogItem` and
+      // `Cat.items → CatItem` with no shared base). There's no physical column
+      // to manage at root, and propagating would clobber the first child's
+      // declaration; each child keeps its local typed property instead.
+      if (isInverseSideRelation && rootProp && rootProp.type !== prop.type) {
+        return;
+      }
+      meta.root.addProperty(newProp);
+    });
+    meta.tableName = meta.root.tableName;
+    meta.root.indexes = Utils.unique([...meta.root.indexes, ...meta.indexes]);
+    meta.root.uniques = Utils.unique([...meta.root.uniques, ...meta.uniques]);
+    meta.root.checks = Utils.unique([...meta.root.checks, ...meta.checks]);
+  }
+  /**
+   * First pass of TPT initialization: sets up hierarchy relationships
+   * (inheritanceType, tptParent, tptChildren) before properties have fieldNames.
+   */
+  initTPTRelationships(meta, metadata) {
+    if (meta.root !== meta) {
+      meta.root = metadata.find(m => m.class === meta.root.class);
+    }
+    // init the root eagerly so children iterated before the root (e.g. alphabetical glob order) still get linked
+    if (meta.root.inheritance === 'tpt' && meta.root.inheritanceType !== 'tpt') {
+      meta.root.inheritanceType = 'tpt';
+      meta.root.tptChildren ??= [];
+    }
+    if (meta.root.inheritanceType !== 'tpt') {
+      return;
+    }
+    const parent = this.getTPTParent(meta, metadata);
+    if (parent) {
+      meta.tptParent = parent;
+      meta.inheritanceType = 'tpt';
+      parent.tptChildren ??= [];
+      if (!parent.tptChildren.includes(meta)) {
+        parent.tptChildren.push(meta);
+      }
+    }
+  }
+  /**
+   * Second pass of TPT initialization: re-resolves metadata references after fieldNames
+   * are set, syncs to registry metadata, and sets up discriminators.
+   */
+  finalizeTPTInheritance(meta, metadata) {
+    if (meta.inheritanceType !== 'tpt') {
+      return;
+    }
+    if (meta.tptParent) {
+      meta.tptParent = metadata.find(m => m.class === meta.tptParent.class) ?? meta.tptParent;
+    }
+    if (meta.tptChildren) {
+      meta.tptChildren = meta.tptChildren.map(child => metadata.find(m => m.class === child.class) ?? child);
+    }
+    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));
+    }
+    this.initTPTDiscriminator(meta, metadata);
+  }
+  /**
+   * Initialize TPT discriminator map and virtual discriminator property.
+   * Unlike STI where the discriminator is a persisted column, TPT discriminator is computed
+   * at query time using CASE WHEN expressions based on which child table has data.
+   */
+  initTPTDiscriminator(meta, metadata) {
+    const allDescendants = this.collectAllTPTDescendants(meta, metadata);
+    allDescendants.sort((a, b) => this.getTPTDepth(b) - this.getTPTDepth(a));
+    meta.allTPTDescendants = allDescendants;
+    if (meta.root !== meta) {
+      return;
+    }
+    meta.root.discriminatorMap = {};
+    for (const m of allDescendants) {
+      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);
+      meta.root.discriminatorMap[name] = meta.class;
+      meta.discriminatorValue = name;
+    }
+    // Virtual discriminator property - computed at query time via CASE WHEN, not persisted
+    const discriminatorColumn = '__tpt_type';
+    if (!meta.root.properties[discriminatorColumn]) {
+      meta.root.addProperty({
+        name: discriminatorColumn,
+        type: 'string',
+        kind: ReferenceKind.SCALAR,
+        persist: false,
+        userDefined: false,
+        hidden: true,
+      });
+    }
+    meta.root.tptDiscriminatorColumn = discriminatorColumn;
+  }
+  /**
+   * Recursively collect all TPT descendants (children, grandchildren, etc.)
+   */
+  collectAllTPTDescendants(meta, metadata) {
+    const descendants = [];
+    const collect = parent => {
+      for (const child of parent.tptChildren ?? []) {
+        const resolved = metadata.find(m => m.class === child.class) ?? child;
+        if (!resolved.abstract) {
+          descendants.push(resolved);
+        }
+        collect(resolved);
+      }
+    };
+    collect(meta);
+    return descendants;
+  }
+  /**
+   * Computes ownProps for TPT entities - only properties defined in THIS entity,
+   * not inherited from parent. Also creates synthetic join properties for parent/child relationships.
+   *
+   * Called multiple times during discovery as metadata is progressively built.
+   * Each pass overwrites earlier results to reflect the final state of properties.
+   */
+  computeTPTOwnProps(meta) {
+    if (meta.inheritanceType !== 'tpt') {
+      return;
+    }
+    const belongsToTable = prop => prop.persist !== false || prop.primary;
+    // Use meta.properties (object) since meta.props (array) may not be populated yet
+    const allProps = Object.values(meta.properties);
+    if (!meta.tptParent) {
+      meta.ownProps = allProps.filter(belongsToTable);
+      return;
+    }
+    const parentPropNames = new Set(Object.values(meta.tptParent.properties).map(p => p.name));
+    meta.ownProps = allProps.filter(prop => !parentPropNames.has(prop.name) && belongsToTable(prop));
+    // Create synthetic join properties for the parent-child relationship
+    const childFieldNames = meta.getPrimaryProps().flatMap(p => p.fieldNames);
+    const parentFieldNames = meta.tptParent.getPrimaryProps().flatMap(p => p.fieldNames);
+    meta.tptParentProp = {
+      name: '[tpt:parent]',
+      kind: ReferenceKind.MANY_TO_ONE,
+      targetMeta: meta.tptParent,
+      fieldNames: childFieldNames,
+      referencedColumnNames: parentFieldNames,
+      persist: false,
+    };
+    meta.tptInverseProp = {
+      name: '[tpt:child]',
+      kind: ReferenceKind.ONE_TO_ONE,
+      owner: true,
+      targetMeta: meta,
+      fieldNames: parentFieldNames,
+      joinColumns: parentFieldNames,
+      referencedColumnNames: childFieldNames,
+      persist: false,
+    };
+  }
+  /** Returns the depth of a TPT entity in its hierarchy (0 for root). */
+  getTPTDepth(meta) {
+    let depth = 0;
+    let current = meta;
+    while (current.tptParent) {
+      depth++;
+      current = current.tptParent;
+    }
+    return depth;
+  }
+  /**
+   * Find the direct TPT parent entity for the given entity.
+   */
+  getTPTParent(meta, metadata) {
+    if (meta.root === meta) {
+      return undefined;
+    }
+    return metadata.find(m => {
+      const ext = meta.extends;
+      if (EntitySchema.is(ext)) {
+        return m.class === ext.meta.class || m.className === ext.meta.className;
+      }
+      return m.class === ext || m.className === Utils.className(ext);
+    });
+  }
+  createDiscriminatorProperty(meta) {
+    meta.addProperty({
+      name: meta.discriminatorColumn,
+      type: 'string',
+      enum: true,
+      kind: ReferenceKind.SCALAR,
+      userDefined: false,
+    });
+  }
+  initAutoincrement(meta) {
+    const pks = meta.getPrimaryProps();
+    if (pks.length === 1 && this.#platform.isNumericProperty(pks[0])) {
+      /* v8 ignore next */
+      pks[0].autoincrement ??= true;
+    }
+  }
+  createSchemaTable(meta) {
+    const qualifiedName = meta.schema ? `${meta.schema}.${meta.tableName}` : meta.tableName;
+    return {
+      name: meta.tableName,
+      schema: meta.schema,
+      qualifiedName,
+      toString: () => qualifiedName,
+    };
+  }
+  initCheckConstraints(meta) {
+    const columns = meta.createSchemaColumnMappingObject();
+    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');
+      if (check.expression instanceof Function) {
+        check.expression = check.expression(columns, table);
+      }
+    }
+    if (this.#platform.usesEnumCheckConstraints() && !meta.embeddable) {
+      // Iterate `meta.properties` rather than `meta.props` — by this point in
+      // the discovery pipeline `initEmbeddables` has added flattened embedded
+      // properties to `meta.properties`, but `meta.sync()` has not yet been
+      // called, so `meta.props` is still the pre-flatten array and would miss
+      // enum properties that live inside embeddables.
+      for (const prop of Object.values(meta.properties)) {
+        if (prop.persist === false || prop.nativeEnumName || !prop.items?.every(item => typeof item === 'string')) {
+          continue;
+        }
+        this.initFieldName(prop);
+        let expression = null;
+        if (prop.enum) {
+          expression = this.#platform.getEnumCheckConstraintExpression(prop.fieldNames[0], prop.items);
+        } else if (prop.array) {
+          expression = this.#platform.getEnumArrayCheckConstraintExpression(prop.fieldNames[0], prop.items);
+        }
+        if (expression) {
+          meta.checks.push({
+            name: this.#namingStrategy.indexName(meta.tableName, prop.fieldNames, 'check'),
+            property: prop.name,
+            expression,
+          });
+        }
+      }
+    }
+  }
+  initGeneratedColumn(meta, prop) {
+    if (!prop.generated && prop.columnTypes) {
+      const match = /(.*) generated always as (.*)/i.exec(prop.columnTypes[0]);
+      if (match) {
+        prop.columnTypes[0] = match[1];
+        prop.generated = match[2];
+        return;
+      }
+      const match2 = /^as (.*)/i.exec(prop.columnTypes[0]?.trim());
+      if (match2) {
+        prop.generated = match2[1];
+      }
+      return;
+    }
+    if (prop.generated instanceof Function) {
+      const columns = meta.createSchemaColumnMappingObject();
+      prop.generated = prop.generated(columns, this.createSchemaTable(meta));
+    }
+  }
+  getDefaultVersionValue(meta, prop) {
+    if (typeof prop.defaultRaw !== 'undefined') {
+      return prop.defaultRaw;
+    }
+    /* v8 ignore next */
+    if (prop.default != null) {
+      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);
+    }
+    return '1';
+  }
+  inferDefaultValue(meta, prop) {
+    try {
+      // try to create two entity instances to detect the value is stable
+      const now = Date.now();
+      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
+      ) {
+        prop.default ??= entity1[prop.name];
+      }
+      // if the default value is null, infer nullability
+      if (entity1[prop.name] === null) {
+        prop.nullable ??= true;
+      }
+      // but still use object values for type inference if not explicitly set, e.g. `createdAt = new Date()`
+      if (prop.kind === ReferenceKind.SCALAR && prop.type == null && entity1[prop.name] != null) {
+        prop.type = prop.runtimeType = Utils.getObjectType(entity1[prop.name]);
+      }
+    } catch {
+      // ignore
+    }
+  }
+  initDefaultValue(prop) {
+    if (prop.defaultRaw || !('default' in prop)) {
+      return;
+    }
+    let val = prop.default;
+    const raw = Raw.getKnownFragment(val);
+    if (raw) {
+      prop.defaultRaw = this.#platform.formatQuery(raw.sql, raw.params);
+      return;
+    }
+    // TODO(v8): always convert the default via the custom type — the `compareAsType() !== 'any'`
+    // guard preserves the legacy convention where JSON defaults are passed pre-stringified.
+    // Array defaults are converted unconditionally (e.g. `default: []` on a JSON-backed embedded array).
+    if (prop.customType && (Array.isArray(prop.default) || prop.customType.compareAsType() !== 'any')) {
+      val = prop.customType.convertToDatabaseValue(prop.default, this.#platform);
+    }
+    prop.defaultRaw = typeof val === 'string' ? `'${val}'` : '' + val;
+  }
+  inferTypeFromDefault(prop) {
+    if ((prop.defaultRaw == null && prop.default == null) || prop.type !== 'any') {
+      return;
+    }
+    switch (typeof prop.default) {
+      case 'string':
+        prop.type = prop.runtimeType = 'string';
+        break;
+      case 'number':
+        prop.type = prop.runtimeType = 'number';
+        break;
+      case 'boolean':
+        prop.type = prop.runtimeType = 'boolean';
+        break;
+    }
+    if (prop.defaultRaw?.startsWith('current_timestamp')) {
+      prop.type = prop.runtimeType = 'Date';
+    }
+  }
+  initVersionProperty(meta, prop) {
+    if (prop.version) {
+      this.initDefaultValue(prop);
+      meta.versionProperty = prop.name;
+      prop.defaultRaw = this.getDefaultVersionValue(meta, prop);
+    }
+    if (prop.concurrencyCheck && !prop.primary) {
+      meta.concurrencyCheckKeys.add(prop.name);
+    }
+  }
+  initCustomType(meta, prop, simple = false, objectEmbeddable = false) {
+    // `prop.type` might be actually instance of custom type class
+    if (Type.isMappedType(prop.type) && !prop.customType) {
+      prop.customType = prop.type;
+      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 the type is an ORM defined mapped type without `ensureComparable: true`,
+      // we use just the type name, to have more performant hydration code
+      const brand = Type.getOrmType(prop.type);
+      const type = Utils.keys(t).find(type => {
+        return !Type.getType(t[type]).ensureComparable(meta, prop) && (prop.type === t[type] || brand === type);
+      });
+      if (type) {
+        prop.type = type === 'datetime' ? 'Date' : type;
+      } else {
+        prop.customType = new prop.type();
+        prop.type = prop.customType.constructor.name;
+      }
+    }
+    if (simple) {
+      return;
+    }
+    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])
+    ) {
+      prop.customType = new t.json();
+    }
+    if (prop.kind === ReferenceKind.EMBEDDED && !prop.customType && (prop.object || prop.array)) {
+      prop.customType = new t.json();
+    }
+    if (!prop.customType && prop.array && prop.items) {
+      prop.customType = new t.enumArray(`${meta.className}.${prop.name}`, prop.items);
+    }
+    const isArray = prop.type?.toLowerCase() === 'array' || prop.type?.toString().endsWith('[]');
+    if (objectEmbeddable && !prop.customType && isArray) {
+      prop.customType = new t.json();
+    }
+    // for number arrays we make sure to convert the items to numbers
+    if (!prop.customType && prop.type === 'number[]') {
+      prop.customType = new t.array(i => +i);
+    }
+    // `string[]` can be returned via ts-morph, while reflect metadata will give us just `array`
+    if (!prop.customType && isArray) {
+      prop.customType = new t.array();
+    }
+    if (!prop.customType && prop.type?.toLowerCase() === 'buffer') {
+      prop.customType = new t.blob();
+    }
+    if (!prop.customType && prop.type?.toLowerCase() === 'uint8array') {
+      prop.customType = new t.uint8array();
+    }
+    const mappedType = this.getMappedType(prop);
+    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()));
+    }
+    if (prop.customType && !prop.columnTypes) {
+      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;
+      } else {
+        prop.runtimeType ??= prop.customType.runtimeType;
+      }
+    } else if (prop.runtimeType === 'object') {
+      prop.runtimeType = mappedType.runtimeType;
+    } else {
+      prop.runtimeType ??= mappedType.runtimeType;
+    }
+    if (prop.customType) {
+      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.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
+    ) {
+      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) !== '';
+          /* v8 ignore next */
+          prop.hasConvertToDatabaseValueSQL ||=
+            !!pk.customType.convertToDatabaseValueSQL &&
+            pk.customType.convertToDatabaseValueSQL('', this.#platform) !== '';
+        } else {
+          prop.customTypes.push(undefined);
+        }
+      }
+    }
+    if (prop.kind === ReferenceKind.SCALAR && !(mappedType instanceof t.unknown)) {
+      if (
+        prop.nativeEnumName &&
+        meta.schema !== this.#platform.getDefaultSchemaName() &&
+        meta.schema &&
+        !prop.nativeEnumName.includes('.')
+      ) {
+        const suffix = prop.columnTypes?.[0]?.endsWith('[]') ? '[]' : '';
+        prop.columnTypes = [`${meta.schema}.${prop.nativeEnumName}${suffix}`];
+      } else {
+        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
+      if (!Object.values(t).some(type => type === mappedType.constructor)) {
+        prop.customType ??= mappedType;
+      }
+    }
+  }
+  initRelation(prop) {
+    if (prop.kind === ReferenceKind.SCALAR || prop.polymorphTargets) {
+      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);
+    // If targetKey is specified, use that property instead of PKs for referencedPKs
+    prop.referencedPKs = prop.targetKey ? [prop.targetKey] : meta2.primaryKeys;
+    prop.targetMeta = meta2;
+    if (meta2.view) {
+      prop.createForeignKeyConstraint = false;
+    }
+    // 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
+    ) {
+      this.initFieldName(prop);
+      if (prop.fieldNames?.length === 1) {
+        prop.formula = table => `${table}.${this.#platform.quoteIdentifier(prop.fieldNames[0])}`;
+      }
+    }
+  }
+  initColumnType(prop) {
+    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()
+      : [];
+    targetProps.map(targetProp => {
+      prop.length ??= targetProp.length;
+      prop.precision ??= targetProp.precision;
+      prop.scale ??= targetProp.scale;
+    });
+    if (prop.kind === ReferenceKind.SCALAR && (prop.type == null || prop.type === 'object') && prop.columnTypes?.[0]) {
+      delete prop.type;
+      const mappedType = this.getMappedType(prop);
+      prop.type = mappedType.compareAsType();
+    }
+    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 &&
+        // 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
+        !/[<>:"';{}]/.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)];
+      }
+      return;
+    }
+    /* v8 ignore next */
+    if (prop.kind === ReferenceKind.EMBEDDED && prop.object) {
+      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();
+    if (prop.polymorphic && prop.polymorphTargets) {
+      prop.columnTypes.push(this.#platform.getVarcharTypeDeclarationSQL(prop));
+    }
+    for (const referencedProp of referencedProps) {
+      this.initCustomType(targetMeta, referencedProp);
+      this.initColumnType(referencedProp);
+      const mappedType = this.getMappedType(referencedProp);
+      let columnTypes = referencedProp.columnTypes;
+      if (referencedProp.autoincrement) {
+        columnTypes = [mappedType.getColumnType({ ...referencedProp, autoincrement: false }, this.#platform)];
+      }
+      prop.columnTypes.push(...columnTypes);
+      if (!targetMeta.compositePK || prop.targetKey) {
+        prop.customType = referencedProp.customType;
+      }
+    }
+  }
+  getMappedType(prop) {
+    if (prop.customType) {
+      return prop.customType;
+    }
+    /* v8 ignore next */
+    let t = prop.columnTypes?.[0] ?? prop.type ?? '';
+    if (prop.nativeEnumName) {
+      t = 'enum';
+    } else if (prop.enum) {
+      t = prop.items?.every(item => typeof item === 'string') ? 'enum' : 'tinyint';
+    }
+    if (t === 'Date') {
+      t = 'datetime';
+    }
+    return this.#platform.getMappedType(t);
+  }
+  getPrefix(prop, parent) {
+    const { embeddedPath = [], fieldNames, prefix = true, prefixMode } = prop;
+    if (prefix === true) {
+      return (embeddedPath.length ? embeddedPath.join('_') : fieldNames[0]) + '_';
+    }
+    const prefixParent = parent ? this.getPrefix(parent, null) : '';
+    if (prefix === false) {
+      return prefixParent;
+    }
+    const mode = prefixMode ?? this.#config.get('embeddables').prefixMode;
+    return mode === 'absolute' ? prefix : prefixParent + prefix;
+  }
+  initUnsigned(prop) {
+    if (prop.unsigned != null) {
+      return;
+    }
+    if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+      prop.unsigned = prop.targetMeta.getPrimaryProps().some(pk => {
+        this.initUnsigned(pk);
+        return pk.unsigned;
+      });
+      return;
+    }
+    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) {
+      prop.index ??= true;
+    }
+  }
+  shouldForceConstructorUsage(meta) {
+    const forceConstructor = this.#config.get('forceEntityConstructor');
+    if (Array.isArray(forceConstructor)) {
+      return forceConstructor.some(cls => Utils.className(cls) === meta.className);
+    }
+    return forceConstructor;
+  }
 }