feat: Moves api controller to it's own module.

Sources/App/Controllers/ApiController.swift

@@ -1,154 +0,0 @@
-import DatabaseClientLive
-import Dependencies
-import Fluent
-import SharedModels
-import Vapor
-
-private let apiMiddleware: [any Middleware] = [
-  UserPasswordAuthenticator(),
-  UserTokenAuthenticator(),
-  UserSessionAuthenticator(),
-  User.guardMiddleware()
-]
-
-extension ApiRoute {
-  var middleware: [any Middleware]? { apiMiddleware }
-
-  func respond(request: Request) async throws -> any AsyncResponseEncodable {
-    switch self {
-    case let .employee(route):
-      return try await route.handleApiRequest(request: request)
-    case let .purchaseOrder(route):
-      return try await route.handleApiRequest(request: request)
-    case let .user(route):
-      return try await route.handleApiRequest(request: request)
-    case let .vendor(route):
-      return try await route.handleApiRequest(request: request)
-    case let .vendorBranch(route):
-      return try await route.handleApiRequest(request: request)
-    }
-  }
-}
-
-extension ApiRoute.EmployeeRoute {
-
-  func handleApiRequest(request: Request) async throws -> any AsyncResponseEncodable {
-    @Dependency(\.database) var database
-
-    switch self {
-    case let .delete(id: id):
-      try await database.employees.delete(id)
-      return HTTPStatus.ok
-    case let .create(employee):
-      return try await database.employees.create(employee)
-    case .index:
-      return try await database.employees.fetchAll()
-    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)
-    }
-  }
-}
-
-extension ApiRoute.PurchaseOrderRoute {
-
-  func handleApiRequest(request: Request) async throws -> any AsyncResponseEncodable {
-    @Dependency(\.database.purchaseOrders) var purchaseOrders
-    switch self {
-    case let .delete(id: id):
-      try await purchaseOrders.delete(id)
-      return HTTPStatus.ok
-    case .index:
-      return try await purchaseOrders.fetchAll()
-    case let .create(purchaseOrder):
-      return try await purchaseOrders.create(purchaseOrder)
-    case let .get(id: id):
-      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))
-    }
-  }
-}
-
-// TODO: Add Login.
-extension ApiRoute.UserRoute {
-
-  func handleApiRequest(request: Request) async throws -> any AsyncResponseEncodable {
-    @Dependency(\.database.users) var users
-    switch self {
-    case let .delete(id: id):
-      try await users.delete(id)
-      return HTTPStatus.ok
-    case let .create(user):
-      return try await users.create(user)
-    case .index:
-      return try await users.fetchAll()
-    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)
-    }
-  }
-}
-
-extension ApiRoute.VendorRoute {
-  func handleApiRequest(request: Request) async throws -> any AsyncResponseEncodable {
-    @Dependency(\.database.vendors) var vendors
-    switch self {
-    case let .delete(id: id):
-      try await vendors.delete(id)
-      return HTTPStatus.ok
-    case let .create(vendor):
-      return try await vendors.create(vendor)
-    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)
-    }
-  }
-}
-
-extension ApiRoute.VendorBranchRoute {
-  func handleApiRequest(request: Request) async throws -> any AsyncResponseEncodable {
-    @Dependency(\.database.vendorBranches) var vendorBranches
-    switch self {
-    case let .delete(id: id):
-      try await vendorBranches.delete(id)
-      return HTTPStatus.ok
-    case let .create(branch):
-      return try await vendorBranches.create(branch)
-    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)
-    }
-  }
-}

Sources/App/Extensions/ApiController+respond.swift

@@ -0,0 +1,35 @@
+import ApiController
+import SharedModels
+import Vapor
+
+extension ApiController {
+
+  func respond(_ route: ApiRoute, request: Vapor.Request) async throws -> any AsyncResponseEncodable {
+    guard let encodable = try await json(route, logger: request.logger) else {
+      return HTTPStatus.ok
+    }
+    return AnyJSONResponse(value: encodable)
+  }
+}
+
+struct AnyJSONResponse: AsyncResponseEncodable {
+  public var headers: HTTPHeaders = ["Content-Type": "application/json"]
+  let value: any Encodable
+
+  init(additionalHeaders: HTTPHeaders = [:], value: any Encodable) {
+    if additionalHeaders.contains(name: .contentType) {
+      self.headers = additionalHeaders
+    } else {
+      headers.add(contentsOf: additionalHeaders)
+    }
+    self.value = value
+  }
+
+  func encodeResponse(for request: Request) async throws -> Response {
+    try Response(
+      status: .ok,
+      headers: headers,
+      body: .init(data: JSONEncoder().encode(value))
+    )
+  }
+}

Sources/App/Middleware/ApiRoute+middleware.swift

