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

Sources/DatabaseClientLive/Employees.swift

@@ -0,0 +1,176 @@
+import DatabaseClient
+import Fluent
+import Foundation
+import SharedModels
+
+public extension DatabaseClient.Employees {
+
+  static func live(database: any Database) -> DatabaseClient.Employees {
+    .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 EmployeeModel.find(id, on: database) else {
+        throw NotFoundError()
+      }
+      try await model.delete(on: database)
+    } fetchAll: { request in
+      var query = EmployeeModel.query(on: database)
+        .sort(\.$lastName)
+
+      switch request {
+      case .active:
+        query = query.filter(\.$active == true)
+      case .inactive:
+        query = query.filter(\.$active == false)
+      case .all:
+        break
+      }
+
+      return try await query.all().map { $0.toDTO() }
+
+    } get: { id in
+      try await EmployeeModel.find(id, on: database).map { $0.toDTO() }
+    } update: { id, updates in
+      guard let model = try await EmployeeModel.find(id, on: database) else {
+        throw NotFoundError()
+      }
+      try model.applyUpdate(updates)
+      try await model.save(on: database)
+      return model.toDTO()
+    }
+  }
+}
+
+private extension Employee.Create {
+
+  func toModel() throws -> EmployeeModel {
+    try validate()
+    return .init(firstName: firstName, lastName: lastName, active: active ?? true)
+  }
+
+  func validate() throws {
+    guard !firstName.isEmpty else {
+      throw ValidationError(message: "Employee first name should not be empty.")
+    }
+    guard !lastName.isEmpty else {
+      throw ValidationError(message: "Employee first name should not be empty.")
+    }
+  }
+}
+
+extension Employee.Update {
+
+  func validate() throws {
+    if let firstName {
+      guard !firstName.isEmpty else {
+        throw ValidationError(message: "Employee first name should not be empty.")
+      }
+    }
+    if let lastName {
+      guard !lastName.isEmpty else {
+        throw ValidationError(message: "Employee first name should not be empty.")
+      }
+    }
+  }
+}
+
+extension Employee {
+
+  struct Migrate: AsyncMigration {
+
+    let name = "CreateEmployee"
+
+    func prepare(on database: Database) async throws {
+      try await database.schema(EmployeeModel.schema)
+        .id()
+        .field("first_name", .string, .required)
+        .field("last_name", .string, .required)
+        .field("is_active", .bool, .required)
+        .field("created_at", .datetime)
+        .field("updated_at", .datetime)
+        .unique(on: "first_name", "last_name")
+        .create()
+    }
+
+    func revert(on database: Database) async throws {
+      try await database.schema(EmployeeModel.schema).delete()
+    }
+
+  }
+}
+
+/// The employee database model.
+///
+/// An employee is someone that PO's can be generated for. They can be either a field
+/// employee / technician, an office employee, or an administrator.
+///
+/// # NOTE: Only `User` types can login and generate po's for employees.
+///
+final class EmployeeModel: Model, @unchecked Sendable {
+
+  static let schema = "employee"
+
+  // @ID(key: ")
+  // var id: UUID?
+  @ID(key: .id)
+  var id: UUID?
+
+  @Field(key: "first_name")
+  var firstName: String
+
+  @Field(key: "last_name")
+  var lastName: String
+
+  @Field(key: "is_active")
+  var active: Bool
+
+  @Timestamp(key: "created_at", on: .create)
+  var createdAt: Date?
+
+  @Timestamp(key: "updated_at", on: .update)
+  var updatedAt: Date?
+
+  init() {}
+
+  init(
+    id: UUID? = nil,
+    firstName: String,
+    lastName: String,
+    active: Bool,
+    createdAt: Date? = nil,
+    updatedAt: Date? = nil
+  ) {
+    self.id = id
+    self.firstName = firstName
+    self.lastName = lastName
+    self.active = active
+    self.createdAt = createdAt
+    self.updatedAt = updatedAt
+  }
+
+  func toDTO() -> Employee {
+    .init(
+      id: id,
+      active: active,
+      createdAt: createdAt,
+      firstName: firstName,
+      lastName: lastName,
+      updatedAt: updatedAt
+    )
+  }
+
+  func applyUpdate(_ updates: Employee.Update) throws {
+    try updates.validate()
+    if let firstName = updates.firstName {
+      self.firstName = firstName
+    }
+    if let lastName = updates.lastName {
+      self.lastName = lastName
+    }
+    if let active = updates.active {
+      self.active = active
+    }
+  }
+}

Sources/DatabaseClientLive/Errors.swift

@@ -0,0 +1,5 @@
+public struct ValidationError: Error {
+  let message: String
+}
+
+public struct NotFoundError: Error {}

