feat: Begins breaking database out into it's own module, using dependencies

Sources/DatabaseClientLive/Users.swift

@@ -0,0 +1,211 @@
+import DatabaseClient
+import FluentKit
+import Foundation
+import HummingbirdBcrypt
+import SharedModels
+
+public extension DatabaseClient.Users {
+
+  static func live(database: any Database) -> Self {
+    .init { create in
+      let model = try create.toModel()
+      try await model.save(on: database)
+      return model.toDTO()
+    } delete: { id in
+      guard let model = try await UserModel.find(id, on: database) else {
+        throw NotFoundError()
+      }
+      try await model.delete(on: database)
+    } fetchAll: {
+      try await UserModel.query(on: database).all().map { $0.toDTO() }
+    } get: { id in
+      try await UserModel.find(id, on: database).map { $0.toDTO() }
+    } login: { login in
+      try login.validate()
+
+      var query = UserModel.query(on: database)
+
+      if let username = login.username {
+        query = query.filter(\.$username == username)
+      } else {
+        query = query.filter(\.$email == login.email!)
+      }
+
+      guard let user = try await query.first() else {
+        throw NotFoundError()
+      }
+
+      let token = try user.generateToken()
+
+      try await token.save(on: database)
+
+      return try User.Token(
+        id: token.requireID(),
+        userID: user.requireID(),
+        value: token.value
+      )
+
+    } logout: { id in
+      guard let token = try await UserTokenModel.find(id, on: database)
+      else { return }
+      try await token.delete(on: database)
+    }
+  }
+}
+
+extension User {
+  struct Migrate: AsyncMigration {
+    let name = "CreateUser"
+
+    func prepare(on database: any Database) async throws {
+      try await database.schema(UserModel.schema)
+        .id()
+        .field("username", .string, .required)
+        .field("email", .string, .required)
+        .field("password_hash", .string, .required)
+        .field("created_at", .datetime)
+        .field("updated_at", .datetime)
+        .unique(on: "email", "username")
+        .create()
+    }
+
+    func revert(on database: any Database) async throws {
+      try await database.schema(UserModel.schema).delete()
+    }
+  }
+}
+
+extension User.Token {
+  struct Migrate: AsyncMigration {
+    let name = "CreateUserToken"
+
+    func prepare(on database: any Database) async throws {
+      try await database.schema(UserTokenModel.schema)
+        .id()
+        .field("value", .string, .required)
+        .field("user_id", .uuid, .required, .references(UserModel.schema, "id"))
+        .unique(on: "value")
+        .create()
+    }
+
+    func revert(on database: any Database) async throws {
+      try await database.schema(UserTokenModel.schema).delete()
+    }
+  }
+}
+
+extension User.Create {
+
+  func toModel() throws -> UserModel {
+    try validate()
+    return .init(username: username, email: email, passwordHash: Bcrypt.hash(password, cost: 12))
+  }
+
+  func validate() throws {
+    guard !username.isEmpty else {
+      throw ValidationError(message: "Username should not be empty.")
+    }
+    guard !email.isEmpty else {
+      throw ValidationError(message: "Email should not be empty")
+    }
+    guard password.count > 8 else {
+      throw ValidationError(message: "Password should be more than 8 characters long.")
+    }
+    guard password == confirmPassword else {
+      throw ValidationError(message: "Passwords do not match.")
+    }
+  }
+}
+
+extension User.Login {
+
+  func validate() throws {
+    guard username != nil || email != nil else {
+      throw ValidationError(message: "Either username or email must be provided to login.")
+    }
+  }
+}
+
+/// The user database model.
+///
+/// A user is someone who is able to login and generate PO's for employees.  Generally a user should also
+/// have an employee profile, but not all employees are users. Users are generally restricted to office workers
+/// and administrators.
+///
+///
+final class UserModel: Model, @unchecked Sendable {
+  static let schema = "user"
+
+  @ID(key: .id)
+  var id: UUID?
+
+  @Field(key: "username")
+  var username: String
+
+  @Field(key: "email")
+  var email: String
+
+  @Field(key: "password_hash")
+  var passwordHash: String
+
+  @Timestamp(key: "created_at", on: .create)
+  var createdAt: Date?
+
+  @Timestamp(key: "updated_at", on: .update)
+  var updatedAt: Date?
+
+  init() {}
+
+  init(
+    id: UUID? = nil,
+    username: String,
+    email: String,
+    passwordHash: String
+  ) {
+    self.id = id
+    self.username = username
+    self.email = email
+    self.passwordHash = passwordHash
+  }
+
+  func toDTO() -> User {
+    .init(
+      id: id,
+      createdAt: createdAt,
+      email: email,
+      updatedAt: updatedAt,
+      username: username
+    )
+  }
+
+  func generateToken() throws -> UserTokenModel {
+    try .init(
+      value: [UInt8].random(count: 16).base64,
+      userID: requireID()
+    )
+  }
+
+}
+
+final class UserTokenModel: Model, Codable, @unchecked Sendable {
+
+  static let schema = "user_token"
+
+  @ID(key: .id)
+  var id: UUID?
+
+  @Field(key: "value")
+  var value: String
+
+  @Parent(key: "user_id")
+  var user: UserModel
+
+  init() {}
+
+  init(id: UUID? = nil, value: String, userID: UserModel.IDValue) {
+    self.id = id
+    self.value = value
+    $user.id = userID
+  }
+
+}