Exodai-Academy-API/Sources/ExodaiAcademy/Infrastructure/Database/UserModel.swift

//
//  UserModel.swift
//  ExodaiAcademy
//
//  Created by Exodai on 22/01/2026.
//

import Vapor
import Fluent
import FluentKit

final class UserModel: Model, @unchecked Sendable  {
    static let schema: String = Database.users.rawValue
    
    @ID(key: .id)
    var id: UUID?
    
    @Field(key: FieldKeys.username)
    var username: String
    
    @Field(key: FieldKeys.email)
    var email: String
    
    @Field(key: FieldKeys.password)
    var password: String
    
    @Field(key: FieldKeys.role)
    var role: Role
    
    @OptionalField(key: FieldKeys.name)
    var name: String?
    
    @OptionalField(key: FieldKeys.lastname)
    var lastname: String?
    
    @OptionalField(key: FieldKeys.address)
    var address: String?
    
    @OptionalField(key: FieldKeys.zipCode)
    var zipCode: String?
    
    @OptionalField(key: FieldKeys.city)
    var city: String?
    
    @OptionalEnum(key: FieldKeys.country)
    var Country: CountryCode?
    
    @OptionalField(key: FieldKeys.stripeID)
    var stripeID: String?
    
    @Timestamp(key: FieldKeys.createdAt, on: .create)
    var createdAt: Date?
    
    @Timestamp(key: FieldKeys.updatedAt, on: .update)
    var updatedAt: Date?
    
    @Timestamp(key: FieldKeys.deletedAt, on: .delete)
    var deletedAt: Date?
    
    @Timestamp(key: FieldKeys.lastLogin, on: .none)
    var lastLogin: Date?
    
    init() {
        
    }
    
    init(id: UUID? = nil, username: String, email: String, password: String, role: Role) {
        self.id = id
        self.username = username
        self.email = email
        self.password = password
        self.role = role
    }
}

extension UserModel {
    struct FieldKeys {
        static var username: FieldKey {"username"}
        static var email: FieldKey {"email"}
        static var password: FieldKey {"password"}
        static var role: FieldKey {"role"}
        static var name: FieldKey {"name"}
        static var lastname: FieldKey {"lastname"}
        static var address: FieldKey {"address"}
        static var zipCode: FieldKey {"zipCode"}
        static var city: FieldKey {"city"}
        static var country: FieldKey {"country"}
        static var stripeID: FieldKey {"stripeID"}
        static var createdAt: FieldKey {"createdAt"}
        static var updatedAt: FieldKey {"updatedAt"}
        static var deletedAt: FieldKey {"deletedAt"}
        static var lastLogin: FieldKey {"lastLogin"}
    }
}

import Fluent

extension UserModel {
    struct Migration: AsyncMigration {

        func prepare(on database: any FluentKit.Database) async throws {
            try await database.schema(UserModel.schema)
                .id()
                .field(FieldKeys.username, .string, .required)
                .field(FieldKeys.email, .string, .required)
                .field(FieldKeys.password, .string, .required)
                .field(FieldKeys.role, .string, .required)
                .field(FieldKeys.name, .string)
                .field(FieldKeys.lastname, .string)
                .field(FieldKeys.address, .string)
                .field(FieldKeys.zipCode, .string)
                .field(FieldKeys.city, .string)
                .field(FieldKeys.country, .string)
                .field(FieldKeys.stripeID, .string)
                .field(FieldKeys.createdAt, .datetime)
                .field(FieldKeys.updatedAt, .datetime)
                .field(FieldKeys.deletedAt, .datetime)
                .field(FieldKeys.lastLogin, .datetime)
                .unique(on: FieldKeys.username)
                .unique(on: FieldKeys.email)
                .create()
        }

        func revert(on database: any FluentKit.Database) async throws {
            try await database.schema(UserModel.schema).delete()
        }
    }
}

extension UserModel {

    struct Public: Content {
        let id: UUID?
        let username: String
        let email: String
        let role: Role
        let name: String?
        let lastname: String?
        let address: String?
        let zipCode: String?
        let city: String?
        let country: CountryCode?
        let stripeID: String?
        let createdAt: Date?
        let updatedAt: Date?
        let lastLogin: Date?
    }
}

extension UserModel {

    func convertToPublic() -> Public {
        .init(
            id: self.id,
            username: self.username,
            email: self.email,
            role: self.role,
            name: self.name,
            lastname: self.lastname,
            address: self.address,
            zipCode: self.zipCode,
            city: self.city,
            country: self.Country,
            stripeID: self.stripeID,
            createdAt: self.createdAt,
            updatedAt: self.updatedAt,
            lastLogin: self.lastLogin
        )
    }
}

extension Collection where Element == UserModel {

    func convertToPublic() -> [UserModel.Public] {
        self.map { $0.convertToPublic() }
    }
}