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

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)) {
@@ -29,7 +34,27 @@ export class MetadataProvider {
                 delete prop.items;
             }
         });
+        // Preserve function expressions from indexes/uniques — they can't survive JSON cache serialization
+        const expressionMap = new Map();
+        for (const arr of [meta.indexes, meta.uniques]) {
+            for (const idx of arr ?? []) {
+                if (typeof idx.expression === 'function' && idx.name) {
+                    expressionMap.set(idx.name, idx.expression);
+                }
+            }
+        }
         Utils.mergeConfig(meta, cache);
+        // Restore function expressions that were lost during JSON serialization
+        if (expressionMap.size > 0) {
+            for (const arr of [meta.indexes, meta.uniques]) {
+                for (const idx of arr ?? []) {
+                    const fn = idx.name && expressionMap.get(idx.name);
+                    if (fn && typeof idx.expression !== 'function') {
+                        idx.expression = fn;
+                    }
+                }
+            }
+        }
     }
     static useCache() {
         return false;

package/metadata/MetadataStorage.d.ts

@@ -1,12 +1,8 @@
 import { type Dictionary, EntityMetadata, type EntityName } from '../typings.js';
 import type { EntityManager } from '../EntityManager.js';
 export declare class MetadataStorage {
+    #private;
     static readonly PATH_SYMBOL: unique symbol;
-    private static readonly metadata;
-    private readonly metadata;
-    private readonly idMap;
-    private readonly classNameMap;
-    private readonly uniqueNameMap;
     constructor(metadata?: Dictionary<EntityMetadata>);
     static getMetadata(): Dictionary<EntityMetadata>;
     static getMetadata<T = any>(entity: string, path: string): EntityMetadata<T>;

package/metadata/MetadataStorage.js

@@ -9,40 +9,40 @@ function getGlobalStorage(namespace) {
     return globalThis[key];
 }
 export class MetadataStorage {
-    static PATH_SYMBOL = Symbol('MetadataStorage.PATH_SYMBOL');
-    static metadata = getGlobalStorage('metadata');
-    metadata = new Map();
-    idMap;
-    classNameMap;
-    uniqueNameMap;
+    static PATH_SYMBOL = Symbol.for('@mikro-orm/core/MetadataStorage.PATH_SYMBOL');
+    static #metadata = getGlobalStorage('metadata');
+    #metadataMap = new Map();
+    #idMap;
+    #classNameMap;
+    #uniqueNameMap;
     constructor(metadata = {}) {
-        this.idMap = {};
-        this.uniqueNameMap = {};
-        this.classNameMap = Utils.copy(metadata, false);
-        for (const meta of Object.values(this.classNameMap)) {
-            this.idMap[meta._id] = meta;
-            this.uniqueNameMap[meta.uniqueName] = meta;
-            this.metadata.set(meta.class, meta);
+        this.#idMap = {};
+        this.#uniqueNameMap = {};
+        this.#classNameMap = Utils.copy(metadata, false);
+        for (const meta of Object.values(this.#classNameMap)) {
+            this.#idMap[meta._id] = meta;
+            this.#uniqueNameMap[meta.uniqueName] = meta;
+            this.#metadataMap.set(meta.class, meta);
         }
     }
     static getMetadata(entity, path) {
         const key = entity && path ? entity + '-' + Utils.hash(path) : null;
-        if (key && !MetadataStorage.metadata[key]) {
-            MetadataStorage.metadata[key] = new EntityMetadata({ className: entity, path });
+        if (key && !MetadataStorage.#metadata[key]) {
+            MetadataStorage.#metadata[key] = new EntityMetadata({ className: entity, path });
         }
         if (key) {
-            return MetadataStorage.metadata[key];
+            return MetadataStorage.#metadata[key];
         }
-        return MetadataStorage.metadata;
+        return MetadataStorage.#metadata;
     }
     static isKnownEntity(name) {
-        return !!Object.values(this.metadata).find(meta => meta.className === name);
+        return !!Object.values(this.#metadata).find(meta => meta.className === name);
     }
     static clear() {
-        Object.keys(this.metadata).forEach(k => delete this.metadata[k]);
+        Object.keys(this.#metadata).forEach(k => delete this.#metadata[k]);
     }
     getAll() {
-        return this.metadata;
+        return this.#metadataMap;
     }
     get(entityName, init = false) {
         const exists = this.find(entityName);
@@ -61,52 +61,50 @@ export class MetadataStorage {
         if (!entityName) {
             return;
         }
-        const meta = this.metadata.get(entityName);
+        const meta = this.#metadataMap.get(entityName);
         if (meta) {
             return meta;
         }
         if (entityName instanceof EntitySchema) {
-            return this.metadata.get(entityName.meta.class) ?? entityName.meta;
+            return this.#metadataMap.get(entityName.meta.class) ?? entityName.meta;
         }
-        return this.classNameMap[Utils.className(entityName)];
+        return this.#classNameMap[Utils.className(entityName)];
     }
     has(entityName) {
-        return this.metadata.has(entityName);
+        return this.#metadataMap.has(entityName);
     }
     set(entityName, meta) {
-        this.metadata.set(entityName, meta);
-        this.idMap[meta._id] = meta;
-        this.uniqueNameMap[meta.uniqueName] = meta;
-        this.classNameMap[Utils.className(entityName)] = meta;
+        this.#metadataMap.set(entityName, meta);
+        this.#idMap[meta._id] = meta;
+        this.#uniqueNameMap[meta.uniqueName] = meta;
+        this.#classNameMap[Utils.className(entityName)] = meta;
         return meta;
     }
     reset(entityName) {
         const meta = this.find(entityName);
         if (meta) {
-            this.metadata.delete(meta.class);
-            delete this.idMap[meta._id];
-            delete this.uniqueNameMap[meta.uniqueName];
-            delete this.classNameMap[meta.className];
+            this.#metadataMap.delete(meta.class);
+            delete this.#idMap[meta._id];
+            delete this.#uniqueNameMap[meta.uniqueName];
+            delete this.#classNameMap[meta.className];
         }
     }
     decorate(em) {
-        [...this.metadata.values()]
-            .filter(meta => meta.prototype)
-            .forEach(meta => EntityHelper.decorate(meta, em));
+        [...this.#metadataMap.values()].filter(meta => meta.prototype).forEach(meta => EntityHelper.decorate(meta, em));
     }
     *[Symbol.iterator]() {
-        for (const meta of this.metadata.values()) {
+        for (const meta of this.#metadataMap.values()) {
             yield meta;
         }
     }
     getById(id) {
-        return this.idMap[id];
+        return this.#idMap[id];
     }
     getByClassName(className, validate = true) {
-        return this.validate(this.classNameMap[className], className, validate);
+        return this.validate(this.#classNameMap[className], className, validate);
     }
     getByUniqueName(uniqueName, validate = true) {
-        return this.validate(this.uniqueNameMap[uniqueName], uniqueName, validate);
+        return this.validate(this.#uniqueNameMap[uniqueName], uniqueName, validate);
     }
     validate(meta, id, validate) {
         if (!meta && validate) {

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/discover-entities.js

@@ -31,7 +31,7 @@ export async function discoverEntities(paths, options) {
     const found = new Map();
     for (const filepath of files) {
         const filename = basename(filepath);
-        if (!filename.match(/\.[cm]?[jt]s$/) || filename.match(/\.d\.[cm]?ts/)) {
+        if (!/\.[cm]?[jt]s$/.exec(filename) || /\.d\.[cm]?ts/.exec(filename)) {
             continue;
         }
         await getEntityClassOrSchema(filepath, found, baseDir);

package/metadata/index.d.ts

@@ -1,4 +1,4 @@
-export * from './types.js';
+export type * from './types.js';
 export * from './EntitySchema.js';
 export * from './MetadataDiscovery.js';
 export * from './MetadataStorage.js';

package/metadata/index.js

@@ -1,4 +1,3 @@
-export * from './types.js';
 export * from './EntitySchema.js';
 export * from './MetadataDiscovery.js';
 export * from './MetadataStorage.js';

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

@@ -34,11 +34,14 @@ export class AbstractNamingStrategy {
      * @inheritDoc
      */
     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('')), '_');
+        const name = /^[^$_\p{ID_Start}]/u.exec(tableName) ? `E_${tableName}` : tableName;
+        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/naming-strategy/EntityCaseNamingStrategy.js

@@ -11,7 +11,7 @@ export class EntityCaseNamingStrategy extends AbstractNamingStrategy {
     }
     joinKeyColumnName(entityName, referencedColumnName, composite, tableName) {
         entityName = this.classToTableName(entityName, tableName);
-        const name = entityName.substr(0, 1).toLowerCase() + entityName.substr(1);
+        const name = entityName.substring(0, 1).toLowerCase() + entityName.substring(1);
         if (composite && referencedColumnName) {
             return name + '_' + referencedColumnName;
         }

package/naming-strategy/index.d.ts

@@ -1,4 +1,4 @@
-export * from './NamingStrategy.js';
+export type * from './NamingStrategy.js';
 export * from './AbstractNamingStrategy.js';
 export * from './MongoNamingStrategy.js';
 export * from './UnderscoreNamingStrategy.js';

package/naming-strategy/index.js

@@ -1,4 +1,3 @@
-export * from './NamingStrategy.js';
 export * from './AbstractNamingStrategy.js';
 export * from './MongoNamingStrategy.js';
 export * from './UnderscoreNamingStrategy.js';

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-rc.2",
+  "version": "7.0.0",
   "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"
   }
 }

package/platforms/Platform.d.ts

@@ -1,6 +1,6 @@
 import { EntityRepository } from '../entity/EntityRepository.js';
 import { type NamingStrategy } from '../naming-strategy/NamingStrategy.js';
-import type { Constructor, EntityMetadata, EntityProperty, IPrimaryKey, ISchemaGenerator, PopulateOptions, Primary, SimpleColumnMeta } from '../typings.js';
+import type { Constructor, EntityMetadata, EntityProperty, IPrimaryKey, ISchemaGenerator, PopulateOptions, Primary, SimpleColumnMeta, FilterQuery, EntityValue, EntityKey } from '../typings.js';
 import { ExceptionConverter } from './ExceptionConverter.js';
 import type { EntityManager } from '../EntityManager.js';
 import type { Configuration } from '../utils/Configuration.js';
@@ -61,6 +61,13 @@ export declare abstract class Platform {
     getDateTypeDeclarationSQL(length?: number): string;
     getTimeTypeDeclarationSQL(length?: number): string;
     getRegExpOperator(val?: unknown, flags?: string): string;
+    mapRegExpCondition(mappedKey: string, value: {
+        $re: string;
+        $flags?: string;
+    }): {
+        sql: string;
+        params: unknown[];
+    };
     getRegExpValue(val: RegExp): {
         $re: string;
         $flags?: string;
@@ -139,7 +146,13 @@ export declare abstract class Platform {
     getMappedType(type: string): Type<unknown>;
     getDefaultMappedType(type: string): Type<unknown>;
     supportsMultipleCascadePaths(): boolean;
+    /**
+     * Returns true if the platform supports ON UPDATE foreign key rules.
+     * Oracle doesn't support ON UPDATE rules.
+     */
+    supportsOnUpdate(): boolean;
     supportsMultipleStatements(): boolean;
+    supportsUnionWhere(): boolean;
     getArrayDeclarationSQL(): string;
     marshallArray(values: string[]): string;
     unmarshallArray(value: string): string[];
@@ -147,6 +160,8 @@ export declare abstract class Platform {
     getJsonDeclarationSQL(): string;
     getSearchJsonPropertySQL(path: string, type: string, aliased: boolean): string | Raw;
     getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean, value?: unknown): string | Raw;
+    processJsonCondition<T extends object>(o: FilterQuery<T>, value: EntityValue<T>, path: EntityKey<T>[], alias: boolean): FilterQuery<T>;
+    protected getJsonValueType(value: unknown): string;
     getJsonIndexDefinition(index: {
         columnNames: string[];
     }): string[];
@@ -159,6 +174,14 @@ export declare abstract class Platform {
     convertDateToJSValue(value: string | Date): string;
     convertIntervalToJSValue(value: string): unknown;
     convertIntervalToDatabaseValue(value: unknown): unknown;
+    usesAsKeyword(): boolean;
+    /**
+     * Determines how UUID values are compared in the change set tracking.
+     * Return `'string'` for inline string comparison (fast), or `'any'` for deep comparison via type methods.
+     */
+    compareUuids(): string;
+    convertUuidToJSValue(value: unknown): unknown;
+    convertUuidToDatabaseValue(value: unknown): unknown;
     parseDate(value: string | number): Date;
     getRepositoryClass<T extends object>(): Constructor<EntityRepository<T>>;
     getDefaultCharset(): string;