Send email with Loopback 4

i am kinda new to Loopback and Typescript so I have no idea how to implement this. I am trying to call Nodemailer directly, but so far I keep getting an error.

My Mailer service:

import { SentMessageInfo } from 'nodemailer';
import Mail = require('nodemailer/lib/mailer');
const nodemailer = require("nodemailer");

export class MailerService {
  async sendMail(mailOptions: Mail.Options): Promise<SentMessageInfo> {
    const transporter = nodemailer.createTransport({
      host: 'smtp.ethereal.email',
      port: 587,
      auth: {
        user: 'albert.grimes@ethereal.email',
        pass: 'qN85JT6SneBA9S5dhy'
      }
    });
    return await transporter.sendMail(mailOptions);
  }
}

My Mailer controller:

import { Request, RestBindings, get, ResponseObject } from 

'@loopback/rest';
import { inject } from '@loopback/context';
import { MailerService } from "../services";

export class MailController {
  constructor(
    @inject ???
    public mailerService: MailerService
  ) { }

  @get('/mail/acceptation')
  async sendEmail(email: string): Promise<any> {
    let info = await this.mailerService.sendMail({
      to: `${email}`,
      subject: 'testmail',
      html: '<p>Hallo</p>'
    })
    return info;
  }
}

I keep getting this as a error:

Unhandled error in GET /mail/acceptation: 500 Error: Cannot resolve injected arguments for MailController.prototype.sendEmail[0]: The arguments[0] is not decorated for dependency injection, but a value is not supplied

So what I am gathering from this is that I should inject a value in my controller, but I have no idea what.

email.service.ts

import Utils from '../utils';
import * as nodemailer from 'nodemailer';
import { IEmail } from '../type-schema';

export interface EmailManager<T = Object> {
  sendMail(mailObj: IEmail): Promise<T>;
}

export class EmailService {
  constructor() { }

  async sendMail(mailObj: IEmail): Promise<object> {
    const configOption = Utils.getSiteOptions();

    let transporter = nodemailer.createTransport(configOption.email);

    return await transporter.sendMail(mailObj);
  }
}

define your smtp option in your config file like following:-

"email": {
    "type": "smtp",
    "host": "smtp.gmail.com",
    "secure": true,
    "port": 465,
    "tls": {
      "rejectUnauthorized": false
    },
    "auth": {
      "user": "example@gmail.com",
      "pass": "sample-password"
    }
  }

in controller send mail like following way:-

import { EmailManager } from '../services/email.service';
import { EmailManagerBindings } from '../keys';

// inject in constructor
@inject(EmailManagerBindings.SEND_MAIL) public emailManager: EmailManager,

// call service method like following way
const mailOptions = {
          from: configOption.fromMail,
          to: getUser.email,
          subject: template.subject,
          html: Utils.filterEmailContent(template.message, msgOpt)
        };

        await this.emailManager.sendMail(mailOptions).then(function (res: any) {
          return { message: `Successfully sent reset mail to ${getUser.email}` };
        }).catch(function (err: any) {
          throw new HttpErrors.UnprocessableEntity(`Error in sending E-mail to ${getUser.email}`);
        });

Simple Way:- If you don't want to make a service function just import nodemailer in your controller and send mail, but its not a good approach.

import * as nodemailer from 'nodemailer';

let transporter = nodemailer.createTransport({
    "type": "smtp",
    "host": "smtp.gmail.com",
    "secure": true,
    "port": 465,
    "tls": {
      "rejectUnauthorized": false
    },
    "auth": {
      "user": "example@gmail.com",
      "pass": "sample-password"
    }
  });

 return await transporter.sendMail({
          from: "sender-email",
          to: "receiver-email",
          subject: "email-subject",
          html: "message body"
        });

Update:-

keys.ts

import { BindingKey } from '@loopback/context';    
import { EmailManager } from './services/email.service';    
import { Member } from './models';
import { Credentials } from './type-schema';

export namespace PasswordHasherBindings {
  export const PASSWORD_HASHER = BindingKey.create<PasswordHasher>('services.hasher');
  export const ROUNDS = BindingKey.create<number>('services.hasher.round');
}

export namespace UserServiceBindings {
  export const USER_SERVICE = BindingKey.create<UserService<Member, Credentials>>('services.user.service');
}

export namespace TokenManagerBindings {
  export const TOKEN_HANDLER = BindingKey.create<TokenManager>('services.token.handler');
}

export namespace EmailManagerBindings {
  export const SEND_MAIL = BindingKey.create<EmailManager>('services.email.send');
}

aplication.ts

import { BootMixin } from '@loopback/boot';
import { ApplicationConfig } from '@loopback/core';
import { RepositoryMixin } from '@loopback/repository';
import { RestApplication } from '@loopback/rest';
import { ServiceMixin } from '@loopback/service-proxy';
import * as path from 'path';
import { MySequence } from './sequence';

import { TokenServiceBindings, UserServiceBindings, TokenServiceConstants, } from './keys';
import { JWTService, TokenGenerator } from './services/jwt-service';
import { EmailService } from './services/email.service';
import { MyUserService } from './services/user-service';
import { AuthenticationComponent, registerAuthenticationStrategy, } from '@loopback/authentication';
import { PasswordHasherBindings, TokenManagerBindings, EmailManagerBindings } from './keys';
import { BcryptHasher } from './services/hash.password.bcryptjs';
import { JWTAuthenticationStrategy } from './authentication-strategies/jwt-strategy';

export class AmpleServerApplication extends BootMixin(ServiceMixin(RepositoryMixin(RestApplication))) {
  constructor(options: ApplicationConfig = {}) {
    super(options);

    this.setUpBindings();

    // Bind authentication component related elements
    this.component(AuthenticationComponent);

    registerAuthenticationStrategy(this, JWTAuthenticationStrategy);

    // Set up the custom sequence
    this.sequence(MySequence);

    // Set up default home page
    this.static('/', path.join(__dirname, '../public'));

    this.projectRoot = __dirname;

    this.bootOptions = {
      controllers: {
        dirs: ['controllers'],
        extensions: ['.controller.js'],
        nested: true,
      },
    };
  }

  setUpBindings(): void {
    this.bind(TokenServiceBindings.TOKEN_SECRET).to(TokenServiceConstants.TOKEN_SECRET_VALUE);
    this.bind(TokenServiceBindings.TOKEN_EXPIRES_IN).to(TokenServiceConstants.TOKEN_EXPIRES_IN_VALUE);

    this.bind(UserServiceBindings.USER_SERVICE).toClass(MyUserService);

    this.bind(EmailManagerBindings.SEND_MAIL).toClass(EmailService);
  }
}