Why are interfaces defined in root?

[sobafuchs]

Hey I'm a fan of this structure and find it greatly simplifies projects, especially when starting out, while remaining useful for a large number of use cases. I'm curious why you advocate defining an interface for the service in the root as opposed to in subpackages that implement the interface? I was under the impression that in Go interfaces are best defined next to where they are consumed and used. This would also mean that if you don't need 1 or 2 functions from the root interface, you would need to still add those functions to the struct passed in to implement it in a subpackage with a dummy implementation or something like panic("not implemented").

Would it be equally feasible to not define the interfaces in the root and define smaller interfaces in subpackages? Or would you advise against that for smaller projects? For instance, instead of using a UserService interface you might have something smaller in a subpackage like:

type UserGetter interface {
    GetUser(ctx context.Context, userID uuid.UUID) (*User, error)
}

[benbjohnson]

I'm curious why you advocate defining an interface for the service in the root as opposed to in subpackages that implement the interface?

I add the interfaces to the root so they can be shared by the subpackages. If the interface lived in the subpackage then you can get in situations where you have circular dependencies. However, the root doesn't import subpackages so it doesn't suffer from the circular dependency issue.

Another option is to not use interfaces at all. For example, if you just have one database implementation (e.g. sqlite) and no mocks, you can have one of the subpackages depend on the implementation directly. For example, the Server in the http package could directly import DB from your sqlite subpackage. As long as you're structuring your code as layers then you should only have one direction of dependencies and you won't have circular dependency issues.

Would it be equally feasible to not define the interfaces in the root and define smaller interfaces in subpackages?

You can define smaller interfaces but I just don't personally like doing it. I find it's a lot of extra types without a lot of value.

[sobafuchs]

That makes sense. Do you include dummy implementations for any methods not needed in subpackages so that they meet the shared interface?

[benbjohnson]

Yeah, sometimes I'll have methods that return a "not implemented" error. If I'm implementing a lot of those methods, though, then it's a sign that I should make a smaller interface.