Skip to content

armgit / zulip

Public Imported from GitHub
0

Zulip server and web application. Open-source team chat that helps teams stay productive and focused.

14.3 KB
Raw Blame
import assert from "minimalistic-assert";

import * as echo_state from "./echo_state.ts";
import {FoldDict} from "./fold_dict.ts";
import * as internal_url from "./internal_url.ts";
import * as message_util from "./message_util.ts";
import * as resolved_topics from "./resolved_topic.ts";
import * as sub_store from "./sub_store.ts";
import * as unread from "./unread.ts";

// stream_id -> PerStreamHistory object
const stream_dict = new Map<number, PerStreamHistory>();
const fetched_stream_ids = new Set<number>();
const request_pending_stream_ids = new Set<number>();

// This is stream_topic_history_util.get_server_history.
// We have to indirectly set it to avoid a circular dependency.
let update_topic_last_message_id: (stream_id: number, topic_name: string) => void;
export function set_update_topic_last_message_id(
    f: (stream_id: number, topic_name: string) => void,
): void {
    update_topic_last_message_id = f;
}

export function stream_has_topics(stream_id: number): boolean {
    if (!stream_dict.has(stream_id)) {
        return false;
    }

    const history = stream_dict.get(stream_id);
    assert(history !== undefined);

    return history.has_topics();
}

export function channel_has_locally_available_topic(
    channel_id: number,
    topic_name: string,
): boolean {
    if (!stream_dict.has(channel_id)) {
        return false;
    }

    const history = stream_dict.get(channel_id);
    assert(history !== undefined);

    return history.topics.has(topic_name);
}

export function stream_has_locally_available_named_topics(stream_id: number): boolean {
    if (!stream_dict.has(stream_id)) {
        return false;
    }

    const history = stream_dict.get(stream_id);
    assert(history !== undefined);

    const topic_names = history.topics.keys();
    for (const topic_name of topic_names) {
        if (topic_name !== "") {
            return true;
        }
    }
    return false;
}

export function stream_has_locally_available_resolved_topics(stream_id: number): boolean {
    if (!stream_dict.has(stream_id)) {
        return false;
    }

    const history = stream_dict.get(stream_id);
    assert(history !== undefined);

    return history.has_resolved_topics();
}

export type TopicHistoryEntry = {
    count: number;
    message_id: number;
    pretty_name: string;
};

type ServerTopicHistoryEntry = {
    name: string;
    max_id: number;
};

export class PerStreamHistory {
    /*
        For a given stream, this structure has a dictionary of topics.
        The main getter of this object is get_recent_topic_names, and
        we just sort on the fly every time we are called.

        Attributes for a topic are:
        * message_id: The latest message_id in the topic. This is to
            the best of our knowledge, and may not be accurate if
            we have not seen all the messages in the topic.
        * pretty_name: The topic_name, with original case.
        * count: Number of known messages in the topic.  Used to detect
          when the last messages in a topic were moved to other topics or
          deleted.
    */

    topics = new FoldDict<TopicHistoryEntry>();
    // Most recent message ID for the stream.
    max_message_id = 0;
    stream_id: number;

    constructor(stream_id: number) {
        this.stream_id = stream_id;
    }

    has_resolved_topics(): boolean {
        return this.topics.keys().some((topic) => resolved_topics.is_resolved(topic));
    }

    has_topics(): boolean {
        return this.topics.size > 0;
    }

    update_stream_with_message_id(message_id: number): void {
        if (message_id > this.max_message_id) {
            this.max_message_id = message_id;
        }

        // Update the first_message_id for the stream.
        // It is fine if `first_message_id` changes to be higher
        // due to removal of messages since it will not cause to
        // display wrong list of topics. So, we don't update it here.
        // On the other hand, if it changes to be lower
        // we may miss some topics in autocomplete in the range
        // of outdated-`first_message_id` to new-`message_id`.
        // Note that this can only happen if a user moves old
        // messages to the stream from another stream.
        const sub = sub_store.get(this.stream_id);
        if (!sub) {
            return;
        }

        if (sub.first_message_id === null || sub.first_message_id === undefined) {
            fetched_stream_ids.delete(this.stream_id);
            sub.first_message_id = message_id;
            return;
        }

        if (sub.first_message_id > message_id) {
            fetched_stream_ids.delete(this.stream_id);
            sub.first_message_id = message_id;
        }
    }

