@mikro-orm/reflection 7.0.10 → 7.0.11-dev.0

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,260 +1,244 @@
 import { extname } from 'node:path';
 import { ModuleKind, Project } from 'ts-morph';
-import {
-  EntitySchema,
-  MetadataError,
-  MetadataProvider,
-  MetadataStorage,
-  RawQueryFragment,
-  ReferenceKind,
-  Type,
-  Utils,
-} from '@mikro-orm/core';
+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;
-  }
-  useCache() {
-    return this.config.get('metadataCache').enabled ?? TsMorphMetadataProvider.useCache();
-  }
-  loadEntityMetadata(meta) {
-    if (!meta.path) {
-      return;
+    project;
+    sources;
+    static useCache() {
+        return true;
     }
-    this.initProperties(meta);
-  }
-  getExistingSourceFile(path, ext, validate = true) {
-    if (!ext) {
-      return this.getExistingSourceFile(path, '.d.ts', false) || this.getExistingSourceFile(path, '.ts');
+    useCache() {
+        return this.config.get('metadataCache').enabled ?? TsMorphMetadataProvider.useCache();
     }
-    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;
-    }
-  }
-  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 };
-  }
-  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;
-  }
-  initPropertyType(meta, prop) {
-    const { type: typeRaw, optional } = this.readTypeFromSource(meta, prop);
-    if (typeRaw != null) {
-      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';
-    }
-  }
-  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 property =
-      cls.getInstanceProperty(prop.name) ??
-      // fallback to the type checker for inherited properties (e.g. with TC39/ES decorators)
-      cls.getType().getProperty(prop.name)?.getDeclarations()?.[0];
-    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());
-      }
-    }
-    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;
-    }
-    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 };
-  }
-  getSourceFile(tsPath, validate) {
-    if (!this.sources) {
-      this.initSourceFiles();
+    loadEntityMetadata(meta) {
+        if (!meta.path) {
+            return;
+        }
+        this.initProperties(meta);
     }
-    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}`), '');
+    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);
+    }
+    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;
+        }
     }
-    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`,
-      );
+    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 };
+    }
+    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;
     }
-    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;
+    initPropertyType(meta, prop) {
+        const { type: typeRaw, optional } = this.readTypeFromSource(meta, prop);
+        if (typeRaw != null) {
+            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';
+        }
     }
-    prop.type = m[1];
-    if (['Ref', 'Reference', 'EntityRef', 'ScalarRef', 'ScalarReference'].includes(wrapper)) {
-      prop.ref = 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 property = (cls.getInstanceProperty(prop.name) ??
+            // fallback to the type checker for inherited properties (e.g. with TC39/ES decorators)
+            cls.getType().getProperty(prop.name)?.getDeclarations()?.[0]);
+        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());
+            }
+        }
+        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;
+        }
+        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 };
     }
-  }
-  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,
-        },
-      });
+    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;
+        }
     }
-  }
-  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);
-      }
+    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,
+                },
+            });
+        }
     }
-  }
-  saveToCache(meta) {
-    if (!this.useCache()) {
-      return;
+    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);
+            }
+        }
     }
-    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');
+    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);
         }
-      }
-      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);
+    getCacheKey(meta) {
+        /* v8 ignore next */
+        return meta.className + (meta.path ? extname(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.10",
+  "version": "7.0.11-dev.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",
@@ -53,7 +53,7 @@
     "@mikro-orm/core": "^7.0.10"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.10"
+    "@mikro-orm/core": "7.0.11-dev.0"
   },
   "engines": {
     "node": ">= 22.17.0"