E_IOC_LOOKUP_FAILED: Cannot resolve "Adonis/Lucid/Orm" namespace from the IoC Container

[alancwoo]

Adonis Core 5.4.2
Adonis Lucid 16.3.2

I think I am running into this problem due to a misunderstanding of how to properly structure my app.

I have to query a remote API to fetch recent posts. If a post does not exist my Adonis app db, I will query the API and store it.

So I thought I should make a service to handle making remote API calls and have a function like:

app/Services/ApiService.ts

import Post from 'App/Models/Post'

...

public async getRecentPosts (numPosts) {
  const latestPost = getLatestPostId() // returns latest post id increment from API
  let i = 0
  while (i < numPosts) {
    let post = Post.findBy(latestPost - i)
    // if post doesn't exist in db, fetch with axios...
    i++
  }
}

This service is registered in my AppProvider.ts with this.app.container.singleton('ExampleNamespace/ApiService', () => new ApiService()) and I've tried register, boot and ready but the server always dies with E_IOC_LOOKUP_FAILED: Cannot resolve "Adonis/Lucid/Orm" namespace from the IoC Container on app/Models/Post.ts: import { BaseModel ... } from '@ioc:Adonis/Lucid/Orm'

I'm sorry if I've fundamentally misunderstood where this logic should go (and what I should be using services for), is it a matter of restructuring so this logic sits somewhere else in the app? I was following this tutorial: https://medium.com/@shemsiu/ioc-container-and-dependency-injection-in-adonis-v5-216774c2a476

Endless thanks in advance for any help and for this incredible project.

--

Edit: Moving getRecentPosts() into the controller itself does solve this, sensibly keeping the ApiService more focused on the actual calls to the API, so I have two questions:

1. Is this the right use case for a service, to provide this kind of reusable functionality throughout the app?
2. If I need to use this getRecentPosts function in a few different controllers, however, where should it then go?

[tomgobich]

Yes, services are a great way to simplify controller logic and a great place to house methods that need to be used across multiple controllers. I typically don't register an IOC namespace for my services, I just import them in the controllers I need them.

There are a few ways you can do this. The way you're going about it is great if you need the same instance of the service class to be used for every single request your server receives. If that's not a requirement for you below are some alternatives.

Using Static Methods

// app/Services/PostService.ts

export default class PostService {
  public static async getRecentPosts(numPosts) {
    // fetch posts ...
  }
}

// app/Controllers/Http/PostsController.ts

import PostService from 'App/Services/PostService'

export default class PostsController {
  public async index({ response }: HttpContextContract) {
    const posts = await PostService.getRecentPosts()
  }
}

Note the service method is defined as static, so a new instance of PostService doesn't need to be created in order to be used.

Using AdonisJS Fold to Inject the Service Into the Controller Class

// app/Services/PostService.ts

export default class PostService {
  public async getRecentPosts(numPosts) {
    // fetch posts ...
  }
}

// app/Controllers/Http/PostsController.ts

import { inject } from '@adonisjs/fold';
import PostService from 'App/Services/PostService'

@inject()
export default class PostsController {
  constructor(public postService: PostService) {}

  public async index({ response }: HttpContextContract) {
    const posts = await this.postService.getRecentPosts()
  }
}

Here @inject() will take the defined parameters on the class constructor and inject an instance into the controller when a new instance is created. In it's basic form it's essentially shorthand for the below, which you could alternatively do:

// app/Controllers/Http/PostsController.ts

import PostService from 'App/Services/PostService'

export default class PostsController {
  public postService: PostService

  constructor() {
    this.postService = new PostService()
  }

  public async index({ response }: HttpContextContract) {
    const posts = await this.postService.getRecentPosts()
  }
}

I'd recommend one of the above usages as they're simpler and easier to understand. However, if you do need one single instance of your service class for all requests in your application, then you'll want to move imports that use the IOC container inside the class instance. The register method inside the provider is where you can register IOC bindings (which would include your service). The IOC container itself isn't ready to be used until the boot method of the provider is called. This is where your error is coming from. The file gets imported, but the IOC container is still registering its bindings.

To fix this, instead of importing your Post model at the top level, import it within the class itself. I haven't tried this, you might need to do this within a constructor, but something like this should work:

export default class PostService {
  public postModel = require('App/Models/Post') // import Post Model inside class

  public async getRecentPosts(numPosts) {
    // fetch posts ...
  }
}

[alancwoo]

Wow thank you so much @tomgobich for such an incredibly detailed response, this is incredibly helpful and indeed helps clarify a lot. You are right that the static methods are probably the best way to go, and there is no need for a singleton, so this works great.

The only issue remaining is trying to access the Post model inside PostService. Trying to call any methods on the model, for example let post = postModel.find(id) results in this.postModel.find is not a function

Many thanks again, I can't tell you how amazing it is to receive such a thoughtful response.

[tomgobich]

Anytime!!

If you're going with the static method service approach, then you aren't going to have an instance of your service so only static items are going to be accessible. With the static method approach you'd use your model like so:

// app/Services/PostService.ts

import Post from 'App/Models/Post'

export default class PostService {
  public static async getRecentPosts(numPosts) {
    return Post.query().limit(numPosts)
  }
}

// app/Controllers/Http/PostsController.ts

import PostService from 'App/Services/PostService'

export default class PostsController {
  public async index({}: HttpContextContract) {
    const posts = await PostService.getRecentPosts(10)
  }
}

Since you aren't importing anything when your AdonisJS application is in the register boot lifecycle in your provider with this approach you're a-okay to use top-level imports like the above.

Hope this helps!

[alancwoo]

Ah this clarified everything, thanks again so much @tomgobich - everything works perfectly now 👍

[tomgobich]

Awesome! Glad to hear that! 🙂