Chapter 2: Extending Reasources with Business Logic (33)
    Reasources and Relationships
        We have created a single reasource now lets create an album reasource. 
            mix ash.gen.resource Tunez.Music.Album --extend postgres

        We now have some new files, we want to add these things to the DB:
            Artist, Album name, Year released, Image

        Let's head over to lib/tunez/music/album.ex
            attributes do
                uuid_primary_key :id
                attribute :name, :string do
                    allow_nil? false
                end
                attribute :year_released, :integer do
                    allow_nil? false
                end
                attribute :cover_image_url, :string
                create_timestamp :inserted_at
                update_timestamp :updated_at
            end

        As you might notice you don't see a artist that will be a relationship.

        "Defining Relationships"
            There are different types of relationship 
            has_many: One has Many (Posts)
            belongs_to: One belongs to One (Post)
            has_one: One has One (User Profile)
            many_to_many: Many to Many (tags)

            Not we can head to lib/tunez/music/artist.ex and add in the relationship
                relationships do
                    belongs_to :artist, Tunez.Music.Artist
                end

                relationships do
                    has_many :albums, Tunez.Music.Album do
                end
            
            Now that we have that setup we can generate and set the migration
                mix ash.codegen create_album

            We now have the new DB and the relationship between the artist and albums. We still need to index from the foriegn key. to do that we need to head back to album.ex and set the index?: to true
                postgres do
                # ...
                references do
                    reference :artist, index?: true➤
                end

            This changed the DB so we can now run the code.gen again to create the snapshot and the migrations.
                mix ash.codegen create_album
                mix ash.migrate
            

        "Album Actions"
            As with before we need to set all the actions for the albums. What is great is that we can make sure that we utilize ASH to make sure that you only pull the albums that are related to the artist.
                actions do
                    defaults([:read, :destroy])

                    create :create do
                    accept([:name, :year_released, :cover_image_url, :artist_id])
                    end

                    update :update do
                    accept([:name, :year_released, :cover_image_url])
                    end
                end

            Now we can add in the new resource to the Module Music. Same as before we can add in the album now.
                resource Tunez.Music.Album do
                    define :create_album, action: :create
                    define :get_album_by_id, action: :read, get_by: :id
                    define :update_album, action: :update
                    define :destroy_album, action: :destroy
                end

            They gave us some sample items and albums we want to now run the mix to add them in and then mix seed to get the rest of the albums after uncommenting the right line in the mix.exs.
                mix run priv/repo/seeds/02-albums.exs
                mix seed
                # There might be some issues here with older data being left behind ignore it for now.

        "Creating and Updating Albums"
            Now let's make sure that we have the ability to add and update albums within the site. 
            lib/tunez_web/albums/form_live.ex
                form = Tunez.Music.form_to_create_album()

                # Then we need to add in the validate
                def handle_event("validate", %{"form" => form_data}, socket) do
                    socket =
                    update(socket, :form, fn form ->
                        AshPhoenix.Form.validate(form, form_data)
                    end)
                    {:noreply, socket}
                end

                # Then a save event
                def handle_event("save", %{"form" => form_data}, socket) do
                    case AshPhoenix.Form.submit(socket.assigns.form, params: form_data) do
                    {:ok, _album} ->
                        socket =
                        socket
                        |> put_flash(:info, "Album created successfully")
                        |> push_navigate(to: ~p"/")

                        {:noreply, socket}

                    {:error, form} ->
                        socket =
                        socket
                        |> put_flash(:error, "Could not create album")
                        |> assign(:form, form)

                        {:noreply, socket}
                    end
                end

                # Last a new mount for when we are updating an event
                def mount(%{"id" => album_id}, _session, socket) do
                    album = Tunez.Music.get_album_by_id!(album_id)
                    form = Tunez.Music.form_to_update_album(album)

                    socket =
                    socket
                    |> assign(:form, to_form(form))
                    |> assign(:page_title, "Update Album")

                    {:ok, socket}
                end

            "Using Artist Data on the Album Form"
                Okay so now we need to be sure that we have the right artist for the album that we are creating. We know the ID of the artist so we can now access that and then make sure the we add that to the new form.
                    artist = Tunez.Music.get_artist_by_id!(album.artists_id)
                Then we need to add in the value of the artist to the form on the page
                    <.input name="artist_id" label="Artist" value={@artist.name} disabled />

                    # Then we need to update the new mount to be sure that we have the artist in the socket and then change the first mount to be sure that we have it in there as well
                    |> assign(:artist, artist)
                    mount(%{"artist_id" => artist_id})

                Now let's figure out how to add in the artist to the save but not the update. We can do this but setting the way in which you even get the form done. You can set the forms in the domain. We will use the form to do this.
                    forms do
                        form :create_album, args: [:artist_id]
                    end

    Loading Related Reasource Data
        Now we can make sure that we have the right list of albums within the ShowLive for the artist. We should head to lib/tunez_web/live/artists/show_live.ex then we can agument the artist to also get the album information as well.
            artist = Tunez.Music.get_artist_by_id!(artist_id, load: [:albums])
            # Now change the assign to remove the album line and the general album as well.
            # change the render as well as we no longer have the value for the :album
        
        We have the first index set now we should be able to set the form live for the album as well. lib/tunez_web/live/albums/form_live.ex and now you can set the artist with the load as they are related.
            album = Tunez.Music.get_album_by_id!(album_id, load: [:artist])
            ...
            |> assign(:artist, album.artist)
        
        To go one step further you can even make sure that things are ordered withing the artist album. lib/tunez/music/artist.ex

    Structured Data with Validations and Identities
        Consistant Data with Validations
            We are going to make sure that when we have a year_released its a valid year and even a valid image URL if we have one, we can even be sure that we are making sure we are not adding the same album twice. Let's head over to lib/music/album.ex
                validations do
                    validate(
                    numericality(:year_released,
                        greater_than: 1950,
                        less_than_or_equal_to: &__MODULE__.next_year/0
                    ),
                    where: [present(:year_released)],
                    message: "must be between 1950 and next year"
                    )

                    validate(
                    match(
                        :cover_image_url,
                        ~r"^(https://|/images/).+(\.png|\.jpg)$"
                    ),
                    where: [changing(:cover_image_url)],
                    message: "must start with https:// or /images/"
                    )
                end

        Unique Data with Identities
            Now lets make sure that we have the right validations for the picture URL. This requires a different set of rules to run. This will create an index in the 2 db so that it can check for those values within the DB so we will need to run a command ofter we do that.
                identities do
                    identity(:unique_album_names_per_artist, [:artist_id, :name],
                    message: "already exists for this artist"
                    )
                end

                # Then
                mix ash.codegen add_unique_album_names_per_artist
                mix ash.migrate
            To see what changed head to priv/repo/migrations/[timestamp]_add_unique_album_names_per_artist.exs

    Deleting All of the Things
        Deleting Album Data
            lib/tunez_web/live/artists/show_live.ex
                def handle_event("destroy-album", %{"id" => album_id}, socket) do
                    case Tunez.Music.destroy_album(album_id) do
                    :ok ->
                        socket =
                        socket
                        |> update(:artist, fn artist ->
                            Map.update!(artist, :albums, fn albums ->
                            Enum.reject(albums, &(&1.id == album_id))
                            end)
                        end)
                        |> put_flash(:info, "Album deleted successfully")

                        {:noreply, socket}

                    {:error, error} ->
                        Logger.info("Could not delete album '#{album_id}': #{inspect(error)}")

                        socket =
                        socket
                        |> put_flash(:error, "Could not delete album")

                        {:noreply, socket}
                    end
                end

        Cascading Deletes with AshPostgres
            We can now utilize the belongs_to to make sure that everything is deleted when we delete an artist. We want to delete the related data on delete of the higher level data. Once this is done we will need to codegen and then migrate the database as well
            lib/tunez/music/album.ex
                postgres do
                    table("albums")
                    repo(Tunez.Repo)

                    references do
                    reference(:artist, index?: true, on_delete: :delete)
                    end
                end

                # Then
                mix ash.codegen configure_reference_for_album_artist_id
                mix ash.migrate
            
    Changing Data with Actions
        So much of what we have done so far is setting a lot of data and built-in functions like inserted_at etc, this was all taken care of by ASH. But there is a way to do this manually. Let's go over a few of those now.
        
        Defining an Inline Change
            We want to keep track of any change to an artists name but tracking all previous artists names. lib/tunez/music/artist.ex, as with all the others this is a db change so we need a codegen and then a migration.
                attributes do
                    # ...
                    attribute :previous_names, {:array, :string} do
                        default []
                    end
                    # ...
                end
            
                # Then
                mix ash.codegen add_previous_names_to_artists
                mix ash.migrate

            Okay so we have the column in the db for the previous_names, but that isn't enough as we now need to update the actions to not just use the defualt and then we need to be sure to add the names to the list. Same file also make sure to remove the update from the defaults first the general syntax will look like this.
                update :update do
                    accept([:name, :biography])
                    change(fn changeset, _context -> changeset end)
                end

                # This is the actual code we want.
                actions do
                    defaults([:create, :read, :destroy])
                    default_accept([:name, :biography])

                    update :update do
                    require_atomic?(false)
                    accept([:name, :biography])

                    change(
                        fn changeset, _context ->
                        new_name = Ash.Changeset.get_attribute(changeset, :name)
                        previous_name = Ash.Changeset.get_data(changeset, :name)
                        previous_names = Ash.Changeset.get_data(changeset, :previous_names)

                        names =
                            [previous_name | previous_names]
                            |> Enum.uniq()
                            |> Enum.reject(fn name -> name == new_name end)

                        Ash.Changeset.change_attribute(changeset, :previous_names, names)
                        end,
                        where: [changing(:name)]
                    )
                    end
                end
            
        Defining a Change Module
            Guess what you can do all that with a much easier and faster built-in way!!! lib/tunez/music/changes/update_previous_names.ex, there is not command for this so just create the folder and file and then update the resource.
                defmodule Tunez.Music.Changes.UpdatePreviousNames do
                    use Ash.Resource.Change

                    @impl true
                    def change(changeset, _opts, _context) do
                        Ash.Changeset.before_action(changeset, fn changeset ->
                        new_name = Ash.Changeset.get_attribute(changeset, :name)
                        previous_name = Map.get(changeset.data, :name)
                        previous_names = Map.get(changeset.data, :previous_names) || []

                        names =
                            [previous_name | previous_names]
                            |> Enum.uniq()
                            |> Enum.reject(&(&1 == new_name))

                        Ash.Changeset.change_attribute(changeset, :previous_names, names)
                        end)
                    end
                end

                # Then change the action in the resource lib/tunez/music/artist.ex
                update :update do
                    require_atomic?(false)
                    accept([:name, :biography])

                    change(Tunez.Music.Changes.UpdatePreviousNames,
                        where: [changing(:name)]
                    )
                end

        Changes Run More Often than You Might Think!
            Keep in mind that any time you: 
                Building the inital form
                Authorization checks
                Every validation check
                When submitting the form
            You are running a change. As such you should wrap them in hooks such as Ash.Changeset.before_action or Ash.Changeset.after_action. So the UpdatePreviousNames would look like this.
                def change(changeset, _opts, _context) do
                    Ash.Changeset.before_action(changeset, fn ->
                    # The code previously in the body of the function
                    # It can still use any `opts` or `context` passed in to the top-level
                    # change function, as well
                    new_name = Ash.Changeset.get_attribute(changeset, :name)
                    previous_name = Ash.Changeset.get_data(changeset, :name)
                    previous_names = Ash.Changeset.get_data(changeset, :previous_names)

                    names =
                        [previous_name | previous_names]
                        |> Enum.uniq()
                        |> Enum.reject(fn name -> name == new_name end)

                    Ash.Changeset.change_attribute(changeset, :previous_names, names)
                    end)
                end
            This is going to run right before the action is completed that calls it, in our case the change name.
        
        Rendering the Previous Names in the UI
            This will be quick so just add this to the code and you will see the older names.
            lib/tunez_web/live/artists/show_live.ex
            <.header>
                <.h1>...</.h1>
                <:subtitle :if={@artist.previous_names != []}>➤
                    formerly known as: {Enum.join(@artist.previous_names, ", ")}➤
                </:subtitle>
                ...
            </.header>