Split `user` into a chat-facing entity and an authentication-facing entity.

The taxonomy is now as follows:

* A _login_ is someone's identity for the purposes of authenticating to the service. Logins are not synchronized, and in fact are not published anywhere in the current API. They have a login ID, a name and a password.

* A _user_ is someone's identity for the purpose of participating in conversations. Users _are_ synchronized, as before. They have a user ID, a name, and a creation instant for the purposes of synchronization.

In practice, a user exists for every login - in fact, users' names are stored in the login table and are joined in, rather than being stored redundantly in the user table. A login ID and its corresponding user ID are always equal, and the user and login ID types support conversion and comparison to facilitate their use in this context.

Tokens are now associated with logins, not users. The currently-acting identity is passed down into app types as a login, not a user, and then resolved to a user where appropriate within the app methods.

As a side effect, the `GET /api/boot` method now returns a `login` key instead of a `user` key. The structure of the nested value is unchanged.

7 files changed, 36 insertions, 39 deletions

diff --git a/src/test/fixtures/cookie.rs b/src/test/fixtures/cookie.rs
index f5a32a6..7dc5083 100644
--- a/src/test/fixtures/cookie.rs
+++ b/src/test/fixtures/cookie.rs
@@ -1,11 +1,7 @@
 use uuid::Uuid;
 
 use crate::{
-    app::App,
-    clock::RequestedAt,
-    name::Name,
-    password::Password,
-    token::{Secret, extract::IdentityCookie},
+    app::App, clock::RequestedAt, name::Name, password::Password, token::extract::IdentityCookie,
 };
 
 pub fn not_logged_in() -> IdentityCookie {
@@ -19,18 +15,14 @@ pub async fn logged_in(
 ) -> IdentityCookie {
     let (name, password) = credentials;
     let secret = app
-        .tokens()
-        .login(name, password, now)
+        .logins()
+        .with_password(name, password, now)
         .await
         .expect("should succeed given known-valid credentials");
 
     IdentityCookie::new().set(secret)
 }
 
-pub fn secret(identity: &IdentityCookie) -> Secret {
-    identity.secret().expect("identity contained a secret")
-}
-
 pub fn fictitious() -> IdentityCookie {
     let token = Uuid::new_v4().to_string();
     IdentityCookie::new().set(token)
diff --git a/src/test/fixtures/identity.rs b/src/test/fixtures/identity.rs
index ac353de..93e4a38 100644
--- a/src/test/fixtures/identity.rs
+++ b/src/test/fixtures/identity.rs
@@ -37,8 +37,8 @@ pub async fn logged_in(
 }
 
 pub fn fictitious() -> Identity {
-    let user = fixtures::user::fictitious();
-    let (token, _) = Token::generate(&user, &fixtures::now());
+    let login = fixtures::login::fictitious();
+    let (token, _) = Token::generate(&login, &fixtures::now());
 
-    Identity { token, user }
+    Identity { token, login }
 }
diff --git a/src/test/fixtures/invite.rs b/src/test/fixtures/invite.rs
index 7a41eb6..654d1b4 100644
--- a/src/test/fixtures/invite.rs
+++ b/src/test/fixtures/invite.rs
@@ -2,10 +2,10 @@ use crate::{
     app::App,
     clock::DateTime,
     invite::{self, Invite},
-    user::User,
+    login::Login,
 };
 
-pub async fn issue(app: &App, issuer: &User, issued_at: &DateTime) -> Invite {
+pub async fn issue(app: &App, issuer: &Login, issued_at: &DateTime) -> Invite {
     app.invites()
         .issue(issuer, issued_at)
         .await
diff --git a/src/test/fixtures/login.rs b/src/test/fixtures/login.rs
new file mode 100644
index 0000000..d9aca81
--- /dev/null
+++ b/src/test/fixtures/login.rs
@@ -0,0 +1,21 @@
+use crate::{
+    app::App,
+    clock::DateTime,
+    login::{self, Login},
+    test::fixtures::user::{propose, propose_name},
+};
+
+pub async fn create(app: &App, created_at: &DateTime) -> Login {
+    let (name, password) = propose();
+    app.users()
+        .create(&name, &password, created_at)
+        .await
+        .expect("should always succeed if the user is actually new")
+}
+
+pub fn fictitious() -> Login {
+    Login {
+        id: login::Id::generate(),
+        name: propose_name(),
+    }
+}
diff --git a/src/test/fixtures/message.rs b/src/test/fixtures/message.rs
index 03f8072..92ac1f5 100644
--- a/src/test/fixtures/message.rs
+++ b/src/test/fixtures/message.rs
@@ -4,14 +4,14 @@ use crate::{
     app::App,
     clock::RequestedAt,
     conversation::Conversation,
+    login::Login,
     message::{self, Body, Message},
-    user::User,
 };
 
 pub async fn send(
     app: &App,
     conversation: &Conversation,
-    sender: &User,
+    sender: &Login,
     sent_at: &RequestedAt,
 ) -> Message {
     let body = propose();
diff --git a/src/test/fixtures/mod.rs b/src/test/fixtures/mod.rs
index 87d3fa1..3d69cfa 100644
--- a/src/test/fixtures/mod.rs
+++ b/src/test/fixtures/mod.rs
@@ -9,6 +9,7 @@ pub mod event;
 pub mod future;
 pub mod identity;
 pub mod invite;
+pub mod login;
 pub mod message;
 pub mod user;
 
diff --git a/src/test/fixtures/user.rs b/src/test/fixtures/user.rs
index 086f866..d4d8db4 100644
--- a/src/test/fixtures/user.rs
+++ b/src/test/fixtures/user.rs
@@ -1,13 +1,7 @@
 use faker_rand::{en_us::internet, lorem::Paragraphs};
 use uuid::Uuid;
 
-use crate::{
-    app::App,
-    clock::RequestedAt,
-    name::Name,
-    password::Password,
-    user::{self, User},
-};
+use crate::{app::App, clock::RequestedAt, login::Login, name::Name, password::Password};
 
 pub async fn create_with_password(app: &App, created_at: &RequestedAt) -> (Name, Password) {
     let (name, password) = propose();
@@ -20,19 +14,8 @@ pub async fn create_with_password(app: &App, created_at: &RequestedAt) -> (Name,
     (user.name, password)
 }
 
-pub async fn create(app: &App, created_at: &RequestedAt) -> User {
-    let (name, password) = propose();
-    app.users()
-        .create(&name, &password, created_at)
-        .await
-        .expect("should always succeed if the login is actually new")
-}
-
-pub fn fictitious() -> User {
-    User {
-        id: user::Id::generate(),
-        name: propose_name(),
-    }
+pub async fn create(app: &App, created_at: &RequestedAt) -> Login {
+    super::login::create(app, created_at).await
 }
 
 pub fn propose() -> (Name, Password) {
@@ -43,7 +26,7 @@ pub fn propose_invalid_name() -> Name {
     rand::random::<Paragraphs>().to_string().into()
 }
 
-fn propose_name() -> Name {
+pub(crate) fn propose_name() -> Name {
     rand::random::<internet::Username>().to_string().into()
 }