    add_or_update(topic_name: string, message_id: number): void {
        // The `message_id` provided here can easily be far from the latest
        // message in the topic, but it is more important for us to cache the topic
        // for autocomplete purposes than to have an accurate max message ID.
        this.update_stream_with_message_id(message_id);

        const existing = this.topics.get(topic_name);

        if (!existing) {
            this.topics.set(topic_name, {
                message_id,
                pretty_name: topic_name,
                count: 1,
            });
            return;
        }

        existing.count += 1;

        if (message_id > existing.message_id) {
            existing.message_id = message_id;
            existing.pretty_name = topic_name;
        }
    }

    maybe_remove(topic_name: string, num_messages: number): void {
        const existing = this.topics.get(topic_name);

        if (!existing) {
            return;
        }

        if (existing.count <= num_messages) {
            this.topics.delete(topic_name);
            // Verify if this topic still has messages from the server.
            update_topic_last_message_id(this.stream_id, topic_name);
        }

        existing.count -= num_messages;
    }

    add_history(server_history: ServerTopicHistoryEntry[]): void {
        // This method populates list of topics from the server.

        for (const obj of server_history) {
            const topic_name = obj.name;
            const message_id = obj.max_id;

            const existing = this.topics.get(topic_name);

            if (existing) {
                // If we have a topic in our cache, we update
                // the message_id to accurately reflect the latest
                // message in the topic.
                existing.message_id = message_id;
                continue;
            }

            // If we get here, we are either finding out about
            // the topic for the first time, or we are getting
            // more current data for it.

            this.topics.set(topic_name, {
                message_id,
                pretty_name: topic_name,
                count: 0,
            });
            this.update_stream_with_message_id(message_id);
        }
    }

    get_recent_topic_names(): string[] {
        // Combines several data sources to produce a complete picture
        // of topics the client knows about.
        //
        // This data source is this module's own data structures.
        const my_recents = this.topics.values().toArray();
        // This data source is older topics that we know exist because
        // we have unread messages in the topic, even if we don't have
        // any messages from the topic in our local cache.
        const missing_topics = unread.get_missing_topics({
            stream_id: this.stream_id,
            topic_dict: this.topics,
        });

        // This data source is locally echoed messages, which should
        // are treated as newer than all delivered messages.
        const local_echo_topics = [
            ...echo_state.get_waiting_for_ack_local_ids_by_topic(this.stream_id),
        ].map(([topic, local_id]) => ({pretty_name: topic, message_id: local_id}));
        const local_echo_set = new Set<string>(
            local_echo_topics.map((message_topic) => message_topic.pretty_name.toLowerCase()),
        );

        // We first sort the topics without locally echoed messages,
        // and then prepend topics with locally echoed messages.
        const server_topics = [...my_recents, ...missing_topics].filter(
            (message_topic) => !local_echo_set.has(message_topic.pretty_name.toLowerCase()),
        );
        server_topics.sort((a, b) => b.message_id - a.message_id);
        return [...local_echo_topics, ...server_topics].map((obj) => obj.pretty_name);
    }

    get_max_message_id(): number {
        // TODO: We probably want to migrate towards this function
        // ignoring locally echoed messages, and thus returning an integer.
        const unacked_message_ids_in_stream = echo_state.get_waiting_for_ack_local_ids_by_topic(
            this.stream_id,
        );
        const max_message_id = Math.max(
            ...unacked_message_ids_in_stream.values(),
            this.max_message_id,
        );
        return max_message_id;
    }
}

