Simplest way to implement dependancy injection

[RoyalVICTOR-pro]

After a lot of research and problems, I recently managed to implement dependency injection in an AdonisJS 5 project. I did this on a simple user creation feature.

In summary, in my n-tier architecture, I have a UserRepository that takes care of creating the user in the database.
My UserRepository is injected into an AuthService that will take care of the business logic.
My AuthService is injected into an AuthController that takes care of validating the elements retrieved in the request.

My AuthController, after the checks, calls the injected AuthService, which performs the business actions, and then calls the injected UserRepository for database creation.

I would like to know if there is a better, cleaner, or simpler way (because I find this to be quite heavy for what it does, and I am afraid of the complexity of the code when there will be many features). I am specifically referring to the part in AppProvider about dependency injection.

Here is the code I have implemented (I only give you what is useful):

start/routes.ts

import Route from '@ioc:Adonis/Core/Route'

Route.post('/register', 'AuthController.register').as('register')

app/Controllers/Http/AuthController.ts

import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
import AuthServiceContract from 'App/Services/ServicesContracts/AuthServiceContract'
import { UserCreateDTO } from 'App/DataAccessLayer/DTO/UserCreateDTO'
import AuthentificationMode from 'App/Enum/AuthentificationMode'
import CreateUserValidator from 'App/Validators/CreateUserValidator'
import { inject } from '@adonisjs/core/build/standalone'

const acceptLanguage = require('accept-language-parser')

@inject()
export class AuthController {
  constructor(private authService: AuthServiceContract) {}

  public async register({ request, response }: HttpContextContract) {
    try {
      const data = await request.validate(CreateUserValidator)

      const acceptLangHeader = request.header('Accept-Language')
      const languages = acceptLanguage.parse(acceptLangHeader)

      const userData: UserCreateDTO = {
        email: data.email,
        password: data.password,
        user_language: languages[0],
        internal_or_sso: AuthentificationMode.INTERNAL,
      }

      const user = await this.authService.createUserAccount(userData)
      return response.created(user) // 201 CREATED
    } catch (error) {
      console.log('error :>> ', error)
      return response.status(400).json({ errors: error.messages })
    }
  }
}

app/Services/AuthService.ts

import { inject } from '@adonisjs/fold'
import { UserCreateDTO } from '@DTO/UserCreateDTO'
import UserContract from 'App/DataAccessLayer/DALContracts/UserContract'
import Config from '@ioc:Adonis/Core/Config'
import AuthServiceContract from 'App/Services/ServicesContracts/AuthServiceContract'

@inject()
export class AuthService implements AuthServiceContract {
  constructor(private userRepository: UserContract) {}

  public async createUserAccount(data: UserCreateDTO) {
    if (!data.user_language) data.user_language = Config.get('custom.DEFAULT_LANGUAGE')
    return this.userRepository.createUser(data)
  }
}

app/DataAccessLayer/Repositories/UserRepository.ts

import User from 'App/Models/User'
import { UserCreateDTO } from '@DTO/UserCreateDTO'
import UserContract from '@DALContracts/UserContract'

export class UserRepository implements UserContract {
  public async createUser(data: UserCreateDTO): Promise<User> {
    const user = new User()
    user.email = data.email
    user.password = data.password
    user.user_language = data.user_language
    user.internal_or_sso = data.internal_or_sso
    await user.save()
    return user
  }
}

providers/AppProvider.ts

import type { ApplicationContract } from '@ioc:Adonis/Core/Application'

export default class AppProvider {
  constructor(protected app: ApplicationContract) {}

  public async register() {
    await this.setupDependancyInjectionBindings()
  }

// ... 

  private async setupDependancyInjectionBindings() {
    const { UserRepository } = await import('App/DataAccessLayer/Repositories/UserRepository')
    const { AuthService } = await import('App/Services/AuthService')
    const { AuthController } = await import('App/Controllers/Http/AuthController')

    this.app.container.singleton(
      'App/DataAccessLayer/DALContracts/UserContract',
      () => new UserRepository()
    )

    this.app.container.singleton('App/Services/AuthService', () => {
      const userRepository = this.app.container.use('App/DataAccessLayer/DALContracts/UserContract')
      return new AuthService(userRepository)
    })

    this.app.container.singleton('App/Controllers/Http/AuthController', () => {
      const service = this.app.container.use('App/Services/AuthService')
      return new AuthController(service)
    })
  }
}

Thank you for your advices !

[juniorschroder]

Hi @RoyalVICTOR-pro!

I'm working on a project with a similar structure, and I am applying a very close solution.

In my case, I have:
Controller > Service > Repository

On repositories, I've created a base abstract class called RepositoryBase that implements a contract called IRepositoryBase.
So have created other repos like UserRepository extends RepositoryBase and implement IUserRepository.

