Best practice for directory structure of a larger application?

@cvh23 You really need to learn lots of Phoenix stuff. Many of your questions are from someone who never tried them - especially Repo naming which is included in every new phoenix project (mix phx.new generator). Please read official Phoenix documentation. After your first Phoenix app if your code would be really big you may consider refactoring your app into umbrella app.

Some useful resources:

https://elixir-lang.org/getting-started/mix-otp/dependencies-and-umbrella-projects.html

Thanks @Eiji for the links. I’ve already tried a small project and some of the generators, but I am not sure how obligatory or recommended these settings are.

I’ve also read about umbrella apps, but I thought this approach maybe “too big” for an application which just consists of some parts/modules.

This is a template for phoenix projects. Nobody forces you to use it, but it’s a useful resource for generic use cases. It’s made by Phoenix core developers, so those are recommended. Hover using them because they were in some template isn’t enough. For example by default every phoenix project have PostgreSQL database. Depends on your project requirements some part of such code may change, but it’s mostly something like database configuration (like credentials) rather than whole application.

For new Elixir/Phoenix developers such template is more than enough as Phoenix is feature-rich framework (which in fact works like library). In order to develop applications well you should know concept like what are contexts and why we write them. All of this you can find in official documentation, ElixirConf videos and many, many more learning resources. Make sure you look also at Learning Resources category.

One question first, is this for fun or profit?

Fun
Just experiment, take a look at the source code from changelog.com and hex.pm (search on github) and build what you think works for you and post it here for others to look at and help you with. It’s very easy to refactor in Elixir and you’ll learn a ton in the process.

Profit
Just build it with the default settings and ship it. No matter how you structure your app, if you don’t ship it it does not matter.

I’ve worked on a number of big Phoenix/Elixir applications. I led the development of a big one (200k+ lines) over 4 years. We did it both ways, the way phoenix boilerplate does it for about 2 years, and then we reorganized it. The main thing we learned was to organize your project around features, not functionality. Why? Because which is more common? working on all your tests at the same time? or all your controllers, views, or graphql code at the same time? Or, working on a particular feature? Sometimes you do refactor something across an entire category of functionality, but WAY more often you or someone maintaining your code is working within a feature/resource/group of resources. So here’s how we did it, and we never ever looked back. It it insanely amazing and other people who have worked on our project have commented on how much easier it is to work on a feature and find all the relevant modules they need.

lib/
  invoices/
    controller_tests/
      index_test.exs
      create_test.exs
      update_test.exs
      delete_test.exs
    controller.ex
    view.ex
    view_test.exs
    schema.ex
    schema_test.exs
    jobs/
     send_invoices.ex
     send_invoices_test.exs
  payments/
    controller_tests/…
    schema.ex
    …
  customers/
    …

We tore a page from golang and we put the tests right by the modules they test. This is so great. Why do we do all the work to build a mirror of our project dir in the test? Tests are code, they are part of our app. This also makes modules that are not tested stand out like a sore thumb. Need to update a module and the test? They are right by each other!

Anyway, I was stuck in analysis paralysis about this, asked the elixir community in slack if I should do this, they all advised against this, but this project has had this structure for 2 years now and I will be doing all projects like this in all languages/frameworks from now on. It is nonsense to organize your project by functionality (controller/view/etc) rather than feature/type/resource. I don’t know rails why ever sent us down that route.

Lastly, when you want to split it up into umbrella apps or microservices, this directly structure is exactly how you’ll want t do it, you’ll just copy the directory wholesale into another app/service/etc. This organization very very much helps facilitate a domain driven design mindset.

I highly highly recommend this

At the moment fun, but with the perspective of profit Just looking how to realize projects with Elixir, which I have already done with TypeScript. For future projects I want to change my backend stack.

Thanks for the hints. Refactoring looks indeed a lot easier than in other ecosystems.

Thank you, looks interesting. In general I am also in favor of splitting apps into feature parts and not technical parts. Of course sometimes it makes sense the other way around.

In that case just start hacking

Not sure if you know but module names have nothing to do with the location of the file on disk. So even if your file is in shop/lib/shop/payments/paypal.ex you can still name the module MyApp.Paypal

Interesting structure, not sure if I would like it but if it works for you, perfect!

How would you find files in your editor though, would that not be challenging with those filenames?

not at all! its awesome. In sublime or vscode I just do invoi/sche to get to invoice schema, etc. so its just the opposite of what you’d normally do mod/inv to fuzzy search for models/invoice.ex. Then, in vscode I do command + E and it shows that file in the sidebar and all the other relevant files I’m going to be working on are right there (tests, graphql resolvers, etc)