export function remove_messages(opts: {
    stream_id: number;
    topic_name: string;
    num_messages: number;
    max_removed_msg_id: number;
}): void {
    const stream_id = opts.stream_id;
    const topic_name = opts.topic_name;
    const num_messages = opts.num_messages;
    const max_removed_msg_id = opts.max_removed_msg_id;
    const history = stream_dict.get(stream_id);

    // This is the special case of "removing" a message from
    // a topic, which happens when we edit topics.

    if (!history) {
        return;
    }

    // Adjust our local data structures to account for the
    // removal of messages from a topic. We can also remove
    // the topic if it has no messages left or if we cannot
    // locally determine the current state of the topic.
    // So, it is important that we return below if we don't have
    // the topic cached.
    history.maybe_remove(topic_name, num_messages);
    const existing_topic = history.topics.get(topic_name);
    if (!existing_topic) {
        return;
    }

    // Update max_message_id in topic
    if (existing_topic.message_id <= max_removed_msg_id) {
        const msgs_in_topic = message_util.get_loaded_messages_in_topic(stream_id, topic_name);
        let max_message_id = 0;
        for (const msg of msgs_in_topic) {
            if (msg.id > max_message_id) {
                max_message_id = msg.id;
            }
        }
        existing_topic.message_id = max_message_id;
    }

    // Update max_message_id in stream
    if (history.max_message_id <= max_removed_msg_id) {
        history.max_message_id = message_util.get_max_message_id_in_stream(stream_id);
    }
}

export function update_topic_name_case(
    stream_id: number,
    old_topic_name: string,
    new_topic_name: string,
): void {
    const history = stream_dict.get(stream_id);
    if (!history) {
        return;
    }

    const existing_topic = history.topics.get(old_topic_name);
    if (!existing_topic) {
        return;
    }
    existing_topic.pretty_name = new_topic_name;
}

export function find_or_create(stream_id: number): PerStreamHistory {
    let history = stream_dict.get(stream_id);

    if (!history) {
        history = new PerStreamHistory(stream_id);
        stream_dict.set(stream_id, history);
    }

    return history;
}

export function add_message(opts: {
    stream_id: number;
    message_id: number;
    topic_name: string;
}): void {
    const stream_id = opts.stream_id;
    const message_id = opts.message_id;
    const topic_name = opts.topic_name;

    const history = find_or_create(stream_id);

    history.add_or_update(topic_name, message_id);
}

export function add_history(stream_id: number, server_history: ServerTopicHistoryEntry[]): void {
    const history = find_or_create(stream_id);
    history.add_history(server_history);
    fetched_stream_ids.add(stream_id);
}

export function has_history_for(stream_id: number): boolean {
    return fetched_stream_ids.has(stream_id);
}

export function mark_history_fetched_for(stream_id: number): void {
    fetched_stream_ids.add(stream_id);
}

export function get_recent_topic_names(stream_id: number): string[] {
    const history = find_or_create(stream_id);

    return history.get_recent_topic_names();
}

export function get_max_message_id(stream_id: number): number {
    const history = find_or_create(stream_id);

    return history.get_max_message_id();
}

export function get_latest_known_message_id_in_topic(
    stream_id: number,
    topic_name: string,
): number | undefined {
    const history = stream_dict.get(stream_id);
    return history?.topics.get(topic_name)?.message_id;
}

export function get_known_topic_name(stream_id: number, topic_name: string): string | undefined {
    return stream_dict.get(stream_id)?.topics.get(topic_name)?.pretty_name;
}

// We use the topic permalinks if we have access to the last message
// id of the topic in the cache, by encoding it at the end of the
// traditional channel-topic url using a `with` operator. If client
// cache doesn't have a message, we use the traditional link format.
export function channel_topic_permalink_hash(stream_id: number, topic: string): string {
    // From an API perspective, any message ID in the topic is a valid
    // choice. In the client code, we choose the latest message ID in
    // the topic, since display in recent conversations, the left
    // sidebar, and most other elements are placed in a way reflecting
    // the recency of the latest message in the topic.
    const target_message_id = get_latest_known_message_id_in_topic(stream_id, topic);

    return internal_url.by_stream_topic_url(
        stream_id,
        topic,
        sub_store.maybe_get_stream_name,
        target_message_id,
    );
}

export function reset(): void {
    // This is only used by tests.
    stream_dict.clear();
    fetched_stream_ids.clear();
    request_pending_stream_ids.clear();
}

export function is_request_pending_for(stream_id: number): boolean {
    return request_pending_stream_ids.has(stream_id);
}

export function add_request_pending_for(stream_id: number): void {
    request_pending_stream_ids.add(stream_id);
}

export function remove_request_pending_for(stream_id: number): void {
    request_pending_stream_ids.delete(stream_id);
}

export function remove_history_for_stream(stream_id: number): void {
    // Currently only used when user loses access to a stream.
    stream_dict.delete(stream_id);
    fetched_stream_ids.delete(stream_id);
}