import EnumKeyPaths

// MARK: - Authentication

enum Authentication {
    case authenticated(accessToken: String)
    case unauthenticated
}

/Authentication.authenticated // EnumKeyPath
   

user[keyPath: \User.id] = 113
user[keyPath: \User.id] // 113

let authentication = (/Authentication.authenticated).embed("access")
(/Authentication.authenticated).extract(from: authentication) // Optional("access")

(/Authentication.authenticated).extract(from: .unauthenticated) // nil

\Table.user.name
// WritableKeyPath
   

/Result<Authentication, Error>..Authentication.authenticated
// EnumKeyPath
   
    
     , String>
    
   

\User.self           // WritableKeyPath
   
/Authentication.self // EnumKeyPath
   

EnumKeyPath<Authentication, String>(
    embed: { token in
        Authentication.authenticated(token: encrypt(token))
    },
    extract: { authentication in
        guard
            case let .authenticated(encryptedToken) = authentication,
            let decryptedToken = decrypt(token)
            else { return nil }
        return decryptedToken
    }
)

users.map(\User.name)
authentications.compactMap(/Authentication.authenticated)

extract(case: Authentication.authenticated, from: .authenticated("token"))
// Optional("token")

// With operators:
/Authentication.authenticated
// Without:
EnumKeyPath.case(Authentication.authenticated)

// With operators:
authentications.compactMap(/Authentication.authenticated)
// Without:
authentications.compactMap(extract(Authentication.authenticated))

// With operators:
/Result<Authentication, Error>.success..Authentication.authenticated
// Without:
EnumKeyPath.case(Result<Authentication, Error>.success)
  .appending(path: .case(Authentication.authenticated))

// With operators:
/Authentication.self
// Without operators:
EnumKeyPath<Authentication, Authentication>.self

dependencies: [
    .package(url: "https://github.com/Incetro/enum-key-paths.git", from: "0.0.1")
]