Sources/DatabaseClientLive/Live.swift

@@ -0,0 +1,27 @@
+import DatabaseClient
+import FluentKit
+import SharedModels
+
+public extension DatabaseClient {
+
+  /// Create the live database client.
+  static func live(database: any Database) -> Self {
+    .init(
+      employees: .live(database: database),
+      migrations: {
+        [
+          Employee.Migrate(),
+          PurchaseOrder.Migrate(),
+          User.Migrate(),
+          User.Token.Migrate(),
+          VendorBranch.Migrate(),
+          Vendor.Migrate()
+        ]
+      },
+      purchaseOrders: .live(database: database),
+      users: .live(database: database),
+      vendorBranches: .live(database: database),
+      vendors: .live(database: database)
+    )
+  }
+}

Sources/DatabaseClientLive/PurchaseOrders.swift

@@ -0,0 +1,174 @@
+import DatabaseClient
+import FluentKit
+import Foundation
+import SharedModels
+
+public extension DatabaseClient.PurchaseOrders {
+
+  static func live(database: any Database) -> Self {
+    .init { create, createdById in
+      let model = try create.toModel(createdByID: createdById)
+      try await model.save(on: database)
+      return try model.toDTO()
+    } fetchAll: {
+      try await PurchaseOrderModel.allQuery(on: database)
+        .all()
+        .map { try $0.toDTO() }
+    } fetchPage: { request in
+      try await PurchaseOrderModel.allQuery(on: database)
+        .paginate(request)
+        .map { try $0.toDTO() }
+    } get: { id in
+      try await PurchaseOrderModel.allQuery(on: database)
+        .filter(\.$id == id)
+        .first()
+        .map { try $0.toDTO() }
+    } delete: { id in
+      guard let model = try await PurchaseOrderModel.find(id, on: database) else {
+        throw NotFoundError()
+      }
+      try await model.delete(on: database)
+    }
+  }
+}
+
+extension PurchaseOrder {
+  struct Migrate: AsyncMigration {
+
+    let name = "CreatePurchaseOrder"
+
+    func prepare(on database: any Database) async throws {
+      try await database.schema(PurchaseOrderModel.schema)
+        .field("id", .int, .identifier(auto: true))
+        .field("work_order", .int)
+        .field("customer", .string, .required)
+        .field("materials", .string, .required)
+        .field("truck_stock", .bool, .required)
+        .field("created_by_id", .uuid, .required, .references(UserModel.schema, "id"))
+        .field("created_for_id", .uuid, .required, .references(EmployeeModel.schema, "id"))
+        .field("vendor_branch_id", .uuid, .required, .references(VendorBranchModel.schema, "id"))
+        .field("created_at", .datetime)
+        .field("updated_at", .datetime)
+        .create()
+    }
+
+    func revert(on database: any Database) async throws {
+      try await database.schema(PurchaseOrderModel.schema).delete()
+    }
+  }
+
+}
+
+extension PurchaseOrder.Create {
+
+  func toModel(createdByID: User.ID) throws -> PurchaseOrderModel {
+    try validate()
+    return .init(
+      materials: materials,
+      customer: customer,
+      truckStock: truckStock ?? false,
+      createdByID: createdByID,
+      createdForID: createdForID,
+      vendorBranchID: vendorBranchID
+    )
+  }
+
+  func validate() throws {
+    guard !materials.isEmpty else {
+      throw ValidationError(message: "Materials should not be empty.")
+    }
+    guard !customer.isEmpty else {
+      throw ValidationError(message: "Customer should not be empty.")
+    }
+  }
+}
+
+/// The purchase order database model.
+///
+/// # NOTE: An initial purchase order should be created with an `id` higher than our current PO
+///         so that subsequent PO's are generated with higher values than our current system produces.
+///         once the first one is set, the rest will auto-increment from there.
+final class PurchaseOrderModel: Model, Codable, @unchecked Sendable {
+  static let schema = "purchase_order"
+
+  @ID(custom: "id", generatedBy: .database)
+  var id: Int?
+
+  @Field(key: "work_order")
+  var workOrder: Int?
+
+  @Field(key: "materials")
+  var materials: String
+
+  @Field(key: "customer")
+  var customer: String
+
+  @Field(key: "truck_stock")
+  var truckStock: Bool
+
+  @Parent(key: "created_by_id")
+  var createdBy: UserModel
+
+  @Parent(key: "created_for_id")
+  var createdFor: EmployeeModel
+
+  @Parent(key: "vendor_branch_id")
+  var vendorBranch: VendorBranchModel
+
+  @Timestamp(key: "created_at", on: .create)
+  var createdAt: Date?
+
+  @Timestamp(key: "updated_at", on: .update)
+  var updatedAt: Date?
+
+  init() {}
+
+  init(
+    id: Int? = nil,
+    workOrder: Int? = nil,
+    materials: String,
+    customer: String,
+    truckStock: Bool,
+    createdByID: UserModel.IDValue,
+    createdForID: EmployeeModel.IDValue,
+    vendorBranchID: VendorBranchModel.IDValue,
+    createdAt: Date? = nil,
+    updatedAt: Date? = nil
+  ) {
+    self.id = id
+    self.workOrder = workOrder
+    self.materials = materials
+    self.customer = customer
+    self.truckStock = truckStock
+    $createdBy.id = createdByID
+    $createdFor.id = createdForID
+    $vendorBranch.id = vendorBranchID
+    self.createdAt = createdAt
+    self.updatedAt = updatedAt
+  }
+
+  func toDTO() throws -> PurchaseOrder {
+    try .init(
+      id: requireID(),
+      workOrder: workOrder,
+      materials: materials,
+      customer: customer,
+      truckStock: truckStock,
+      createdBy: createdBy.toDTO(),
+      createdFor: createdFor.toDTO(),
+      vendorBranch: vendorBranch.toDTO(),
+      createdAt: createdAt,
+      updatedAt: updatedAt
+    )
+  }
+
+  static func allQuery(on db: any Database) -> QueryBuilder<PurchaseOrderModel> {
+    PurchaseOrderModel.query(on: db)
+      .sort(\.$id, .descending)
+      .with(\.$createdBy)
+      .with(\.$createdFor)
+      .with(\.$vendorBranch) { branch in
+        branch.with(\.$vendor)
+      }
+  }
+}

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
+  }
+
+}

