@mikro-orm/core 7.0.0-dev.84 → 7.0.0-dev.86

package/MikroORM.js

@@ -18,17 +18,17 @@ export async function lookupExtensions(options) {
     const extensions = options.extensions ?? [];
     const exists = (name) => extensions.some(ext => ext.name === name);
     if (!exists('SeedManager')) {
-        await registerExtension('SeedManager', import('@mikro-orm/seeder' + ''), extensions);
+        await registerExtension('SeedManager', import((() => '@mikro-orm/seeder')()), extensions);
     }
     if (!exists('Migrator')) {
-        await registerExtension('Migrator', import('@mikro-orm/migrations' + ''), extensions);
+        await registerExtension('Migrator', import((() => '@mikro-orm/migrations')()), extensions);
     }
     /* v8 ignore if */
     if (!exists('Migrator')) {
-        await registerExtension('Migrator', import('@mikro-orm/migrations-mongodb' + ''), extensions);
+        await registerExtension('Migrator', import((() => '@mikro-orm/migrations-mongodb')()), extensions);
     }
     if (!exists('EntityGenerator')) {
-        await registerExtension('EntityGenerator', import('@mikro-orm/entity-generator' + ''), extensions);
+        await registerExtension('EntityGenerator', import((() => '@mikro-orm/entity-generator')()), extensions);
     }
     options.extensions = extensions;
     const metadataCacheEnabled = options.metadataCache?.enabled || options.metadataProvider?.useCache?.();

package/events/EventManager.d.ts

@@ -6,8 +6,9 @@ export declare class EventManager {
     private readonly entities;
     private readonly cache;
     private readonly subscribers;
-    constructor(subscribers: EventSubscriber[]);
+    constructor(subscribers: Iterable<EventSubscriber>);
     registerSubscriber(subscriber: EventSubscriber): void;
+    getSubscribers(): Set<EventSubscriber>;
     dispatchEvent<T extends object>(event: TransactionEventType, args: TransactionEventArgs, meta?: EntityMetadata<T>): unknown;
     dispatchEvent<T extends object>(event: EventType.onInit, args: Partial<EventArgs<T>>, meta?: EntityMetadata<T>): unknown;
     dispatchEvent<T extends object>(event: EventType, args: Partial<EventArgs<T> | FlushEventArgs>, meta?: EntityMetadata<T>): Promise<unknown>;

package/events/EventManager.js

@@ -4,21 +4,29 @@ export class EventManager {
     listeners = {};
     entities = new Map();
     cache = new Map();
-    subscribers = [];
+    subscribers = new Set();
     constructor(subscribers) {
-        subscribers.forEach(subscriber => this.registerSubscriber(subscriber));
+        for (const subscriber of subscribers) {
+            this.registerSubscriber(subscriber);
+        }
     }
     registerSubscriber(subscriber) {
-        this.subscribers.push(subscriber);
+        if (this.subscribers.has(subscriber)) {
+            return;
+        }
+        this.subscribers.add(subscriber);
         this.entities.set(subscriber, this.getSubscribedEntities(subscriber));
         this.cache.clear();
         Utils.keys(EventType)
             .filter(event => event in subscriber)
             .forEach(event => {
-            this.listeners[event] ??= [];
-            this.listeners[event].push(subscriber);
+            this.listeners[event] ??= new Set();
+            this.listeners[event].add(subscriber);
         });
     }
+    getSubscribers() {
+        return this.subscribers;
+    }
     dispatchEvent(event, args, meta) {
         const listeners = [];
         const entity = args.entity;
@@ -30,9 +38,9 @@ export class EventManager {
             const handler = typeof hook === 'function' ? hook : entity[hook] ?? prototypeHook;
             return handler.bind(entity);
         }));
-        for (const listener of this.listeners[event] || []) {
+        for (const listener of this.listeners[event] ?? new Set()) {
             const entities = this.entities.get(listener);
-            if (entities.length === 0 || !entity || entities.includes(entity.constructor.name)) {
+            if (entities.size === 0 || !entity || entities.has(entity.constructor.name)) {
                 listeners.push(listener[event].bind(listener));
             }
         }
@@ -51,9 +59,9 @@ export class EventManager {
             this.cache.set(cacheKey, true);
             return true;
         }
-        for (const listener of this.listeners[event] ?? []) {
+        for (const listener of this.listeners[event] ?? new Set()) {
             const entities = this.entities.get(listener);
-            if (entities.length === 0 || entities.includes(meta.className)) {
+            if (entities.size === 0 || entities.has(meta.className)) {
                 this.cache.set(cacheKey, true);
                 return true;
             }
@@ -66,8 +74,8 @@ export class EventManager {
     }
     getSubscribedEntities(listener) {
         if (!listener.getSubscribedEntities) {
-            return [];
+            return new Set();
         }
-        return listener.getSubscribedEntities().map(name => Utils.className(name));
+        return new Set(listener.getSubscribedEntities().map(name => Utils.className(name)));
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.84",
+  "version": "7.0.0-dev.86",
   "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",

package/utils/Configuration.d.ts

@@ -480,7 +480,7 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * Event subscribers to register.
      * Can be class references or instances.
      */
-    subscribers?: (EventSubscriber | Constructor<EventSubscriber>)[];
+    subscribers?: Iterable<EventSubscriber | Constructor<EventSubscriber>>;
     /**
      * Global entity filters to apply.
      * Filters are applied by default unless explicitly disabled.

package/utils/Configuration.js

@@ -319,7 +319,7 @@ export class Configuration {
         if (!this.options.filtersOnRelations) {
             this.options.autoJoinRefsForFilters ??= false;
         }
-        this.options.subscribers = Utils.unique(this.options.subscribers).map(subscriber => {
+        this.options.subscribers = [...this.options.subscribers].map(subscriber => {
             return subscriber.constructor.name === 'Function' ? new subscriber() : subscriber;
         });
         this.sync();

package/utils/DataloaderUtils.js

@@ -216,7 +216,7 @@ export class DataloaderUtils {
             return this.DataLoader;
         }
         try {
-            const mod = await import('dataloader' + '');
+            const mod = await import('dataloader');
             const DataLoader = mod.default;
             return (this.DataLoader ??= DataLoader);
         }

package/utils/EntityComparator.js

@@ -285,10 +285,14 @@ export class EntityComparator {
             lines.push(`${padding}    if (${value} == null || ${value} instanceof Date) {`);
             lines.push(`${padding}      ${key} = ${value};`);
             if (!tz || tz === 'local') {
+                lines.push(`${padding}    } else if (typeof ${value} === 'bigint') {`);
+                lines.push(`${padding}      ${key} = parseDate(Number(${value}));`);
                 lines.push(`${padding}    } else {`);
                 lines.push(`${padding}      ${key} = parseDate(${value});`);
             }
             else {
+                lines.push(`${padding}    } else if (typeof ${value} === 'bigint') {`);
+                lines.push(`${padding}      ${key} = parseDate(Number(${value}));`);
                 lines.push(`${padding}    } else if (typeof ${value} === 'number' || ${value}.includes('+') || ${value}.lastIndexOf('-') > 10 || ${value}.endsWith('Z')) {`);
                 lines.push(`${padding}      ${key} = parseDate(${value});`);
                 lines.push(`${padding}    } else {`);

package/utils/Utils.js

@@ -728,7 +728,7 @@ export class Utils {
         return this.dynamicImportProvider(specifier);
     }
     static getORMVersion() {
-        return '6.6.1';
+        return '6.6.2';
     }
     static createFunction(context, code) {
         try {

package/utils/fs-utils.d.ts

@@ -4,9 +4,9 @@ export declare const fs: {
     ensureDir(path: string): void;
     readJSONSync<T = Dictionary>(path: string): T;
     glob(input: string | string[], cwd?: string): string[];
-    getPackageConfig<T extends Dictionary>(basePath?: string): Promise<T>;
-    getORMPackages(): Promise<Set<string>>;
+    getPackageConfig<T extends Dictionary>(basePath?: string): T;
+    getORMPackages(): Set<string>;
     getORMPackageVersion(name: string): string | undefined;
-    checkPackageVersion(): Promise<void>;
+    checkPackageVersion(): void;
 };
 export * from '../cache/FileCacheAdapter.js';

package/utils/fs-utils.js

@@ -39,10 +39,11 @@ export const fs = {
         const files = globSync(input, { cwd, withFileTypes: true });
         return files.filter(f => f.isFile()).map(f => join(f.parentPath, f.name));
     },
-    async getPackageConfig(basePath = process.cwd()) {
+    getPackageConfig(basePath = process.cwd()) {
         if (this.pathExists(`${basePath}/package.json`)) {
             try {
-                return await Utils.dynamicImport(`${basePath}/package.json`);
+                const path = import.meta.resolve(`${basePath}/package.json`);
+                return this.readJSONSync(fileURLToPath(path));
             }
             catch (e) {
                 /* v8 ignore next */
@@ -56,8 +57,8 @@ export const fs = {
         }
         return this.getPackageConfig(parentFolder);
     },
-    async getORMPackages() {
-        const pkg = await this.getPackageConfig();
+    getORMPackages() {
+        const pkg = this.getPackageConfig();
         return new Set([
             ...Object.keys(pkg.dependencies ?? {}),
             ...Object.keys(pkg.devDependencies ?? {}),
@@ -74,12 +75,12 @@ export const fs = {
         }
     },
     // inspired by https://github.com/facebook/docusaurus/pull/3386
-    async checkPackageVersion() {
+    checkPackageVersion() {
         const coreVersion = Utils.getORMVersion();
         if (process.env.MIKRO_ORM_ALLOW_VERSION_MISMATCH || coreVersion === '[[MIKRO_ORM_VERSION]]') {
             return;
         }
-        const deps = await this.getORMPackages();
+        const deps = this.getORMPackages();
         const exceptions = new Set(['nestjs', 'sql-highlighter', 'mongo-highlighter']);
         const ormPackages = [...deps].filter(d => d.startsWith('@mikro-orm/') && d !== '@mikro-orm/core' && !exceptions.has(d.substring('@mikro-orm/'.length)));
         for (const ormPackage of ormPackages) {