@devchitchat/chat 0.0.0

package/src/adapters/InMemoryReactionRepository.js

@@ -0,0 +1,45 @@
+export class InMemoryReactionRepository {
+  constructor() {
+    this._reactions = [] // { reaction_id, msg_id, channel_id, user_id, emoji, ts }
+  }
+
+  upsertReaction({ reactionId, msgId, channelId, userId, emoji, ts }) {
+    const exists = this._reactions.find(r => r.msg_id === msgId && r.user_id === userId && r.emoji === emoji)
+    if (!exists) {
+      this._reactions.push({ reaction_id: reactionId, msg_id: msgId, channel_id: channelId, user_id: userId, emoji, ts })
+    }
+  }
+
+  removeReaction({ msgId, userId, emoji }) {
+    this._reactions = this._reactions.filter(r => !(r.msg_id === msgId && r.user_id === userId && r.emoji === emoji))
+  }
+
+  listReactionsForMsgs({ msgIds, requestingUserId }) {
+    const map = new Map()
+    if (!msgIds || msgIds.length === 0) return map
+
+    const msgIdSet = new Set(msgIds)
+    const relevant = this._reactions.filter(r => msgIdSet.has(r.msg_id))
+
+    // Group by msg_id + emoji, preserving insertion order
+    const grouped = new Map() // key: `${msgId}|${emoji}` → { msg_id, emoji, count, minTs, reacted }
+    for (const r of relevant) {
+      const key = `${r.msg_id}|${r.emoji}`
+      if (!grouped.has(key)) {
+        grouped.set(key, { msg_id: r.msg_id, emoji: r.emoji, count: 0, minTs: r.ts, reacted: false })
+      }
+      const entry = grouped.get(key)
+      entry.count++
+      if (r.ts < entry.minTs) entry.minTs = r.ts
+      if (r.user_id === requestingUserId) entry.reacted = true
+    }
+
+    // Sort by minTs and build the output map
+    const sorted = Array.from(grouped.values()).sort((a, b) => a.minTs - b.minTs)
+    for (const entry of sorted) {
+      if (!map.has(entry.msg_id)) map.set(entry.msg_id, [])
+      map.get(entry.msg_id).push({ emoji: entry.emoji, count: entry.count, reacted: entry.reacted })
+    }
+    return map
+  }
+}

package/src/adapters/InMemorySearchRepository.js

@@ -0,0 +1,37 @@
+export class InMemorySearchRepository {
+  constructor() {
+    this._index = [] // { msg_id, channel_id, seq, user_id, ts, text }
+    this._ftsEnabled = true
+  }
+
+  isFtsEnabled() {
+    return this._ftsEnabled
+  }
+
+  indexMessage({ msg_id, channel_id, seq, user_id, ts, text }) {
+    const existing = this._index.findIndex(r => r.msg_id === msg_id)
+    if (existing >= 0) this._index.splice(existing, 1)
+    this._index.push({ msg_id, channel_id, seq, user_id, ts, text })
+  }
+
+  removeMessage({ msgId }) {
+    const i = this._index.findIndex(r => r.msg_id === msgId)
+    if (i >= 0) this._index.splice(i, 1)
+  }
+
+  searchFts({ channelId, query, limit }) {
+    const q = query.toLowerCase()
+    return this._index
+      .filter(r => r.channel_id === channelId && r.text.toLowerCase().includes(q))
+      .slice(0, limit)
+      .map(r => ({ ...r, snippet: r.text }))
+  }
+
+  searchLike({ channelId, query, limit }) {
+    const q = query.toLowerCase()
+    return this._index
+      .filter(r => r.channel_id === channelId && r.text.toLowerCase().includes(q))
+      .slice(0, limit)
+      .map(r => ({ ...r, snippet: r.text }))
+  }
+}

package/src/adapters/InMemorySignalingRepository.js

