chore: fix dialyzer, add embedded resources guide back

documentation/topics/embedded-resources.md

@@ -0,0 +1,172 @@
+# Embedded Resources
+
+Embedded resources function very similarly to [embedded schemas in Ecto](https://hexdocs.pm/ecto/Ecto.Schema.html).
+The primary difference is the same as the primary difference between Ecto schemas and Ash resources: the full lifecycle
+of the resource is managed by its configuration. For example, you can add validations, calculations, and even authorization policies to an embedded resource. Here is an example of a simple embedded resource:
+
+```elixir
+defmodule MyApp.Profile do
+  use Ash.Resource,
+    data_layer: :embedded # Use the atom `:embedded` as the data layer.
+
+  attributes do
+    attribute :first_name, :string
+    attribute :last_name, :string
+  end
+end
+```
+
+Embedded resources cannot have relationships or aggregates.
+
+## Adding embedded resource attributes
+
+Embedded resources simply define an `Ash.Type` under the hood, meaning you can use them anywhere you would 
+use an Ash type.
+
+```elixir
+defmodule MyApp.User do
+  use Ash.Resource, ...
+
+  attributes do
+    ...
+
+    attribute :profile, MyApp.Profile
+    attribute :profiles, {:array, MyApp.Profile} # You can also have an array of embeds
+  end
+end
+```
+
+## Editing embedded attributes
+
+If you manually supply instances of the embedded structs, the structs you provide are used with no validation. For example:
+
+```elixir
+Ash.Changeset.new(user, %{profile: %MyApp.Profile{first_name: "first_name", last_name: "last_name}})
+```
+
+However, you can also treat embedded resources like regular resources that can be "created", "updated", and "destroyed".
+To do this, provide maps as the input, instead of structs. In the example above, if you just wanted to change the `first_name`, you'd provide:
+
+```elixir
+Ash.Changeset.new(user, %{profile: %{first_name: "first_name"}})
+```
+
+This will call the primary `update` action on the resource. This allows you to define an action on the embed, and add validations to it. For example, you might have something like this:
+
+```elixir
+defmodule MyApp.Profile do
+  use Ash.Resource,
+    data_layer: :embedded # Use the atom `:embedded` as the data layer.
+
+  attributes do
+    attribute :first_name, :string
+    attribute :last_name, :string
+  end
+
+  validations do
+    validate present([:first_name, :last_name], at_least: 1)
+  end
+end
+```
+
+## Calculations
+
+Calculations can be added to embedded resources. When you use an embedded resource, you declare what calculations to load via a `constraint`.
+For example:
+
+```elixir
+defmodule MyApp.Profile do
+  use Ash.Resource,
+    data_layer: :embedded # Use the atom `:embedded` as the data layer.
+
+  attributes do
+    attribute :first_name, :string
+    attribute :last_name, :string
+  end
+
+  calculations do
+    calculate :full_name, :string, concat([:first_name, :last_name], " ")
+  end
+end
+
+defmodule MyApp.User do
+  use Ash.Resource,
+    ...
+
+  attributes do
+    attribute :profile, MyApp.Profile do
+      constraints [load: [:full_name]]
+    end
+  end
+end
+```
+
+## Determining what action(s) will be called:
+
+Remember: default actions are already implemented for a resource, with no need to add them. They are called `:create`, `:update`, `:destroy`, and `:read`. You can use those without defining them. You only need to define them if you wish to override their configuration.
+
+### Single Embeds
+
+* If the current value is `nil` - a `create` with the provided values
+* If the current value is not `nil` - an `update` with the provided values
+* If the current value is not `nil` and the *new value* is `nil` - a `destroy` with the original value
+
+### Array Embeds
+
+All values in the original array are destroyed, and all maps in the new array are used to `create` new records.
+
+## Adding a primary key
+
+Adding a primary key to your embedded resources is especially useful when managing lists of data. Specifically, it allows you to consider changes to elements with matching primary key values as `updates`.
+
+For example:
+
+```elixir
+defmodule MyApp.Tag do
+  use Ash.Resource,
+    data_layer: :embedded
+
+  attributes do
+    uuid_primary_key :id
+    attribute :name, :string
+    attribute :counter, :integer
+  end
+
+  validations do
+    validate {Increasing, field: :counter}, on: :update
+  end
+end
+```
+
+Now, you can accept input meant to `update` individual list items. The entire list must still be provided, but any items with a matching id will be considered an `update` instead of a `destroy` + `create`.
+
+### Determining what action(s) will be called with a primary key:
+
+#### Single Embeds with primary keys
+
+* If you provide a struct, instead of a map, the value provided is simply used as the new relationship value.
+* If the current value is `nil` - a `create` with the provided values
+* If the current value is not `nil` and the primary keys match - an `update` with the provided values
+* If the current value is not `nil` and the primary keys *don't* match - a `destroy` of the original value and a `create` of the new value
+* If the current value is not `nil` and the *new value* is `nil` - a `destroy` with the original value
+
+#### Array Embeds with primary keys
+
+* If you provide structs, instead of maps, the value provided is simply used as the new relationship value.
+* Any values in the original list with no primary key matching in the new list are `destroy`ed.
+* Any values in the new list with no primary key matching in the original list are `create`d.
+* Any values with a primary key match in the original list and the new list are `update`d
+
+## Identities
+
+Identities can be added on an embedded resource, which will ensure that for any given list, they are unique on that identity. For example, if you had an embedded resource called `Tag`, you could add an identity on `name` to ensure that nothing has duplicate tag names.
+
+## Usage in Extensions
+
+The AshJsonApi extension simply exposes these attributes as maps. However, the AshGraphql extension allows you
+to specify a type (but not queries/mutations) for an embedded resource. If you do, instead of being treated as a `:json` type it will get its own named input object type and field type.
+
+## Accessing the source changeset
+
+When building changesets for embedded resources, the source changeset will be available in action changes under `changeset.context.__source__`.
+This allows you to customize the action based on the details of the parent changeset.

lib/ash/filter/filter.ex

@@ -1934,7 +1934,7 @@ defmodule Ash.Filter do
              )}
 
           resource_calculation ->
