https://github.com/igorkamyshev/nest-telegram

NestJS module for creating Telegram bots by telegraf.js framework
https://github.com/igorkamyshev/nest-telegram

nestjs nodejs telegraf-framework telegram telegram-bot

Last synced: 9 days ago
JSON representation

NestJS module for creating Telegram bots by telegraf.js framework

• Host: GitHub
• URL: https://github.com/igorkamyshev/nest-telegram
• Owner: igorkamyshev
• License: mit
• Created: 2019-02-27T19:38:24.000Z (over 5 years ago)
• Default Branch: master
• Last Pushed: 2021-05-08T05:32:39.000Z (over 3 years ago)
• Last Synced: 2024-10-19T19:30:06.463Z (18 days ago)
• Topics: nestjs, nodejs, telegraf-framework, telegram, telegram-bot
• Language: JavaScript
• Homepage:
• Size: 40.7 MB
• Stars: 36
• Watchers: 3
• Forks: 4
• Open Issues: 4
• Metadata Files:
  • Readme: README.md
  • Changelog: CHANGELOG.md
  • License: LICENSE

Awesome Lists containing this project

README

        
# nest-telegram

[![Scripts sets up by @solid-soda/scripts v2.1.0](https://img.shields.io/static/v1?label=@solid-soda/scripts&message=2.1.0&color=75ddf4)](https://github.com/solid-soda/scripts)

Integrate [telegraf.js](https://telegraf.js.org/) to [NestJS](https://nestjs.com/) application.

> Warning! Package under development, please waiting for v1 release.

## Instalation

`yarn add nest-telegram`

## Setup

### Add TelegramModule to your app

```ts

import { TelegramModule, TelegramModuleOptionsFactory } from 'nest-telegram'

// In real app, please, don't store token in source code

class TelegramOptionsFactory implements TelegramModuleOptionsFactory {

  createOptions(): TelegramModuleOptions {

    return {

      token: 'TelegramToken#1213',

      sitePublicUrl: 'https://my-site.com',

    }

  }

}

@Module({

  imports: [

    TelegramModule.forRootAsync({,

      imports: [/* all modules for initialize TelegramOptionsFactory*/]

      useClass: TelegramOptionsFactory,

    }),

    UtilsModule,

  ],

})

export class MyModule implements NestModule {

  constructor(

    private readonly moduleRef: ModuleRef,

    private readonly telegramBot: TelegramBot,

  ) {}

  onModuleInit() {

    const isDev = process.env.NODE_ENV === 'development'

    // in dev mode, we can't use webhook, polling starts automatically

    this.telegramBot.init(this.moduleRef, isDev);

  }

  // ...

}

```

### Add custom middleware to your app

```ts

import { TelegramBot } from 'nest-telegram';

import { NestFactory } from '@nestjs/core';

import { AppModule } from '@app/app.module';

async function bootstrap() {

  const isDev = process.env.NODE_ENV === 'development';

  const app = await NestFactory.create(AppModule);

  const bot = app.get(TelegramBot);

  if (!isDev) {

    // in production mode, please use webhook with middleware

    app.use(bot.getMiddleware('hook-path'));

  }

  await app.listen(3000);

}

bootstrap();

```

## Usage

Now, you can decorate any method with `TelegramActionHandler`.

Example:

```ts

import { Injectable } from '@nestjs/common';

import { Context, PipeContext, TelegramActionHandler } from 'nest-telegram';

@Injectable()

export class HelpActions {

  @TelegramActionHandler({ onStart: true })

  async start(ctx: Context) {

    await ctx.reply('Hello!');

  }

}

```

Available actions for decorator:

- `onStart` {boolean}, it triggers on `/start` command.

- `command` {string}, it triggers on any command, e.g. — `@TelegramActionHandler({ command: '/help' })`.

- `message` {string|RegExp}, it triggers on text message matching RegExp or string.

- `location` {boolean}, it triggers on location send.

Also, you can write Transformators for context (like Pipes in NestJS). Example:

```ts

import { Injectable } from '@nestjs/common'

import { ContextTransformer, Context } from 'nest-telegram'

@Injectable()

class CurrentSender implements ContextTransformer {

  async transform(ctx: Context) {

    const user = // get user from DB

    return {

      login: user.login,

      isManager: user.isManager,

    }

  }

}

@Injectable()

export class SomethingActions {

  @TelegramActionHandler({ command: '/say' })

  async say(

    ctx: Context,

    // apply this transformer like this

    @PipeContext(CurrentSender) user: TokenPayloadModel,

  ) {

    const { login } = user

    // now you can use `login`

    await ctx.reply(`Hello, ${login}`)

  }

}

```

Also, you can write `Catchers` for exceptions (like Filters in NestJS). Example:

```js

import { TelegramErrorHandler, TelegramCatch, Context } from 'nest-telegram'

@TelegramCatch(MyExecption)

export class MyCatcher

  implements TelegramErrorHandler {

  public async catch(ctx: Context, exception: MyExecption) {

    await ctx.reply(exception.message)

  }

}

```

Stay tuned, stable release is coming. 🤓