Remove accept, arguments from pipeline

Author: nallwhy

documentation/dsls/DSL-Ash.Resource.md

@@ -3024,7 +3024,6 @@ that can be referenced from multiple actions via `pipe_through`.
 
 ### Nested DSLs
  * [pipeline](#pipelines-pipeline)
-   * argument
    * change
    * validate
    * prepare
@@ -3055,7 +3054,6 @@ that can be referenced from multiple actions via `pipe_through`.
 
 
 ### Nested DSLs
- * [argument](#pipelines-pipeline-argument)
  * [change](#pipelines-pipeline-change)
  * [validate](#pipelines-pipeline-validate)
  * [prepare](#pipelines-pipeline-prepare)
@@ -3082,52 +3080,8 @@ end
 | Name | Type | Default | Docs |
 |------|------|---------|------|
 | [`description`](#pipelines-pipeline-description){: #pipelines-pipeline-description } | `String.t` |  | An optional description for the pipeline |
-| [`accept`](#pipelines-pipeline-accept){: #pipelines-pipeline-accept } | `atom \| list(atom) \| :*` | `[]` | A list of attributes to accept. Merged with the action's own accept list. |
-
-
-### pipelines.pipeline.argument
-```elixir
-argument name, type
-```
-
-
-Declares an argument on the action
-
-
-
-
-### Examples
-```
-argument :password_confirmation, :string
-```
-
 
 
-### Arguments
-
-| Name | Type | Default | Docs |
-|------|------|---------|------|
-| [`name`](#pipelines-pipeline-argument-name){: #pipelines-pipeline-argument-name .spark-required} | `atom` |  | The name of the argument |
-| [`type`](#pipelines-pipeline-argument-type){: #pipelines-pipeline-argument-type .spark-required} | `module` |  | The type of the argument. See `Ash.Type` for more. |
-### Options
-
-| Name | Type | Default | Docs |
-|------|------|---------|------|
-| [`description`](#pipelines-pipeline-argument-description){: #pipelines-pipeline-argument-description } | `String.t` |  | An optional description for the argument. |
-| [`constraints`](#pipelines-pipeline-argument-constraints){: #pipelines-pipeline-argument-constraints } | `keyword` | `[]` | Constraints to provide to the type when casting the value. For more information, see `Ash.Type`. |
-| [`allow_nil?`](#pipelines-pipeline-argument-allow_nil?){: #pipelines-pipeline-argument-allow_nil? } | `boolean` | `true` | Whether or not the argument value may be nil (or may be not provided). If nil value is given error is raised. |
-| [`public?`](#pipelines-pipeline-argument-public?){: #pipelines-pipeline-argument-public? } | `boolean` | `true` | Whether or not the argument should appear in public interfaces |
-| [`sensitive?`](#pipelines-pipeline-argument-sensitive?){: #pipelines-pipeline-argument-sensitive? } | `boolean` | `false` | Whether or not the argument value contains sensitive information, like PII(Personally Identifiable Information). See the [security guide](/documentation/topics/security/sensitive-data.md) for more. |
-| [`default`](#pipelines-pipeline-argument-default){: #pipelines-pipeline-argument-default } | `any` |  | The default value for the argument to take. It can be a zero argument function e.g `&MyMod.my_fun/0` or a value |
-
-
-
-
-
-### Introspection
-
-Target: `Ash.Resource.Actions.Argument`
-
 ### pipelines.pipeline.change
 ```elixir
 change change

lib/ash/resource/dsl.ex

@@ -1185,9 +1185,6 @@ defmodule Ash.Resource.Dsl do
     target: Ash.Resource.Pipeline,
     schema: Ash.Resource.Pipeline.schema(),
     entities: [
-      arguments: [
-        @action_argument
-      ],
       changes: [
         @action_change
       ],

lib/ash/resource/pipeline.ex

@@ -10,8 +10,6 @@ defmodule Ash.Resource.Pipeline do
   defstruct [
     :name,
     :description,
-    accept: [],
-    arguments: [],
     changes: [],
     validations: [],
     preparations: [],
@@ -21,8 +19,6 @@ defmodule Ash.Resource.Pipeline do
   @type t :: %__MODULE__{
           name: atom(),
           description: String.t() | nil,
-          accept: list(atom()) | :*,
-          arguments: list(),
           changes: list(),
           validations: list(),
           preparations: list(),
@@ -38,11 +34,6 @@ defmodule Ash.Resource.Pipeline do
     description: [
       type: :string,
       doc: "An optional description for the pipeline"
-    ],
-    accept: [
-      type: {:or, [{:wrap_list, :atom}, {:literal, :*}]},
-      default: [],
-      doc: "A list of attributes to accept. Merged with the action's own accept list."
     ]
   ]
 

lib/ash/resource/transformers/resolve_pipelines.ex

@@ -24,55 +24,43 @@ defmodule Ash.Resource.Transformers.ResolvePipelines do
 
     dsl_state
     |> Transformer.get_entities([:actions])
-    |> Enum.reduce_while({:ok, dsl_state}, fn action, {:ok, dsl_state} ->
+    |> Enum.reduce({:ok, dsl_state}, fn action, {:ok, dsl_state} ->
       field = entity_field(action.type)
       entities = Map.get(action, field, [])
 
       if Enum.any?(entities, &match?(%PipeThrough{}, &1)) do
-        updated_action = resolve_action(action, field, entities, pipelines, dsl_state)
+        expanded = resolve_action(action, entities, pipelines, dsl_state)
 
         new_state =
           Transformer.replace_entity(
             dsl_state,
             [:actions],
-            updated_action,
+            Map.put(action, field, expanded),
             &(&1.name == action.name && &1.type == action.type)
           )
 
-        {:cont, {:ok, new_state}}
+        {:ok, new_state}
       else
-        {:cont, {:ok, dsl_state}}
+        {:ok, dsl_state}
       end
     end)
   end
 
-  defp resolve_action(action, field, entities, pipelines, dsl_state) do
-    {expanded, arguments, accept} =
-      Enum.reduce(entities, {[], [], []}, fn
-        %PipeThrough{names: names, where: where}, {expanded, arguments, accept} ->
-          {new_entities, new_arguments, new_accept} =
-            expand_pipe_through(names, where, action, pipelines, dsl_state)
+  defp resolve_action(action, entities, pipelines, dsl_state) do
+    Enum.flat_map(entities, fn
+      %PipeThrough{names: names, where: where} ->
+        expand_pipe_through(names, where, action, pipelines, dsl_state)
 
-          {expanded ++ new_entities, arguments ++ new_arguments, accept ++ new_accept}
-
-        entity, {expanded, arguments, accept} ->
-          {expanded ++ [entity], arguments, accept}
-      end)
-
-    action
-    |> Map.put(field, expanded)
-    |> merge_arguments(arguments, dsl_state)
-    |> merge_accept(merge_pipeline_accepts(accept))
+      entity ->
+        [entity]
+    end)
   end
 
   defp expand_pipe_through(names, where, action, pipelines, dsl_state) do
-    Enum.reduce(names, {[], [], []}, fn name, {entities, arguments, accept} ->
+    Enum.flat_map(names, fn name ->
       case Map.fetch(pipelines, name) do
         {:ok, pipeline} ->
-          pipeline_entities = collect_entities(action.type, pipeline, where, dsl_state)
-
-          {entities ++ pipeline_entities, arguments ++ pipeline.arguments,
-           accept ++ List.wrap(if pipeline.accept == :*, do: [:*], else: pipeline.accept)}
+          collect_entities(action.type, pipeline, where, dsl_state)
 
         :error ->
           raise DslError,
@@ -86,135 +74,41 @@ defmodule Ash.Resource.Transformers.ResolvePipelines do
 
   defp collect_entities(type, pipeline, where, dsl_state) do
     subject = subject_for_type(type)
-    entities = source_entities(pipeline, type)
 
-    Enum.each(entities, &validate_supports!(&1, subject, pipeline, dsl_state))
-
-    Enum.map(entities, fn entity ->
+    source_entities(pipeline, type)
+    |> Enum.map(fn entity ->
+      validate_supports!(entity, subject, pipeline, dsl_state)
       Map.update!(entity, :where, &(where ++ &1))
     end)
   end
 
-  defp merge_arguments(action, [], _dsl_state), do: action
-
-  defp merge_arguments(action, pipeline_arguments, dsl_state) do
-    {deduped_pipeline_args, pipeline_conflicts} =
-      Enum.reduce(pipeline_arguments, {%{}, []}, fn arg, {seen, conflicts} ->
-        case Map.fetch(seen, arg.name) do
-          :error ->
-            {Map.put(seen, arg.name, arg), conflicts}
-
-          {:ok, existing} ->
-            if existing.type == arg.type do
-              {seen, conflicts}
-            else
-              {seen, [{arg.name, existing.type, arg.type} | conflicts]}
-            end
-        end
-      end)
-
-    if pipeline_conflicts != [] do
-      conflict_details =
-        Enum.map_join(pipeline_conflicts, ", ", fn {name, type1, type2} ->
-          "`#{name}` (#{inspect(type1)} vs #{inspect(type2)})"
-        end)
-
-      raise DslError,
-        module: Transformer.get_persisted(dsl_state, :module),
-        path: [:actions, action.type, action.name],
-        message: "Pipelines define argument(s) with conflicting types: #{conflict_details}"
-    end
-
-    action_args_by_name = Map.new(action.arguments, &{&1.name, &1})
+  defp validate_supports!(entity, subject, pipeline, dsl_state) do
+    case entity_module_and_opts(entity) do
+      {module, opts} ->
+        supported = module.supports(opts)
 
-    {new_args, action_conflicts} =
-      Enum.reduce(deduped_pipeline_args, {[], []}, fn {_name, pipeline_arg}, {keep, conflicts} ->
-        case Map.fetch(action_args_by_name, pipeline_arg.name) do
-          :error ->
-            {[pipeline_arg | keep], conflicts}
+        if subject not in supported do
+          label = entity.__struct__ |> Module.split() |> List.last()
 
-          {:ok, action_arg} ->
-            if action_arg.type == pipeline_arg.type do
-              {keep, conflicts}
-            else
-              {keep, [pipeline_arg | conflicts]}
-            end
+          raise DslError,
+            module: Transformer.get_persisted(dsl_state, :module),
+            path: [:pipelines, pipeline.name],
+            message:
+              "#{label} `#{inspect(module)}` in pipeline `#{pipeline.name}` does not support `#{inspect(subject)}` (supported: #{inspect(supported)})"
         end
-      end)
 
-    if action_conflicts != [] do
-      conflict_details =
-        Enum.map_join(action_conflicts, ", ", fn arg ->
-          action_arg = action_args_by_name[arg.name]
-
-          "`#{arg.name}` (pipeline: #{inspect(arg.type)}, action: #{inspect(action_arg.type)})"
-        end)
-
-      raise DslError,
-        module: Transformer.get_persisted(dsl_state, :module),
-        path: [:actions, action.type, action.name],
-        message:
-          "Action `#{action.name}` redefines pipeline argument(s) with a different type: #{conflict_details}"
-    end
-
-    Map.update!(action, :arguments, &(Enum.reverse(new_args) ++ &1))
-  end
-
-  defp merge_pipeline_accepts(accept_lists) do
-    if :* in accept_lists do
-      :*
-    else
-      Enum.uniq(accept_lists)
-    end
-  end
-
-  defp merge_accept(action, []), do: action
-  defp merge_accept(action, :*), do: Map.put(action, :accept, :*)
-
-  defp merge_accept(action, accept) when is_list(accept) do
-    case Map.get(action, :accept) do
       nil ->
-        Map.put(action, :accept, accept)
-
-      :* ->
-        action
-
-      existing when is_list(existing) ->
-        Map.put(action, :accept, Enum.uniq(accept ++ existing))
+        :ok
     end
   end
 
-  defp validate_supports!(
-         %Ash.Resource.Validation{module: module, opts: opts},
-         subject,
-         pipeline,
-         dsl_state
-       ) do
-    if subject not in module.supports(opts) do
-      raise DslError,
-        module: Transformer.get_persisted(dsl_state, :module),
-        path: [:pipelines, pipeline.name],
-        message:
-          "Validation `#{inspect(module)}` in pipeline `#{pipeline.name}` does not support `#{inspect(subject)}` (supported: #{inspect(module.supports(opts))})"
-    end
-  end
+  defp entity_module_and_opts(%Ash.Resource.Validation{module: module, opts: opts}),
+    do: {module, opts}
 
-  defp validate_supports!(
-         %Ash.Resource.Preparation{preparation: {module, opts}},
-         subject,
-         pipeline,
-         dsl_state
-       ) do
-    if subject not in module.supports(opts) do
-      raise DslError,
-        module: Transformer.get_persisted(dsl_state, :module),
-        path: [:pipelines, pipeline.name],
-        message:
-          "Preparation `#{inspect(module)}` in pipeline `#{pipeline.name}` does not support `#{inspect(subject)}` (supported: #{inspect(module.supports(opts))})"
-    end
-  end
+  defp entity_module_and_opts(%Ash.Resource.Preparation{preparation: {module, opts}}),
+    do: {module, opts}
 
-  defp validate_supports!(_entity, _subject, _pipeline, _dsl_state), do: :ok
+  defp entity_module_and_opts(_), do: nil
 
   defp source_entities(pipeline, type) when type in [:create, :update, :destroy],
     do: pipeline.changes ++ pipeline.validations