11023596682

Committed 24 Sep 2024 11:41PM UTC coverage: 31.82% (-0.009%) from 31.829%

Build # 11023596682

Build Type

push

github

Committed by

darkruby501

Commit Message

filter checkboxes on llm converation viewing page

Run Details

5069 of 41410 branches covered (12.24%)

Branch coverage included in aggregate %.

1 of 12 new or added lines in 1 file covered. (8.33%)

2 existing lines in 2 files now uncovered.

29435 of 67026 relevant lines covered (43.92%)

184.78 hits per line

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

66.3

/packages/lesswrong/server/callbacks/rateLimitCallbacks.ts

import moment from 'moment';
import { captureEvent } from '../../lib/analyticsEvents';
import Users from '../../lib/collections/users/collection';
import { getCollectionHooks } from '../mutationCallbacks';
import { rateLimitDateWhenUserNextAbleToComment, rateLimitDateWhenUserNextAbleToPost } from '../rateLimitUtils';
import { userIsAdminOrMod, userOwns } from '@/lib/vulcan-users';
import LWEventsRepo from '../repos/LWEventsRepo';
import { isEAForum } from '@/lib/instanceSettings';
import { DatabaseServerSetting } from '../databaseSettings';

const changesAllowedSetting = new DatabaseServerSetting<number>('displayNameRateLimit.changesAllowed', 1);
const sinceDaysAgoSetting = new DatabaseServerSetting<number>('displayNameRateLimit.sinceDaysAgo', 60);

// Post rate limiting
getCollectionHooks("Posts").createValidate.add(async function PostsNewRateLimit (validationErrors, { newDocument: post, currentUser }) {
  if (!post.draft && !post.isEvent) {
    await enforcePostRateLimit(currentUser!);
  }
  return validationErrors;
});

getCollectionHooks("Posts").updateValidate.add(async function PostsUndraftRateLimit (validationErrors, { oldDocument, newDocument, currentUser }) {
  // Only undrafting is rate limited, not other edits
  if (oldDocument.draft && !newDocument.draft && !newDocument.isEvent) {
    await enforcePostRateLimit(currentUser!);
  }
  return validationErrors;
});

getCollectionHooks("Users").updateValidate.add(async function ChangeDisplayNameRateLimit (validationErrors, { oldDocument, newDocument, currentUser }) {
  if (oldDocument.displayName !== newDocument.displayName) {
    await enforceDisplayNameRateLimit({ userToUpdate: oldDocument, currentUser: currentUser! });
  }
  return validationErrors;
});

getCollectionHooks("Comments").createValidate.add(async function CommentsNewRateLimit (validationErrors, { newDocument: comment, currentUser, context }) {
  if (!currentUser) {
    throw new Error(`Can't comment while logged out.`);
  }
  await enforceCommentRateLimit({user: currentUser, comment, context});

  return validationErrors;
});

getCollectionHooks("Comments").createAsync.add(async ({document, context}: {
  document: DbComment
  context: ResolverContext
}) => {
  const user = await Users.findOne(document.userId)
  
  if (user) {
    const rateLimit = await rateLimitDateWhenUserNextAbleToComment(user, null, context)
    // if the user has created a comment that makes them hit the rate limit, record an event
    // (ignore the universal 8 sec rate limit)
    if (rateLimit && rateLimit.rateLimitType !== 'universal') {
      captureEvent("commentRateLimitHit", {
        rateLimitType: rateLimit.rateLimitType,
        userId: document.userId,
        commentId: document._id
      })
    }
  }
})

async function enforceDisplayNameRateLimit({userToUpdate, currentUser}: {userToUpdate: DbUser, currentUser: DbUser}) {
  if (userIsAdminOrMod(currentUser)) return;

  if (!userOwns(currentUser, userToUpdate)) {
    throw new Error(`You do not have permission to update this user`)
  }

  if (!isEAForum) return;

  const sinceDaysAgo = sinceDaysAgoSetting.get();
  const changesAllowed = changesAllowedSetting.get();

  const nameChangeCount = await new LWEventsRepo().countDisplayNameChanges({
    userId: userToUpdate._id,
    sinceDaysAgo,
  });

  if (nameChangeCount >= changesAllowed) {
    const times = changesAllowed === 1 ? 'time' : 'times';
    throw new Error(`You can only change your display name ${changesAllowed} ${times} every ${sinceDaysAgo} days. Please contact support if you would like to change it again`);
  }
}

