@mikro-orm/core 7.0.0-dev.53 → 7.0.0-dev.55

package/MikroORM.d.ts

@@ -28,7 +28,7 @@ export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver,
      * - no loading of the `config` file, `options` parameter is mandatory
      * - no support for folder based discovery
      */
-    constructor(options: Options<Driver, EM>);
+    constructor(options: Options<Driver, EM, Entities>);
     /**
      * Connects to the database.
      */
@@ -36,7 +36,7 @@ export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver,
     /**
      * Reconnects, possibly to a different database.
      */
-    reconnect(options?: Options): Promise<void>;
+    reconnect(options?: Partial<Options<Driver, EM, Entities>>): Promise<void>;
     /**
      * Checks whether the database connection is active.
      */

package/drivers/DatabaseDriver.d.ts

@@ -48,6 +48,7 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
     setMetadata(metadata: MetadataStorage): void;
     getMetadata(): MetadataStorage;
     getDependencies(): string[];
+    protected isPopulated<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T>, hint: PopulateOptions<T>, name?: string): boolean;
     protected processCursorOptions<T extends object, P extends string>(meta: EntityMetadata<T>, options: FindOptions<T, P, any, any>, orderBy: OrderDefinition<T>): {
         orderBy: OrderDefinition<T>[];
         where: FilterQuery<T>;

package/drivers/DatabaseDriver.js

@@ -105,6 +105,15 @@ export class DatabaseDriver {
     getDependencies() {
         return this.dependencies;
     }
+    isPopulated(meta, prop, hint, name) {
+        if (hint.field === prop.name || hint.field === name || hint.all) {
+            return true;
+        }
+        if (prop.embedded && hint.children && meta.properties[prop.embedded[0]].name === hint.field) {
+            return hint.children.some(c => this.isPopulated(meta, prop, c, prop.embedded[1]));
+        }
+        return false;
+    }
     processCursorOptions(meta, options, orderBy) {
         const { first, last, before, after, overfetch } = options;
         const limit = first ?? last;

package/metadata/MetadataDiscovery.d.ts

@@ -1,4 +1,4 @@
-import { type Constructor, EntityMetadata } from '../typings.js';
+import { type EntityClass, EntityMetadata } from '../typings.js';
 import type { Configuration } from '../utils/Configuration.js';
 import { MetadataStorage } from './MetadataStorage.js';
 import { EntitySchema } from './EntitySchema.js';
@@ -24,8 +24,7 @@ export declare class MetadataDiscovery {
     private findEntities;
     private discoverMissingTargets;
     private tryDiscoverTargets;
-    private discoverDirectories;
-    discoverReferences<T>(refs: (Constructor<T> | EntitySchema<T>)[], validate?: boolean): EntityMetadata<T>[];
+    discoverReferences<T>(refs: Iterable<EntityClass<T> | EntitySchema<T>>, validate?: boolean): EntityMetadata<T>[];
     reset(className: string): void;
     private getSchema;
     private discoverEntity;
@@ -67,6 +66,5 @@ export declare class MetadataDiscovery {
     private getPrefix;
     private initUnsigned;
     private initIndexes;
-    private getEntityClassOrSchema;
     private shouldForceConstructorUsage;
 }

package/metadata/MetadataDiscovery.js

@@ -1,5 +1,4 @@
-import { basename, extname } from 'node:path';
-import { glob } from 'tinyglobby';
+import { extname } from 'node:path';
 import { EntityMetadata } from '../typings.js';
 import { Utils } from '../utils/Utils.js';
 import { MetadataValidator } from './MetadataValidator.js';
@@ -32,6 +31,7 @@ export class MetadataDiscovery {
         this.schemaHelper = this.platform.getSchemaHelper();
     }
     async discover(preferTs = true) {
+        this.discovered.length = 0;
         const startTime = Date.now();
         this.logger.log('discovery', `ORM entity discovery started, using ${colors.cyan(this.metadataProvider.constructor.name)}`);
         await this.findEntities(preferTs);
@@ -48,9 +48,11 @@ export class MetadataDiscovery {
         return storage;
     }
     discoverSync() {
+        this.discovered.length = 0;
         const startTime = Date.now();
         this.logger.log('discovery', `ORM entity discovery started, using ${colors.cyan(this.metadataProvider.constructor.name)} in sync mode`);
-        this.findEntities();
+        const refs = this.config.get('entities');
+        this.discoverReferences(refs);
         for (const meta of this.discovered) {
             /* v8 ignore next */
             void this.config.get('discovery').onMetadata?.(meta, this.platform);
@@ -154,21 +156,23 @@ export class MetadataDiscovery {
             return meta;
         });
     }
-    findEntities(preferTs, sync = false) {
-        this.discovered.length = 0;
-        const options = this.config.get('discovery');
-        const key = (preferTs && this.config.get('entitiesTs').length > 0) ? 'entitiesTs' : 'entities';
-        const paths = this.config.get(key).filter(item => Utils.isString(item));
-        const refs = this.config.get(key).filter(item => !Utils.isString(item));
-        if (paths.length > 0) {
-            if (sync || options.requireEntitiesArray) {
-                throw new Error(`[requireEntitiesArray] Explicit list of entities is required, please use the 'entities' option.`);
+    async findEntities(preferTs) {
+        const { entities, entitiesTs, baseDir } = this.config.getAll();
+        const targets = (preferTs && entitiesTs.length > 0) ? entitiesTs : entities;
+        const processed = [];
+        for (const entity of targets) {
+            if (typeof entity === 'string') {
+                if (this.config.get('discovery').requireEntitiesArray) {
+                    throw new Error(`[requireEntitiesArray] Explicit list of entities is required, please use the 'entities' option.`);
+                }
+                const { discoverEntities } = await Utils.dynamicImport('@mikro-orm/core/file-discovery');
+                processed.push(...await discoverEntities(entity, { baseDir }));
+            }
+            else {
+                processed.push(entity);
             }
-            return this.discoverDirectories(paths).then(targets => {
-                return this.discoverReferences([...targets, ...refs]);
-            });
         }
-        return this.discoverReferences(refs);
+        return this.discoverReferences(processed);
     }
     discoverMissingTargets() {
         const unwrap = (type) => type
@@ -203,24 +207,12 @@ export class MetadataDiscovery {
             }
         }
     }
-    async discoverDirectories(paths) {
-        paths = paths.map(path => Utils.normalizePath(path));
-        const files = await glob(paths, { cwd: Utils.normalizePath(this.config.get('baseDir')) });
-        this.logger.log('discovery', `- processing ${colors.cyan('' + files.length)} files`);
-        const found = new Map();
-        for (const filepath of files) {
-            const filename = basename(filepath);
-            if (!filename.match(/\.[cm]?[jt]s$/) || filename.match(/\.d\.[cm]?ts/)) {
-                this.logger.log('discovery', `- ignoring file ${filename}`);
-                continue;
-            }
-            await this.getEntityClassOrSchema(filepath, found);
-        }
-        return found.keys();
-    }
     discoverReferences(refs, validate = true) {
         const found = [];
         for (const entity of refs) {
+            if (typeof entity === 'string') {
+                throw new Error('Folder based discovery requires the async `MikroORM.init()` method.');
+            }
             const schema = this.getSchema(entity);
             const meta = schema.init().meta;
             this.metadata.set(meta.className, meta);
@@ -1109,8 +1101,18 @@ export class MetadataDiscovery {
         }
         // `prop.type` might also be custom type class (not instance), so `typeof MyType` will give us `function`, not `object`
         if (typeof prop.type === 'function' && Type.isMappedType(prop.type.prototype) && !prop.customType) {
-            prop.customType = new prop.type();
-            prop.type = prop.customType.constructor.name;
+            // if the type is an ORM defined mapped type without `ensureComparable: true`,
+            // we use just the type name, to have more performant hydration code
+            const type = Utils.keys(t).find(type => {
+                return !Type.getType(t[type]).ensureComparable(meta, prop) && prop.type === t[type];
+            });
+            if (type) {
+                prop.type = type === 'datetime' ? 'Date' : type;
+            }
+            else {
+                prop.customType = new prop.type();
+                prop.type = prop.customType.constructor.name;
+            }
         }
         if (simple) {
             return;
@@ -1320,27 +1322,6 @@ export class MetadataDiscovery {
             prop.index ??= true;
         }
     }
-    async getEntityClassOrSchema(filepath, allTargets) {
-        const path = Utils.normalizePath(this.config.get('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);
-            }
-        }
-    }
     shouldForceConstructorUsage(meta) {
         const forceConstructor = this.config.get('forceEntityConstructor');
         if (Array.isArray(forceConstructor)) {

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 { glob } from 'tinyglobby';
+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 = await glob(paths, { cwd: 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/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.53",
+  "version": "7.0.0-dev.55",
   "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"
+    ".": "./index.js",
+    "./file-discovery": "./metadata/discover-entities.js"
   },
   "repository": {
     "type": "git",
@@ -54,7 +55,7 @@
     "dataloader": "2.2.3",
     "dotenv": "17.2.3",
     "esprima": "4.0.1",
-    "mikro-orm": "7.0.0-dev.53",
+    "mikro-orm": "7.0.0-dev.55",
     "reflect-metadata": "0.2.2",
     "tinyglobby": "0.2.13"
   }

package/types/BlobType.d.ts

@@ -4,6 +4,5 @@ import type { EntityProperty } from '../typings.js';
 export declare class BlobType extends Uint8ArrayType {
     convertToJSValue(value: Buffer): Buffer | null;
     compareAsType(): string;
-    ensureComparable(): boolean;
     getColumnType(prop: EntityProperty, platform: Platform): string;
 }

package/types/BlobType.js

@@ -12,9 +12,6 @@ export class BlobType extends Uint8ArrayType {
     compareAsType() {
         return 'Buffer';
     }
-    ensureComparable() {
-        return false;
-    }
     getColumnType(prop, platform) {
         return platform.getBlobDeclarationSQL();
     }

package/types/BooleanType.d.ts

@@ -4,5 +4,6 @@ import type { EntityProperty } from '../typings.js';
 export declare class BooleanType extends Type<boolean | null | undefined, boolean | null | undefined> {
     getColumnType(prop: EntityProperty, platform: Platform): string;
     compareAsType(): string;
+    convertToJSValue(value: boolean | null | undefined): boolean | null | undefined;
     ensureComparable(): boolean;
 }

package/types/BooleanType.js

@@ -6,6 +6,9 @@ export class BooleanType extends Type {
     compareAsType() {
         return 'boolean';
     }
+    convertToJSValue(value) {
+        return Boolean(value);
+    }
     ensureComparable() {
         return false;
     }

package/types/Uint8ArrayType.d.ts

@@ -5,6 +5,5 @@ export declare class Uint8ArrayType extends Type<Uint8Array | null> {
     convertToDatabaseValue(value: Uint8Array): Buffer;
     convertToJSValue(value: Buffer): Uint8Array | null;
     compareAsType(): string;
-    ensureComparable(): boolean;
     getColumnType(prop: EntityProperty, platform: Platform): string;
 }

package/types/Uint8ArrayType.js

@@ -22,9 +22,6 @@ export class Uint8ArrayType extends Type {
     compareAsType() {
         return 'Buffer';
     }
-    ensureComparable() {
-        return false;
-    }
     getColumnType(prop, platform) {
         return platform.getBlobDeclarationSQL();
     }

package/utils/Configuration.d.ts

@@ -300,7 +300,7 @@ export interface MetadataDiscoveryOptions {
 }
 export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager<Driver> & Driver[typeof EntityManagerType] = EntityManager<Driver> & Driver[typeof EntityManagerType], Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends ConnectionOptions {
     entities?: Entities;
-    entitiesTs?: (string | EntityClass<AnyEntity> | EntitySchema)[];
+    entitiesTs?: Entities;
     extensions?: {
         register: (orm: MikroORM) => void;
     }[];

package/utils/EntityComparator.d.ts

@@ -1,4 +1,4 @@
-import type { EntityData, EntityDictionary, EntityMetadata, EntityProperty, IMetadataStorage } from '../typings.js';
+import type { EntityData, EntityDictionary, EntityMetadata, EntityName, EntityProperty, IMetadataStorage } from '../typings.js';
 import type { Platform } from '../platforms/Platform.js';
 type Comparator<T> = (a: T, b: T, options?: {
     includeInverseSides?: boolean;
@@ -48,7 +48,7 @@ export declare class EntityComparator {
     /**
      * @internal Highly performance-sensitive method.
      */
-    getSnapshotGenerator<T>(entityName: string): SnapshotGenerator<T>;
+    getSnapshotGenerator<T>(entityName: EntityName<T>): SnapshotGenerator<T>;
     /**
      * @internal
      */

package/utils/EntityComparator.js

@@ -199,6 +199,7 @@ export class EntityComparator {
      * @internal Highly performance-sensitive method.
      */
     getSnapshotGenerator(entityName) {
+        entityName = Utils.className(entityName);
         const exists = this.snapshotGenerators.get(entityName);
         if (exists) {
             return exists;