feat: MVP two-user chat via embedded SPA (#9)

Backend:
- Session/client UUID model: sessions table (uuid, nick, signing_key),
  clients table (uuid, session_id, token) with per-client message queues
- MOTD delivery as IRC numeric messages (375/372/376) on connect
- EnqueueToSession fans out to all clients of a session
- EnqueueToClient for targeted delivery (MOTD)
- All queries updated for session/client model

SPA client:
- Long-poll loop (15s timeout) instead of setInterval
- IRC message envelope parsing (command/from/to/body)
- Display JOIN/PART/NICK/TOPIC/QUIT system messages
- Nick change via /nick command
- Topic display in header bar
- Unread count badges on inactive tabs
- Auto-rejoin channels on reconnect (localStorage)
- Connection status indicator
- Message deduplication by UUID
- Channel history loaded on join
- /topic command support

Closes #9

internal/db/queries.go

@@ -55,76 +55,132 @@ type MemberInfo struct {
 	LastSeen time.Time `json:"lastSeen"`
 }
 
-// CreateUser registers a new user with the given nick.
-func (database *Database) CreateUser(
+// CreateSession registers a new session and its first client.
+func (database *Database) CreateSession(
 	ctx context.Context,
 	nick string,
-) (int64, string, error) {
+) (int64, int64, string, error) {
+	sessionUUID := uuid.New().String()
+	clientUUID := uuid.New().String()
+
 	token, err := generateToken()
 	if err != nil {
-		return 0, "", err
+		return 0, 0, "", err
 	}
 
 	now := time.Now()
 
-	res, err := database.conn.ExecContext(ctx,
-		`INSERT INTO users
-		 (nick, token, created_at, last_seen)
-		 VALUES (?, ?, ?, ?)`,
-		nick, token, now, now)
+	transaction, err := database.conn.BeginTx(ctx, nil)
 	if err != nil {
-		return 0, "", fmt.Errorf("create user: %w", err)
+		return 0, 0, "", fmt.Errorf(
+			"begin tx: %w", err,
+		)
 	}
 
-	userID, _ := res.LastInsertId()
+	res, err := transaction.ExecContext(ctx,
+		`INSERT INTO sessions
+		 (uuid, nick, created_at, last_seen)
+		 VALUES (?, ?, ?, ?)`,
+		sessionUUID, nick, now, now)
+	if err != nil {
+		_ = transaction.Rollback()
 
-	return userID, token, nil
+		return 0, 0, "", fmt.Errorf(
+			"create session: %w", err,
+		)
+	}
+
+	sessionID, _ := res.LastInsertId()
+
+	clientRes, err := transaction.ExecContext(ctx,
+		`INSERT INTO clients
+		 (uuid, session_id, token,
+		  created_at, last_seen)
+		 VALUES (?, ?, ?, ?, ?)`,
+		clientUUID, sessionID, token, now, now)
+	if err != nil {
+		_ = transaction.Rollback()
+
+		return 0, 0, "", fmt.Errorf(
+			"create client: %w", err,
+		)
+	}
+
+	clientID, _ := clientRes.LastInsertId()
+
+	err = transaction.Commit()
+	if err != nil {
+		return 0, 0, "", fmt.Errorf(
+			"commit session: %w", err,
+		)
+	}
+
+	return sessionID, clientID, token, nil
 }
 
-// GetUserByToken returns user id and nick for a token.
-func (database *Database) GetUserByToken(
+// GetSessionByToken returns session id, client id, and
+// nick for a client token.
+func (database *Database) GetSessionByToken(
 	ctx context.Context,
 	token string,
-) (int64, string, error) {
-	var userID int64
-
-	var nick string
+) (int64, int64, string, error) {
+	var (
+		sessionID int64
+		clientID  int64
+		nick      string
+	)
 
 	err := database.conn.QueryRowContext(
 		ctx,
-		"SELECT id, nick FROM users WHERE token = ?",
+		`SELECT s.id, c.id, s.nick
+		 FROM clients c
+		 INNER JOIN sessions s
+		   ON s.id = c.session_id
+		 WHERE c.token = ?`,
 		token,
-	).Scan(&userID, &nick)
+	).Scan(&sessionID, &clientID, &nick)
 	if err != nil {
-		return 0, "", fmt.Errorf("get user by token: %w", err)
+		return 0, 0, "", fmt.Errorf(
+			"get session by token: %w", err,
+		)
 	}
 
+	now := time.Now()
+
 	_, _ = database.conn.ExecContext(
 		ctx,
-		"UPDATE users SET last_seen = ? WHERE id = ?",
-		time.Now(), userID,
+		"UPDATE sessions SET last_seen = ? WHERE id = ?",
+		now, sessionID,
 	)
 
-	return userID, nick, nil
+	_, _ = database.conn.ExecContext(
+		ctx,
+		"UPDATE clients SET last_seen = ? WHERE id = ?",
+		now, clientID,
+	)
+
+	return sessionID, clientID, nick, nil
 }
 
-// GetUserByNick returns user id for a given nick.
-func (database *Database) GetUserByNick(
+// GetSessionByNick returns session id for a given nick.
+func (database *Database) GetSessionByNick(
 	ctx context.Context,
 	nick string,
 ) (int64, error) {
-	var userID int64
+	var sessionID int64
 
 	err := database.conn.QueryRowContext(
 		ctx,
-		"SELECT id FROM users WHERE nick = ?",
+		"SELECT id FROM sessions WHERE nick = ?",
 		nick,
-	).Scan(&userID)
+	).Scan(&sessionID)
 	if err != nil {
-		return 0, fmt.Errorf("get user by nick: %w", err)
+		return 0, fmt.Errorf(
+			"get session by nick: %w", err,
+		)
 	}
 
-	return userID, nil
+	return sessionID, nil
 }
 
 // GetChannelByName returns the channel ID for a name.
@@ -179,16 +235,16 @@ func (database *Database) GetOrCreateChannel(
 	return channelID, nil
 }
 
-// JoinChannel adds a user to a channel.
+// JoinChannel adds a session to a channel.
 func (database *Database) JoinChannel(
 	ctx context.Context,
-	channelID, userID int64,
+	channelID, sessionID int64,
 ) error {
 	_, err := database.conn.ExecContext(ctx,
 		`INSERT OR IGNORE INTO channel_members
-		 (channel_id, user_id, joined_at)
+		 (channel_id, session_id, joined_at)
 		 VALUES (?, ?, ?)`,
-		channelID, userID, time.Now())
+		channelID, sessionID, time.Now())
 	if err != nil {
 		return fmt.Errorf("join channel: %w", err)
 	}
@@ -196,15 +252,15 @@ func (database *Database) JoinChannel(
 	return nil
 }
 
-// PartChannel removes a user from a channel.
+// PartChannel removes a session from a channel.
 func (database *Database) PartChannel(
 	ctx context.Context,
-	channelID, userID int64,
+	channelID, sessionID int64,
 ) error {
 	_, err := database.conn.ExecContext(ctx,
 		`DELETE FROM channel_members
-		 WHERE channel_id = ? AND user_id = ?`,
-		channelID, userID)
+		 WHERE channel_id = ? AND session_id = ?`,
+		channelID, sessionID)
 	if err != nil {
 		return fmt.Errorf("part channel: %w", err)
 	}
@@ -265,18 +321,18 @@ func scanChannels(
 	return out, nil
 }
 
-// ListChannels returns channels the user has joined.
+// ListChannels returns channels the session has joined.
 func (database *Database) ListChannels(
 	ctx context.Context,
-	userID int64,
+	sessionID int64,
 ) ([]ChannelInfo, error) {
 	rows, err := database.conn.QueryContext(ctx,
 		`SELECT c.id, c.name, c.topic
 		 FROM channels c
 		 INNER JOIN channel_members cm
 		   ON cm.channel_id = c.id
-		 WHERE cm.user_id = ?
-		 ORDER BY c.name`, userID)
+		 WHERE cm.session_id = ?
+		 ORDER BY c.name`, sessionID)
 	if err != nil {
 		return nil, fmt.Errorf("list channels: %w", err)
 	}
@@ -306,12 +362,12 @@ func (database *Database) ChannelMembers(
 	channelID int64,
 ) ([]MemberInfo, error) {
 	rows, err := database.conn.QueryContext(ctx,
-		`SELECT u.id, u.nick, u.last_seen
-		 FROM users u
+		`SELECT s.id, s.nick, s.last_seen
+		 FROM sessions s
 		 INNER JOIN channel_members cm
-		   ON cm.user_id = u.id
+		   ON cm.session_id = s.id
 		 WHERE cm.channel_id = ?
-		 ORDER BY u.nick`, channelID)
+		 ORDER BY s.nick`, channelID)
 	if err != nil {
 		return nil, fmt.Errorf(
 			"query channel members: %w", err,
@@ -349,17 +405,17 @@ func (database *Database) ChannelMembers(
 	return members, nil
 }
 
-// IsChannelMember checks if a user belongs to a channel.
+// IsChannelMember checks if a session belongs to a channel.
 func (database *Database) IsChannelMember(
 	ctx context.Context,
-	channelID, userID int64,
+	channelID, sessionID int64,
 ) (bool, error) {
 	var count int
 
 	err := database.conn.QueryRowContext(ctx,
 		`SELECT COUNT(*) FROM channel_members
-		 WHERE channel_id = ? AND user_id = ?`,
-		channelID, userID,
+		 WHERE channel_id = ? AND session_id = ?`,
+		channelID, sessionID,
 	).Scan(&count)
 	if err != nil {
 		return false, fmt.Errorf(
@@ -397,13 +453,13 @@ func scanInt64s(rows *sql.Rows) ([]int64, error) {
 	return ids, nil
 }
 
-// GetChannelMemberIDs returns user IDs in a channel.
+// GetChannelMemberIDs returns session IDs in a channel.
 func (database *Database) GetChannelMemberIDs(
 	ctx context.Context,
 	channelID int64,
 ) ([]int64, error) {
 	rows, err := database.conn.QueryContext(ctx,
-		`SELECT user_id FROM channel_members
+		`SELECT session_id FROM channel_members
 		 WHERE channel_id = ?`, channelID)
 	if err != nil {
 		return nil, fmt.Errorf(
@@ -414,17 +470,17 @@ func (database *Database) GetChannelMemberIDs(
 	return scanInt64s(rows)
 }
 
-// GetUserChannelIDs returns channel IDs the user is in.
-func (database *Database) GetUserChannelIDs(
+// GetSessionChannelIDs returns channel IDs for a session.
+func (database *Database) GetSessionChannelIDs(
 	ctx context.Context,
-	userID int64,
+	sessionID int64,
 ) ([]int64, error) {
 	rows, err := database.conn.QueryContext(ctx,
 		`SELECT channel_id FROM channel_members
-		 WHERE user_id = ?`, userID)
+		 WHERE session_id = ?`, sessionID)
 	if err != nil {
 		return nil, fmt.Errorf(
-			"get user channel ids: %w", err,
+			"get session channel ids: %w", err,
 		)
 	}
 
@@ -467,27 +523,52 @@ func (database *Database) InsertMessage(
 	return dbID, msgUUID, nil
 }
 
-// EnqueueMessage adds a message to a user's queue.
-func (database *Database) EnqueueMessage(
+// EnqueueToSession adds a message to all clients of a
+// session's queues.
+func (database *Database) EnqueueToSession(
 	ctx context.Context,
-	userID, messageID int64,
+	sessionID, messageID int64,
 ) error {
 	_, err := database.conn.ExecContext(ctx,
 		`INSERT OR IGNORE INTO client_queues
-		 (user_id, message_id, created_at)
-		 VALUES (?, ?, ?)`,
-		userID, messageID, time.Now())
+		 (client_id, message_id, created_at)
+		 SELECT c.id, ?, ?
+		 FROM clients c
+		 WHERE c.session_id = ?`,
+		messageID, time.Now(), sessionID)
 	if err != nil {
-		return fmt.Errorf("enqueue message: %w", err)
+		return fmt.Errorf(
+			"enqueue to session: %w", err,
+		)
 	}
 
 	return nil
 }
 
-// PollMessages returns queued messages for a user.
+// EnqueueToClient adds a message to a specific client's
+// queue.
+func (database *Database) EnqueueToClient(
+	ctx context.Context,
+	clientID, messageID int64,
+) error {
+	_, err := database.conn.ExecContext(ctx,
+		`INSERT OR IGNORE INTO client_queues
+		 (client_id, message_id, created_at)
+		 VALUES (?, ?, ?)`,
+		clientID, messageID, time.Now())
+	if err != nil {
+		return fmt.Errorf(
+			"enqueue to client: %w", err,
+		)
+	}
+
+	return nil
+}
+
+// PollMessages returns queued messages for a client.
 func (database *Database) PollMessages(
 	ctx context.Context,
-	userID, afterQueueID int64,
+	clientID, afterQueueID int64,
 	limit int,
 ) ([]IRCMessage, int64, error) {
 	if limit <= 0 {
@@ -501,9 +582,9 @@ func (database *Database) PollMessages(
 		 FROM client_queues cq
 		 INNER JOIN messages m
 		   ON m.id = cq.message_id
-		 WHERE cq.user_id = ? AND cq.id > ?
+		 WHERE cq.client_id = ? AND cq.id > ?
 		 ORDER BY cq.id ASC LIMIT ?`,
-		userID, afterQueueID, limit)
+		clientID, afterQueueID, limit)
 	if err != nil {
 		return nil, afterQueueID, fmt.Errorf(
 			"poll messages: %w", err,
@@ -649,15 +730,15 @@ func reverseMessages(msgs []IRCMessage) {
 	}
 }
 
-// ChangeNick updates a user's nickname.
+// ChangeNick updates a session's nickname.
 func (database *Database) ChangeNick(
 	ctx context.Context,
-	userID int64,
+	sessionID int64,
 	newNick string,
 ) error {
 	_, err := database.conn.ExecContext(ctx,
-		"UPDATE users SET nick = ? WHERE id = ?",
-		newNick, userID)
+		"UPDATE sessions SET nick = ? WHERE id = ?",
+		newNick, sessionID)
 	if err != nil {
 		return fmt.Errorf("change nick: %w", err)
 	}
@@ -681,38 +762,38 @@ func (database *Database) SetTopic(
 	return nil
 }
 
-// DeleteUser removes a user and all their data.
-func (database *Database) DeleteUser(
+// DeleteSession removes a session and all its data.
+func (database *Database) DeleteSession(
 	ctx context.Context,
-	userID int64,
+	sessionID int64,
 ) error {
 	_, err := database.conn.ExecContext(
 		ctx,
-		"DELETE FROM users WHERE id = ?",
-		userID,
+		"DELETE FROM sessions WHERE id = ?",
+		sessionID,
 	)
 	if err != nil {
-		return fmt.Errorf("delete user: %w", err)
+		return fmt.Errorf("delete session: %w", err)
 	}
 
 	return nil
 }
 
-// GetAllChannelMembershipsForUser returns channels
-// a user belongs to.
-func (database *Database) GetAllChannelMembershipsForUser(
+// GetSessionChannels returns channels a session
+// belongs to.
+func (database *Database) GetSessionChannels(
 	ctx context.Context,
-	userID int64,
+	sessionID int64,
 ) ([]ChannelInfo, error) {
 	rows, err := database.conn.QueryContext(ctx,
 		`SELECT c.id, c.name, c.topic
 		 FROM channels c
 		 INNER JOIN channel_members cm
 		   ON cm.channel_id = c.id
-		 WHERE cm.user_id = ?`, userID)
+		 WHERE cm.session_id = ?`, sessionID)
 	if err != nil {
 		return nil, fmt.Errorf(
-			"get memberships: %w", err,
+			"get session channels: %w", err,
 		)
 	}
 

internal/db/queries_test.go

@@ -27,70 +27,91 @@ func setupTestDB(t *testing.T) *db.Database {
 	return database
 }
 
-func TestCreateUser(t *testing.T) {
+func TestCreateSession(t *testing.T) {
 	t.Parallel()
 
 	database := setupTestDB(t)
 	ctx := t.Context()
 
-	id, token, err := database.CreateUser(ctx, "alice")
+	sessionID, _, token, err := database.CreateSession(
+		ctx, "alice",
+	)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	if id == 0 || token == "" {
+	if sessionID == 0 || token == "" {
 		t.Fatal("expected valid id and token")
 	}
 
-	_, _, err = database.CreateUser(ctx, "alice")
-	if err == nil {
+	_, _, dupToken, dupErr := database.CreateSession(
+		ctx, "alice",
+	)
+	if dupErr == nil {
 		t.Fatal("expected error for duplicate nick")
 	}
+
+	_ = dupToken
 }
 
-func TestGetUserByToken(t *testing.T) {
+func TestGetSessionByToken(t *testing.T) {
 	t.Parallel()
 
 	database := setupTestDB(t)
 	ctx := t.Context()
 
-	_, token, err := database.CreateUser(ctx, "bob")
+	_, _, token, err := database.CreateSession(ctx, "bob")
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	id, nick, err := database.GetUserByToken(ctx, token)
+	sessionID, clientID, nick, err :=
+		database.GetSessionByToken(ctx, token)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	if nick != "bob" || id == 0 {
+	if nick != "bob" || sessionID == 0 || clientID == 0 {
 		t.Fatalf("expected bob, got %s", nick)
 	}
 
-	_, _, err = database.GetUserByToken(ctx, "badtoken")
-	if err == nil {
+	badSID, badCID, badNick, badErr :=
+		database.GetSessionByToken(ctx, "badtoken")
+	if badErr == nil {
 		t.Fatal("expected error for bad token")
 	}
+
+	if badSID != 0 || badCID != 0 || badNick != "" {
+		t.Fatal("expected zero values on error")
+	}
 }
 
-func TestGetUserByNick(t *testing.T) {
+func TestGetSessionByNick(t *testing.T) {
 	t.Parallel()
 
 	database := setupTestDB(t)
 	ctx := t.Context()
 
-	_, _, err := database.CreateUser(ctx, "charlie")
+	charlieID, charlieClientID, charlieToken, err :=
+		database.CreateSession(ctx, "charlie")
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	id, err := database.GetUserByNick(ctx, "charlie")
+	if charlieID == 0 || charlieClientID == 0 {
+		t.Fatal("expected valid session/client IDs")
+	}
+
+	if charlieToken == "" {
+		t.Fatal("expected non-empty token")
+	}
+
+	id, err := database.GetSessionByNick(ctx, "charlie")
 	if err != nil || id == 0 {
 		t.Fatal("expected to find charlie")
 	}
 
-	_, err = database.GetUserByNick(ctx, "nobody")
+	_, err = database.GetSessionByNick(ctx, "nobody")
 	if err == nil {
 		t.Fatal("expected error for unknown nick")
 	}
@@ -129,7 +150,7 @@ func TestJoinAndPart(t *testing.T) {
 	database := setupTestDB(t)
 	ctx := t.Context()
 
-	uid, _, err := database.CreateUser(ctx, "user1")
+	sid, _, _, err := database.CreateSession(ctx, "user1")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -139,22 +160,22 @@ func TestJoinAndPart(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	err = database.JoinChannel(ctx, chID, uid)
+	err = database.JoinChannel(ctx, chID, sid)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	ids, err := database.GetChannelMemberIDs(ctx, chID)
-	if err != nil || len(ids) != 1 || ids[0] != uid {
-		t.Fatal("expected user in channel")
+	if err != nil || len(ids) != 1 || ids[0] != sid {
+		t.Fatal("expected session in channel")
 	}
 
-	err = database.JoinChannel(ctx, chID, uid)
+	err = database.JoinChannel(ctx, chID, sid)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	err = database.PartChannel(ctx, chID, uid)
+	err = database.PartChannel(ctx, chID, sid)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -178,17 +199,17 @@ func TestDeleteChannelIfEmpty(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	uid, _, err := database.CreateUser(ctx, "temp")
+	sid, _, _, err := database.CreateSession(ctx, "temp")
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	err = database.JoinChannel(ctx, chID, uid)
+	err = database.JoinChannel(ctx, chID, sid)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	err = database.PartChannel(ctx, chID, uid)
+	err = database.PartChannel(ctx, chID, sid)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -204,7 +225,7 @@ func TestDeleteChannelIfEmpty(t *testing.T) {
 	}
 }
 
-func createUserWithChannels(
+func createSessionWithChannels(
 	t *testing.T,
 	database *db.Database,
 	nick, ch1Name, ch2Name string,
@@ -213,7 +234,7 @@ func createUserWithChannels(
 
 	ctx := t.Context()
 
-	uid, _, err := database.CreateUser(ctx, nick)
+	sid, _, _, err := database.CreateSession(ctx, nick)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -232,29 +253,29 @@ func createUserWithChannels(
 		t.Fatal(err)
 	}
 
-	err = database.JoinChannel(ctx, ch1, uid)
+	err = database.JoinChannel(ctx, ch1, sid)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	err = database.JoinChannel(ctx, ch2, uid)
+	err = database.JoinChannel(ctx, ch2, sid)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	return uid, ch1, ch2
+	return sid, ch1, ch2
 }
 
 func TestListChannels(t *testing.T) {
 	t.Parallel()
 
 	database := setupTestDB(t)
-	uid, _, _ := createUserWithChannels(
+	sid, _, _ := createSessionWithChannels(
 		t, database, "lister", "#a", "#b",
 	)
 
 	channels, err := database.ListChannels(
-		t.Context(), uid,
+		t.Context(), sid,
 	)
 	if err != nil || len(channels) != 2 {
 		t.Fatalf(
@@ -295,17 +316,21 @@ func TestChangeNick(t *testing.T) {
 	database := setupTestDB(t)
 	ctx := t.Context()
 
-	uid, token, err := database.CreateUser(ctx, "old")
+	sid, _, token, err := database.CreateSession(
+		ctx, "old",
+	)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	err = database.ChangeNick(ctx, uid, "new")
+	err = database.ChangeNick(ctx, sid, "new")
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	_, nick, err := database.GetUserByToken(ctx, token)
+	_, _, nick, err := database.GetSessionByToken(
+		ctx, token,
+	)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -375,7 +400,16 @@ func TestPollMessages(t *testing.T) {
 	database := setupTestDB(t)
 	ctx := t.Context()
 
-	uid, _, err := database.CreateUser(ctx, "poller")
+	sid, _, token, err := database.CreateSession(
+		ctx, "poller",
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, clientID, _, err := database.GetSessionByToken(
+		ctx, token,
+	)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -389,7 +423,7 @@ func TestPollMessages(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	err = database.EnqueueMessage(ctx, uid, dbID)
+	err = database.EnqueueToSession(ctx, sid, dbID)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -397,7 +431,7 @@ func TestPollMessages(t *testing.T) {
 	const batchSize = 10
 
 	msgs, lastQID, err := database.PollMessages(
-		ctx, uid, 0, batchSize,
+		ctx, clientID, 0, batchSize,
 	)
 	if err != nil {
 		t.Fatal(err)
@@ -420,7 +454,7 @@ func TestPollMessages(t *testing.T) {
 	}
 
 	msgs, _, _ = database.PollMessages(
-		ctx, uid, lastQID, batchSize,
+		ctx, clientID, lastQID, batchSize,
 	)
 
 	if len(msgs) != 0 {
@@ -467,13 +501,15 @@ func TestGetHistory(t *testing.T) {
 	}
 }
 
-func TestDeleteUser(t *testing.T) {
+func TestDeleteSession(t *testing.T) {
 	t.Parallel()
 
 	database := setupTestDB(t)
 	ctx := t.Context()
 
-	uid, _, err := database.CreateUser(ctx, "deleteme")
+	sid, _, _, err := database.CreateSession(
+		ctx, "deleteme",
+	)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -485,19 +521,19 @@ func TestDeleteUser(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	err = database.JoinChannel(ctx, chID, uid)
+	err = database.JoinChannel(ctx, chID, sid)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	err = database.DeleteUser(ctx, uid)
+	err = database.DeleteSession(ctx, sid)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	_, err = database.GetUserByNick(ctx, "deleteme")
+	_, err = database.GetSessionByNick(ctx, "deleteme")
 	if err == nil {
-		t.Fatal("user should be deleted")
+		t.Fatal("session should be deleted")
 	}
 
 	ids, _ := database.GetChannelMemberIDs(ctx, chID)
@@ -512,12 +548,12 @@ func TestChannelMembers(t *testing.T) {
 	database := setupTestDB(t)
 	ctx := t.Context()
 
-	uid1, _, err := database.CreateUser(ctx, "m1")
+	sid1, _, _, err := database.CreateSession(ctx, "m1")
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	uid2, _, err := database.CreateUser(ctx, "m2")
+	sid2, _, _, err := database.CreateSession(ctx, "m2")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -529,12 +565,12 @@ func TestChannelMembers(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	err = database.JoinChannel(ctx, chID, uid1)
+	err = database.JoinChannel(ctx, chID, sid1)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	err = database.JoinChannel(ctx, chID, uid2)
+	err = database.JoinChannel(ctx, chID, sid2)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -548,17 +584,17 @@ func TestChannelMembers(t *testing.T) {
 	}
 }
 
-func TestGetAllChannelMembershipsForUser(t *testing.T) {
+func TestGetSessionChannels(t *testing.T) {
 	t.Parallel()
 
 	database := setupTestDB(t)
-	uid, _, _ := createUserWithChannels(
+	sid, _, _ := createSessionWithChannels(
 		t, database, "multi", "#m1", "#m2",
 	)
 
 	channels, err :=
-		database.GetAllChannelMembershipsForUser(
-			t.Context(), uid,
+		database.GetSessionChannels(
+			t.Context(), sid,
 		)
 	if err != nil || len(channels) != 2 {
 		t.Fatalf(
@@ -567,3 +603,51 @@ func TestGetAllChannelMembershipsForUser(t *testing.T) {
 		)
 	}
 }
+
+func TestEnqueueToClient(t *testing.T) {
+	t.Parallel()
+
+	database := setupTestDB(t)
+	ctx := t.Context()
+
+	_, _, token, err := database.CreateSession(
+		ctx, "enqclient",
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, clientID, _, err := database.GetSessionByToken(
+		ctx, token,
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	body := json.RawMessage(`["test"]`)
+
+	dbID, _, err := database.InsertMessage(
+		ctx, "PRIVMSG", "sender", "#ch", body, nil,
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = database.EnqueueToClient(ctx, clientID, dbID)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	const batchSize = 10
+
+	msgs, _, err := database.PollMessages(
+		ctx, clientID, 0, batchSize,
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(msgs) != 1 {
+		t.Fatalf("expected 1, got %d", len(msgs))
+	}
+}

internal/db/schema/001_initial.sql

@@ -1,15 +1,28 @@
 -- Chat server schema (pre-1.0 consolidated)
 PRAGMA foreign_keys = ON;
 
--- Users: IRC-style sessions (no passwords, just nick + token)
-CREATE TABLE IF NOT EXISTS users (
+-- Sessions: IRC-style sessions (no passwords, nick + optional signing key)
+CREATE TABLE IF NOT EXISTS sessions (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
+    uuid TEXT NOT NULL UNIQUE,
     nick TEXT NOT NULL UNIQUE,
+    signing_key TEXT NOT NULL DEFAULT '',
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    last_seen DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+CREATE INDEX IF NOT EXISTS idx_sessions_uuid ON sessions(uuid);
+
+-- Clients: each session can have multiple connected clients
+CREATE TABLE IF NOT EXISTS clients (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    uuid TEXT NOT NULL UNIQUE,
+    session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
     token TEXT NOT NULL UNIQUE,
     created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
     last_seen DATETIME DEFAULT CURRENT_TIMESTAMP
 );
-CREATE INDEX IF NOT EXISTS idx_users_token ON users(token);
+CREATE INDEX IF NOT EXISTS idx_clients_token ON clients(token);
+CREATE INDEX IF NOT EXISTS idx_clients_session ON clients(session_id);
 
 -- Channels
 CREATE TABLE IF NOT EXISTS channels (
@@ -24,9 +37,9 @@ CREATE TABLE IF NOT EXISTS channels (
 CREATE TABLE IF NOT EXISTS channel_members (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     channel_id INTEGER NOT NULL REFERENCES channels(id) ON DELETE CASCADE,
-    user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
     joined_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-    UNIQUE(channel_id, user_id)
+    UNIQUE(channel_id, session_id)
 );
 
 -- Messages: IRC envelope format
@@ -46,9 +59,9 @@ CREATE INDEX IF NOT EXISTS idx_messages_created ON messages(created_at);
 -- Per-client message queues for fan-out delivery
 CREATE TABLE IF NOT EXISTS client_queues (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
-    user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    client_id INTEGER NOT NULL REFERENCES clients(id) ON DELETE CASCADE,
     message_id INTEGER NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
     created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-    UNIQUE(user_id, message_id)
+    UNIQUE(client_id, message_id)
 );
-CREATE INDEX IF NOT EXISTS idx_client_queues_user ON client_queues(user_id, id);
+CREATE INDEX IF NOT EXISTS idx_client_queues_client ON client_queues(client_id, id);

internal/handlers/api.go

@@ -1,6 +1,7 @@
 package handlers
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"net/http"
@@ -37,35 +38,37 @@ func (hdlr *Handlers) maxBodySize() int64 {
 	return defaultMaxBodySize
 }
 
-// authUser extracts the user from the Authorization header.
-func (hdlr *Handlers) authUser(
+// authSession extracts the session from the client token.
+func (hdlr *Handlers) authSession(
 	request *http.Request,
-) (int64, string, error) {
+) (int64, int64, string, error) {
 	auth := request.Header.Get("Authorization")
 	if !strings.HasPrefix(auth, "Bearer ") {
-		return 0, "", errUnauthorized
+		return 0, 0, "", errUnauthorized
 	}
 
 	token := strings.TrimPrefix(auth, "Bearer ")
 	if token == "" {
-		return 0, "", errUnauthorized
+		return 0, 0, "", errUnauthorized
 	}
 
-	uid, nick, err := hdlr.params.Database.GetUserByToken(
-		request.Context(), token,
-	)
+	sessionID, clientID, nick, err :=
+		hdlr.params.Database.GetSessionByToken(
+			request.Context(), token,
+		)
 	if err != nil {
-		return 0, "", fmt.Errorf("auth: %w", err)
+		return 0, 0, "", fmt.Errorf("auth: %w", err)
 	}
 
-	return uid, nick, nil
+	return sessionID, clientID, nick, nil
 }
 
 func (hdlr *Handlers) requireAuth(
 	writer http.ResponseWriter,
 	request *http.Request,
-) (int64, string, bool) {
-	uid, nick, err := hdlr.authUser(request)
+) (int64, int64, string, bool) {
+	sessionID, clientID, nick, err :=
+		hdlr.authSession(request)
 	if err != nil {
 		hdlr.respondError(
 			writer, request,
@@ -73,19 +76,19 @@ func (hdlr *Handlers) requireAuth(
 			http.StatusUnauthorized,
 		)
 
-		return 0, "", false
+		return 0, 0, "", false
 	}
 
-	return uid, nick, true
+	return sessionID, clientID, nick, true
 }
 
 // fanOut stores a message and enqueues it to all specified
-// user IDs, then notifies them.
+// session IDs, then notifies them.
 func (hdlr *Handlers) fanOut(
 	request *http.Request,
 	command, from, target string,
 	body json.RawMessage,
-	userIDs []int64,
+	sessionIDs []int64,
 ) (string, error) {
 	dbID, msgUUID, err := hdlr.params.Database.InsertMessage(
 		request.Context(), command, from, target, body, nil,
@@ -94,16 +97,16 @@ func (hdlr *Handlers) fanOut(
 		return "", fmt.Errorf("insert message: %w", err)
 	}
 
-	for _, uid := range userIDs {
-		enqErr := hdlr.params.Database.EnqueueMessage(
-			request.Context(), uid, dbID,
+	for _, sid := range sessionIDs {
+		enqErr := hdlr.params.Database.EnqueueToSession(
+			request.Context(), sid, dbID,
 		)
 		if enqErr != nil {
 			hdlr.log.Error("enqueue failed",
-				"error", enqErr, "user_id", uid)
+				"error", enqErr, "session_id", sid)
 		}
 
-		hdlr.broker.Notify(uid)
+		hdlr.broker.Notify(sid)
 	}
 
 	return msgUUID, nil
@@ -114,10 +117,10 @@ func (hdlr *Handlers) fanOutSilent(
 	request *http.Request,
 	command, from, target string,
 	body json.RawMessage,
-	userIDs []int64,
+	sessionIDs []int64,
 ) error {
 	_, err := hdlr.fanOut(
-		request, command, from, target, body, userIDs,
+		request, command, from, target, body, sessionIDs,
 	)
 
 	return err
@@ -125,16 +128,6 @@ func (hdlr *Handlers) fanOutSilent(
 
 // HandleCreateSession creates a new user session.
 func (hdlr *Handlers) HandleCreateSession() http.HandlerFunc {
-	type createRequest struct {
-		Nick string `json:"nick"`
-	}
-
-	type createResponse struct {
-		ID    int64  `json:"id"`
-		Nick  string `json:"nick"`
-		Token string `json:"token"`
-	}
-
 	return func(
 		writer http.ResponseWriter,
 		request *http.Request,
@@ -143,82 +136,174 @@ func (hdlr *Handlers) HandleCreateSession() http.HandlerFunc {
 			writer, request.Body, hdlr.maxBodySize(),
 		)
 
-		var payload createRequest
-
-		err := json.NewDecoder(request.Body).Decode(&payload)
-		if err != nil {
-			hdlr.respondError(
-				writer, request,
-				"invalid request body",
-				http.StatusBadRequest,
-			)
-
-			return
-		}
-
-		payload.Nick = strings.TrimSpace(payload.Nick)
-
-		if !validNickRe.MatchString(payload.Nick) {
-			hdlr.respondError(
-				writer, request,
-				"invalid nick format",
-				http.StatusBadRequest,
-			)
-
-			return
-		}
-
-		userID, token, err := hdlr.params.Database.CreateUser(
-			request.Context(), payload.Nick,
-		)
-		if err != nil {
-			if strings.Contains(err.Error(), "UNIQUE") {
-				hdlr.respondError(
-					writer, request,
-					"nick already taken",
-					http.StatusConflict,
-				)
-
-				return
-			}
-
-			hdlr.log.Error(
-				"create user failed", "error", err,
-			)
-			hdlr.respondError(
-				writer, request,
-				"internal error",
-				http.StatusInternalServerError,
-			)
-
-			return
-		}
-
-		hdlr.respondJSON(
-			writer, request,
-			&createResponse{
-				ID:    userID,
-				Nick:  payload.Nick,
-				Token: token,
-			},
-			http.StatusCreated,
-		)
+		hdlr.handleCreateSession(writer, request)
 	}
 }
 
-// HandleState returns the current user's info and channels.
+func (hdlr *Handlers) handleCreateSession(
+	writer http.ResponseWriter,
+	request *http.Request,
+) {
+	type createRequest struct {
+		Nick string `json:"nick"`
+	}
+
+	var payload createRequest
+
+	err := json.NewDecoder(request.Body).Decode(&payload)
+	if err != nil {
+		hdlr.respondError(
+			writer, request,
+			"invalid request body",
+			http.StatusBadRequest,
+		)
+
+		return
+	}
+
+	payload.Nick = strings.TrimSpace(payload.Nick)
+
+	if !validNickRe.MatchString(payload.Nick) {
+		hdlr.respondError(
+			writer, request,
+			"invalid nick format",
+			http.StatusBadRequest,
+		)
+
+		return
+	}
+
+	sessionID, clientID, token, err :=
+		hdlr.params.Database.CreateSession(
+			request.Context(), payload.Nick,
+		)
+	if err != nil {
+		hdlr.handleCreateSessionError(
+			writer, request, err,
+		)
+
+		return
+	}
+
+	hdlr.deliverMOTD(request, clientID, sessionID)
+
+	hdlr.respondJSON(writer, request, map[string]any{
+		"id":    sessionID,
+		"nick":  payload.Nick,
+		"token": token,
+	}, http.StatusCreated)
+}
+
+func (hdlr *Handlers) handleCreateSessionError(
+	writer http.ResponseWriter,
+	request *http.Request,
+	err error,
+) {
+	if strings.Contains(err.Error(), "UNIQUE") {
+		hdlr.respondError(
+			writer, request,
+			"nick already taken",
+			http.StatusConflict,
+		)
+
+		return
+	}
+
+	hdlr.log.Error(
+		"create session failed", "error", err,
+	)
+	hdlr.respondError(
+		writer, request,
+		"internal error",
+		http.StatusInternalServerError,
+	)
+}
+
+// deliverMOTD sends the MOTD as IRC numeric messages to a
+// new client.
+func (hdlr *Handlers) deliverMOTD(
+	request *http.Request,
+	clientID, sessionID int64,
+) {
+	motd := hdlr.params.Config.MOTD
+	serverName := hdlr.params.Config.ServerName
+
+	if serverName == "" {
+		serverName = "chat"
+	}
+
+	if motd == "" {
+		return
+	}
+
+	ctx := request.Context()
+
+	hdlr.enqueueNumeric(
+		ctx, clientID, "375", serverName,
+		"- "+serverName+" Message of the Day -",
+	)
+
+	for line := range strings.SplitSeq(motd, "\n") {
+		hdlr.enqueueNumeric(
+			ctx, clientID, "372", serverName,
+			"- "+line,
+		)
+	}
+
+	hdlr.enqueueNumeric(
+		ctx, clientID, "376", serverName,
+		"End of /MOTD command.",
+	)
+
+	hdlr.broker.Notify(sessionID)
+}
+
+func (hdlr *Handlers) enqueueNumeric(
+	ctx context.Context,
+	clientID int64,
+	command, serverName, text string,
+) {
+	body, err := json.Marshal([]string{text})
+	if err != nil {
+		hdlr.log.Error(
+			"marshal numeric body", "error", err,
+		)
+
+		return
+	}
+
+	dbID, _, insertErr := hdlr.params.Database.InsertMessage(
+		ctx, command, serverName, "",
+		json.RawMessage(body), nil,
+	)
+	if insertErr != nil {
+		hdlr.log.Error(
+			"insert numeric message", "error", insertErr,
+		)
+
+		return
+	}
+
+	_ = hdlr.params.Database.EnqueueToClient(
+		ctx, clientID, dbID,
+	)
+}
+
+// HandleState returns the current session's info and
+// channels.
 func (hdlr *Handlers) HandleState() http.HandlerFunc {
 	return func(
 		writer http.ResponseWriter,
 		request *http.Request,
 	) {
-		uid, nick, ok := hdlr.requireAuth(writer, request)
+		sessionID, _, nick, ok :=
+			hdlr.requireAuth(writer, request)
 		if !ok {
 			return
 		}
 
 		channels, err := hdlr.params.Database.ListChannels(
-			request.Context(), uid,
+			request.Context(), sessionID,
 		)
 		if err != nil {
 			hdlr.log.Error(
@@ -234,7 +319,7 @@ func (hdlr *Handlers) HandleState() http.HandlerFunc {
 		}
 
 		hdlr.respondJSON(writer, request, map[string]any{
-			"id":       uid,
+			"id":       sessionID,
 			"nick":     nick,
 			"channels": channels,
 		}, http.StatusOK)
@@ -247,7 +332,7 @@ func (hdlr *Handlers) HandleListAllChannels() http.HandlerFunc {
 		writer http.ResponseWriter,
 		request *http.Request,
 	) {
-		_, _, ok := hdlr.requireAuth(writer, request)
+		_, _, _, ok := hdlr.requireAuth(writer, request)
 		if !ok {
 			return
 		}
@@ -280,7 +365,7 @@ func (hdlr *Handlers) HandleChannelMembers() http.HandlerFunc {
 		writer http.ResponseWriter,
 		request *http.Request,
 	) {
-		_, _, ok := hdlr.requireAuth(writer, request)
+		_, _, _, ok := hdlr.requireAuth(writer, request)
 		if !ok {
 			return
 		}
@@ -328,7 +413,8 @@ func (hdlr *Handlers) HandleGetMessages() http.HandlerFunc {
 		writer http.ResponseWriter,
 		request *http.Request,
 	) {
-		uid, _, ok := hdlr.requireAuth(writer, request)
+		sessionID, clientID, _, ok :=
+			hdlr.requireAuth(writer, request)
 		if !ok {
 			return
 		}
@@ -349,7 +435,7 @@ func (hdlr *Handlers) HandleGetMessages() http.HandlerFunc {
 		}
 
 		msgs, lastQID, err := hdlr.params.Database.PollMessages(
-			request.Context(), uid,
+			request.Context(), clientID,
 			afterID, pollMessageLimit,
 		)
 		if err != nil {
@@ -374,17 +460,20 @@ func (hdlr *Handlers) HandleGetMessages() http.HandlerFunc {
 			return
 		}
 
-		hdlr.longPoll(writer, request, uid, afterID, timeout)
+		hdlr.longPoll(
+			writer, request,
+			sessionID, clientID, afterID, timeout,
+		)
 	}
 }
 
 func (hdlr *Handlers) longPoll(
 	writer http.ResponseWriter,
 	request *http.Request,
-	uid, afterID int64,
+	sessionID, clientID, afterID int64,
 	timeout int,
 ) {
-	waitCh := hdlr.broker.Wait(uid)
+	waitCh := hdlr.broker.Wait(sessionID)
 
 	timer := time.NewTimer(
 		time.Duration(timeout) * time.Second,
@@ -396,15 +485,15 @@ func (hdlr *Handlers) longPoll(
 	case <-waitCh:
 	case <-timer.C:
 	case <-request.Context().Done():
-		hdlr.broker.Remove(uid, waitCh)
+		hdlr.broker.Remove(sessionID, waitCh)
 
 		return
 	}
 
-	hdlr.broker.Remove(uid, waitCh)
+	hdlr.broker.Remove(sessionID, waitCh)
 
 	msgs, lastQID, err := hdlr.params.Database.PollMessages(
-		request.Context(), uid,
+		request.Context(), clientID,
 		afterID, pollMessageLimit,
 	)
 	if err != nil {
@@ -443,7 +532,8 @@ func (hdlr *Handlers) HandleSendCommand() http.HandlerFunc {
 			writer, request.Body, hdlr.maxBodySize(),
 		)
 
-		uid, nick, ok := hdlr.requireAuth(writer, request)
+		sessionID, _, nick, ok :=
+			hdlr.requireAuth(writer, request)
 		if !ok {
 			return
 		}
@@ -492,7 +582,7 @@ func (hdlr *Handlers) HandleSendCommand() http.HandlerFunc {
 		}
 
 		hdlr.dispatchCommand(
-			writer, request, uid, nick,
+			writer, request, sessionID, nick,
 			payload.Command, payload.To,
 			payload.Body, bodyLines,
 		)
@@ -502,7 +592,7 @@ func (hdlr *Handlers) HandleSendCommand() http.HandlerFunc {
 func (hdlr *Handlers) dispatchCommand(
 	writer http.ResponseWriter,
 	request *http.Request,
-	uid int64,
+	sessionID int64,
 	nick, command, target string,
 	body json.RawMessage,
 	bodyLines func() []string,
@@ -510,20 +600,20 @@ func (hdlr *Handlers) dispatchCommand(
 	switch command {
 	case cmdPrivmsg, "NOTICE":
 		hdlr.handlePrivmsg(
-			writer, request, uid, nick,
+			writer, request, sessionID, nick,
 			command, target, body, bodyLines,
 		)
 	case "JOIN":
 		hdlr.handleJoin(
-			writer, request, uid, nick, target,
+			writer, request, sessionID, nick, target,
 		)
 	case "PART":
 		hdlr.handlePart(
-			writer, request, uid, nick, target, body,
+			writer, request, sessionID, nick, target, body,
 		)
 	case "NICK":
 		hdlr.handleNick(
-			writer, request, uid, nick, bodyLines,
+			writer, request, sessionID, nick, bodyLines,
 		)
 	case "TOPIC":
 		hdlr.handleTopic(
@@ -531,7 +621,7 @@ func (hdlr *Handlers) dispatchCommand(
 		)
 	case "QUIT":
 		hdlr.handleQuit(
-			writer, request, uid, nick, body,
+			writer, request, sessionID, nick, body,
 		)
 	case "PING":
 		hdlr.respondJSON(writer, request,
@@ -552,7 +642,7 @@ func (hdlr *Handlers) dispatchCommand(
 func (hdlr *Handlers) handlePrivmsg(
 	writer http.ResponseWriter,
 	request *http.Request,
-	uid int64,
+	sessionID int64,
 	nick, command, target string,
 	body json.RawMessage,
 	bodyLines func() []string,
@@ -580,7 +670,7 @@ func (hdlr *Handlers) handlePrivmsg(
 
 	if strings.HasPrefix(target, "#") {
 		hdlr.handleChannelMsg(
-			writer, request, uid, nick,
+			writer, request, sessionID, nick,
 			command, target, body,
 		)
 
@@ -588,7 +678,7 @@ func (hdlr *Handlers) handlePrivmsg(
 	}
 
 	hdlr.handleDirectMsg(
-		writer, request, uid, nick,
+		writer, request, sessionID, nick,
 		command, target, body,
 	)
 }
@@ -596,7 +686,7 @@ func (hdlr *Handlers) handlePrivmsg(
 func (hdlr *Handlers) handleChannelMsg(
 	writer http.ResponseWriter,
 	request *http.Request,
-	uid int64,
+	sessionID int64,
 	nick, command, target string,
 	body json.RawMessage,
 ) {
@@ -614,7 +704,7 @@ func (hdlr *Handlers) handleChannelMsg(
 	}
 
 	isMember, err := hdlr.params.Database.IsChannelMember(
-		request.Context(), chID, uid,
+		request.Context(), chID, sessionID,
 	)
 	if err != nil {
 		hdlr.log.Error(
@@ -677,11 +767,11 @@ func (hdlr *Handlers) handleChannelMsg(
 func (hdlr *Handlers) handleDirectMsg(
 	writer http.ResponseWriter,
 	request *http.Request,
-	uid int64,
+	sessionID int64,
 	nick, command, target string,
 	body json.RawMessage,
 ) {
-	targetUID, err := hdlr.params.Database.GetUserByNick(
+	targetSID, err := hdlr.params.Database.GetSessionByNick(
 		request.Context(), target,
 	)
 	if err != nil {
@@ -694,9 +784,9 @@ func (hdlr *Handlers) handleDirectMsg(
 		return
 	}
 
-	recipients := []int64{targetUID}
-	if targetUID != uid {
-		recipients = append(recipients, uid)
+	recipients := []int64{targetSID}
+	if targetSID != sessionID {
+		recipients = append(recipients, sessionID)
 	}
 
 	msgUUID, err := hdlr.fanOut(
@@ -721,7 +811,7 @@ func (hdlr *Handlers) handleDirectMsg(
 func (hdlr *Handlers) handleJoin(
 	writer http.ResponseWriter,
 	request *http.Request,
-	uid int64,
+	sessionID int64,
 	nick, target string,
 ) {
 	if target == "" {
@@ -766,7 +856,7 @@ func (hdlr *Handlers) handleJoin(
 	}
 
 	err = hdlr.params.Database.JoinChannel(
-		request.Context(), chID, uid,
+		request.Context(), chID, sessionID,
 	)
 	if err != nil {
 		hdlr.log.Error(
@@ -800,7 +890,7 @@ func (hdlr *Handlers) handleJoin(
 func (hdlr *Handlers) handlePart(
 	writer http.ResponseWriter,
 	request *http.Request,
-	uid int64,
+	sessionID int64,
 	nick, target string,
 	body json.RawMessage,
 ) {
@@ -841,7 +931,7 @@ func (hdlr *Handlers) handlePart(
 	)
 
 	err = hdlr.params.Database.PartChannel(
-		request.Context(), chID, uid,
+		request.Context(), chID, sessionID,
 	)
 	if err != nil {
 		hdlr.log.Error(
@@ -871,7 +961,7 @@ func (hdlr *Handlers) handlePart(
 func (hdlr *Handlers) handleNick(
 	writer http.ResponseWriter,
 	request *http.Request,
-	uid int64,
+	sessionID int64,
 	nick string,
 	bodyLines func() []string,
 ) {
@@ -909,7 +999,7 @@ func (hdlr *Handlers) handleNick(
 	}
 
 	err := hdlr.params.Database.ChangeNick(
-		request.Context(), uid, newNick,
+		request.Context(), sessionID, newNick,
 	)
 	if err != nil {
 		if strings.Contains(err.Error(), "UNIQUE") {
@@ -934,7 +1024,7 @@ func (hdlr *Handlers) handleNick(
 		return
 	}
 
-	hdlr.broadcastNick(request, uid, nick, newNick)
+	hdlr.broadcastNick(request, sessionID, nick, newNick)
 
 	hdlr.respondJSON(writer, request,
 		map[string]string{
@@ -945,15 +1035,15 @@ func (hdlr *Handlers) handleNick(
 
 func (hdlr *Handlers) broadcastNick(
 	request *http.Request,
-	uid int64,
+	sessionID int64,
 	oldNick, newNick string,
 ) {
 	channels, _ := hdlr.params.Database.
-		GetAllChannelMembershipsForUser(
-			request.Context(), uid,
+		GetSessionChannels(
+			request.Context(), sessionID,
 		)
 
-	notified := map[int64]bool{uid: true}
+	notified := map[int64]bool{sessionID: true}
 
 	nickBody, err := json.Marshal([]string{newNick})
 	if err != nil {
@@ -969,11 +1059,11 @@ func (hdlr *Handlers) broadcastNick(
 		json.RawMessage(nickBody), nil,
 	)
 
-	_ = hdlr.params.Database.EnqueueMessage(
-		request.Context(), uid, dbID,
+	_ = hdlr.params.Database.EnqueueToSession(
+		request.Context(), sessionID, dbID,
 	)
 
-	hdlr.broker.Notify(uid)
+	hdlr.broker.Notify(sessionID)
 
 	for _, chanInfo := range channels {
 		memberIDs, _ := hdlr.params.Database.
@@ -985,7 +1075,7 @@ func (hdlr *Handlers) broadcastNick(
 			if !notified[mid] {
 				notified[mid] = true
 
-				_ = hdlr.params.Database.EnqueueMessage(
+				_ = hdlr.params.Database.EnqueueToSession(
 					request.Context(), mid, dbID,
 				)
 
@@ -1077,13 +1167,13 @@ func (hdlr *Handlers) handleTopic(
 func (hdlr *Handlers) handleQuit(
 	writer http.ResponseWriter,
 	request *http.Request,
-	uid int64,
+	sessionID int64,
 	nick string,
 	body json.RawMessage,
 ) {
 	channels, _ := hdlr.params.Database.
-		GetAllChannelMembershipsForUser(
-			request.Context(), uid,
+		GetSessionChannels(
+			request.Context(), sessionID,
 		)
 
 	notified := map[int64]bool{}
@@ -1103,10 +1193,10 @@ func (hdlr *Handlers) handleQuit(
 			)
 
 		for _, mid := range memberIDs {
-			if mid != uid && !notified[mid] {
+			if mid != sessionID && !notified[mid] {
 				notified[mid] = true
 
-				_ = hdlr.params.Database.EnqueueMessage(
+				_ = hdlr.params.Database.EnqueueToSession(
 					request.Context(), mid, dbID,
 				)
 
@@ -1115,7 +1205,7 @@ func (hdlr *Handlers) handleQuit(
 		}
 
 		_ = hdlr.params.Database.PartChannel(
-			request.Context(), chanInfo.ID, uid,
+			request.Context(), chanInfo.ID, sessionID,
 		)
 
 		_ = hdlr.params.Database.DeleteChannelIfEmpty(
@@ -1123,8 +1213,8 @@ func (hdlr *Handlers) handleQuit(
 		)
 	}
 
-	_ = hdlr.params.Database.DeleteUser(
-		request.Context(), uid,
+	_ = hdlr.params.Database.DeleteSession(
+		request.Context(), sessionID,
 	)
 
 	hdlr.respondJSON(writer, request,
@@ -1138,7 +1228,8 @@ func (hdlr *Handlers) HandleGetHistory() http.HandlerFunc {
 		writer http.ResponseWriter,
 		request *http.Request,
 	) {
-		uid, nick, ok := hdlr.requireAuth(writer, request)
+		sessionID, _, nick, ok :=
+			hdlr.requireAuth(writer, request)
 		if !ok {
 			return
 		}
@@ -1155,7 +1246,7 @@ func (hdlr *Handlers) HandleGetHistory() http.HandlerFunc {
 		}
 
 		if !hdlr.canAccessHistory(
-			writer, request, uid, nick, target,
+			writer, request, sessionID, nick, target,
 		) {
 			return
 		}
@@ -1198,12 +1289,12 @@ func (hdlr *Handlers) HandleGetHistory() http.HandlerFunc {
 func (hdlr *Handlers) canAccessHistory(
 	writer http.ResponseWriter,
 	request *http.Request,
-	uid int64,
+	sessionID int64,
 	nick, target string,
 ) bool {
 	if strings.HasPrefix(target, "#") {
 		return hdlr.canAccessChannelHistory(
-			writer, request, uid, target,
+			writer, request, sessionID, target,
 		)
 	}
 
@@ -1225,7 +1316,7 @@ func (hdlr *Handlers) canAccessHistory(
 func (hdlr *Handlers) canAccessChannelHistory(
 	writer http.ResponseWriter,
 	request *http.Request,
-	uid int64,
+	sessionID int64,
 	target string,
 ) bool {
 	chID, err := hdlr.params.Database.GetChannelByName(
@@ -1242,7 +1333,7 @@ func (hdlr *Handlers) canAccessChannelHistory(
 	}
 
 	isMember, err := hdlr.params.Database.IsChannelMember(
-		request.Context(), chID, uid,
+		request.Context(), chID, sessionID,
 	)
 	if err != nil {
 		hdlr.log.Error(