@mikro-orm/reflection 7.0.4-dev.9 → 7.0.4

package/README.md

@@ -133,7 +133,7 @@ const author = await em.findOneOrFail(Author, 1, {
   populate: ['books'],
 });
 author.name = 'Jon Snow II';
-author.books.getItems().forEach(book => book.title += ' (2nd ed.)');
+author.books.getItems().forEach(book => (book.title += ' (2nd ed.)'));
 author.books.add(orm.em.create(Book, { title: 'New Book', author }));
 
 // Flush computes change sets and executes them in a single transaction

package/TsMorphMetadataProvider.d.ts

@@ -2,22 +2,22 @@ import { type SourceFile } from 'ts-morph';
 import { type EntityMetadata, MetadataProvider } from '@mikro-orm/core';
 /** Metadata provider that uses ts-morph to infer property types from TypeScript source files or declaration files. */
 export declare class TsMorphMetadataProvider extends MetadataProvider {
-    private project;
-    private sources;
-    static useCache(): boolean;
-    useCache(): boolean;
-    loadEntityMetadata(meta: EntityMetadata): void;
-    getExistingSourceFile(path: string, ext?: string, validate?: boolean): SourceFile;
-    protected initProperties(meta: EntityMetadata): void;
-    private extractType;
-    private cleanUpTypeTags;
-    private initPropertyType;
-    private readTypeFromSource;
-    private getSourceFile;
-    private stripRelativePath;
-    private processWrapper;
-    private initProject;
-    private initSourceFiles;
-    saveToCache(meta: EntityMetadata): void;
-    getCacheKey(meta: Pick<EntityMetadata, 'className' | 'path'>): string;
+  private project;
+  private sources;
+  static useCache(): boolean;
+  useCache(): boolean;
+  loadEntityMetadata(meta: EntityMetadata): void;
+  getExistingSourceFile(path: string, ext?: string, validate?: boolean): SourceFile;
+  protected initProperties(meta: EntityMetadata): void;
+  private extractType;
+  private cleanUpTypeTags;
+  private initPropertyType;
+  private readTypeFromSource;
+  private getSourceFile;
+  private stripRelativePath;
+  private processWrapper;
+  private initProject;
+  private initSourceFiles;
+  saveToCache(meta: EntityMetadata): void;
+  getCacheKey(meta: Pick<EntityMetadata, 'className' | 'path'>): string;
 }

package/TsMorphMetadataProvider.js

@@ -1,256 +1,271 @@
 import { extname } from 'node:path';
