improvement: support extra blob attrs from service upload (#9)

* improvement: support `{:ok, extra_blob_attrs}` return from service upload

The Service.upload callback already declared `{:ok, map()}` as a valid
return type, but none of the callers honoured it — they only matched on
`:ok`. This meant wrapping services had no way to pass per-file metadata
back into the blob record at creation time.

All three upload sites (HandleFileArgument, Attach, VariantGenerator)
now normalise the upload result through `normalize_upload/1` and merge
any returned map into the blob attributes before `Ash.create`. A service
that returns `:ok` still works unchanged; one that returns
`{:ok, %{metadata: …}}` gets those entries merged into the blob.

This is the minimal hook needed for wrapping services (e.g. encryption)
to annotate blobs without requiring changes to the blob resource schema
or the storage DSL.

* fix: ensure SetupBlob runs before SetRelationshipSource

The SetupBlob transformer adds relationships (source_blob, variants) but
was not guaranteed to run before SetRelationshipSource, leaving their
`source` field as nil. This caused AshPostgres to crash with
`nil.persisted(:otp_app)` when resolving foreign key constraints during
bulk updates (e.g. update_metadata).

* test: add tests for {:ok, extra_blob_attrs} service upload return

Covers all three code paths that handle the extra attrs merge:
Operations.attach, AttachFile change (create + update), and
VariantGenerator (eager variants).

Author: marcnnn

lib/ash_storage/blob_resource/transformers/setup_blob.ex

@@ -4,7 +4,8 @@ defmodule AshStorage.BlobResource.Transformers.SetupBlob do
 
   @before_transformers [
     Ash.Resource.Transformers.DefaultAccept,
-    Ash.Resource.Transformers.SetTypes
+    Ash.Resource.Transformers.SetTypes,
+    Ash.Resource.Transformers.SetRelationshipSource
   ]
 
   def before?(transformer) when transformer in @before_transformers, do: true

lib/ash_storage/changes/attach.ex

@@ -253,11 +253,10 @@ defmodule AshStorage.Changes.Attach do
     checksum = :crypto.hash(:md5, data) |> Base.encode64()
     byte_size = byte_size(data)
 
-    with :ok <- service_mod.upload(key, data, ctx) do
+    with {:ok, extra_blob_attrs} <- normalize_upload(service_mod.upload(key, data, ctx)) do
       blob_resource = Info.storage_blob_resource!(resource)
 
-      Ash.create(
-        blob_resource,
+      blob_attrs =
         %{
           key: key,
           filename: filename,
@@ -267,12 +266,17 @@ defmodule AshStorage.Changes.Attach do
           service_name: service_mod,
           service_opts: persistable_service_opts(service_mod, ctx.service_opts),
           metadata: metadata
-        },
-        Keyword.merge(context_opts, action: :create)
-      )
+        }
+        |> Map.merge(extra_blob_attrs)
+
+      Ash.create(blob_resource, blob_attrs, Keyword.merge(context_opts, action: :create))
     end
   end
 
+  defp normalize_upload(:ok), do: {:ok, %{}}
+  defp normalize_upload({:ok, attrs}) when is_map(attrs), do: {:ok, attrs}
+  defp normalize_upload({:error, _} = error), do: error
+
   # -- IO helpers --
 
   defp read_io(%Ash.Type.File{} = file) do

lib/ash_storage/changes/handle_file_argument.ex

@@ -294,11 +294,10 @@ defmodule AshStorage.Changes.HandleFileArgument do
     checksum = :crypto.hash(:md5, data) |> Base.encode64()
     byte_size = byte_size(data)
 
-    with :ok <- service_mod.upload(key, data, ctx) do
+    with {:ok, extra_blob_attrs} <- normalize_upload(service_mod.upload(key, data, ctx)) do
       blob_resource = Info.storage_blob_resource!(resource)
 
-      Ash.create(
-        blob_resource,
+      blob_attrs =
         %{
           key: key,
           filename: filename,
@@ -308,12 +307,17 @@ defmodule AshStorage.Changes.HandleFileArgument do
           service_name: service_mod,
           service_opts: persistable_service_opts(service_mod, ctx.service_opts),
           metadata: %{}
-        },
-        action: :create
-      )
+        }
+        |> Map.merge(extra_blob_attrs)
+
+      Ash.create(blob_resource, blob_attrs, action: :create)
     end
   end
 
+  defp normalize_upload(:ok), do: {:ok, %{}}
+  defp normalize_upload({:ok, attrs}) when is_map(attrs), do: {:ok, attrs}
+  defp normalize_upload({:error, _} = error), do: error
+
   defp read_io(%Ash.Type.File{} = file) do
     {:ok, device} = Ash.Type.File.open(file, [:read, :binary])
     data = IO.binread(device, :eof)

