feat: add grpc, websocket, graphql, and streaming service types

Extend the service type system with four new types following the same
pattern as inference. Each type has its own config map field with
validation (required when active, empty when inactive). Includes
built-in templates, KDL generation, config export/import, and tests.

Author: raffaelschneider

lib/sentinel_cp/config_export.ex

@@ -214,6 +214,10 @@ defmodule SentinelCp.ConfigExport do
       |> maybe_add("compression", s.compression, %{})
       |> maybe_add("security", s.security, %{})
       |> maybe_add("inference", s.inference, %{})
+      |> maybe_add("grpc", s.grpc, %{})
+      |> maybe_add("websocket", s.websocket, %{})
+      |> maybe_add("graphql", s.graphql, %{})
+      |> maybe_add("streaming", s.streaming, %{})
     end)
   end
 
@@ -295,7 +299,11 @@ defmodule SentinelCp.ConfigExport do
           enabled: Map.get(svc_data, "enabled", true),
           position: Map.get(svc_data, "position", 0),
           service_type: Map.get(svc_data, "service_type", "standard"),
-          inference: Map.get(svc_data, "inference", %{})
+          inference: Map.get(svc_data, "inference", %{}),
+          grpc: Map.get(svc_data, "grpc", %{}),
+          websocket: Map.get(svc_data, "websocket", %{}),
+          graphql: Map.get(svc_data, "graphql", %{}),
+          streaming: Map.get(svc_data, "streaming", %{})
         }
 
         case SentinelCp.Services.create_service(attrs) do

lib/sentinel_cp/services/built_in_templates.ex

@@ -123,6 +123,78 @@ defmodule SentinelCp.Services.BuiltInTemplates do
       },
       is_builtin: true,
       version: 1
+    },
+    %{
+      name: "gRPC Gateway",
+      category: "grpc",
+      description: "gRPC gateway with reflection and health checking.",
+      template_data: %{
+        "upstream_url" => "http://grpc-backend:9090",
+        "route_path" => "/grpc/*",
+        "service_type" => "grpc",
+        "grpc" => %{
+          "max_message_size" => 4_194_304,
+          "reflection" => "true",
+          "health_check_service" => "grpc.health.v1.Health"
+        }
+      },
+      is_builtin: true,
+      version: 1
+    },
+    %{
+      name: "WebSocket Gateway",
+      category: "websocket",
+      description: "WebSocket gateway with connection management and ping/pong.",
+      template_data: %{
+        "upstream_url" => "http://ws-backend:8080",
+        "route_path" => "/ws/*",
+        "service_type" => "websocket",
+        "timeout_seconds" => 300,
+        "websocket" => %{
+          "ping_interval" => 30,
+          "max_message_size" => 65_536,
+          "max_connections" => 10_000
+        }
+      },
+      is_builtin: true,
+      version: 1
+    },
+    %{
+      name: "GraphQL Gateway",
+      category: "graphql",
+      description: "GraphQL gateway with depth limiting, complexity analysis, and introspection control.",
+      template_data: %{
+        "upstream_url" => "http://graphql-backend:4000",
+        "route_path" => "/graphql",
+        "service_type" => "graphql",
+        "graphql" => %{
+          "max_depth" => 10,
+          "max_complexity" => 1000,
+          "introspection" => "true",
+          "persisted_queries" => "false"
+        }
+      },
+      is_builtin: true,
+      version: 1
+    },
+    %{
+      name: "SSE Streaming Service",
+      category: "streaming",
+      description: "Server-Sent Events streaming service with keepalive and buffering.",
+      template_data: %{
+        "upstream_url" => "http://streaming-backend:8080",
+        "route_path" => "/events/*",
+        "service_type" => "streaming",
+        "timeout_seconds" => 600,
+        "streaming" => %{
+          "format" => "sse",
+          "keepalive_interval" => 15,
+          "max_connection_duration" => 3600,
+          "buffer_size" => 1024
+        }
+      },
+      is_builtin: true,
+      version: 1
     }
   ]
 

lib/sentinel_cp/services/kdl_generator.ex