-import { ComputedPropertyName, ModuleKind, NoSubstitutionTemplateLiteral, Project, StringLiteral, } from 'ts-morph';
-import { EntitySchema, MetadataError, MetadataProvider, MetadataStorage, RawQueryFragment, ReferenceKind, Type, Utils, } from '@mikro-orm/core';
+import { ComputedPropertyName, ModuleKind, NoSubstitutionTemplateLiteral, Project, StringLiteral } from 'ts-morph';
+import {
+  EntitySchema,
+  MetadataError,
+  MetadataProvider,
+  MetadataStorage,
+  RawQueryFragment,
+  ReferenceKind,
+  Type,
+  Utils,
+} from '@mikro-orm/core';
 import { fs } from '@mikro-orm/core/fs-utils';
 /** Metadata provider that uses ts-morph to infer property types from TypeScript source files or declaration files. */
 export class TsMorphMetadataProvider extends MetadataProvider {
-    project;
-    sources;
-    static useCache() {
-        return true;
+  project;
+  sources;
+  static useCache() {
+    return true;
+  }
+  useCache() {
+    return this.config.get('metadataCache').enabled ?? TsMorphMetadataProvider.useCache();
+  }
+  loadEntityMetadata(meta) {
+    if (!meta.path) {
+      return;
     }
-    useCache() {
-        return this.config.get('metadataCache').enabled ?? TsMorphMetadataProvider.useCache();
+    this.initProperties(meta);
+  }
+  getExistingSourceFile(path, ext, validate = true) {
+    if (!ext) {
+      return this.getExistingSourceFile(path, '.d.ts', false) || this.getExistingSourceFile(path, '.ts');
     }
-    loadEntityMetadata(meta) {
-        if (!meta.path) {
-            return;
-        }
-        this.initProperties(meta);
+    const tsPath = /.*\/[^/]+$/.exec(path)[0].replace(/\.js$/, ext);
+    return this.getSourceFile(tsPath, validate);
+  }
+  initProperties(meta) {
+    meta.path = fs.normalizePath(meta.path);
+    // load types and column names
+    for (const prop of Object.values(meta.properties)) {
+      const { type, target } = this.extractType(meta, prop);
+      this.initPropertyType(meta, prop);
+      prop.type = type ?? prop.type;
+      prop.target = target;
     }
-    getExistingSourceFile(path, ext, validate = true) {
-        if (!ext) {
-            return this.getExistingSourceFile(path, '.d.ts', false) || this.getExistingSourceFile(path, '.ts');
-        }
-        const tsPath = /.*\/[^/]+$/.exec(path)[0].replace(/\.js$/, ext);
-        return this.getSourceFile(tsPath, validate);
+  }
+  extractType(meta, prop) {
+    /* v8 ignore next */
+    if (typeof prop.entity === 'string') {
+      throw new Error(
+        `Relation target needs to be an entity class or EntitySchema instance, '${prop.entity}' given instead for ${meta.className}.${prop.name}.`,
+      );
     }
-    initProperties(meta) {
-        meta.path = fs.normalizePath(meta.path);
-        // load types and column names
-        for (const prop of Object.values(meta.properties)) {
-            const { type, target } = this.extractType(meta, prop);
-            this.initPropertyType(meta, prop);
-            prop.type = type ?? prop.type;
-            prop.target = target;
-        }
+    if (!prop.entity) {
+      return { type: prop.type };
     }
-    extractType(meta, prop) {
-        /* v8 ignore next */
-        if (typeof prop.entity === 'string') {
-            throw new Error(`Relation target needs to be an entity class or EntitySchema instance, '${prop.entity}' given instead for ${meta.className}.${prop.name}.`);
-        }
-        if (!prop.entity) {
-            return { type: prop.type };
-        }
-        const tmp = prop.entity();
-        const target = EntitySchema.is(tmp) ? tmp.meta.class : tmp;
-        return { type: Utils.className(target), target };
+    const tmp = prop.entity();
+    const target = EntitySchema.is(tmp) ? tmp.meta.class : tmp;
+    return { type: Utils.className(target), target };
+  }
+  cleanUpTypeTags(type) {
+    const genericTags = [/Opt<(.*?)>/, /Hidden<(.*?)>/, /RequiredNullable<(.*?)>/];
+    const intersectionTags = ['Opt.Brand', 'Hidden.Brand', 'RequiredNullable.Brand'];
+    for (const tag of genericTags) {
+      type = type.replace(tag, '$1');
     }
-    cleanUpTypeTags(type) {
-        const genericTags = [/Opt<(.*?)>/, /Hidden<(.*?)>/, /RequiredNullable<(.*?)>/];
-        const intersectionTags = ['Opt.Brand', 'Hidden.Brand', 'RequiredNullable.Brand'];
-        for (const tag of genericTags) {
-            type = type.replace(tag, '$1');
-        }
-        for (const tag of intersectionTags) {
-            type = type.replace(' & ' + tag, '');
-            type = type.replace(tag + ' & ', '');
-        }
-        return type;
+    for (const tag of intersectionTags) {
+      type = type.replace(' & ' + tag, '');
+      type = type.replace(tag + ' & ', '');
     }
-    initPropertyType(meta, prop) {
-        const { type: typeRaw, optional } = this.readTypeFromSource(meta, prop);
-        prop.type = this.cleanUpTypeTags(typeRaw);
-        if (optional) {
-            prop.optional = true;
-        }
-        this.processWrapper(prop, 'Ref');
-        this.processWrapper(prop, 'Reference');
-        this.processWrapper(prop, 'EntityRef');
-        this.processWrapper(prop, 'ScalarRef');
-        this.processWrapper(prop, 'ScalarReference');
-        this.processWrapper(prop, 'Collection');
-        prop.runtimeType ??= prop.type;
-        if (/^(Dictionary|Record)<.*>$/.exec(prop.type.replace(/import\(.*\)\./g, ''))) {
-            prop.type = 'json';
-        }
+    return type;
+  }
+  initPropertyType(meta, prop) {
+    const { type: typeRaw, optional } = this.readTypeFromSource(meta, prop);
+    prop.type = this.cleanUpTypeTags(typeRaw);
+    if (optional) {
+      prop.optional = true;
     }
-    readTypeFromSource(meta, prop) {
-        const source = this.getExistingSourceFile(meta.path);
-        const cls = source.getClass(meta.className);
-        /* v8 ignore next */
-        if (!cls) {
-            throw new MetadataError(`Source class for entity ${meta.className} not found. Verify you have 'compilerOptions.declaration' enabled in your 'tsconfig.json'. If you are using webpack, see https://bit.ly/35pPDNn`);
-        }
-        const properties = cls.getInstanceProperties();
-        const property = properties.find(v => {
-            if (v.getName() === prop.name) {
-                return true;
-            }
-            const nameNode = v.getNameNode();
-            if (nameNode instanceof StringLiteral && nameNode.getLiteralText() === prop.name) {
-                return true;
-            }
-            if (nameNode instanceof ComputedPropertyName) {
-                const expr = nameNode.getExpression();
-                if (expr instanceof NoSubstitutionTemplateLiteral && expr.getLiteralText() === prop.name) {
-                    return true;
-                }
-            }
-            return false;
-        });
-        if (!property) {
-            return { type: prop.type, optional: prop.nullable };
-        }
-        const tsType = property.getType();
-        const typeName = tsType.getText(property);
-        if (prop.enum && tsType.isEnum()) {
-            prop.items = tsType.getUnionTypes().map(t => t.getLiteralValueOrThrow());
-        }
-        if (tsType.isArray()) {
-            prop.array = true;
-            /* v8 ignore next */
-            if (tsType.getArrayElementType().isEnum()) {
-                prop.items = tsType
-                    .getArrayElementType()
-                    .getUnionTypes()
-                    .map(t => t.getLiteralValueOrThrow());
-            }
-        }
-        if (prop.array && prop.enum) {
-            prop.enum = false;
-        }
-        let type = typeName;
-        const union = type.split(' | ');
-        const optional = property.hasQuestionToken?.() || union.includes('null') || union.includes('undefined') || tsType.isNullable();
-        type = union.filter(t => !['null', 'undefined'].includes(t)).join(' | ');
-        prop.array ??= type.endsWith('[]') || !!/Array<(.*)>/.exec(type);
-        type = type
-            .replace(/Array<(.*)>/, '$1') // unwrap array
-            .replace(/\[]$/, '') // remove array suffix
-            .replace(/\((.*)\)/, '$1'); // unwrap union types
-        // keep the array suffix in the type, it is needed in few places in discovery and comparator (`prop.array` is used only for enum arrays)
-        if (prop.array && !type.includes(' | ') && prop.kind === ReferenceKind.SCALAR) {
-            type += '[]';
-        }
-        return { type, optional };
+    this.processWrapper(prop, 'Ref');
+    this.processWrapper(prop, 'Reference');
+    this.processWrapper(prop, 'EntityRef');
+    this.processWrapper(prop, 'ScalarRef');
+    this.processWrapper(prop, 'ScalarReference');
+    this.processWrapper(prop, 'Collection');
+    prop.runtimeType ??= prop.type;
+    if (/^(Dictionary|Record)<.*>$/.exec(prop.type.replace(/import\(.*\)\./g, ''))) {
+      prop.type = 'json';
     }
-    getSourceFile(tsPath, validate) {
-        if (!this.sources) {
-            this.initSourceFiles();
-        }
-        const baseDir = this.config.get('baseDir');
-        const outDir = this.project.getCompilerOptions().outDir;
-        let path = tsPath;
-        /* v8 ignore next */
-        if (outDir != null) {
-            const outDirRelative = fs.relativePath(outDir, baseDir);
-            path = path.replace(new RegExp(`^${outDirRelative}`), '');
-        }
-        path = this.stripRelativePath(path);
-        const source = this.sources.find(s => s.getFilePath().endsWith(path));
-        if (!source && validate) {
-            throw new MetadataError(`Source file '${fs.relativePath(tsPath, baseDir)}' not found. Check your 'entitiesTs' option and verify you have 'compilerOptions.declaration' enabled in your 'tsconfig.json'. If you are using webpack, see https://bit.ly/35pPDNn`);
+  }
+  readTypeFromSource(meta, prop) {
+    const source = this.getExistingSourceFile(meta.path);
+    const cls = source.getClass(meta.className);
+    /* v8 ignore next */
+    if (!cls) {
+      throw new MetadataError(
+        `Source class for entity ${meta.className} not found. Verify you have 'compilerOptions.declaration' enabled in your 'tsconfig.json'. If you are using webpack, see https://bit.ly/35pPDNn`,
+      );
+    }
+    const properties = cls.getInstanceProperties();
+    const property = properties.find(v => {
+      if (v.getName() === prop.name) {
+        return true;
+      }
+      const nameNode = v.getNameNode();
+      if (nameNode instanceof StringLiteral && nameNode.getLiteralText() === prop.name) {
+        return true;
+      }
+      if (nameNode instanceof ComputedPropertyName) {
+        const expr = nameNode.getExpression();
+        if (expr instanceof NoSubstitutionTemplateLiteral && expr.getLiteralText() === prop.name) {
+          return true;
         }
-        return source;
+      }
+      return false;
+    });
+    if (!property) {
+      return { type: prop.type, optional: prop.nullable };
     }
-    stripRelativePath(str) {
-        return str.replace(/^(?:\.\.\/|\.\/)+/, '/');
+    const tsType = property.getType();
+    const typeName = tsType.getText(property);
+    if (prop.enum && tsType.isEnum()) {
+      prop.items = tsType.getUnionTypes().map(t => t.getLiteralValueOrThrow());
     }
-    processWrapper(prop, wrapper) {
-        // type can be sometimes in form of:
-        // `'({ object?: Entity | undefined; } & import("...").Reference<Entity>)'`
-        // `{ object?: import("...").Entity | undefined; } & import("...").Reference<Entity>`
-        // `{ node?: ({ id?: number | undefined; } & import("...").Reference<import("...").Entity>) | undefined; } & import("...").Reference<Entity>`
-        // the regexp is looking for the `wrapper`, possible prefixed with `.` or wrapped in parens.
-        const type = prop.type.replace(/import\(.*\)\./g, '').replace(/\{ .* } & ([\w &]+)/g, '$1');
-        const m = new RegExp(`(?:^|[.( ])${wrapper}<(\\w+),?.*>(?:$|[) ])`).exec(type);
-        if (!m) {
-            return;
-        }
-        prop.type = m[1];
-        if (['Ref', 'Reference', 'EntityRef', 'ScalarRef', 'ScalarReference'].includes(wrapper)) {
-            prop.ref = true;
-        }
+    if (tsType.isArray()) {
+      prop.array = true;
+      /* v8 ignore next */
+      if (tsType.getArrayElementType().isEnum()) {
+        prop.items = tsType
+          .getArrayElementType()
+          .getUnionTypes()
+          .map(t => t.getLiteralValueOrThrow());
+      }
     }
-    initProject() {
-        /* v8 ignore next */
-        const tsConfigFilePath = this.config.get('discovery').tsConfigPath ?? './tsconfig.json';
-        try {
-            this.project = new Project({
-                tsConfigFilePath: fs.normalizePath(process.cwd(), tsConfigFilePath),
-                skipAddingFilesFromTsConfig: true,
-                compilerOptions: {
-                    strictNullChecks: true,
-                    module: ModuleKind.Node20,
-                },
-            });
-        }
-        catch (e) {
-            this.config.getLogger().warn('discovery', e.message);
-            this.project = new Project({
-                compilerOptions: {
-                    strictNullChecks: true,
-                    module: ModuleKind.Node20,
-                },
-            });
-        }
+    let type = typeName;
+    const union = type.split(' | ');
+    const optional =
+      property.hasQuestionToken?.() || union.includes('null') || union.includes('undefined') || tsType.isNullable();
+    type = union.filter(t => !['null', 'undefined'].includes(t)).join(' | ');
+    prop.array ??= type.endsWith('[]') || !!/Array<(.*)>/.exec(type);
+    if (prop.array && prop.enum) {
+      prop.enum = false;
     }
-    initSourceFiles() {
-        this.initProject();
-        this.sources = [];
-        // All entity files are first required during the discovery, before we reach here, so it is safe to get the parts from the global
-        // metadata storage. We know the path thanks to the decorators being executed. In case we are running the TS code, the extension
-        // will be already `.ts`, so no change is needed. `.js` files will get renamed to `.d.ts` files as they will be used as a source for
-        // the ts-morph reflection.
-        for (const meta of Utils.values(MetadataStorage.getMetadata())) {
-            const metaPath = fs.normalizePath(meta.path);
-            /* v8 ignore next */
-            const path = /\.[jt]s$/.exec(metaPath) ? metaPath.replace(/\.js$/, '.d.ts') : `${metaPath}.d.ts`; // when entities are bundled, their paths are just their names
-            const sourceFile = this.project.addSourceFileAtPathIfExists(path);
-            if (sourceFile) {
-                this.sources.push(sourceFile);
-            }
-        }
+    type = type
+      .replace(/Array<(.*)>/, '$1') // unwrap array
+      .replace(/\[]$/, '') // remove array suffix
+      .replace(/\((.*)\)/, '$1'); // unwrap union types
+    // keep the array suffix in the type, it is needed in few places in discovery and comparator (`prop.array` is used only for enum arrays)
+    if (prop.array && !type.includes(' | ') && prop.kind === ReferenceKind.SCALAR) {
+      type += '[]';
     }
-    saveToCache(meta) {
-        if (!this.useCache()) {
-            return;
-        }
-        Reflect.deleteProperty(meta, 'root'); // to allow caching (as root can contain cycles)
-        const copy = Utils.copy(meta, false);
-        for (const prop of copy.props) {
-            if (Type.isMappedType(prop.type)) {
-                Reflect.deleteProperty(prop, 'type');
-                Reflect.deleteProperty(prop, 'customType');
-            }
-            if (prop.default) {
-                const raw = RawQueryFragment.getKnownFragment(prop.default);
-                if (raw) {
-                    prop.defaultRaw ??= this.config.getPlatform().formatQuery(raw.sql, raw.params);
-                    Reflect.deleteProperty(prop, 'default');
-                }
-            }
-            Reflect.deleteProperty(prop, 'targetMeta');
-        }
-        [
-            'prototype',
-            'props',
-            'referencingProperties',
-            'propertyOrder',
-            'relations',
-            'concurrencyCheckKeys',
-            'checks',
-        ].forEach(key => delete copy[key]);
-        // base entity without properties might not have path, but nothing to cache there
-        if (meta.path) {
-            meta.path = fs.relativePath(meta.path, this.config.get('baseDir'));
-            this.config.getMetadataCacheAdapter().set(this.getCacheKey(meta), copy, meta.path);
+    return { type, optional };
+  }
+  getSourceFile(tsPath, validate) {
+    if (!this.sources) {
+      this.initSourceFiles();
+    }
+    const baseDir = this.config.get('baseDir');
+    const outDir = this.project.getCompilerOptions().outDir;
+    let path = tsPath;
+    /* v8 ignore next */
+    if (outDir != null) {
+      const outDirRelative = fs.relativePath(outDir, baseDir);
+      path = path.replace(new RegExp(`^${outDirRelative}`), '');
+    }
+    path = this.stripRelativePath(path);
+    const source = this.sources.find(s => s.getFilePath().endsWith(path));
+    if (!source && validate) {
+      throw new MetadataError(
+        `Source file '${fs.relativePath(tsPath, baseDir)}' not found. Check your 'entitiesTs' option and verify you have 'compilerOptions.declaration' enabled in your 'tsconfig.json'. If you are using webpack, see https://bit.ly/35pPDNn`,
+      );
+    }
+    return source;
+  }
+  stripRelativePath(str) {
+    return str.replace(/^(?:\.\.\/|\.\/)+/, '/');
+  }
+  processWrapper(prop, wrapper) {
+    // type can be sometimes in form of:
+    // `'({ object?: Entity | undefined; } & import("...").Reference<Entity>)'`
+    // `{ object?: import("...").Entity | undefined; } & import("...").Reference<Entity>`
+    // `{ node?: ({ id?: number | undefined; } & import("...").Reference<import("...").Entity>) | undefined; } & import("...").Reference<Entity>`
+    // the regexp is looking for the `wrapper`, possible prefixed with `.` or wrapped in parens.
+    const type = prop.type.replace(/import\(.*\)\./g, '').replace(/\{ .* } & ([\w &]+)/g, '$1');
+    const m = new RegExp(`(?:^|[.( ])${wrapper}<(\\w+),?.*>(?:$|[) ])`).exec(type);
+    if (!m) {
+      return;
+    }
+    prop.type = m[1];
+    if (['Ref', 'Reference', 'EntityRef', 'ScalarRef', 'ScalarReference'].includes(wrapper)) {
+      prop.ref = true;
+    }
+  }
+  initProject() {
+    /* v8 ignore next */
+    const tsConfigFilePath = this.config.get('discovery').tsConfigPath ?? './tsconfig.json';
+    try {
+      this.project = new Project({
+        tsConfigFilePath: fs.normalizePath(process.cwd(), tsConfigFilePath),
+        skipAddingFilesFromTsConfig: true,
+        compilerOptions: {
+          strictNullChecks: true,
+          module: ModuleKind.Node20,
+        },
+      });
+    } catch (e) {
+      this.config.getLogger().warn('discovery', e.message);
+      this.project = new Project({
+        compilerOptions: {
+          strictNullChecks: true,
+          module: ModuleKind.Node20,
+        },
+      });
+    }
+  }
+  initSourceFiles() {
+    this.initProject();
+    this.sources = [];
+    // All entity files are first required during the discovery, before we reach here, so it is safe to get the parts from the global
+    // metadata storage. We know the path thanks to the decorators being executed. In case we are running the TS code, the extension
+    // will be already `.ts`, so no change is needed. `.js` files will get renamed to `.d.ts` files as they will be used as a source for
+    // the ts-morph reflection.
+    for (const meta of Utils.values(MetadataStorage.getMetadata())) {
+      const metaPath = fs.normalizePath(meta.path);
+      /* v8 ignore next */
+      const path = /\.[jt]s$/.exec(metaPath) ? metaPath.replace(/\.js$/, '.d.ts') : `${metaPath}.d.ts`; // when entities are bundled, their paths are just their names
+      const sourceFile = this.project.addSourceFileAtPathIfExists(path);
+      if (sourceFile) {
+        this.sources.push(sourceFile);
+      }
+    }
+  }
+  saveToCache(meta) {
+    if (!this.useCache()) {
+      return;
+    }
+    Reflect.deleteProperty(meta, 'root'); // to allow caching (as root can contain cycles)
+    const copy = Utils.copy(meta, false);
+    for (const prop of copy.props) {
+      if (Type.isMappedType(prop.type)) {
+        Reflect.deleteProperty(prop, 'type');
+        Reflect.deleteProperty(prop, 'customType');
+      }
+      if (prop.default) {
+        const raw = RawQueryFragment.getKnownFragment(prop.default);
+        if (raw) {
+          prop.defaultRaw ??= this.config.getPlatform().formatQuery(raw.sql, raw.params);
+          Reflect.deleteProperty(prop, 'default');
         }
+      }
+      Reflect.deleteProperty(prop, 'targetMeta');
     }
-    getCacheKey(meta) {
-        /* v8 ignore next */
-        return meta.className + (meta.path ? extname(meta.path) : '');
+    [
+      'prototype',
+      'props',
+      'referencingProperties',
+      'propertyOrder',
+      'relations',
+      'concurrencyCheckKeys',
+      'checks',
+    ].forEach(key => delete copy[key]);
+    // base entity without properties might not have path, but nothing to cache there
+    if (meta.path) {
+      meta.path = fs.relativePath(meta.path, this.config.get('baseDir'));
+      this.config.getMetadataCacheAdapter().set(this.getCacheKey(meta), copy, meta.path);
     }
+  }
+  getCacheKey(meta) {
+    /* v8 ignore next */
+    return meta.className + (meta.path ? extname(meta.path) : '');
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/reflection",
-  "version": "7.0.4-dev.9",
+  "version": "7.0.4",
   "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",
@@ -50,10 +50,10 @@
     "ts-morph": "27.0.2"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.0.3"
+    "@mikro-orm/core": "^7.0.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.4-dev.9"
+    "@mikro-orm/core": "7.0.4"
   },
   "engines": {
     "node": ">= 22.17.0"