feat: Detour controller updates for single detour

assets/src/api.ts

@@ -53,8 +53,17 @@ import {
 } from "./models/locationSearchSuggestionData"
 import { LocationSearchSuggestion } from "./models/locationSearchSuggestion"
 import { DetourShapeData, detourShapeFromData } from "./models/detourShapeData"
-import { groupedDetoursFromData, GroupedSimpleDetours } from "./models/detour"
-import { DetourShape, FinishedDetour, UnfinishedDetour } from "./models/detour"
+import {
+  groupedDetoursFromData,
+  GroupedSimpleDetours,
+} from "./models/detoursList"
+import {
+  DetourShape,
+  detourStateFromData,
+  DetourWithState,
+  FinishedDetour,
+  UnfinishedDetour,
+} from "./models/detour"
 import {
   FinishedDetourData,
   finishedDetourFromData,
@@ -510,6 +519,8 @@ export const putRouteTabs = (routeTabs: RouteTab[]): Promise<Response> =>
     body: JSON.stringify({ route_tabs: routeTabs }),
   })
 
+// #region Detour API functions
+
 export const putDetourUpdate = (
   snapshot: Snapshot<unknown>
 ): Promise<Result<number, never>> =>
@@ -529,12 +540,24 @@ export const putDetourUpdate = (
 
 export const fetchDetours = (): Promise<Result<GroupedSimpleDetours, never>> =>
   apiCallResult({
-    url: `/api/detours/get_detours`,
+    url: `/api/detours`,
     OkStruct: GroupedSimpleDetours,
     ErrStruct: never(),
     parser: groupedDetoursFromData,
   })
 
+export const fetchDetour = (
+  id: number
+): Promise<Result<DetourWithState, never>> =>
+  apiCallResult({
+    url: `/api/detours/${id}`,
+    OkStruct: DetourWithState,
+    ErrStruct: never(),
+    parser: detourStateFromData,
+  })
+
+// #endregion Detour API functions
+
 const getCsrfToken = (): string => appData()?.csrfToken || ""
 
 export const nullableParser =

assets/src/components/detoursTable.tsx

@@ -3,7 +3,7 @@ import { Table } from "react-bootstrap"
 import { RoutePill } from "./routePill"
 import { useCurrentTimeSeconds } from "../hooks/useCurrentTime"
 import { timeAgoLabel } from "../util/dateTime"
-import { SimpleDetour } from "../models/detour"
+import { SimpleDetour } from "../models/detoursList"
 
 interface DetoursTableProps {
   data: SimpleDetour[]

assets/src/models/detour.ts

@@ -1,64 +1,30 @@
 import { LatLngLiteral } from "leaflet"
 import { ShapePoint, Stop } from "../schedule"
 import { CreateDetourMachineInput } from "./createDetourMachine"
-import { array, Infer, nullable, number, string, type } from "superstruct"
+import { any, Infer, number, string, type } from "superstruct"
 
-export const SimpleDetour = type({
-  route: string(),
-  direction: string(),
-  name: string(),
-  intersection: string(),
+export const DetourWithState = type({
+  author: string(),
+  state: any(),
   updatedAt: number(),
 })
 
-export type SimpleDetour = Infer<typeof SimpleDetour>
+export type DetourWithState = Infer<typeof DetourWithState>
 
-export const SimpleDetourFromApi = type({
-  route: string(),
-  direction: string(),
-  name: string(),
-  intersection: string(),
+export const DetourWithStateFromApi = type({
+  author: string(),
+  state: any(),
   updated_at: number(),
 })
 
-export type SimpleDetourFromApi = Infer<typeof SimpleDetourFromApi>
+export type DetourWithStateFromApi = Infer<typeof DetourWithStateFromApi>
 
-const simpleDetourFromData = (
-  detourData: SimpleDetourFromApi
-): SimpleDetour => ({
-  route: detourData.route,
-  direction: detourData.direction,
-  name: detourData.name,
-  intersection: detourData.intersection,
-  updatedAt: detourData.updated_at,
-})
-
-export const GroupedSimpleDetours = type({
-  active: nullable(array(SimpleDetour)),
-  draft: nullable(array(SimpleDetour)),
-  past: nullable(array(SimpleDetour)),
-})
-
-export type GroupedSimpleDetours = Infer<typeof GroupedSimpleDetours>
-
-export const GroupedDetoursFromApi = type({
-  active: nullable(array(SimpleDetourFromApi)),
-  draft: nullable(array(SimpleDetourFromApi)),
-  past: nullable(array(SimpleDetourFromApi)),
-})
-
-export type GroupedDetoursFromApi = Infer<typeof GroupedDetoursFromApi>
-
-export const groupedDetoursFromData = (
-  groupedDetours: GroupedDetoursFromApi
-): GroupedSimpleDetours => ({
-  active:
-    groupedDetours.active?.map((detour) => simpleDetourFromData(detour)) ||
-    null,
-  draft:
-    groupedDetours.draft?.map((detour) => simpleDetourFromData(detour)) || null,
-  past:
-    groupedDetours.past?.map((detour) => simpleDetourFromData(detour)) || null,
+export const detourStateFromData = (
+  detourWithState: DetourWithStateFromApi
+): DetourWithState => ({
+  author: detourWithState.author,
+  state: detourWithState.state,
+  updatedAt: detourWithState.updated_at,
 })
 
 export interface DetourShape {

assets/src/models/detoursList.ts

@@ -0,0 +1,62 @@
+import { array, Infer, nullable, number, string, type } from "superstruct"
+
+export const SimpleDetour = type({
+  uuid: number(),
+  route: string(),
+  direction: string(),
+  name: string(),
+  intersection: string(),
+  updatedAt: number(),
+})
+
+export type SimpleDetour = Infer<typeof SimpleDetour>
+
+export const SimpleDetourFromApi = type({
+  uuid: number(),
+  route: string(),
+  direction: string(),
+  name: string(),
+  intersection: string(),
+  updated_at: number(),
+})
+
+export type SimpleDetourFromApi = Infer<typeof SimpleDetourFromApi>
+
+export const simpleDetourFromData = (
+  detourData: SimpleDetourFromApi
+): SimpleDetour => ({
+  uuid: detourData.uuid,
+  route: detourData.route,
+  direction: detourData.direction,
+  name: detourData.name,
+  intersection: detourData.intersection,
+  updatedAt: detourData.updated_at,
+})
+
+export const GroupedSimpleDetours = type({
+  active: nullable(array(SimpleDetour)),
+  draft: nullable(array(SimpleDetour)),
+  past: nullable(array(SimpleDetour)),
+})
+
+export type GroupedSimpleDetours = Infer<typeof GroupedSimpleDetours>
+
+export const GroupedDetoursFromApi = type({
+  active: nullable(array(SimpleDetourFromApi)),
+  draft: nullable(array(SimpleDetourFromApi)),
+  past: nullable(array(SimpleDetourFromApi)),
+})
+
+export type GroupedDetoursFromApi = Infer<typeof GroupedDetoursFromApi>
+
+export const groupedDetoursFromData = (
+  groupedDetours: GroupedDetoursFromApi
+): GroupedSimpleDetours => ({
+  active:
+    groupedDetours.active?.map((detour) => simpleDetourFromData(detour)) ||
+    null,
+  draft:
+    groupedDetours.draft?.map((detour) => simpleDetourFromData(detour)) || null,
+  past:
+    groupedDetours.past?.map((detour) => simpleDetourFromData(detour)) || null,
+})

assets/tests/components/detourListPage.test.tsx

@@ -20,13 +20,15 @@ describe("DetourListPage", () => {
       Ok({
         active: [
           {
+            uuid: 1,
             route: "1",
             direction: "Inbound",
             name: "Headsign A",
             intersection: "Street A & Avenue B",
             updatedAt: 1724866392,
           },
           {
+            uuid: 8,
             route: "2",
             direction: "Outbound",
             name: "Headsign B",
@@ -37,13 +39,15 @@ describe("DetourListPage", () => {
         draft: null,
         past: [
           {
+            uuid: 10,
             route: "1",
             direction: "Inbound",
             name: "Headsign A",
             intersection: "Street E & Avenue F",
             updatedAt: 1724866392,
           },
           {
+            uuid: 7,
             route: "1",
             direction: "Outbound",
             name: "Headsign Z",

lib/skate/detours/detour.ex

@@ -0,0 +1,53 @@
+defmodule Skate.Detours.Detour do
+  @moduledoc """
+  Modules for different detour structures that can be read from the db
+  """
+
+  defmodule Detailed do
+    @moduledoc """
+    Detailed detours have had the db detour state parsed into attributes
+    """
+    @type t :: %__MODULE__{
+            uuid: integer(),
+            route: String.t(),
+            direction: String.t(),
+            name: String.t(),
+            intersection: String.t(),
+            updated_at: integer(),
+            author_id: integer(),
+            status: :active | :draft | :past
+          }
+
+    @derive Jason.Encoder
+
+    defstruct [
+      :uuid,
+      :route,
+      :direction,
+      :name,
+      :intersection,
+      :updated_at,
+      :author_id,
+      :status
+    ]
+  end
+
+  defmodule WithState do
+    @moduledoc """
+    Detours WithState have had their state left intact
+    """
+    @type t :: %__MODULE__{
+            author: String.t(),
+            state: map(),
+            updated_at: integer()
+          }
+
+    @derive Jason.Encoder
+
+    defstruct [
+      :author,
+      :state,
+      :updated_at
+    ]
+  end
+end