How to use Subscribers in TypeORM?

In TypeORM, the subscription feature enables listening for changes to database entities. For example, when new data is inserted, updated, or deleted, TypeORM can notify application code to process these events.

Below is a step-by-step guide on how to use the subscription feature in TypeORM:

Define an Entity

First, you need to define an entity, such as a simple User entity:

typescript
import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';

@Entity()
export class User {
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    name: string;

    // ... other properties
}

Listen for Entity Events

TypeORM provides several decorators to listen for different lifecycle events of entities, such as @BeforeInsert, @AfterInsert, @BeforeUpdate, @AfterUpdate, @BeforeRemove, and @AfterRemove.

typescript
@Entity()
export class User {
    // ...

    @AfterInsert()
    afterInsert() {
        console.log(`A new user has been inserted with id: ${this.id}`);
        // You can implement logic here to publish messages to the subscription service
    }

    // ...
}

Use a Subscription Service

Now, you can implement a subscription service using message queue services such as Redis, RabbitMQ, or any other. The key is to publish messages to this service within the entity's event listeners.

For example, if you are using Redis, you can create a Publisher and Subscriber service:

typescript
import { createClient } from 'redis';

const redisPublisher = createClient();
const redisSubscriber = createClient();

redisSubscriber.subscribe('user_notifications');

redisSubscriber.on('message', (channel, message) => {
    console.log(`Received data from ${channel}: ${message}`);
});

@Entity()
export class User {
    // ...

    @AfterInsert()
    afterInsert() {
        const message = `A new user has been inserted with id: ${this.id}`;
        redisPublisher.publish('user_notifications', message);
    }

    // ...
}

In this example, the afterInsert method is triggered after a new user is inserted into the database. It uses the Redis publisher client to send a message to the user_notifications channel, while the Redis subscriber client listens to this channel and processes the messages.

This method allows your application to respond in real-time to database changes, which can be used for triggering business logic, notifying users, or updating caches. However, in production environments, more robust error handling and message queue management are recommended.