@@ -62,7 +62,8 @@ defmodule SentinelCp.Services.KdlGenerator do
   defp resolve_service_configs(services, project_id, environment) do
     config_fields = [:headers, :cors, :cache, :retry, :rate_limit, :health_check,
                      :access_control, :compression, :security, :request_transform,
-                     :response_transform, :path_rewrite, :inference]
+                     :response_transform, :path_rewrite, :inference,
+                     :grpc, :websocket, :graphql, :streaming]
 
     Enum.reduce_while(services, {:ok, []}, fn service, {:ok, acc} ->
       case resolve_service_config_maps(service, config_fields, project_id, environment) do
@@ -267,6 +268,10 @@ defmodule SentinelCp.Services.KdlGenerator do
     lines = lines ++ build_response_transform_block(service.response_transform)
     lines = lines ++ build_traffic_split_block(service.traffic_split, group_map)
     lines = lines ++ build_inference_block(service.inference)
+    lines = lines ++ build_grpc_block(service.grpc)
+    lines = lines ++ build_websocket_block(service.websocket)
+    lines = lines ++ build_graphql_block(service.graphql)
+    lines = lines ++ build_streaming_block(service.streaming)
 
     # Append middleware chain blocks (after inline fields)
     lines = lines ++ build_middleware_chain(middleware_chain)
@@ -510,6 +515,18 @@ defmodule SentinelCp.Services.KdlGenerator do
     lines ++ ["        }"]
   end
 
+  defp build_grpc_block(g) when g == %{} or g == nil, do: []
+  defp build_grpc_block(g), do: build_nested_map_block(g, "grpc", "        ")
+
+  defp build_websocket_block(ws) when ws == %{} or ws == nil, do: []
+  defp build_websocket_block(ws), do: build_nested_map_block(ws, "websocket", "        ")
+
+  defp build_graphql_block(gql) when gql == %{} or gql == nil, do: []
+  defp build_graphql_block(gql), do: build_nested_map_block(gql, "graphql", "        ")
+
+  defp build_streaming_block(s) when s == %{} or s == nil, do: []
+  defp build_streaming_block(s), do: build_nested_map_block(s, "streaming", "        ")
+
   defp build_inference_sub_block(nil, _name), do: []
   defp build_inference_sub_block(map, _name) when map == %{}, do: []
 

lib/sentinel_cp/services/service.ex

@@ -36,6 +36,10 @@ defmodule SentinelCp.Services.Service do
     field :traffic_split, :map, default: %{}
     field :service_type, :string, default: "standard"
     field :inference, :map, default: %{}
+    field :grpc, :map, default: %{}
+    field :websocket, :map, default: %{}
+    field :graphql, :map, default: %{}
+    field :streaming, :map, default: %{}
     field :redirect_url, :string
 
     belongs_to :project, SentinelCp.Projects.Project
@@ -78,6 +82,10 @@ defmodule SentinelCp.Services.Service do
       :traffic_split,
       :service_type,
       :inference,
+      :grpc,
+      :websocket,
+      :graphql,
+      :streaming,
       :redirect_url,
       :upstream_group_id,
       :certificate_id,
@@ -90,8 +98,8 @@ defmodule SentinelCp.Services.Service do
     |> validate_length(:name, min: 1, max: 100)
     |> validate_route_path()
     |> validate_route_type()
-    |> validate_inclusion(:service_type, ~w(standard inference))
-    |> validate_inference_config()
+    |> validate_inclusion(:service_type, ~w(standard inference grpc websocket graphql streaming))
+    |> validate_service_type_config()
     |> generate_slug()
     |> validate_slug()
     |> unique_constraint([:project_id, :slug], error_key: :slug)
@@ -125,6 +133,10 @@ defmodule SentinelCp.Services.Service do
       :traffic_split,
       :service_type,
       :inference,
+      :grpc,
+      :websocket,
+      :graphql,
+      :streaming,
       :redirect_url,
       :upstream_group_id,
       :certificate_id,
@@ -136,36 +148,68 @@ defmodule SentinelCp.Services.Service do
     |> validate_length(:name, min: 1, max: 100)
     |> validate_route_path()
     |> validate_route_type()
-    |> validate_inclusion(:service_type, ~w(standard inference))
-    |> validate_inference_config()
+    |> validate_inclusion(:service_type, ~w(standard inference grpc websocket graphql streaming))
+    |> validate_service_type_config()
   end
 
-  defp validate_inference_config(changeset) do
+  @type_config_fields %{
+    "inference" => :inference,
+    "grpc" => :grpc,
+    "websocket" => :websocket,
+    "graphql" => :graphql,
+    "streaming" => :streaming
+  }
+
+  defp validate_service_type_config(changeset) do
     service_type = get_field(changeset, :service_type)
-    inference = get_field(changeset, :inference)
 
-    case service_type do
-      "inference" ->
-        cond do
-          not is_map(inference) or inference == %{} ->
-            add_error(changeset, :inference, "is required when service_type is inference")
+    # Validate the active type's config is present
+    changeset = validate_active_type_config(changeset, service_type)
 
-          Map.get(inference, "provider") not in ~w(openai anthropic generic) ->
-            add_error(changeset, :inference, "must include a valid provider (openai, anthropic, generic)")
+    # Validate all inactive type configs are empty
+    Enum.reduce(@type_config_fields, changeset, fn {type, field}, cs ->
+      if type != service_type do
+        value = get_field(cs, field)
 
-          true ->
-            changeset
-        end
-
-      _ ->
-        if is_map(inference) and inference != %{} do
-          add_error(changeset, :inference, "must be empty for standard services")
+        if is_map(value) and value != %{} do
+          add_error(cs, field, "must be empty when service_type is not #{type}")
         else
-          changeset
+          cs
         end
+      else
+        cs
+      end
+    end)
+  end
+
+  defp validate_active_type_config(changeset, "inference") do
+    inference = get_field(changeset, :inference)
+
+    cond do
+      not is_map(inference) or inference == %{} ->
+        add_error(changeset, :inference, "is required when service_type is inference")
+
+      Map.get(inference, "provider") not in ~w(openai anthropic generic) ->
+        add_error(changeset, :inference, "must include a valid provider (openai, anthropic, generic)")
+
+      true ->
+        changeset
     end
   end
 
+  defp validate_active_type_config(changeset, type) when type in ~w(grpc websocket graphql streaming) do
+    field = Map.fetch!(@type_config_fields, type)
+    value = get_field(changeset, field)
+
+    if not is_map(value) or value == %{} do
+      add_error(changeset, field, "is required when service_type is #{type}")
+    else
+      changeset
+    end
+  end
+
+  defp validate_active_type_config(changeset, _standard), do: changeset
+
   defp validate_route_path(changeset) do
     validate_format(changeset, :route_path, ~r/^\//, message: "must start with /")
   end

lib/sentinel_cp/services/service_template.ex

@@ -11,7 +11,7 @@ defmodule SentinelCp.Services.ServiceTemplate do
   @primary_key {:id, :binary_id, autogenerate: true}
   @foreign_key_type :binary_id
 
-  @categories ~w(api web websocket static auth utility inference)
+  @categories ~w(api web websocket static auth utility inference grpc graphql streaming)
 
   schema "service_templates" do
     field :name, :string

priv/repo/migrations/20260213140002_add_service_type_configs.exs

@@ -0,0 +1,12 @@
+defmodule SentinelCp.Repo.Migrations.AddServiceTypeConfigs do
+  use Ecto.Migration
+
+  def change do
+    alter table(:services) do
+      add :grpc, :map, default: %{}
+      add :websocket, :map, default: %{}
+      add :graphql, :map, default: %{}
+      add :streaming, :map, default: %{}
+    end
+  end
+end

test/sentinel_cp/config_export_test.exs

@@ -198,6 +198,36 @@ defmodule SentinelCp.ConfigExportTest do
     end
   end
 
+  describe "typed service export/import" do
+    test "exports and imports grpc service config", %{project: project} do
+      {:ok, _} =
+        SentinelCp.Services.create_service(%{
+          project_id: project.id,
+          name: "grpc-gateway",
+          route_path: "/grpc/*",
+          upstream_url: "http://grpc:9090",
+          service_type: "grpc",
+          grpc: %{"max_message_size" => 4_194_304, "reflection" => "true"}
+        })
+
+      {:ok, config} = ConfigExport.export(project.id)
+
+      svc = Enum.find(config["services"], &(&1["name"] == "grpc-gateway"))
+      assert svc["service_type"] == "grpc"
+      assert svc["grpc"]["max_message_size"] == 4_194_304
+
+      # Import into a new project
+      project2 = project_fixture()
+      {:ok, summary} = ConfigExport.import_config(project2.id, config)
+      assert summary.created >= 1
+
+      services = SentinelCp.Services.list_services(project2.id)
+      imported = Enum.find(services, &(&1.name == "grpc-gateway"))
+      assert imported.service_type == "grpc"
+      assert imported.grpc["max_message_size"] == 4_194_304
+    end
+  end
+
   # ─── 18.4 GraphQL Schema ────────────────────────────────────────
 
   describe "GraphQL schema" do