@mikro-orm/reflection 7.0.0-dev.77 → 7.0.0-dev.78

package/TsMorphMetadataProvider.d.ts

@@ -3,6 +3,7 @@ import { type EntityMetadata, MetadataProvider } from '@mikro-orm/core';
 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;
@@ -16,4 +17,7 @@ export declare class TsMorphMetadataProvider extends MetadataProvider {
     private processWrapper;
     private initProject;
     private initSourceFiles;
+    loadFromCache(meta: EntityMetadata, cache: EntityMetadata): void;
+    saveToCache(meta: EntityMetadata): void;
+    getCacheKey(meta: Pick<EntityMetadata, 'className' | 'path'>): string;
 }

package/TsMorphMetadataProvider.js

@@ -1,10 +1,14 @@
+import { extname } from 'node:path';
 import { ComputedPropertyName, ModuleKind, NoSubstitutionTemplateLiteral, Project, StringLiteral } from 'ts-morph';
-import { MetadataError, MetadataProvider, MetadataStorage, ReferenceKind, Utils, } from '@mikro-orm/core';
+import { MetadataError, MetadataProvider, MetadataStorage, RawQueryFragment, ReferenceKind, Type, Utils, } from '@mikro-orm/core';
 export class TsMorphMetadataProvider extends MetadataProvider {
     project;
     sources;
+    static useCache() {
+        return true;
+    }
     useCache() {
-        return this.config.get('metadataCache').enabled ?? true;
+        return this.config.get('metadataCache').enabled ?? TsMorphMetadataProvider.useCache();
     }
     loadEntityMetadata(meta) {
         if (!meta.path) {
@@ -24,7 +28,7 @@ export class TsMorphMetadataProvider extends MetadataProvider {
         for (const prop of Object.values(meta.properties)) {
             const type = this.extractType(prop);
             this.initPropertyType(meta, prop);
-            prop.type = type || prop.type;
+            prop.type = type ?? prop.type;
         }
     }
     extractType(prop) {
@@ -174,7 +178,7 @@ export class TsMorphMetadataProvider extends MetadataProvider {
                 skipAddingFilesFromTsConfig: true,
                 compilerOptions: {
                     strictNullChecks: true,
-                    module: ModuleKind.Node16,
+                    module: ModuleKind.Node20,
                 },
             });
         }
@@ -183,15 +187,13 @@ export class TsMorphMetadataProvider extends MetadataProvider {
             this.project = new Project({
                 compilerOptions: {
                     strictNullChecks: true,
-                    module: ModuleKind.Node16,
+                    module: ModuleKind.Node20,
                 },
             });
         }
     }
     initSourceFiles() {
-        if (!this.project) {
-            this.initProject();
-        }
+        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
@@ -208,4 +210,47 @@ export class TsMorphMetadataProvider extends MetadataProvider {
             }
         }
     }
+    loadFromCache(meta, cache) {
+        Object.values(cache.properties).forEach(prop => {
+            const metaProp = meta.properties[prop.name];
+            /* v8 ignore next 3 */
+            if (metaProp?.enum && Array.isArray(metaProp.items)) {
+                delete prop.items;
+            }
+        });
+        Utils.mergeConfig(meta, cache);
+    }
+    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) {
+            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,7 +1,7 @@
 {
   "name": "@mikro-orm/reflection",
   "type": "module",
-  "version": "7.0.0-dev.77",
+  "version": "7.0.0-dev.78",
   "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.",
   "exports": {
     "./package.json": "./package.json",
@@ -56,6 +56,6 @@
     "@mikro-orm/core": "^6.6.1"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.77"
+    "@mikro-orm/core": "7.0.0-dev.78"
   }
 }