Sources/DatabaseClientLive/VendorBranches.swift

@@ -0,0 +1,143 @@
+import DatabaseClient
+import FluentKit
+import Foundation
+import SharedModels
+
+public extension DatabaseClient.VendorBranches {
+
+  static func live(database db: any Database) -> Self {
+    .init { create in
+      let model = try create.toModel()
+      try await model.save(on: db)
+      return model.toDTO()
+    } delete: { id in
+      guard let model = try await VendorBranchModel.find(id, on: db) else {
+        throw NotFoundError()
+      }
+      try await model.delete(on: db)
+    } fetchAll: { request in
+      var query = VendorBranchModel.query(on: db)
+
+      switch request {
+      case .all:
+        break
+      case .withVendor:
+        query = query.with(\.$vendor)
+      case let .for(vendorID: vendorID):
+        let branches = try await VendorModel.query(on: db)
+          .filter(\.$id == vendorID)
+          .with(\.$branches)
+          .first()?
+          .branches
+          .map { $0.toDTO() }
+
+        guard let branches else { throw NotFoundError() }
+        return branches
+      }
+
+      return try await query.all().map { $0.toDTO() }
+    } get: { id in
+      try await VendorBranchModel.find(id, on: db).map { $0.toDTO() }
+    } update: { id, updates in
+      guard let model = try await VendorBranchModel.find(id, on: db) else {
+        throw NotFoundError()
+      }
+      try model.applyUpdates(updates)
+      try await model.save(on: db)
+      return model.toDTO()
+    }
+  }
+
+}
+
+extension VendorBranch {
+
+  struct Migrate: AsyncMigration {
+    let name = "CreateVendorBranch"
+
+    func prepare(on database: Database) async throws {
+      try await database.schema(VendorBranchModel.schema)
+        .id()
+        .field("name", .string, .required)
+        .field("vendor_id", .uuid, .required)
+        .field("created_at", .datetime)
+        .field("updated_at", .datetime)
+        .foreignKey("vendor_id", references: VendorModel.schema, "id", onDelete: .cascade)
+        .create()
+    }
+
+    func revert(on database: Database) async throws {
+      try await database.schema(VendorBranchModel.schema).delete()
+    }
+  }
+}
+
+extension VendorBranch.Create {
+
+  func toModel() throws -> VendorBranchModel {
+    try validate()
+    return .init(name: name, vendorId: vendorID)
+  }
+
+  func validate() throws {
+    guard !name.isEmpty else {
+      throw ValidationError(message: "Vendor branch name should not be empty.")
+    }
+  }
+}
+
+extension VendorBranch.Update {
+  func validate() throws {
+    if let name {
+      guard !name.isEmpty else {
+        throw ValidationError(message: "Vendor branch name should not be empty.")
+      }
+    }
+  }
+}
+
+final class VendorBranchModel: Model, @unchecked Sendable {
+
+  static let schema = "vendor_branch"
+
+  @ID(key: .id)
+  var id: UUID?
+
+  @Field(key: "name")
+  var name: String
+
+  @Timestamp(key: "created_at", on: .create)
+  var createdAt: Date?
+
+  @Timestamp(key: "updated_at", on: .update)
+  var updatedAt: Date?
+
+  @Parent(key: "vendor_id")
+  var vendor: VendorModel
+
+  init() {}
+
+  init(id: UUID? = nil, name: String, vendorId: Vendor.ID) {
+    self.id = id
+    self.name = name
+    $vendor.id = vendorId
+  }
+
+  func toDTO() -> VendorBranch {
+    .init(
+      id: id,
+      name: name,
+      vendorID: $vendor.id,
+      createdAt: createdAt,
+      updatedAt: updatedAt
+    )
+  }
+
+  func applyUpdates(_ updates: VendorBranch.Update) throws {
+    try updates.validate()
+    if let name = updates.name {
+      self.name = name
+    }
+  }
+
+}

