feat: RoutePatterns table, part 1: Adding to db

lib/skate/detours/db/detour.ex

@@ -7,10 +7,12 @@ defmodule Skate.Detours.Db.Detour do
   import Ecto.Changeset
 
   alias Skate.Settings.Db.User
+  alias Skate.Detours.Db.RoutePattern
 
   typed_schema "detours" do
     field :state, :map
     belongs_to :author, User
+    belongs_to :route_pattern, RoutePattern
 
     timestamps()
   end

lib/skate/detours/db/route_pattern.ex

@@ -0,0 +1,54 @@
+# Should this live here under detours?
+# I don't like how the db folders are scattered throughout /lib subdirectories.
+# I'd rather they all live in one subfolder. 
+# Example: there's db files in /notifications and /skate/detours and /skate/settings, etc
+defmodule Skate.Detours.Db.RoutePattern do
+  @moduledoc """
+  Ecto Model for `route_patterns` Database table
+  """
+
+  use Skate.Schema
+  import Ecto.Changeset
+
+  alias Skate.Detours.Db.Detour
+  alias Skate.Detours.DirectionName
+
+  @required_fields [
+    :hash,
+    :gtfs_route_pattern_id,
+    :gtfs_route_pattern_name,
+    :gtfs_route_pattern_headsign,
+    # :gtfs_route_pattern_shape,
+    :gtfs_route_pattern_direction_name,
+    :gtfs_route_id,
+    :gtfs_route_name
+  ]
+
+  typed_schema "route_patterns" do
+    field(:hash, :integer)
+    field(:gtfs_route_pattern_id, :string)
+    field(:gtfs_route_pattern_name, :string)
+    field(:gtfs_route_pattern_headsign, :string)
+    field(:gtfs_route_pattern_direction_name, DirectionName)
+
+    # The given route pattern will always have the given route
+    # Does it need to be stored here as well?
+    field(:gtfs_route_id, :string)
+    field(:gtfs_route_name, :string)
+
+    field(:gtfs_route_pattern_time_description, :string)
+
+    # To be added: gtfs_route_pattern_shape (separate table)
+
+    has_many(:detours, Detour)
+
+    timestamps()
+  end
+
+  def changeset(route_pattern, attrs \\ %{}) do
+    route_pattern
+    |> cast(attrs, @required_fields, [:gtfs_route_pattern_time_description])
+    |> validate_required(@required_fields)
+    |> unique_constraint([:hash], name: :route_patterns_unique_index)
+  end
+end

lib/skate/detours/detours.ex

@@ -6,6 +6,7 @@ defmodule Skate.Detours.Detours do
   import Ecto.Query, warn: false
   alias Skate.Repo
   alias Skate.Detours.Db.Detour
+  alias Skate.Detours.Db.RoutePattern
   alias Skate.Detours.SnapshotSerde
   alias Skate.Detours.Detour.Detailed, as: DetailedDetour
   alias Skate.Detours.Detour.WithState, as: DetourWithState
@@ -198,18 +199,18 @@ defmodule Skate.Detours.Detours do
   """
   def upsert_from_snapshot(author_id, %{} = snapshot) do
     previous_record =
-      case Skate.Detours.SnapshotSerde.id_from_snapshot(snapshot) do
+      case SnapshotSerde.id_from_snapshot(snapshot) do
         nil -> nil
         id -> Skate.Repo.get(Detour, id)
       end
 
     detour_db_result =
       author_id
-      |> Skate.Detours.SnapshotSerde.deserialize(snapshot)
+      |> SnapshotSerde.deserialize(snapshot)
       |> Skate.Repo.insert(
         returning: true,
         conflict_target: [:id],
-        on_conflict: {:replace, [:state, :updated_at]}
+        on_conflict: {:replace, [:state, :updated_at, :route_pattern_id]}
       )
 
     case detour_db_result do
@@ -223,6 +224,24 @@ defmodule Skate.Detours.Detours do
     detour_db_result
   end
 
+  @doc """
+  Retrieve or insert-and-return a route_pattern given a deserialized route_pattern.
+  """
+  def get_or_create_route_pattern(route_pattern) do
+    route_pattern_hash = Map.get(route_pattern, :hash)
+
+    case Skate.Repo.get_by(RoutePattern, hash: route_pattern_hash) do
+      nil ->
+        Skate.Repo.insert!(
+          route_pattern,
+          returning: true
+        )
+
+      existing_route_pattern ->
+        existing_route_pattern
+    end
+  end
+
   @doc """
   Retrieves a `Skate.Detours.Db.Detour` from the database by it's ID and then resolves the
   detour's category via `categorize_detour/2`

