Inject abstract class in entities using Clean code

[benjibenoit]

Hi,

I'm trying to setup a clean code architecture using Adonisjs6. I'm struggling when I try to inject a Slugify abastract class to my entity.

For exemple, here is my abstract class :

export default abstract class Slugify {
  abstract makeSlug(text: string): string
}

And here my actual entity :

import Slugify from '#domain/contracts/helpers/slugify'

export class Post {
  id?: string
  displayName: string
  slug?: string

  private slugify!: Slugify

  constructor(props: {
    id?: string
    displayName: string
    slug?: string
  }) {
    this.id = props.id
    this.displayName = props.displayName
    this.slug = props.slug
  }

  setSlug() {
    this.slug = this.slugify.makeSlug(this.displayName)
    return this
  }

  setId() {
    this.id = 'id'
    return this
  }
}

The question is : How can I inject Slugify in the Entity directly ? I have a solution by injecting de Slugify in the use-case and pass it in the new Post() but I don't really like this approach.

[thetutlage]

Okay, I have many follow up questions here.

• Are you struggling to find, how to inject a class to the Post constructor with options as well. Meaning, the first argument is an options object and second is some class you want container to automatically inject?
• Since, you cannot instantiate an abstract class directly, are you asking how to inject something else that inherits from the abstract Slugify class.

[benjibenoit]

• Are you struggling to find, how to inject a class to the Post constructor with options as well. Meaning, the first argument is an options object and second is some class you want container to automatically inject?

This could be a solution, but I don't want to pass the instantiation of Slugify via the use case. I don't want this :

@inject()
export class CreatePost implements CreatePostUseCase {
  constructor(
    private postRepository: PostRepository,
    private slugify: Slugify
  ) {}

  async handle(payload: CreatePostDto) {
    const post = new Post(
      {
        displayName: payload.displayName,
      },
      this.slugify
    )

    return this.PostRepository.save(post)
  }
}

But more something like this :

@inject()
export class CreatePost implements CreatePostUseCase {
  constructor(private postRepository: PostRepository) {}

  async handle(payload: CreatePostDto) {
    const post = new Post({
      displayName: payload.displayName,
    })

    post.setSlug().setId()

    return this.PostRepository.save(post)
  }
}

I don't know if what I want is the "right way to do it", so I'm open if you think there's a better way.

• Since, you cannot instantiate an abstract class directly, are you asking how to inject something else that inherits from the abstract Slugify class.

Here's a simple example. Let's say I wanted to test the creation of a post, here's the code I tried:

test.group('Post', () => {
  class FakeSlugify extends Slugify {
    makeSlug(text: string): string {
      return text.toLowerCase().replace(/\s/g, '-')
    }
  }

  test('should generate post correctly', async ({ assert }) => {
    // Arrange
    app.container.bind(Slugify, () => new FakeSlugify())

    const props = {
      displayName: 'Ethereum',
    }

    // Act
    const post = new Post(props).setSlug().setId()

    // Assert
    assert.isDefined(post.slug)
    assert.isDefined(post.id)
    assert.instanceOf(post, Post)
  })
})

[RomainLanz]

Hey @shankiflang! 👋🏻

I am not sure you architectured correctly your dependencies.

Your Post entity should not directly rely on your Slugify service. It should be a stable dependency with no external/side-effect behavior.

Nevertheless, if you want to keep it that way, I would recommend changing how your entity works and not using the constructor to inject its props since it is needed for dependency injection. For example, you could have a static method create instead (and their are many other ways).

interface PostProps {
  id?: string
  displayName: string
  slug?: string
}

@inject()
export default class Post {
  constructor(private slugify: Slugify) {}
  
  static async create(props: PostProps) {
    const post = await app.container.make(Post)

    post.id = props.id
    post.displayName = props.displayName
    post.slug = props.slug
  }
}

@inject()
export class CreatePost implements CreatePostUseCase {
  constructor(private postRepository: PostRepository) {}

  async handle(payload: CreatePostDto) {
    const post = await Post.create({ /* ... */ })
  }

If you want to keep injecting your stuff in your constructor + its props, you need to rely on app.container.make inside your use case.

 @inject()
export class CreatePost implements CreatePostUseCase {
  constructor(private postRepository: PostRepository) {}

  async handle(payload: CreatePostDto) {
    const post = await app.container.make(Post, [{ displayName: 'foo' }])
    
    post.setSlug().setId()
  }
}

and your entity will looks like this:

interface PostProps {
  id?: string
  displayName: string
  slug?: string
}

export class Post {
  constructor(private props: PostProps, private slugify: Slugify) {}
}

Note, since your method makeSlug is not async, I am not even sure why you would need to fake that dependency. It does not seem to have any side effects or external calls.

[benjibenoit]

What you're telling me is that Slugify should be a business object and therefore not have to be injected?
I define it in the business and simply import it in the business entity code ?

[RomainLanz]

Yes, if your Slugify "service" is stable and does not make any external calls or side effects, there is no need to abstract it or inject it via dependency injection. Simply require it and use it as-is.