@@ -0,0 +1,20 @@
+import DatabaseClientLive
+import SharedModels
+import Vapor
+
+private let apiMiddleware: [any Middleware] = [
+  UserPasswordAuthenticator(),
+  UserTokenAuthenticator(),
+  UserSessionAuthenticator(),
+  User.guardMiddleware()
+]
+
+extension ApiRoute {
+  var middleware: [any Middleware]? {
+    switch self {
+    case .login: return nil
+    default:
+      return apiMiddleware
+    }
+  }
+}

Sources/App/Middleware/DependenciesMiddleware.swift

@@ -1,3 +1,4 @@
+import ApiControllerLive
 import DatabaseClientLive
 import Dependencies
 import Vapor
@@ -8,14 +9,17 @@ import ViewControllerLive
 struct DependenciesMiddleware: AsyncMiddleware {
 
   private let values: DependencyValues.Continuation
+  private let apiController: ApiController
   private let database: DatabaseClient
   private let viewController: ViewController
 
   init(
     database: DatabaseClient,
+    apiController: ApiController = .liveValue,
     viewController: ViewController = .liveValue
   ) {
     self.values = withEscapedDependencies { $0 }
+    self.apiController = apiController
     self.database = database
     self.viewController = viewController
   }
@@ -23,6 +27,7 @@ struct DependenciesMiddleware: AsyncMiddleware {
   func respond(to request: Request, chainingTo next: any AsyncResponder) async throws -> Response {
     try await values.yield {
       try await withDependencies {
+        $0.apiController = apiController
         $0.database = database
         $0.dateFormatter = .liveValue
         $0.viewController = viewController

Sources/App/configure.swift

@@ -1,3 +1,4 @@
+import ApiController
 import DatabaseClientLive
 import Dependencies
 import Elementary
@@ -15,6 +16,24 @@ public func configure(
   _ app: Application,
   makeDatabaseClient: @escaping (any Database) -> DatabaseClient = { .live(database: $0) }
 ) async throws {
+  // Setup the database client.
+  let databaseClient = try await setupDatabase(on: app, factory: makeDatabaseClient)
+  // Add the global middlewares.
+  addMiddleware(to: app, database: databaseClient)
+  #if DEBUG
+    // Live reload of the application for development when launched with the `./swift-dev` command
+    app.lifecycle.use(BrowserSyncHandler())
+  #endif
+  // Add our route handlers.
+  addRoutes(to: app)
+  if app.environment != .testing {
+    try await app.autoMigrate()
+  }
+  // Add our custom cli-commands to the application.
+  addCommands(to: app)
+}
+
+private func addMiddleware(to app: Application, database databaseClient: DatabaseClient) {
   // cors middleware should come before default error middleware using `at: .beginning`
   let corsConfiguration = CORSMiddleware.Configuration(
     allowedOrigin: .all,
@@ -27,11 +46,13 @@ public func configure(
 
   app.middleware.use(FileMiddleware(publicDirectory: app.directory.publicDirectory))
   app.middleware.use(app.sessions.middleware)
+  app.middleware.use(DependenciesMiddleware(database: databaseClient))
+}
 
-  #if DEBUG
-    app.lifecycle.use(BrowserSyncHandler())
-  #endif
-
+private func setupDatabase(
+  on app: Application,
+  factory makeDatabaseClient: @escaping (any Database) -> DatabaseClient
+) async throws -> DatabaseClient {
   switch app.environment {
   case .production, .development:
     let dbFileName = Environment.get("SQLITE_FILENAME") ?? "db.sqlite"
@@ -46,8 +67,10 @@ public func configure(
     try await app.migrations.add(databaseClient.migrations())
   }
 
-  app.middleware.use(DependenciesMiddleware(database: databaseClient))
+  return databaseClient
+}
 
+private func addRoutes(to app: Application) {
   // Redirect the index path to purchase order route.
   app.get { req in
     req.redirect(to: ViewRoute.router.path(for: .purchaseOrder(.index)))
@@ -64,18 +87,16 @@ public func configure(
     },
     use: siteHandler
   )
+}
 
-  if app.environment != .testing {
-    try await app.autoMigrate()
-  }
-
+private func addCommands(to app: Application) {
   #if DEBUG
     app.asyncCommands.use(SeedCommand(), as: "seed")
   #endif
   app.asyncCommands.use(GenerateAdminUserCommand(), as: "generate-admin")
 }
 
-extension SiteRoute {
+private extension SiteRoute {
 
   func middleware() -> [any Middleware]? {
     switch self {
@@ -90,14 +111,16 @@ extension SiteRoute {
 }
 
 @Sendable
-func siteHandler(
+private func siteHandler(
   request: Request,
   route: SiteRoute
 ) async throws -> any AsyncResponseEncodable {
+  @Dependency(\.apiController) var apiController
   @Dependency(\.viewController) var viewController
+
   switch route {
   case let .api(route):
-    return try await route.respond(request: request)
+    return try await apiController.respond(route, request: request)
   case .health:
     return HTTPStatus.ok
   case let .view(route):