prime the comment cache when loading replies for single conversation …

…view

adds a check to only prime once in the `commentCache` so we can keep
calling it to ensure it's at least done once when loading a stories
comments whether in the regular stream or a singular conversation view
so as to ensure the cache is primed to return all appropriate ancestors
and replies.

common/lib/errors.ts

@@ -467,4 +467,10 @@ export enum ERROR_CODES {
    * to a DSA report that is too long
    */
   DSA_REPORT_ADDITIONAL_INFO_TOO_LONG = "DSA_REPORT_ADDITIONAL_INFO_TOO_LONG",
+  /**
+   * UNABLE_TO_PRIME_CACHED_COMMENTS_FOR_STORY is thrown when DATA_CACHE is enabled and the
+   * priming of comments for the story in the data caches `commentCache` returns an undefined
+   * result. This usually means something went very wrong loading from Redis or Mongo.
+   */
+  UNABLE_TO_PRIME_CACHED_COMMENTS_FOR_STORY = "UNABLE_TO_PRIME_CACHED_COMMENTS_FOR_STORY"
 }

server/src/core/server/data/cache/commentCache.spec.ts

@@ -3,6 +3,7 @@ import RedisClient from "ioredis";
 import { waitFor } from "coral-common/common/lib/helpers";
 import { CommentCache } from "coral-server/data/cache/commentCache";
 import { MongoContext, MongoContextImpl } from "coral-server/data/context";
+import { UnableToPrimeCachedCommentsForStory } from "coral-server/errors";
 import logger from "coral-server/logger";
 import { Comment } from "coral-server/models/comment";
 import { createMongoDB } from "coral-server/services/mongodb";
