feat: Minimal user api controller on hummingbird app, not sure there's big wins over vapor.

Sources/HApp/App+build.swift

@@ -1,65 +1,87 @@
+import DatabaseClient
+import DatabaseClientLive
+import FluentSQLiteDriver
 import Hummingbird
+import HummingbirdFluent
 import Logging
 
-public struct AppConfiguration {
-
-  public let hostname: String
-  public let port: Int
-  public let logLevel: Logger.Level?
-
-  public init(hostname: String, port: Int, logLevel: Logger.Level? = nil) {
-    self.hostname = hostname
-    self.port = port
-    self.logLevel = logLevel
-  }
+public protocol AppArguments {
+  var inMemoryDatabase: Bool { get }
+  var migrate: Bool { get }
+  var revert: Bool { get }
+  var hostname: String { get }
+  var port: Int { get }
+  var logLevel: Logger.Level? { get }
 }
 
 ///  Build application
 /// - Parameter arguments: application arguments
-public func buildApplication(_ arguments: AppConfiguration) async throws -> some ApplicationProtocol {
+public func buildApplication(_ arguments: some AppArguments) async throws -> some ApplicationProtocol {
   let environment = Environment()
 
   let logger = {
-    var logger = Logger(label: "Todos")
+    var logger = Logger(label: "PurchaseOrders")
     logger.logLevel = arguments.logLevel ??
       environment.get("LOG_LEVEL").map { Logger.Level(rawValue: $0) ?? .info } ??
       .info
 
     return logger
   }()
+  let fluent = Fluent(logger: logger)
+  if arguments.inMemoryDatabase {
+    fluent.databases.use(.sqlite(.memory), as: .sqlite)
+  } else {
+    fluent.databases.use(.sqlite(.file("hdb.sqlite")), as: .sqlite)
+  }
+  let dbClient = DatabaseClient.live(database: fluent.db())
+  try await fluent.migrations.add(dbClient.migrations())
+
+  if arguments.revert {
+    try await fluent.revert()
+  }
+
+  if arguments.migrate || arguments.inMemoryDatabase {
+    try await fluent.migrate()
+  }
+
+  let fluentPersist = await FluentPersistDriver(fluent: fluent)
 
   let router = Router()
 
   // Add middleware
 
-  router.addMiddleware {
-    // logging middleware
-    LogRequestsMiddleware(.info)
-  }
+  // logging middleware
+  router.add(middleware: LogRequestsMiddleware(.info))
+  router.add(middleware: FileMiddleware(logger: logger))
+  router.add(middleware: CORSMiddleware(
+    allowOrigin: .originBased,
+    allowHeaders: [.contentType],
+    allowMethods: [.get, .options, .post, .delete, .put, .patch]
+  ))
 
   // Add health endpoint
-
   router.get("/health") { _, _ -> HTTPResponse.Status in
     return .ok
   }
 
+  UserController(db: dbClient.users).addRoutes(to: router.group("api/users"))
+
   // let router = buildRouter()
   //
-  let app = Application(
+  var app = Application(
     router: router,
-
     configuration: .init(
       address: .hostname(arguments.hostname, port: arguments.port),
-      serverName: "Todos"
+      serverName: "Purchase-Orders"
     ),
     logger: logger
   )
 
+  app.addServices(fluent, fluentPersist)
   return app
 }
 
-/// Build router
-
+// Build router
 // func buildRouter() -> Router<AppRequestContext> {
 //   let router = Router()
 //