@@ -0,0 +1,35 @@
+export class InMemorySignalingRepository {
+  constructor() {
+    this._calls = new Map()         // callId → { call_id, channel_id, created_by_user_id, topology, started_at, ended_at }
+    this._participants = []         // { call_id, user_id, peer_id, joined_at, left_at }
+  }
+
+  findActiveByChannel({ channelId }) {
+    for (const call of this._calls.values()) {
+      if (call.channel_id === channelId && call.ended_at == null) return call
+    }
+    return null
+  }
+
+  findActiveCalls() {
+    return [...this._calls.values()].filter(c => c.ended_at == null)
+  }
+
+  insertCall({ callId, channelId, createdByUserId, topology, startedAt }) {
+    this._calls.set(callId, { call_id: callId, channel_id: channelId, created_by_user_id: createdByUserId, topology, started_at: startedAt, ended_at: null })
+  }
+
+  endCall({ callId, endedAt }) {
+    const call = this._calls.get(callId)
+    if (call) call.ended_at = endedAt
+  }
+
+  insertParticipant({ callId, userId, peerId, joinedAt }) {
+    this._participants.push({ call_id: callId, user_id: userId, peer_id: peerId, joined_at: joinedAt, left_at: null })
+  }
+
+  leaveParticipant({ callId, peerId, leftAt }) {
+    const p = this._participants.find(p => p.call_id === callId && p.peer_id === peerId && p.left_at == null)
+    if (p) p.left_at = leftAt
+  }
+}

package/src/adapters/InMemoryUploadRepository.js

@@ -0,0 +1,36 @@
+export class InMemoryUploadRepository {
+  constructor() {
+    this._uploads = new Map()
+  }
+
+  insert({ uploadId, uploaderUserId, channelId, originalName, storedName, mimeType, sizeBytes, now }) {
+    this._uploads.set(uploadId, {
+      upload_id: uploadId,
+      uploader_user_id: uploaderUserId,
+      channel_id: channelId,
+      original_name: originalName,
+      stored_name: storedName,
+      mime_type: mimeType,
+      size_bytes: sizeBytes,
+      created_at: now,
+      msg_id: null,
+    })
+  }
+
+  findById({ uploadId }) {
+    return this._uploads.get(uploadId) ?? null
+  }
+
+  linkToMessage({ uploadId, msgId }) {
+    const row = this._uploads.get(uploadId)
+    if (row) row.msg_id = msgId
+  }
+
+  findOrphansOlderThan({ thresholdTs }) {
+    return [...this._uploads.values()].filter(r => r.msg_id === null && r.created_at < thresholdTs)
+  }
+
+  delete({ uploadId }) {
+    this._uploads.delete(uploadId)
+  }
+}

package/src/adapters/InMemoryUserSettingsRepository.js

@@ -0,0 +1,15 @@
+export class InMemoryUserSettingsRepository {
+  constructor() {
+    this._store = new Map() // userId → { settings_json, updated_at }
+  }
+
+  findByUserId({ userId }) {
+    return this._store.get(userId) ?? null
+  }
+
+  upsert({ userId, settingsJson, updatedAt }) {
+    const existing = this._store.get(userId)
+    if (existing && existing.updated_at > updatedAt) return
+    this._store.set(userId, { settings_json: settingsJson, updated_at: updatedAt })
+  }
+}

package/src/adapters/LocalFileStore.js

