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

package/EntityManager.d.ts

@@ -109,7 +109,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     /**
      * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
      */
-    addFilter<T extends object>(options: FilterDef<T>): void;
+    addFilter<T extends EntityName<any> | readonly EntityName<any>[]>(options: FilterDef<T>): void;
     /**
      * Sets filter parameter values globally inside context defined by this entity manager.
      * If you want to set shared value for all contexts, be sure to use the root entity manager.
@@ -129,7 +129,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     getLoggerContext<T extends Dictionary = Dictionary>(options?: {
         disableContextResolution?: boolean;
     }): T;
-    setFlushMode(flushMode?: FlushMode): void;
+    setFlushMode(flushMode?: FlushMode | `${FlushMode}`): void;
     protected processWhere<Entity extends object, Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(entityName: string, where: FilterQuery<Entity>, options: FindOptions<Entity, Hint, Fields, Excludes> | FindOneOptions<Entity, Hint, Fields, Excludes>, type: 'read' | 'update' | 'delete'): Promise<FilterQuery<Entity>>;
     protected applyDiscriminatorCondition<Entity extends object>(entityName: string, where: FilterQuery<Entity>): FilterQuery<Entity>;
     protected createPopulateWhere<Entity extends object>(cond: ObjectQuery<Entity>, options: FindOptions<Entity, any, any, any> | FindOneOptions<Entity, any, any, any> | CountOptions<Entity, any>): ObjectQuery<Entity>;
@@ -611,7 +611,7 @@ export interface ForkOptions {
     /** use this flag to ignore the current async context - this is required if we want to call `em.fork()` inside the `getContext` handler */
     disableContextResolution?: boolean;
     /** set flush mode for this fork, overrides the global option can be overridden locally via FindOptions */
-    flushMode?: FlushMode;
+    flushMode?: FlushMode | `${FlushMode}`;
     /** disable transactions for this fork */
     disableTransactions?: boolean;
     /** should we keep the transaction context of the parent EM? */

package/EntityManager.js

@@ -256,25 +256,6 @@ export class EntityManager {
         }
         return { where: options.populateWhere };
     }
-    // /**
-    //  * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
-    //  */
-    // addFilter<T1>(name: string, cond: FilterQuery<T1> | ((args: Dictionary) => MaybePromise<FilterQuery<T1>>), entityName?: EntityName<T1> | [EntityName<T1>], options?: boolean | Partial<FilterDef>): void;
-    //
-    // /**
-    //  * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
-    //  */
-    // addFilter<T1, T2>(name: string, cond: FilterQuery<T1 | T2> | ((args: Dictionary) => MaybePromise<FilterQuery<T1 | T2>>), entityName?: [EntityName<T1>, EntityName<T2>], options?: boolean | Partial<FilterDef>): void;
-    //
-    // /**
-    //  * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
-    //  */
-    // addFilter<T1, T2, T3>(name: string, cond: FilterQuery<T1 | T2 | T3> | ((args: Dictionary) => MaybePromise<FilterQuery<T1 | T2 | T3>>), entityName?: [EntityName<T1>, EntityName<T2>, EntityName<T3>], options?: boolean | Partial<FilterDef>): void;
-    //
-    // /**
-    //  * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
-    //  */
-    // addFilter(name: string, cond: Dictionary | ((args: Dictionary) => MaybePromise<FilterQuery<AnyEntity>>), entityName?: EntityName<AnyEntity> | EntityName<AnyEntity>[], options?: boolean | Partial<FilterDef>): void;
     /**
      * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
      */

package/connections/Connection.d.ts

