Refactor fields handling

demo/lib/demo_web/live/post_live.ex

@@ -110,7 +110,7 @@ defmodule DemoWeb.PostLive do
         module: Backpex.Fields.Textarea,
         label: "Body",
         rows: 10,
-        except: [:index, :resource_action],
+        except: [:index],
         align_label: :center
       },
       published: %{
@@ -123,7 +123,7 @@ defmodule DemoWeb.PostLive do
         module: Backpex.Fields.Boolean,
         label: "Show likes",
         select: dynamic([post: p], fragment("? > 0", p.likes)),
-        except: [:index, :resource_action, :show]
+        except: [:index, :show]
       },
       likes: %{
         module: Backpex.Fields.Number,

demo/lib/demo_web/live/product_live.ex

@@ -51,7 +51,7 @@ defmodule DemoWeb.ProductLive do
           assigns ->
             ~H"<p>{Backpex.HTML.pretty_value(@value)}</p>"
         end,
-        except: [:index, :resource_action]
+        except: [:index]
       },
       name: %{
         module: Backpex.Fields.Text,

demo/lib/demo_web/live/short_link_live.ex

@@ -22,6 +22,7 @@ defmodule DemoWeb.ShortLinkLive do
   def can?(_assigns, :delete, _item), do: false
   def can?(_assigns, _action, _item), do: true
 
+  @impl Backpex.LiveResource
   def return_to(_socket, _assigns, :edit, _form_action, _item) do
     # since the primary key might be updated, we go to the index page
     ~p"/admin/short-links"

guides/fields/visibility.md

@@ -6,7 +6,7 @@ You can change the visibility of fields in certain views.
 
 You can use the `only` and `except` options to define the views where a field should be visible. The `only` option will show the field only in the specified views, while the `except` option will show the field in all views except the specified ones. The options have to be a list of view names.
 
-The following values are supported: `:new`, `:edit`, `:show`, `:index` and `:resource_action`.
+The following values are supported: `:new`, `:edit`, `:show` and `:index`.
 
 ```elixir
 # in your resource configuration file

guides/filter/how-to-add-a-filter.md

@@ -27,7 +27,7 @@ defmodule MyAppWeb.Filters.PostCategorySelect do
   def prompt, do: "Select category ..."
 
   @impl Backpex.Filters.Select
-  def options do
+  def options(_assigns) do
     query =
       from p in Post,
         join: c in Category,

guides/live_resource/navigation.md

@@ -34,4 +34,4 @@ When working with forms (in `:new` or  `:edit` live actions), the following form
 - `:save` - When a form is successfully submitted aka the "Save" button was clicked
 - `:cancel` - When a form submission is canceled aka the "Cancel" button was clicked
 
-For all other live actions, the form_action will be `nil`.
+For all other live actions, the form_action will be `nil`.

guides/upgrading/v0.15.md

@@ -54,3 +54,34 @@ Note that it is now also possible to configure the layout as a function:
 use Backpex.LiveResource,
   layout: &MyAppWeb.admin/1
 ```
+
+## Resource and adapter functions have been updated
+
+We've updated some functions in `Backpex.Resource` and the adapter modules (`Backpex.Adapters.Ecto` and `Backpex.Adapters.Ash`) to include the fields as an additional parameter.
+
+The following functions are affected:
+
+`Backpex.Resource`:
+- `list/3` -> `Backpex.Resource.list/4`
+- `count/3` -> `Backpex.Resource.count/4`
+- `get/3` -> `Backpex.Resource.get/4`
+- `get!/3` -> `Backpex.Resource.get!/4`
+
+`Backpex.Adapter` (including `Backpex.Adapters.Ecto` and `Backpex.Adapters.Ash`):
+- `list/3` -> `c:Backpex.Adapter.list/4`
+- `count/3` -> `c:Backpex.Adapter.count/4`
+- `get/3` -> `c:Backpex.Adapter.get/4`
+
+For example:
+
+```elixir
+# before
+Resource.get(primary_value, socket.assigns, live_resource)
+# after
+Resource.get(primary_value, fields, socket.assigns, live_resource)
+```
+
+## `:only`/`:except` field option changes
+
+You no longer need to pass `:resource_action` in addition to `:index` to the fields `:only`/`:except` option.
+Before, it was needed to make fields visible behind the backdrop of the resource action modal.

guides/upgrading/v0.7.md

@@ -39,10 +39,10 @@ end
 We have updated certain functions in `Backpex.Resource`.
 
 The following functions are affected:
-- `Backpex.Resource.update/6` (`update/5` before)
-- [`Backpex.Resource.insert/6`]() (`insert/5` before)
-- [`Backpex.Resource.change/7`]()
-- [`Backpex.Resource.put_assocs/2`]() (has been removed)
+- `update/6` (`update/5` before)
+- `insert/6` (`insert/5` before)
+- `change/7`
+- `put_assocs/2` (has been removed)
 
 If you call one of these functions in your application, you will probably need to update the function call.
 
@@ -85,4 +85,4 @@ def label(_assigns, _item) do
 end
 ```
 
-Read more about the new `item` parameter in [the item action guide](/guides/actions/item-actions.md#implementing-an-item-action).
+Read more about the new `item` parameter in [the item action guide](/guides/actions/item-actions.md#implementing-an-item-action).

lib/backpex/adapter.ex

@@ -27,41 +27,51 @@ defmodule Backpex.Adapter do
 
   Should return `nil` if no result was found.
   """
-  @callback get(term(), map(), module()) :: {:ok, struct() | nil} | {:error, term()}
+  @callback get(primary_value :: term(), fields :: list(), assigns :: map(), live_resource :: module()) ::
+              {:ok, struct() | nil} | {:error, term()}
 
   @doc """
   Returns a list of items by given criteria.
   """
-  @callback list(keyword(), map(), module()) :: {:ok, list()}
+  @callback list(criteria :: keyword(), fields :: list(), assigns :: map(), live_resource :: module()) :: {:ok, list()}
 
   @doc """
   Gets the total count of the current live_resource.
   Possibly being constrained the item query and the search- and filter options.
   """
-  @callback count(keyword(), map(), module()) :: {:ok, non_neg_integer()}
+  @callback count(criteria :: keyword(), fields :: list(), assigns :: map(), live_resource :: module()) ::
+              {:ok, non_neg_integer()}
 
   @doc """
   Inserts given item.
   """
-  @callback insert(struct(), module()) :: {:ok, struct()} | {:error, term()}
+  @callback insert(item :: struct(), live_resource :: module()) :: {:ok, struct()} | {:error, term()}
 
   @doc """
   Updates given item.
   """
-  @callback update(struct(), module()) :: {:ok, struct()} | {:error, term()}
+  @callback update(item :: struct(), live_resource :: module()) :: {:ok, struct()} | {:error, term()}
 
   @doc """
   Updates given items.
   """
-  @callback update_all(list(struct()), keyword(), module()) :: {:ok, non_neg_integer()}
+  @callback update_all(items :: list(struct()), updates :: keyword(), live_resource :: module()) ::
+              {:ok, non_neg_integer()}
 
   @doc """
   Applies a change to a given item.
   """
-  @callback change(struct(), map(), term(), list(), module(), keyword()) :: Ecto.Changeset.t()
+  @callback change(
+              item :: struct(),
+              attrs :: map(),
+              fields :: term(),
+              assigns :: list(),
+              live_resource :: module(),
+              opts :: keyword()
+            ) :: Ecto.Changeset.t()
 
   @doc """
   Deletes multiple items.
   """
-  @callback delete_all(list(struct()), module()) :: {:ok, term()} | {:error, term()}
+  @callback delete_all(items :: list(struct()), live_resource :: module()) :: {:ok, term()} | {:error, term()}
 end

lib/backpex/adapters/ash.ex

@@ -29,7 +29,7 @@ if Code.ensure_loaded?(Ash) do
     Returns `nil` if no result was found.
     """
     @impl Backpex.Adapter
-    def get(primary_value, _assigns, live_resource) do
+    def get(primary_value, _fields, _assigns, live_resource) do
       resource = live_resource.adapter_config(:resource)
       primary_key = live_resource.config(:primary_key)
 
@@ -42,7 +42,7 @@ if Code.ensure_loaded?(Ash) do
     Returns a list of items by given criteria.
     """
     @impl Backpex.Adapter
-    def list(_criteria, _assigns, live_resource) do
+    def list(_criteria, _fields, _assigns, live_resource) do
       live_resource.adapter_config(:resource)
       |> Ash.read()
     end
@@ -51,7 +51,7 @@ if Code.ensure_loaded?(Ash) do
     Returns the number of items matching the given criteria.
     """
     @impl Backpex.Adapter
-    def count(_criteria, _assigns, live_resource) do
+    def count(_criteria, _fields, _assigns, live_resource) do
       live_resource.adapter_config(:resource)
       |> Ash.count()
     end

lib/backpex/adapters/ecto.ex

@@ -75,10 +75,10 @@ defmodule Backpex.Adapters.Ecto do
   Gets a database record with the given primary key value.
   """
   @impl Backpex.Adapter
-  def get(primary_value, assigns, live_resource) do
+  def get(primary_value, fields, assigns, live_resource) do
     repo = live_resource.adapter_config(:repo)
 
-    record_query(primary_value, assigns, live_resource)
+    record_query(primary_value, assigns, fields, live_resource)
     |> repo.one()
     |> then(fn result -> {:ok, result} end)
   end
@@ -87,10 +87,10 @@ defmodule Backpex.Adapters.Ecto do
   Returns a list of items by given criteria.
   """
   @impl Backpex.Adapter
-  def list(criteria, assigns, live_resource) do
+  def list(criteria, fields, assigns, live_resource) do
     repo = live_resource.adapter_config(:repo)
 
-    list_query(criteria, assigns, live_resource)
+    list_query(criteria, fields, assigns, live_resource)
     |> repo.all()
     |> then(fn items -> {:ok, items} end)
   end
@@ -99,10 +99,10 @@ defmodule Backpex.Adapters.Ecto do
   Returns the number of items matching the given criteria.
   """
   @impl Backpex.Adapter
-  def count(criteria, assigns, live_resource) do
+  def count(criteria, fields, assigns, live_resource) do
     repo = live_resource.adapter_config(:repo)
 
-    list_query(criteria, assigns, live_resource)
+    list_query(criteria, fields, assigns, live_resource)
     |> exclude(:preload)
     |> exclude(:select)
     |> subquery()
@@ -115,11 +115,10 @@ defmodule Backpex.Adapters.Ecto do
 
   TODO: Should be private.
   """
-  def list_query(criteria, assigns, live_resource) do
+  def list_query(criteria, fields, assigns, live_resource) do
     schema = live_resource.adapter_config(:schema)
     item_query = live_resource.adapter_config(:item_query)
     full_text_search = live_resource.config(:full_text_search)
-    fields = live_resource.validated_fields()
     associations = associations(fields, schema)
 
     schema
@@ -350,10 +349,9 @@ defmodule Backpex.Adapters.Ecto do
 
   # --- PRIVATE
 
-  defp record_query(primary_value, assigns, live_resource) do
+  defp record_query(primary_value, assigns, fields, live_resource) do
     schema = live_resource.adapter_config(:schema)
     item_query = live_resource.adapter_config(:item_query)
-    fields = live_resource.validated_fields()
     schema_name = name_by_schema(schema)
     primary_key = live_resource.config(:primary_key)
     primary_type = schema.__schema__(:type, primary_key)

lib/backpex/field.ex

@@ -93,11 +93,11 @@ defmodule Backpex.Field do
     ],
     only: [
       doc: "Define the only views where this field should be visible.",
-      type: {:list, {:in, [:new, :edit, :show, :index, :resource_action]}}
+      type: {:list, {:in, [:new, :edit, :show, :index]}}
     ],
     except: [
       doc: "Define the views where this field should not be visible.",
-      type: {:list, {:in, [:new, :edit, :show, :index, :resource_action]}}
+      type: {:list, {:in, [:new, :edit, :show, :index]}}
     ],
     translate_error: [
       doc: """
@@ -398,7 +398,7 @@ defmodule Backpex.Field do
   Handles index editable.
   """
   def handle_index_editable(socket, value, change) do
-    %{assigns: %{item: item, live_resource: live_resource, fields: fields} = assigns} = socket
+    %{assigns: %{item: item, fields: fields, live_resource: live_resource} = assigns} = socket
 
     if not live_resource.can?(assigns, :edit, item) do
       raise Backpex.ForbiddenError

lib/backpex/fields/has_many_through.ex

@@ -154,24 +154,18 @@ defmodule Backpex.Fields.HasManyThrough do
       <table class="table">
         <thead class="bg-base-200/50 text-base-content uppercase">
           <tr>
-            <th
-              :for={{_name, %{label: label}} <- action_fields(@field_options.child_fields, assigns, :index)}
-              class="font-medium"
-            >
+            <th :for={{_name, %{label: label}} <- action_fields(@field_options.child_fields, :index)} class="font-medium">
               {label}
             </th>
-            <th
-              :for={{_name, %{label: label}} <- action_fields(@field_options.pivot_fields, assigns, :index)}
-              class="font-medium"
-            >
+            <th :for={{_name, %{label: label}} <- action_fields(@field_options.pivot_fields, :index)} class="font-medium">
               {label}
             </th>
             <th></th>
           </tr>
         </thead>
         <tbody class="text-base-content/75">
           <tr :for={{listable, index} <- Enum.with_index(@listables)}>
-            <td :for={{name, field_options} = field <- action_fields(@field_options.child_fields, assigns, :index)}>
+            <td :for={{name, field_options} = field <- action_fields(@field_options.child_fields, :index)}>
               <.live_component
                 id={"child_table_#{name}_#{index}"}
                 module={field_options.module}
@@ -183,7 +177,7 @@ defmodule Backpex.Fields.HasManyThrough do
                 {assigns}
               />
             </td>
-            <td :for={{name, field_options} = field <- action_fields(@field_options.pivot_fields, assigns, :index)}>
+            <td :for={{name, field_options} = field <- action_fields(@field_options.pivot_fields, :index)}>
               <.live_component
                 id={"pivot_table_#{name}_#{index}"}
                 module={field_options.module}
@@ -252,13 +246,13 @@ defmodule Backpex.Fields.HasManyThrough do
             <thead class="bg-base-200/50 text-base-content uppercase">
               <tr>
                 <th
-                  :for={{_name, %{label: label}} <- action_fields(@field_options.child_fields, assigns, :index)}
+                  :for={{_name, %{label: label}} <- action_fields(@field_options.child_fields, :index)}
                   class="font-medium"
                 >
                   {label}
                 </th>
                 <th
-                  :for={{_name, %{label: label}} <- action_fields(@field_options.pivot_fields, assigns, :index)}
+                  :for={{_name, %{label: label}} <- action_fields(@field_options.pivot_fields, :index)}
                   class="font-medium"
                 >
                   {label}
@@ -271,7 +265,7 @@ defmodule Backpex.Fields.HasManyThrough do
                 :for={{listable, index} <- Enum.with_index(@listables)}
                 class="border-b-[1px] border-base-content/10 last:border-b-0"
               >
-                <td :for={{name, field_options} <- action_fields(@field_options.child_fields, assigns, :index)}>
+                <td :for={{name, field_options} <- action_fields(@field_options.child_fields, :index)}>
                   <.live_component
                     id={"child_table_#{name}_#{index}"}
                     module={field_options.module}
@@ -281,7 +275,7 @@ defmodule Backpex.Fields.HasManyThrough do
                     {assigns}
                   />
                 </td>
-                <td :for={{name, field_options} <- action_fields(@field_options.pivot_fields, assigns, :index)}>
+                <td :for={{name, field_options} <- action_fields(@field_options.pivot_fields, :index)}>
                   <.live_component
                     id={"pivot_table_#{name}_#{index}"}
                     module={field_options.module}
@@ -414,15 +408,22 @@ defmodule Backpex.Fields.HasManyThrough do
     {:noreply, socket}
   end
 
-  defp action_fields(fields, assigns, action), do: LiveResource.filtered_fields_by_action(fields, assigns, action)
+  defp action_fields(fields, action) do
+    # Currently, the fields are only filtered by action, not by the fields `can?` option.
+    # See https://github.com/naymspace/backpex/pull/1271
+    LiveResource.fields_by_action(fields, action)
+  end
 
   defp assign_fallback_child_fields(assigns) do
     case Map.has_key?(assigns.field_options, :child_fields) do
       true ->
         assigns
 
       false ->
-        fields = assigns.field_options.live_resource.validated_fields()
+        # It's currently not supported to add a `can?` options to the child fields. Therefore we
+        # are passing an empty map as the assigns.
+        # See https://github.com/naymspace/backpex/pull/1271
+        fields = assigns.field_options.live_resource.fields(:index, %{})
         new_field_options = Map.put(assigns.field_options, :child_fields, fields)
 
         assigns