// Check whether the given user can post a post right now. If they can, does
// nothing; if they would exceed a rate limit, throws an exception.
async function enforcePostRateLimit (user: DbUser) {
  const rateLimit = await rateLimitDateWhenUserNextAbleToPost(user);
  if (rateLimit) {
    const {nextEligible} = rateLimit;
    if (nextEligible > new Date()) {
      // "fromNow" makes for a more human readable "how long till I can comment/post?".
      // moment.relativeTimeThreshold ensures that it doesn't appreviate unhelpfully to "now"
      moment.relativeTimeThreshold('ss', 0);
      throw new Error(`Rate limit: You cannot post for ${moment(nextEligible).fromNow()}, until ${nextEligible}`);
    }
  }
}

async function enforceCommentRateLimit({user, comment, context}: {
  user: DbUser,
  comment: DbComment,
  context: ResolverContext,
}) {
  const rateLimit = await rateLimitDateWhenUserNextAbleToComment(user, comment.postId, context);
  if (rateLimit) {
    const {nextEligible, rateLimitType:_} = rateLimit;
    if (nextEligible > new Date()) {
      // "fromNow" makes for a more human readable "how long till I can comment/post?".
      // moment.relativeTimeThreshold ensures that it doesn't appreviate unhelpfully to "now"
      moment.relativeTimeThreshold('ss', 0);
      throw new Error(`Rate limit: You cannot comment for ${moment(nextEligible).fromNow()} (until ${nextEligible})`);
    }
  }
}

