@mikro-orm/core 7.3.0-dev.2 → 7.3.0-dev.20

package/metadata/MetadataDiscovery.js

@@ -183,10 +183,11 @@ export class MetadataDiscovery {
         }
         discovered.forEach(meta => meta.sync(true));
         this.#metadataProvider.combineCache();
+        const referencingProperties = this.indexReferencingProperties(filtered);
         return discovered.map(meta => {
             meta = this.#metadata.get(meta.class);
             meta.sync(true);
-            this.findReferencingProperties(meta, filtered);
+            this.findReferencingProperties(meta, referencingProperties);
             if (meta.inheritanceType === 'tpt') {
                 this.computeTPTOwnProps(meta);
             }
@@ -217,18 +218,20 @@ export class MetadataDiscovery {
             .replace(/Array<(.*)>/, '$1') // unwrap array
             .replace(/\[]$/, '') // remove array suffix
             .replace(/\((.*)\)/, '$1'); // unwrap union types
+        const discoveredNames = new Set(this.#discovered.map(m => m.className));
         // Names can be ambiguous when a minifier mangles two classes to the same name,
         // so class references also need to be checked by identity.
+        const discoveredClasses = new Set(this.#discovered.map(m => m.class));
         const discoveredByIdentity = (target) => {
             const cls = EntitySchema.is(target) ? target.meta.class : target;
-            return typeof cls !== 'function' || this.#discovered.some(m => m.class === cls);
+            return typeof cls !== 'function' || discoveredClasses.has(cls);
         };
         const missing = [];
         this.#discovered.forEach(meta => Object.values(meta.properties).forEach(prop => {
             const indirect = (prop.kind === ReferenceKind.MANY_TO_MANY ? prop.pivotEntity : prop.through);
             if (indirect) {
                 const target = typeof indirect === 'function' && !indirect.prototype ? indirect() : indirect;
-                if (!this.#discovered.find(m => m.className === Utils.className(target)) || !discoveredByIdentity(target)) {
+                if (!discoveredNames.has(Utils.className(target)) || !discoveredByIdentity(target)) {
                     missing.push(target);
                 }
             }
@@ -236,7 +239,7 @@ export class MetadataDiscovery {
                 const target = typeof prop.entity === 'function' && !prop.entity.prototype ? prop.entity() : prop.type;
                 if (!unwrap(prop.type)
                     .split(/ ?\| ?/)
-                    .every(type => this.#discovered.find(m => m.className === type)) ||
+                    .every(type => discoveredNames.has(type)) ||
                     !Utils.asArray(target).every(discoveredByIdentity)) {
                     missing.push(...Utils.asArray(target));
                 }
@@ -302,7 +305,8 @@ export class MetadataDiscovery {
         if (validate) {
             this.#validator.validateDiscovered(this.#discovered, this.#config.get('discovery'));
         }
-        return this.#discovered.filter(meta => found.find(m => m.name === meta.className));
+        const foundNames = new Set(found.map(m => m.name));
+        return this.#discovered.filter(meta => foundNames.has(meta.className));
     }
     reset(entityName) {
         const exists = this.#discovered.findIndex(m => m.class === entityName || m.className === Utils.className(entityName));
@@ -463,7 +467,8 @@ export class MetadataDiscovery {
         }
     }
     initManyToOneFieldName(prop, name) {
-        const meta2 = prop.targetMeta;
+        // STI property renaming runs before `initRelation` populates `targetMeta`
+        const meta2 = prop.targetMeta ?? this.#metadata.getByClassName(prop.type);
         const ret = [];
         // with `targetKey` on a composite PK target, derive the FK field name from that property
         // instead of the PKs (simple PK targets keep the PK based naming for backwards compatibility)
@@ -480,8 +485,53 @@ export class MetadataDiscovery {
         const meta2 = prop.targetMeta;
         return meta2.primaryKeys.map(() => this.#namingStrategy.propertyToColumnName(name));
     }
+    /**
+     * Walks up the TPT hierarchy to the entity whose M:N declaration this property inherits. A child redeclaring
+     * the property with a different target, pivot table, join columns or fixed order keeps its own pivot table.
+     */
+    getPivotDeclaringMeta(meta, prop) {
+        const keys = [
+            'type',
+            'pivotTable',
+            'pivotEntity',
+            'joinColumns',
+            'inverseJoinColumns',
+            'fixedOrder',
+            'fixedOrderColumn',
+        ];
+        // Rails-style polymorphic owners already share an explicit pivot table, each under its own discriminator value
+        if (prop.polymorphic && !QueryHelper.isUnionTargetPolymorphic(prop)) {
+            return meta;
+        }
+        while (meta.tptParent) {
+            const parentProp = meta.tptParent.properties[prop.name];
+            if (parentProp?.kind !== ReferenceKind.MANY_TO_MANY) {
+                break;
+            }
+            // resolve the parent first so explicit options are compared against its final mapping regardless of discovery order
+            this.initManyToManyFields(meta.tptParent, parentProp);
+            if (keys.some(key => prop[key] != null && !Utils.equals(prop[key], parentProp[key]))) {
+                break;
+            }
+            meta = meta.tptParent;
+        }
+        return meta;
+    }
     initManyToManyFields(meta, prop) {
         const meta2 = prop.targetMeta;
+        // inverse sides derive their mapping from the owner via `mappedBy`
+        const declaringMeta = prop.mappedBy ? meta : this.getPivotDeclaringMeta(meta, prop);
+        if (declaringMeta !== meta) {
+            const prop2 = declaringMeta.properties[prop.name];
+            prop.pivotTable = prop2.pivotTable;
+            prop.pivotEntity = prop2.pivotEntity;
+            prop.fixedOrder = prop2.fixedOrder;
+            prop.fixedOrderColumn = prop2.fixedOrderColumn;
+            prop.joinColumns = prop2.joinColumns;
+            prop.inverseJoinColumns = prop2.inverseJoinColumns;
+            prop.referencedColumnNames = prop2.referencedColumnNames;
+            return;
+        }
         Utils.defaultValue(prop, 'fixedOrder', !!prop.fixedOrderColumn);
         const pivotMeta = this.#metadata.find(prop.pivotEntity);
         const props = Object.values(pivotMeta?.properties ?? {});
@@ -523,12 +573,16 @@ export class MetadataDiscovery {
         prop.referencedColumnNames ??= Utils.flatten(meta.primaryKeys.map(primaryKey => meta.properties[primaryKey].fieldNames));
         // Union-target polymorphic M:N: owner side is fixed (real FK), target side uses discriminator-derived names.
         const isUnionTargetMN = QueryHelper.isUnionTargetPolymorphic(prop);
+        // both sides of a TPT hierarchy would collide on the root name, so name them after the entities themselves
+        const sameTPTRoot = meta.inheritanceType === 'tpt' && meta.root.class === meta2.root.class;
+        const ownerName = sameTPTRoot ? meta.className : meta.root.className;
+        const targetName = sameTPTRoot ? meta2.className : meta2.root.className;
         if (prop.polymorphic && prop.discriminator && !isUnionTargetMN) {
             // Rails-style: owner side is polymorphic, uses discriminator base name (e.g. taggable_id instead of post_id)
             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.joinColumns ??= prop.referencedColumnNames.map(referencedColumnName => this.#namingStrategy.joinKeyColumnName(ownerName, referencedColumnName, meta.compositePK));
         }
         if (isUnionTargetMN) {
             // Target side uses discriminator base name (e.g. attachable_id — shared across Image/Video)
@@ -536,7 +590,7 @@ export class MetadataDiscovery {
             prop.inverseJoinColumns ??= targetPkCols.map(fieldName => this.#namingStrategy.joinKeyColumnName(prop.discriminator, fieldName, targetPkCols.length > 1));
         }
         else {
-            prop.inverseJoinColumns ??= this.initManyToOneFieldName(prop, meta2.root.className);
+            prop.inverseJoinColumns ??= this.initManyToOneFieldName(prop, targetName);
         }
     }
     isExplicitTableName(meta) {
@@ -564,7 +618,10 @@ export class MetadataDiscovery {
         }
         Utils.defaultValue(prop, 'referencedTableName', meta2.tableName);
         if (!prop.joinColumns) {
-            prop.joinColumns = fieldNames.map(fieldName => this.#namingStrategy.joinKeyColumnName(prop.name, fieldName, fieldNames.length > 1));
+            // must match the real FK columns, which ignore `targetKey` naming for simple PK targets
+            prop.joinColumns = prop.targetKey
+                ? prop.fieldNames
+                : fieldNames.map(fieldName => this.#namingStrategy.joinKeyColumnName(prop.name, fieldName, fieldNames.length > 1));
         }
         if (!prop.referencedColumnNames) {
             prop.referencedColumnNames = fieldNames;
@@ -632,8 +689,13 @@ export class MetadataDiscovery {
             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);
+                // an inherited M:N lives in the pivot table of the declaring TPT entity, whose table the pivot FK references
+                const declaringMeta = this.getPivotDeclaringMeta(meta, prop);
+                const ownerProp = declaringMeta.properties[prop.name];
+                const pivotMeta = this.definePivotTableEntity(declaringMeta, ownerProp);
                 prop.pivotEntity = pivotMeta.class;
+                prop.inversedBy ??= ownerProp.inversedBy;
+                prop.fixedOrderColumn = ownerProp.fixedOrderColumn;
                 if (prop.inversedBy) {
                     prop.targetMeta.properties[prop.inversedBy].pivotEntity = pivotMeta.class;
                     const targetRoot = prop.targetMeta.root;
@@ -646,14 +708,22 @@ export class MetadataDiscovery {
                 //   - regular inverse (Tag.posts mappedBy Post.tags) — handled by inversedBy above
                 //   - union-target inverse (Image.posts mappedBy Post.attachments) — on each polymorph target
                 //   - merged inverse (Tag.owners mappedBy [Post,Video].tags) — union collection on the target
-                const inverseCandidates = QueryHelper.isUnionTargetPolymorphic(prop)
-                    ? prop.polymorphTargets
-                    : [prop.targetMeta];
+                // inherited inverse copies on TPT descendants of the target need the pivot as well
+                const withTPTDescendants = (m) => [
+                    m,
+                    ...(m.tptChildren ?? []).flatMap(withTPTDescendants),
+                ];
+                const targets = QueryHelper.isUnionTargetPolymorphic(prop) ? prop.polymorphTargets : [prop.targetMeta];
+                const inverseCandidates = targets.flatMap(withTPTDescendants);
                 for (const targetMeta of inverseCandidates) {
                     for (const inverseProp of Object.values(targetMeta.properties)) {
                         if (inverseProp.kind === ReferenceKind.MANY_TO_MANY &&
                             inverseProp.mappedBy === prop.name &&
-                            !inverseProp.pivotEntity) {
+                            !inverseProp.pivotEntity &&
+                            // a descendant can declare its own inverse of another owner's same-named M:N
+                            targets.some(target => target.properties[inverseProp.name]?.mappedBy === prop.name) &&
+                            // the target itself can carry an inherited inverse of a parent M:N it redeclares
+                            (inverseProp.targetMeta?.properties[prop.name]?.pivotTable ?? prop.pivotTable) === prop.pivotTable) {
                             inverseProp.pivotEntity = pivotMeta.class;
                             inverseProp.pivotTable = pivotMeta.tableName;
                         }
@@ -664,14 +734,47 @@ export class MetadataDiscovery {
         }
         return [];
     }
-    findReferencingProperties(meta, metadata) {
+    /**
+     * Groups the relations of all entities by target class name in one pass, so `findReferencingProperties()`
+     * does not go over the relations of every entity for each entity. Lists keep the order of `metadata` and `relations`.
+     */
+    indexReferencingProperties(metadata) {
+        const index = { byType: new Map(), withTargetKey: new Map() };
+        const add = (map, key, value) => {
+            const list = map.get(key);
+            if (list) {
+                list.push(value);
+            }
+            else {
+                map.set(key, [value]);
+            }
+        };
         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 });
+                if (prop2.kind !== ReferenceKind.SCALAR) {
+                    add(index.byType, prop2.type, [meta2, prop2]);
+                }
+                if (prop2.targetKey) {
+                    const targets = new Set([prop2.type, ...(prop2.polymorphTargets?.map(t => t.className) ?? [])]);
+                    for (const target of targets) {
+                        add(index.withTargetKey, target, prop2);
+                    }
                 }
             }
         }
+        return index;
+    }
+    findReferencingProperties(meta, index) {
+        for (const [meta2, prop2] of index.byType.get(meta.className) ?? []) {
+            meta.referencingProperties.push({ meta: meta2, prop: prop2 });
+        }
+        for (const prop2 of index.withTargetKey.get(meta.className) ?? []) {
+            const targetKey = prop2.targetKey;
+            if (!(meta.primaryKeys.length === 1 && meta.primaryKeys[0] === targetKey) &&
+                !meta.root.targetKeys?.includes(targetKey)) {
+                (meta.root.targetKeys ??= []).push(targetKey);
+            }
+        }
     }
     initFactoryField(meta, prop) {
         ['mappedBy', 'inversedBy', 'pivotEntity'].forEach(type => {
@@ -776,11 +879,14 @@ export class MetadataDiscovery {
         else {
             pivotMeta2.compositePK = true;
         }
+        // STI entities share one table, so any m:n within the hierarchy is self-referencing, named after the root
+        const stiRoot = meta.root.inheritanceType === 'sti' ? meta.root : undefined;
+        const baseMeta = stiRoot ?? meta;
         // handle self-referenced m:n with same default field names
-        if (meta.className === targetType &&
+        if ((meta.className === targetType || stiRoot === targetMeta.root) &&
             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;
+            const baseName = this.isExplicitTableName(baseMeta) ? baseMeta.tableName : baseMeta.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) {
@@ -788,13 +894,23 @@ export class MetadataDiscovery {
                 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)) {
+            // propagate updated joinColumns to all entities that inherit this property or its inverse (STI, or TPT sharing the pivot)
+            const inherits = (m) => m.root === baseMeta || (m.inheritanceType === 'tpt' && m.root === meta.root);
+            // includes `meta` itself: an STI root carries the inverse copy of an M:N declared on a child
+            for (const childMeta of this.#discovered.filter(inherits)) {
                 const childProp = childMeta.properties[prop.name];
-                if (childProp) {
+                // a TPT subclass redeclaring its own pivot table keeps its own columns
+                const sharesPivot = childMeta.inheritanceType !== 'tpt' || childProp?.pivotTable === prop.pivotTable;
+                if (childProp && sharesPivot) {
                     childProp.joinColumns = prop.joinColumns;
                     childProp.inverseJoinColumns = prop.inverseJoinColumns;
                 }
+                const childProp2 = prop.inversedBy ? childMeta.properties[prop.inversedBy] : undefined;
+                // the inherited inverse can stay on this pivot even when the child redeclares the owner side
+                if (childProp2 && (childMeta.inheritanceType !== 'tpt' || childProp2.pivotTable === prop.pivotTable)) {
+                    childProp2.inverseJoinColumns = prop.joinColumns;
+                    childProp2.joinColumns = prop.inverseJoinColumns;
+                }
             }
         }
         // Union-target polymorphic M:N: discriminator + target FK share the pivot across multiple target types
@@ -1272,16 +1388,37 @@ export class MetadataDiscovery {
         // 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;
+        const props = Object.values(embeddable.properties);
+        // variants can declare a same-named property of a different kind, the virtual entity lacks it when the variants are shared with another union
+        for (const prop of embeddable.polymorphs?.flatMap(m => Object.values(m.properties)) ?? []) {
+            const same = props.find(p => p.name === prop.name && Utils.isSameKind(p, prop));
+            if (!same && !prop.embedded) {
+                props.push({ ...prop }); // a copy, the variant's metadata is shared with its other owners
+            }
+            else if (same && same.kind !== ReferenceKind.SCALAR && same.type !== prop.type) {
+                // a column shared by relations to different targets cannot have a FK constraint
+                same.createForeignKeyConstraint = false;
+            }
+        }
+        for (const prop of props) {
+            const sameName = props.filter(p => p.name === prop.name);
+            // same-kind variants of a conflicting property share one owner property, as they share the column
+            const first = sameName.find(p => Utils.isSameKind(p, prop));
+            const conflict = first !== sameName[0];
+            const name = (embeddedProp.embeddedPath?.join(glue) ?? embeddedProp.fieldNames[0] + glue) +
+                prop.name +
+                (conflict ? `_${props.indexOf(first)}` : '');
             meta.properties[name] = Utils.copy(prop);
             meta.properties[name].name = name;
+            // STI column tracking between the variants does not apply to the owner's columns
+            delete meta.properties[name].stiFieldNames;
             meta.properties[name].embedded = [embeddedProp.name, prop.name];
             meta.propertyOrder.set(name, (order += 0.01));
-            embeddedProp.embeddedProps[prop.name] = meta.properties[name];
+            embeddedProp.embeddedProps[conflict ? name : 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) {
+            // each variant fills only its own column of a conflicting property
+            if (embeddedProp.nullable || refInArray || sameName.some(p => !Utils.isSameKind(p, prop))) {
                 meta.properties[name].nullable = true;
             }
             // polymorphic relations derive their column names from the discriminator, so prefix it too
@@ -1452,7 +1589,15 @@ export class MetadataDiscovery {
                     }
                 }
                 rootProp.stiFieldNameMap[meta.discriminatorValue] = prop.fieldNames[0];
-                rootProp.stiFieldNames.push(...prop.fieldNames);
+                // subtypes that only differ in type share the column
+                rootProp.stiFieldNames = Utils.unique([...rootProp.stiFieldNames, ...prop.fieldNames]);
+                // a column shared by relations to different targets cannot have a FK constraint
+                for (const p of Object.values(meta.root.properties)) {
+                    const shared = p.type !== newProp.type && compareArrays(p.fieldNames ?? [], newProp.fieldNames);
+                    if (shared && p.kind !== ReferenceKind.SCALAR && Utils.isSameKind(p, newProp)) {
+                        p.createForeignKeyConstraint = newProp.createForeignKeyConstraint = false;
+                    }
+                }
                 newProp.nullable = true;
                 newProp.name = name;
                 newProp.hydrate = false;
@@ -1497,6 +1642,9 @@ export class MetadataDiscovery {
             if (isInverseSideRelation && rootProp && rootProp.type !== prop.type) {
                 return;
             }
+            // a sibling matching the root property must not drop the column variants of already renamed siblings
+            newProp.stiFieldNames ??= rootProp?.stiFieldNames;
+            newProp.stiFieldNameMap ??= rootProp?.stiFieldNameMap;
             meta.root.addProperty(newProp);
         });
         meta.tableName = meta.root.tableName;
@@ -1617,7 +1765,7 @@ export class MetadataDiscovery {
         if (meta.inheritanceType !== 'tpt') {
             return;
         }
-        const belongsToTable = (prop) => prop.persist !== false || prop.primary;
+        const belongsToTable = (prop) => prop.persist !== false || prop.primary || !!prop.formula;
         // Use meta.properties (object) since meta.props (array) may not be populated yet
         const allProps = Object.values(meta.properties);
         if (!meta.tptParent) {
@@ -1863,9 +2011,9 @@ export class MetadataDiscovery {
         // 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);
+            val = prop.customType.convertToDatabaseValue(prop.default, this.#platform, { mode: 'discovery' });
         }
-        prop.defaultRaw = typeof val === 'string' ? `'${val}'` : '' + val;
+        prop.defaultRaw = typeof val === 'string' ? this.#platform.quoteDefaultValue(val) : '' + val;
     }
     inferTypeFromDefault(prop) {
         if ((prop.defaultRaw == null && prop.default == null) || prop.type !== 'any') {

package/metadata/MetadataStorage.d.ts

@@ -9,6 +9,7 @@ export declare class MetadataStorage {
     /** Returns the global metadata dictionary, or a specific entry by entity name and path (keyed by the class reference when `target` is provided). */
     static getMetadata(): Dictionary<EntityMetadata>;
     static getMetadata<T = any>(entity: string, path: string, target?: EntityCtor): EntityMetadata<T>;
+    private static hashPath;
     /** Checks whether an entity with the given class name exists in the global metadata. */
     static isKnownEntity(name: string): boolean;
     /** Clears all entries from the global metadata registry. */
@@ -32,6 +33,13 @@ export declare class MetadataStorage {
     getById<T>(id: number): EntityMetadata<T>;
     /** Returns metadata by class name, optionally throwing if not found. */
     getByClassName<T = any, V extends boolean = true>(className: string, validate?: V): V extends true ? EntityMetadata<T> : EntityMetadata<T> | undefined;
+    /**
+     * Returns the first registered metadata with the given table name, in registration order (entities sharing
+     * a table, like STI children, resolve to the one registered first). The index is built on first use, as table
+     * names are only final once discovery has finished.
+     * @internal
+     */
+    getByTableName<T = any>(tableName: string): EntityMetadata<T> | undefined;
     /** Returns metadata by unique name, optionally throwing if not found. */
     getByUniqueName<T = any, V extends boolean = true>(uniqueName: string, validate?: V): V extends true ? EntityMetadata<T> : EntityMetadata<T> | undefined;
     private validate;

package/metadata/MetadataStorage.js

@@ -13,11 +13,17 @@ export class MetadataStorage {
     static PATH_SYMBOL = Symbol.for('@mikro-orm/core/MetadataStorage.PATH_SYMBOL');
     static META_SYMBOL = Symbol.for('@mikro-orm/core/MetadataStorage.META_SYMBOL');
     static #metadata = getGlobalStorage('metadata');
+    /** Lives in the global storage next to the registry, so it stays in sync when several copies of this module share it (e.g. after `vi.resetModules()`). */
+    static #classNames = getGlobalStorage('metadata-class-names');
+    /** Hashes of entity file paths, decorators call `getMetadata()` with the same path for every decorated member. */
+    static #pathHashes = new Map();
     #metadataMap = new Map();
     #idMap;
     #classNameMap;
     #uniqueNameMap;
     #ambiguousNames = new Set();
+    /** Built on first use by `getByTableName()`, dropped whenever an entity is registered or removed. */
+    #tableNameMap;
     constructor(metadata = {}) {
         this.#idMap = {};
         this.#uniqueNameMap = {};
@@ -29,7 +35,7 @@ export class MetadataStorage {
         }
     }
     static getMetadata(entity, path, target) {
-        const key = entity && path ? entity + '-' + Utils.hash(path) : null;
+        const key = entity && path ? entity + '-' + MetadataStorage.hashPath(path) : null;
         // Key the registry by the class reference when available, so two classes minified
         // to the same mangled name don't collide on the `className-path` key.
         if (key && target) {
@@ -41,23 +47,36 @@ export class MetadataStorage {
             }
             // Keep the name-keyed entry in sync, the class-keyed metadata survives `MetadataStorage.clear()`.
             MetadataStorage.#metadata[key] = target[MetadataStorage.META_SYMBOL];
+            MetadataStorage.#classNames.names?.add(target[MetadataStorage.META_SYMBOL].className);
             return target[MetadataStorage.META_SYMBOL];
         }
         if (key && !MetadataStorage.#metadata[key]) {
-            MetadataStorage.#metadata[key] = new EntityMetadata({ className: entity, path });
+            const meta = new EntityMetadata({ className: entity, path });
+            MetadataStorage.#metadata[key] = meta;
+            MetadataStorage.#classNames.names?.add(meta.className);
         }
         if (key) {
             return MetadataStorage.#metadata[key];
         }
         return MetadataStorage.#metadata;
     }
+    static hashPath(path) {
+        let hash = MetadataStorage.#pathHashes.get(path);
+        if (hash === undefined) {
+            hash = Utils.hash(path);
+            MetadataStorage.#pathHashes.set(path, hash);
+        }
+        return hash;
+    }
     /** Checks whether an entity with the given class name exists in the global metadata. */
     static isKnownEntity(name) {
-        return !!Object.values(this.#metadata).find(meta => meta.className === name);
+        this.#classNames.names ??= new Set(Object.values(this.#metadata).map(meta => meta.className));
+        return this.#classNames.names.has(name);
     }
     /** Clears all entries from the global metadata registry. */
     static clear() {
         Object.keys(this.#metadata).forEach(k => delete this.#metadata[k]);
+        delete this.#classNames.names;
     }
     /** Returns the map of all registered entity metadata. */
     getAll() {
@@ -102,6 +121,7 @@ export class MetadataStorage {
     /** Registers metadata for the given entity. */
     set(entityName, meta) {
         this.#metadataMap.set(entityName, meta);
+        this.#tableNameMap = undefined;
         this.#idMap[meta._id] = meta;
         this.#uniqueNameMap[meta.uniqueName] = meta;
         const className = Utils.className(entityName);
@@ -110,6 +130,12 @@ export class MetadataStorage {
         if (existing && existing !== meta && existing.class !== meta.class) {
             this.#ambiguousNames.add(className);
         }
+        // colliding names are numbered in storage order, which follows the discovery config, not module evaluation
+        const sameName = this.#ambiguousNames.has(className)
+            ? [...new Set(this.#metadataMap.values())].filter(m => m.className === meta.className)
+            : [meta];
+        const ordinal = sameName.indexOf(meta);
+        meta.compiledName = ordinal > 0 ? `${meta.className}#${ordinal}` : meta.className;
         this.#classNameMap[className] = meta;
         return meta;
     }
@@ -118,6 +144,7 @@ export class MetadataStorage {
         const meta = this.find(entityName);
         if (meta) {
             this.#metadataMap.delete(meta.class);
+            this.#tableNameMap = undefined;
             delete this.#idMap[meta._id];
             delete this.#uniqueNameMap[meta.uniqueName];
             delete this.#classNameMap[meta.className];
@@ -145,6 +172,23 @@ export class MetadataStorage {
     getByClassName(className, validate = true) {
         return this.validate(this.#classNameMap[className], className, validate);
     }
+    /**
+     * Returns the first registered metadata with the given table name, in registration order (entities sharing
+     * a table, like STI children, resolve to the one registered first). The index is built on first use, as table
+     * names are only final once discovery has finished.
+     * @internal
+     */
+    getByTableName(tableName) {
+        if (!this.#tableNameMap) {
+            this.#tableNameMap = new Map();
+            for (const meta of this.#metadataMap.values()) {
+                if (!this.#tableNameMap.has(meta.tableName)) {
+                    this.#tableNameMap.set(meta.tableName, meta);
+                }
+            }
+        }
+        return this.#tableNameMap.get(tableName);
+    }
     /** Returns metadata by unique name, optionally throwing if not found. */
     getByUniqueName(uniqueName, validate = true) {
         return this.validate(this.#uniqueNameMap[uniqueName], uniqueName, validate);

package/metadata/MetadataValidator.js

@@ -118,12 +118,13 @@ export class MetadataValidator {
             return Utils.className(p);
         };
         const pivotProps = new Map();
+        const discoveredNames = new Set(discovered.map(m => m.className));
         // check for not discovered entities
         discovered.forEach(meta => Object.values(meta.properties).forEach(prop => {
             if (prop.kind !== ReferenceKind.SCALAR &&
                 !unwrap(prop.type)
                     .split(/ ?\| ?/)
-                    .every(type => discovered.find(m => m.className === type))) {
+                    .every(type => discoveredNames.has(type))) {
                 throw MetadataError.fromUnknownEntity(prop.type, `${meta.className}.${prop.name}`);
             }
             if (prop.pivotEntity) {

package/metadata/types.d.ts

@@ -176,6 +176,12 @@ export interface PropertyOptions<Owner> {
      * Explicitly specify the auto increment of the primary key.
      */
     autoincrement?: boolean;
+    /**
+     * Start value and increment of an autoincrement column. (SQL only)
+     * Applied only when the column is created (and by `orm.schema.clear()`), never diffed by the schema generator.
+     * `incrementBy` is not supported on MySQL, MariaDB and SQLite.
+     */
+    sequence?: SequenceOptions;
     /**
      * Add the property to the `returning` clause of inserts, updates and upserts, reloading the database value into the entity.
      */
@@ -587,6 +593,12 @@ export interface EnumOptions<T> extends PropertyOptions<T> {
     /** for postgres, by default it uses text column with check constraint */
     nativeEnumName?: string;
 }
+export interface SequenceOptions {
+    /** The first value the autoincrement column generates. */
+    startWith?: number;
+    /** The step between generated values. Not supported on MySQL, MariaDB and SQLite. */
+    incrementBy?: number;
+}
 export interface PrimaryKeyOptions<T> extends PropertyOptions<T> {
 }
 export interface SerializedPrimaryKeyOptions<T> extends PropertyOptions<T> {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.3.0-dev.2",
+  "version": "7.3.0-dev.20",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",

package/platforms/Platform.d.ts

@@ -204,6 +204,8 @@ export declare abstract class Platform {
     supportsUnionWhere(): boolean;
     /** Returns the SQL type declaration used for array storage. */
     getArrayDeclarationSQL(): string;
+    /** Whether array columns support the `&&` (overlap) operator. */
+    supportsArrayOverlap(): boolean;
     /** Serializes a string array into its database storage format. */
     marshallArray(values: string[]): string;
     /** Deserializes a database-stored array string back into a string array. */
@@ -274,6 +276,8 @@ export declare abstract class Platform {
     }, quote?: string): string;
     /** Quotes a literal value for safe embedding in SQL. */
     quoteValue(value: any): string;
+    /** Quotes a string default value for DDL; dialects that escape with backslashes override this. */
+    quoteDefaultValue(value: string): string;
     escape(value: any): string;
     /** Replaces `?` placeholders in SQL with quoted parameter values. */
     formatQuery(sql: string, params: readonly any[]): string;
@@ -325,6 +329,8 @@ export declare abstract class Platform {
     supportsDownMigrations(): boolean;
     /** Whether the platform supports deferred unique constraints. */
     supportsDeferredUniqueConstraints(): boolean;
+    /** Whether autoincrement columns support a per-column increment (`sequence.incrementBy`). */
+    supportsAutoincrementIncrement(): boolean;
     /** Whether the platform supports row level security (PostgreSQL). */
     supportsRowLevelSecurity(): boolean;
     /** Whether the driver can apply the session context on every pooled connection acquire (`sessionContext: 'connection'`). */

package/platforms/Platform.js

@@ -360,6 +360,10 @@ export class Platform {
     getArrayDeclarationSQL() {
         return 'text';
     }
+    /** Whether array columns support the `&&` (overlap) operator. */
+    supportsArrayOverlap() {
+        return false;
+    }
     /** Serializes a string array into its database storage format. */
     marshallArray(values) {
         return values.map(v => (/[,",\\]/.test(v) ? JSON.stringify(v) : v)).join(',');
@@ -573,6 +577,10 @@ export class Platform {
     quoteValue(value) {
         return value;
     }
+    /** Quotes a string default value for DDL; dialects that escape with backslashes override this. */
+    quoteDefaultValue(value) {
+        return `'${value.replaceAll("'", "''")}'`;
+    }
     /* v8 ignore next */
     escape(value) {
         return value;
@@ -738,6 +746,10 @@ export class Platform {
     supportsDeferredUniqueConstraints() {
         return true;
     }
+    /** Whether autoincrement columns support a per-column increment (`sequence.incrementBy`). */
+    supportsAutoincrementIncrement() {
+        return true;
+    }
     /** Whether the platform supports row level security (PostgreSQL). */
     supportsRowLevelSecurity() {
         return false;
@@ -758,6 +770,20 @@ export class Platform {
         if (meta.partitionBy && !this.supportsPartitionedTables()) {
             throw new MetadataError(`Entity ${meta.className} uses partitionBy, but ${this.constructor.name} does not support partitioned tables`);
         }
+        for (const prop of Object.values(meta.properties)) {
+            if (!prop.sequence) {
+                continue;
+            }
+            if (!prop.autoincrement) {
+                throw MetadataError.sequenceWithoutAutoincrement(meta, prop);
+            }
+            if (typeof prop.generated === 'string' && /identity\s*\(/i.test(prop.generated)) {
+                throw MetadataError.sequenceWithIdentityOptions(meta, prop);
+            }
+            if (prop.sequence.incrementBy != null && !this.supportsAutoincrementIncrement()) {
+                throw MetadataError.sequenceIncrementNotSupported(meta, prop, this.constructor.name);
+            }
+        }
         const declaresRls = meta.policies.length > 0 || !!meta.rowLevelSecurity;
         if (declaresRls && !this.supportsRowLevelSecurity()) {
             throw MetadataError.rowLevelSecurityNotSupportedByDriver(meta);