d99b9d1d6b
### Overview
This PR introduces significant enhancements to the MessageQueue module
by integrating `@Processor`, `@Process`, and `@InjectMessageQueue`
decorators. These changes streamline the process of defining and
managing queue processors and job handlers, and also allow for
request-scoped handlers, improving compatibility with services that rely
on scoped providers like TwentyORM repositories.
### Key Features
1. **Decorator-based Job Handling**: Use `@Processor` and `@Process`
decorators to define job handlers declaratively.
2. **Request Scope Support**: Job handlers can be scoped per request,
enhancing integration with request-scoped services.
### Usage
#### Defining Processors and Job Handlers
The `@Processor` decorator is used to define a class that processes jobs
for a specific queue. The `@Process` decorator is applied to methods
within this class to define specific job handlers.
##### Example 1: Specific Job Handlers
```typescript
import { Processor, Process, InjectMessageQueue } from 'src/engine/integrations/message-queue';
@Processor('taskQueue')
export class TaskProcessor {
@Process('taskA')
async handleTaskA(job: { id: string, data: any }) {
console.log(`Handling task A with data:`, job.data);
// Logic for task A
}
@Process('taskB')
async handleTaskB(job: { id: string, data: any }) {
console.log(`Handling task B with data:`, job.data);
// Logic for task B
}
}
```
In the example above, `TaskProcessor` is responsible for processing jobs
in the `taskQueue`. The `handleTaskA` method will only be called for
jobs with the name `taskA`, while `handleTaskB` will be called for
`taskB` jobs.
##### Example 2: General Job Handler
```typescript
import { Processor, Process, InjectMessageQueue } from 'src/engine/integrations/message-queue';
@Processor('generalQueue')
export class GeneralProcessor {
@Process()
async handleAnyJob(job: { id: string, name: string, data: any }) {
console.log(`Handling job ${job.name} with data:`, job.data);
// Logic for any job
}
}
```
In this example, `GeneralProcessor` handles all jobs in the
`generalQueue`, regardless of the job name. The `handleAnyJob` method
will be invoked for every job added to the `generalQueue`.
#### Adding Jobs to a Queue
You can use the `@InjectMessageQueue` decorator to inject a queue into a
service and add jobs to it.
##### Example:
```typescript
import { Injectable } from '@nestjs/common';
import { InjectMessageQueue, MessageQueue } from 'src/engine/integrations/message-queue';
@Injectable()
export class TaskService {
constructor(
@InjectMessageQueue('taskQueue') private readonly taskQueue: MessageQueue,
) {}
async addTaskA(data: any) {
await this.taskQueue.add('taskA', data);
}
async addTaskB(data: any) {
await this.taskQueue.add('taskB', data);
}
}
```
In this example, `TaskService` adds jobs to the `taskQueue`. The
`addTaskA` and `addTaskB` methods add jobs named `taskA` and `taskB`,
respectively, to the queue.
#### Using Scoped Job Handlers
To utilize request-scoped job handlers, specify the scope in the
`@Processor` decorator. This is particularly useful for services that
use scoped repositories like those in TwentyORM.
##### Example:
```typescript
import { Processor, Process, InjectMessageQueue, Scope } from 'src/engine/integrations/message-queue';
@Processor({ name: 'scopedQueue', scope: Scope.REQUEST })
export class ScopedTaskProcessor {
@Process('scopedTask')
async handleScopedTask(job: { id: string, data: any }) {
console.log(`Handling scoped task with data:`, job.data);
// Logic for scoped task, which might use request-scoped services
}
}
```
Here, the `ScopedTaskProcessor` is associated with `scopedQueue` and
operates with request scope. This setup is essential when the job
handler relies on services that need to be instantiated per request,
such as scoped repositories.
### Migration Notes
- **Decorators**: Refactor job handlers to use `@Processor` and
`@Process` decorators.
- **Request Scope**: Utilize the scope option in `@Processor` if your
job handlers depend on request-scoped services.
Fix #5628
---------
Co-authored-by: Weiko <corentin@twenty.com>
68 lines
3.4 KiB
TypeScript
68 lines
3.4 KiB
TypeScript
import { Module } from '@nestjs/common';
|
|
import { ModuleRef } from '@nestjs/core';
|
|
|
|
import { DataSeedDemoWorkspaceModule } from 'src/database/commands/data-seed-demo-workspace/data-seed-demo-workspace.module';
|
|
import { DataSeedDemoWorkspaceJob } from 'src/database/commands/data-seed-demo-workspace/jobs/data-seed-demo-workspace.job';
|
|
import { TypeORMModule } from 'src/database/typeorm/typeorm.module';
|
|
import { WorkspaceQueryRunnerJobModule } from 'src/engine/api/graphql/workspace-query-runner/jobs/workspace-query-runner-job.module';
|
|
import { BillingModule } from 'src/engine/core-modules/billing/billing.module';
|
|
import { UpdateSubscriptionJob } from 'src/engine/core-modules/billing/jobs/update-subscription.job';
|
|
import { StripeModule } from 'src/engine/core-modules/billing/stripe/stripe.module';
|
|
import { UserWorkspaceModule } from 'src/engine/core-modules/user-workspace/user-workspace.module';
|
|
import { UserModule } from 'src/engine/core-modules/user/user.module';
|
|
import { HandleWorkspaceMemberDeletedJob } from 'src/engine/core-modules/workspace/handle-workspace-member-deleted.job';
|
|
import { EmailSenderJob } from 'src/engine/integrations/email/email-sender.job';
|
|
import { EmailModule } from 'src/engine/integrations/email/email.module';
|
|
import { DataSourceModule } from 'src/engine/metadata-modules/data-source/data-source.module';
|
|
import { ObjectMetadataModule } from 'src/engine/metadata-modules/object-metadata/object-metadata.module';
|
|
import { CleanInactiveWorkspaceJob } from 'src/engine/workspace-manager/workspace-cleaner/crons/clean-inactive-workspace.job';
|
|
import { CalendarEventParticipantModule } from 'src/modules/calendar/services/calendar-event-participant/calendar-event-participant.module';
|
|
import { TimelineActivityModule } from 'src/modules/timeline/timeline-activity.module';
|
|
import { WorkspaceModule } from 'src/engine/core-modules/workspace/workspace.module';
|
|
import { CalendarMessagingParticipantJobModule } from 'src/modules/calendar-messaging-participant/jobs/calendar-messaging-participant-job.module';
|
|
import { CalendarCronJobModule } from 'src/modules/calendar/crons/jobs/calendar-cron-job.module';
|
|
import { CalendarJobModule } from 'src/modules/calendar/jobs/calendar-job.module';
|
|
import { AutoCompaniesAndContactsCreationJobModule } from 'src/modules/connected-account/auto-companies-and-contacts-creation/jobs/auto-companies-and-contacts-creation-job.module';
|
|
import { MessagingModule } from 'src/modules/messaging/messaging.module';
|
|
import { TimelineJobModule } from 'src/modules/timeline/jobs/timeline-job.module';
|
|
import { CalendarModule } from 'src/modules/calendar/calendar.module';
|
|
|
|
@Module({
|
|
imports: [
|
|
DataSourceModule,
|
|
ObjectMetadataModule,
|
|
TypeORMModule,
|
|
UserModule,
|
|
EmailModule,
|
|
DataSeedDemoWorkspaceModule,
|
|
BillingModule,
|
|
UserWorkspaceModule,
|
|
WorkspaceModule,
|
|
MessagingModule,
|
|
CalendarModule,
|
|
CalendarEventParticipantModule,
|
|
TimelineActivityModule,
|
|
StripeModule,
|
|
WorkspaceQueryRunnerJobModule,
|
|
CalendarMessagingParticipantJobModule,
|
|
CalendarCronJobModule,
|
|
CalendarJobModule,
|
|
AutoCompaniesAndContactsCreationJobModule,
|
|
TimelineJobModule,
|
|
],
|
|
providers: [
|
|
CleanInactiveWorkspaceJob,
|
|
EmailSenderJob,
|
|
DataSeedDemoWorkspaceJob,
|
|
UpdateSubscriptionJob,
|
|
HandleWorkspaceMemberDeletedJob,
|
|
],
|
|
})
|
|
export class JobsModule {
|
|
static moduleRef: ModuleRef;
|
|
|
|
constructor(private moduleRef: ModuleRef) {
|
|
JobsModule.moduleRef = this.moduleRef;
|
|
}
|
|
}
|