《互联网产品的客户端架构·内容、社交与实时互动》13.1 端到端场景：发内容、互动、实时回复

// file: src/summary/e2e.ts
// tier: L2
// verify: node --test --test-concurrency=1 test/summary/e2e.test.ts
import type { ContentBlock, ContentItem } from "../core/content-model.ts";
import { SocialClient } from "../core/social-client.ts";
import { ReactionStore } from "../interaction/optimistic.ts";
import { CommentThread } from "../interaction/comments.ts";
import type { CommentRecord, TimelineEntry } from "../interaction/comments.ts";
import { OrderingGate } from "../reliability/ordering.ts";
import type { IngestStatus } from "../reliability/ordering.ts";
import { UnreadMerger } from "../notify/unread.ts";

export type Clock = () => number;

export interface ReplyEvent {
  id: string;
  seq: number;
  itemId: string;
  authorId: string;
  text: string;
}

export interface ReplyResult {
  status: IngestStatus;
  badge: number;
  commentCount: number;
}

const FEED = "home";

function cloneItem(item: ContentItem): ContentItem {
  return { ...item, blocks: item.blocks.map((block) => ({ ...block })) };
}

// 内存服务端只负责“事实”：绝对计数、评论记录、自增 id。
// 它不模拟网络延迟与失败，那些交给 13.2 的可控适配器。
export class MemorySocialServer {
  #items: ContentItem[] = [];
  #liked = new Set<string>();
  #likes = new Map<string, number>();
  #comments = new Map<string, CommentRecord[]>();
  #itemSeq = 0;
  #commentSeq = 0;
  #now: Clock;

  constructor(now: Clock = () => Date.now()) {
    this.#now = now;
  }

  publish(authorId: string, blocks: ContentBlock[], likeCount = 0): { item: ContentItem } {
    if (authorId.trim() === "" || blocks.length === 0) throw new Error("作者与内容块不能为空");
    this.#itemSeq += 1;
    const item: ContentItem = {
      id: `post-${this.#itemSeq}`,
      authorId,
      createdAt: this.#now(),
      state: "published",
      blocks: blocks.map((block) => ({ ...block })),
      likeCount,
      commentCount: 0,
    };
    this.#items.unshift(item);
    this.#likes.set(item.id, likeCount);
    return { item: cloneItem(item) };
  }