On services, a similar thing, for sample UserService implementing a contract called IUserService. User service class annotated with @Inject (adonis fold) and in the constructor are injected the IUserRepository contract:

constructor(private userRepository: IUserRepository) {}

In UserController annotated with @Inject, are injected IUserService contract:

constructor(private userService: IUserService) {}

Finally in AppProvider:

• I have created 2 private methods:

private async registerRepositories(){
  const UserRepository = await import('App/Repositories/UserRepository') // this will import the type UserRepository
  this.app.container.singleton('App/Contracts/Repositories/IUserRepository', () => UserRepository) // this will inject the concert implementation class in any place that uses the contract
}

// and

private async registerServices(){
  const UserService = await import('App/Services/UserService') // this will import the type UserService
  this.app.container.singleton('App/Contracts/Services/IUserService', () => UserService) // this will inject the concert implementation class in any place that uses the contract
}

And, on method register, I have call these private methods:

public async register () {
    // Register your own bindings
    await this.registerRepositories()
    await this.registerServices()
  }

And that's it, the dependency injection will replace my contracts injection on constructors by a concrete class that I defined on AppProvider

[RoyalVICTOR-pro]

Thank you for your response. I've made some progress on my project in the meantime, and I have a behavior that I can't explain:

I used the same Controller < Service < Repository organization for managing one of my entities: professions. I have a Repository that allows CRUD operations on professions, which is injected into a Service that is injected into a controller. I haven't put anything in AppProvider, and everything works perfectly. In essence, I only had a lot of difficulties implementing this for users; for the rest, it's very smooth.

Here's an example:

start/routes.ts

  // PROFESSIONS
  Route.get('/professions', 'ProfessionsController.getAllProfessions')
    .as('getAllProfessions')
    .middleware('auth')
  Route.get('/professions/:id', 'ProfessionsController.getProfessionById')
    .as('getProfessionById')
    .middleware('auth')
  Route.post('/professions', 'ProfessionsController.createProfession')
    .as('createProfession')
    .middleware(['auth', `role:${[Role.ADMIN]}`])
  Route.put('/professions/:id', 'ProfessionsController.updateProfession')
    .as('updateProfession')
    .middleware(['auth', `role:${[Role.ADMIN]}`])
  Route.delete('/professions/:id', 'ProfessionsController.deleteProfession')
    .as('deleteProfession')
    .middleware(['auth', `role:${[Role.ADMIN]}`])

app/Controllers/Http/ProfessionsController.ts

import { inject } from '@adonisjs/core/build/standalone'
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
import { ProfessionCreateOrUpdateDTO } from 'App/DataAccessLayer/DTO/ProfessionCreateOrUpdateDTO'
import { ProfessionService } from 'App/Services/ProfessionService'
import ProfessionCreateValidator from 'App/Validators/ProfessionCreateValidator'
import ProfessionUpdateValidator from 'App/Validators/ProfessionUpdateValidator'

@inject()
export default class ProfessionsController {
  private professionService: ProfessionService
  constructor(professionService: ProfessionService) {
    this.professionService = professionService
  }

  public async getAllProfessions({ response }: HttpContextContract) {
    const professions = await this.professionService.listProfessions()
    return response.ok(professions)
  }

  public async getProfessionById({ response, params }: HttpContextContract) {
    const profession = await this.professionService.getProfessionById(params.id)
    return response.ok(profession)
  }

  public async createProfession({ request, response }: HttpContextContract) {
    const data = await request.validate(ProfessionCreateValidator)

    const newProfession: ProfessionCreateOrUpdateDTO = {
      name_fr: data.name_fr,
      is_enabled: data.is_enabled,
    }

    const profession = await this.professionService.createProfession(
      newProfession,
      data.picto_file,
      data.image_file
    )
    return response.created(profession)
  }

  public async updateProfession({ request, response, params }: HttpContextContract) {
    const data = await request.validate(ProfessionUpdateValidator)
    const newProfession = {
      name_fr: data.name_fr,
      is_enabled: data.is_enabled,
    }

    const profession = await this.professionService.updateProfessionById(
      params.id,
      newProfession,
      data.picto_file,
      data.image_file
    )
    return response.ok(profession)
  }

  public async deleteProfession({ response, params }: HttpContextContract) {
    await this.professionService.deleteProfession(params.id)
    return response.noContent()
  }
}

app/Services/ProfessionService.ts

import { ProfessionCreateOrUpdateDTO } from 'App/DataAccessLayer/DTO/ProfessionCreateOrUpdateDTO'
import { inject } from '@adonisjs/core/build/standalone'
import ProfessionServiceInterface from 'App/Services/Interfaces/ProfessionServiceInterface'
import { ProfessionRepository } from 'App/DataAccessLayer/Repositories/ProfessionRepository'
import { MultipartFileContract } from '@ioc:Adonis/Core/BodyParser'
import UploadService from 'App/Services/UploadService'

