Allow injectable entity subscribers

I’m submitting a…

[ ] Regression 
[ ] Bug report
[x] Feature request
[ ] Documentation issue or request
[ ] Support request => Please do not submit support request here, instead post your question on Stack Overflow.

Current behavior

Currently only the default subscription mechanism of typeorm is usable. While this is a good thing, it does not allow to inject other services into the subscriber instance.

Expected behavior

By defining a new service class decorator, like @EntitySubscriber and the technique mentioned at https://github.com/typeorm/typeorm/issues/2630#issuecomment-447211212 we could implement a very easy way to implement rich subscribers which can participate in the nest injection container.

Minimal reproduction of the problem with instructions

I made a local solution myself which is straight forward, but works as expected:

// subscriber.decorator.ts
import { SetMetadata } from '@nestjs/common';

export const IS_SUBSCRIBER = 'IS_SUBSCRIBER';
export const Subscriber = () => SetMetadata(IS_SUBSCRIBER, true);

// app.module.ts (trimmed), guess this would be TypeORMModule.forRoot then

export class AppModule implements OnModuleInit {
  constructor(
    private readonly connection: Connection,
    private readonly container: ModulesContainer,
    private readonly reflector: Reflector,
  ) {}

  onModuleInit() {
    // find providers marked as entity subscribers...
    const subscribers = [...this.container.values()]
      .filter(({ providers }) => providers.size > 0)
      .reduce(
        (matching, { providers }) => [
          ...matching,
          ...[...providers.values()]
            .filter(
              provider =>
                provider.instance &&
                this.reflector.get(
                  IS_SUBSCRIBER,
                  provider.instance.constructor,
                ) === true,
            )
            .map(provider => provider.instance),
        ],
        [],
      );

    // ...and hand those instances over to typeorm
    subscribers.forEach(subscriber => {
      this.connection.subscribers.push(subscriber);
    });
  }
}

I'm pretty sure this kind of feature should be easily transported into the typeorm nest package.

What is the motivation / use case for changing the behavior?

Its allows nestjs dependency injection inside of entity subscribers. For example:

// user-subscriber.service.ts
@Subscriber()
@Injectable()
export class UserSubscriberService implements EntitySubscriberInterface {
  constructor(private readonly invitation: InvitationService) {}

  listenTo() {
    return User;
  }

  async beforeInsert(event: InsertEvent<User>) {
    const email = event.entity.email;
    const user = await event.manager.getRepository(User).findOne({
      where: {
        email,
      },
    });

    if (user !== undefined) {
      throw new BadRequestException(
        `User with email '${email}' already exists`,
      );
    }

    event.entity.status = UserStatus.UNREGISTERED;
    event.entity.password = null;
  }

  async afterInsert(event: InsertEvent<User>) {
    this.invitation.invite(event.entity);
  }
}

This provider is added to the module as usual. It actually works almost the same as websocket services.

Environment

Nest version: 6.1.1
Nest/TypeORM version: 6.0.0



Others:

[leesiongchan]

Is there any chance to inject REQUEST object as well? I am struggling on implementing a BlameableColumn, anyone has any thoughts?

[LittleTheFu]

I ran into the same problem.