@mikro-orm/core 7.0.0-dev.85 → 7.0.0-dev.87

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?.();
@@ -150,8 +150,8 @@ export class MikroORM {
      */
     async close(force = false) {
         await this.driver.close(force);
-        await this.config.getMetadataCacheAdapter().close?.();
-        await this.config.getResultCacheAdapter().close?.();
+        await this.config.getMetadataCacheAdapter()?.close?.();
+        await this.config.getResultCacheAdapter()?.close?.();
     }
     /**
      * Gets the `MetadataStorage` (without parameters) or `EntityMetadata` instance when provided with the `entityName` parameter.

package/entity/defineEntity.d.ts

@@ -1,6 +1,6 @@
 import type { EntityManager } from '../EntityManager.js';
 import type { ColumnType, PropertyOptions, ReferenceOptions, EnumOptions, EmbeddedOptions, ManyToOneOptions, OneToManyOptions, OneToOneOptions, ManyToManyOptions } from '../metadata/types.js';
-import type { AnyString, GeneratedColumnCallback, Constructor, CheckCallback, FilterQuery, EntityName, Dictionary, EntityMetadata, PrimaryKeyProp, Hidden, Opt, Primary, EntityClass, EntitySchemaWithMeta, InferEntity, MaybeReturnType, Ref } from '../typings.js';
+import type { AnyString, GeneratedColumnCallback, Constructor, CheckCallback, FilterQuery, EntityName, Dictionary, EntityMetadata, PrimaryKeyProp, Hidden, Opt, Primary, EntityClass, EntitySchemaWithMeta, InferEntity, MaybeReturnType, Ref, IndexCallback } from '../typings.js';
 import type { ScalarReference } from './Reference.js';
 import type { SerializeOptions } from '../serialization/EntitySerializer.js';
 import type { Cascade, DeferMode, EmbeddedPrefixMode, EventType, LoadStrategy, QueryOrderMap } from '../enums.js';
@@ -409,14 +409,33 @@ declare const propertyBuilders: {
     interval: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
     unknown: () => UniversalPropertyOptionsBuilder<{}, EmptyOptions, IncludeKeysForProperty>;
 };
-export declare function defineEntity<const TName extends string, const TTableName extends string, const TProperties extends Record<string, any>, const TPK extends (keyof TProperties)[] | undefined = undefined, const TBase = never>(meta: Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks'> & {
+export interface EntityMetadataWithProperties<TName extends string, TTableName extends string, TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminatorColumn' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques'> {
     name: TName;
     tableName?: TTableName;
     extends?: EntityName<TBase>;
     properties: TProperties | ((properties: typeof propertyBuilders) => TProperties);
     primaryKeys?: TPK & InferPrimaryKey<TProperties>[];
     hooks?: DefineEntityHooks<InferEntityFromProperties<TProperties, TPK>>;
-}): EntitySchemaWithMeta<TName, TTableName, InferEntityFromProperties<TProperties, TPK>, TBase, TProperties>;
+    discriminatorColumn?: keyof TProperties;
+    versionProperty?: keyof TProperties;
+    concurrencyCheckKeys?: Set<keyof TProperties>;
+    serializedPrimaryKey?: keyof TProperties;
+    indexes?: {
+        properties?: keyof TProperties | (keyof TProperties)[];
+        name?: string;
+        type?: string;
+        options?: Dictionary;
+        expression?: string | IndexCallback<InferEntityFromProperties<TProperties, TPK>>;
+    }[];
+    uniques?: {
+        properties?: keyof TProperties | (keyof TProperties)[];
+        name?: string;
+        options?: Dictionary;
+        expression?: string | IndexCallback<InferEntityFromProperties<TProperties, TPK>>;
+        deferMode?: DeferMode | `${DeferMode}`;
+    }[];
+}
+export declare function defineEntity<const TName extends string, const TTableName extends string, const TProperties extends Record<string, any>, const TPK extends (keyof TProperties)[] | undefined = undefined, const TBase = never>(meta: EntityMetadataWithProperties<TName, TTableName, TProperties, TPK, TBase>): EntitySchemaWithMeta<TName, TTableName, InferEntityFromProperties<TProperties, TPK>, TBase, TProperties>;
 export declare function defineEntity<const TEntity = any, const TProperties extends Record<string, any> = Record<string, any>, const TClassName extends string = string, const TTableName extends string = string, const TBase = never>(meta: Omit<Partial<EntityMetadata<TEntity>>, 'properties' | 'extends' | 'className' | 'tableName'> & {
     class: EntityClass<TEntity>;
     className?: TClassName;

package/package.json

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