Sources/DatabaseClientLive/Vendors.swift

@@ -0,0 +1,140 @@
+import DatabaseClient
+import FluentKit
+import Foundation
+import SharedModels
+
+public extension DatabaseClient.Vendors {
+
+  static func live(database db: any Database) -> Self {
+    .init { create in
+      let model = try create.toModel()
+      try await model.save(on: db)
+      return model.toDTO()
+    } delete: { id in
+      guard let model = try await VendorModel.find(id, on: db) else {
+        throw NotFoundError()
+      }
+      try await model.delete(on: db)
+    } fetchAll: { request in
+      var query = VendorModel.query(on: db).sort(\.$name, .ascending)
+
+      let withBranches = request == .withBranches
+
+      switch request {
+      case .withBranches:
+        query = query.with(\.$branches)
+      case .all:
+        break
+      }
+
+      return try await query.all().map { $0.toDTO(includeBranches: withBranches) }
+
+    } get: { id, request in
+      var query = VendorModel.query(on: db).filter(\.$id == id)
+      let withBranches = request == .withBranches
+      if withBranches {
+        query = query.with(\.$branches)
+      }
+      return try await query.first().map { $0.toDTO(includeBranches: withBranches) }
+    } update: { id, updates in
+      guard let model = try await VendorModel.find(id, on: db) else {
+        throw NotFoundError()
+      }
+      try model.applyUpdates(updates)
+      try await model.save(on: db)
+      return model.toDTO()
+    }
+  }
+}
+
+extension Vendor {
+
+  struct Migrate: AsyncMigration {
+    let name = "CreateVendor"
+
+    func prepare(on database: Database) async throws {
+      try await database.schema(VendorModel.schema)
+        .id()
+        .field("name", .string, .required)
+        .field("created_at", .datetime)
+        .field("updated_at", .datetime)
+        .unique(on: "name")
+        .create()
+    }
+
+    func revert(on database: Database) async throws {
+      try await database.schema(VendorModel.schema).delete()
+    }
+  }
+}
+
+extension Vendor.Create {
+
+  func toModel() throws -> VendorModel {
+    try validate()
+    return .init(name: name)
+  }
+
+  func validate() throws {
+    guard !name.isEmpty else {
+      throw ValidationError(message: "Vendor name should not be empty.")
+    }
+  }
+}
+
+extension Vendor.Update {
+  func validate() throws {
+    if let name {
+      guard !name.isEmpty else {
+        throw ValidationError(message: "Vendor name should not be empty.")
+      }
+    }
+  }
+}
+
+// The primary database model.
+final class VendorModel: Model, @unchecked Sendable {
+
+  static let schema = "vendor"
+
+  @ID(key: .id)
+  var id: UUID?
+
+  @Field(key: "name")
+  var name: String
+
+  @Timestamp(key: "created_at", on: .create)
+  var createdAt: Date?
+
+  @Timestamp(key: "updated_at", on: .update)
+  var updatedAt: Date?
+
+  @Children(for: \.$vendor)
+  var branches: [VendorBranchModel]
+
+  init() {}
+
+  init(id: UUID? = nil, name: String) {
+    self.id = id
+    self.name = name
+  }
+
+  func toDTO(includeBranches: Bool? = nil) -> Vendor {
+    .init(
+      id: id,
+      name: name,
+      branches: ($branches.value != nil && $branches.value!.count > 0)
+        ? $branches.value!.map { $0.toDTO() }
+        : [],
+      createdAt: createdAt,
+      updatedAt: updatedAt
+    )
+  }
+
+  func applyUpdates(_ updates: Vendor.Update) throws {
+    try updates.validate()
+    if let name = updates.name {
+      self.name = name
+    }
+  }
+}