feat: Moves database dependency directory.

Sources/App/DB/EmployeeDB.swift

@@ -0,0 +1,83 @@
+import Dependencies
+import DependenciesMacros
+import Fluent
+import Vapor
+
+extension DependencyValues {
+  // An intermediate layer between our api and view controllers that interacts with the
+  // database model.
+  var employees: EmployeeDB {
+    get { self[EmployeeDB.self] }
+    set { self[EmployeeDB.self] = newValue }
+  }
+}
+
+@DependencyClient
+struct EmployeeDB: Sendable {
+  var create: @Sendable (Employee.Create) async throws -> Employee.DTO
+  var fetchAll: @Sendable (Bool) async throws -> [Employee.DTO]
+  var get: @Sendable (Employee.IDValue) async throws -> Employee.DTO?
+  var update: @Sendable (Employee.IDValue, Employee.Update) async throws -> Employee.DTO
+  var delete: @Sendable (Employee.IDValue) async throws -> Void
+  var toggleActive: @Sendable (Employee.IDValue) async throws -> Employee.DTO
+
+  func fetchAll() async throws -> [Employee.DTO] {
+    try await fetchAll(false)
+  }
+
+  func get(_ id: String?) async throws -> Employee.DTO? {
+    guard let idString = id, let id = UUID(uuidString: idString) else {
+      throw Abort(.badRequest, reason: "Employee id not valid.")
+    }
+    return try await get(id)
+  }
+}
+
+extension EmployeeDB: TestDependencyKey {
+  static let testValue: EmployeeDB = Self()
+
+  static func live(database: any Database) -> Self {
+    .init(
+      create: { model in
+        let model = model.toModel()
+        try await model.save(on: database)
+        return model.toDTO()
+      },
+      fetchAll: { active in
+        var query = Employee.query(on: database)
+          .sort(\.$lastName)
+
+        if active {
+          query = query.filter(\.$active == active)
+        }
+
+        return try await query.all().map { $0.toDTO() }
+      },
+      get: { id in
+        try await Employee.find(id, on: database).map { $0.toDTO() }
+      },
+      update: { id, updates in
+        guard let employee = try await Employee.find(id, on: database) else {
+          throw Abort(.badRequest, reason: "Employee id not found.")
+        }
+        employee.applyUpdates(updates)
+        try await employee.save(on: database)
+        return employee.toDTO()
+      },
+      delete: { id in
+        guard let employee = try await Employee.find(id, on: database) else {
+          throw Abort(.badRequest, reason: "Employee id not found.")
+        }
+        try await employee.delete(on: database)
+      },
+      toggleActive: { id in
+        guard let employee = try await Employee.find(id, on: database) else {
+          throw Abort(.notFound)
+        }
+        employee.active.toggle()
+        try await employee.save(on: database)
+        return employee.toDTO()
+      }
+    )
+  }
+}

Sources/App/DB/PurchaseOrderDB.swift

