10929273199

Committed 18 Sep 2024 08:01PM UTC coverage: 31.848% (-0.02%) from 31.871%

Build # 10929273199

Build Type

Pull #9714

github

Committed by

rjmk

Commit Message

More stuff in loaders

Pull Request Pull Request #9714: Doppel comments

Run Details

5071 of 41388 branches covered (12.25%)

Branch coverage included in aggregate %.

66 of 187 new or added lines in 16 files covered. (35.29%)

3 existing lines in 2 files now uncovered.

29462 of 67041 relevant lines covered (43.95%)

185.57 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

44.29

/packages/lesswrong/server/resolvers/commentResolvers.ts

import {addGraphQLMutation, addGraphQLResolvers} from '../../lib/vulcan-lib';
import { encodeIntlError} from '../../lib/vulcan-lib/utils';
import { userCanModerateComment } from "../../lib/collections/users/helpers";
import { accessFilterSingle, accessFilterMultiple, augmentFieldsDict } from '../../lib/utils/schemaUtils';
import { createAdminContext, createMutator, runFragmentQuery, updateMutator } from '../vulcan-lib';
import { Comments } from '../../lib/collections/comments';
import {CommentsRepo} from "../repos";
import { createPaginatedResolver } from './paginatedResolver';
import { filterNonnull } from '../../lib/utils/typeGuardUtils';
import { isLWorAF } from '../../lib/instanceSettings';
import { fetchFragmentSingle } from '../fetchFragment';
import DoppelComments from '@/lib/collections/doppelComments/collection';
import { constructMessageHistory } from '../autocompleteEndpoint';
import { Posts } from '@/lib/collections/posts';
import { getAnthropicPromptCachingClientOrThrow } from '../languageModels/anthropicClient';
import { markdownToHtmlSimple } from '@/lib/editor/utils';
import { captureException, captureMessage } from '@sentry/core';
import { Severity } from '@sentry/types';
import { userHasDoppelComments } from '@/lib/betas';
import { getWithCustomLoader, getWithLoader } from '@/lib/loaders';
import groupBy from 'lodash/groupBy';

const specificResolvers = {
  Mutation: {
    async moderateComment(root: void, { commentId, deleted, deletedPublic, deletedReason}: {
      commentId: string, deleted: boolean, deletedPublic: boolean, deletedReason: string
    }, context: ResolverContext) {
      const {currentUser} = context;
      const comment = await context.Comments.findOne(commentId)
      if (!comment) throw new Error("Invalid commentId");
      const post = comment.postId ? await context.Posts.findOne(comment.postId) : null;
      const tag = comment.tagId ? await context.Tags.findOne(comment.tagId) : null;
      
      if (currentUser && userCanModerateComment(currentUser, post, tag, comment))
      {
        let set: Record<string,any> = {deleted: deleted}
        if (deleted) {
          if(deletedPublic !== undefined) {
            set.deletedPublic = deletedPublic;
          }
          set.deletedDate = comment.deletedDate || new Date();
          if(deletedReason !== undefined) {
            set.deletedReason = deletedReason;
          }
          set.deletedByUserId = currentUser._id;
        } else { //When you undo delete, reset all delete-related fields
          set.deletedPublic = false;
          set.deletedDate = null;
          set.deletedReason = "";
          set.deletedByUserId = null;
        }
        
        const {data: updatedComment} = await updateMutator({
          collection: Comments,
          documentId: commentId,
          set,
          currentUser: currentUser,
          validate: false,
          context
        });
        return await accessFilterSingle(context.currentUser, context.Comments, updatedComment, context);
      } else {
        throw new Error(encodeIntlError({id: `app.user_cannot_moderate_post`}));
      }
    }
  }
};

addGraphQLResolvers(specificResolvers);
addGraphQLMutation('moderateComment(commentId: String, deleted: Boolean, deletedPublic: Boolean, deletedReason: String): Comment');


createPaginatedResolver({
  name: "CommentsWithReacts",
  graphQLType: "Comment",
  callback: async (context: ResolverContext, limit: number): Promise<DbComment[]> => {
    const commentsRepo = new CommentsRepo()
    const commentsWithReacts = await commentsRepo.getCommentsWithReacts(limit);
    return filterNonnull(commentsWithReacts);
  }
})

createPaginatedResolver({
  name: "PopularComments",
  graphQLType: "Comment",
  callback: async (
    context: ResolverContext,
    limit: number,
  ): Promise<DbComment[]> => {
    const recencyFactor = isLWorAF ? 175_000 : 250_000;
    return context.repos.comments.getPopularComments({limit, recencyFactor});
  },
  cacheMaxAgeMs: 300000, // 5 mins
});

