add logic and some tests for bundling descriptors

Author: mjheilmann

lib/grpc_reflection/service/builder/util.ex

@@ -163,6 +163,9 @@ defmodule GrpcReflection.Service.Builder.Util do
     []
   end
 
+  # in gRPC, the leading "." signifies it is a FQDN
+  # we trim it and assume everything is a FQDN
+  # it works so far, but there may be corner cases
   def trim_symbol("." <> symbol), do: symbol
   def trim_symbol(symbol), do: symbol
 end

lib/grpc_reflection/service/state.ex

@@ -117,8 +117,72 @@ defmodule GrpcReflection.Service.State do
   end
 
   def group_symbols_by_namespace(%__MODULE__{} = state) do
-    # group symbols by namespace and combine
-    # IO.inspect(state)
-    state
+    state.symbols
+    |> Map.keys()
+    |> Enum.group_by(&GrpcReflection.Service.Builder.Util.get_package(&1))
+    |> Enum.reduce(state, fn {package, symbols}, state_acc ->
+      # each symbol in symbols is in the same package
+      # we will combine their files into a single file, and update them to
+      # reference this new file
+
+      # Step 1: Collect descriptors to be combined
+      symbol_files = Enum.map(symbols, &state.symbols[&1])
+      files_to_combine = state.files |> Map.take(symbol_files) |> Map.values()
+
+      # Step 2: Combine the descriptors
+      combined_file =
+        Enum.reduce(
+          files_to_combine,
+          %Google.Protobuf.FileDescriptorProto{
+            package: package,
+            name: package <> ".proto"
+          },
+          fn descriptor, acc ->
+            %{
+              acc
+              | syntax: descriptor.syntax,
+                message_type: acc.message_type ++ descriptor.message_type,
+                service: acc.service ++ descriptor.service,
+                enum_type: acc.enum_type ++ descriptor.enum_type,
+                dependency: acc.dependency ++ descriptor.dependency,
+                extension: acc.extension ++ descriptor.extension
+            }
+          end
+        )
+
+      # Step 3: remove internal dependency refs
+      cleaned_file =
+        %{combined_file | dependency: combined_file.dependency -- symbol_files}
+
+      # Step 4: rework state around combined descriptor
+      # removing and re-adding symbols pointing to combined file
+      # removing combined file descriptors
+      # editing existing descriptors for relevant dependency entries
+      # add combined file descriptor
+      %{
+        state_acc
+        | symbols:
+            state.symbols
+            |> Map.drop(symbols)
+            |> Map.merge(Map.new(symbols, &{&1, cleaned_file.name})),
+          files:
+            state.files
+            |> Map.drop(symbol_files)
+            |> Map.new(fn {filename, descriptor} ->
+              if Enum.any?(descriptor.dependency, &Enum.member?(symbol_files, &1)) do
+                {
+                  filename,
+                  %{
+                    descriptor
+                    | dependency: (descriptor.dependency -- symbol_files) ++ [cleaned_file.name]
+                  }
+                }
+              else
+                {filename, descriptor}
+              end
+            end)
+            |> Map.put(cleaned_file.name, cleaned_file)
+      }
+    end)
   end
 end

test/service/state_test.exs

@@ -55,4 +55,67 @@ defmodule GrpcReflection.Service.StateTest do
                    fn -> State.merge(state1, state2) end
     end
   end
+
+  describe "group_symbols_by_namespace" do
+    setup do
+      state_with_recursion = %State{
+        services: ["Service1", "Service2"],
+        files: %{
+          "file1.proto" => %Google.Protobuf.FileDescriptorProto{
+            name: "file1.proto",
+            package: ".common.path",
+            dependency: ["file2.proto"],
+            service: ["A"],
+            message_type: [%Google.Protobuf.DescriptorProto{name: "Symbol_a"}],
+            syntax: "proto2"
+          },
+          "file2.proto" => %Google.Protobuf.FileDescriptorProto{
+            name: "file2.proto",
+            package: ".common.path",
+            dependency: ["file1.proto"],
+            service: ["B"],
+            message_type: [%Google.Protobuf.DescriptorProto{name: "Symbol_b"}],
+            syntax: "proto2"
+          },
+          "file3.proto" => %Google.Protobuf.FileDescriptorProto{
+            name: "file3.proto",
+            package: ".other.path",
+            dependency: ["file1.proto", "file2.proto"],
+            service: ["C"],
+            message_type: [%Google.Protobuf.DescriptorProto{name: "Symbol_c"}],
+            syntax: "proto2"
+          }
+        },
+        symbols: %{
+          "common.path.Symbol_a" => "file1.proto",
+          "common.path.Symbol_b" => "file2.proto"
+        }
+      }
+
+      %{
+        state: State.group_symbols_by_namespace(state_with_recursion)
+      }
+    end
+
+    test "should maintain all symbols", %{state: state} do
+      assert Map.keys(state.symbols) == ["common.path.Symbol_a", "common.path.Symbol_b"]
+    end
+
+    test "should reduce and update files", %{state: state} do
+      assert [combined_file, other_file] = Map.values(state.files)
+      # combined file is present as we expect
+      assert combined_file.dependency == []
+      assert combined_file.name == "common.path.proto"
+      # referencing file is updated as we expect
+      assert other_file.dependency == ["common.path.proto"]
+      assert other_file.name == "file3.proto"
+    end
+
+    test "should combine descriptors", %{state: state} do
+      file = state.files["common.path.proto"]
+      symbols = Enum.map(file.message_type, & &1.name)
+      assert symbols == ["Symbol_a", "Symbol_b"]
+      assert file.service == ["A", "B"]
+    end
+  end
 end