  feedPage(limit = 20): { items: ContentItem[]; nextCursor: string | null } {
    const items = [...this.#items]
      .sort((a, b) => b.createdAt - a.createdAt || b.id.localeCompare(a.id))
      .slice(0, limit)
      .map(cloneItem);
    return { items, nextCursor: null };
  }

  // 发送目标状态而不是 toggle；重复发送同一个 active 不改变计数。
  setLike(itemId: string, active: boolean): { active: boolean; count: number } {
    const item = this.#find(itemId);
    if (this.#liked.has(itemId) !== active) {
      const count = Math.max(0, (this.#likes.get(itemId) ?? 0) + (active ? 1 : -1));
      this.#likes.set(itemId, count);
      item.likeCount = count;
      if (active) this.#liked.add(itemId);
      else this.#liked.delete(itemId);
    }
    return this.reaction(itemId);
  }

  reaction(itemId: string): { active: boolean; count: number } {
    this.#find(itemId);
    return { active: this.#liked.has(itemId), count: this.#likes.get(itemId) ?? 0 };
  }

  // 其他用户的点赞只改绝对计数，不改变当前用户的互动关系。
  receiveLike(itemId: string, delta = 1): { count: number } {
    if (!Number.isInteger(delta) || delta === 0) throw new RangeError("delta 必须是非零整数");
    const item = this.#find(itemId);
    const count = Math.max(0, (this.#likes.get(itemId) ?? 0) + delta);
    this.#likes.set(itemId, count);
    item.likeCount = count;
    return { count };
  }

  addComment(itemId: string, authorId: string, text: string): CommentRecord {
    const item = this.#find(itemId);
    const body = text.trim();
    if (body === "") throw new Error("评论内容不能为空");
    this.#commentSeq += 1;
    const record: CommentRecord = {
      id: `cmt-${this.#commentSeq}`,
      threadId: itemId,
      authorId,
      text: body,
      createdAt: this.#now(),
    };
    this.#comments.set(itemId, [...(this.#comments.get(itemId) ?? []), record]);
    item.commentCount += 1;
    return { ...record };
  }

  comments(itemId: string): CommentRecord[] {
    return (this.#comments.get(itemId) ?? []).map((comment) => ({ ...comment }));
  }

  #find(itemId: string): ContentItem {
    const item = this.#items.find((entry) => entry.id === itemId);
    if (!item) throw new Error(`未知内容 ${itemId}`);
    return item;
  }
}

// 组合层只做显式回写：信息流、互动关系、评论时间线、实时顺序门各管各的状态。
export class SocialSession {
  readonly client = new SocialClient();
  #server: MemorySocialServer;
  #reactions = new ReactionStore();
  #threads: CommentThread;
  #gate = new OrderingGate({ initialSeq: 0 });
  #unread = new UnreadMerger();
  #replies = new Map<string, ReplyEvent>();
  #seeded = new Set<string>();
  #replySeq = 0;

  constructor(server: MemorySocialServer, options: { now?: Clock; idFactory?: () => string } = {}) {
    this.#server = server;
    let localId = 0;
    const idFactory = options.idFactory ?? (() => `local-${++localId}`);
    this.#threads = new CommentThread({ now: options.now, idFactory, authorId: "me" });
  }

  get feed(): ContentItem[] {
    return this.client.items(FEED);
  }

  get cursor(): string | null {
    return this.client.cursor(FEED);
  }

  get badge(): number {
    return this.#unread.badge().total;
  }

  publish(authorId: string, blocks: ContentBlock[]): ContentItem {
    const { item } = this.#server.publish(authorId, blocks);
    this.client.replacePage(FEED, this.#server.feedPage());
    return item;
  }

  like(itemId: string): { active: boolean; count: number } {
    const before = this.#feedItem(itemId).likeCount;
    if (!this.#seeded.has(itemId)) {
      this.#reactions.seed(itemId, { like: this.#server.reaction(itemId) });
      this.#seeded.add(itemId);
    }
    const request = this.#reactions.toggle(itemId, "like");
    this.#reactions.settle(request, this.#server.setLike(itemId, request.active));
    const view = this.#reactions.view(itemId).like;
    this.client.updateInteraction(FEED, itemId, { like: view.count - before });
    return view;
  }

  comment(itemId: string, text: string): TimelineEntry[] {
    this.#feedItem(itemId);
    this.#threads.seed(itemId, this.#server.comments(itemId));
    const request = this.#threads.submit(itemId, text);
    const record = this.#server.addComment(itemId, "me", request.text);
    if (this.#threads.markSent(request.clientId, record).inserted) {
      this.client.updateInteraction(FEED, itemId, { comment: 1 });
    }
    return this.#threads.timeline(itemId);
  }

  receiveReply(itemId: string, authorId: string, text: string): ReplyResult {
    this.#feedItem(itemId);
    this.#replySeq += 1;
    return this.deliver({ id: `reply-${this.#replySeq}`, seq: this.#replySeq, itemId, authorId, text });
  }

  // 实时回复也走顺序门：重复、迟到与超前都先判定，再决定是否更新角标与计数。
  deliver(event: ReplyEvent): ReplyResult {
    this.#replies.set(event.id, event);
    const result = this.#gate.ingest({ id: event.id, seq: event.seq });
    if (result.status === "applied") {
      for (const applied of result.applied) {
        const payload = this.#replies.get(applied.id);
        if (!payload) throw new Error(`缺少实时事件 ${applied.id}`);
        this.#unread.applyEvent({ id: payload.id, kind: "comment", seq: payload.seq });
        this.client.updateInteraction(FEED, payload.itemId, { comment: 1 });
        this.#replies.delete(payload.id);
      }
    }
    return {
      status: result.status,
      badge: this.badge,
      commentCount: this.#feedItem(event.itemId).commentCount,
    };
  }

  // replacePage 只插新条目，已有条目的计数不会被覆盖；刷新必须显式对账。
  refresh(): ContentItem[] {
    const page = this.#server.feedPage();
    const before = new Map(
      this.client.items(FEED).map((item) => [
        item.id,
        { like: item.likeCount, comment: item.commentCount },
      ]),
    );
    this.client.replacePage(FEED, page);
    for (const item of page.items) {
      const old = before.get(item.id);
      if (old) {
        this.client.updateInteraction(FEED, item.id, {
          like: item.likeCount - old.like,
          comment: item.commentCount - old.comment,
        });
      }
      if (this.#seeded.has(item.id)) {
        this.#reactions.applySnapshot(item.id, { like: this.#server.reaction(item.id) });
      }
    }
    return this.feed;
  }

  appliedReplySeqs(): number[] {
    return this.#gate.appliedSeqs();
  }

  reactionView(itemId: string): { active: boolean; count: number } {
    return this.#reactions.view(itemId).like;
  }

  pendingLike(itemId: string): boolean {
    return this.#reactions.pending(itemId, "like");
  }

  #feedItem(itemId: string): ContentItem {
    const item = this.client.items(FEED).find((entry) => entry.id === itemId);
    if (!item) throw new Error(`信息流里没有 ${itemId}`);
    return item;
  }
}

$ node --test --test-concurrency=1 test/summary/e2e.test.ts
✔ 发内容后信息流出现同一条，状态与计数都来自服务端快照 (0.752ms)
✔ 点赞先改互动意图，确认后信息流计数显式回写 (0.70675ms)
✔ 取消点赞回到零，服务端重复确认不会把计数减成负数 (0.133625ms)
✔ 评论先有本地占位，服务端确认后只保留一条已确认记录 (0.272292ms)
✔ 实时回复按序应用，角标与评论计数同步增加 (0.306334ms)
✔ 同一条实时回复重复投递被顺序门判为 duplicate，不重复计数 (0.107958ms)
✔ 刷新用绝对快照覆盖计数，但不覆盖当前用户已确认的互动关系 (0.19925ms)
ℹ tests 7
ℹ suites 0
ℹ pass 7
ℹ fail 0
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 154.855416