Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/nestjsx/nestjs-amqp
Amqp connections for nestjs :love_letter:
https://github.com/nestjsx/nestjs-amqp
amqp connection manager module nestjs typescript
Last synced: about 1 month ago
JSON representation
Amqp connections for nestjs :love_letter:
- Host: GitHub
- URL: https://github.com/nestjsx/nestjs-amqp
- Owner: nestjsx
- License: mit
- Created: 2018-07-03T09:38:24.000Z (over 6 years ago)
- Default Branch: master
- Last Pushed: 2023-01-16T09:09:34.000Z (almost 2 years ago)
- Last Synced: 2024-05-19T14:34:15.332Z (6 months ago)
- Topics: amqp, connection, manager, module, nestjs, typescript
- Language: TypeScript
- Homepage:
- Size: 821 KB
- Stars: 189
- Watchers: 5
- Forks: 24
- Open Issues: 31
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
- awesome-nestjs - Nestjs AMQP - amqp 连接管理器 (资源 / 集成)
README
Nestjs Amqp
An AMQP connection service for NestJS.
Using the AMQPlib for node package.
This package was intented to be used in execution content and provides a basic AMQPlib connection via the providers to allow developers to develop their amqp queue consumers and publishers. For microservice transport; check out the docs for rabbitMQ.
## Install
```bash
$ yarn add nestjs-amqp
$ yarn add -D @types/amqplib
```## Basic usage
```ts
import {Module} from '@nestjs/common';
import {AmqpModule} from 'nestjs-amqp';@Module({
imports: [AmqpModule.forRoot({
name: 'rabbitmq',
hostname: 'localhost',
port: 5672,
username: 'test',
password: 'test',
})],
})
export default class AppModule {}```
## Advanced usage
### Usage with nestjs-config```ts
import {Module} from '@nestjs/common';
import {AmqpModule} from 'nestjs-amqp';
import {ConfigModule, ConfigService} from 'nestjs-config';
import * as path from 'path';@Module({
imports: [
ConfigModule.load(path.resolve(__dirname, 'config', '**/*.ts')),
AmqpModule.forRootAsync({
useFactory: (config: ConfigService) => config.get('amqp'),
inject: [ConfigService],
}),
],
})
export default class AppModule {}//src/config/amqp.ts
export default {
name: 'rabbitmq',
hostname: process.env.AMQP_HOST,
port: process.env.AMQP_PORT,
username: process.env.USERNAME,
password: process.env.PASSWORD,
}
```
> Unfortunately multiple connections are unavailable when using the `forRootAsync` method.### Usage in custom provider
It is possible to inject the AmqpConnection in a factory of a custom provider if one needs such capability.```ts
import { Connection as AmqpConnection } from 'amqplib';
import {ConfigService} from 'nestjs-config';
import {createConnectionToken} from 'nestjs-amqp/utils';export const queueServiceProvider = {
provider: 'QueueService',
useFactory: (amqp: AmqpConnection, configService: ConfigService) => new QueueService(amqp, config.get('queue')),
inject: [createConnectionToken('default'), ConfigService],
}
```It's also possible to give your connections names, if you have done so then use the name of your connection instead of ``default``.
### Connection Decorators```ts
import {Module} from '@nestjs/common';
import {AmqpModule} from 'nestjs-amqp';@Module({
imports: [AmqpModule.forRoot([
{
hostname: 'test:test@localhost',
},
{
username: 'test',
password: 'test',
hostname: 'localhost',
port: 5672,
protocol: 'amqps',
name: 'test',
}
])],
})
export default class ExecutionModule {
}
``````ts
import {Injectable} from '@nestjs/common';
import {InjectAmqpConnection} from 'nestjs-amqp';
import {Connection} from 'amqplib';@Injectable()
export default class TestService {
constructor(
@InjectAmqpConnection('test')
private readonly connectionTest: Connection, //gets connection with name 'test' defined in module
@InjectAmqpConnection(0)
private readonly connection0: Connection, //gets first defined connection without a name
) {}
}
```
> Use InjectAmqpConnection without a parameter for default connection### Example publish
```ts
import {Injectable, Logger} from '@nestjs/common';
import {InjectAmqpConnection} from 'nestjs-amqp';
import {Connection} from 'amqplib';@Injectable()
export default class TestProvider {
constructor(
@InjectAmqpConnection()
private readonly amqp: Connection,
) {}
async publish(message: string) {
await this.amqp.createChannel((err, channel) => {
if (err != null) {
Logger.alert(err, 'TestProvider');
}
channel.assertQueue('test_queue_name');
channel.sendToQueue('test_queue_name', message);
});
}
}
```
More information and examples about amqplib can be found [here](https://www.npmjs.com/package/amqplib).## Available Options
Name | For | Default
--- | --- | ---
hostname | The host url for the connection | `localhost`
port | The port of the amqp host | `5672`
name | The name of the connection | `default` or the array key index `[0]`
retrys | The amount of retry attempts before surrender | 3
retryDelay | The amount of milliseconds to wait before attempting retry | 3000
protocol | The protocol for the connection | `amqp`
username | The username for the connection |
password | The password for the connection |
locale | The desired locale for error messages | `en_US`
frameMax | The size in bytes of the maximum frame allowed over the connection | 0
heartbeat | The period of the connection heartbeat in seconds | 0
vhost | What VHost shall be used | `/`## Testing this package
In order to test first you need to start the rabbitmq container. We've provided a `docker-compose` file to make this easier.
```bash
$ docker-compose up -d
$ yarn test
```
> Navigate to localhost:15672 for rabbitmq manager, username and password are both `guest`> If you're using docker-machine or a VM then change the env for `HOST` in the `.env` file or create one using the provided `.env.dist` file.
## Future implementation
> WARNING: The below examples have not been implemented
So far this package manages multiple AMQP connections using the nestjs container and injects them into other providers.
Alternatively I'd like to implement something like this:```ts
import {Injectable} from '@nestjs/common';
import {
AmqpConnection,
Consume,
Publish,
Message,
} from 'nestjs-amqp';@Injectable()
@AmqpConnection()
export default class MyAmqpService {
@Consume("queue_name", {
noAck: true,
})
async listen(@Message message) {
console.log('Message received', message);
//send a message back
this.publish();
}@Publish("queue_name")
async publish() {
return "Send this to 'queue queue_name'";
}
}
```Then using executable context
```ts
import { NestFactory } from '@nestjs/core';
import QueueModule, { MyAmqpService } from './queue';async function bootstrap() {
const app = await NestFactory.create(QueueModule);
const event = app.get(MyAmqpService);await event.listen();
}
bootstrap();process.stdin.resume();
```Or something similar to the above is what I'd like to implement