@@ -0,0 +1,87 @@
+import Dependencies
+import DependenciesMacros
+import Fluent
+import Vapor
+
+extension DependencyValues {
+  // An intermediate between our api and view controllers that interacts with the
+  // database.
+  var purchaseOrders: PurchaseOrdersDB {
+    get { self[PurchaseOrdersDB.self] }
+    set { self[PurchaseOrdersDB.self] = newValue }
+  }
+}
+
+@DependencyClient
+struct PurchaseOrdersDB: Sendable {
+  var create: @Sendable (PurchaseOrder.Create, User.IDValue) async throws -> PurchaseOrder.DTO
+  var fetchAll: @Sendable () async throws -> [PurchaseOrder.DTO]
+  var fetchPage: @Sendable (PageRequest) async throws -> Page<PurchaseOrder.DTO>
+  var get: @Sendable (PurchaseOrder.IDValue) async throws -> PurchaseOrder.DTO?
+  // var update: @Sendable (PurchaseOrder.IDValue, PurchaseOrder.Update) async throws -> PurchaseOrder.DTO
+  var delete: @Sendable (PurchaseOrder.IDValue) async throws -> Void
+}
+
+extension PurchaseOrdersDB: TestDependencyKey {
+  static let testValue: PurchaseOrdersDB = Self()
+
+  static func live(database db: any Database) -> Self {
+    .init(
+      create: { model, createdById in
+        guard let employee = try await Employee.find(model.createdForID, on: db) else {
+          throw Abort(.notFound, reason: "Employee not found.")
+        }
+
+        guard employee.active else {
+          throw Abort(.badRequest, reason: "Employee is not active, unable to generate a PO for in-active employees")
+        }
+
+        let purchaseOrder = model.toModel(createdByID: createdById)
+        try await purchaseOrder.save(on: db)
+        guard let loaded = try await PurchaseOrder.get(purchaseOrder.requireID(), on: db) else {
+          return purchaseOrder.toDTO()
+        }
+        return loaded
+
+      },
+      fetchAll: {
+        try await PurchaseOrder.allQuery(on: db)
+          .sort(\.$id, .descending)
+          .all().map { $0.toDTO() }
+      },
+      fetchPage: { request in
+        try await PurchaseOrder.allQuery(on: db)
+          .sort(\.$id, .descending)
+          .paginate(request)
+          .map { $0.toDTO() }
+      },
+      get: { id in
+        try await PurchaseOrder.get(id, on: db)
+      },
+      delete: { id in
+        guard let purchaseOrder = try await PurchaseOrder.find(id, on: db) else {
+          throw Abort(.notFound)
+        }
+        try await purchaseOrder.delete(on: db)
+      }
+    )
+  }
+
+}
+
+private extension PurchaseOrder {
+  static func allQuery(on db: any Database) -> QueryBuilder<PurchaseOrder> {
+    PurchaseOrder.query(on: db)
+      .with(\.$createdBy)
+      .with(\.$createdFor)
+      .with(\.$vendorBranch) { branch in
+        branch.with(\.$vendor)
+      }
+  }
+
+  static func get(_ id: PurchaseOrder.IDValue, on db: any Database) async throws -> PurchaseOrder.DTO? {
+    try await PurchaseOrder.allQuery(on: db)
+      .filter(\.$id == id)
+      .first()?.toDTO()
+  }
+}

Sources/App/DB/UserDB.swift

@@ -0,0 +1,56 @@
+import Dependencies
+import DependenciesMacros
+import Fluent
+import Vapor
+
+extension DependencyValues {
+  var users: UserDB {
+    get { self[UserDB.self] }
+    set { self[UserDB.self] = newValue }
+  }
+}
+
+@DependencyClient
+struct UserDB: Sendable {
+  var create: @Sendable (User.Create) async throws -> User.DTO
+  var delete: @Sendable (User.IDValue) async throws -> Void
+  var fetchAll: @Sendable () async throws -> [User.DTO]
+  var login: @Sendable (User) async throws -> UserToken
+}
+
+extension UserDB: TestDependencyKey {
+  static let testValue: UserDB = Self()
+
+  static func live(database db: any Database) -> Self {
+    self.init(
+      create: { model in
+        guard model.password == model.confirmPassword else {
+          throw Abort(.badRequest, reason: "Passwords did not match.")
+        }
+        let user = try User(
+          username: model.username,
+          email: model.email,
+          passwordHash: Bcrypt.hash(model.password)
+        )
+        try await user.save(on: db)
+        return user.toDTO()
+
+      },
+      delete: { id in
+        guard let user = try await User.find(id, on: db) else {
+          throw Abort(.notFound)
+        }
+        try await user.delete(on: db)
+
+      },
+      fetchAll: {
+        try await User.query(on: db).all().map { $0.toDTO() }
+      },
+      login: { user in
+        let token = try user.generateToken()
+        try await token.save(on: db)
+        return token
+      }
+    )
+  }
+}

Sources/App/DB/VendorBranchDB.swift