type TopicRecommendation = {
  comment: DbComment,
  yourVote?: string,
  theirVote?: string,
  recommendationReason: string
}

augmentFieldsDict(Comments, {
  postVersion: {
    onCreate: async ({newDocument}) => {
      if (!newDocument.postId) {
        return "1.0.0";
      }
      const post = await fetchFragmentSingle({
        collectionName: "Posts",
        fragmentName: "PostsRevision",
        currentUser: null,
        selector: {_id: newDocument.postId},
      });
      return (post && post.contents && post.contents.version) || "1.0.0";
    },
  },
  doppelComments: {
    resolveAs: {
      type: '[DoppelComment]',
      resolver: async (dbComment, args, context: ResolverContext) => {
        const {DoppelComments, Users, currentUser} = context
        if (!userHasDoppelComments(currentUser)) return []
        // This should always be a single user
        const [user] = await getWithLoader(context, Users, "usersByIdsForDoppelComments", {}, "_id", dbComment.userId, {karma: 1})
        if (!user) return []
        if (user.karma < 10_000) return []
        const doppelComments = await getWithCustomLoader(context, "doppelCommentsForComment", dbComment._id, async (commentIds: string[]) => {
          const doppelComments = await DoppelComments.find({commentId: {$in: commentIds}}).fetch()
          const doppelsByComment = groupBy(doppelComments, 'commentId')
          return commentIds.map(commentId => doppelsByComment[commentId] ?? [])
        })
        if (doppelComments.length < 2) {
          // We'll make 'em for next time
          void [createDoppelComment(dbComment, user), createDoppelComment(dbComment, user)]
        }
        return doppelComments
      }
    }
  }
});

const createDoppelComment = async (dbComment: DbComment, user: DbUser) => {
  const [interestingGwernComment, eightShortStudies, topUserComment, topUserPost] = await Promise.all([
    Comments.findOne({ _id: 'hxMNNJRF6o644aNTa'}),
    Posts.findOne({_id: 'gFMH3Cqw4XxwL69iy'}),
    Comments.findOne({ userId: dbComment.userId }, { sort: { 'baseScore': -1 }, limit: 1, projection: { '_id': 1 } }),
    Posts.findOne({ userId: dbComment.userId }, { sort: { 'baseScore': -1 }, limit: 1, projection: { '_id': 1 } }),
  ])
  if (!interestingGwernComment || !eightShortStudies || !topUserComment || !topUserPost) {
    const docIdentifiers = ["interestingGwernComment", "eightShortStudies", "topUserComment", "topUserPost"]
    const failedToFind = [interestingGwernComment, eightShortStudies, topUserComment, topUserPost].flatMap((doc, i) => !doc ? [docIdentifiers[i]] : [])
    captureMessage(`Failed to find all necessary documents for doppel comments on ${dbComment._id}. Failed to find: ${failedToFind.join('\n')}`, Severity.Warning)
    return
  }
  const messageHistory = await constructMessageHistory(
    '',
    [interestingGwernComment, topUserComment].map(comment => comment._id),
    [eightShortStudies, topUserPost].map(post => post._id),
    user,
    createAdminContext(),
    dbComment.parentCommentId ?? undefined,
    dbComment.postId ?? undefined,
  )

  const client = getAnthropicPromptCachingClientOrThrow()

  let res = null
  try {
    res = await client.messages.create({
      model: 'claude-3-5-sonnet-20240620',
      max_tokens: 2000,
      system: "The assistant is in CLI simulation mode, and responds to the user's CLI commands only with the output of the command.",
      messages: messageHistory,
      stop_sequences: ['---'],
    })
  } catch (e) {
    captureException(e)
    return
  }

  if (res.content[0].type === 'tool_use') {
    captureMessage(`The LLM thinks this comment (${dbComment._id}) would be a tool use. That's surprising.`, Severity.Warning)
    return
  }

  const html = markdownToHtmlSimple(res.content[0].text)

  void createMutator({
    collection: DoppelComments,
    document: {
      commentId: dbComment._id,
      content: html,
    },
    context: createAdminContext(),
  })
}