1	import moment from 'moment';	19✔
2	import { captureEvent } from '../../lib/analyticsEvents';	19✔
3	import Users from '../../lib/collections/users/collection';	19✔
4	import { getCollectionHooks } from '../mutationCallbacks';	19✔
5	import { rateLimitDateWhenUserNextAbleToComment, rateLimitDateWhenUserNextAbleToPost } from '../rateLimitUtils';	19✔
6	import { userIsAdminOrMod, userOwns } from '@/lib/vulcan-users';	19✔
7	import LWEventsRepo from '../repos/LWEventsRepo';	19✔
8	import { isEAForum } from '@/lib/instanceSettings';	19✔
9	import { DatabaseServerSetting } from '../databaseSettings';	19✔
10
11	const changesAllowedSetting = new DatabaseServerSetting<number>('displayNameRateLimit.changesAllowed', 1);	19✔
12	const sinceDaysAgoSetting = new DatabaseServerSetting<number>('displayNameRateLimit.sinceDaysAgo', 60);	19✔
13
14	// Post rate limiting
15	getCollectionHooks("Posts").createValidate.add(async function PostsNewRateLimit (validationErrors, { newDocument: post, currentUser }) {
16	if (!post.draft && !post.isEvent) {	×
17	await enforcePostRateLimit(currentUser!);	×
18	}
19	return validationErrors;	×
20	});	19✔
21
22	getCollectionHooks("Posts").updateValidate.add(async function PostsUndraftRateLimit (validationErrors, { oldDocument, newDocument, currentUser }) {
23	// Only undrafting is rate limited, not other edits
24	if (oldDocument.draft && !newDocument.draft && !newDocument.isEvent) {	10!
25	await enforcePostRateLimit(currentUser!);	×
26	}
27	return validationErrors;	10✔
28	});	19✔
29
30	getCollectionHooks("Users").updateValidate.add(async function ChangeDisplayNameRateLimit (validationErrors, { oldDocument, newDocument, currentUser }) {
31	if (oldDocument.displayName !== newDocument.displayName) {	17✔
32	await enforceDisplayNameRateLimit({ userToUpdate: oldDocument, currentUser: currentUser! });	3✔
33	}
34	return validationErrors;	16✔
35	});	19✔
36
37	getCollectionHooks("Comments").createValidate.add(async function CommentsNewRateLimit (validationErrors, { newDocument: comment, currentUser, context }) {
38	if (!currentUser) {	4!
39	throw new Error(`Can't comment while logged out.`);	×
40	}
41	await enforceCommentRateLimit({user: currentUser, comment, context});	4✔
42
43	return validationErrors;	3✔
44	});	19✔
45
46	getCollectionHooks("Comments").createAsync.add(async ({document, context}: {
47	document: DbComment
48	context: ResolverContext
49	}) => {
50	const user = await Users.findOne(document.userId)	22✔
51
52	if (user) {	22!
53	const rateLimit = await rateLimitDateWhenUserNextAbleToComment(user, null, context)	22✔
54	// if the user has created a comment that makes them hit the rate limit, record an event
55	// (ignore the universal 8 sec rate limit)
56	if (rateLimit && rateLimit.rateLimitType !== 'universal') {	22!
UNCOV 57	captureEvent("commentRateLimitHit", {	×
58	rateLimitType: rateLimit.rateLimitType,
59	userId: document.userId,
60	commentId: document._id
61	})
62	}
63	}
64	})
65
66	async function enforceDisplayNameRateLimit({userToUpdate, currentUser}: {userToUpdate: DbUser, currentUser: DbUser}) {
67	if (userIsAdminOrMod(currentUser)) return;	3✔
68
69	if (!userOwns(currentUser, userToUpdate)) {	2!
70	throw new Error(`You do not have permission to update this user`)	×
71	}
72
73	if (!isEAForum) return;	2!
74
75	const sinceDaysAgo = sinceDaysAgoSetting.get();	2✔
76	const changesAllowed = changesAllowedSetting.get();	2✔
77
78	const nameChangeCount = await new LWEventsRepo().countDisplayNameChanges({	2✔
79	userId: userToUpdate._id,
80	sinceDaysAgo,
81	});
82
83	if (nameChangeCount >= changesAllowed) {	2✔
84	const times = changesAllowed === 1 ? 'time' : 'times';	1!
85	throw new Error(`You can only change your display name ${changesAllowed} ${times} every ${sinceDaysAgo} days. Please contact support if you would like to change it again`);	1✔
86	}
87	}
88
89	// Check whether the given user can post a post right now. If they can, does
90	// nothing; if they would exceed a rate limit, throws an exception.
91	async function enforcePostRateLimit (user: DbUser) {
92	const rateLimit = await rateLimitDateWhenUserNextAbleToPost(user);	×
93	if (rateLimit) {	×
94	const {nextEligible} = rateLimit;	×
95	if (nextEligible > new Date()) {	×
96	// "fromNow" makes for a more human readable "how long till I can comment/post?".
97	// moment.relativeTimeThreshold ensures that it doesn't appreviate unhelpfully to "now"
98	moment.relativeTimeThreshold('ss', 0);	×
99	throw new Error(`Rate limit: You cannot post for ${moment(nextEligible).fromNow()}, until ${nextEligible}`);	×
100	}
101	}
102	}
103
104	async function enforceCommentRateLimit({user, comment, context}: {
105	user: DbUser,
106	comment: DbComment,
107	context: ResolverContext,
108	}) {
109	const rateLimit = await rateLimitDateWhenUserNextAbleToComment(user, comment.postId, context);	4✔
110	if (rateLimit) {	4✔
111	const {nextEligible, rateLimitType:_} = rateLimit;	1✔
112	if (nextEligible > new Date()) {	1!
113	// "fromNow" makes for a more human readable "how long till I can comment/post?".
114	// moment.relativeTimeThreshold ensures that it doesn't appreviate unhelpfully to "now"
115	moment.relativeTimeThreshold('ss', 0);	1✔
116	throw new Error(`Rate limit: You cannot comment for ${moment(nextEligible).fromNow()} (until ${nextEligible})`);	1✔
117	}
118	}
119	}

ForumMagnum / ForumMagnum / 11023596682

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