@mikro-orm/core 7.0.0-dev.300 → 7.0.0-dev.302

package/metadata/MetadataDiscovery.js

@@ -33,7 +33,9 @@ export class MetadataDiscovery {
     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)}`;
+        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) {
@@ -51,7 +53,9 @@ export class MetadataDiscovery {
     discoverSync() {
         this.discovered.length = 0;
         const startTime = Date.now();
-        const suffix = this.metadataProvider.constructor === MetadataProvider ? '' : `, using ${colors.cyan(this.metadataProvider.constructor.name)}`;
+        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);
@@ -127,7 +131,7 @@ export class MetadataDiscovery {
         // ignore base entities (not annotated with @Entity)
         const filtered = discovered.filter(meta => meta.root.name);
         // sort so we discover entities first to get around issues with nested embeddables
-        filtered.sort((a, b) => !a.embeddable === !b.embeddable ? 0 : (a.embeddable ? 1 : -1));
+        filtered.sort((a, b) => (!a.embeddable === !b.embeddable ? 0 : a.embeddable ? 1 : -1));
         filtered.forEach(meta => this.initSingleTableInheritance(meta, filtered));
         filtered.forEach(meta => this.initTPTRelationships(meta, filtered));
         filtered.forEach(meta => this.defineBaseEntityProperties(meta));
@@ -176,7 +180,7 @@ export class MetadataDiscovery {
     }
     async findEntities(preferTs) {
         const { entities, entitiesTs, baseDir } = this.config.getAll();
-        const targets = (preferTs && entitiesTs.length > 0) ? entitiesTs : entities;
+        const targets = preferTs && entitiesTs.length > 0 ? entitiesTs : entities;
         const processed = [];
         const paths = [];
         for (const entity of targets) {
@@ -189,7 +193,7 @@ export class MetadataDiscovery {
         }
         if (paths.length > 0) {
             const { discoverEntities } = await import('@mikro-orm/core/file-discovery');
-            processed.push(...await discoverEntities(paths, { baseDir }));
+            processed.push(...(await discoverEntities(paths, { baseDir })));
         }
         return this.discoverReferences(processed);
     }
@@ -210,10 +214,10 @@ export class MetadataDiscovery {
                 }
             }
             if (prop.kind !== ReferenceKind.SCALAR) {
-                const target = typeof prop.entity === 'function' && !prop.entity.prototype
-                    ? prop.entity()
-                    : prop.type;
-                if (!unwrap(prop.type).split(/ ?\| ?/).every(type => this.discovered.find(m => m.className === type))) {
+                const target = typeof prop.entity === 'function' && !prop.entity.prototype ? prop.entity() : prop.type;
+                if (!unwrap(prop.type)
+                    .split(/ ?\| ?/)
+                    .every(type => this.discovered.find(m => m.className === type))) {
                     missing.push(...Utils.asArray(target));
                 }
             }
@@ -305,7 +309,8 @@ export class MetadataDiscovery {
     }
     getRootEntity(meta) {
         const base = meta.extends && this.metadata.find(meta.extends);
-        if (!base || base === meta) { // make sure we do not fall into infinite loop
+        if (!base || base === meta) {
+            // make sure we do not fall into infinite loop
             return meta;
         }
         const root = this.getRootEntity(base);
@@ -365,7 +370,10 @@ export class MetadataDiscovery {
     initOwnColumns(meta) {
         meta.sync();
         for (const prop of meta.props) {
-            if (!prop.joinColumns || !prop.columnTypes || prop.ownColumns || ![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+            if (!prop.joinColumns ||
+                !prop.columnTypes ||
+                prop.ownColumns ||
+                ![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
                 continue;
             }
             // For polymorphic relations, ownColumns should include all fieldNames
@@ -553,7 +561,8 @@ export class MetadataDiscovery {
             this.initRelation(prop);
         }
         this.initOwnColumns(meta);
-        meta.simplePK = pks.length === 1 && pks[0].kind === ReferenceKind.SCALAR && !pks[0].customType && pks[0].runtimeType !== 'Date';
+        meta.simplePK =
+            pks.length === 1 && pks[0].kind === ReferenceKind.SCALAR && !pks[0].customType && pks[0].runtimeType !== 'Date';
         meta.serializedPrimaryKey ??= meta.props.find(prop => prop.serializedPrimaryKey)?.name;
         if (meta.serializedPrimaryKey && meta.serializedPrimaryKey !== meta.primaryKeys[0]) {
             meta.properties[meta.serializedPrimaryKey].persist ??= false;
@@ -685,7 +694,8 @@ export class MetadataDiscovery {
             pivotMeta2.compositePK = true;
         }
         // handle self-referenced m:n with same default field names
-        if (meta.className === targetType && prop.joinColumns.every((joinColumn, idx) => joinColumn === prop.inverseJoinColumns[idx])) {
+        if (meta.className === targetType &&
+            prop.joinColumns.every((joinColumn, idx) => joinColumn === prop.inverseJoinColumns[idx])) {
             // use tableName only when explicitly provided by user, otherwise use className for backwards compatibility
             const baseName = this.isExplicitTableName(meta) ? meta.tableName : meta.className;
             prop.joinColumns = prop.referencedColumnNames.map(name => this.namingStrategy.joinKeyColumnName(baseName + '_1', name, meta.compositePK));
@@ -775,7 +785,9 @@ export class MetadataDiscovery {
         if (isCompositePK) {
             // Create separate properties for each PK column (nullable for other entity types)
             for (let i = 0; i < prop.joinColumns.length; i++) {
-                pivotMeta.properties[prop.joinColumns[i]] = this.createPivotScalarProperty(prop.joinColumns[i], [columnTypes[i]]);
+                pivotMeta.properties[prop.joinColumns[i]] = this.createPivotScalarProperty(prop.joinColumns[i], [
+                    columnTypes[i],
+                ]);
             }
             // Virtual property combining all columns (for compatibility)
             pivotMeta.properties[prop.discriminator] = this.createPivotScalarProperty(prop.discriminator, columnTypes, [...prop.joinColumns], { type: meta.className, persist: false });
@@ -915,7 +927,8 @@ export class MetadataDiscovery {
     }
     defineBaseEntityProperties(meta) {
         const base = meta.extends && this.metadata.get(meta.extends);
-        if (!base || base === meta) { // make sure we do not fall into infinite loop
+        if (!base || base === meta) {
+            // make sure we do not fall into infinite loop
             return 0;
         }
         let order = this.defineBaseEntityProperties(base);
@@ -927,10 +940,12 @@ export class MetadataDiscovery {
                 meta.properties[prop.name] = prop;
             }
         });
-        ownProps.forEach(prop => meta.properties[prop.name] = prop);
+        ownProps.forEach(prop => (meta.properties[prop.name] = prop));
         meta.filters = { ...base.filters, ...meta.filters };
         if (!meta.discriminatorValue) {
-            Object.values(base.properties).filter(prop => !old.includes(prop.name)).forEach(prop => {
+            Object.values(base.properties)
+                .filter(prop => !old.includes(prop.name))
+                .forEach(prop => {
                 meta.properties[prop.name] = { ...prop };
                 meta.propertyOrder.set(prop.name, (order += 0.01));
             });
@@ -938,7 +953,9 @@ export class MetadataDiscovery {
         meta.indexes = Utils.unique([...base.indexes, ...meta.indexes]);
         meta.uniques = Utils.unique([...base.uniques, ...meta.uniques]);
         meta.checks = Utils.unique([...base.checks, ...meta.checks]);
-        const pks = Object.values(meta.properties).filter(p => p.primary).map(p => p.name);
+        const pks = Object.values(meta.properties)
+            .filter(p => p.primary)
+            .map(p => p.name);
         if (pks.length > 0 && meta.primaryKeys.length === 0) {
             meta.primaryKeys = pks;
         }
@@ -971,7 +988,7 @@ export class MetadataDiscovery {
                         properties[prop.name].runtimeType = 'any';
                         return properties[prop.name];
                     }
-                    return properties[prop.name] = prop;
+                    return (properties[prop.name] = prop);
                 });
             };
             const processExtensions = (meta) => {
@@ -989,7 +1006,10 @@ export class MetadataDiscovery {
                 inlineProperties(meta);
                 processExtensions(meta);
             });
-            const name = polymorphs.map(t => t.className).sort().join(' | ');
+            const name = polymorphs
+                .map(t => t.className)
+                .sort()
+                .join(' | ');
             embeddable = new EntityMetadata({
                 name,
                 className: name,
@@ -1001,7 +1021,7 @@ export class MetadataDiscovery {
             });
             embeddable.sync();
             discovered.push(embeddable);
-            polymorphs.forEach(meta => meta.root = embeddable);
+            polymorphs.forEach(meta => (meta.root = embeddable));
         }
     }
     initPolymorphicRelation(meta, prop, discovered) {
@@ -1171,7 +1191,7 @@ export class MetadataDiscovery {
             const map = meta.root.discriminatorMap;
             Object.keys(map)
                 .filter(key => typeof map[key] === 'string')
-                .forEach(key => map[key] = this.metadata.getByClassName(map[key]).class);
+                .forEach(key => (map[key] = this.metadata.getByClassName(map[key]).class));
         }
         else {
             meta.root.discriminatorMap = {};
@@ -1195,7 +1215,9 @@ export class MetadataDiscovery {
         Object.values(meta.properties).forEach(prop => {
             const newProp = { ...prop };
             const rootProp = meta.root.properties[prop.name];
-            if (rootProp && (rootProp.type !== prop.type || (rootProp.fieldNames && prop.fieldNames && !compareArrays(rootProp.fieldNames, prop.fieldNames)))) {
+            if (rootProp &&
+                (rootProp.type !== prop.type ||
+                    (rootProp.fieldNames && prop.fieldNames && !compareArrays(rootProp.fieldNames, prop.fieldNames)))) {
                 const name = newProp.name;
                 this.initFieldName(newProp, newProp.object);
                 newProp.renamedFrom = name;
@@ -1210,7 +1232,8 @@ export class MetadataDiscovery {
                     // 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)) {
+                        if (childMeta?.properties[prop.name]?.fieldNames &&
+                            compareArrays(childMeta.properties[prop.name].fieldNames, rootProp.fieldNames)) {
                             rootProp.stiFieldNameMap[discValue] = rootProp.fieldNames[0];
                             break;
                         }
@@ -1442,7 +1465,10 @@ export class MetadataDiscovery {
         }
         if (this.platform.usesEnumCheckConstraints() && !meta.embeddable) {
             for (const prop of meta.props) {
-                if (prop.enum && prop.persist !== false && !prop.nativeEnumName && prop.items?.every(item => typeof item === 'string')) {
+                if (prop.enum &&
+                    prop.persist !== false &&
+                    !prop.nativeEnumName &&
+                    prop.items?.every(item => typeof item === 'string')) {
                     this.initFieldName(prop);
                     meta.checks.push({
                         name: this.namingStrategy.indexName(meta.tableName, prop.fieldNames, 'check'),
@@ -1495,7 +1521,11 @@ export class MetadataDiscovery {
             const entity1 = new meta.class();
             const entity2 = new meta.class();
             // we compare the two values by reference, this will discard things like `new Date()` or `Date.now()`
-            if (this.config.get('discovery').inferDefaultValues && prop.default === undefined && entity1[prop.name] != null && entity1[prop.name] === entity2[prop.name] && entity1[prop.name] !== now) {
+            if (this.config.get('discovery').inferDefaultValues &&
+                prop.default === undefined &&
+                entity1[prop.name] != null &&
+                entity1[prop.name] === entity2[prop.name] &&
+                entity1[prop.name] !== now) {
                 prop.default ??= entity1[prop.name];
             }
             // if the default value is null, infer nullability
@@ -1562,7 +1592,9 @@ export class MetadataDiscovery {
             prop.type = prop.customType.constructor.name;
         }
         // `prop.type` might also be custom type class (not instance), so `typeof MyType` will give us `function`, not `object`
-        if (typeof prop.type === 'function' && Type.isMappedType(prop.type.prototype) && !prop.customType) {
+        if (typeof prop.type === 'function' &&
+            Type.isMappedType(prop.type.prototype) &&
+            !prop.customType) {
             // if the type is an ORM defined mapped type without `ensureComparable: true`,
             // we use just the type name, to have more performant hydration code
             const type = Utils.keys(t).find(type => {
@@ -1582,7 +1614,10 @@ export class MetadataDiscovery {
         if (!prop.customType && ['json', 'jsonb'].includes(prop.type?.toLowerCase())) {
             prop.customType = new t.json();
         }
-        if (prop.kind === ReferenceKind.SCALAR && !prop.customType && prop.columnTypes && ['json', 'jsonb'].includes(prop.columnTypes[0])) {
+        if (prop.kind === ReferenceKind.SCALAR &&
+            !prop.customType &&
+            prop.columnTypes &&
+            ['json', 'jsonb'].includes(prop.columnTypes[0])) {
             prop.customType = new t.json();
         }
         if (prop.kind === ReferenceKind.EMBEDDED && !prop.customType && (prop.object || prop.array)) {
@@ -1613,10 +1648,12 @@ export class MetadataDiscovery {
         if (prop.fieldNames?.length === 1 && !prop.customType) {
             [t.bigint, t.double, t.decimal, t.interval, t.date]
                 .filter(type => mappedType instanceof type)
-                .forEach((type) => prop.customType = new type());
+                .forEach((type) => (prop.customType = new type()));
         }
         if (prop.customType && !prop.columnTypes) {
-            const mappedType = this.getMappedType({ columnTypes: [prop.customType.getColumnType(prop, this.platform)] });
+            const mappedType = this.getMappedType({
+                columnTypes: [prop.customType.getColumnType(prop, this.platform)],
+            });
             if (prop.customType.compareAsType() === 'any' && ![t.json].some(t => prop.customType instanceof t)) {
                 prop.runtimeType ??= mappedType.runtimeType;
             }
@@ -1635,23 +1672,33 @@ export class MetadataDiscovery {
             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.hasConvertToJSValueSQL =
+                !!prop.customType.convertToJSValueSQL && prop.customType.convertToJSValueSQL('', this.platform) !== '';
+            prop.hasConvertToDatabaseValueSQL =
+                !!prop.customType.convertToDatabaseValueSQL &&
+                    prop.customType.convertToDatabaseValueSQL('', this.platform) !== '';
+            if (prop.customType instanceof t.bigint &&
+                ['string', 'bigint', 'number'].includes(prop.runtimeType.toLowerCase())) {
                 prop.customType.mode = prop.runtimeType.toLowerCase();
             }
         }
         if (Type.isMappedType(prop.customType) && prop.kind === ReferenceKind.SCALAR && !isArray) {
             prop.type = prop.customType.name;
         }
-        if (!prop.customType && [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind) && !prop.polymorphic && prop.targetMeta.compositePK) {
+        if (!prop.customType &&
+            [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind) &&
+            !prop.polymorphic &&
+            prop.targetMeta.compositePK) {
             prop.customTypes = [];
             for (const pk of prop.targetMeta.getPrimaryProps()) {
                 if (pk.customType) {
                     prop.customTypes.push(pk.customType);
-                    prop.hasConvertToJSValueSQL ||= !!pk.customType.convertToJSValueSQL && pk.customType.convertToJSValueSQL('', this.platform) !== '';
+                    prop.hasConvertToJSValueSQL ||=
+                        !!pk.customType.convertToJSValueSQL && pk.customType.convertToJSValueSQL('', this.platform) !== '';
                     /* v8 ignore next */
-                    prop.hasConvertToDatabaseValueSQL ||= !!pk.customType.convertToDatabaseValueSQL && pk.customType.convertToDatabaseValueSQL('', this.platform) !== '';
+                    prop.hasConvertToDatabaseValueSQL ||=
+                        !!pk.customType.convertToDatabaseValueSQL &&
+                            pk.customType.convertToDatabaseValueSQL('', this.platform) !== '';
                 }
                 else {
                     prop.customTypes.push(undefined);
@@ -1659,7 +1706,11 @@ export class MetadataDiscovery {
             }
         }
         if (prop.kind === ReferenceKind.SCALAR && !(mappedType instanceof t.unknown)) {
-            if (!prop.columnTypes && prop.nativeEnumName && meta.schema !== this.platform.getDefaultSchemaName() && meta.schema && !prop.nativeEnumName.includes('.')) {
+            if (!prop.columnTypes &&
+                prop.nativeEnumName &&
+                meta.schema !== this.platform.getDefaultSchemaName() &&
+                meta.schema &&
+                !prop.nativeEnumName.includes('.')) {
                 prop.columnTypes = [`${meta.schema}.${prop.nativeEnumName}`];
             }
             else {
@@ -1686,7 +1737,10 @@ export class MetadataDiscovery {
         }
         // Auto-generate formula for persist: false relations, but only for single-column FKs
         // Composite FK relations need standard JOIN conditions, not formula-based
-        if (!prop.formula && prop.persist === false && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && !prop.embedded) {
+        if (!prop.formula &&
+            prop.persist === false &&
+            [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) &&
+            !prop.embedded) {
             this.initFieldName(prop);
             if (prop.fieldNames?.length === 1) {
                 prop.formula = table => `${table}.${this.platform.quoteIdentifier(prop.fieldNames[0])}`;
@@ -1697,7 +1751,9 @@ export class MetadataDiscovery {
         this.initUnsigned(prop);
         // Get the target properties for FK relations - use targetKey property if specified, otherwise PKs
         const targetProps = prop.targetMeta
-            ? (prop.targetKey ? [prop.targetMeta.properties[prop.targetKey]] : prop.targetMeta.getPrimaryProps())
+            ? prop.targetKey
+                ? [prop.targetMeta.properties[prop.targetKey]]
+                : prop.targetMeta.getPrimaryProps()
             : [];
         targetProps.map(targetProp => {
             prop.length ??= targetProp.length;
@@ -1715,11 +1771,11 @@ export class MetadataDiscovery {
         if (prop.kind === ReferenceKind.SCALAR) {
             const mappedType = this.getMappedType(prop);
             const SCALAR_TYPES = ['string', 'number', 'boolean', 'bigint', 'Date', 'Buffer', 'RegExp', 'any', 'unknown'];
-            if (mappedType instanceof t.unknown
+            if (mappedType instanceof t.unknown &&
                 // it could be a runtime type from reflect-metadata
-                && !SCALAR_TYPES.includes(prop.type)
+                !SCALAR_TYPES.includes(prop.type) &&
                 // or it might be inferred via ts-morph to some generic type alias
-                && !prop.type.match(/[<>:"';{}]/)) {
+                !prop.type.match(/[<>:"';{}]/)) {
                 const type = prop.length != null && !prop.type.endsWith(`(${prop.length})`) ? `${prop.type}(${prop.length})` : prop.type;
                 prop.columnTypes = [type];
             }
@@ -1736,9 +1792,7 @@ export class MetadataDiscovery {
         const targetMeta = prop.targetMeta;
         prop.columnTypes = [];
         // Use targetKey property if specified, otherwise use primary key properties
-        const referencedProps = prop.targetKey
-            ? [targetMeta.properties[prop.targetKey]]
-            : targetMeta.getPrimaryProps();
+        const referencedProps = prop.targetKey ? [targetMeta.properties[prop.targetKey]] : targetMeta.getPrimaryProps();
         if (prop.polymorphic && prop.polymorphTargets) {
             prop.columnTypes.push(this.platform.getVarcharTypeDeclarationSQL(prop));
         }
@@ -1796,7 +1850,8 @@ export class MetadataDiscovery {
             });
             return;
         }
-        prop.unsigned ??= (prop.primary || prop.unsigned) && this.platform.isNumericProperty(prop) && this.platform.supportsUnsigned();
+        prop.unsigned ??=
+            (prop.primary || prop.unsigned) && this.platform.isNumericProperty(prop) && this.platform.supportsUnsigned();
     }
     initIndexes(meta, prop) {
         const hasIndex = meta.indexes.some(idx => idx.properties?.length === 1 && idx.properties[0] === prop.name);

package/metadata/MetadataProvider.js

@@ -13,7 +13,12 @@ export class MetadataProvider {
             }
             else if (prop.entity) {
                 const tmp = prop.entity();
-                prop.type = Array.isArray(tmp) ? tmp.map(t => Utils.className(t)).sort().join(' | ') : Utils.className(tmp);
+                prop.type = Array.isArray(tmp)
+                    ? tmp
+                        .map(t => Utils.className(t))
+                        .sort()
+                        .join(' | ')
+                    : Utils.className(tmp);
                 prop.target = tmp instanceof EntitySchema ? tmp.meta.class : tmp;
             }
             else if (!prop.type && !((prop.enum || prop.array) && (prop.items?.length ?? 0) > 0)) {

package/metadata/MetadataStorage.js

@@ -90,9 +90,7 @@ export class MetadataStorage {
         }
     }
     decorate(em) {
-        [...this.metadata.values()]
-            .filter(meta => meta.prototype)
-            .forEach(meta => EntityHelper.decorate(meta, em));
+        [...this.metadata.values()].filter(meta => meta.prototype).forEach(meta => EntityHelper.decorate(meta, em));
     }
     *[Symbol.iterator]() {
         for (const meta of this.metadata.values()) {

package/metadata/MetadataValidator.js

@@ -63,7 +63,11 @@ export class MetadataValidator {
         }
         // Validate no mixing of STI and TPT in the same hierarchy
         this.validateInheritanceStrategies(discovered);
-        const tableNames = discovered.filter(meta => !meta.abstract && !meta.embeddable && meta === meta.root && (meta.tableName || meta.collection) && meta.schema !== '*');
+        const tableNames = discovered.filter(meta => !meta.abstract &&
+            !meta.embeddable &&
+            meta === meta.root &&
+            (meta.tableName || meta.collection) &&
+            meta.schema !== '*');
         const duplicateTableNames = Utils.findDuplicates(tableNames.map(meta => {
             const tableName = meta.tableName || meta.collection;
             return (meta.schema ? '.' + meta.schema : '') + tableName;
@@ -88,7 +92,10 @@ export class MetadataValidator {
         const pivotProps = new Map();
         // 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))) {
+            if (prop.kind !== ReferenceKind.SCALAR &&
+                !unwrap(prop.type)
+                    .split(/ ?\| ?/)
+                    .every(type => discovered.find(m => m.className === type))) {
                 throw MetadataError.fromUnknownEntity(prop.type, `${meta.className}.${prop.name}`);
             }
             if (prop.pivotEntity) {
@@ -122,7 +129,10 @@ export class MetadataValidator {
         if (targetMeta.abstract && !targetMeta.root?.inheritanceType && !targetMeta.embeddable) {
             throw MetadataError.targetIsAbstract(meta, prop);
         }
-        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && prop.persist === false && targetMeta.compositePK && options.checkNonPersistentCompositeProps) {
+        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) &&
+            prop.persist === false &&
+            targetMeta.compositePK &&
+            options.checkNonPersistentCompositeProps) {
             throw MetadataError.nonPersistentCompositeProp(meta, prop);
         }
         this.validateTargetKey(meta, prop, targetMeta);
@@ -248,7 +258,9 @@ export class MetadataValidator {
         // has correct `mappedBy` reference type
         // For polymorphic relations, check if this entity is one of the polymorphic targets
         const isValidPolymorphicInverse = owner.polymorphic && owner.polymorphTargets?.some(target => target.class === meta.root.class);
-        if (!isValidPolymorphicInverse && owner.type !== meta.className && owner.targetMeta?.root.class !== meta.root.class) {
+        if (!isValidPolymorphicInverse &&
+            owner.type !== meta.className &&
+            owner.targetMeta?.root.class !== meta.root.class) {
             throw MetadataError.fromWrongReference(meta, prop, 'mappedBy', owner);
         }
         // owning side is not defined as inverse
@@ -280,7 +292,10 @@ export class MetadataValidator {
     }
     validateDuplicateFieldNames(meta, options) {
         const candidates = Object.values(meta.properties)
-            .filter(prop => prop.persist !== false && !prop.inherited && prop.fieldNames?.length === 1 && (prop.kind !== ReferenceKind.EMBEDDED || prop.object))
+            .filter(prop => prop.persist !== false &&
+            !prop.inherited &&
+            prop.fieldNames?.length === 1 &&
+            (prop.kind !== ReferenceKind.EMBEDDED || prop.object))
             .map(prop => prop.fieldNames[0]);
         const duplicates = Utils.findDuplicates(candidates);
         if (duplicates.length > 0 && options.checkDuplicateFieldNames) {

package/metadata/types.d.ts

@@ -526,7 +526,7 @@ export interface IndexColumnOptions {
 }
 interface BaseOptions<T, H extends string> {
     name?: string;
-    properties?: (T extends EntityClass<infer P> ? Properties<P, H> : Properties<T, H>);
+    properties?: T extends EntityClass<infer P> ? Properties<P, H> : Properties<T, H>;
     options?: Dictionary;
     expression?: string | (T extends EntityClass<infer P> ? IndexCallback<P> : IndexCallback<T>);
     /**
@@ -540,7 +540,7 @@ interface BaseOptions<T, H extends string> {
      * Columns to include in the index but not as part of the key (PostgreSQL, MSSQL).
      * These columns are stored in the leaf level of the index but not used for searching.
      */
-    include?: (T extends EntityClass<infer P> ? Properties<P, H> : Properties<T, H>);
+    include?: T extends EntityClass<infer P> ? Properties<P, H> : Properties<T, H>;
     /** Fill factor for the index as a percentage 0-100 (PostgreSQL, MSSQL). */
     fillFactor?: number;
 }

package/naming-strategy/AbstractNamingStrategy.js

@@ -35,10 +35,13 @@ export class AbstractNamingStrategy {
      */
     getEntityName(tableName, schemaName) {
         const name = tableName.match(/^[^$_\p{ID_Start}]/u) ? `E_${tableName}` : tableName;
-        return this.getClassName(name.replaceAll(/[^\u200C\u200D\p{ID_Continue}]+/ug, r => r.split('').map(c => `$${c.codePointAt(0)}`).join('')), '_');
+        return this.getClassName(name.replaceAll(/[^\u200C\u200D\p{ID_Continue}]+/gu, r => r
+            .split('')
+            .map(c => `$${c.codePointAt(0)}`)
+            .join('')), '_');
     }
     columnNameToProperty(columnName) {
-        const propName = columnName.replace(/[_\- ]+(\w)/ug, (_, p1) => p1.toUpperCase());
+        const propName = columnName.replace(/[_\- ]+(\w)/gu, (_, p1) => p1.toUpperCase());
         if (populatePathMembers.includes(propName.replace(/^\${2,}/u, '$$').replace(/^\$\*$/u, '*'))) {
             return `$${propName}`;
         }

package/not-supported.js

@@ -1,4 +1,8 @@
 export function discoverEntities() {
     throw new Error('Folder-based discovery is not supported in this environment.');
 }
-export const fs = new Proxy({}, { get: () => { throw new Error('File system is not supported in this environment.'); } });
+export const fs = new Proxy({}, {
+    get: () => {
+        throw new Error('File system is not supported in this environment.');
+    },
+});

package/package.json

@@ -1,8 +1,39 @@
 {
   "name": "@mikro-orm/core",
-  "type": "module",
-  "version": "7.0.0-dev.300",
+  "version": "7.0.0-dev.302",
   "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",
+    "ddd",
+    "entity",
+    "identity-map",
+    "javascript",
+    "js",
+    "mariadb",
+    "mikro-orm",
+    "mongo",
+    "mongodb",
+    "mysql",
+    "orm",
+    "postgresql",
+    "sqlite",
+    "sqlite3",
+    "ts",
+    "typescript",
+    "unit-of-work"
+  ],
+  "homepage": "https://mikro-orm.io",
+  "bugs": {
+    "url": "https://github.com/mikro-orm/mikro-orm/issues"
+  },
+  "license": "MIT",
+  "author": "Martin Adámek",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
+  },
+  "funding": "https://github.com/sponsors/b4nan",
+  "type": "module",
   "exports": {
     "./package.json": "./package.json",
     ".": "./index.js",
@@ -18,39 +49,8 @@
     "./schema": "./utils/AbstractSchemaGenerator.js",
     "./dataloader": "./utils/DataloaderUtils.js"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
-  },
-  "funding": "https://github.com/sponsors/b4nan",
-  "keywords": [
-    "orm",
-    "mongo",
-    "mongodb",
-    "mysql",
-    "mariadb",
-    "postgresql",
-    "sqlite",
-    "sqlite3",
-    "ts",
-    "typescript",
-    "js",
-    "javascript",
-    "entity",
-    "ddd",
-    "mikro-orm",
-    "unit-of-work",
-    "data-mapper",
-    "identity-map"
-  ],
-  "author": "Martin Adámek",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/mikro-orm/mikro-orm/issues"
-  },
-  "homepage": "https://mikro-orm.io",
-  "engines": {
-    "node": ">= 22.17.0"
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {
     "build": "yarn compile && yarn copy",
@@ -58,9 +58,6 @@
     "compile": "yarn run -T tsc -p tsconfig.build.json",
     "copy": "node ../../scripts/copy.mjs"
   },
-  "publishConfig": {
-    "access": "public"
-  },
   "peerDependencies": {
     "dataloader": "2.2.3"
   },
@@ -68,5 +65,8 @@
     "dataloader": {
       "optional": true
     }
+  },
+  "engines": {
+    "node": ">= 22.17.0"
   }
 }