@mikro-orm/reflection 7.0.0-dev.33 → 7.0.0-dev.330

package/README.md

@@ -2,14 +2,14 @@
   <a href="https://mikro-orm.io"><img src="https://raw.githubusercontent.com/mikro-orm/mikro-orm/master/docs/static/img/logo-readme.svg?sanitize=true" alt="MikroORM" /></a>
 </h1>
 
-TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL and SQLite (including libSQL) databases. 
+TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL, SQLite (including libSQL), MSSQL and Oracle databases. 
 
 > Heavily inspired by [Doctrine](https://www.doctrine-project.org/) and [Hibernate](https://hibernate.org/).
 
-[![NPM version](https://img.shields.io/npm/v/@mikro-orm/core.svg)](https://www.npmjs.com/package/@mikro-orm/core)
-[![NPM dev version](https://img.shields.io/npm/v/@mikro-orm/core/next.svg)](https://www.npmjs.com/package/@mikro-orm/core)
+[![NPM version](https://img.shields.io/npm/v/@mikro-orm/core.svg)](https://npmx.dev/package/@mikro-orm/core)
+[![NPM dev version](https://img.shields.io/npm/v/@mikro-orm/core/next.svg)](https://npmx.dev/package/@mikro-orm/core)
 [![Chat on discord](https://img.shields.io/discord/1214904142443839538?label=discord&color=blue)](https://discord.gg/w8bjxFHS7X)
-[![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://www.npmjs.com/package/@mikro-orm/core)
+[![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://npmx.dev/package/@mikro-orm/core)
 [![Coverage Status](https://img.shields.io/coveralls/mikro-orm/mikro-orm.svg)](https://coveralls.io/r/mikro-orm/mikro-orm?branch=master)
 [![Build Status](https://github.com/mikro-orm/mikro-orm/workflows/tests/badge.svg?branch=master)](https://github.com/mikro-orm/mikro-orm/actions?workflow=tests)
 
@@ -181,6 +181,7 @@ yarn add @mikro-orm/core @mikro-orm/mysql         # for mysql/mariadb
 yarn add @mikro-orm/core @mikro-orm/mariadb       # for mysql/mariadb
 yarn add @mikro-orm/core @mikro-orm/postgresql    # for postgresql
 yarn add @mikro-orm/core @mikro-orm/mssql         # for mssql
+yarn add @mikro-orm/core @mikro-orm/oracledb      # for oracle
 yarn add @mikro-orm/core @mikro-orm/sqlite        # for sqlite
 yarn add @mikro-orm/core @mikro-orm/libsql        # for libsql
 ```
@@ -381,6 +382,8 @@ See also the list of contributors who [participated](https://github.com/mikro-or
 
 Please ⭐️ this repository if this project helped you!
 
+> If you'd like to support my open-source work, consider sponsoring me directly at [github.com/sponsors/b4nan](https://github.com/sponsors/b4nan).
+
 ## 📝 License
 
 Copyright © 2018 [Martin Adámek](https://github.com/b4nan).

package/TsMorphMetadataProvider.d.ts

@@ -3,8 +3,9 @@ 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, name: string): void;
+    loadEntityMetadata(meta: EntityMetadata): void;
     getExistingSourceFile(path: string, ext?: string, validate?: boolean): SourceFile;
     protected initProperties(meta: EntityMetadata): void;
     private extractType;
@@ -12,7 +13,10 @@ export declare class TsMorphMetadataProvider extends MetadataProvider {
     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,12 +1,17 @@
-import { ModuleKind, Project } from 'ts-morph';
-import { ConfigurationLoader, MetadataError, MetadataProvider, MetadataStorage, ReferenceKind, Utils, } from '@mikro-orm/core';
+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 { fs } from '@mikro-orm/core/fs-utils';
 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, name) {
+    loadEntityMetadata(meta) {
         if (!meta.path) {
             return;
         }
@@ -16,35 +21,34 @@ export class TsMorphMetadataProvider extends MetadataProvider {
         if (!ext) {
             return this.getExistingSourceFile(path, '.d.ts', false) || this.getExistingSourceFile(path, '.ts');
         }
-        const tsPath = path.match(/.*\/[^/]+$/)[0].replace(/\.js$/, ext);
+        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 = this.extractType(prop);
-            if (!type || this.config.get('discovery').alwaysAnalyseProperties) {
-                this.initPropertyType(meta, prop);
-            }
-            prop.type = type || prop.type;
+            const { type, target } = this.extractType(meta, prop);
+            this.initPropertyType(meta, prop);
+            prop.type = type ?? prop.type;
+            prop.target = target;
         }
     }
-    extractType(prop) {
-        if (Utils.isString(prop.entity)) {
-            return prop.entity;
+    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 Utils.className(prop.entity());
+        if (!prop.entity) {
+            return { type: prop.type };
         }
-        return prop.type;
+        const tmp = prop.entity();
+        const target = tmp instanceof EntitySchema ? 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',
-        ];
+        const intersectionTags = ['Opt.Brand', 'Hidden.Brand', 'RequiredNullable.Brand'];
         for (const tag of genericTags) {
             type = type.replace(tag, '$1');
         }
@@ -67,19 +71,34 @@ export class TsMorphMetadataProvider extends MetadataProvider {
         this.processWrapper(prop, 'ScalarReference');
         this.processWrapper(prop, 'Collection');
         prop.runtimeType ??= prop.type;
-        if (prop.type.replace(/import\(.*\)\./g, '').match(/^(Dictionary|Record)<.*>$/)) {
+        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 3 */
+        /* 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 => v.getName() === prop.name);
+        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 };
         }
@@ -90,9 +109,12 @@ export class TsMorphMetadataProvider extends MetadataProvider {
         }
         if (tsType.isArray()) {
             prop.array = true;
-            /* v8 ignore next 3 */
+            /* v8 ignore next */
             if (tsType.getArrayElementType().isEnum()) {
-                prop.items = tsType.getArrayElementType().getUnionTypes().map(t => t.getLiteralValueOrThrow());
+                prop.items = tsType
+                    .getArrayElementType()
+                    .getUnionTypes()
+                    .map(t => t.getLiteralValueOrThrow());
             }
         }
         if (prop.array && prop.enum) {
@@ -102,7 +124,7 @@ export class TsMorphMetadataProvider extends MetadataProvider {
         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('[]') || !!type.match(/Array<(.*)>/);
+        prop.array ??= type.endsWith('[]') || !!/Array<(.*)>/.exec(type);
         type = type
             .replace(/Array<(.*)>/, '$1') // unwrap array
             .replace(/\[]$/, '') // remove array suffix
@@ -120,27 +142,29 @@ export class TsMorphMetadataProvider extends MetadataProvider {
         const baseDir = this.config.get('baseDir');
         const outDir = this.project.getCompilerOptions().outDir;
         let path = tsPath;
+        /* v8 ignore next */
         if (outDir != null) {
-            const outDirRelative = Utils.relativePath(outDir, baseDir);
+            const outDirRelative = fs.relativePath(outDir, baseDir);
             path = path.replace(new RegExp(`^${outDirRelative}`), '');
         }
-        path = Utils.stripRelativePath(path);
+        path = this.stripRelativePath(path);
         const source = this.sources.find(s => s.getFilePath().endsWith(path));
         if (!source && validate) {
-            throw new MetadataError(`Source file '${tsPath}' 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`);
+            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 = type.match(new RegExp(`(?:^|[.( ])${wrapper}<(\\w+),?.*>(?:$|[) ])`));
+        const type = prop.type.replace(/import\(.*\)\./g, '').replace(/\{ .* } & ([\w &]+)/g, '$1');
+        const m = new RegExp(`(?:^|[.( ])${wrapper}<(\\w+),?.*>(?:$|[) ])`).exec(type);
         if (!m) {
             return;
         }
@@ -150,16 +174,15 @@ export class TsMorphMetadataProvider extends MetadataProvider {
         }
     }
     initProject() {
-        const settings = ConfigurationLoader.getSettings();
         /* v8 ignore next */
-        const tsConfigFilePath = this.config.get('discovery').tsConfigPath ?? settings.tsConfigPath ?? './tsconfig.json';
+        const tsConfigFilePath = this.config.get('discovery').tsConfigPath ?? './tsconfig.json';
         try {
             this.project = new Project({
-                tsConfigFilePath: Utils.normalizePath(process.cwd(), tsConfigFilePath),
+                tsConfigFilePath: fs.normalizePath(process.cwd(), tsConfigFilePath),
                 skipAddingFilesFromTsConfig: true,
                 compilerOptions: {
                     strictNullChecks: true,
-                    module: ModuleKind.Node16,
+                    module: ModuleKind.Node20,
                 },
             });
         }
@@ -168,29 +191,65 @@ 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
         // 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())) {
-            /* v8 ignore next 3 */
-            const path = meta.path.match(/\.[jt]s$/)
-                ? meta.path.replace(/\.js$/, '.d.ts')
-                : `${meta.path}.d.ts`; // when entities are bundled, their paths are just their names
+            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');
+        }
+        [
+            '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,62 +1,61 @@
 {
   "name": "@mikro-orm/reflection",
-  "type": "module",
-  "version": "7.0.0-dev.33",
+  "version": "7.0.0-dev.330",
   "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",
-    ".": "./index.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
-  },
   "keywords": [
-    "orm",
+    "data-mapper",
+    "ddd",
+    "entity",
+    "identity-map",
+    "javascript",
+    "js",
+    "mariadb",
+    "mikro-orm",
     "mongo",
     "mongodb",
     "mysql",
-    "mariadb",
+    "orm",
     "postgresql",
     "sqlite",
     "sqlite3",
     "ts",
     "typescript",
-    "js",
-    "javascript",
-    "entity",
-    "ddd",
-    "mikro-orm",
-    "unit-of-work",
-    "data-mapper",
-    "identity-map"
+    "unit-of-work"
   ],
-  "author": "Martin Adámek",
-  "license": "MIT",
+  "homepage": "https://mikro-orm.io",
   "bugs": {
     "url": "https://github.com/mikro-orm/mikro-orm/issues"
   },
-  "homepage": "https://mikro-orm.io",
-  "engines": {
-    "node": ">= 22.11.0"
+  "license": "MIT",
+  "author": "Martin Adámek",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
+  },
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./index.js"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {
-    "build": "yarn clean && yarn compile && yarn copy",
+    "build": "yarn compile && yarn copy",
     "clean": "yarn run -T rimraf ./dist",
     "compile": "yarn run -T tsc -p tsconfig.build.json",
     "copy": "node ../../scripts/copy.mjs"
   },
-  "publishConfig": {
-    "access": "public"
-  },
   "dependencies": {
-    "tinyglobby": "0.2.13",
-    "ts-morph": "27.0.0"
+    "ts-morph": "27.0.2"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.5.7"
+    "@mikro-orm/core": "^6.6.9"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.33"
+    "@mikro-orm/core": "7.0.0-dev.330"
+  },
+  "engines": {
+    "node": ">= 22.17.0"
   }
 }