https://hexdocs.pm/lua/Lua.html

When you define a relationship like `has_many :representatives`, Ash does’t create `representative_id` on the destination resource, we only validate that it exists and meets some criteria.

No resource ever modifies another resource, so you have to define the id on the other side using `belongs_to` which modifies it's own resource only adding the `respresentative_id` attribute with this

`belongs_to :representative, Representative`

If you need custom field names, you can override them:

`has_many :representatives, MyApp.Representative, destination_attribute: :custom_reference_id`

The docs explain more:

https://hexdocs.pm/ash/relationships.html#belongs-to

https://hexdocs.pm/ash/relationships.html#has-many

It's funny that you say it sounds like low-code, because we've often said it's low-code tool but for software engineers. So when you inevitably hit the wall of a proprietary no-code/low-code platform, Ash can let you extend the framework or just solve the problem by writing functions as you like.

Once you appreciate the Ash way though, be warned! It's very hard to go back...

The gap it solves is having an opinionated, UI agnostic way of building your application layer. Phoenix has very limited opinions on how to write your application, and the team has stated that "Phoenix is NOT your application". Ash basically is your app, and Phoenix is the web frontend.

https://elixirforum.com/t/what-do-they-actually-mean-when-th...

That's a great suggestion, the one-liner is cute but isn't quite as readable and explanatory as your multi-line version.

Not to mention, the one-liner doesn't show off the true power of igniter -- composability and additive AST patching codegen.

Thanks!

We'll definitely be looking at how to make it even better, because the Igniter tasks are intended to make things easier and should help explain how to get started effectively and be productive as quickly as possible.

Have you got any thoughts on how we could improve this? Perhaps a suggestion of running the generate domain or resource mix task next once the install is done?

https://alembic.com.au/case-studies/from-paper-to-precision-...

Quite a few users have commented that the free support in Discord is incredibly fast and comprehensive. Zach responds unreasonably quickly and often you've run into a bug or unclear documentation that is fixed virtually instantly.

Like Zach mentioned, please help us understand where your challenges are and we'll do our best to help out. We can only improve things for everyone if we know where to focus our attention.

At the risk of being called a shill, if you need more reliable paid support then please reach out, we have a service for this which teams find really valuable. https://ash.alembic.com.au/ash-premium-support

Just click on the hard to spot "Already have an app?" link and it will show you the individual mix tasks you can run yourself.

I would argue that this is the preferred way to see what's happening and avoid running a remote shell script for the security conscious. ;)

Also the generated project name is completely random and intended to be humourous.

The Ash DSLs get full autocomplete from your LSP and so make sure this is setup. The new Elixir LSP called Expert - https://expert-lsp.org/ is coming soon and aims to make this a much smoother process.

The documentation has been overhauled multiple times and is constantly being improved. If you encounter issues please raise an issue or a PR, knowing where users get confused is important for improving the docs for everyone.

One issue that new users often run into is that Ash is spread over multiple packages for different extensions and Hex didn't support multiple package search, which is being currently improved. So double check you're searching in the right package. Dash can help with this offline if you have it.

Tidewave (https://tidewave.ai/) MCP can help with doc search too if you are using a LLM/AI assisted editor like Cursor, Windsurf or Claude Code, etc. We also have some Ash specific announcements this week along these lines... ;)

For example AshAdmin (https://github.com/ash-project/ash_admin) takes these ideas further and generates a full super admin interface for you. It's a bit clunky and you should ultimately write your own admin, but it lets you focus on the important parts first.

For anyone else who hasn't seen it Iommi's motivation and docs are here:

Motivation https://kodare.net/2024/09/11/why-we-wrote-a-new-form-librar...

Iommi Forms https://docs.iommi.rocks/forms.html

Iommi Github repo https://github.com/iommirocks/iommi

https://hexdocs.pm/ash/Mix.Tasks.Ash.Gen.Resource.html will generate a new resource for example (and the Domain if it doesn't already exist).

Check the side bar for other generator mix tasks.

Thanks for the feedback, we'll try and make this DX clearer!

The context here is that Alembic builds custom business applications where these problems have not typically been solved before. We want to spend most of our development time on the core business problem not rebuilding things like Content management systems or Ecommerce shopfronts.

Thanks!

https://hexdocs.pm/ash_graphql/handle-errors.html

Ash models nouns and relationships like ActiveRecord does, but it also models Domains (think DDD bounded contexts) and Resources with the verbs or "actions" of your system.

It also lets you configure generated APIs and your data layer (eg Postgres) so it doesn't stop at just how an ORM may typically model your data.

https://alembic.com.au/blog/essence-of-ash-framework

Would love any feedback as to whether this helps allay your fear and dread!

Spark is the DSL library that takes a DSL definition as Elixir structs and builds the DSL for you which in turn takes the written DSL and converts to a standard and simple data structure. So there are fewer macros than you might expect. Ash extensions just introspect that generated data structure with ordinary Elixir code.

The main macro in Ash core itself is the `expr` macro which enables portable declarative predicates which can be used in data layers like AshPostgres for filtering in SQL queries. If your data layer is simple like ETS or a CSV then it runs as Elixir code.