@inject()
export class ProfessionService implements ProfessionServiceInterface {
  private professionRepository: ProfessionRepository
  private readonly pictoPath = './professions/pictos/'
  private readonly imagePath = './professions/images/'

  constructor(professionRepository: ProfessionRepository) {
    this.professionRepository = professionRepository
  }

  public async listProfessions() {
    return await this.professionRepository.listProfessions()
  }

  public async getProfessionById(id: number) {
    return await this.professionRepository.getProfessionById(id)
  }

  public async createProfession(
    data: ProfessionCreateOrUpdateDTO,
    pictoFile: MultipartFileContract | null = null,
    imageFile: MultipartFileContract | null = null
  ) {
    if (pictoFile) {
      data.picto_file = await UploadService.uploadFileTo(pictoFile, this.pictoPath, data.name_fr)
    }

    if (imageFile) {
      data.image_file = await UploadService.uploadFileTo(imageFile, this.imagePath, data.name_fr)
    }
    return await this.professionRepository.createProfession(data)
  }

  public async updateProfessionById(
    idToUpdate: number,
    data: ProfessionCreateOrUpdateDTO,
    pictoFile: MultipartFileContract | null = null,
    imageFile: MultipartFileContract | null = null
  ) {
    if (pictoFile || imageFile) {
      const oldProfession = await this.professionRepository.getProfessionById(idToUpdate)
      if (pictoFile) {
        if (oldProfession.picto_file) {
          await UploadService.deleteFile(oldProfession.picto_file)
        }
        data.picto_file = await UploadService.uploadFileTo(pictoFile, this.pictoPath, data.name_fr)
      }
      if (imageFile) {
        if (oldProfession.image_file) {
          await UploadService.deleteFile(oldProfession.image_file)
        }
        data.image_file = await UploadService.uploadFileTo(imageFile, this.imagePath, data.name_fr)
      }
    }
    return await this.professionRepository.updateProfessionById(idToUpdate, data)
  }

  public async deleteProfession(idToDelete: number) {
    const professionToDelete = await this.professionRepository.getProfessionById(idToDelete)
    if (professionToDelete.picto_file) {
      await UploadService.deleteFile(professionToDelete.picto_file)
    }

    if (professionToDelete.image_file) {
      await UploadService.deleteFile(professionToDelete.image_file)
    }
    return await this.professionRepository.deleteProfession(idToDelete)
  }
}

app/DataAccessLayer/Repositories/ProfessionRepository.ts

import Profession from 'App/Models/Profession'
import { ProfessionCreateOrUpdateDTO } from 'App/DataAccessLayer/DTO/ProfessionCreateOrUpdateDTO'
import ProfessionRepositoryInterface from 'App/DataAccessLayer/Interfaces/ProfessionRepositoryInterface'
import { inject } from '@adonisjs/core/build/standalone'

@inject()
export class ProfessionRepository implements ProfessionRepositoryInterface {
  public async listProfessions(): Promise<Profession[]> {
    const professions = await Profession.all()
    return professions
  }

  public async getProfessionById(id: number): Promise<Profession> {
    const profession = await Profession.findOrFail(id)
    return profession
  }

  public async createProfession(data: ProfessionCreateOrUpdateDTO): Promise<Profession> {
    const profession = new Profession()
    profession.name_fr = data.name_fr
    if (data.picto_file) profession.picto_file = data.picto_file
    if (data.image_file) profession.image_file = data.image_file
    if (data.is_enabled) profession.is_enabled = data.is_enabled
    await profession.save()
    return profession
  }

  public async updateProfessionById(
    idToUpdate: number,
    data: ProfessionCreateOrUpdateDTO
  ): Promise<Profession> {
    const profession = await Profession.findOrFail(idToUpdate)
    profession.name_fr = data.name_fr
    if (data.picto_file) profession.picto_file = data.picto_file
    if (data.image_file) profession.image_file = data.image_file
    if (data.is_enabled) profession.is_enabled = data.is_enabled
    await profession.save()
    return profession
  }

  public async deleteProfession(id: number): Promise<boolean> {
    const profession = await Profession.findOrFail(id)
    await profession.delete()
    return true
  }
}

Nothing has changed in AppProvider.ts.
Why does it work without any issues while, for users, I had to find a very specific way to modify AppProvider for it to work?

[juniorschroder]

Can you share the AppProvider code?

[RoyalVICTOR-pro]

While checking again, I realized that I had made a lot of changes to AppProvider.ts.

