feat: add structured Services UI for proxy config generation

Add a Services feature that lets users create/manage proxy services
through forms instead of writing raw KDL. Services are converted to
KDL configuration and can generate bundles for compilation.

- Service schema with route path, upstream/static response, retry,
  cache, rate limit, health check, and header policies
- ProjectConfig schema for global proxy settings (log level, metrics)
- KDL generator that produces valid config from service definitions
- Bundle integration to create bundles from services
- Full CRUD LiveViews (index, new, show, edit) with DaisyUI styling
- Sidebar navigation, dual routing (legacy + org-scoped)
- 53 new tests covering context, KDL generation, and LiveViews

Author: raffaelschneider

lib/sentinel_cp/services.ex

@@ -0,0 +1,119 @@
+defmodule SentinelCp.Services do
+  @moduledoc """
+  The Services context manages proxy service definitions.
+
+  Services are structured representations of proxy routes that can be
+  used to generate KDL configuration for bundles.
+  """
+
+  import Ecto.Query, warn: false
+  alias SentinelCp.Repo
+  alias SentinelCp.Services.{Service, ProjectConfig}
+
+  ## Services
+
+  @doc """
+  Lists services for a project, ordered by position.
+  """
+  def list_services(project_id, opts \\ []) do
+    query =
+      from(s in Service,
+        where: s.project_id == ^project_id,
+        order_by: [asc: s.position, asc: s.inserted_at]
+      )
+
+    query =
+      Enum.reduce(opts, query, fn
+        {:enabled, enabled}, q -> where(q, [s], s.enabled == ^enabled)
+        _, q -> q
+      end)
+
+    Repo.all(query)
+  end
+
+  @doc """
+  Gets a single service by ID.
+  """
+  def get_service(id), do: Repo.get(Service, id)
+
+  @doc """
+  Gets a single service by ID, raises if not found.
+  """
+  def get_service!(id), do: Repo.get!(Service, id)
+
+  @doc """
+  Creates a service.
+  """
+  def create_service(attrs) do
+    %Service{}
+    |> Service.create_changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Updates a service.
+  """
+  def update_service(%Service{} = service, attrs) do
+    service
+    |> Service.update_changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a service.
+  """
+  def delete_service(%Service{} = service) do
+    Repo.delete(service)
+  end
+
+  @doc """
+  Batch updates service positions.
+
+  Accepts a list of `{service_id, position}` tuples.
+  """
+  def reorder_services(project_id, id_position_pairs) do
+    Repo.transaction(fn ->
+      for {id, position} <- id_position_pairs do
+        from(s in Service,
+          where: s.id == ^id and s.project_id == ^project_id
+        )
+        |> Repo.update_all(set: [position: position])
+      end
+
+      :ok
+    end)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking service changes.
+  """
+  def change_service(%Service{} = service, attrs \\ %{}) do
+    Service.update_changeset(service, attrs)
+  end
+
+  ## Project Config
+
+  @doc """
+  Gets or creates the project config for a project.
+  """
+  def get_or_create_project_config(project_id) do
+    case Repo.get_by(ProjectConfig, project_id: project_id) do
+      nil ->
+        %ProjectConfig{}
+        |> ProjectConfig.changeset(%{project_id: project_id})
+        |> Repo.insert()
+
+      config ->
+        {:ok, config}
+    end
+  end
+
+  @doc """
+  Updates the project config.
+  """
+  def update_project_config(%ProjectConfig{} = config, attrs) do
+    config
+    |> ProjectConfig.changeset(attrs)
+    |> Repo.update()
+  end
+end

lib/sentinel_cp/services/bundle_integration.ex

@@ -0,0 +1,50 @@
+defmodule SentinelCp.Services.BundleIntegration do
+  @moduledoc """
+  Integrates structured services with the bundle compilation pipeline.
+
+  Generates KDL from services and creates bundles for compilation.
+  """
+
+  alias SentinelCp.Bundles
+  alias SentinelCp.Services.KdlGenerator
+
+  @doc """
+  Creates a bundle from the project's service definitions.
+
+  Generates KDL configuration from enabled services, then creates a bundle
+  and enqueues compilation.
+
+  Returns `{:ok, bundle}` or `{:error, reason}`.
+  """
+  def create_bundle_from_services(project_id, version, opts \\ []) do
+    case KdlGenerator.generate(project_id) do
+      {:ok, kdl} ->
+        attrs = %{
+          project_id: project_id,
+          version: version,
+          config_source: kdl
+        }
+
+        attrs =
+          if created_by_id = Keyword.get(opts, :created_by_id) do
+            Map.put(attrs, :created_by_id, created_by_id)
+          else
+            attrs
+          end
+
+        Bundles.create_bundle(attrs)
+
+      {:error, :no_services} ->
+        {:error, :no_services}
+    end
+  end
+
+  @doc """
+  Generates a KDL preview without creating a bundle.
+
+  Returns `{:ok, kdl_string}` or `{:error, :no_services}`.
+  """
+  def preview_kdl(project_id) do
+    KdlGenerator.generate(project_id)
+  end
+end

lib/sentinel_cp/services/kdl_generator.ex

@@ -0,0 +1,192 @@
+defmodule SentinelCp.Services.KdlGenerator do
+  @moduledoc """
+  Generates KDL configuration from structured service definitions.
+
+  Pure function module — reads services and project config, produces KDL text.
+  """
+
+  alias SentinelCp.Services
+  alias SentinelCp.Services.{Service, ProjectConfig}
+
+  @doc """
+  Generates KDL configuration for a project from its services and config.
+
+  Returns `{:ok, kdl_string}` or `{:error, :no_services}`.
+  """
+  def generate(project_id) do
+    services = Services.list_services(project_id, enabled: true)
+
+    if services == [] do
+      {:error, :no_services}
+    else
+      {:ok, config} = Services.get_or_create_project_config(project_id)
+      kdl = build_kdl(services, config)
+      {:ok, kdl}
+    end
+  end
+
+  @doc """
+  Generates KDL from provided services and config (no DB access).
+  Useful for testing.
+  """
+  def build_kdl(services, %ProjectConfig{} = config) do
+    parts = [
+      "// Generated by Sentinel Control Plane",
+      "// Do not edit manually — managed via Services UI",
+      "",
+      build_settings(config),
+      "",
+      build_routes(services),
+      build_rate_limits(services)
+    ]
+
+    parts
+    |> List.flatten()
+    |> Enum.join("\n")
+    |> String.trim_trailing()
+    |> Kernel.<>("\n")
+  end
+
+  defp build_settings(%ProjectConfig{} = config) do
+    lines = [
+      "settings {",
+      "    log_level #{inspect(config.log_level)}",
+      "    metrics_port #{config.metrics_port}"
+    ]
+
+    custom_lines =
+      (config.custom_settings || %{})
+      |> Enum.sort_by(fn {k, _} -> k end)
+      |> Enum.map(fn {key, value} -> "    #{key} #{format_value(value)}" end)
+
+    lines ++ custom_lines ++ ["}"]
+  end
+
+  defp build_routes(services) do
+    route_blocks =
+      services
+      |> Enum.map(&build_route/1)
+      |> Enum.intersperse([""])
+
+    ["routes {"] ++ List.flatten(route_blocks) ++ ["}"]
+  end
+
+  defp build_route(%Service{} = service) do
+    lines = ["    route #{inspect(service.route_path)} {"]
+
+    lines =
+      if service.upstream_url do
+        lines ++ ["        upstream #{inspect(service.upstream_url)}"]
+      else
+        lines ++
+          ["        respond #{service.respond_status} #{inspect(service.respond_body || "")}"]
+      end
+
+    lines =
+      if service.timeout_seconds do
+        lines ++ ["        timeout #{service.timeout_seconds}s"]
+      else
+        lines
+      end
+
+    lines = lines ++ build_retry_block(service.retry)
+    lines = lines ++ build_cache_block(service.cache)
+    lines = lines ++ build_health_check_block(service.health_check)
+    lines = lines ++ build_headers_block(service.headers)
+
+    lines ++ ["    }"]
+  end
+
+  defp build_retry_block(retry) when retry == %{} or retry == nil, do: []
+
+  defp build_retry_block(retry) do
+    inner =
+      retry
+      |> Enum.sort_by(fn {k, _} -> k end)
+      |> Enum.map(fn {key, value} -> "            #{key} #{format_value(value)}" end)
+
+    if inner == [] do
+      []
+    else
+      ["        retry {"] ++ inner ++ ["        }"]
+    end
+  end
+
+  defp build_cache_block(cache) when cache == %{} or cache == nil, do: []
+
+  defp build_cache_block(cache) do
+    inner =
+      cache
+      |> Enum.sort_by(fn {k, _} -> k end)
+      |> Enum.map(fn {key, value} -> "            #{key} #{format_value(value)}" end)
+
+    if inner == [] do
+      []
+    else
+      ["        cache {"] ++ inner ++ ["        }"]
+    end
+  end
+
+  defp build_health_check_block(hc) when hc == %{} or hc == nil, do: []
+
+  defp build_health_check_block(hc) do
+    inner =
+      hc
+      |> Enum.sort_by(fn {k, _} -> k end)
+      |> Enum.map(fn {key, value} -> "            #{key} #{format_value(value)}" end)
+
+    if inner == [] do
+      []
+    else
+      ["        health_check {"] ++ inner ++ ["        }"]
+    end
+  end
+
+  defp build_headers_block(headers) when headers == %{} or headers == nil, do: []
+
+  defp build_headers_block(headers) do
+    inner =
+      headers
+      |> Enum.sort_by(fn {k, _} -> k end)
+      |> Enum.map(fn {key, value} -> "            #{key} #{format_value(value)}" end)
+
+    if inner == [] do
+      []
+    else
+      ["        headers {"] ++ inner ++ ["        }"]
+    end
+  end
+
+  defp build_rate_limits(services) do
+    rate_limited =
+      services
+      |> Enum.filter(fn s -> s.rate_limit && s.rate_limit != %{} end)
+
+    if rate_limited == [] do
+      []
+    else
+      blocks =
+        rate_limited
+        |> Enum.map(&build_rate_limit_entry/1)
+        |> Enum.intersperse([""])
+
+      ["", "rate_limits {"] ++ List.flatten(blocks) ++ ["}"]
+    end
+  end
+
+  defp build_rate_limit_entry(%Service{} = service) do
+    inner =
+      service.rate_limit
+      |> Enum.sort_by(fn {k, _} -> k end)
+      |> Enum.map(fn {key, value} -> "        #{key} #{format_value(value)}" end)
+
+    ["    limit #{inspect(service.slug)} {"] ++ inner ++ ["    }"]
+  end
+
+  defp format_value(value) when is_binary(value), do: inspect(value)
+  defp format_value(value) when is_integer(value), do: Integer.to_string(value)
+  defp format_value(value) when is_float(value), do: Float.to_string(value)
+  defp format_value(true), do: "true"
+  defp format_value(false), do: "false"
+  defp format_value(value), do: inspect(value)
+end

lib/sentinel_cp/services/project_config.ex

@@ -0,0 +1,34 @@
+defmodule SentinelCp.Services.ProjectConfig do
+  @moduledoc """
+  ProjectConfig schema storing global proxy settings for a project.
+
+  Maps to the `settings {}` block in generated KDL configuration.
+  """
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :binary_id, autogenerate: true}
+  @foreign_key_type :binary_id
+
+  @log_levels ~w(trace debug info warn error)
+
+  schema "project_configs" do
+    field :log_level, :string, default: "info"
+    field :metrics_port, :integer, default: 9090
+    field :custom_settings, :map, default: %{}
+
+    belongs_to :project, SentinelCp.Projects.Project
+
+    timestamps(type: :utc_datetime)
+  end
+
+  def changeset(config, attrs) do
+    config
+    |> cast(attrs, [:log_level, :metrics_port, :custom_settings, :project_id])
+    |> validate_required([:project_id])
+    |> validate_inclusion(:log_level, @log_levels)
+    |> validate_number(:metrics_port, greater_than: 0, less_than: 65536)
+    |> unique_constraint(:project_id)
+    |> foreign_key_constraint(:project_id)
+  end
+end