@@ -0,0 +1,40 @@
+import { mkdir } from 'node:fs/promises'
+import path from 'node:path'
+import { ServiceError } from '../util/errors'
+const DEFAULT_UPLOAD_DIR = 'data/uploads'
+
+export class LocalFileStore {
+  constructor({ uploadDir = process.env.UPLOAD_DIR ?? DEFAULT_UPLOAD_DIR } = {}) {
+    this.uploadDir = uploadDir
+  }
+
+  #dir(uploadId) {
+    return path.join(this.uploadDir, uploadId)
+  }
+
+  async write({ uploadId, storedName, stream: data }) {
+    const dir = this.#dir(uploadId)
+    await mkdir(dir, { recursive: true })
+    const filePath = path.join(dir, storedName)
+    await Bun.write(filePath, data)
+  }
+
+  async read({ uploadId, storedName }) {
+    const filePath = path.join(this.#dir(uploadId), storedName)
+    const file = Bun.file(filePath)
+    const exists = await file.exists()
+    if (!exists) {
+      throw new ServiceError('NOT_FOUND', `File not found: ${filePath}`)
+    }
+    return file.stream()
+  }
+
+  async delete({ uploadId, storedName }) {
+    const filePath = path.join(this.#dir(uploadId), storedName)
+    try {
+      await Bun.file(filePath).unlink()
+    } catch {
+      // already gone — ignore
+    }
+  }
+}

package/src/adapters/SqliteAuthRepository.js

@@ -0,0 +1,184 @@
+import { runTransaction } from '../db/transaction.js'
+
+export class SqliteAuthRepository {
+  constructor({ db }) {
+    this.db = db
+  }
+
+  // ── Invites ────────────────────────────────────────────────────────────────
+
+  insertInvite({ inviteId, tokenHash, createdByUserId, now, expiresAt, maxUses, note, initialRolesJson }) {
+    this.db.prepare(
+      `INSERT INTO invites (invite_id, token_hash, created_by_user_id, created_at, expires_at, max_uses, uses, note, initial_roles_json)
+       VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?)`
+    ).run(inviteId, tokenHash, createdByUserId, now, expiresAt, maxUses, note, initialRolesJson)
+  }
+
+  findInviteByTokenHash({ tokenHash }) {
+    return this.db.prepare('SELECT * FROM invites WHERE token_hash = ?').get(tokenHash) ?? null
+  }
+
+  listInvites() {
+    return this.db.prepare(`
+      SELECT i.*, u.handle AS created_by_handle
+      FROM invites i
+      LEFT JOIN users u ON u.user_id = i.created_by_user_id
+      ORDER BY i.created_at DESC
+    `).all()
+  }
+
+  deleteInvite({ inviteId }) {
+    this.db.prepare('DELETE FROM invites WHERE invite_id = ?').run(inviteId)
+  }
+
+  /** Atomically: increment invite uses + insert user + insert session */
+  registerUser({ inviteId, userId, handle, displayName, rolesJson, passwordHash, now, sessionId, sessionTokenHash, sessionExpiresAt }) {
+    runTransaction(this.db, () => {
+      this.db.prepare(
+        `INSERT INTO users (user_id, handle, display_name, roles_json, password_hash, created_at)
+         VALUES (?, ?, ?, ?, ?, ?)`
+      ).run(userId, handle, displayName, rolesJson, passwordHash, now)
+      this.db.prepare(
+        `UPDATE invites SET uses = uses + 1, redeemed_by_user_id = ? WHERE invite_id = ?`
+      ).run(userId, inviteId)
+      this.db.prepare(
+        `INSERT INTO sessions (session_id, user_id, token_hash, created_at, expires_at, last_seen_at)
+         VALUES (?, ?, ?, ?, ?, ?)`
+      ).run(sessionId, userId, sessionTokenHash, now, sessionExpiresAt, now)
+    })
+  }
+
+  /** Atomically: insert user + insert session (bootstrap — no invite to redeem) */
+  registerBootstrapUser({ userId, handle, displayName, rolesJson, passwordHash, now, sessionId, sessionTokenHash, sessionExpiresAt }) {
+    runTransaction(this.db, () => {
+      this.db.prepare(
+        `INSERT INTO users (user_id, handle, display_name, roles_json, password_hash, created_at)
+         VALUES (?, ?, ?, ?, ?, ?)`
+      ).run(userId, handle, displayName, rolesJson, passwordHash, now)
+      this.db.prepare(
+        `INSERT INTO sessions (session_id, user_id, token_hash, created_at, expires_at, last_seen_at)
+         VALUES (?, ?, ?, ?, ?, ?)`
+      ).run(sessionId, userId, sessionTokenHash, now, sessionExpiresAt, now)
+    })
+  }
+
+  // ── Users ──────────────────────────────────────────────────────────────────
+
+  findUserByHandle({ handle }) {
+    return this.db.prepare(
+      'SELECT user_id, handle, display_name, roles_json, password_hash FROM users WHERE handle = ?'
+    ).get(handle) ?? null
+  }
+
+  findUserById({ userId }) {
+    return this.db.prepare(
+      'SELECT user_id, handle, display_name, roles_json FROM users WHERE user_id = ?'
+    ).get(userId) ?? null
+  }
+
+  listUsers() {
+    return this.db.prepare(
+      `SELECT user_id, handle, display_name, roles_json, created_at FROM users ORDER BY created_at ASC`
+    ).all()
+  }
+
+  updateUserRoles({ userId, rolesJson }) {
+    this.db.prepare('UPDATE users SET roles_json = ? WHERE user_id = ?').run(rolesJson, userId)
+  }
+
+  updateUserPassword({ userId, passwordHash }) {
+    this.db.prepare('UPDATE users SET password_hash = ? WHERE user_id = ?').run(passwordHash, userId)
+  }
+
+  updateUserDisplayName({ userId, displayName }) {
+    this.db.prepare('UPDATE users SET display_name = ? WHERE user_id = ?').run(displayName, userId)
+  }
+
+  getUserCount() {
+    return this.db.prepare('SELECT COUNT(*) AS count FROM users').get()?.count ?? 0
+  }
+
+  isHandleTaken({ handle }) {
+    return !!this.db.prepare('SELECT 1 FROM users WHERE handle = ?').get(handle)
+  }
+
+  // ── Sessions ───────────────────────────────────────────────────────────────
+
+  insertSession({ sessionId, userId, tokenHash, now, expiresAt }) {
+    this.db.prepare(
+      `INSERT INTO sessions (session_id, user_id, token_hash, created_at, expires_at, last_seen_at)
+       VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(sessionId, userId, tokenHash, now, expiresAt, now)
+  }
+
+  findSessionWithUser({ tokenHash }) {
+    return this.db.prepare(
+      `SELECT s.session_id, s.user_id, s.expires_at, s.revoked_at, u.handle, u.display_name, u.roles_json
+       FROM sessions s JOIN users u ON u.user_id = s.user_id
+       WHERE s.token_hash = ?`
+    ).get(tokenHash) ?? null
+  }
+
+  touchSession({ sessionId, now }) {
+    this.db.prepare('UPDATE sessions SET last_seen_at = ? WHERE session_id = ?').run(now, sessionId)
+  }
+
+  revokeSession({ sessionId, now }) {
+    this.db.prepare('UPDATE sessions SET revoked_at = ? WHERE session_id = ?').run(now, sessionId)
+  }
+
+  revokeAllUserSessions({ userId, now }) {
+    this.db.prepare(
+      'UPDATE sessions SET revoked_at = ? WHERE user_id = ? AND revoked_at IS NULL'
+    ).run(now, userId)
+  }
+
+  // ── Bot tokens ─────────────────────────────────────────────────────────────
+
+  insertBotUser({ userId, handle, displayName, now }) {
+    this.db.prepare(
+      `INSERT INTO users (user_id, handle, display_name, roles_json, password_hash, created_at)
+       VALUES (?, ?, ?, '["bot"]', NULL, ?)`
+    ).run(userId, handle, displayName, now)
+  }
+
+  insertBotToken({ tokenId, userId, tokenHash, label, now, expiresAt = null }) {
+    this.db.prepare(
+      `INSERT INTO bot_tokens (token_id, user_id, token_hash, label, created_at, expires_at)
+       VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(tokenId, userId, tokenHash, label ?? null, now, expiresAt)
+  }
+
+  listBotTokens({ userId }) {
+    return this.db.prepare(
+      `SELECT token_id, label, created_at, expires_at, last_used_at, revoked_at
+       FROM bot_tokens WHERE user_id = ? ORDER BY created_at DESC`
+    ).all(userId)
+  }
+
+  revokeBotToken({ tokenId, now }) {
+    this.db.prepare('UPDATE bot_tokens SET revoked_at = ? WHERE token_id = ?').run(now, tokenId)
+  }
+
+  revokeAllBotTokens({ userId, now }) {
+    this.db.prepare(
+      'UPDATE bot_tokens SET revoked_at = ? WHERE user_id = ? AND revoked_at IS NULL'
+    ).run(now, userId)
+  }
+
+  findBotTokenByHash({ tokenHash, now }) {
+    return this.db.prepare(
+      `SELECT bt.token_id, bt.user_id, bt.last_used_at,
+              u.handle, u.display_name, u.roles_json
+       FROM bot_tokens bt
+       JOIN users u ON u.user_id = bt.user_id
+       WHERE bt.token_hash = ?
+         AND bt.revoked_at IS NULL
+         AND (bt.expires_at IS NULL OR bt.expires_at > ?)`
+    ).get(tokenHash, now) ?? null
+  }
+
+  touchBotToken({ tokenId, now }) {
+    this.db.prepare('UPDATE bot_tokens SET last_used_at = ? WHERE token_id = ?').run(now, tokenId)
+  }
+}

package/src/adapters/SqliteChannelRepository.js

@@ -0,0 +1,149 @@
+import { runTransaction } from '../db/transaction.js'
+
+export class SqliteChannelRepository {
+  constructor({ db }) {
+    this.db = db
+  }
+
+  insertChannelWithOwner({ channelId, hubId, kind, name, topic, visibility, createdByUserId, now }) {
+    runTransaction(this.db, () => {
+      const nextOrder = (this.db.prepare(
+        `SELECT COALESCE(MAX(sort_order), -1) + 1 AS next FROM channels WHERE hub_id = ? AND deleted_at IS NULL`
+      ).get(hubId)?.next ?? 0)
+      this.db.prepare(
+        `INSERT INTO channels (channel_id, hub_id, kind, name, topic, visibility, sort_order, created_by_user_id, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      ).run(channelId, hubId, kind, name, topic, visibility, nextOrder, createdByUserId, now)
+      this.db.prepare(
+        `INSERT INTO channel_members (channel_id, user_id, role, joined_at) VALUES (?, ?, 'owner', ?)`
+      ).run(channelId, createdByUserId, now)
+    })
+  }
+
+  listInHub({ hubId }) {
+    return this.db.prepare(
+      `SELECT c.channel_id, c.hub_id, c.name, c.kind, c.visibility, c.topic, c.sort_order
+       FROM channels c WHERE c.hub_id = ? AND c.deleted_at IS NULL
+       ORDER BY c.sort_order ASC, c.created_at ASC`
+    ).all(hubId)
+  }
+
+  listAccessibleInHub({ hubId, userId, isGuest = false }) {
+    return this.db.prepare(
+      `SELECT c.channel_id, c.hub_id, c.name, c.kind, c.visibility, c.topic, c.sort_order
+       FROM channels c WHERE c.hub_id = ? AND c.deleted_at IS NULL
+       AND (EXISTS (
+         SELECT 1 FROM channel_members cm WHERE cm.channel_id = c.channel_id
+         AND cm.user_id = ? AND cm.left_at IS NULL AND cm.banned_at IS NULL
+       ) OR (? = 0 AND c.visibility = 'public'))
+       ORDER BY c.sort_order ASC, c.created_at ASC`
+    ).all(hubId, userId, isGuest ? 1 : 0)
+  }
+
+  listAll() {
+    return this.db.prepare(
+      `SELECT c.channel_id, c.hub_id, c.name, c.kind, c.visibility, c.topic, c.sort_order, h.name AS hub_name
+       FROM channels c JOIN hubs h ON c.hub_id = h.hub_id
+       WHERE c.deleted_at IS NULL AND h.deleted_at IS NULL
+       ORDER BY h.name, c.sort_order ASC, c.created_at ASC`
+    ).all()
+  }
+
+  listAccessible({ userId, isGuest = false }) {
+    return this.db.prepare(
+      `SELECT c.channel_id, c.hub_id, c.name, c.kind, c.visibility, c.topic, c.sort_order, h.name AS hub_name
+       FROM channels c JOIN hubs h ON c.hub_id = h.hub_id
+       WHERE c.deleted_at IS NULL AND h.deleted_at IS NULL
+       AND (EXISTS (SELECT 1 FROM channel_members cm WHERE cm.channel_id = c.channel_id AND cm.user_id = ? AND cm.left_at IS NULL AND cm.banned_at IS NULL)
+         OR (? = 0 AND (
+           (h.visibility = 'public' AND c.visibility = 'public')
+           OR (c.visibility = 'public' AND EXISTS (SELECT 1 FROM hub_members hm WHERE hm.hub_id = h.hub_id AND hm.user_id = ? AND hm.left_at IS NULL))
+         )))
+       ORDER BY h.name, c.sort_order ASC, c.created_at ASC`
+    ).all(userId, isGuest ? 1 : 0, userId)
+  }
+
+  findById({ channelId }) {
+    return this.db.prepare('SELECT * FROM channels WHERE channel_id = ?').get(channelId) ?? null
+  }
+
+  findMembership({ channelId, userId }) {
+    return this.db.prepare('SELECT * FROM channel_members WHERE channel_id = ? AND user_id = ?').get(channelId, userId) ?? null
+  }
+
+  findByHubAndName({ hubId, name }) {
+    return this.db.prepare('SELECT * FROM channels WHERE hub_id = ? AND name = ? AND deleted_at IS NULL').get(hubId, name) ?? null
+  }
+
+  findDmByName({ name }) {
+    return this.db.prepare(`SELECT * FROM channels WHERE kind = 'dm' AND name = ? AND deleted_at IS NULL`).get(name) ?? null
+  }
+
+  insertDmChannel({ channelId, name, userIdA, userIdB, now }) {
+    runTransaction(this.db, () => {
+      this.db.prepare(
+        `INSERT INTO channels (channel_id, hub_id, kind, name, topic, visibility, sort_order, created_by_user_id, created_at)
+         VALUES (?, NULL, 'dm', ?, NULL, 'private', 0, ?, ?)`
+      ).run(channelId, name, userIdA, now)
+      this.db.prepare(
+        `INSERT INTO channel_members (channel_id, user_id, role, joined_at) VALUES (?, ?, 'member', ?)`
+      ).run(channelId, userIdA, now)
+      this.db.prepare(
+        `INSERT INTO channel_members (channel_id, user_id, role, joined_at) VALUES (?, ?, 'member', ?)`
+      ).run(channelId, userIdB, now)
+    })
+  }
+
+  listDmsByUser({ userId }) {
+    return this.db.prepare(
+      `SELECT c.channel_id, c.name, c.kind,
+              other.user_id AS other_user_id
+       FROM channels c
+       JOIN channel_members cm  ON cm.channel_id = c.channel_id AND cm.user_id = ? AND cm.left_at IS NULL
+       LEFT JOIN channel_members other ON other.channel_id = c.channel_id AND other.user_id != ? AND other.left_at IS NULL
+       WHERE c.kind = 'dm' AND c.deleted_at IS NULL
+       ORDER BY c.created_at DESC`
+    ).all(userId, userId)
+  }
+
+  upsertMembership({ channelId, userId, role, now }) {
+    this.db.prepare(
+      `INSERT INTO channel_members (channel_id, user_id, role, joined_at) VALUES (?, ?, ?, ?)
+       ON CONFLICT(channel_id, user_id) DO UPDATE SET left_at = NULL, banned_at = NULL`
+    ).run(channelId, userId, role, now)
+  }
+
+  setMemberLeft({ channelId, userId, now }) {
+    this.db.prepare('UPDATE channel_members SET left_at = ? WHERE channel_id = ? AND user_id = ?').run(now, channelId, userId)
+  }
+
+  listActiveMembers({ channelId }) {
+    return this.db.prepare(
+      `SELECT user_id, role FROM channel_members WHERE channel_id = ? AND left_at IS NULL AND banned_at IS NULL`
+    ).all(channelId)
+  }
+
+  patchChannel({ channelId, name, topic, visibility }) {
+    const updates = []
+    const params = []
+    if (name !== undefined) { updates.push('name = ?'); params.push(name) }
+    if (topic !== undefined) { updates.push('topic = ?'); params.push(topic) }
+    if (visibility !== undefined) { updates.push('visibility = ?'); params.push(visibility) }
+    params.push(channelId)
+    this.db.prepare(`UPDATE channels SET ${updates.join(', ')} WHERE channel_id = ?`).run(...params)
+  }
+
+  softDeleteChannel({ channelId, now }) {
+    this.db.prepare('UPDATE channels SET deleted_at = ? WHERE channel_id = ?').run(now, channelId)
+  }
+
+  reorderChannels({ hubId, channelIds }) {
+    runTransaction(this.db, () => {
+      const stmt = this.db.prepare(
+        `UPDATE channels SET sort_order = ? WHERE channel_id = ? AND hub_id = ? AND deleted_at IS NULL`
+      )
+      channelIds.forEach((channelId, index) => stmt.run(index, channelId, hubId))
+    })
+    return this.listInHub({ hubId })
+  }
+}

package/src/adapters/SqliteDeliveryRepository.js

@@ -0,0 +1,53 @@
+import { newId } from '../util/ids.js'
+
+export class SqliteDeliveryRepository {
+  constructor({ db }) {
+    this.db = db
+  }
+
+  findByChannelAndUser({ channelId, userId }) {
+    return this.db.prepare('SELECT * FROM deliveries WHERE channel_id = ? AND user_id = ?').get(channelId, userId) ?? null
+  }
+
+  create({ channelId, userId, now }) {
+    const deliveryId = newId('del')
+    this.db.prepare(
+      `INSERT INTO deliveries (delivery_id, user_id, channel_id, after_seq, last_delivered_at, status) VALUES (?, ?, ?, 0, ?, 'active')`
+    ).run(deliveryId, userId, channelId, now)
+    return this.db.prepare('SELECT * FROM deliveries WHERE delivery_id = ?').get(deliveryId)
+  }
+
+  advance({ channelId, userId, afterSeq, now }) {
+    this.db.prepare(
+      `UPDATE deliveries
+       SET after_seq = ?, last_delivered_at = ?,
+           mention_seq = CASE WHEN mention_seq > 0 AND mention_seq <= ? THEN 0 ELSE mention_seq END
+       WHERE channel_id = ? AND user_id = ?`
+    ).run(afterSeq, now, afterSeq, channelId, userId)
+  }
+
+  advanceMention({ channelId, userId, mentionSeq, priority = 'normal' }) {
+    this.db.prepare(
+      `UPDATE deliveries SET mention_seq = ?, mention_priority = ?
+       WHERE channel_id = ? AND user_id = ? AND mention_seq < ?`
+    ).run(mentionSeq, priority, channelId, userId, mentionSeq)
+  }
+
+  buildDigestData({ userId }) {
+    return this.db.prepare(
+      `SELECT
+         d.channel_id, c.name, c.kind, d.after_seq, d.mention_seq, d.mention_priority,
+         COALESCE(
+           (SELECT MAX(seq) FROM messages WHERE channel_id = d.channel_id AND deleted_at IS NULL),
+           0
+         ) AS max_seq,
+         (SELECT cm2.user_id FROM channel_members cm2
+          WHERE cm2.channel_id = c.channel_id AND cm2.user_id != d.user_id
+            AND cm2.left_at IS NULL AND c.kind = 'dm'
+          LIMIT 1) AS other_user_id
+       FROM deliveries d
+       JOIN channels c ON d.channel_id = c.channel_id AND c.deleted_at IS NULL
+       WHERE d.user_id = ?`
+    ).all(userId)
+  }
+}