@@ -0,0 +1,80 @@
+import Dependencies
+import DependenciesMacros
+import Fluent
+import Vapor
+
+public extension DependencyValues {
+  var vendorBranches: VendorBranchDB {
+    get { self[VendorBranchDB.self] }
+    set { self[VendorBranchDB.self] = newValue }
+  }
+}
+
+@DependencyClient
+public struct VendorBranchDB: Sendable {
+  var create: @Sendable (VendorBranch.Create, Vendor.IDValue) async throws -> VendorBranch.DTO
+  var delete: @Sendable (VendorBranch.IDValue) async throws -> Void
+  var fetchAll: @Sendable (Bool) async throws -> [VendorBranch.DTO]
+  var fetchForVendor: @Sendable (Vendor.IDValue) async throws -> [VendorBranch.DTO]
+  var get: @Sendable (VendorBranch.IDValue) async throws -> VendorBranch.DTO?
+  var update: @Sendable (VendorBranch.IDValue, VendorBranch.Update) async throws -> VendorBranch.DTO
+
+  func fetchAll() async throws -> [VendorBranch.DTO] {
+    try await fetchAll(false)
+  }
+}
+
+extension VendorBranchDB: TestDependencyKey {
+  public static let testValue: VendorBranchDB = Self()
+
+  static func live(database db: any Database) -> Self {
+    .init(
+      create: { model, vendorID in
+        let branch = model.toModel()
+        guard let vendor = try await Vendor.find(vendorID, on: db) else {
+          throw Abort(.badRequest, reason: "Vendor does not exist.")
+        }
+        try await vendor.$branches.create(branch, on: db)
+        return branch.toDTO()
+      },
+      delete: { id in
+        guard let branch = try await VendorBranch.find(id, on: db) else {
+          throw Abort(.notFound)
+        }
+        try await branch.delete(on: db)
+      },
+      fetchAll: { withVendor in
+        var query = VendorBranch.query(on: db)
+        if withVendor == true {
+          query = query.with(\.$vendor)
+        }
+        return try await query.all().map { $0.toDTO() }
+
+      },
+      fetchForVendor: { vendorID in
+        guard let vendor = try await Vendor.query(on: db)
+          .filter(\.$id == vendorID)
+          .with(\.$branches)
+          .first()
+        else {
+          throw Abort(.notFound)
+        }
+
+        return vendor.branches.map { $0.toDTO() }
+
+      },
+      get: { id in
+
+        try await VendorBranch.find(id, on: db).map { $0.toDTO() }
+      },
+      update: { id, updates in
+        guard let branch = try await VendorBranch.find(id, on: db) else {
+          throw Abort(.notFound)
+        }
+        branch.applyUpdates(updates)
+        try await branch.save(on: db)
+        return branch.toDTO()
+      }
+    )
+  }
+}

Sources/App/DB/VendorDB.swift

@@ -0,0 +1,85 @@
+import Dependencies
+import DependenciesMacros
+import Fluent
+import Vapor
+
+public extension DependencyValues {
+  var vendors: VendorDB {
+    get { self[VendorDB.self] }
+    set { self[VendorDB.self] = newValue }
+  }
+}
+
+@DependencyClient
+public struct VendorDB: Sendable {
+  var create: @Sendable (Vendor.Create) async throws -> Vendor.DTO
+  var delete: @Sendable (Vendor.IDValue) async throws -> Void
+  var fetchAll: @Sendable (FetchRequest) async throws -> [Vendor.DTO]
+  var get: @Sendable (Vendor.IDValue, GetRequest) async throws -> Vendor.DTO?
+  var update: @Sendable (Vendor.IDValue, Vendor.Update) async throws -> Vendor.DTO
+
+  enum FetchRequest {
+    case `default`
+    case withBranches
+  }
+
+  enum GetRequest {
+    case `default`
+    case withBranches
+  }
+
+  func fetchAll() async throws -> [Vendor.DTO] {
+    try await fetchAll(.default)
+  }
+
+  func get(_ id: Vendor.IDValue) async throws -> Vendor.DTO? {
+    try await get(id, .default)
+  }
+}
+
+extension VendorDB: TestDependencyKey {
+  public static let testValue: VendorDB = Self()
+
+  static func live(database db: any Database) -> Self {
+    .init(
+      create: { model in
+        let model = model.toModel()
+        try await model.save(on: db)
+        return model.toDTO()
+
+      },
+      delete: { id in
+        guard let vendor = try await Vendor.find(id, on: db) else {
+          throw Abort(.notFound)
+        }
+        try await vendor.delete(on: db)
+
+      },
+      fetchAll: { request in
+        var query = Vendor.query(on: db).sort(\.$name, .ascending)
+        let withBranches = request == .withBranches
+        if withBranches {
+          query = query.with(\.$branches)
+        }
+        return try await query.all().map { $0.toDTO(includeBranches: withBranches) }
+
+      },
+      get: { id, request in
+        var query = Vendor.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 vendor = try await Vendor.find(id, on: db) else {
+          throw Abort(.notFound)
+        }
+        vendor.applyUpdates(updates)
+        return vendor.toDTO()
+      }
+    )
+  }
+}