@mikro-orm/core 7.0.0-dev.1 → 7.0.0-dev.100

package/metadata/MetadataProvider.d.ts

@@ -1,13 +1,22 @@
-import type { EntityMetadata } from '../typings';
-import type { Logger } from '../logging/Logger';
+import type { EntityMetadata } from '../typings.js';
+import type { Logger } from '../logging/Logger.js';
+import type { SyncCacheAdapter } from '../cache/CacheAdapter.js';
+import type { Platform } from '../platforms/Platform.js';
 export interface IConfiguration {
     get(key: string, defaultValue?: any): any;
     getLogger(): Logger;
+    getMetadataCacheAdapter(): SyncCacheAdapter;
+    getPlatform(): Platform;
 }
-export declare abstract class MetadataProvider {
+export declare class MetadataProvider {
     protected readonly config: IConfiguration;
     constructor(config: IConfiguration);
-    abstract loadEntityMetadata(meta: EntityMetadata, name: string): void;
+    loadEntityMetadata(meta: EntityMetadata): void;
     loadFromCache(meta: EntityMetadata, cache: EntityMetadata): void;
+    static useCache(): boolean;
     useCache(): boolean;
+    saveToCache(meta: EntityMetadata): void;
+    getCachedMetadata<T>(meta: Pick<EntityMetadata<T>, 'className' | 'path' | 'root'>, root: EntityMetadata<T>): EntityMetadata<T> | undefined;
+    combineCache(): void;
+    getCacheKey(meta: Pick<EntityMetadata, 'className' | 'path'>): string;
 }

package/metadata/MetadataProvider.js

@@ -1,23 +1,62 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetadataProvider = void 0;
-const Utils_1 = require("../utils/Utils");
-class MetadataProvider {
+import { Utils } from '../utils/Utils.js';
+export class MetadataProvider {
     config;
     constructor(config) {
         this.config = config;
     }
+    loadEntityMetadata(meta) {
+        for (const prop of meta.props) {
+            /* v8 ignore next */
+            if (typeof prop.entity === 'string') {
+                prop.type = prop.entity;
+            }
+            else if (prop.entity) {
+                const tmp = prop.entity();
+                prop.type = Array.isArray(tmp) ? tmp.map(t => Utils.className(t)).sort().join(' | ') : Utils.className(tmp);
+            }
+            else if (!prop.type && !(prop.enum && (prop.items?.length ?? 0) > 0)) {
+                throw new Error(`Please provide either 'type' or 'entity' attribute in ${meta.className}.${prop.name}.`);
+            }
+        }
+    }
     loadFromCache(meta, cache) {
         Object.values(cache.properties).forEach(prop => {
             const metaProp = meta.properties[prop.name];
+            /* v8 ignore next */
             if (metaProp?.enum && Array.isArray(metaProp.items)) {
                 delete prop.items;
             }
         });
-        Utils_1.Utils.mergeConfig(meta, cache);
+        Utils.mergeConfig(meta, cache);
+    }
+    static useCache() {
+        return false;
     }
     useCache() {
-        return this.config.get('metadataCache').enabled ?? false;
+        return this.config.get('metadataCache').enabled ?? MetadataProvider.useCache();
+    }
+    saveToCache(meta) {
+        //
+    }
+    getCachedMetadata(meta, root) {
+        if (!this.useCache()) {
+            return undefined;
+        }
+        const cache = meta.path && this.config.getMetadataCacheAdapter().get(this.getCacheKey(meta));
+        if (cache) {
+            this.loadFromCache(meta, cache);
+            meta.root = root;
+        }
+        return cache;
+    }
+    combineCache() {
+        const path = this.config.getMetadataCacheAdapter().combine?.();
+        // override the path in the options, so we can log it from the CLI in `cache:generate` command
+        if (path) {
+            this.config.get('metadataCache').combined = path;
+        }
+    }
+    getCacheKey(meta) {
+        return meta.className;
     }
 }
-exports.MetadataProvider = MetadataProvider;

package/metadata/MetadataStorage.d.ts

@@ -1,5 +1,5 @@
-import { EntityMetadata, type Dictionary, type EntityData, type EntityName } from '../typings';
-import type { EntityManager } from '../EntityManager';
+import { EntityMetadata, type Dictionary, type EntityName } from '../typings.js';
+import type { EntityManager } from '../EntityManager.js';
 export declare class MetadataStorage {
     static readonly PATH_SYMBOL: unique symbol;
     private static readonly metadata;
@@ -8,13 +8,8 @@ export declare class MetadataStorage {
     static getMetadata(): Dictionary<EntityMetadata>;
     static getMetadata<T = any>(entity: string, path: string): EntityMetadata<T>;
     static isKnownEntity(name: string): boolean;
-    static getMetadataFromDecorator<T = any>(target: T & Dictionary & {
-        [MetadataStorage.PATH_SYMBOL]?: string;
-    }): EntityMetadata<T>;
-    static init(): MetadataStorage;
     static clear(): void;
     getAll(): Dictionary<EntityMetadata>;
-    getByDiscriminatorColumn<T>(meta: EntityMetadata<T>, data: EntityData<T>): EntityMetadata<T> | undefined;
     get<T = any>(entityName: EntityName<T>, init?: boolean, validate?: boolean): EntityMetadata<T>;
     find<T = any>(entityName: EntityName<T>): EntityMetadata<T> | undefined;
     has(entity: string): boolean;

package/metadata/MetadataStorage.js

@@ -1,21 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetadataStorage = void 0;
-const typings_1 = require("../typings");
-const Utils_1 = require("../utils/Utils");
-const errors_1 = require("../errors");
-const EntityHelper_1 = require("../entity/EntityHelper");
-class MetadataStorage {
+import { EntityMetadata } from '../typings.js';
+import { Utils } from '../utils/Utils.js';
+import { MetadataError } from '../errors.js';
+import { EntityHelper } from '../entity/EntityHelper.js';
+function getGlobalStorage(namespace) {
+    const key = `mikro-orm-${namespace}`;
+    globalThis[key] = globalThis[key] || {};
+    return globalThis[key];
+}
+export class MetadataStorage {
     static PATH_SYMBOL = Symbol('MetadataStorage.PATH_SYMBOL');
-    static metadata = Utils_1.Utils.getGlobalStorage('metadata');
+    static metadata = getGlobalStorage('metadata');
     metadata;
     constructor(metadata = {}) {
-        this.metadata = Utils_1.Utils.copy(metadata, false);
+        this.metadata = Utils.copy(metadata, false);
     }
     static getMetadata(entity, path) {
-        const key = entity && path ? entity + '-' + Utils_1.Utils.hash(path) : null;
+        const key = entity && path ? entity + '-' + Utils.hash(path) : null;
         if (key && !MetadataStorage.metadata[key]) {
-            MetadataStorage.metadata[key] = new typings_1.EntityMetadata({ className: entity, path });
+            MetadataStorage.metadata[key] = new EntityMetadata({ className: entity, path });
         }
         if (key) {
             return MetadataStorage.metadata[key];
@@ -25,36 +27,19 @@ class MetadataStorage {
     static isKnownEntity(name) {
         return !!Object.values(this.metadata).find(meta => meta.className === name);
     }
-    static getMetadataFromDecorator(target) {
-        if (!Object.hasOwn(target, MetadataStorage.PATH_SYMBOL)) {
-            Object.defineProperty(target, MetadataStorage.PATH_SYMBOL, { value: Utils_1.Utils.lookupPathFromDecorator(target.name), writable: true });
-        }
-        return MetadataStorage.getMetadata(target.name, target[MetadataStorage.PATH_SYMBOL]);
-    }
-    static init() {
-        return new MetadataStorage(MetadataStorage.metadata);
-    }
     static clear() {
         Object.keys(this.metadata).forEach(k => delete this.metadata[k]);
     }
     getAll() {
         return this.metadata;
     }
-    getByDiscriminatorColumn(meta, data) {
-        const value = data[meta.root.discriminatorColumn];
-        if (!value) {
-            return undefined;
-        }
-        const type = meta.root.discriminatorMap[value];
-        return this.metadata[type];
-    }
     get(entityName, init = false, validate = true) {
-        entityName = Utils_1.Utils.className(entityName);
+        entityName = Utils.className(entityName);
         if (validate && !init && !this.has(entityName)) {
-            throw errors_1.MetadataError.missingMetadata(entityName);
+            throw MetadataError.missingMetadata(entityName);
         }
         if (init && !this.has(entityName)) {
-            this.metadata[entityName] = new typings_1.EntityMetadata();
+            this.metadata[entityName] = new EntityMetadata();
         }
         return this.metadata[entityName];
     }
@@ -62,7 +47,7 @@ class MetadataStorage {
         if (!entityName) {
             return;
         }
-        entityName = Utils_1.Utils.className(entityName);
+        entityName = Utils.className(entityName);
         return this.metadata[entityName];
     }
     has(entity) {
@@ -77,7 +62,7 @@ class MetadataStorage {
     decorate(em) {
         Object.values(this.metadata)
             .filter(meta => meta.prototype)
-            .forEach(meta => EntityHelper_1.EntityHelper.decorate(meta, em));
+            .forEach(meta => EntityHelper.decorate(meta, em));
     }
     *[Symbol.iterator]() {
         for (const meta of Object.values(this.metadata)) {
@@ -85,4 +70,3 @@ class MetadataStorage {
         }
     }
 }
-exports.MetadataStorage = MetadataStorage;

package/metadata/MetadataValidator.d.ts

@@ -1,17 +1,10 @@
-import type { EntityMetadata } from '../typings';
-import { type MetadataDiscoveryOptions } from '../utils';
-import { ReferenceKind } from '../enums';
-import type { MetadataStorage } from './MetadataStorage';
+import type { EntityMetadata } from '../typings.js';
+import { type MetadataDiscoveryOptions } from '../utils/Configuration.js';
+import type { MetadataStorage } from './MetadataStorage.js';
 /**
  * @internal
  */
 export declare class MetadataValidator {
-    /**
-     * Validate there is only one property decorator. This disallows using `@Property()` together with e.g. `@ManyToOne()`
-     * on the same property. One should use only `@ManyToOne()` in such case.
-     * We allow the existence of the property in metadata if the reference type is the same, this should allow things like HMR to work.
-     */
-    static validateSingleDecorator(meta: EntityMetadata, propertyName: string, reference: ReferenceKind): void;
     validateEntityDefinition<T>(metadata: MetadataStorage, name: string, options: MetadataDiscoveryOptions): void;
     validateDiscovered(discovered: EntityMetadata[], options: MetadataDiscoveryOptions): void;
     private validateReference;

package/metadata/MetadataValidator.js

@@ -1,73 +1,60 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetadataValidator = void 0;
-const utils_1 = require("../utils");
-const errors_1 = require("../errors");
-const enums_1 = require("../enums");
+import { Utils } from '../utils/Utils.js';
+import { MetadataError } from '../errors.js';
+import { ReferenceKind } from '../enums.js';
 /**
  * @internal
  */
-class MetadataValidator {
-    /**
-     * Validate there is only one property decorator. This disallows using `@Property()` together with e.g. `@ManyToOne()`
-     * on the same property. One should use only `@ManyToOne()` in such case.
-     * We allow the existence of the property in metadata if the reference type is the same, this should allow things like HMR to work.
-     */
-    static validateSingleDecorator(meta, propertyName, reference) {
-        if (meta.properties[propertyName] && meta.properties[propertyName].kind !== reference) {
-            throw errors_1.MetadataError.multipleDecorators(meta.className, propertyName);
-        }
-    }
+export class MetadataValidator {
     validateEntityDefinition(metadata, name, options) {
         const meta = metadata.get(name);
         if (meta.virtual || meta.expression) {
-            for (const prop of utils_1.Utils.values(meta.properties)) {
-                if (![enums_1.ReferenceKind.SCALAR, enums_1.ReferenceKind.EMBEDDED, enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
-                    throw new errors_1.MetadataError(`Only scalars, embedded properties and to-many relations are allowed inside virtual entity. Found '${prop.kind}' in ${meta.className}.${prop.name}`);
+            for (const prop of Utils.values(meta.properties)) {
+                if (![ReferenceKind.SCALAR, ReferenceKind.EMBEDDED, ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+                    throw new MetadataError(`Only scalars, embedded properties and to-many relations are allowed inside virtual entity. Found '${prop.kind}' in ${meta.className}.${prop.name}`);
                 }
                 if (prop.primary) {
-                    throw new errors_1.MetadataError(`Virtual entity ${meta.className} cannot have primary key ${meta.className}.${prop.name}`);
+                    throw new MetadataError(`Virtual entity ${meta.className} cannot have primary key ${meta.className}.${prop.name}`);
                 }
             }
             return;
         }
         // entities have PK
         if (!meta.embeddable && (!meta.primaryKeys || meta.primaryKeys.length === 0)) {
-            throw errors_1.MetadataError.fromMissingPrimaryKey(meta);
+            throw MetadataError.fromMissingPrimaryKey(meta);
         }
         this.validateVersionField(meta);
         this.validateDuplicateFieldNames(meta, options);
         this.validateIndexes(meta, meta.indexes ?? [], 'index');
         this.validateIndexes(meta, meta.uniques ?? [], 'unique');
-        for (const prop of utils_1.Utils.values(meta.properties)) {
-            if (prop.kind !== enums_1.ReferenceKind.SCALAR) {
+        for (const prop of Utils.values(meta.properties)) {
+            if (prop.kind !== ReferenceKind.SCALAR) {
                 this.validateReference(meta, prop, metadata, options);
                 this.validateBidirectional(meta, prop, metadata);
             }
             else if (metadata.has(prop.type)) {
-                throw errors_1.MetadataError.propertyTargetsEntityType(meta, prop, metadata.get(prop.type));
+                throw MetadataError.propertyTargetsEntityType(meta, prop, metadata.get(prop.type));
             }
         }
     }
     validateDiscovered(discovered, options) {
         if (discovered.length === 0 && options.warnWhenNoEntities) {
-            throw errors_1.MetadataError.noEntityDiscovered();
+            throw MetadataError.noEntityDiscovered();
         }
-        const duplicates = utils_1.Utils.findDuplicates(discovered.map(meta => meta.className));
+        const duplicates = Utils.findDuplicates(discovered.map(meta => meta.className));
         if (duplicates.length > 0 && options.checkDuplicateEntities) {
-            throw errors_1.MetadataError.duplicateEntityDiscovered(duplicates);
+            throw MetadataError.duplicateEntityDiscovered(duplicates);
         }
         const tableNames = discovered.filter(meta => !meta.abstract && meta === meta.root && (meta.tableName || meta.collection) && meta.schema !== '*');
-        const duplicateTableNames = utils_1.Utils.findDuplicates(tableNames.map(meta => {
+        const duplicateTableNames = Utils.findDuplicates(tableNames.map(meta => {
             const tableName = meta.tableName || meta.collection;
             return (meta.schema ? '.' + meta.schema : '') + tableName;
         }));
         if (duplicateTableNames.length > 0 && options.checkDuplicateTableNames && options.checkDuplicateEntities) {
-            throw errors_1.MetadataError.duplicateEntityDiscovered(duplicateTableNames, 'table names');
+            throw MetadataError.duplicateEntityDiscovered(duplicateTableNames, 'table names');
         }
         // validate we found at least one entity (not just abstract/base entities)
         if (discovered.filter(meta => meta.name).length === 0 && options.warnWhenNoEntities) {
-            throw errors_1.MetadataError.onlyAbstractEntitiesDiscovered();
+            throw MetadataError.onlyAbstractEntitiesDiscovered();
         }
         const unwrap = (type) => type
             .replace(/Array<(.*)>/, '$1') // unwrap array
@@ -75,15 +62,15 @@ class MetadataValidator {
             .replace(/\((.*)\)/, '$1'); // unwrap union types
         const name = (p) => {
             if (typeof p === 'function') {
-                return utils_1.Utils.className(p());
+                return Utils.className(p());
             }
-            return utils_1.Utils.className(p);
+            return Utils.className(p);
         };
         const pivotProps = new Map();
         // check for not discovered entities
         discovered.forEach(meta => Object.values(meta.properties).forEach(prop => {
-            if (prop.kind !== enums_1.ReferenceKind.SCALAR && !unwrap(prop.type).split(/ ?\| ?/).every(type => discovered.find(m => m.className === type))) {
-                throw errors_1.MetadataError.fromUnknownEntity(prop.type, `${meta.className}.${prop.name}`);
+            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) {
                 const props = pivotProps.get(name(prop.pivotEntity)) ?? [];
@@ -94,24 +81,25 @@ class MetadataValidator {
         pivotProps.forEach(props => {
             // if the pivot entity is used in more than one property, check if they are linked
             if (props.length > 1 && props.every(p => !p.prop.mappedBy && !p.prop.inversedBy)) {
-                throw errors_1.MetadataError.invalidManyToManyWithPivotEntity(props[0].meta, props[0].prop, props[1].meta, props[1].prop);
+                throw MetadataError.invalidManyToManyWithPivotEntity(props[0].meta, props[0].prop, props[1].meta, props[1].prop);
             }
         });
     }
     validateReference(meta, prop, metadata, options) {
         // references do have types
         if (!prop.type) {
-            throw errors_1.MetadataError.fromWrongTypeDefinition(meta, prop);
+            throw MetadataError.fromWrongTypeDefinition(meta, prop);
         }
+        const targetMeta = metadata.find(prop.type);
         // references do have type of known entity
-        if (!metadata.find(prop.type)) {
-            throw errors_1.MetadataError.fromWrongTypeDefinition(meta, prop);
+        if (!targetMeta) {
+            throw MetadataError.fromWrongTypeDefinition(meta, prop);
         }
-        if (metadata.find(prop.type).abstract && !metadata.find(prop.type).discriminatorColumn) {
-            throw errors_1.MetadataError.targetIsAbstract(meta, prop);
+        if (targetMeta.abstract && !targetMeta.discriminatorColumn && !targetMeta.embeddable) {
+            throw MetadataError.targetIsAbstract(meta, prop);
         }
-        if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && prop.persist === false && metadata.find(prop.type).compositePK && options.checkNonPersistentCompositeProps) {
-            throw errors_1.MetadataError.nonPersistentCompositeProp(meta, prop);
+        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && prop.persist === false && targetMeta.compositePK && options.checkNonPersistentCompositeProps) {
+            throw MetadataError.nonPersistentCompositeProp(meta, prop);
         }
     }
     validateBidirectional(meta, prop, metadata) {
@@ -125,67 +113,67 @@ class MetadataValidator {
         }
         else {
             // 1:m property has `mappedBy`
-            if (prop.kind === enums_1.ReferenceKind.ONE_TO_MANY && !prop.mappedBy) {
-                throw errors_1.MetadataError.fromMissingOption(meta, prop, 'mappedBy');
+            if (prop.kind === ReferenceKind.ONE_TO_MANY && !prop.mappedBy) {
+                throw MetadataError.fromMissingOption(meta, prop, 'mappedBy');
             }
         }
     }
     validateOwningSide(meta, prop, inverse, metadata) {
         // has correct `inversedBy` on owning side
         if (!inverse) {
-            throw errors_1.MetadataError.fromWrongReference(meta, prop, 'inversedBy');
+            throw MetadataError.fromWrongReference(meta, prop, 'inversedBy');
         }
         const targetClassName = metadata.find(inverse.type)?.root.className;
         // has correct `inversedBy` reference type
         if (inverse.type !== meta.className && targetClassName !== meta.root.className) {
-            throw errors_1.MetadataError.fromWrongReference(meta, prop, 'inversedBy', inverse);
+            throw MetadataError.fromWrongReference(meta, prop, 'inversedBy', inverse);
         }
         // inverse side is not defined as owner
         if (inverse.inversedBy || inverse.owner) {
-            throw errors_1.MetadataError.fromWrongOwnership(meta, prop, 'inversedBy');
+            throw MetadataError.fromWrongOwnership(meta, prop, 'inversedBy');
         }
     }
     validateInverseSide(meta, prop, owner, metadata) {
         // has correct `mappedBy` on inverse side
         if (prop.mappedBy && !owner) {
-            throw errors_1.MetadataError.fromWrongReference(meta, prop, 'mappedBy');
+            throw MetadataError.fromWrongReference(meta, prop, 'mappedBy');
         }
         // has correct `mappedBy` reference type
         if (owner.type !== meta.className && metadata.find(owner.type)?.root.className !== meta.root.className) {
-            throw errors_1.MetadataError.fromWrongReference(meta, prop, 'mappedBy', owner);
+            throw MetadataError.fromWrongReference(meta, prop, 'mappedBy', owner);
         }
         // owning side is not defined as inverse
         if (owner.mappedBy) {
-            throw errors_1.MetadataError.fromWrongOwnership(meta, prop, 'mappedBy');
+            throw MetadataError.fromWrongOwnership(meta, prop, 'mappedBy');
         }
         // owning side is not defined as inverse
         const valid = [
-            { owner: enums_1.ReferenceKind.MANY_TO_ONE, inverse: enums_1.ReferenceKind.ONE_TO_MANY },
-            { owner: enums_1.ReferenceKind.MANY_TO_MANY, inverse: enums_1.ReferenceKind.MANY_TO_MANY },
-            { owner: enums_1.ReferenceKind.ONE_TO_ONE, inverse: enums_1.ReferenceKind.ONE_TO_ONE },
+            { owner: ReferenceKind.MANY_TO_ONE, inverse: ReferenceKind.ONE_TO_MANY },
+            { owner: ReferenceKind.MANY_TO_MANY, inverse: ReferenceKind.MANY_TO_MANY },
+            { owner: ReferenceKind.ONE_TO_ONE, inverse: ReferenceKind.ONE_TO_ONE },
         ];
         if (!valid.find(spec => spec.owner === owner.kind && spec.inverse === prop.kind)) {
-            throw errors_1.MetadataError.fromWrongReferenceKind(meta, owner, prop);
+            throw MetadataError.fromWrongReferenceKind(meta, owner, prop);
         }
         if (prop.primary) {
-            throw errors_1.MetadataError.fromInversideSidePrimary(meta, owner, prop);
+            throw MetadataError.fromInversideSidePrimary(meta, owner, prop);
         }
     }
     validateIndexes(meta, indexes, type) {
         for (const index of indexes) {
-            for (const propName of utils_1.Utils.asArray(index.properties)) {
+            for (const propName of Utils.asArray(index.properties)) {
                 const prop = meta.root.properties[propName];
                 if (!prop && !Object.values(meta.root.properties).some(p => propName.startsWith(p.name + '.'))) {
-                    throw errors_1.MetadataError.unknownIndexProperty(meta, propName, type);
+                    throw MetadataError.unknownIndexProperty(meta, propName, type);
                 }
             }
         }
     }
     validateDuplicateFieldNames(meta, options) {
         const candidates = Object.values(meta.properties)
-            .filter(prop => prop.persist !== false && !prop.inherited && prop.fieldNames?.length === 1 && (prop.kind !== enums_1.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_1.Utils.findDuplicates(candidates);
+        const duplicates = Utils.findDuplicates(candidates);
         if (duplicates.length > 0 && options.checkDuplicateFieldNames) {
             const pairs = duplicates.flatMap(name => {
                 return Object.values(meta.properties)
@@ -194,7 +182,7 @@ class MetadataValidator {
                     return [prop.embedded ? prop.embedded.join('.') : prop.name, prop.fieldNames[0]];
                 });
             });
-            throw errors_1.MetadataError.duplicateFieldName(meta.className, pairs);
+            throw MetadataError.duplicateFieldName(meta.className, pairs);
         }
     }
     validateVersionField(meta) {
@@ -203,13 +191,12 @@ class MetadataValidator {
         }
         const props = Object.values(meta.properties).filter(p => p.version);
         if (props.length > 1) {
-            throw errors_1.MetadataError.multipleVersionFields(meta, props.map(p => p.name));
+            throw MetadataError.multipleVersionFields(meta, props.map(p => p.name));
         }
         const prop = meta.properties[meta.versionProperty];
         const type = prop.runtimeType ?? prop.columnTypes?.[0] ?? prop.type;
         if (type !== 'number' && type !== 'Date' && !type.startsWith('timestamp') && !type.startsWith('datetime')) {
-            throw errors_1.MetadataError.invalidVersionFieldType(meta);
+            throw MetadataError.invalidVersionFieldType(meta);
         }
     }
 }
-exports.MetadataValidator = MetadataValidator;

package/metadata/discover-entities.d.ts

@@ -0,0 +1,5 @@
+import { type Constructor } from '../typings.js';
+import { EntitySchema } from './EntitySchema.js';
+export declare function discoverEntities(paths: string | string[], options?: {
+    baseDir?: string;
+}): Promise<Iterable<EntitySchema | Constructor>>;

package/metadata/discover-entities.js

@@ -0,0 +1,40 @@
+import { basename } from 'node:path';
+import { fs } from '../utils/fs-utils.js';
+import { Utils } from '../utils/Utils.js';
+import { MetadataStorage } from './MetadataStorage.js';
+import { EntitySchema } from './EntitySchema.js';
+async function getEntityClassOrSchema(filepath, allTargets, baseDir) {
+    const path = Utils.normalizePath(baseDir, filepath);
+    const exports = await Utils.dynamicImport(path);
+    const targets = Object.values(exports);
+    // ignore class implementations that are linked from an EntitySchema
+    for (const item of targets) {
+        if (item instanceof EntitySchema) {
+            for (const item2 of targets) {
+                if (item.meta.class === item2) {
+                    targets.splice(targets.indexOf(item2), 1);
+                }
+            }
+        }
+    }
+    for (const item of targets) {
+        const validTarget = item instanceof EntitySchema || (item instanceof Function && MetadataStorage.isKnownEntity(item.name));
+        if (validTarget && !allTargets.has(item)) {
+            allTargets.set(item, path);
+        }
+    }
+}
+export async function discoverEntities(paths, options) {
+    paths = Utils.asArray(paths).map(path => Utils.normalizePath(path));
+    const baseDir = options?.baseDir ?? process.cwd();
+    const files = fs.glob(paths, Utils.normalizePath(baseDir));
+    const found = new Map();
+    for (const filepath of files) {
+        const filename = basename(filepath);
+        if (!filename.match(/\.[cm]?[jt]s$/) || filename.match(/\.d\.[cm]?ts/)) {
+            continue;
+        }
+        await getEntityClassOrSchema(filepath, found, baseDir);
+    }
+    return found.keys();
+}

package/metadata/index.d.ts

@@ -1,6 +1,6 @@
-export * from './EntitySchema';
-export * from './MetadataDiscovery';
-export * from './MetadataStorage';
-export * from './MetadataProvider';
-export * from './MetadataValidator';
-export * from './ReflectMetadataProvider';
+export * from './types.js';
+export * from './EntitySchema.js';
+export * from './MetadataDiscovery.js';
+export * from './MetadataStorage.js';
+export * from './MetadataProvider.js';
+export * from './MetadataValidator.js';

package/metadata/index.js

@@ -1,22 +1,6 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./EntitySchema"), exports);
-__exportStar(require("./MetadataDiscovery"), exports);
-__exportStar(require("./MetadataStorage"), exports);
-__exportStar(require("./MetadataProvider"), exports);
-__exportStar(require("./MetadataValidator"), exports);
-__exportStar(require("./ReflectMetadataProvider"), exports);
+export * from './types.js';
+export * from './EntitySchema.js';
+export * from './MetadataDiscovery.js';
+export * from './MetadataStorage.js';
+export * from './MetadataProvider.js';
+export * from './MetadataValidator.js';