gloomberb 0.7.5 → 0.8.0

package/src/plugins/builtin/chat/controller/index.ts

@@ -0,0 +1,488 @@
+import type { AppNotificationRequest, PluginPersistence, PluginResumeState } from "../../../../types/plugin";
+import {
+  apiClient,
+  type ChatChannel,
+  type ChatChannelState,
+  type ChatMessage,
+} from "../../../../api-client";
+import { debugLog } from "../../../../utils/debug-log";
+import {
+  getUnreadMentionMessages,
+  getVisibleMessages,
+  markChatChannelViewedThroughLatestMessage,
+  mergeChatMessages,
+} from "./messages";
+import {
+  DEFAULT_CHAT_CHANNEL_ID,
+  normalizeChannelId,
+  type ChannelRuntimeState,
+  type ChatControllerSnapshot,
+  type MergeMessagesOptions,
+} from "./state";
+import {
+  attachChatChannelView,
+  updateChatChannelDraft,
+  updateChatChannelNotifications,
+} from "./channel-actions";
+import { sendChatMessageToChannel } from "./send";
+import {
+  clearChatControllerSessionState,
+  disposeChatControllerRuntime,
+  resetChatControllerRuntime,
+} from "./lifecycle";
+import type { ChatSessionUser } from "./persistence";
+import {
+  closeAllChannelConnections,
+  closeInactiveChannelConnections,
+  countOpenConnections,
+  ensureChatChannelConnection,
+  getOpenConnectionChannelIds,
+  getSafetyRefreshChannelIds as getChannelIdsForSafetyRefresh,
+} from "./connections";
+import {
+  handleChatNotification as handleChatNotificationEvent,
+} from "./notifications";
+import { ChatControllerRealtime } from "./realtime";
+import { ChatControllerChannels } from "./channels";
+import { ChatControllerView } from "./view";
+import { ChatControllerMessageLoading } from "./message-loading";
+import { ChatControllerStorage } from "./storage";
+import {
+  applySignedOutChatControllerSession,
+  createChatControllerSessionState,
+  hydrateChatControllerSession,
+  refreshChatControllerSession,
+} from "./session-runtime";
+
+const chatLog = debugLog.createLogger("chat-controller");
+
+export type { ChatControllerSnapshot } from "./state";
+
+export class ChatController {
+  private appActive = true;
+  private readonly session = createChatControllerSessionState();
+  private pendingMessageSeq = 0;
+  private notifyFn: (notification: AppNotificationRequest) => void = () => {};
+  private notifiedMessageIds = new Set<string>();
+
+  private get hydrated(): boolean { return this.session.hydrated; }
+  private set hydrated(value: boolean) { this.session.hydrated = value; }
+  private get sessionToken(): string | null { return this.session.sessionToken; }
+  private set sessionToken(value: string | null) { this.session.sessionToken = value; }
+  private get sessionChecked(): boolean { return this.session.sessionChecked; }
+  private set sessionChecked(value: boolean) { this.session.sessionChecked = value; }
+  private get user(): ChatSessionUser | null { return this.session.user; }
+  private set user(value: ChatSessionUser | null) { this.session.user = value; }
+
+  private readonly storage = new ChatControllerStorage({
+    emit: (channelId) => this.emit(channelId),
+    getSessionToken: () => this.session.sessionToken,
+    getUser: () => this.session.user,
+  });
+  private readonly channelCatalog = new ChatControllerChannels({
+    canLoadPrivateState: () => !!this.session.user?.emailVerified && !!this.session.sessionToken,
+    ensureChannelState: (channelId) => this.ensureChannelState(channelId),
+    getChannelStateIds: () => this.storage.channelStates.keys(),
+    handleNotification: (notification, options) => this.handleChatNotification(notification, options),
+    ensureOpenChannelConnections: () => this.ensureOpenChannelConnections(),
+    emit: (channelId) => this.emit(channelId),
+  });
+  private readonly view = new ChatControllerView({
+    ensureChannelState: (channelId) => this.ensureChannelState(channelId),
+    getChannels: () => this.channelCatalog.getChannels(),
+    getChannelStateSnapshots: () => this.channelCatalog.getChannelStateSnapshots(),
+    isChannelsLoading: () => this.channelCatalog.isLoading(),
+    isSessionChecked: () => this.session.sessionChecked,
+    hasSessionToken: () => !!this.session.sessionToken,
+    getOnlineCount: () => this.channelCatalog.getOnlineCount(),
+    getUser: () => this.session.user,
+    getListenerSnapshot: (channelId) => this.getSnapshot(channelId),
+    getVisibleMessages: (channelId) => this.getVisibleMessages(channelId),
+    getUnreadMentionCount: (channelId) => this.getUnreadMentionCount(channelId),
+  });
+  private readonly messageLoading = new ChatControllerMessageLoading({
+    ensureChannelState: (channelId) => this.ensureChannelState(channelId),
+    emit: (channelId) => this.emit(channelId),
+    mergeMessages: (channelId, messages, options) => this.mergeMessages(channelId, messages, options),
+    persistChannelState: (channelId) => this.storage.persistChannelState(channelId),
+  });
+  private readonly realtime = new ChatControllerRealtime({
+    getAppActive: () => this.appActive,
+    getSessionToken: () => this.session.sessionToken,
+    getUser: () => this.session.user,
+    refreshSession: () => this.refreshSession(),
+    handleNotification: (notification) => this.handleChatNotification(notification),
+    setOnlineCount: (onlineCount) => {
+      this.channelCatalog.setOnlineCount(onlineCount);
+    },
+    emit: () => this.emit(),
+    getSafetyRefreshChannelIds: () => getChannelIdsForSafetyRefresh(this.storage.channelStates),
+    runSafetyRefresh: (channelId) => this.messageLoading.runMessagesRefresh(channelId, { showLoading: false }),
+  });
+
+  attachPersistence(persistence: PluginPersistence, resume?: PluginResumeState): void {
+    this.storage.attachPersistence(persistence, resume);
+    this.hydrate();
+  }
+
+  setNotifier(notify: (notification: AppNotificationRequest) => void): void {
+    this.notifyFn = notify;
+  }
+
+  hydrate(): void {
+    hydrateChatControllerSession({
+      session: this.session,
+      storage: this.storage,
+      syncVerificationPolling: () => this.realtime.syncVerificationPolling(),
+    });
+  }
+
+  subscribe(listener: (snapshot: ChatControllerSnapshot) => void): () => void;
+  subscribe(channelId: string, listener: (snapshot: ChatControllerSnapshot) => void): () => void;
+  subscribe(
+    channelIdOrListener: string | ((snapshot: ChatControllerSnapshot) => void),
+    maybeListener?: (snapshot: ChatControllerSnapshot) => void,
+  ): () => void {
+    if (typeof channelIdOrListener === "function") {
+      return this.view.subscribe(channelIdOrListener);
+    }
+    return this.view.subscribe(channelIdOrListener, maybeListener as (snapshot: ChatControllerSnapshot) => void);
+  }
+
+  getSnapshot(channelId = DEFAULT_CHAT_CHANNEL_ID): ChatControllerSnapshot {
+    return this.view.getSnapshot(channelId);
+  }
+
+  getChannels(): ChatChannel[] {
+    return this.channelCatalog.getChannels();
+  }
+
+  async refreshChannels(): Promise<void> {
+    return this.channelCatalog.refreshChannels();
+  }
+
+  async refreshPresence(): Promise<void> {
+    return this.channelCatalog.refreshPresence();
+  }
+
+  async refreshChatState(): Promise<void> {
+    return this.channelCatalog.refreshChatState();
+  }
+
+  async openDirectChannel(target: { userId?: string; username?: string }): Promise<ChatChannel> {
+    return this.channelCatalog.openDirectChannel(target);
+  }
+
+  async openGroupChannel(body: { userIds?: string[]; usernames?: string[]; name?: string }): Promise<ChatChannel> {
+    return this.channelCatalog.openGroupChannel(body);
+  }
+
+  async resolveRequiredChannelId(channelId: string): Promise<string> {
+    return this.channelCatalog.resolveRequiredChannelId(channelId);
+  }
+
+  async resolvePreferredChannelId(channelId: string | null | undefined): Promise<string> {
+    return this.channelCatalog.resolvePreferredChannelId(channelId);
+  }
+
+  private ensureChannelState(channelId: string): ChannelRuntimeState {
+    return this.storage.ensureChannelState(channelId);
+  }
+
+  async refreshSession(): Promise<void> {
+    return refreshChatControllerSession({
+      applySignedOut: () => this.applySignedOutSession(),
+      channelStates: this.storage.channelStates,
+      emit: () => this.emit(),
+      ensureOpenChannelConnections: () => this.ensureOpenChannelConnections(),
+      ensureRealtimeSubscriptions: () => this.realtime.ensureRealtimeSubscriptions(),
+      persistChannelState: (channelId) => this.storage.persistChannelState(channelId),
+      persistSession: (sessionToken, user) => this.storage.persistSession(sessionToken, user),
+      refreshChatState: () => this.refreshChatState(),
+      session: this.session,
+      stopRealtimeSubscriptions: () => {
+        this.realtime.stopRealtimeSubscriptions();
+        this.closeAllConnections();
+      },
+      stopSafetyRefresh: () => this.realtime.stopSafetyRefresh(),
+      stopVerificationPolling: () => this.realtime.stopVerificationPolling(),
+      syncVerificationPolling: () => this.realtime.syncVerificationPolling(),
+    });
+  }
+
+  async refreshMessages(): Promise<void> {
+    return this.messageLoading.refreshMessages();
+  }
+
+  async refreshChannelMessages(channelId: string): Promise<void> {
+    return this.messageLoading.refreshChannelMessages(channelId);
+  }
+
+  async loadOlderMessages(): Promise<void> {
+    return this.messageLoading.loadOlderMessages();
+  }
+
+  async loadOlderChannelMessages(channelId: string): Promise<void> {
+    return this.messageLoading.loadOlderChannelMessages(channelId);
+  }
+
+  setDraft(draft: string): void {
+    this.setChannelDraft(DEFAULT_CHAT_CHANNEL_ID, draft);
+  }
+
+  setChannelDraft(channelId: string, draft: string): void {
+    const normalizedChannelId = normalizeChannelId(channelId);
+    const channel = this.ensureChannelState(normalizedChannelId);
+    if (updateChatChannelDraft(channel, draft)) {
+      this.storage.scheduleDraftSync(normalizedChannelId);
+    }
+  }
+
+  setReplyToId(replyToId: string | null): void {
+    this.setChannelReplyToId(DEFAULT_CHAT_CHANNEL_ID, replyToId);
+  }
+
+  setChannelReplyToId(channelId: string, replyToId: string | null): void {
+    const normalizedChannelId = normalizeChannelId(channelId);
+    const channel = this.ensureChannelState(normalizedChannelId);
+    channel.replyToId = replyToId;
+    this.storage.persistChannelState(normalizedChannelId);
+    this.emit(normalizedChannelId);
+  }
+
+  setChannelNotificationsEnabled(channelId: string, enabled: boolean): void {
+    const normalizedChannelId = normalizeChannelId(channelId);
+    const channel = this.ensureChannelState(normalizedChannelId);
+    updateChatChannelNotifications({
+      channelId: normalizedChannelId,
+      channel,
+      enabled,
+      applyChannelState: (state) => this.applyChannelState(state),
+      ensureOpenChannelConnections: () => this.ensureOpenChannelConnections(),
+      emit: () => this.emit(),
+      notify: this.notifyFn,
+    });
+  }
+
+  attachView(): () => void {
+    return this.attachChannelView(DEFAULT_CHAT_CHANNEL_ID);
+  }
+
+  attachChannelView(channelId: string): () => void {
+    const normalizedChannelId = normalizeChannelId(channelId);
+    const channel = this.ensureChannelState(normalizedChannelId);
+    return attachChatChannelView({
+      channel,
+      channelId: normalizedChannelId,
+      emit: (nextChannelId) => this.emit(nextChannelId),
+      flushDraftSync: (nextChannelId) => this.storage.flushDraftSync(nextChannelId),
+      markViewedThroughLatestMessage: (nextChannelId) => this.markViewedThroughLatestMessage(nextChannelId),
+    });
+  }
+
+  clearSession(): void {
+    clearChatControllerSessionState({
+      channelStates: this.storage.channelStates.values(),
+      clearSessionIdentity: () => {
+        this.session.sessionToken = null;
+        this.session.user = null;
+        this.session.sessionChecked = false;
+      },
+      closeAllConnections: () => this.closeAllConnections(),
+      emit: () => this.emit(),
+      stopRealtime: () => this.realtime.stopAll(),
+    });
+  }
+
+  setAppActive(appActive: boolean): void {
+    if (this.appActive === appActive) return;
+    this.appActive = appActive;
+    if (!appActive) {
+      this.realtime.stopVerificationPolling();
+      return;
+    }
+    this.realtime.syncVerificationPolling();
+    void this.refreshChatState().catch(() => {});
+  }
+
+  reset(clearSession = false): void {
+    resetChatControllerRuntime({
+      channelStates: this.storage.channelStates,
+      clearApiSessionToken: () => apiClient.setSessionToken(null),
+      clearDraftSyncTimer: (channel) => this.storage.clearDraftSyncTimer(channel),
+      clearSessionIdentity: () => {
+        this.session.sessionToken = null;
+        this.session.user = null;
+      },
+      closeAllConnections: () => this.closeAllConnections(),
+      deleteSession: () => this.storage.deleteSession(),
+      deleteTranscript: (channelId) => this.storage.deleteTranscript(channelId),
+      emit: () => this.emit(),
+      persistChannelState: (channelId) => this.storage.persistChannelState(channelId),
+      persistSession: () => this.storage.persistSession(this.session.sessionToken, this.session.user),
+      shouldClearSession: clearSession,
+      stopRealtime: () => this.realtime.stopAll(),
+    });
+  }
+
+  dispose(): void {
+    chatLog.info("dispose controller", {
+      listeners: this.view.listenerCount,
+      connections: countOpenConnections(this.storage.channelStates.values()),
+    });
+    disposeChatControllerRuntime({
+      channelStates: this.storage.channelStates,
+      clearNotifications: () => this.notifiedMessageIds.clear(),
+      clearView: () => this.view.clear(),
+      closeAllConnections: () => this.closeAllConnections(),
+      flushDraftSync: (channelId) => this.storage.flushDraftSync(channelId),
+      resetNotifier: () => {
+        this.notifyFn = () => {};
+      },
+      stopRealtime: () => this.realtime.stopAll(),
+    });
+  }
+
+  send(content: string, replyToId?: string): boolean {
+    return this.sendToChannel(DEFAULT_CHAT_CHANNEL_ID, content, replyToId);
+  }
+
+  sendToChannel(channelId: string, content: string, replyToId?: string): boolean {
+    const normalizedChannelId = normalizeChannelId(channelId);
+    const channel = this.ensureChannelState(normalizedChannelId);
+    return sendChatMessageToChannel({
+      channelId: normalizedChannelId,
+      channel,
+      content,
+      replyToId,
+      user: this.session.user,
+      sessionToken: this.session.sessionToken,
+      ensureConnection: () => this.ensureConnection(normalizedChannelId),
+      getVisibleMessages: () => this.getVisibleMessages(normalizedChannelId),
+      nextPendingMessageId: () => `local:${Date.now()}:${this.pendingMessageSeq += 1}`,
+      persistChannelState: () => this.storage.persistChannelState(normalizedChannelId),
+      emit: () => this.emit(normalizedChannelId),
+      mergeMessages: (messages) => this.mergeMessages(normalizedChannelId, messages),
+      notify: this.notifyFn,
+    });
+  }
+
+  ensureConnection(channelId = DEFAULT_CHAT_CHANNEL_ID): void {
+    const normalizedChannelId = normalizeChannelId(channelId);
+    const channel = this.ensureChannelState(normalizedChannelId);
+    ensureChatChannelConnection({
+      channelId: normalizedChannelId,
+      channel,
+      canConnect: !!this.session.user?.emailVerified && !!this.session.sessionToken,
+      stopSafetyRefresh: () => this.realtime.stopSafetyRefresh(),
+      startSafetyRefresh: () => this.realtime.startSafetyRefresh(),
+      refreshMessages: () => this.refreshChannelMessages(normalizedChannelId),
+      connectChannel: (nextChannelId, onMessage, onDisconnect) => (
+        apiClient.connectChannel(nextChannelId, onMessage, onDisconnect)
+      ),
+      mergeMessages: (messages) => this.mergeMessages(normalizedChannelId, messages),
+    });
+  }
+
+  private emit(channelId?: string): void {
+    this.view.emit(channelId);
+  }
+
+  private applyChannelState(state: ChatChannelState): void {
+    const channel = this.ensureChannelState(state.channelId);
+    channel.notificationsEnabled = state.notificationsEnabled;
+    channel.unreadCount = state.unreadCount;
+    channel.lastViewedMessageId = state.lastReadMessageId ?? channel.lastViewedMessageId;
+  }
+
+  private closeAllConnections(): void {
+    closeAllChannelConnections(this.storage.channelStates.values());
+  }
+
+  private applySignedOutSession(): void {
+    applySignedOutChatControllerSession({
+      channelStates: this.storage.channelStates.values(),
+      closeAllConnections: () => this.closeAllConnections(),
+      emit: () => this.emit(),
+      persistSession: (sessionToken, user) => this.storage.persistSession(sessionToken, user),
+      session: this.session,
+      stopRealtime: () => this.realtime.stopAll(),
+    });
+  }
+
+  private ensureOpenChannelConnections(): void {
+    const channelIds = getOpenConnectionChannelIds(this.storage.channelStates);
+    closeInactiveChannelConnections(this.storage.channelStates, channelIds);
+    for (const channelId of channelIds) {
+      this.ensureConnection(channelId);
+    }
+  }
+
+  private mergeMessages(
+    channelIdOrMessages: string | ChatMessage[],
+    maybeMessages?: ChatMessage[] | MergeMessagesOptions,
+    maybeOptions?: MergeMessagesOptions,
+  ): void {
+    const channelId = Array.isArray(channelIdOrMessages) ? DEFAULT_CHAT_CHANNEL_ID : channelIdOrMessages;
+    const messages = Array.isArray(channelIdOrMessages)
+      ? channelIdOrMessages
+      : (maybeMessages as ChatMessage[] | undefined) ?? [];
+    const options = Array.isArray(channelIdOrMessages)
+      ? maybeMessages as MergeMessagesOptions | undefined
+      : maybeOptions;
+    const channel = this.ensureChannelState(channelId);
+    mergeChatMessages({
+      channel,
+      currentUserId: this.session.user?.id,
+      messages,
+      options,
+      markViewed: (persist) => this.markViewedThroughLatestMessage(channelId, persist),
+    });
+    this.storage.persistTranscript(channelId);
+    this.emit(channelId);
+  }
+
+  private handleChatNotification(
+    notification: Parameters<typeof handleChatNotificationEvent>[0]["notification"],
+    options: { countUnread?: boolean } = {},
+  ): void {
+    handleChatNotificationEvent({
+      notification,
+      options,
+      ensureChannelState: (channelId) => this.ensureChannelState(channelId),
+      mergeMessages: (channelId, messages, mergeOptions) => this.mergeMessages(channelId, messages, mergeOptions),
+      notifiedMessageIds: this.notifiedMessageIds,
+      notify: this.notifyFn,
+    });
+  }
+
+  private getUnreadMentionCount(channelId: string): number {
+    const channel = this.ensureChannelState(channelId);
+    return getUnreadMentionMessages(channel, this.session.user).length;
+  }
+
+  private markViewedThroughLatestMessage(channelId: string, persist = true): boolean {
+    const channel = this.ensureChannelState(channelId);
+    return markChatChannelViewedThroughLatestMessage({
+      channel,
+      canSyncReadState: !!this.session.user?.emailVerified && !!this.session.sessionToken,
+      persist,
+      persistChannelState: () => this.storage.persistChannelState(channelId),
+      syncReadState: (messageId) => {
+        void apiClient.updateChatChannelState(channelId, {
+          readThroughMessageId: messageId,
+        }).then((state) => {
+          this.applyChannelState(state);
+          this.emit();
+        }).catch(() => {});
+      },
+    });
+  }
+
+  private getVisibleMessages(channelId: string): ChatMessage[] {
+    const channel = this.ensureChannelState(channelId);
+    return getVisibleMessages(channel);
+  }
+}
+
+export const chatController = new ChatController();