1	import {addGraphQLMutation, addGraphQLResolvers} from '../../lib/vulcan-lib';	19✔
2	import { encodeIntlError} from '../../lib/vulcan-lib/utils';	19✔
3	import { userCanModerateComment } from "../../lib/collections/users/helpers";	19✔
4	import { accessFilterSingle, accessFilterMultiple, augmentFieldsDict } from '../../lib/utils/schemaUtils';	19✔
5	import { createAdminContext, createMutator, runFragmentQuery, updateMutator } from '../vulcan-lib';	19✔
6	import { Comments } from '../../lib/collections/comments';	19✔
7	import {CommentsRepo} from "../repos";	19✔
8	import { createPaginatedResolver } from './paginatedResolver';	19✔
9	import { filterNonnull } from '../../lib/utils/typeGuardUtils';	19✔
10	import { isLWorAF } from '../../lib/instanceSettings';	19✔
11	import { fetchFragmentSingle } from '../fetchFragment';	19✔
12	import DoppelComments from '@/lib/collections/doppelComments/collection';	19✔
13	import { constructMessageHistory } from '../autocompleteEndpoint';	19✔
14	import { Posts } from '@/lib/collections/posts';	19✔
15	import { getAnthropicPromptCachingClientOrThrow } from '../languageModels/anthropicClient';	19✔
16	import { markdownToHtmlSimple } from '@/lib/editor/utils';	19✔
17	import { captureException, captureMessage } from '@sentry/core';	19✔
18	import { Severity } from '@sentry/types';	19✔
19	import { userHasDoppelComments } from '@/lib/betas';	19✔
20	import { getWithCustomLoader, getWithLoader } from '@/lib/loaders';	19✔
21	import groupBy from 'lodash/groupBy';	19✔
22
23	const specificResolvers = {	19✔
24	Mutation: {
25	async moderateComment(root: void, { commentId, deleted, deletedPublic, deletedReason}: {
26	commentId: string, deleted: boolean, deletedPublic: boolean, deletedReason: string
27	}, context: ResolverContext) {
28	const {currentUser} = context;	5✔
29	const comment = await context.Comments.findOne(commentId)	5✔
30	if (!comment) throw new Error("Invalid commentId");	5!
31	const post = comment.postId ? await context.Posts.findOne(comment.postId) : null;	5!
32	const tag = comment.tagId ? await context.Tags.findOne(comment.tagId) : null;	5!
33
34	if (currentUser && userCanModerateComment(currentUser, post, tag, comment))	5✔
35	{
36	let set: Record<string,any> = {deleted: deleted}	2✔
37	if (deleted) {	2!
38	if(deletedPublic !== undefined) {	2!
39	set.deletedPublic = deletedPublic;	×
40	}
41	set.deletedDate = comment.deletedDate \|\| new Date();	2✔
42	if(deletedReason !== undefined) {	2!
43	set.deletedReason = deletedReason;	×
44	}
45	set.deletedByUserId = currentUser._id;	2✔
46	} else { //When you undo delete, reset all delete-related fields
47	set.deletedPublic = false;	×
48	set.deletedDate = null;	×
49	set.deletedReason = "";	×
50	set.deletedByUserId = null;	×
51	}
52
53	const {data: updatedComment} = await updateMutator({	2✔
54	collection: Comments,
55	documentId: commentId,
56	set,
57	currentUser: currentUser,
58	validate: false,
59	context
60	});
61	return await accessFilterSingle(context.currentUser, context.Comments, updatedComment, context);	2✔
62	} else {
63	throw new Error(encodeIntlError({id: `app.user_cannot_moderate_post`}));	3✔
64	}
65	}
66	}
67	};	19✔
68
69	addGraphQLResolvers(specificResolvers);	19✔
70	addGraphQLMutation('moderateComment(commentId: String, deleted: Boolean, deletedPublic: Boolean, deletedReason: String): Comment');	19✔
71
72
73	createPaginatedResolver({
74	name: "CommentsWithReacts",
75	graphQLType: "Comment",
76	callback: async (context: ResolverContext, limit: number): Promise<DbComment[]> => {
77	const commentsRepo = new CommentsRepo()	×
78	const commentsWithReacts = await commentsRepo.getCommentsWithReacts(limit);	×
79	return filterNonnull(commentsWithReacts);	×
80	}
81	})	19✔
82
83	createPaginatedResolver({
84	name: "PopularComments",
85	graphQLType: "Comment",
86	callback: async (
87	context: ResolverContext,
88	limit: number,
89	): Promise<DbComment[]> => {
90	const recencyFactor = isLWorAF ? 175_000 : 250_000;	×
91	return context.repos.comments.getPopularComments({limit, recencyFactor});	×
92	},
93	cacheMaxAgeMs: 300000, // 5 mins
94	});	19✔
95
96	type TopicRecommendation = {
97	comment: DbComment,
98	yourVote?: string,
99	theirVote?: string,
100	recommendationReason: string
101	}
102
103	augmentFieldsDict(Comments, {
104	postVersion: {
105	onCreate: async ({newDocument}) => {
106	if (!newDocument.postId) {	22!
107	return "1.0.0";	×
108	}
109	const post = await fetchFragmentSingle({	22✔
110	collectionName: "Posts",
111	fragmentName: "PostsRevision",
112	currentUser: null,
113	selector: {_id: newDocument.postId},
114	});
115	return (post && post.contents && post.contents.version) \|\| "1.0.0";	22!
116	},
117	},
118	doppelComments: {
119	resolveAs: {
120	type: '[DoppelComment]',
121	resolver: async (dbComment, args, context: ResolverContext) => {
NEW 122	const {DoppelComments, Users, currentUser} = context	×
NEW 123	if (!userHasDoppelComments(currentUser)) return []	×
124	// This should always be a single user
NEW 125	const [user] = await getWithLoader(context, Users, "usersByIdsForDoppelComments", {}, "_id", dbComment.userId, {karma: 1})	×
NEW 126	if (!user) return []	×
NEW 127	if (user.karma < 10_000) return []	×
NEW 128	const doppelComments = await getWithCustomLoader(context, "doppelCommentsForComment", dbComment._id, async (commentIds: string[]) => {	×
NEW 129	const doppelComments = await DoppelComments.find({commentId: {$in: commentIds}}).fetch()	×
NEW 130	const doppelsByComment = groupBy(doppelComments, 'commentId')	×
NEW 131	return commentIds.map(commentId => doppelsByComment[commentId] ?? [])	×
132	})
NEW 133	if (doppelComments.length < 2) {	×
134	// We'll make 'em for next time
NEW 135	void [createDoppelComment(dbComment, user), createDoppelComment(dbComment, user)]	×
136	}
NEW 137	return doppelComments	×
138	}
139	}
140	}
141	});
142
143	const createDoppelComment = async (dbComment: DbComment, user: DbUser) => {	19✔
NEW 144	const [interestingGwernComment, eightShortStudies, topUserComment, topUserPost] = await Promise.all([	×
145	Comments.findOne({ _id: 'hxMNNJRF6o644aNTa'}),
146	Posts.findOne({_id: 'gFMH3Cqw4XxwL69iy'}),
147	Comments.findOne({ userId: dbComment.userId }, { sort: { 'baseScore': -1 }, limit: 1, projection: { '_id': 1 } }),
148	Posts.findOne({ userId: dbComment.userId }, { sort: { 'baseScore': -1 }, limit: 1, projection: { '_id': 1 } }),
149	])
NEW 150	if (!interestingGwernComment \|\| !eightShortStudies \|\| !topUserComment \|\| !topUserPost) {	×
NEW 151	const docIdentifiers = ["interestingGwernComment", "eightShortStudies", "topUserComment", "topUserPost"]	×
NEW 152	const failedToFind = [interestingGwernComment, eightShortStudies, topUserComment, topUserPost].flatMap((doc, i) => !doc ? [docIdentifiers[i]] : [])	×
NEW 153	captureMessage(`Failed to find all necessary documents for doppel comments on ${dbComment._id}. Failed to find: ${failedToFind.join('\n')}`, Severity.Warning)	×
NEW 154	return	×
155	}
NEW 156	const messageHistory = await constructMessageHistory(	×
157	'',
NEW 158	[interestingGwernComment, topUserComment].map(comment => comment._id),	×
NEW 159	[eightShortStudies, topUserPost].map(post => post._id),	×
160	user,
161	createAdminContext(),
162	dbComment.parentCommentId ?? undefined,	×
163	dbComment.postId ?? undefined,	×
164	)
165
NEW 166	const client = getAnthropicPromptCachingClientOrThrow()	×
167
NEW 168	let res = null	×
NEW 169	try {	×
NEW 170	res = await client.messages.create({	×
171	model: 'claude-3-5-sonnet-20240620',
172	max_tokens: 2000,
173	system: "The assistant is in CLI simulation mode, and responds to the user's CLI commands only with the output of the command.",
174	messages: messageHistory,
175	stop_sequences: ['---'],
176	})
177	} catch (e) {
NEW 178	captureException(e)	×
NEW 179	return	×
180	}
181
NEW 182	if (res.content[0].type === 'tool_use') {	×
NEW 183	captureMessage(`The LLM thinks this comment (${dbComment._id}) would be a tool use. That's surprising.`, Severity.Warning)	×
NEW 184	return	×
185	}
186
NEW 187	const html = markdownToHtmlSimple(res.content[0].text)	×
188
NEW 189	void createMutator({	×
190	collection: DoppelComments,
191	document: {
192	commentId: dbComment._id,
193	content: html,
194	},
195	context: createAdminContext(),
196	})
197	}

ForumMagnum / ForumMagnum / 10929273199

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous