feat: Removes base routes and goes back to separated routes.

Sources/App/Controllers/ApiController.swift

@@ -38,21 +38,17 @@ extension ApiRoute.EmployeeRoute {
     case let .delete(id: id):
       try await database.employees.delete(id)
       return HTTPStatus.ok
-
+    case let .create(employee):
-    case let .base(route):
+      return try await database.employees.create(employee)
-      switch route {
+    case .index:
-      case let .create(employee):
+      return try await database.employees.fetchAll()
-        return try await database.employees.create(employee)
+    case let .get(id: id):
-      case .index:
+      guard let employee = try await database.employees.get(id) else {
-        return try await database.employees.fetchAll()
+        throw Abort(.badRequest, reason: "Employee not found")
-      case let .get(id: id):
-        guard let employee = try await database.employees.get(id) else {
-          throw Abort(.badRequest, reason: "Employee not found")
-        }
-        return employee
-      case let .update(id: id, updates: updates):
-        return try await database.employees.update(id, updates)
       }
+      return employee
+    case let .update(id: id, updates: updates):
+      return try await database.employees.update(id, updates)
     }
   }
 }
@@ -65,20 +61,17 @@ extension ApiRoute.PurchaseOrderRoute {
     case let .delete(id: id):
       try await purchaseOrders.delete(id)
       return HTTPStatus.ok
-    case let .base(route):
+    case .index:
-      switch route {
+      return try await purchaseOrders.fetchAll()
-      case .index:
+    case let .create(purchaseOrder):
-        return try await purchaseOrders.fetchAll()
+      return try await purchaseOrders.create(purchaseOrder)
-      case let .create(purchaseOrder):
+    case let .get(id: id):
-        return try await purchaseOrders.create(purchaseOrder)
+      guard let output = try await purchaseOrders.get(id) else {
-      case let .get(id: id):
+        throw Abort(.badRequest, reason: "Purchase order not found.")
-        guard let output = try await purchaseOrders.get(id) else {
-          throw Abort(.badRequest, reason: "Purchase order not found.")
-        }
-        return output
-      case let .page(page: page, limit: limit):
-        return try await purchaseOrders.fetchPage(.init(page: page, per: limit))
       }
+      return output
+    case let .page(page: page, limit: limit):
+      return try await purchaseOrders.fetchPage(.init(page: page, per: limit))
     }
   }
 }
@@ -92,23 +85,19 @@ extension ApiRoute.UserRoute {
     case let .delete(id: id):
       try await users.delete(id)
       return HTTPStatus.ok
-
+    case let .create(user):
-    case let .base(route):
+      return try await users.create(user)
-      switch route {
+    case .index:
-      case let .create(user):
+      return try await users.fetchAll()
-        return try await users.create(user)
+    case let .get(id: id):
-      case .index:
+      guard let user = try await users.get(id) else {
-        return try await users.fetchAll()
+        throw Abort(.badRequest, reason: "Employee not found")
-      case let .get(id: id):
-        guard let user = try await users.get(id) else {
-          throw Abort(.badRequest, reason: "Employee not found")
-        }
-        return user
-      // case let .login(user):
-      //   return try await users.login(user)
-      case let .update(id: id, updates: updates):
-        return try await users.update(id, updates)
       }
+      return user
+    // case let .login(user):
+    //   return try await users.login(user)
+    case let .update(id: id, updates: updates):
+      return try await users.update(id, updates)
     }
   }
 }
@@ -120,24 +109,20 @@ extension ApiRoute.VendorRoute {
     case let .delete(id: id):
       try await vendors.delete(id)
       return HTTPStatus.ok
-
+    case let .create(vendor):
-    case let .base(route):
+      return try await vendors.create(vendor)
-      switch route {
+    case let .get(id: id):
-      case let .create(vendor):
+      guard let vendor = try await vendors.get(id) else {
-        return try await vendors.create(vendor)
+        throw Abort(.badRequest, reason: "Employee not found")
-      case let .get(id: id):
-        guard let vendor = try await vendors.get(id) else {
-          throw Abort(.badRequest, reason: "Employee not found")
-        }
-        return vendor
-      case let .update(id: id, updates: updates):
-        return try await vendors.update(id, with: updates)
-      case let .index(withBranches: withBranches):
-        guard withBranches == true else {
-          return try await vendors.fetchAll()
-        }
-        return try await vendors.fetchAll(.withBranches)
       }
+      return vendor
+    case let .update(id: id, updates: updates):
+      return try await vendors.update(id, with: updates)
+    case let .index(withBranches: withBranches):
+      guard withBranches == true else {
+        return try await vendors.fetchAll()
+      }
+      return try await vendors.fetchAll(.withBranches)
     }
   }
 }
@@ -149,24 +134,20 @@ extension ApiRoute.VendorBranchRoute {
     case let .delete(id: id):
       try await vendorBranches.delete(id)
       return HTTPStatus.ok
-
+    case let .create(branch):
-    case let .base(route):
+      return try await vendorBranches.create(branch)
-      switch route {
+    case let .index(for: optionalVendorID):
-      case let .create(branch):
+      guard let vendorID = optionalVendorID else {
-        return try await vendorBranches.create(branch)
+        return try await vendorBranches.fetchAll()
-      case let .index(for: optionalVendorID):
-        guard let vendorID = optionalVendorID else {
-          return try await vendorBranches.fetchAll()
-        }
-        return try await vendorBranches.fetchAll(.for(vendorID: vendorID))
-      case let .get(id: id):
-        guard let branch = try await vendorBranches.get(id) else {
-          throw Abort(.badRequest, reason: "Employee not found")
-        }
-        return branch
-      case let .update(id: id, updates: updates):
-        return try await vendorBranches.update(id, updates)
       }
+      return try await vendorBranches.fetchAll(.for(vendorID: vendorID))
+    case let .get(id: id):
+      guard let branch = try await vendorBranches.get(id) else {
+        throw Abort(.badRequest, reason: "Employee not found")
+      }
+      return branch
+    case let .update(id: id, updates: updates):
+      return try await vendorBranches.update(id, updates)
     }
   }
 }

Sources/SharedModels/Routes/ApiRoute.swift

@@ -36,77 +36,188 @@ public enum ApiRoute: Sendable, Equatable {
   }
 
   public enum EmployeeRoute: Sendable, Equatable {
-    case base(BaseRoute.EmployeeRoute)
+    case create(Employee.Create)
     case delete(id: Employee.ID)
+    case get(id: Employee.ID)
+    case index
+    case update(id: Employee.ID, updates: Employee.Update)
+
+    static let rootPath = "employees"
 
     public static let router = OneOf {
-      Route(.case(Self.base)) {
+      Route(.case(Self.create)) {
-        BaseRoute.EmployeeRoute.router
+        Path { rootPath }
+        Method.post
+        Body(.json(Employee.Create.self))
       }
       Route(.case(Self.delete(id:))) {
-        Path { BaseRoute.EmployeeRoute.rootPath; Employee.ID.parser() }
+        Path { rootPath; Employee.ID.parser() }
         Method.delete
       }
+      Route(.case(Self.index)) {
+        Path { rootPath }
+        Method.get
+      }
+      Route(.case(Self.get(id:))) {
+        Path { rootPath; Employee.ID.parser() }
+        Method.get
+      }
+      Route(.case(Self.update(id:updates:))) {
+        Path { rootPath; Employee.ID.parser() }
+        Method.put
+        Body(.json(Employee.Update.self))
+      }
     }
   }
 
   public enum PurchaseOrderRoute: Sendable, Equatable {
-    case base(BaseRoute.PurchaseOrderRoute)
+    case create(PurchaseOrder.Create)
     case delete(id: PurchaseOrder.ID)
+    case get(id: PurchaseOrder.ID)
+    case index
+    case page(page: Int, limit: Int)
+
+    static let rootPath = "purchase-orders"
 
     public static let router = OneOf {
-      Route(.case(Self.base)) {
+      Route(.case(Self.create)) {
-        BaseRoute.PurchaseOrderRoute.router
+        Path { rootPath }
+        Method.post
+        Body(.json(PurchaseOrder.Create.self))
       }
       Route(.case(Self.delete(id:))) {
-        Path { BaseRoute.PurchaseOrderRoute.rootPath; PurchaseOrder.ID.parser() }
+        Path { rootPath; PurchaseOrder.ID.parser() }
         Method.delete
       }
+      Route(.case(Self.get(id:))) {
+        Path { rootPath; Digits() }
+        Method.get
+      }
+      Route(.case(Self.index)) {
+        Path { rootPath }
+        Method.get
+      }
+      Route(.case(Self.page(page:limit:))) {
+        Path { rootPath; "next" }
+        Method.get
+        Query {
+          Field("page", default: 1) { Digits() }
+          Field("limit", default: 25) { Digits() }
+        }
+      }
     }
   }
 
   public enum UserRoute: Sendable, Equatable {
-    case base(BaseRoute.UserRoute)
     case delete(id: User.ID)
+    case create(User.Create)
+    case get(id: User.ID)
+    case index
+    case update(id: User.ID, updates: User.Update)
+
+    static let rootPath = "users"
 
     public static let router = OneOf {
-      Route(.case(Self.base)) {
+      Route(.case(Self.create)) {
-        BaseRoute.UserRoute.router
+        Path { rootPath }
+        Method.post
+        Body(.json(User.Create.self))
       }
       Route(.case(Self.delete(id:))) {
-        Path { BaseRoute.UserRoute.rootPath; User.ID.parser() }
+        Path { rootPath; User.ID.parser() }
         Method.delete
       }
+      Route(.case(Self.get(id:))) {
+        Path { rootPath; User.ID.parser() }
+        Method.get
+      }
+      Route(.case(Self.index)) {
+        Path { rootPath }
+        Method.get
+      }
+      Route(.case(Self.update(id:updates:))) {
+        Path { rootPath; User.ID.parser() }
+        Method.patch
+        Body(.json(User.Update.self))
+      }
     }
   }
 
   public enum VendorRoute: Sendable, Equatable {
-    case base(BaseRoute.VendorRoute)
     case delete(id: Vendor.ID)
+    case index(withBranches: Bool? = nil)
+    case create(Vendor.Create)
+    case get(id: Vendor.ID)
+    case update(id: Vendor.ID, updates: Vendor.Update)
+
+    static let rootPath = "vendors"
 
     public static let router = OneOf {
-      Route(.case(Self.base)) {
-        BaseRoute.VendorRoute.router
-      }
       Route(.case(Self.delete(id:))) {
-        Path { BaseRoute.VendorRoute.rootPath; Vendor.ID.parser() }
+        Path { rootPath; Vendor.ID.parser() }
         Method.delete
       }
+      Route(.case(Self.create)) {
+        Path { rootPath }
+        Method.post
+        Body(.json(Vendor.Create.self))
+      }
+      Route(.case(Self.get(id:))) {
+        Path { rootPath; Vendor.ID.parser() }
+        Method.get
+      }
+      Route(.case(Self.index(withBranches:))) {
+        Path { rootPath }
+        Method.get
+        Query {
+          Optionally {
+            Field("branches", default: nil) {
+              Bool.parser()
+            }
+          }
+        }
+      }
+      Route(.case(Self.update(id:updates:))) {
+        Path { rootPath; Vendor.ID.parser() }
+        Method.put
+        Body(.json(Vendor.Update.self))
+      }
     }
   }
 
   public enum VendorBranchRoute: Sendable, Equatable {
-    case base(BaseRoute.VendorBranchRoute)
     case delete(id: VendorBranch.ID)
+    case create(VendorBranch.Create)
+    case get(id: VendorBranch.ID)
+    case index(for: Vendor.ID? = nil)
+    case update(id: VendorBranch.ID, updates: VendorBranch.Update)
 
     public static let router = OneOf {
-      Route(.case(Self.base)) {
+      Route(.case(Self.create)) {
-        BaseRoute.VendorBranchRoute.router
+        Path { "vendors"; "branches" }
+        Method.post
+        Body(.json(VendorBranch.Create.self))
       }
       Route(.case(Self.delete(id:))) {
         Path { "vendors"; "branches"; VendorBranch.ID.parser() }
         Method.delete
       }
+      Route(.case(Self.get(id:))) {
+        Path { "vendors"; "branches"; VendorBranch.ID.parser() }
+        Method.get
+      }
+      Route(.case(Self.index(for:))) {
+        Path { "vendors"; "branches" }
+        Method.get
+        Query {
+          Optionally { Field("vendorID", default: nil) { VendorBranch.ID.parser() } }
+        }
+      }
+      Route(.case(Self.update(id:updates:))) {
+        Path { "vendors"; "branches"; VendorBranch.ID.parser() }
+        Method.put
+        Body(.json(VendorBranch.Update.self))
+      }
     }
   }
 }

Sources/SharedModels/Routes/BaseRoutes.swift

@@ -1,267 +0,0 @@
-import CasePaths
-import Foundation
-@preconcurrency import URLRouting
-
-public enum BaseRoute {}
-
-public extension BaseRoute {
-  enum EmployeeRoute: Sendable, Equatable {
-    case create(Employee.Create)
-    case get(id: Employee.ID)
-    case index
-    case update(id: Employee.ID, updates: Employee.Update)
-
-    static let rootPath = "employees"
-
-    public static let router = OneOf {
-      Route(.case(Self.create)) {
-        Path { rootPath }
-        Method.post
-        OneOf {
-          Body(.json(Employee.Create.self))
-          Body {
-            FormData {
-              Field("firstName", .string)
-              Field("lastName", .string)
-              Optionally { Field("active") { Bool.parser() } }
-            }
-            .map(.memberwise(Employee.Create.init))
-          }
-        }
-      }
-      Route(.case(Self.index)) {
-        Path { rootPath }
-        Method.get
-      }
-      Route(.case(Self.get(id:))) {
-        Path { rootPath; Employee.ID.parser() }
-        Method.get
-      }
-      Route(.case(Self.update(id:updates:))) {
-        Path { rootPath; Employee.ID.parser() }
-        Method.put
-        OneOf {
-          Body(.json(Employee.Update.self))
-          Body {
-            FormData {
-              Optionally { Field("firstName") { CharacterSet.alphanumerics.map(.string) } }
-              Optionally { Field("lastName") { CharacterSet.alphanumerics.map(.string) } }
-              Optionally { Field("active") { Bool.parser() } }
-            }
-            .map(.memberwise(Employee.Update.init))
-          }
-        }
-      }
-    }
-  }
-}
-
-public extension BaseRoute {
-  enum PurchaseOrderRoute: Sendable, Equatable {
-    case create(PurchaseOrder.Create)
-    case get(id: PurchaseOrder.ID)
-    case index
-    case page(page: Int, limit: Int)
-
-    static let rootPath = "purchase-orders"
-
-    public static let router = OneOf {
-      Route(.case(Self.create)) {
-        Path { rootPath }
-        Method.post
-        OneOf {
-          Body(.json(PurchaseOrder.Create.self))
-          Body {
-            FormData {
-              Optionally { Field("id") { PurchaseOrder.ID.parser() } }
-              Optionally { Field("workOrder") { Int.parser() } }
-              Field("materials", .string)
-              Field("customer", .string)
-              Optionally { Field("truckStock") { Bool.parser() } }
-              Field("createdByID") { User.ID.parser() }
-              Field("createdForID") { Employee.ID.parser() }
-              Field("vendorBranchID") { VendorBranch.ID.parser() }
-            }
-            .map(.memberwise(PurchaseOrder.Create.init))
-          }
-        }
-      }
-      Route(.case(Self.get(id:))) {
-        Path { rootPath; Digits() }
-        Method.get
-      }
-      Route(.case(Self.index)) {
-        Path { rootPath }
-        Method.get
-      }
-      Route(.case(Self.page(page:limit:))) {
-        Path { rootPath; "next" }
-        Method.get
-        Query {
-          Field("page", default: 1) { Digits() }
-          Field("limit", default: 25) { Digits() }
-        }
-      }
-    }
-  }
-}
-
-public extension BaseRoute {
-  enum UserRoute: Sendable, Equatable {
-    case create(User.Create)
-    case get(id: User.ID)
-    case index
-    case update(id: User.ID, updates: User.Update)
-
-    static let rootPath = "users"
-
-    public static let router = OneOf {
-      Route(.case(Self.create)) {
-        Path { rootPath }
-        Method.post
-        OneOf {
-          Body(.json(User.Create.self))
-          Body {
-            FormData {
-              Field("username", .string)
-              Field("email", .string)
-              Field("password", .string)
-              Field("confirmPassword", .string)
-            }
-            .map(.memberwise(User.Create.init))
-          }
-        }
-      }
-      Route(.case(Self.get(id:))) {
-        Path { rootPath; User.ID.parser() }
-        Method.get
-      }
-      Route(.case(Self.index)) {
-        Path { rootPath }
-        Method.get
-      }
-      Route(.case(Self.update(id:updates:))) {
-        Path { rootPath; User.ID.parser() }
-        Method.patch
-        OneOf {
-          Body(.json(User.Update.self))
-          Body {
-            FormData {
-              Optionally { Field("username") {
-                CharacterSet.alphanumerics.map(.string)
-              }
-              }
-              Optionally { Field("email", .string) }
-            }
-            .map(.memberwise(User.Update.init))
-          }
-        }
-      }
-    }
-  }
-}
-
-public extension BaseRoute {
-  enum VendorRoute: Sendable, Equatable {
-    case index(withBranches: Bool? = nil)
-    case create(Vendor.Create)
-    case get(id: Vendor.ID)
-    case update(id: Vendor.ID, updates: Vendor.Update)
-
-    static let rootPath = "vendors"
-
-    public static let router = OneOf {
-      Route(.case(Self.create)) {
-        Path { rootPath }
-        Method.post
-        OneOf {
-          Body(.json(Vendor.Create.self))
-          Body {
-            FormData {
-              Field("name", .string)
-            }
-            .map(.memberwise(Vendor.Create.init))
-          }
-        }
-      }
-      Route(.case(Self.get(id:))) {
-        Path { rootPath; Vendor.ID.parser() }
-        Method.get
-      }
-      Route(.case(Self.index(withBranches:))) {
-        Path { rootPath }
-        Method.get
-        Query {
-          Optionally {
-            Field("branches", default: nil) {
-              Bool.parser()
-            }
-          }
-        }
-      }
-      Route(.case(Self.update(id:updates:))) {
-        Path { rootPath; Vendor.ID.parser() }
-        Method.put
-        OneOf {
-          Body(.json(Vendor.Update.self))
-          Body {
-            FormData {
-              Field("name", .string)
-            }
-            .map(.memberwise(Vendor.Update.init))
-          }
-        }
-      }
-    }
-  }
-}
-
-public extension BaseRoute {
-  enum VendorBranchRoute: Sendable, Equatable {
-    case create(VendorBranch.Create)
-    case get(id: VendorBranch.ID)
-    case index(for: Vendor.ID? = nil)
-    case update(id: VendorBranch.ID, updates: VendorBranch.Update)
-
-    public static let router = OneOf {
-      Route(.case(Self.create)) {
-        Path { "vendors"; "branches" }
-        Method.post
-        OneOf {
-          Body(.json(VendorBranch.Create.self))
-          Body {
-            FormData {
-              Field("name", .string)
-              Field("vendorID") { Vendor.ID.parser() }
-            }
-            .map(.memberwise(VendorBranch.Create.init))
-          }
-        }
-      }
-      Route(.case(Self.get(id:))) {
-        Path { "vendors"; "branches"; VendorBranch.ID.parser() }
-        Method.get
-      }
-      Route(.case(Self.index(for:))) {
-        Path { "vendors"; "branches" }
-        Method.get
-        Query {
-          Optionally { Field("vendorID", default: nil) { VendorBranch.ID.parser() } }
-        }
-      }
-      Route(.case(Self.update(id:updates:))) {
-        Path { "vendors"; "branches"; VendorBranch.ID.parser() }
-        Method.put
-        OneOf {
-          Body(.json(VendorBranch.Update.self))
-          Body {
-            FormData {
-              Field("name", .string)
-            }
-            .map(.memberwise(VendorBranch.Update.init))
-          }
-        }
-      }
-    }
-  }
-}

Tests/ApiRouteTests/EmployeeApiRouteTests.swift

@@ -24,7 +24,7 @@ struct EmployeeApiRouteTests {
     )
     let route = try router.parse(&request)
     #expect(
-      route == .employee(.base(.create(.init(firstName: "Blob", lastName: "Esquire", active: true))))
+      route == .employee(.create(.init(firstName: "Blob", lastName: "Esquire", active: true)))
     )
   }
 
@@ -50,7 +50,7 @@ struct EmployeeApiRouteTests {
     )
     let route = try router.parse(&request)
     #expect(
-      route == .employee(.base(.get(id: id)))
+      route == .employee(.get(id: id))
     )
   }
 
@@ -62,7 +62,7 @@ struct EmployeeApiRouteTests {
     )
     let route = try router.parse(&request)
     #expect(
-      route == .employee(.base(.index))
+      route == .employee(.index)
       // route == .employee(\.index)
     )
   }
@@ -84,10 +84,10 @@ struct EmployeeApiRouteTests {
     )
     let route = try router.parse(&request)
     #expect(
-      route == .employee(.base(.update(
+      route == .employee(.update(
         id: id,
         updates: .init(firstName: "Blob", lastName: "Esquire", active: true)
-      )))
+      ))
     )
   }
 

Tests/ApiRouteTests/PurchaseOrderApiRouteTests.swift

@@ -29,7 +29,7 @@ struct PurchaseOrderApiRouteTests {
       body: .init(json.utf8)
     )
     let route = try router.parse(&request)
-    #expect(route == .purchaseOrder(.base(.create(.init(
+    #expect(route == .purchaseOrder(.create(.init(
       id: 1,
       workOrder: 12345,
       materials: "some",
@@ -38,7 +38,7 @@ struct PurchaseOrderApiRouteTests {
       createdByID: id,
       createdForID: id,
       vendorBranchID: id
-    )))))
+    ))))
   }
 
   @Test
@@ -60,7 +60,7 @@ struct PurchaseOrderApiRouteTests {
       path: "/api/v1/purchase-orders/\(id)"
     )
     let route = try router.parse(&request)
-    #expect(route == .purchaseOrder(.base(.get(id: id))))
+    #expect(route == .purchaseOrder(.get(id: id)))
   }
 
   @Test
@@ -70,7 +70,7 @@ struct PurchaseOrderApiRouteTests {
       path: "/api/v1/purchase-orders"
     )
     let route = try router.parse(&request)
-    #expect(route == .purchaseOrder(.base(.index)))
+    #expect(route == .purchaseOrder(.index))
   }
 
   @Test
@@ -80,7 +80,7 @@ struct PurchaseOrderApiRouteTests {
       path: "/api/v1/purchase-orders/next"
     )
     let route = try router.parse(&request)
-    #expect(route == .purchaseOrder(.base(.page(page: 1, limit: 25))))
+    #expect(route == .purchaseOrder(.page(page: 1, limit: 25)))
 
     var request2 = URLRequestData(
       method: "GET",
@@ -88,6 +88,6 @@ struct PurchaseOrderApiRouteTests {
       query: ["page": ["2"], "limit": ["50"]]
     )
     let route2 = try router.parse(&request2)
-    #expect(route2 == .purchaseOrder(.base(.page(page: 2, limit: 50))))
+    #expect(route2 == .purchaseOrder(.page(page: 2, limit: 50)))
   }
 }

Tests/ApiRouteTests/UserApiRouteTests.swift

@@ -25,12 +25,12 @@ struct UserApiRouteTests {
     )
     let route = try router.parse(&request)
     #expect(
-      route == .user(.base(.create(.init(
+      route == .user(.create(.init(
         username: "foo",
         email: "foo@bar.com",
         password: "super-secret",
         confirmPassword: "super-secret"
-      )))))
+      ))))
   }
 
   @Test
@@ -52,7 +52,7 @@ struct UserApiRouteTests {
       path: "/api/v1/users/\(id)"
     )
     let route = try router.parse(&request)
-    #expect(route == .user(.base(.get(id: id))))
+    #expect(route == .user(.get(id: id)))
   }
 
   @Test
@@ -62,7 +62,7 @@ struct UserApiRouteTests {
       path: "/api/v1/users"
     )
     let route = try router.parse(&request)
-    #expect(route == .user(.base(.index)))
+    #expect(route == .user(.index))
   }
 
   @Test
@@ -80,6 +80,6 @@ struct UserApiRouteTests {
       body: .init(json.utf8)
     )
     let route = try router.parse(&request)
-    #expect(route == .user(.base(.update(id: id, updates: .init(username: "bar", email: "bar@foo.com")))))
+    #expect(route == .user(.update(id: id, updates: .init(username: "bar", email: "bar@foo.com"))))
   }
 }

Tests/ApiRouteTests/VendorApiRouteTests.swift

@@ -21,7 +21,7 @@ struct VendorApiRouteTests {
       body: .init(json.utf8)
     )
     let route = try router.parse(&request)
-    #expect(route == .vendor(.base(.create(.init(name: "Test")))))
+    #expect(route == .vendor(.create(.init(name: "Test"))))
   }
 
   @Test
@@ -43,7 +43,7 @@ struct VendorApiRouteTests {
       path: "/api/v1/vendors/\(id)"
     )
     let route = try router.parse(&request)
-    #expect(route == .vendor(.base(.get(id: id))))
+    #expect(route == .vendor(.get(id: id)))
   }
 
   @Test
@@ -53,7 +53,7 @@ struct VendorApiRouteTests {
       path: "/api/v1/vendors"
     )
     let route = try router.parse(&request)
-    #expect(route == .vendor(.base(.index())))
+    #expect(route == .vendor(.index()))
 
     var request2 = URLRequestData(
       method: "GET",
@@ -61,7 +61,7 @@ struct VendorApiRouteTests {
       query: ["branches": ["true"]]
     )
     let route2 = try router.parse(&request2)
-    #expect(route2 == .vendor(.base(.index(withBranches: true))))
+    #expect(route2 == .vendor(.index(withBranches: true)))
   }
 
   @Test
@@ -78,6 +78,6 @@ struct VendorApiRouteTests {
       body: .init(json.utf8)
     )
     let route = try router.parse(&request)
-    #expect(route == .vendor(.base(.update(id: id, updates: .init(name: "Test")))))
+    #expect(route == .vendor(.update(id: id, updates: .init(name: "Test"))))
   }
 }

Tests/ApiRouteTests/VendorBranchApiRouteTests.swift

@@ -23,7 +23,7 @@ struct VendorBranchApiRouteTests {
       body: .init(json.utf8)
     )
     let route = try router.parse(&request)
-    #expect(route == .vendorBranch(.base(.create(.init(name: "Test", vendorID: id)))))
+    #expect(route == .vendorBranch(.create(.init(name: "Test", vendorID: id))))
   }
 
   @Test
@@ -45,7 +45,7 @@ struct VendorBranchApiRouteTests {
       path: "/api/v1/vendors/branches/\(id)"
     )
     let route = try router.parse(&request)
-    #expect(route == .vendorBranch(.base(.get(id: id))))
+    #expect(route == .vendorBranch(.get(id: id)))
   }
 
   @Test
@@ -56,7 +56,7 @@ struct VendorBranchApiRouteTests {
       path: "/api/v1/vendors/branches"
     )
     let route = try router.parse(&request)
-    #expect(route == .vendorBranch(.base(.index())))
+    #expect(route == .vendorBranch(.index()))
 
     var request2 = URLRequestData(
       method: "GET",
@@ -64,7 +64,7 @@ struct VendorBranchApiRouteTests {
       query: ["vendorID": ["\(id)"]]
     )
     let route2 = try router.parse(&request2)
-    #expect(route2 == .vendorBranch(.base(.index(for: id))))
+    #expect(route2 == .vendorBranch(.index(for: id)))
   }
 
   @Test
@@ -81,7 +81,7 @@ struct VendorBranchApiRouteTests {
       body: .init(json.utf8)
     )
     let route = try router.parse(&request)
-    #expect(route == .vendorBranch(.base(.update(id: id, updates: .init(name: "Test")))))
+    #expect(route == .vendorBranch(.update(id: id, updates: .init(name: "Test"))))
   }
 
 }