lib/skate/detours/direction_name.ex

@@ -0,0 +1,29 @@
+defmodule Skate.Detours.DirectionName do
+  @moduledoc false
+
+  use Ecto.Type
+
+  @type t :: String.t()
+
+  @valid_directions ["Inbound", "Outbound"]
+
+  @impl true
+  def type, do: :string
+
+  @impl true
+  def cast(direction), do: allow_valid_direction(direction)
+
+  @impl true
+  def load(direction), do: allow_valid_direction(direction)
+
+  @impl true
+  def dump(direction), do: allow_valid_direction(direction)
+
+  defp allow_valid_direction(direction) do
+    if direction in @valid_directions do
+      {:ok, direction}
+    else
+      :error
+    end
+  end
+end

lib/skate/detours/snapshot_serde.ex

@@ -12,11 +12,17 @@ defmodule Skate.Detours.SnapshotSerde do
   Converts a XState JSON Snapshot to Detours Database Changeset
   """
   def deserialize(user_id, %{} = snapshot) do
+    route_pattern =
+      snapshot
+      |> deserialize_route_pattern()
+      |> Skate.Detours.Detours.get_or_create_route_pattern()
+
     Skate.Detours.Db.Detour.changeset(
       %Skate.Detours.Db.Detour{
         # `id` is `nil` by default, so a `nil` `id` should be fine
         id: id_from_snapshot(snapshot),
-        author_id: user_id
+        author_id: user_id,
+        route_pattern_id: Map.get(route_pattern, :id)
       },
       %{
         # Save Snapshot to DB until we've fully transitioned to serializing
@@ -32,6 +38,41 @@ defmodule Skate.Detours.SnapshotSerde do
   def id_from_snapshot(%{"context" => %{"uuid" => id}}), do: id
   def id_from_snapshot(%{"context" => %{}}), do: nil
 
+  # Converts the RoutePattern from a XState Snapshot to ready for DB insertion
+  defp deserialize_route_pattern(%{
+         "context" => %{
+           "route" =>
+             %{
+               "id" => route_id,
+               "name" => route_name,
+               "directionNames" => direction_map
+             } = route,
+           "routePattern" =>
+             %{
+               "id" => route_pattern_id,
+               "name" => route_pattern_name,
+               "headsign" => headsign,
+               "directionId" => direction_id,
+               "timeDescription" => time_description
+             } = routePattern
+         }
+       }) do
+    direction_name = direction_map[Integer.to_string(direction_id)]
+
+    %Skate.Detours.Db.RoutePattern{
+      hash: route_pattern_hash(Map.merge(route, routePattern)),
+      gtfs_route_pattern_id: route_pattern_id,
+      gtfs_route_pattern_name: route_pattern_name,
+      gtfs_route_pattern_headsign: headsign,
+      gtfs_route_pattern_direction_name: direction_name,
+      gtfs_route_id: route_id,
+      gtfs_route_name: route_name,
+      gtfs_route_pattern_time_description: time_description
+    }
+  end
+
+  defp route_pattern_hash(map), do: :erlang.phash2(map)
+
   @doc """
   Builds XState Snapshot from Detours Database object
   """

priv/repo/migrations/20241112190520_create_route_patterns_table.exs

@@ -0,0 +1,27 @@
+defmodule Skate.Repo.Migrations.CreateRoutePatternsTable do
+  use Ecto.Migration
+
+  def change do
+    execute("CREATE TYPE direction_name AS ENUM ('Inbound', 'Outbound')")
+
+    create table(:route_patterns) do
+      add :hash, :integer
+      add :gtfs_route_pattern_id, :string
+      add :gtfs_route_pattern_name, :string
+      add :gtfs_route_pattern_headsign, :string
+      add :gtfs_route_pattern_direction_name, :direction_name
+      add :gtfs_route_id, :string
+      add :gtfs_route_name, :string
+      add :gtfs_route_pattern_time_description, :string
+      timestamps()
+    end
+
+    create(
+      unique_index(
+        :route_patterns,
+        [:hash],
+        name: :route_patterns_unique_index
+      )
+    )
+  end
+end

priv/repo/migrations/20241112235628_detour_has_one_route_pattern.exs

@@ -0,0 +1,9 @@
+defmodule Skate.Repo.Migrations.DetourHasOneRoutePattern do
+  use Ecto.Migration
+
+  def change do
+    alter table(:detours) do
+      add :route_pattern_id, references(:route_patterns)
+    end
+  end
+end