Neanderthal Pudding Mix

    nestjs-amqp-with-inject
    TypeScript icon, indicating that this package has built-in type declarations

    0.2.3 • Public • Published

    Awesome Nest Nest Powered

    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

    $ yarn add nestjs-amqp
    $ yarn add -D @types/amqplib

    Basic usage

    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

    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.

    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

    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 {
    }
    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

    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.

    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.

    $ 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:

    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

    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

    Keywords

    Install

    npm i nestjs-amqp-with-inject

    DownloadsWeekly Downloads

    6

    Version

    0.2.3

    License

    MIT

    Unpacked Size

    222 kB

    Total Files

    34

    Last publish

    Collaborators

    • aquaminer