lib/ash_storage/service.ex

@@ -32,9 +32,13 @@ defmodule AshStorage.Service do
 
   @doc """
   Upload a file to the storage service.
+
+  May return `:ok` or `{:ok, extra_blob_attrs}`. When a map is returned, its entries
+  are merged into the blob record on creation. This allows wrapping services (e.g.
+  encryption) to store per-file metadata such as encryption keys on the blob.
   """
   @callback upload(key(), iodata() | File.Stream.t(), Context.t()) ::
-              :ok | {:error, term()}
+              :ok | {:ok, map()} | {:error, term()}
 
   @doc """
   Download a file from the storage service.

lib/ash_storage/variant_generator.ex

@@ -110,9 +110,8 @@ defmodule AshStorage.VariantGenerator do
 
     blob_resource = Info.storage_blob_resource!(resource)
 
-    with :ok <- service_mod.upload(key, variant_data, ctx) do
-      Ash.create(
-        blob_resource,
+    with {:ok, extra_blob_attrs} <- normalize_upload(service_mod.upload(key, variant_data, ctx)) do
+      blob_attrs =
         %{
           key: key,
           filename: variant_filename,
@@ -125,12 +124,17 @@ defmodule AshStorage.VariantGenerator do
           variant_of_blob_id: source_blob.id,
           variant_name: to_string(variant_name),
           variant_digest: digest
-        },
-        action: :create_variant
-      )
+        }
+        |> Map.merge(extra_blob_attrs)
+
+      Ash.create(blob_resource, blob_attrs, action: :create_variant)
     end
   end
 
+  defp normalize_upload(:ok), do: {:ok, %{}}
+  defp normalize_upload({:ok, attrs}) when is_map(attrs), do: {:ok, attrs}
+  defp normalize_upload({:error, _} = error), do: error
+
   defp resolve_service(resource, attachment_def) do
     case Info.service_for_attachment(resource, attachment_def) do
       {:ok, service} -> {:ok, service}

test/ash_storage/extra_blob_attrs_test.exs

@@ -0,0 +1,111 @@
+defmodule AshStorage.ExtraBlobAttrsTest do
+  use ExUnit.Case, async: false
+
+  setup do
+    AshStorage.Service.Test.reset!()
+    :ok
+  end
+
+  defp create_post!(title \\ "test post") do
+    AshStorage.Test.ExtraAttrsPost
+    |> Ash.Changeset.for_create(:create, %{title: title})
+    |> Ash.create!()
+  end
+
+  describe "Operations.attach with extra blob attrs" do
+    test "service returning {:ok, map} merges attrs into blob" do
+      post = create_post!()
+
+      {:ok, %{blob: blob}} =
+        AshStorage.Operations.attach(post, :cover_image, "hello",
+          filename: "hello.txt",
+          content_type: "text/plain"
+        )
+
+      assert blob.metadata["injected"] == "from_service"
+      assert blob.metadata["key"] == blob.key
+    end
+
+    test "service extra attrs merge with caller-provided metadata" do
+      post = create_post!()
+
+      {:ok, %{blob: blob}} =
+        AshStorage.Operations.attach(post, :cover_image, "hello",
+          filename: "hello.txt",
+          metadata: %{"user_tag" => "important"}
+        )
+
+      # Service returns metadata that replaces the caller metadata via Map.merge.
+      # The extra_blob_attrs map has a :metadata key that overwrites the original.
+      # This is expected — the service has final say on the metadata field.
+      assert blob.metadata["injected"] == "from_service"
+    end
+  end
+
+  describe "AttachFile change with extra blob attrs" do
+    test "create action merges service attrs into blob" do
+      path = Path.join(System.tmp_dir!(), "extra_attrs_create.txt")
+      File.write!(path, "create test data")
+
+      post =
+        AshStorage.Test.ExtraAttrsPost
+        |> Ash.Changeset.for_create(:create_with_image, %{
+          title: "with image",
+          cover_image: Ash.Type.File.from_path(path)
+        })
+        |> Ash.create!()
+
+      post = Ash.load!(post, cover_image: :blob)
+      blob = post.cover_image.blob
+
+      assert blob.metadata["injected"] == "from_service"
+      assert blob.metadata["key"] == blob.key
+    after
+      File.rm(Path.join(System.tmp_dir!(), "extra_attrs_create.txt"))
+    end
+
+    test "update action merges service attrs into blob" do
+      post = create_post!()
+
+      path = Path.join(System.tmp_dir!(), "extra_attrs_update.txt")
+      File.write!(path, "update test data")
+
+      post =
+        post
+        |> Ash.Changeset.for_update(:update_cover_image, %{
+          cover_image: Ash.Type.File.from_path(path)
+        })
+        |> Ash.update!()
+
+      post = Ash.load!(post, cover_image: :blob)
+      blob = post.cover_image.blob
+
+      assert blob.metadata["injected"] == "from_service"
+      assert blob.metadata["key"] == blob.key
+    after
+      File.rm(Path.join(System.tmp_dir!(), "extra_attrs_update.txt"))
+    end
+  end
+
+  describe "VariantGenerator with extra blob attrs" do
+    test "eager variant blob gets service extra attrs" do
+      post = create_post!()
+
+      {:ok, %{blob: blob}} =
+        AshStorage.Operations.attach(post, :document, "hello world",
+          filename: "test.txt",
+          content_type: "text/plain"
+        )
+
+      blob = Ash.load!(blob, :variants)
+      variant = Enum.find(blob.variants, &(&1.variant_name == "eager_uppercase"))
+
+      assert variant != nil
+      assert variant.metadata["injected"] == "from_service"
+      assert variant.metadata["key"] == variant.key
+
+      # Verify the variant data was actually uploaded correctly
+      assert {:ok, "HELLO WORLD"} = AshStorage.Service.Test.download(variant.key, [])
+    end
+  end
+end

test/support/domain.ex

@@ -12,5 +12,6 @@ defmodule AshStorage.Test.Domain do
     resource AshStorage.Test.ConfigurablePost
     resource AshStorage.Test.AnalyzablePost
     resource AshStorage.Test.VariantPost
+    resource AshStorage.Test.ExtraAttrsPost
   end
 end

test/support/extra_attrs_post.ex

@@ -0,0 +1,45 @@
+defmodule AshStorage.Test.ExtraAttrsPost do
+  @moduledoc false
+  use Ash.Resource,
+    domain: AshStorage.Test.Domain,
+    data_layer: Ash.DataLayer.Ets,
+    extensions: [AshStorage]
+
+  ets do
+    private? true
+  end
+
+  storage do
+    service({AshStorage.Test.ExtraAttrsService, []})
+    blob_resource(AshStorage.Test.Blob)
+    attachment_resource(AshStorage.Test.PolymorphicAttachment)
+
+    has_one_attached(:cover_image)
+
+    has_one_attached :document do
+      variant(:eager_uppercase, AshStorage.Test.UppercaseVariant, generate: :eager)
+    end
+  end
+
+  attributes do
+    uuid_primary_key :id
+    attribute :title, :string, allow_nil?: false
+  end
+
+  actions do
+    defaults [:read, :destroy, create: [:title], update: [:title]]
+
+    create :create_with_image do
+      accept [:title]
+      argument :cover_image, :file, allow_nil?: true
+
+      change {AshStorage.Changes.AttachFile, argument: :cover_image, attachment: :cover_image}
+    end
+
+    update :update_cover_image do
+      argument :cover_image, :file, allow_nil?: true
+
+      change {AshStorage.Changes.AttachFile, argument: :cover_image, attachment: :cover_image}
+    end
+  end
+end

test/support/extra_attrs_service.ex

@@ -0,0 +1,33 @@
+defmodule AshStorage.Test.ExtraAttrsService do
+  @moduledoc false
+  @behaviour AshStorage.Service
+
+  @doc """
+  A test service wrapper that returns extra blob attributes from upload/3.
+  Delegates storage to the Test service but returns `{:ok, map()}` with
+  additional metadata to verify the extra_blob_attrs merge path.
+  """
+
+  @impl true
+  def upload(key, data, ctx) do
+    case AshStorage.Service.Test.upload(key, data, ctx) do
+      :ok -> {:ok, %{metadata: %{"injected" => "from_service", "key" => key}}}
+      error -> error
+    end
+  end
+
+  @impl true
+  def download(key, ctx), do: AshStorage.Service.Test.download(key, ctx)
+
+  @impl true
+  def delete(key, ctx), do: AshStorage.Service.Test.delete(key, ctx)
+
+  @impl true
+  def exists?(key, ctx), do: AshStorage.Service.Test.exists?(key, ctx)
+
+  @impl true
+  def url(key, ctx), do: AshStorage.Service.Test.url(key, ctx)
+
+  @impl true
+  def direct_upload(key, ctx), do: AshStorage.Service.Test.direct_upload(key, ctx)
+end