import type { ApplicationContract } from '@ioc:Adonis/Core/Application'

export default class AppProvider {
  constructor(protected app: ApplicationContract) {}

  public async register() {
    // Register your own bindings
    const { default: AuthController } = await import('../app/Controllers/Http/AuthController')
    this.app.container.make(AuthController)
  }

  public async boot() {
    // IoC container is ready
  }

  public async ready() {
    // App is ready
  }

  public async shutdown() {
    // Cleanup, since app is going down
  }
}

Out of curiosity, I wanted to remove what was in register, and everything continued to work normally. I don't know how I managed to do it, but I was convinced that it was indispensable, when in fact it wasn't. I must have modified other things that had an impact on it.

import type { ApplicationContract } from '@ioc:Adonis/Core/Application'

export default class AppProvider {
  constructor(protected app: ApplicationContract) {}

  public async register() {
    // Register your own bindings
  }

  public async boot() {
    // IoC container is ready
  }

  public async ready() {
    // App is ready
  }

  public async shutdown() {
    // Cleanup, since app is going down
  }
}

Therefore, my question no longer makes any sense. :-)

[MetaSeth]

Hello everyone,

I've been following this discussion here and wanted to share my recent experience with dependency injection in AdonisJS, specifically when injecting a custom UserRepository.

I encountered two primary errors:

• "Cannot inject "{Object Constructor}" to "UserService" at position "1""
• "this.userRepository.create is not a function"

My breakthrough came when I used the @inject() decorator to explicitly specify the dependency:

UserService Injection:

import UserRepository from 'App/Repositories/Interfaces/UserRepository/UserRepository';
@inject([UserRepository])
export default class UserService {
  constructor(protected userRepository: UserRepository) {}
}

Binding in Provider:

public async register() {
  this.app.container.singleton('App/Repositories/Interfaces/UserRepository/UserRepository', () => new FirebaseUserRepository())
}

For controllers like UsersController, direct injection of UserService simplified things:

import UserService from 'App/Services/UserService'
@inject()
export default class UsersController {
  constructor(protected userService: UserService) {}

I used an abstract class instead of an interface for UserRepository, as interfaces do not exist in JavaScript and are removed during transpilation:

export default abstract class UserRepository {
    abstract find(id: string): Promise<User | null>
    abstract create(userData: Partial<User>): Promise<User>
    abstract update(id: string, userData: Partial<User>): Promise<User | null>
    abstract delete(id: string): Promise<void>
}

---

Additionally, I have an idea that might further refine the implementation, though I'm still exploring its feasibility. I believe creating a contract to expose the dependency could streamline the process even more. This approach would involve defining a clear and explicit interface for our dependencies, potentially making the code cleaner and more maintainable.

declare module '@ioc:App/Repositories/Interfaces/UserRepository/UserRepository' {
  import UserRepository from "App/Repositories/Interfaces/UserRepository/UserRepository";
  export default UserRepository
}

I'm currently testing this approach and found a video that demonstrates the use of modules in a similar context, which could be quite enlightening:. This video provides practical insights into how such an implementation could be structured and integrated.

While I'm still validating this concept in AdonisJS, I think it shows promise for further improving the architecture. I’d love to hear any insights or experiences from the community regarding the use of contracts in such scenarios

I'm sharing this in the hope that it might help others facing similar challenges. I'm also interested in hearing any thoughts or further insights on using contracts in AdonisJS.

[MetaSeth]

For the record, I would like to clarify the architectural decisions made for my application, particularly in terms of database abstraction and dependency injection.

The initial goal was to design the application to be database agnostic. I initially implemented this using the repository pattern, which is typically effective for isolating the data layer. However, upon further reflection, I realized that this approach was somewhat overkill for the specific requirements of my project.

In the context of a hexagonal architecture, where complete isolation of data is crucial, the repository pattern is indeed more pertinent. But for my application, such complete data isolation turned out to be unnecessary.

Therefore, I shifted the database abstraction from the repository level to the service level by creating an abstract class UserService and implementing a FirebaseUserService. This change has simplified the architecture by removing the superfluous repository layer while maintaining the necessary flexibility for database agnosticism.

It has aligned more closely with the needs and scale of my project, rendering the code simpler and more maintainable.

[smlntsv]

Hey there, when working on this, I usually go with something like:

UsersController

import { inject } from '@adonisjs/fold'
import SingletonService from 'App/Services/SingletonService'
import MultitonService from 'App/Services/MultitonService'

@inject()
class UsersController {
	protected singletonService = SingletonService

	constructor(protected multitonService: MultitonService) {}
}

SingletonService

class SingletonService {
// ... 
}

export default new SingletonService()

MultitonService

class MultitonService {
// ... 
}

export default MultitonService