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

package/EntityManager.js

@@ -355,7 +355,8 @@ export class EntityManager {
             const field = hint.field.split(':')[0];
             const prop = meta.properties[field];
             const strategy = getLoadingStrategy(prop.strategy || hint.strategy || options.strategy || this.config.get('loadStrategy'), prop.kind);
-            const joined = strategy === LoadStrategy.JOINED && prop.kind !== ReferenceKind.SCALAR;
+            const joined = (strategy === LoadStrategy.JOINED || (prop.kind === ReferenceKind.ONE_TO_ONE && !prop.owner)) &&
+                prop.kind !== ReferenceKind.SCALAR;
             if (!joined && !hint.filter) {
                 continue;
             }
@@ -424,11 +425,13 @@ export class EntityManager {
                 const populated = options.populate.filter(({ field }) => field.split(':')[0] === prop.name);
                 let found = false;
                 for (const hint of populated) {
-                    if (!hint.all) {
+                    const strategy = getLoadingStrategy(prop.strategy || hint.strategy || options.strategy || this.config.get('loadStrategy'), prop.kind);
+                    // inverse 1:1 always produces a JOIN (forced by `joinedProps()`), regardless of strategy
+                    const willJoin = strategy === LoadStrategy.JOINED || (prop.kind === ReferenceKind.ONE_TO_ONE && !prop.owner);
+                    if (!hint.all || willJoin) {
                         hint.filter = true;
                     }
-                    const strategy = getLoadingStrategy(prop.strategy || hint.strategy || options.strategy || this.config.get('loadStrategy'), prop.kind);
-                    if (hint.field === `${prop.name}:ref` || (hint.filter && strategy === LoadStrategy.JOINED)) {
+                    if (hint.field === `${prop.name}:ref` || (hint.filter && willJoin)) {
                         found = true;
                     }
                 }

package/entity/defineEntity.d.ts

@@ -556,12 +556,15 @@ export type PropertyBuilders = {
 /** Own keys + base entity keys (when TBase is not `never`). Guards against `keyof never = string | number | symbol`. */
 type AllKeys<TProperties, TBase> = keyof TProperties | (IsNever<TBase> extends true ? never : keyof TBase);
 /** Metadata descriptor for `defineEntity()`, combining entity options with property definitions. */
-export interface EntityMetadataWithProperties<TName extends string, TTableName extends string, TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never, TRepository = never, TForceObject extends boolean = false> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK, TBase, TRepository>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminatorColumn' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques' | 'repository' | 'filters' | 'orderBy'> {
+export interface EntityMetadataWithProperties<TName extends string, TTableName extends string, TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never, TRepository = never, TForceObject extends boolean = false, TDiscriminatorColumn extends string | undefined = undefined, TDiscriminatorValue extends string | number | undefined = undefined, TBaseDiscriminatorColumn extends string | undefined = undefined> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK, TBase, TRepository>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminatorColumn' | 'discriminatorValue' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques' | 'repository' | 'filters' | 'orderBy'> {
     name: TName;
     tableName?: TTableName;
     extends?: {
         '~entity': TBase;
-    } | EntityCtor<TBase>;
+        '~discriminatorColumn'?: TBaseDiscriminatorColumn;
+    } | (EntityCtor<TBase> & {
+        '~discriminatorColumn'?: TBaseDiscriminatorColumn;
+    });
     properties: TProperties | ((properties: PropertyBuilders) => TProperties);
     primaryKeys?: TPK & InferPrimaryKeyConstraint<TProperties>[];
     hooks?: DefineEntityHooks;
@@ -581,7 +584,8 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
     } | {
         [K in Extract<AllKeys<TProperties, TBase>, string>]?: QueryOrderKeysFlat;
     }[];
-    discriminatorColumn?: string;
+    discriminatorColumn?: TDiscriminatorColumn;
+    discriminatorValue?: TDiscriminatorValue;
     versionProperty?: AllKeys<TProperties, TBase>;
     concurrencyCheckKeys?: Set<AllKeys<TProperties, TBase>>;
     serializedPrimaryKey?: AllKeys<TProperties, TBase>;
@@ -611,7 +615,7 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
     }[];
 }
 /** Defines an entity schema using property builders, with full type inference from the property definitions. */
-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, const TRepository = never, const TForceObject extends boolean = false>(meta: EntityMetadataWithProperties<TName, TTableName, TProperties, TPK, TBase, TRepository, TForceObject>): EntitySchemaWithMeta<TName, TTableName, InferEntityFromProperties<TProperties, TPK, TBase, TRepository, TForceObject>, TBase, TProperties>;
+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, const TRepository = never, const TForceObject extends boolean = false, const TDiscriminatorColumn extends string | undefined = undefined, const TDiscriminatorValue extends string | number | undefined = undefined, const TBaseDiscriminatorColumn extends string | undefined = undefined>(meta: EntityMetadataWithProperties<TName, TTableName, TProperties, TPK, TBase, TRepository, TForceObject, TDiscriminatorColumn, TDiscriminatorValue, TBaseDiscriminatorColumn>): EntitySchemaWithMeta<TName, TTableName, InferEntityFromProperties<TProperties, TPK, TBase, TRepository, TForceObject, TBaseDiscriminatorColumn, TDiscriminatorValue>, TBase, TProperties, EntityCtor<InferEntityFromProperties<TProperties, TPK, TBase, TRepository, TForceObject, TBaseDiscriminatorColumn, TDiscriminatorValue>>, TDiscriminatorColumn>;
 /** Defines an entity schema for an existing class, combining the class with property builders. */
 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, const TClass extends EntityCtor = EntityCtor<TEntity>>(meta: Omit<Partial<EntityMetadata<TEntity>>, 'properties' | 'extends' | 'className' | 'tableName' | 'hooks'> & {
     class: TClass;
@@ -647,7 +651,7 @@ type InferJSType<T> = T extends typeof Type<infer TValue, any> ? NonNullable<TVa
 type InferColumnType<T extends string> = T extends 'int' | 'int4' | 'integer' | 'bigint' | 'int8' | 'int2' | 'tinyint' | 'smallint' | 'mediumint' ? number : T extends 'double' | 'double precision' | 'real' | 'float8' | 'decimal' | 'numeric' | 'float' | 'float4' ? number : T extends 'datetime' | 'time' | 'time with time zone' | 'timestamp' | 'timestamp with time zone' | 'timetz' | 'timestamptz' | 'date' | 'interval' ? Date : T extends 'ObjectId' | 'objectId' | 'character varying' | 'varchar' | 'char' | 'character' | 'uuid' | 'text' | 'tinytext' | 'mediumtext' | 'longtext' | 'enum' ? string : T extends 'boolean' | 'bool' | 'bit' ? boolean : T extends 'blob' | 'tinyblob' | 'mediumblob' | 'longblob' | 'bytea' ? Buffer : T extends 'point' | 'line' | 'lseg' | 'box' | 'circle' | 'path' | 'polygon' | 'geometry' ? number[] : T extends 'tsvector' | 'tsquery' ? string[] : T extends 'json' | 'jsonb' ? any : any;
 type BaseEntityMethodKeys = 'toObject' | 'toPOJO' | 'serialize' | 'assign' | 'populate' | 'init' | 'toReference';
 /** Infers the entity type from a `defineEntity()` properties map, resolving builders, base classes, and primary keys. */
-export type InferEntityFromProperties<Properties extends Record<string, any>, PK extends (keyof Properties)[] | undefined = undefined, Base = never, Repository = never, ForceObject extends boolean = false> = (IsNever<Base> extends true ? {} : Base extends {
+export type InferEntityFromProperties<Properties extends Record<string, any>, PK extends (keyof Properties)[] | undefined = undefined, Base = never, Repository = never, ForceObject extends boolean = false, BaseDiscriminatorColumn extends string | undefined = undefined, DiscriminatorValue extends string | number | undefined = undefined> = (IsNever<Base> extends true ? {} : Base extends {
     toObject(...args: any[]): any;
 } ? Pick<IWrappedEntity<{
     -readonly [K in keyof Properties]: InferBuilderValue<MaybeReturnType<Properties[K]>>;
@@ -655,17 +659,20 @@ export type InferEntityFromProperties<Properties extends Record<string, any>, PK
     [PrimaryKeyProp]?: InferCombinedPrimaryKey<Properties, PK, Base>;
 } & (IsNever<Repository> extends true ? {} : {
     [EntityRepositoryType]?: Repository extends Constructor<infer R> ? R : Repository;
-}) & Omit<Base, typeof PrimaryKeyProp>>, BaseEntityMethodKeys> : {}) & {
+}) & NarrowDiscriminator<Omit<Base, typeof PrimaryKeyProp>, BaseDiscriminatorColumn, DiscriminatorValue>>, BaseEntityMethodKeys> : {}) & {
     -readonly [K in keyof Properties]: InferBuilderValue<MaybeReturnType<Properties[K]>>;
 } & {
     [PrimaryKeyProp]?: InferCombinedPrimaryKey<Properties, PK, Base>;
 } & (IsNever<Repository> extends true ? {} : {
     [EntityRepositoryType]?: Repository extends Constructor<infer R> ? R : Repository;
-}) & (IsNever<Base> extends true ? {} : Omit<Base, typeof PrimaryKeyProp>) & (ForceObject extends true ? {
+}) & (IsNever<Base> extends true ? {} : NarrowDiscriminator<Omit<Base, typeof PrimaryKeyProp>, BaseDiscriminatorColumn, DiscriminatorValue>) & (ForceObject extends true ? {
     [Config]?: DefineConfig<{
         forceObject: true;
     }>;
 } : {});
+type NarrowDiscriminator<Base, DiscColumn extends string | undefined, DiscValue> = DiscColumn extends string ? DiscColumn extends keyof Base ? DiscValue extends string | number ? Omit<Base, DiscColumn> & {
+    [K in DiscColumn]: DiscValue;
+} : Base : Base : Base;
 type InferCombinedPrimaryKey<Properties extends Record<string, any>, PK, Base> = PK extends undefined ? CombinePrimaryKeys<InferPrimaryKey<Properties>, ExtractBasePrimaryKey<Base>> : PK;
 type ExtractBasePrimaryKey<Base> = Base extends {
     [PrimaryKeyProp]?: infer BasePK;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.0.15-dev.1",
+  "version": "7.0.15-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.",
   "keywords": [
     "data-mapper",

package/typings.d.ts

@@ -990,7 +990,7 @@ export type MigrationRow = {
  * @internal
  */
 export interface IMigrationRunner {
-    run(migration: Migration, method: 'up' | 'down'): Promise<void>;
+    run(migration: Migration, method: 'up' | 'down', afterRun?: (tx?: Transaction) => Promise<void>): Promise<void>;
     setMasterMigration(trx: Transaction): void;
     unsetMasterMigration(): void;
 }
@@ -999,8 +999,8 @@ export interface IMigrationRunner {
  */
 export interface IMigratorStorage {
     executed(): Promise<string[]>;
-    logMigration(params: Dictionary): Promise<void>;
-    unlogMigration(params: Dictionary): Promise<void>;
+    logMigration(params: Dictionary, tx?: Transaction): Promise<void>;
+    unlogMigration(params: Dictionary, tx?: Transaction): Promise<void>;
     getExecutedMigrations(): Promise<MigrationRow[]>;
     ensureTable?(): Promise<void>;
     setMasterMigration(trx: Transaction): void;
@@ -1298,15 +1298,18 @@ export type MaybeReturnType<T> = T extends (...args: any[]) => infer R ? R : T;
  * Extended `EntitySchema` interface that carries additional type-level metadata (entity name, properties, table name).
  * Returned by `defineEntity()` to provide strong type inference without explicit generics.
  */
-export interface EntitySchemaWithMeta<TName extends string = string, TTableName extends string = string, TEntity = any, TBase = never, TProperties extends Record<string, any> = Record<string, any>, TClass extends EntityCtor = EntityCtor<TEntity>> extends EntitySchema<TEntity, TBase, TClass> {
+export interface EntitySchemaWithMeta<TName extends string = string, TTableName extends string = string, TEntity = any, TBase = never, TProperties extends Record<string, any> = Record<string, any>, TClass extends EntityCtor = EntityCtor<TEntity>, TDiscriminatorColumn extends string | undefined = undefined> extends EntitySchema<TEntity, TBase, TClass> {
     readonly name: TName;
     readonly properties: TProperties;
     readonly tableName: TTableName;
     /** @internal Direct entity type access - avoids expensive pattern matching */
     readonly '~entity': TEntity;
+    /** @internal Type-level marker carrying the discriminator column name, used by `defineEntity()` to narrow inherited discriminator properties to the literal `discriminatorValue` of each child schema. */
+    readonly '~discriminatorColumn'?: TDiscriminatorColumn;
     /** @internal */
     readonly class: TClass & {
         '~entityName'?: TName;
+        '~discriminatorColumn'?: TDiscriminatorColumn;
     };
 }
 /**

package/utils/AbstractMigrator.d.ts

@@ -5,8 +5,8 @@ import type { EntityManagerType, IDatabaseDriver } from '../drivers/IDatabaseDri
 interface RunnableMigration {
     name: string;
     path?: string;
-    up: () => MaybePromise<void>;
-    down: () => MaybePromise<void>;
+    up: (afterRun?: (tx?: Transaction) => Promise<void>) => MaybePromise<void>;
+    down: (afterRun?: (tx?: Transaction) => Promise<void>) => MaybePromise<void>;
 }
 type MigrateOptions = {
     from?: string | number;

package/utils/AbstractMigrator.js

@@ -98,26 +98,26 @@ export class AbstractMigrator {
         }
     }
     resolve(params) {
-        const createMigrationHandler = async (method) => {
+        const createMigrationHandler = async (method, afterRun) => {
             const { fs } = await import('@mikro-orm/core/fs-utils');
             const migration = await fs.dynamicImport(params.path);
             const MigrationClass = Object.values(migration).find(cls => typeof cls === 'function' && typeof cls.constructor === 'function');
             const instance = new MigrationClass(this.driver, this.config);
-            await this.runner.run(instance, method);
+            await this.runner.run(instance, method, afterRun);
         };
         return {
             name: this.storage.getMigrationName(params.name),
             path: params.path,
-            up: () => createMigrationHandler('up'),
-            down: () => createMigrationHandler('down'),
+            up: afterRun => createMigrationHandler('up', afterRun),
+            down: afterRun => createMigrationHandler('down', afterRun),
         };
     }
     initialize(MigrationClass, name) {
         const instance = new MigrationClass(this.driver, this.config);
         return {
             name: this.storage.getMigrationName(name),
-            up: () => this.runner.run(instance, 'up'),
-            down: () => this.runner.run(instance, 'down'),
+            up: afterRun => this.runner.run(instance, 'up', afterRun),
+            down: afterRun => this.runner.run(instance, 'down', afterRun),
         };
     }
     /**
@@ -196,13 +196,15 @@ export class AbstractMigrator {
         for (const migration of toRun) {
             const event = { name: migration.name, path: migration.path };
             await this.emit(eventBefore, event);
-            await migration[method]();
-            if (method === 'up') {
-                await this.storage.logMigration({ name: migration.name });
-            }
-            else {
-                await this.storage.unlogMigration({ name: migration.name });
-            }
+            // log inside the runner's tx (if any) so a logMigration failure rolls the migration back
+            await migration[method](async (tx) => {
+                if (method === 'up') {
+                    await this.storage.logMigration({ name: migration.name }, tx);
+                }
+                else {
+                    await this.storage.unlogMigration({ name: migration.name }, tx);
+                }
+            });
             await this.emit(eventAfter, event);
             result.push(event);
         }

package/utils/Utils.js

@@ -141,7 +141,7 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.15-dev.1';
+    static #ORM_VERSION = '7.0.15-dev.10';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */