improvement: allow data loading when no primary read action exists

this is still a bit experimental, so there may be some sharp edges,
but it makes sense for a resource with only a create action to be able to
load data, but to do so it currently needs to add a read action that will
never actually be called, only "used" as the action being performed, for things
like policies etc. We may even want to make this logic the default in a future
major version.

documentation/dsls/DSL-Ash.Reactor.md

@@ -760,7 +760,7 @@ end
 | [`max_concurrency`](#reactor-bulk_update-max_concurrency){: #reactor-bulk_update-max_concurrency } | `non_neg_integer` | `0` | If set to a value greater than 0, up to that many tasks will be started to run batches asynchronously. |
 | [`notification_metadata`](#reactor-bulk_update-notification_metadata){: #reactor-bulk_update-notification_metadata } | `map \| Reactor.Template.Element \| Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value` | `%{}` | Metadata to be merged into the metadata field for all notifications sent from this operation. |
 | [`notify?`](#reactor-bulk_update-notify?){: #reactor-bulk_update-notify? } | `boolean` | `false` | Whether or not to generate any notifications. This may be intensive for large bulk actions. |
-| [`page`](#reactor-bulk_update-page){: #reactor-bulk_update-page } | `keyword` | `[]` | Pagination options, see [the pagination docs for more](read-actions.md#pagination). |
+| [`page`](#reactor-bulk_update-page){: #reactor-bulk_update-page } | `keyword` | `[]` | Pagination options, see `Ash.read/2` for more. |
 | [`read_action`](#reactor-bulk_update-read_action){: #reactor-bulk_update-read_action } | `atom` |  | The action to use when building the read query. |
 | [`return_errors?`](#reactor-bulk_update-return_errors?){: #reactor-bulk_update-return_errors? } | `boolean` | `false` | Whether or not to return all of the errors that occur. Defaults to false to account for large inserts. |
 | [`return_records?`](#reactor-bulk_update-return_records?){: #reactor-bulk_update-return_records? } | `boolean` | `false` | Whether or not to return all of the records that were inserted. Defaults to false to account for large inserts. |

lib/ash/actions/create/bulk.ex

@@ -1438,6 +1438,7 @@ defmodule Ash.Actions.Create.Bulk do
              context: %{private: %{just_created_by_action: action.name}},
              reuse_values?: true,
              domain: domain,
+             action: Ash.Resource.Info.primary_action(resource, :read) || action,
              tenant: opts[:tenant],
              actor: opts[:actor],
              authorize?: opts[:authorize?],
@@ -1450,6 +1451,7 @@ defmodule Ash.Actions.Create.Bulk do
             context: %{private: %{just_created_by_action: action.name}},
             domain: domain,
             tenant: opts[:tenant],
+            action: Ash.Resource.Info.primary_action(resource, :read) || action,
             reuse_values?: true,
             actor: opts[:actor],
             authorize?: opts[:authorize?],

lib/ash/actions/create/create.ex

@@ -470,6 +470,7 @@ defmodule Ash.Actions.Create do
           }),
           domain,
           actor: opts[:actor],
+          action: Ash.Resource.Info.primary_action(changeset.resource, :read) || changeset.action,
           reuse_values?: true,
           authorize?: opts[:authorize?],
           tracer: opts[:tracer]

lib/ash/actions/destroy/bulk.ex

@@ -2139,6 +2139,8 @@ defmodule Ash.Actions.Destroy.Bulk do
            reuse_values?: true,
            domain: domain,
            tenant: opts[:tenant],
+           action:
+             Ash.Resource.Info.primary_action(changeset.resource, :read) || changeset.action,
            actor: opts[:actor],
            authorize?: opts[:authorize?],
            tracer: opts[:tracer]
@@ -2149,6 +2151,7 @@ defmodule Ash.Actions.Destroy.Bulk do
           List.wrap(changeset.load),
           reuse_values?: true,
           tenant: opts[:tenant],
+          action: Ash.Resource.Info.primary_action(changeset.resource, :read) || changeset.action,
           domain: domain,
           actor: opts[:actor],
           authorize?: opts[:authorize?],

lib/ash/actions/destroy/destroy.ex

@@ -174,6 +174,8 @@ defmodule Ash.Actions.Destroy do
           case Helpers.load({:ok, changeset.data, %{}}, changeset, domain,
                  actor: opts[:actor],
                  reuse_values?: true,
+                 action:
+                   Ash.Resource.Info.primary_action(changeset.resource, :read) || changeset.action,
                  authorize?: opts[:authorize?],
                  tracer: opts[:tracer]
                ) do

lib/ash/actions/read/read.ex

@@ -132,14 +132,18 @@ defmodule Ash.Actions.Read do
     action = get_action(query.resource, query.action || action)
 
     query =
-      for_read(
-        query,
-        action,
-        actor: opts[:actor],
-        authorize?: opts[:authorize?],
-        timeout: opts[:timeout],
-        tenant: opts[:tenant]
-      )
+      if action.type == :read do
+        for_read(
+          query,
+          action,
+          actor: opts[:actor],
+          authorize?: opts[:authorize?],
+          timeout: opts[:timeout],
+          tenant: opts[:tenant]
+        )
+      else
+        query
+      end
 
     initial_query = query
 
@@ -148,7 +152,7 @@ defmodule Ash.Actions.Read do
     query = %{
       query
       | timeout:
-          opts[:timeout] || query.timeout || query.action.timeout ||
+          opts[:timeout] || query.timeout || (query.action && query.action.timeout) ||
             Ash.Domain.Info.timeout(query.domain)
     }
 
@@ -2420,6 +2424,9 @@ defmodule Ash.Actions.Read do
 
   def page_opts(action, page_opts, relationship?) do
     cond do
+      action.type != :read ->
+        nil
+
       action.pagination == false ->
         nil
 

lib/ash/actions/update/bulk.ex

@@ -2494,6 +2494,8 @@ defmodule Ash.Actions.Update.Bulk do
            reuse_values?: true,
            domain: domain,
            tenant: opts[:tenant],
+           action:
+             Ash.Resource.Info.primary_action(changeset.resource, :read) || changeset.action,
            actor: opts[:actor],
            authorize?: opts[:authorize?],
            tracer: opts[:tracer]
@@ -2504,6 +2506,7 @@ defmodule Ash.Actions.Update.Bulk do
           List.wrap(changeset.load),
           reuse_values?: true,
           tenant: opts[:tenant],
+          action: Ash.Resource.Info.primary_action(changeset.resource, :read) || changeset.action,
           domain: domain,
           actor: opts[:actor],
           authorize?: opts[:authorize?],

lib/ash/actions/update/update.ex

@@ -571,6 +571,7 @@ defmodule Ash.Actions.Update do
         |> Helpers.load(changeset, domain,
           actor: opts[:actor],
           reuse_values?: true,
+          action: Ash.Resource.Info.primary_action(changeset.resource, :read) || changeset.action,
           authorize?: opts[:authorize?],
           tracer: opts[:tracer]
         )

lib/ash/reactor/dsl/bulk_update.ex

@@ -235,8 +235,7 @@ defmodule Ash.Reactor.Dsl.BulkUpdate do
           ],
           page: [
             type: :keyword_list,
-            doc:
-              "Pagination options, see `Ash.read/2` for more.",
+            doc: "Pagination options, see `Ash.read/2` for more.",
             required: false,
             default: []
           ],

test/actions/load_test.exs

@@ -6,6 +6,24 @@ defmodule Ash.Test.Actions.LoadTest do
 
   alias Ash.Test.Domain, as: Domain
 
+  defmodule ExampleWithNoPrimaryRead do
+    use Ash.Resource,
+      domain: Domain,
+      data_layer: Ash.DataLayer.Ets
+
+    actions do
+      defaults [:create]
+    end
+
+    attributes do
+      uuid_primary_key :id
+    end
+
+    calculations do
+      calculate :id_calc, :uuid, expr(id)
+    end
+  end
+
   defmodule Campaign do
     @moduledoc false
     use Ash.Resource,
@@ -1927,4 +1945,14 @@ defmodule Ash.Test.Actions.LoadTest do
       assert post.contents == loaded_post.contents
     end
   end
+
+  test "you can load data on create with no default read action" do
+    record =
+      ExampleWithNoPrimaryRead
+      |> Ash.Changeset.for_create(:create, %{})
+      |> Ash.Changeset.load(:id_calc)
+      |> Ash.create!()
+
+    assert record.id == record.id_calc
+  end
 end