@@ -84,6 +85,10 @@ it("can load root comments from commentCache", async () => {
     story.id,
     false
   );
+  if (!primeResult) {
+    throw new UnableToPrimeCachedCommentsForStory(story.tenantID, story.id);
+  }
+
   const results = await comments.rootComments(
     story.tenantID,
     story.id,
@@ -144,6 +149,10 @@ it("can load replies from commentCache", async () => {
     story.id,
     false
   );
+  if (!primeResult) {
+    throw new UnableToPrimeCachedCommentsForStory(story.tenantID, story.id);
+  }
+
   const rootResults = await comments.rootComments(
     story.tenantID,
     story.id,
@@ -211,6 +220,9 @@ it("cache expires appropriately", async () => {
     story.id,
     false
   );
+  if (!primeResult) {
+    throw new UnableToPrimeCachedCommentsForStory(story.tenantID, story.id);
+  }
   expect(primeResult.retrievedFrom).toEqual("redis");
 
   let lockExists = await redis.exists(lockKey);

server/src/core/server/data/cache/commentCache.ts

@@ -35,6 +35,7 @@ export class CommentCache implements IDataCache {
   private commentsByKey: Map<string, Readonly<Comment>>;
   private membersLookup: Map<string, string[]>;
   private tenantCache: TenantCache | null;
+  private primedStories: Set<string>;
 
   constructor(
     mongo: MongoContext,
@@ -55,6 +56,8 @@ export class CommentCache implements IDataCache {
 
     this.commentsByKey = new Map<string, Readonly<Comment>>();
     this.membersLookup = new Map<string, string[]>();
+
+    this.primedStories = new Set<string>();
   }
 
   public async available(tenantID: string): Promise<boolean> {
@@ -192,6 +195,10 @@ export class CommentCache implements IDataCache {
     storyID: string,
     isArchived: boolean
   ) {
+    if (this.primedStories.has(storyID)) {
+      return;
+    }
+
     const lockKey = this.computeLockKey(tenantID, storyID);
     const hasCommentsInRedis = await this.redis.exists(lockKey);
 
@@ -214,6 +221,8 @@ export class CommentCache implements IDataCache {
       commentIDs.add(comment.id);
     }
 
+    this.primedStories.add(storyID);
+
     return {
       userIDs: Array.from(userIDs),
       commentIDs: Array.from(commentIDs),

server/src/core/server/errors/index.ts

@@ -1064,3 +1064,12 @@ export class InvalidFlairBadgeName extends CoralError {
     });
   }
 }
+
+export class UnableToPrimeCachedCommentsForStory extends CoralError {
+  constructor(tenantID: string, storyID: string) {
+    super({
+      code: ERROR_CODES.UNABLE_TO_PRIME_CACHED_COMMENTS_FOR_STORY,
+      context: { pub: { tenantID } },
+    });
+  }
+}

server/src/core/server/errors/translations.ts

@@ -84,4 +84,6 @@ export const ERROR_TRANSLATIONS: Record<ERROR_CODES, string> = {
   INVALID_FLAIR_BADGE_NAME: "error-invalidFlairBadgeName",
   DSA_REPORT_LAW_BROKEN_TOO_LONG: "error-dsaReportLawBrokenTooLong",
   DSA_REPORT_ADDITIONAL_INFO_TOO_LONG: "error-dsaReportAdditionalInfoTooLong",
+  UNABLE_TO_PRIME_CACHED_COMMENTS_FOR_STORY:
+    "error-unableToPrimeCachedCommentsForStory",
 };

server/src/core/server/graph/loaders/Comments.ts

@@ -2,7 +2,10 @@ import DataLoader from "dataloader";
 import { defaultTo, isNumber } from "lodash";
 import { DateTime } from "luxon";
 
-import { StoryNotFoundError } from "coral-server/errors";
+import {
+  StoryNotFoundError,
+  UnableToPrimeCachedCommentsForStory,
+} from "coral-server/errors";
 import GraphContext from "coral-server/graph/context";
 import { retrieveManyUserActionPresence } from "coral-server/models/action/comment";
 import {
@@ -369,11 +372,16 @@ export default (ctx: GraphContext) => ({
       return connection;
     }
 
-    const { userIDs } = await ctx.cache.comments.primeCommentsForStory(
+    const primeResult = await ctx.cache.comments.primeCommentsForStory(
       ctx.tenant.id,
       storyID,
       isArchived
     );
+    if (!primeResult) {
+      throw new UnableToPrimeCachedCommentsForStory(ctx.tenant.id, storyID);
+    }
+
+    const { userIDs } = primeResult;
     await ctx.cache.users.loadUsers(ctx.tenant.id, userIDs);
     await ctx.cache.commentActions.primeCommentActions(ctx.tenant.id, story.id);
 

server/src/core/server/graph/resolvers/Comment.ts

@@ -147,12 +147,26 @@ export const Comment: GQLCommentTypeResolver<comment.Comment> = {
   },
   statusHistory: ({ id }, input, ctx) =>
     ctx.loaders.CommentModerationActions.forComment(input, id),
-  replies: (c, input, ctx) =>
+  replies: async (c, input, ctx) => {
     // If there is at least one reply, then use the connection loader, otherwise
     // return a blank connection.
-    c.childCount > 0
-      ? ctx.loaders.Comments.forParent(c.storyID, c.id, input)
-      : createConnection(),
+    if (c.childCount === 0) {
+      return createConnection();
+    }
+
+    const cacheAvailable = await ctx.cache.available(ctx.tenant.id);
+    if (cacheAvailable) {
+      const story = await ctx.loaders.Stories.find.load({ id: c.storyID });
+      await ctx.cache.comments.primeCommentsForStory(
+        ctx.tenant.id,
+        c.storyID,
+        !!story?.isArchived
+      );
+    }
+
+    const result = await ctx.loaders.Comments.forParent(c.storyID, c.id, input);
+    return result;
+  },
   replyCount: async ({ storyID, childIDs }, input, ctx) => {
     // TODO: (wyattjoh) the childCount should be used eventually, but it should be managed with the status so it's only a count of published comments
     if (childIDs.length === 0) {

server/src/core/server/locales/en-US/errors.ftl

@@ -85,3 +85,4 @@ error-dataCachingNotAvailable = Data caching is not available at this time.
 error-invalidFlairBadgeName = Only letters, numbers, and the special characters - . are permitted in flair badge names.
 error-dsaReportLawBrokenTooLong = What law do you believe has been broken for DSA report exceeds maximum length.
 error-dsaReportAdditionalInfoTooLong = Additional information for DSA report exceeds maximum length.
+error-unableToPrimeCachedCommentsForStory = Unable to prime cached comments for story.