98e06cb
/**
* Chat transport: every call the 聊天室 pages make, wrapped in the shared
* envelope contract so the UI only ever sees unwrapped rows or an `ApiFailure`.
*
* Two schema quirks are handled here and nowhere else:
* - `list_threads` is typed against the generic `Page` schema (items untyped),
* so the thread row is asserted once, in {@link listRoomThreads}.
* - `POST /chat/dms` carries the *list* query parameters in its generated
* `pathParams`, because the spec shares one path with `GET /chat/dms`; they
* are never substituted into the URL, so {@link openDm} passes nulls.
*
* Empty strings are dropped (`nz`), not sent: Alova omits `undefined` query
* values but forwards `''`, and the backend's `Option<Uuid>` deserialization
* rejects an empty `thread_id=` with a 400.
*/
import { getLocale, translate } from '@app/i18n'
import { type ApiEnvelope, toMemberUserRow, unwrapApi } from '@app/lib'
import type { MemberSummaryPage } from '@app/services/api'
import Apis from '@app/services/api'
import type {
Attachment,
ChatMessage,
DmBrief,
Draft,
EmojiPage,
MessageEdit,
MessagePage,
Presence,
ReactionAgg,
ReactionUser,
ReadState,
RoomBrief,
RoomMember,
RoomSetting,
SendMessageInput,
SpaceReadStates,
ThreadBrief,
UploadIntent,
} from './chat'
const nz = <T>(value: T | '' | null | undefined): T | undefined => (value ? value : undefined)
const listOf = <T>(method: PromiseLike<ApiEnvelope<unknown>>): Promise<T[]> =>
unwrapApi<T[] | null>(method as PromiseLike<ApiEnvelope<T[] | null>>).then((rows) => rows ?? [])
const nothing = (method: PromiseLike<ApiEnvelope<unknown>>) => unwrapApi<null>(method as PromiseLike<ApiEnvelope<null>>)
/* ------------------------------------------------------------------ rooms */
export const getRoom = (roomId: string) => unwrapApi<RoomBrief>(Apis.chat.get_room({ pathParams: { room_id: roomId } }))
/** `undefined` leaves a field untouched. The backend takes single `Option`s
* here (only `parent_id` is three-state), so clearing goes through the empty
* value instead of `null`: `topic: ''` and `rate_limit_per_user: 0`. */
export const updateRoom = (
roomId: string,
cmd: {
name?: string
topic?: string
is_private?: boolean
nsfw?: boolean
rate_limit_per_user?: number
position?: number
},
) => unwrapApi<RoomBrief>(Apis.chat.update_room({ pathParams: { room_id: roomId }, data: cmd }))
export const deleteRoom = (roomId: string) => nothing(Apis.chat.delete_room({ pathParams: { room_id: roomId } }))
/** A room's roster is the enclosing space's membership: the chat service has no
* member endpoint of its own, and DMs (`@me`) have no roster to show. */
export const listRoomMembers = async (spaceName: string, _roomId: string): Promise<RoomMember[]> => {
if (!spaceName || spaceName === '@me') return []
const page = await unwrapApi<MemberSummaryPage | null>(
Apis.space.list_space_members({ pathParams: { space_name: spaceName }, params: { limit: 100 } }),
)
return (page?.items ?? []).map((row) => toMemberUserRow(row) as unknown as RoomMember)
}
/** Per-viewer channel preferences (mute / favorite / hidden / notification level). */
export const getRoomSetting = (roomId: string) =>
unwrapApi<RoomSetting>(Apis.chat.get_room_setting({ pathParams: { room_id: roomId } }))
export const updateRoomSetting = (
roomId: string,
cmd: {
muted?: boolean
favorite?: boolean
hidden?: boolean
/** `0` lifts a mute; `null` would read as "unchanged". */
mute_minutes?: number
notification_level?: 'Default' | 'All' | 'Mentions' | 'Nothing'
},
) => unwrapApi<RoomSetting>(Apis.chat.update_room_setting({ pathParams: { room_id: roomId }, data: cmd }))
/* -------------------------------------------------------------------- dms */
export const openDm = (peerUserId: number) =>
unwrapApi<DmBrief>(Apis.chat.open_dm({ data: { peer_user_id: peerUserId } }))
export const closeDm = (roomId: string) => nothing(Apis.chat.close_dm({ pathParams: { room_id: roomId } }))
/* -------------------------------------------------------------- transcript */
export interface MessageQuery {
beforeSeq?: number
afterSeq?: number
limit?: number
threadId?: string
authorId?: number
}
/** Ascending by `seq`; `has_more` means *older* rows exist (before_seq path). */
export const listMessages = (roomId: string, query: MessageQuery = {}): Promise<MessagePage> =>
unwrapApi<MessagePage | null>(
Apis.chat.list_messages({
pathParams: { room_id: roomId },
params: {
before_seq: query.beforeSeq,
after_seq: query.afterSeq,
limit: query.limit,
thread_id: nz(query.threadId),
author_id: nz(query.authorId),
},
}),
).then(
(page) => page ?? { items: [], has_more: false, oldest_seq: null, newest_seq: null, limit: 0, offset: 0, total: 0 },
)
export const getMessage = (roomId: string, messageId: string) =>
unwrapApi<ChatMessage>(Apis.chat.get_message({ pathParams: { room_id: roomId, message_id: messageId } }))
export const sendMessage = (roomId: string, input: SendMessageInput) =>
unwrapApi<ChatMessage>(
Apis.chat.send_message({
pathParams: { room_id: roomId },
data: {
content: input.content,
nonce: nz(input.nonce),
reply_to_id: input.reply_to_id ?? null,
thread_id: input.thread_id ?? null,
thread_broadcast: input.thread_broadcast ?? false,
attachments: input.attachments ?? [],
urgent: input.urgent ?? false,
},
}),
)
export const editMessage = (roomId: string, messageId: string, content: string) =>
unwrapApi<ChatMessage>(
Apis.chat.update_message({
pathParams: { room_id: roomId, message_id: messageId },
data: { content },
}),
)
export const deleteMessage = (roomId: string, messageId: string) =>
nothing(Apis.chat.delete_message({ pathParams: { room_id: roomId, message_id: messageId } }))
export const bulkDeleteMessages = (roomId: string, messageIds: string[]) =>
nothing(Apis.chat.bulk_delete_messages({ pathParams: { room_id: roomId }, data: { message_ids: messageIds } }))
export const listMessageEdits = (roomId: string, messageId: string) =>
listOf<MessageEdit>(Apis.chat.list_message_history({ pathParams: { room_id: roomId, message_id: messageId } }))
/** Forward to another room: the backend copies the payload, no re-upload. */
export const forwardMessage = (roomId: string, messageId: string, targetRoomId: string, comment?: string) =>
unwrapApi<ChatMessage>(
Apis.chat.forward_message({
pathParams: { room_id: roomId, message_id: messageId },
data: { target_room_id: targetRoomId, comment: nz(comment) ?? null },
}),
)
/* --------------------------------------------------------------- reactions */
export const addReaction = (roomId: string, messageId: string, emoji: string) =>
listOf<ReactionAgg>(
Apis.chat.add_reaction({
pathParams: { room_id: roomId, message_id: messageId },
data: { emoji },
}),
)
export const removeReaction = (roomId: string, messageId: string, emoji: string) =>
listOf<ReactionAgg>(
Apis.chat.remove_reaction({
pathParams: { room_id: roomId, message_id: messageId },
data: { emoji },
}),
)
/** Who reacted, per emoji — the popover's detail list. */
export const listReactionUsers = (roomId: string, messageId: string) =>
listOf<ReactionUser>(Apis.chat.list_reactions({ pathParams: { room_id: roomId, message_id: messageId } }))
/** Add or withdraw the viewer's reaction; returns the authoritative aggregate. */
export const setReaction = (roomId: string, messageId: string, emoji: string, on: boolean) =>
on ? addReaction(roomId, messageId, emoji) : removeReaction(roomId, messageId, emoji)
/* -------------------------------------------------------------------- pins */
export const setMessagePin = (roomId: string, messageId: string, pinned: boolean) =>
unwrapApi<ChatMessage>(
Apis.chat.set_message_pin({
pathParams: { room_id: roomId, message_id: messageId },
data: { pinned },
}),
)
/** The handler answers with a bare array (its own utoipa body annotation still
* claims a Page, which is why the generated type disagrees with the wire). */
export const listPins = (roomId: string) =>
listOf<ChatMessage>(Apis.chat.list_pins({ pathParams: { room_id: roomId } }))
/* -------------------------------------------------------------- read state */
export const getReadState = (roomId: string) =>
unwrapApi<ReadState>(Apis.chat.get_read_state({ pathParams: { room_id: roomId } }))
/** No cursor at all means "read everything" — the backend clamps to the tip. */
export const markRead = (roomId: string, cursor?: { messageId?: string; seq?: number }) =>
unwrapApi<ReadState>(
Apis.chat.mark_read({
pathParams: { room_id: roomId },
data: { message_id: nz(cursor?.messageId) ?? null, seq: cursor?.seq ?? null },
}),
)
/** Unread rows for every room of a space — one call for the whole sidebar. */
export const listSpaceReadStates = (spaceName: string) =>
unwrapApi<SpaceReadStates>(Apis.chat.list_space_read_states({ pathParams: { space_name: spaceName } })).then(
(state) => state?.items ?? [],
)
/* ------------------------------------------------------------------- drafts */
export const getDraft = (roomId: string, threadId?: string) =>
unwrapApi<Draft | null>(
Apis.chat.get_draft({
pathParams: { room_id: roomId },
params: { thread_id: nz(threadId) },
}),
)
/** Empty content clears the draft server-side, so `''` is a meaningful write. */
export const saveDraft = (roomId: string, content: string, threadId?: string) =>
unwrapApi<Draft>(
Apis.chat.upsert_draft({
pathParams: { room_id: roomId },
data: { content, thread_id: nz(threadId) ?? null },
}),
)
export const clearDraft = (roomId: string, threadId?: string) =>
nothing(
Apis.chat.delete_draft({
pathParams: { room_id: roomId },
params: { thread_id: nz(threadId) },
}),
)
/* ------------------------------------------------------------------ threads */
/** Idempotent: a root that already has a thread returns the existing one. */
export const createThread = (roomId: string, rootMessageId: string, name?: string) =>
unwrapApi<ThreadBrief>(
Apis.chat.create_thread({
pathParams: { room_id: roomId, message_id: rootMessageId },
data: { name: nz(name) ?? null },
}),
)
export const listRoomThreads = (roomId: string) =>
unwrapApi<{ items?: ThreadBrief[] } | null>(
Apis.chat.list_threads({
pathParams: { room_id: roomId },
params: { limit: 100 },
}) as unknown as PromiseLike<ApiEnvelope<{ items?: ThreadBrief[] } | null>>,
).then((page) => page?.items ?? [])
export const listMyThreads = () =>
unwrapApi<{ items?: ThreadBrief[] } | null>(Apis.chat.list_my_threads({ params: { limit: 50 } })).then(
(page) => page?.items ?? [],
)
export const getThread = (threadId: string) =>
unwrapApi<ThreadBrief>(Apis.chat.get_thread({ pathParams: { thread_id: threadId } }))
export const updateThread = (
threadId: string,
/** An empty `name` clears it server-side; `null` means "unchanged". */
cmd: { name?: string; archived?: boolean; locked?: boolean },
) => unwrapApi<ThreadBrief>(Apis.chat.update_thread({ pathParams: { thread_id: threadId }, data: cmd }))
// `notify_level` is a three-state field, so both follow calls carry a body.
export const followThread = (threadId: string, notifyLevel: 'All' | 'None' | null = null) =>
nothing(
Apis.chat.follow_thread({
pathParams: { thread_id: threadId },
data: { notify_level: notifyLevel },
}),
)
export const unfollowThread = (threadId: string) =>
nothing(Apis.chat.unfollow_thread({ pathParams: { thread_id: threadId } }))
export const markThreadRead = (threadId: string, messageId?: string) =>
nothing(
Apis.chat.mark_thread_read({
pathParams: { thread_id: threadId },
data: { message_id: nz(messageId) ?? null },
}),
)
/* ------------------------------------------------------------ space people */
/**
* A space member row, as the generic `Page` schema leaves it. `MemberDto` nests
* the identity under `user` and ships no `user_id`/`role`/`group_ids`, so the id
* is flattened in `listSpaceMembers` below — every caller reads `user_id`.
*/
export interface SpaceMemberRow {
user?: import('@app/services/api').UserDto | null
alias_name?: string | null
status?: string | null
}
export interface SpaceMemberOption extends SpaceMemberRow {
user_id: number
}
/**
* People who can be pulled into a room. Only space members may join one, so this
* is the source for the add-member picker (the same list the 问题集 uses for
* assignees — both are "who is in this space", read from the space endpoint).
*/
export const listSpaceMembers = (spaceName: string) =>
unwrapApi<MemberSummaryPage | null>(
Apis.space.list_space_members({ pathParams: { space_name: spaceName }, params: { limit: 100 } }),
).then((page) => (page?.items ?? []).map((row) => ({ ...toMemberUserRow(row), user_id: row.user_id })))
/* ---------------------------------------------------------------- presence */
export const listSpacePresences = (spaceName: string) =>
listOf<import('./chat').Presence>(Apis.chat.list_space_presences({ pathParams: { space_name: spaceName } }))
export const getUserPresence = (userId: number) =>
unwrapApi<Presence>(Apis.chat.get_presence({ pathParams: { user_id: userId } }))
/* ------------------------------------------------------------------ emojis */
/** Paged: the handler returns `Page<EmojiDto>`, so read `items` (a bare-array
* read handed the picker the page object and crashed its `.filter`). */
export const listSpaceEmojis = (spaceName: string) =>
unwrapApi<EmojiPage | null>(
Apis.chat.list_emojis({ pathParams: { space_name: spaceName }, params: { limit: 100 } }),
).then((page) => page?.items ?? [])
/* -------------------------------------------------------------- attachments */
/**
* Three-step upload: reserve a row + presigned PUT, stream the bytes, then
* `finalize` (which `head`s the object and refuses an empty/oversized blob).
* Only a `Ready`/`Uploaded` attachment the caller owns may be referenced by
* `send_message`, so a message never sends half-uploaded ids.
*/
export const createAttachment = (cmd: { filename: string; content_type: string; size: number }) =>
unwrapApi<UploadIntent>(Apis.chat.create_attachment({ data: cmd }))
export const finalizeAttachment = (
attachmentId: string,
meta: { width?: number | null; height?: number | null; duration_secs?: number | null } = {},
) =>
unwrapApi<Attachment>(
Apis.chat.finalize_attachment({
pathParams: { attachment_id: attachmentId },
data: {
width: meta.width ?? null,
height: meta.height ?? null,
duration_secs: meta.duration_secs ?? null,
},
}),
)
/** Stream endpoint used by every `src`/download link: cookie-authed, no expiry. */
export { attachmentUrl } from './meta'
/**
* PUT the raw bytes to the presigned URL. The object store allows `*` origins,
* so the browser talks to it directly; `trackFetch` deliberately does not wrap
* this call — a dead bucket must not look like a dead API to the outage gate.
*/
export async function putUpload(uploadUrl: string, file: File): Promise<void> {
const response = await fetch(uploadUrl, {
method: 'PUT',
headers: { 'content-type': file.type || 'application/octet-stream' },
body: file,
})
if (!response.ok) {
throw new Error(translate(getLocale(), 'chat.upload.failedStatus', { status: response.status }))
}
}
/** Probe an image blob's intrinsic size for `finalize` (best effort). */
export function readImageSize(file: File): Promise<{ width: number; height: number } | null> {
return new Promise((resolve) => {
if (!file.type.startsWith('image/')) return resolve(null)
const url = URL.createObjectURL(file)
const image = new Image()
const done = (value: { width: number; height: number } | null) => {
URL.revokeObjectURL(url)
resolve(value)
}
image.onload = () =>
done(
image.naturalWidth > 0 && image.naturalHeight > 0
? { width: image.naturalWidth, height: image.naturalHeight }
: null,
)
image.onerror = () => done(null)
image.src = url
})
}