@@ -44,14 +44,14 @@ export declare abstract class Connection {
     ensureConnection(): Promise<void>;
     protected onConnect(): Promise<void>;
     transactional<T>(cb: (trx: Transaction) => Promise<T>, options?: {
-        isolationLevel?: IsolationLevel;
+        isolationLevel?: IsolationLevel | `${IsolationLevel}`;
         readOnly?: boolean;
         ctx?: Transaction;
         eventBroadcaster?: TransactionEventBroadcaster;
         loggerContext?: LogContext;
     }): Promise<T>;
     begin(options?: {
-        isolationLevel?: IsolationLevel;
+        isolationLevel?: IsolationLevel | `${IsolationLevel}`;
         readOnly?: boolean;
         ctx?: Transaction;
         eventBroadcaster?: TransactionEventBroadcaster;

package/decorators/Transactional.d.ts

@@ -1,4 +1,4 @@
-import type { TransactionOptions } from '../enums.js';
+import { type TransactionOptions } from '../enums.js';
 import type { ContextProvider } from '../typings.js';
 type TransactionalOptions<T> = TransactionOptions & {
     context?: ContextProvider<T>;
@@ -9,6 +9,7 @@ type TransactionalOptions<T> = TransactionOptions & {
  * The difference is that you can specify the context in which the transaction begins by providing `context` option,
  * and if omitted, the transaction will begin in the current context implicitly.
  * It works on async functions and can be nested with `em.transactional()`.
+ * Unlike `em.transactional()`, this decorator uses `REQUIRED` propagation by default, which means it will join existing transactions.
  */
 export declare function Transactional<T extends object>(options?: TransactionalOptions<T>): MethodDecorator;
 export {};

package/decorators/Transactional.js

@@ -1,3 +1,4 @@
+import { TransactionPropagation } from '../enums.js';
 import { RequestContext } from '../utils/RequestContext.js';
 import { resolveContextProvider } from '../utils/resolveContextProvider.js';
 import { TransactionContext } from '../utils/TransactionContext.js';
@@ -6,6 +7,7 @@ import { TransactionContext } from '../utils/TransactionContext.js';
  * The difference is that you can specify the context in which the transaction begins by providing `context` option,
  * and if omitted, the transaction will begin in the current context implicitly.
  * It works on async functions and can be nested with `em.transactional()`.
+ * Unlike `em.transactional()`, this decorator uses `REQUIRED` propagation by default, which means it will join existing transactions.
  */
 export function Transactional(options = {}) {
     return function (target, propertyKey, descriptor) {
@@ -15,6 +17,7 @@ export function Transactional(options = {}) {
         }
         descriptor.value = async function (...args) {
             const { context, contextName, ...txOptions } = options;
+            txOptions.propagation ??= TransactionPropagation.REQUIRED;
             const em = (await resolveContextProvider(this, context))
                 || TransactionContext.getEntityManager(contextName)
                 || RequestContext.getEntityManager(contextName);

package/drivers/IDatabaseDriver.d.ts

@@ -169,7 +169,7 @@ export interface FindOptions<Entity, Hint extends string = never, Fields extends
 export interface FindByCursorOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never, I extends boolean = true> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'offset'> {
     includeCount?: I;
 }
-export interface FindOneOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'lockMode'> {
+export interface FindOneOptions<T, P extends string = never, F extends string = '*', E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'lockMode'> {
     lockMode?: LockMode;
     lockVersion?: number | Date;
 }

package/enums.d.ts

@@ -170,11 +170,11 @@ export declare enum TransactionPropagation {
 }
 export interface TransactionOptions {
     ctx?: Transaction;
-    propagation?: TransactionPropagation;
-    isolationLevel?: IsolationLevel;
+    propagation?: TransactionPropagation | `${TransactionPropagation}`;
+    isolationLevel?: IsolationLevel | `${IsolationLevel}`;
     readOnly?: boolean;
     clear?: boolean;
-    flushMode?: FlushMode;
+    flushMode?: FlushMode | `${FlushMode}`;
     ignoreNestedTransactions?: boolean;
     loggerContext?: LogContext;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.55",
+  "version": "7.0.0-dev.57",
   "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",
@@ -55,7 +55,7 @@
     "dataloader": "2.2.3",
     "dotenv": "17.2.3",
     "esprima": "4.0.1",
-    "mikro-orm": "7.0.0-dev.55",
+    "mikro-orm": "7.0.0-dev.57",
     "reflect-metadata": "0.2.2",
     "tinyglobby": "0.2.13"
   }

package/typings.d.ts

@@ -713,14 +713,18 @@ export interface MigrationObject {
     name: string;
     class: Constructor<Migration>;
 }
-export type FilterDef<T extends object = any> = {
+type EntityFromInput<T> = T extends readonly EntityName<infer U>[] ? U : T extends EntityName<infer U> ? U : never;
+type FilterDefResolved<T extends object = any> = {
     name: string;
-    cond: Dictionary | ((args: Dictionary, type: 'read' | 'update' | 'delete', em: any, options?: FindOptions<T, any, any, any> | FindOneOptions<T, any, any, any>, entityName?: EntityName<T>) => MaybePromise<Dictionary>);
+    cond: FilterQuery<T> | ((args: Dictionary, type: 'read' | 'update' | 'delete', em: any, options?: FindOptions<T, any, any, any> | FindOneOptions<T, any, any, any>, entityName?: EntityName<T>) => MaybePromise<FilterQuery<T>>);
     default?: boolean;
     entity?: EntityName<T> | EntityName<T>[];
     args?: boolean;
     strict?: boolean;
 };
+export type FilterDef<T extends EntityName<any> | readonly EntityName<any>[] = any> = FilterDefResolved<EntityFromInput<T>> & {
+    entity?: T;
+};
 export type Populate<T, P extends string = never> = readonly AutoPath<T, P, `${PopulatePath}`>[] | false;
 export type PopulateOptions<T> = {
     field: EntityKey<T>;