-            {module, opts} = module_and_opts(resource_calculation.calculation)
+            {module, opts} = resource_calculation.calculation
 
             {args, nested_statement} =
               case args do
@@ -2114,7 +2114,7 @@ defmodule Ash.Filter do
         add_aggregate_expression(context, nested_statement, field, expression)
 
       resource_calculation = calculation(context, field) ->
-        {module, opts} = module_and_opts(resource_calculation.calculation)
+        {module, opts} = resource_calculation.calculation
 
         {input, nested_statement} =
           case nested_statement do
@@ -2358,7 +2358,7 @@ defmodule Ash.Filter do
 
     case {calculation(%{context | resource: resource}, name), could_be_calculation?} do
       {resource_calculation, true} when not is_nil(resource_calculation) ->
-        {module, opts} = module_and_opts(resource_calculation.calculation)
+        {module, opts} = resource_calculation.calculation
 
         with {:ok, args} <-
                Ash.Query.validate_calculation_arguments(
@@ -2428,9 +2428,6 @@ defmodule Ash.Filter do
     end
   end
 
-  defp module_and_opts({module, opts}), do: {module, opts}
-  defp module_and_opts(module), do: {module, []}
-
   def hydrate_refs({key, value}, context) when is_atom(key) do
     context = Map.put_new(context, :root_resource, context[:resource])
 
@@ -2469,7 +2466,7 @@ defmodule Ash.Filter do
             {:ok, %{ref | attribute: attribute, resource: related}}
 
           resource_calculation = calculation(context, attribute) ->
-            {module, opts} = module_and_opts(resource_calculation.calculation)
+            {module, opts} = resource_calculation.calculation
 
             with {:ok, args} <-
                    Ash.Query.validate_calculation_arguments(resource_calculation, %{}),

lib/ash/flow/chart/mermaid.ex

@@ -308,12 +308,12 @@ defmodule Ash.Flow.Chart.Mermaid do
   defp do_format_template(template, all_steps) when is_map(template) do
     body =
       Enum.map_join(template, ",<br/>", fn {key, value} ->
-        case do_format_template(key, all_steps) do
-          ":" <> key ->
-            "#{key}: #{do_format_template(value, all_steps)}"
+        result = do_format_template(key, all_steps)
 
-          key ->
-            "#{inspect(key)} => #{do_format_template(value, all_steps)}"
+        if String.starts_with?(result, ":") do
+          "#{String.trim_leading(result, ":")}: #{do_format_template(value, all_steps)}"
+        else
+          "#{inspect(result)} => #{do_format_template(value, all_steps)}"
         end
       end)
 

lib/ash/query/query.ex

@@ -820,7 +820,7 @@ defmodule Ash.Query do
             load_relationship(query, [{field, nested_query}])
 
           resource_calculation = Ash.Resource.Info.calculation(query.resource, field) ->
-            {module, opts} = module_and_opts(resource_calculation.calculation)
+            {module, opts} = resource_calculation.calculation
 
             with {:ok, args} <- validate_calculation_arguments(resource_calculation, rest),
                  {:ok, calculation} <-
@@ -870,9 +870,6 @@ defmodule Ash.Query do
     end)
   end
 
-  defp module_and_opts({module, opts}), do: {module, opts}
-  defp module_and_opts(module), do: {module, []}
-
   defp do_load(query, field) do
     cond do
       Ash.Resource.Info.attribute(query.resource, field) ->
@@ -920,11 +917,7 @@ defmodule Ash.Query do
         end
 
       resource_calculation = Ash.Resource.Info.calculation(query.resource, field) ->
-        {module, opts} =
-          case resource_calculation.calculation do
-            {module, opts} -> {module, opts}
-            module -> {module, []}
-          end
+        {module, opts} = resource_calculation.calculation
 
         with {:ok, args} <- validate_calculation_arguments(resource_calculation, %{}),
              {:ok, calculation} <-

lib/ash/type/type.ex

@@ -750,7 +750,9 @@ defmodule Ash.Type do
 
         @impl true
         def load(term, _, params) do
-          case @parent.cast_stored(term, params) do
+          parent = @parent
+
+          case parent.cast_stored(term, params) do
             {:ok, value} ->
               {:ok, value}
 
@@ -761,7 +763,9 @@ defmodule Ash.Type do
 
         @impl true
         def dump(term, _dumper, params) do
-          case @parent.dump_to_native(term, params) do
+          parent = @parent
+
+          case parent.dump_to_native(term, params) do
             {:ok, value} ->
               {:ok, value}