@mikro-orm/core 6.6.3-dev.1 → 6.6.3-dev.10

package/MikroORM.js

@@ -153,15 +153,9 @@ class MikroORM {
      * Closes the database connection.
      */
     async close(force = false) {
-        if (await this.isConnected()) {
-            await this.driver.close(force);
-        }
-        if (this.config.getMetadataCacheAdapter()?.close) {
-            await this.config.getMetadataCacheAdapter().close();
-        }
-        if (this.config.getResultCacheAdapter()?.close) {
-            await this.config.getResultCacheAdapter().close();
-        }
+        await this.driver.close(force);
+        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

@@ -6,7 +6,7 @@ import type { ManyToOneOptions } from '../decorators/ManyToOne';
 import type { OneToManyOptions } from '../decorators/OneToMany';
 import type { OneToOneOptions } from '../decorators/OneToOne';
 import type { ManyToManyOptions } from '../decorators/ManyToMany';
-import type { AnyString, GeneratedColumnCallback, Constructor, CheckCallback, FilterQuery, EntityName, Dictionary, EntityMetadata, PrimaryKeyProp, Hidden, Opt, Primary, EntityClass, Ref } from '../typings';
+import type { AnyString, GeneratedColumnCallback, Constructor, CheckCallback, FilterQuery, EntityName, Dictionary, EntityMetadata, PrimaryKeyProp, Hidden, Opt, Primary, EntityClass, Ref, IndexCallback } from '../typings';
 import type { ScalarReference } from './Reference';
 import type { SerializeOptions } from '../serialization/EntitySerializer';
 import type { Cascade, DeferMode, EventType, LoadStrategy, QueryOrderMap } from '../enums';
@@ -416,13 +416,32 @@ declare const propertyBuilders: {
     interval: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
     unknown: () => UniversalPropertyOptionsBuilder<{}, EmptyOptions, IncludeKeysForProperty>;
 };
-export declare function defineEntity<Properties extends Record<string, any>, const PK extends (keyof Properties)[] | undefined = undefined, Base = never>(meta: Omit<Partial<EntityMetadata<InferEntityFromProperties<Properties, PK>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks'> & {
+export interface EntityMetadataWithProperties<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: string;
-    extends?: EntityName<Base>;
-    properties: Properties | ((properties: typeof propertyBuilders) => Properties);
-    primaryKeys?: PK & InferPrimaryKey<Properties>[];
-    hooks?: DefineEntityHooks<InferEntityFromProperties<Properties, PK>>;
-}): EntitySchema<InferEntityFromProperties<Properties, PK>, Base>;
+    extends?: EntityName<TBase>;
+    properties: TProperties | ((properties: typeof propertyBuilders) => TProperties);
+    primaryKeys?: TPK & InferPrimaryKey<TProperties>[];
+    hooks?: DefineEntityHooks<InferEntityFromProperties<TProperties, TPK>>;
+    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<TProperties extends Record<string, any>, const TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never>(meta: EntityMetadataWithProperties<TProperties, TPK, TBase>): EntitySchema<InferEntityFromProperties<TProperties, TPK>, TBase>;
 export declare function defineEntity<Entity = any, Base = never>(meta: Omit<Partial<EntityMetadata<Entity>>, 'properties' | 'extends'> & {
     class: EntityClass<Entity>;
     extends?: EntityName<Base>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.6.3-dev.1",
+  "version": "6.6.3-dev.10",
   "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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -64,7 +64,7 @@
     "esprima": "4.0.1",
     "fs-extra": "11.3.2",
     "globby": "11.1.0",
-    "mikro-orm": "6.6.3-dev.1",
+    "mikro-orm": "6.6.3-dev.10",
     "reflect-metadata": "0.2.2"
   }
 }

package/utils/EntityComparator.js

@@ -6,6 +6,7 @@ const enums_1 = require("../enums");
 const Utils_1 = require("./Utils");
 const JsonType_1 = require("../types/JsonType");
 const RawQueryFragment_1 = require("./RawQueryFragment");
+const EntityIdentifier_1 = require("../entity/EntityIdentifier");
 class EntityComparator {
     metadata;
     platform;
@@ -522,8 +523,11 @@ class EntityComparator {
                     return val;
                 };
                 context.set('toArray', toArray);
+                context.set('EntityIdentifier', EntityIdentifier_1.EntityIdentifier);
                 ret += `    if (entity${entityKey} === null) {\n`;
                 ret += `      ret${dataKey} = null;\n`;
+                ret += `    } else if (entity${entityKey}?.__helper.__identifier && !entity${entityKey}.__helper.hasPrimaryKey()) {\n`;
+                ret += `      ret${dataKey} = entity${entityKey}?.__helper.__identifier;\n`;
                 ret += `    } else if (typeof entity${entityKey} !== 'undefined') {\n`;
                 ret += `      ret${dataKey} = toArray(entity${entityKey}.__helper.getPrimaryKey(true));\n`;
                 ret += `    }\n`;