@tsed/mikro-orm 8.0.1 → 8.0.3

package/package.json

@@ -2,13 +2,14 @@
   "name": "@tsed/mikro-orm",
   "description": "MikroORM package for Ts.ED framework",
   "type": "module",
-  "version": "8.0.1",
+  "version": "8.0.3",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
   "typings": "./lib/types/index.d.ts",
   "exports": {
     ".": {
+      "@tsed/source": "./src/index.ts",
       "types": "./lib/types/index.d.ts",
       "import": "./lib/esm/index.js",
       "default": "./lib/esm/index.js"
@@ -27,15 +28,15 @@
   "devDependencies": {
     "@mikro-orm/core": "6.3.12",
     "@mikro-orm/mongodb": "6.3.12",
-    "@tsed/barrels": "8.0.1",
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/json-mapper": "8.0.1",
+    "@tsed/barrels": "8.0.3",
+    "@tsed/core": "8.0.3",
+    "@tsed/di": "8.0.3",
+    "@tsed/json-mapper": "8.0.3",
     "@tsed/logger": "^6.7.8",
-    "@tsed/platform-http": "8.0.1",
-    "@tsed/schema": "8.0.1",
-    "@tsed/testcontainers-mongo": "8.0.1",
-    "@tsed/typescript": "8.0.1",
+    "@tsed/platform-http": "8.0.3",
+    "@tsed/schema": "8.0.3",
+    "@tsed/testcontainers-mongo": "8.0.3",
+    "@tsed/typescript": "8.0.3",
     "cross-env": "7.0.3",
     "eslint": "9.12.0",
     "ts-mockito": "^2.6.1",
@@ -44,10 +45,10 @@
   },
   "peerDependencies": {
     "@mikro-orm/core": ">=4.5.9",
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
+    "@tsed/core": "8.0.3",
+    "@tsed/di": "8.0.3",
     "@tsed/logger": ">=6.7.5",
-    "@tsed/platform-http": "8.0.1"
+    "@tsed/platform-http": "8.0.3"
   },
   "repository": "https://github.com/tsedio/tsed",
   "bugs": {

package/readme.md

@@ -1,5 +1,5 @@
 <p style="text-align: center" align="center">
- <a href="https://tsed.io" target="_blank"><img src="https://tsed.io/tsed-og.png" width="200" alt="Ts.ED logo"/></a>
+ <a href="https://tsed.dev" target="_blank"><img src="https://tsed.dev/tsed-og.png" width="200" alt="Ts.ED logo"/></a>
 </p>
 
 <div align="center">
@@ -16,9 +16,9 @@
 </div>
 
 <div align="center">
-  <a href="https://tsed.io/">Website</a>
+  <a href="https://tsed.dev/">Website</a>
   <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
-  <a href="https://tsed.io/getting-started/">Getting started</a>
+  <a href="https://tsed.dev/getting-started/">Getting started</a>
   <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
   <a href="https://api.tsed.io/rest/slack/tsedio/tsed">Slack</a>
   <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
@@ -27,7 +27,7 @@
 
 <hr />
 
-A package of Ts.ED framework. See website: https://tsed.io/tutorials/mikro-orm
+A package of Ts.ED framework. See website: https://tsed.dev/tutorials/mikro-orm
 
 ## Feature
 
@@ -219,7 +219,7 @@ export class User {
 }
 ```
 
-Now, the model is correctly defined and can be used with a [Controller](https://tsed.io/docs/controllers.html)
+Now, the model is correctly defined and can be used with a [Controller](https://tsed.dev/docs/controllers.html)
 , [AJV validation](tutorials/ajv.md),
 [Swagger](tutorials/swagger.md) and [MikroORM](https://mikro-orm.io/docs/defining-entities).
 
@@ -462,7 +462,7 @@ When using the `AfterTransactionCommit` hook, you need to handle eventual consis
 
 ## Contributors
 
-Please read [contributing guidelines here](https://tsed.io/contributing.html)
+Please read [contributing guidelines here](https://tsed.dev/contributing.html)
 
 <a href="https://github.com/tsedio/tsed/graphs/contributors"><img src="https://opencollective.com/tsed/contributors.svg?width=890" /></a>
 

package/src/MikroOrmModule.spec.ts

@@ -0,0 +1,110 @@
+import {EntityManager, EventSubscriber, MikroORM, Options} from "@mikro-orm/core";
+import {PlatformTest} from "@tsed/platform-http/testing";
+import {anyOfClass, anything, deepEqual, instance, mock, reset, verify, when} from "ts-mockito";
+
+import {Subscriber} from "./decorators/subscriber.js";
+import {MikroOrmModule} from "./MikroOrmModule.js";
+import {MikroOrmContext} from "./services/MikroOrmContext.js";
+import {MikroOrmRegistry} from "./services/MikroOrmRegistry.js";
+
+class Subscriber1 implements EventSubscriber {}
+
+@Subscriber()
+class Subscriber2 implements EventSubscriber {}
+
+describe("MikroOrmModule", () => {
+  const config: Options = {
+    type: "mongo",
+    entities: [],
+    clientUrl: "mongo://localhost",
+    subscribers: [new Subscriber1()]
+  } as never;
+  const mockedMikroOrmRegistry = mock<MikroOrmRegistry>();
+  const mockedMikroOrmContext = mock<MikroOrmContext>();
+  const mockedMikroORM = mock<MikroORM>();
+  const mockedEntityManager = mock<EntityManager>();
+
+  let mikroOrmModule!: MikroOrmModule;
+
+  beforeEach(async () => {
+    await PlatformTest.create({
+      mikroOrm: [config],
+      imports: [
+        {
+          token: MikroOrmContext,
+          use: instance(mockedMikroOrmContext)
+        },
+        {
+          token: MikroOrmRegistry,
+          use: instance(mockedMikroOrmRegistry)
+        }
+      ]
+    });
+
+    mikroOrmModule = PlatformTest.get<MikroOrmModule>(MikroOrmModule);
+  });
+
+  afterEach(() => {
+    vi.resetAllMocks();
+
+    reset<MikroOrmRegistry | EntityManager | MikroORM | MikroOrmContext>(
+      mockedMikroOrmRegistry,
+      mockedMikroOrmContext,
+      mockedMikroORM,
+      mockedEntityManager
+    );
+
+    return PlatformTest.reset();
+  });
+
+  describe("$onInit", () => {
+    it("should register the subscribers", async () => {
+      // act
+      await mikroOrmModule.$onInit();
+
+      // assert
+      verify(
+        mockedMikroOrmRegistry.register(deepEqual({...config, subscribers: [anyOfClass(Subscriber1), anyOfClass(Subscriber2)]}))
+      ).called();
+    });
+  });
+
+  describe("$onDestroy", () => {
+    it("should destroy the corresponding instances", async () => {
+      // act
+      await mikroOrmModule.$onDestroy();
+
+      // assert
+      verify(mockedMikroOrmRegistry.clear()).called();
+    });
+  });
+
+  describe("$alterRunInContext", () => {
+    it("should return a function", () => {
+      // arrange
+      const next = vi.fn();
+
+      // act
+      const result = mikroOrmModule.$alterRunInContext(next);
+
+      // assert
+      expect(result).toBeInstanceOf(Function);
+    });
+
+    it("should make a function create a context", () => {
+      // arrange
+      const next = vi.fn();
+      const manager = instance(mockedEntityManager);
+
+      when(mockedMikroOrmRegistry.values()).thenReturn([instance(mockedMikroORM)] as unknown as IterableIterator<MikroORM>);
+      when(mockedMikroORM.em).thenReturn(manager);
+      when(mockedMikroOrmContext.run(anything(), anything())).thenReturn();
+
+      // act
+      mikroOrmModule.$alterRunInContext(next)();
+
+      // assert
+      verify(mockedMikroOrmContext.run(deepEqual([manager]), next)).once();
+    });
+  });
+});

package/src/MikroOrmModule.ts

@@ -0,0 +1,104 @@
+import "./services/MikroOrmFactory.js";
+
+import {EventSubscriber, Options} from "@mikro-orm/core";
+import {classOf, isFunction, Store} from "@tsed/core";
+import {
+  AlterRunInContext,
+  Constant,
+  Inject,
+  InjectorService,
+  LocalsContainer,
+  Module,
+  OnDestroy,
+  OnInit,
+  ProviderScope,
+  registerProvider
+} from "@tsed/di";
+
+import {DEFAULT_CONTEXT_NAME, SUBSCRIBER_INJECTION_TYPE} from "./constants.js";
+import {OptimisticLockErrorFilter} from "./filters/OptimisticLockErrorFilter.js";
+import {RetryStrategy} from "./interfaces/RetryStrategy.js";
+import {MikroOrmContext} from "./services/MikroOrmContext.js";
+import {MikroOrmRegistry} from "./services/MikroOrmRegistry.js";
+
+declare global {
+  namespace TsED {
+    interface Configuration {
+      /**
+       * The ORM configuration, entity metadata.
+       * If you omit the `options` parameter, your CLI config will be used.
+       */
+      mikroOrm?: Options[];
+    }
+  }
+}
+
+@Module({
+  responseFilters: [OptimisticLockErrorFilter]
+})
+export class MikroOrmModule implements OnDestroy, OnInit, AlterRunInContext {
+  @Constant("mikroOrm", [])
+  private readonly settings!: Options[];
+
+  @Inject()
+  private readonly registry!: MikroOrmRegistry;
+
+  @Inject()
+  private readonly context!: MikroOrmContext;
+
+  @Inject()
+  private readonly injector!: InjectorService;
+
+  constructor(@Inject(SUBSCRIBER_INJECTION_TYPE) private subscribers: EventSubscriber[]) {}
+
+  public async $onInit(): Promise<void> {
+    const container = new LocalsContainer();
+
+    await Promise.all(
+      this.settings.map((opts) =>
+        this.registry.register({
+          ...opts,
+          subscribers: this.getSubscribers(opts, container)
+        })
+      )
+    );
+  }
+
+  public $onDestroy(): Promise<void> {
+    return this.registry.clear();
+  }
+
+  public $alterRunInContext(next: (...args: unknown[]) => unknown): () => unknown | Promise<() => unknown> {
+    return () => this.createContext(next);
+  }
+
+  private getSubscribers(opts: Pick<Options, "subscribers" | "contextName">, container: LocalsContainer) {
+    return [...this.getUnmanagedSubscribers(opts, container), ...this.getManagedSubscribers(opts.contextName)];
+  }
+
+  private getUnmanagedSubscribers(opts: Pick<Options, "subscribers">, container: LocalsContainer) {
+    return (opts.subscribers ?? []).map((subscriber) => {
+      // Starting from https://github.com/mikro-orm/mikro-orm/issues/4231 mikro-orm
+      // accept also accepts class reference, not just instances.
+      if (isFunction(subscriber)) {
+        return this.injector.invoke(subscriber, {locals: container});
+      }
+
+      return subscriber;
+    });
+  }
+
+  private getManagedSubscribers(contextName: string = DEFAULT_CONTEXT_NAME): EventSubscriber[] {
+    return this.subscribers.filter((instance) => Store.from(classOf(instance)).get(SUBSCRIBER_INJECTION_TYPE)?.contextName === contextName);
+  }
+
+  private createContext(next: (...args: unknown[]) => unknown): unknown {
+    const instances = [...this.registry.values()];
+    const managers = instances.map((orm) => orm.em);
+
+    return this.context.run(managers, next);
+  }
+}
+
+// TODO: the IoC container should provide null or undefined by default until tsedio/tsed#1694 is closed
+registerProvider({token: RetryStrategy, useValue: null});

package/src/constants.ts

@@ -0,0 +1,2 @@
+export const DEFAULT_CONTEXT_NAME = "default";
+export const SUBSCRIBER_INJECTION_TYPE = Symbol("Subscriber");

package/src/decorators/entityManager.spec.ts

@@ -0,0 +1,98 @@
+import {MikroORM} from "@mikro-orm/core";
+import {MongoEntityManager} from "@mikro-orm/mongodb";
+import {DITest, Injectable} from "@tsed/di";
+import {afterEach, beforeEach} from "vitest";
+
+import {MikroOrmRegistry} from "../services/MikroOrmRegistry.js";
+import {Em, EntityManager, entityManager} from "./entityManager.js";
+
+describe("@EntityManager()", () => {
+  beforeEach(() => DITest.create());
+  afterEach(() => DITest.reset());
+
+  describe("decorator", () => {
+    it("should decorate property (without context)", async () => {
+      @Injectable()
+      class UsersService {
+        @Em()
+        public readonly em!: MongoEntityManager;
+      }
+
+      const ormRegistry = {
+        get: vi.fn().mockReturnValue({em: {id: "id"}} as never)
+      };
+
+      const usersService = await DITest.invoke<UsersService>(UsersService, [
+        {
+          token: MikroOrmRegistry,
+          use: ormRegistry
+        }
+      ]);
+      expect(ormRegistry.get).toHaveBeenCalledWith(undefined);
+      expect(usersService.em).toEqual({id: "id"});
+    });
+    it("should decorate property (with context)", async () => {
+      @Injectable()
+      class UsersService {
+        @EntityManager("context")
+        public readonly orm!: MikroORM;
+      }
+
+      const ormRegistry = {
+        get: vi.fn().mockReturnValue({em: {id: "id"}} as never)
+      };
+
+      const usersService = await DITest.invoke<UsersService>(UsersService, [
+        {
+          token: MikroOrmRegistry,
+          use: ormRegistry
+        }
+      ]);
+
+      expect(ormRegistry.get).toHaveBeenCalledWith("context");
+      expect(usersService.orm).toEqual({id: "id"});
+    });
+  });
+
+  describe("prop function", () => {
+    it("should inject property (without context)", async () => {
+      @Injectable()
+      class UsersService {
+        public readonly em = entityManager();
+      }
+
+      const ormRegistry = {
+        get: vi.fn().mockReturnValue({em: {id: "id"}} as never)
+      };
+
+      const usersService = await DITest.invoke<UsersService>(UsersService, [
+        {
+          token: MikroOrmRegistry,
+          use: ormRegistry
+        }
+      ]);
+      expect(ormRegistry.get).toHaveBeenCalledWith(undefined);
+      expect(usersService.em).toEqual({id: "id"});
+    });
+    it("should inject property (with context)", async () => {
+      @Injectable()
+      class UsersService {
+        public readonly em = entityManager("context");
+      }
+
+      const ormRegistry = {
+        get: vi.fn().mockReturnValue({em: {id: "id"}} as never)
+      };
+
+      const usersService = await DITest.invoke<UsersService>(UsersService, [
+        {
+          token: MikroOrmRegistry,
+          use: ormRegistry
+        }
+      ]);
+
+      expect(ormRegistry.get).toHaveBeenCalledWith("context");
+      expect(usersService.em).toEqual({id: "id"});
+    });
+  });
+});

package/src/decorators/entityManager.ts

@@ -0,0 +1,25 @@
+import {Inject} from "@tsed/di";
+
+import {MikroOrmRegistry} from "../services/MikroOrmRegistry.js";
+import {orm} from "./orm.js";
+
+export function entityManager(contextName?: string) {
+  return orm(contextName)?.em;
+}
+
+/**
+ * Get the entity manager for the given context name.
+ * @param {String} contextName
+ * @decorator
+ * @mikroOrm
+ */
+export const EntityManager = (contextName?: string): PropertyDecorator =>
+  Inject(MikroOrmRegistry, {transform: (registry: MikroOrmRegistry) => registry.get(contextName)?.em}) as PropertyDecorator;
+
+/**
+ * Get the entity manager for the given context name.
+ * @param {String} connectionName
+ * @decorator
+ * @mikroOrm
+ */
+export const Em = EntityManager;

package/src/decorators/orm.spec.ts

@@ -0,0 +1,97 @@
+import {MikroORM} from "@mikro-orm/core";
+import {DITest, Injectable} from "@tsed/di";
+import {afterEach, beforeEach} from "vitest";
+
+import {MikroOrmRegistry} from "../services/MikroOrmRegistry.js";
+import {Orm, orm} from "./orm.js";
+
+describe("@Orm()", () => {
+  beforeEach(() => DITest.create());
+  afterEach(() => DITest.reset());
+
+  describe("decorator", () => {
+    it("should decorate property (without context)", async () => {
+      @Injectable()
+      class UsersService {
+        @Orm()
+        public readonly orm!: MikroORM;
+      }
+
+      const ormRegistry = {
+        get: vi.fn().mockReturnValue({id: "id"} as never)
+      };
+
+      const usersService = await DITest.invoke<UsersService>(UsersService, [
+        {
+          token: MikroOrmRegistry,
+          use: ormRegistry
+        }
+      ]);
+      expect(ormRegistry.get).toHaveBeenCalledWith(undefined);
+      expect(usersService.orm).toEqual({id: "id"});
+    });
+    it("should decorate property (with context)", async () => {
+      @Injectable()
+      class UsersService {
+        @Orm("context")
+        public readonly orm!: MikroORM;
+      }
+
+      const ormRegistry = {
+        get: vi.fn().mockReturnValue({id: "id"} as never)
+      };
+
+      const usersService = await DITest.invoke<UsersService>(UsersService, [
+        {
+          token: MikroOrmRegistry,
+          use: ormRegistry
+        }
+      ]);
+
+      expect(ormRegistry.get).toHaveBeenCalledWith("context");
+      expect(usersService.orm).toEqual({id: "id"});
+    });
+  });
+
+  describe("prop function", () => {
+    it("should inject property (without context)", async () => {
+      @Injectable()
+      class UsersService {
+        public readonly orm = orm();
+      }
+
+      const ormRegistry = {
+        get: vi.fn().mockReturnValue({id: "id"} as never)
+      };
+
+      const usersService = await DITest.invoke<UsersService>(UsersService, [
+        {
+          token: MikroOrmRegistry,
+          use: ormRegistry
+        }
+      ]);
+      expect(ormRegistry.get).toHaveBeenCalledWith(undefined);
+      expect(usersService.orm).toEqual({id: "id"});
+    });
+    it("should inject property (with context)", async () => {
+      @Injectable()
+      class UsersService {
+        public readonly orm = orm("context");
+      }
+
+      const ormRegistry = {
+        get: vi.fn().mockReturnValue({id: "id"} as never)
+      };
+
+      const usersService = await DITest.invoke<UsersService>(UsersService, [
+        {
+          token: MikroOrmRegistry,
+          use: ormRegistry
+        }
+      ]);
+
+      expect(ormRegistry.get).toHaveBeenCalledWith("context");
+      expect(usersService.orm).toEqual({id: "id"});
+    });
+  });
+});

package/src/decorators/orm.ts

@@ -0,0 +1,19 @@
+import {MikroORM} from "@mikro-orm/core";
+import {Inject, inject} from "@tsed/di";
+
+import {MikroOrmRegistry} from "../services/MikroOrmRegistry.js";
+
+/**
+ * Get the ORM for the given context name using new inject() function.
+ * @param contextName
+ */
+export function orm(contextName?: string): MikroORM | undefined {
+  return inject(MikroOrmRegistry).get(contextName);
+}
+
+/**
+ * Get the ORM for the given context name.
+ * @param {String} contextName
+ */
+export const Orm = (contextName?: string): PropertyDecorator =>
+  Inject(MikroOrmRegistry, {transform: (registry: MikroOrmRegistry) => registry.get(contextName)}) as PropertyDecorator;

package/src/decorators/subscriber.spec.ts

@@ -0,0 +1,27 @@
+import {EventSubscriber} from "@mikro-orm/core";
+import {Store} from "@tsed/core";
+
+import {DEFAULT_CONTEXT_NAME, SUBSCRIBER_INJECTION_TYPE} from "../constants.js";
+import {Subscriber} from "./subscriber.js";
+
+@Subscriber()
+export class Subscriber1 implements EventSubscriber {}
+
+@Subscriber({contextName: "non-default"})
+export class Subscriber2 implements EventSubscriber {}
+
+describe("@Subscriber", () => {
+  it("should decorate the class", () => {
+    // act
+    const result = Store.from(Subscriber1).get(SUBSCRIBER_INJECTION_TYPE);
+    // assert
+    expect(result).toEqual({contextName: DEFAULT_CONTEXT_NAME});
+  });
+
+  it("should decorate the class tying a context name to it", () => {
+    // act
+    const result = Store.from(Subscriber2).get(SUBSCRIBER_INJECTION_TYPE);
+    // assert
+    expect(result).toEqual({contextName: "non-default"});
+  });
+});

package/src/decorators/subscriber.ts

@@ -0,0 +1,12 @@
+import {StoreSet, useDecorators} from "@tsed/core";
+import {Injectable} from "@tsed/di";
+
+import {DEFAULT_CONTEXT_NAME, SUBSCRIBER_INJECTION_TYPE} from "../constants.js";
+
+/**
+ * Register a new subscriber for the given context name.
+ * @decorator
+ * @mikroOrm
+ */
+export const Subscriber = (options: {contextName: string} = {contextName: DEFAULT_CONTEXT_NAME}) =>
+  useDecorators(Injectable({type: SUBSCRIBER_INJECTION_TYPE}), StoreSet(SUBSCRIBER_INJECTION_TYPE, options));

package/src/decorators/transactional.spec.ts

@@ -0,0 +1,34 @@
+import {Controller, DITest} from "@tsed/di";
+import {Post} from "@tsed/schema";
+import {afterEach, beforeEach} from "vitest";
+
+import {TransactionalInterceptor} from "../interceptors/TransactionalInterceptor.js";
+import {Transactional} from "./transactional.js";
+
+@Controller("/users")
+export class UsersCtrl {
+  @Post("/")
+  @Transactional()
+  create(): any {}
+}
+
+describe("@Transactional", () => {
+  beforeEach(() => DITest.create());
+  afterEach(() => DITest.reset());
+  it("should decorate method", async () => {
+    const interceptor = {
+      intercept: vi.fn().mockResolvedValue({})
+    };
+
+    const usersService = await DITest.invoke<UsersCtrl>(UsersCtrl, [
+      {
+        token: TransactionalInterceptor,
+        use: interceptor
+      }
+    ]);
+
+    const result = await usersService.create();
+
+    expect(result).toEqual({});
+  });
+});

package/src/decorators/transactional.ts

@@ -0,0 +1,10 @@
+import {Intercept} from "@tsed/di";
+
+import {TransactionalInterceptor, TransactionOptions} from "../interceptors/TransactionalInterceptor.js";
+
+/**
+ * Register a new request context for your method and execute it inside the context.
+ * @param {String | TransactionOptions} contextNameOrOptions
+ */
+export const Transactional = (contextNameOrOptions?: string | TransactionOptions): MethodDecorator =>
+  Intercept(TransactionalInterceptor, contextNameOrOptions);

package/src/filters/OptimisticLockErrorFilter.spec.ts

@@ -0,0 +1,33 @@
+import {OptimisticLockError} from "@mikro-orm/core";
+import {PlatformTest} from "@tsed/platform-http/testing";
+
+import {OptimisticLockErrorFilter} from "./OptimisticLockErrorFilter.js";
+
+describe("OptimisticLockErrorFilter", () => {
+  beforeEach(() => PlatformTest.create());
+  afterEach(() => PlatformTest.reset());
+
+  describe("catch", () => {
+    it("should set HTTP status to 409", async () => {
+      const optimisticLockErrorFilter = await PlatformTest.invoke(OptimisticLockErrorFilter);
+
+      // arrange
+      const exception = OptimisticLockError.lockFailed("entity");
+      const context = PlatformTest.createRequestContext();
+
+      vi.spyOn(context.logger, "error").mockReturnThis();
+
+      // act
+      optimisticLockErrorFilter.catch(exception, context);
+
+      expect(context.logger.error).toHaveBeenCalledWith({
+        event: "MIKRO_ORM_OPTIMISTIC_LOCK_ERROR",
+        error_name: exception.name,
+        error_message: exception.message,
+        stack: exception.stack
+      });
+      expect(context.response.getBody()).toEqual("Update refused. The resource has changed on the server. Please try again later");
+      expect(context.response.statusCode).toEqual(409);
+    });
+  });
+});