package/src/plugins/builtin/chat/controller/lifecycle.ts

@@ -0,0 +1,141 @@
+import type { ChannelRuntimeState } from "./state";
+import { createClientMessageId } from "./utils";
+
+export function clearSignedOutChannelState(channel: ChannelRuntimeState): void {
+  channel.pendingMessages = [];
+  channel.lastViewedMessageId = null;
+  channel.unreadCount = 0;
+  channel.notificationsEnabled = false;
+}
+
+function clearSessionChannelState(channel: ChannelRuntimeState): void {
+  clearSignedOutChannelState(channel);
+  channel.draftClientMessageId = channel.draft.trim()
+    ? createClientMessageId()
+    : null;
+}
+
+function resetChannelRuntimeState(channel: ChannelRuntimeState): void {
+  channel.messages = [];
+  channel.pendingMessages = [];
+  channel.draft = "";
+  channel.draftClientMessageId = null;
+  channel.replyToId = null;
+  channel.lastCursor = null;
+  channel.lastViewedMessageId = null;
+  channel.unreadCount = 0;
+  channel.notificationsEnabled = false;
+  channel.reachedOldestMessage = false;
+  channel.openViewCount = 0;
+}
+
+function disposeChannelRuntimeState(channel: ChannelRuntimeState): void {
+  channel.messagesLoading = false;
+  channel.olderMessagesLoading = false;
+  channel.refreshMessagesPromise = null;
+  channel.loadOlderMessagesPromise = null;
+  channel.openViewCount = 0;
+}
+
+interface ClearChatControllerSessionOptions {
+  channelStates: Iterable<ChannelRuntimeState>;
+  clearSessionIdentity: () => void;
+  closeAllConnections: () => void;
+  emit: () => void;
+  stopRealtime: () => void;
+}
+
+export function clearChatControllerSessionState({
+  channelStates,
+  clearSessionIdentity,
+  closeAllConnections,
+  emit,
+  stopRealtime,
+}: ClearChatControllerSessionOptions): void {
+  stopRealtime();
+  closeAllConnections();
+  clearSessionIdentity();
+  for (const channel of channelStates) {
+    clearSessionChannelState(channel);
+  }
+  emit();
+}
+
+interface ResetChatControllerRuntimeOptions {
+  channelStates: Iterable<[string, ChannelRuntimeState]>;
+  clearApiSessionToken: () => void;
+  clearDraftSyncTimer: (channel: ChannelRuntimeState) => void;
+  clearSessionIdentity: () => void;
+  closeAllConnections: () => void;
+  deleteSession: () => void;
+  deleteTranscript: (channelId: string) => void;
+  emit: () => void;
+  persistChannelState: (channelId: string) => void;
+  persistSession: () => void;
+  shouldClearSession: boolean;
+  stopRealtime: () => void;
+}
+
+export function resetChatControllerRuntime({
+  channelStates,
+  clearApiSessionToken,
+  clearDraftSyncTimer,
+  clearSessionIdentity,
+  closeAllConnections,
+  deleteSession,
+  deleteTranscript,
+  emit,
+  persistChannelState,
+  persistSession,
+  shouldClearSession,
+  stopRealtime,
+}: ResetChatControllerRuntimeOptions): void {
+  stopRealtime();
+  closeAllConnections();
+  for (const [channelId, channel] of channelStates) {
+    clearDraftSyncTimer(channel);
+    resetChannelRuntimeState(channel);
+    deleteTranscript(channelId);
+    persistChannelState(channelId);
+  }
+  if (shouldClearSession) {
+    clearSessionIdentity();
+    clearApiSessionToken();
+    deleteSession();
+  } else {
+    persistSession();
+  }
+  emit();
+}
+
+interface DisposeChatControllerRuntimeOptions {
+  channelStates: Iterable<[string, ChannelRuntimeState]>;
+  clearNotifications: () => void;
+  clearView: () => void;
+  closeAllConnections: () => void;
+  flushDraftSync: (channelId: string) => void;
+  resetNotifier: () => void;
+  stopRealtime: () => void;
+}
+
+export function disposeChatControllerRuntime({
+  channelStates,
+  clearNotifications,
+  clearView,
+  closeAllConnections,
+  flushDraftSync,
+  resetNotifier,
+  stopRealtime,
+}: DisposeChatControllerRuntimeOptions): void {
+  for (const [channelId] of channelStates) {
+    flushDraftSync(channelId);
+  }
+  stopRealtime();
+  closeAllConnections();
+  for (const [, channel] of channelStates) {
+    disposeChannelRuntimeState(channel);
+  }
+  resetNotifier();
+  clearView();
+  clearNotifications();
+}