9166296059

Committed 20 May 2024 11:23PM UTC coverage: 31.893% (-0.008%) from 31.901%

Build # 9166296059

Build Type

Pull #9269

github

Committed by

jimrandomh

Commit Message

Support absolute paths in migrate.js (and other top-level sripts)

Pull Request Pull Request #9269: Configure typescript, eslint and jest to allow absolute imports

Run Details

4762 of 38944 branches covered (12.23%)

Branch coverage included in aggregate %.

5 of 5 new or added lines in 2 files covered. (100.0%)

608 existing lines in 28 files now uncovered.

27724 of 62915 relevant lines covered (44.07%)

178.08 hits per line

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

16.75

/packages/lesswrong/server/resolvers/userResolvers.ts

import { markdownToHtml, dataToMarkdown } from '../editor/conversionUtils';
import Users from '../../lib/collections/users/collection';
import { accessFilterMultiple, augmentFieldsDict, denormalizedField } from '../../lib/utils/schemaUtils'
import { addGraphQLMutation, addGraphQLQuery, addGraphQLResolvers, addGraphQLSchema, slugify, updateMutator, Utils } from '../vulcan-lib';
import pick from 'lodash/pick';
import SimpleSchema from 'simpl-schema';
import {getUserEmail, userCanEditUser, userGetDisplayName} from "../../lib/collections/users/helpers";
import {userFindOneByEmail} from "../commonQueries";
import { isEAForum } from '../../lib/instanceSettings';
import GraphQLJSON from 'graphql-type-json';
import { getRecentKarmaInfo, rateLimitDateWhenUserNextAbleToComment, rateLimitDateWhenUserNextAbleToPost } from '../rateLimitUtils';
import { RateLimitInfo, RecentKarmaInfo } from '../../lib/rateLimits/types';
import { userIsAdminOrMod } from '../../lib/vulcan-users/permissions';
import { UsersRepo } from '../repos';
import { defineQuery } from '../utils/serverGraphqlUtil';
import { UserDialogueUsefulData } from "../../components/users/DialogueMatchingPage";


addGraphQLSchema(`
  type CommentCountTag {
    name: String!
    comment_count: Int!
  }
  type TopCommentedTagUser {
    _id: ID!
    username: String!
    displayName: String!
    total_power: Float!
    tag_comment_counts: [CommentCountTag!]!
  }
  type UpvotedUser {
    _id: ID!
    username: String!
    displayName: String!
    total_power: Float!
    power_values: String!
    vote_counts: Int!
    total_agreement: Float!
    agreement_values: String!
    recently_active_matchmaking: Boolean!
  }
  type UserDialogueUsefulData {
    dialogueUsers: [User]
    topUsers: [UpvotedUser]
    activeDialogueMatchSeekers: [User]
  }
`)

augmentFieldsDict(Users, {
  htmlMapMarkerText: {
    ...denormalizedField({
      needsUpdate: (data: Partial<DbUser>) => ('mapMarkerText' in data),
      getValue: async (user: DbUser) => {
        if (!user.mapMarkerText) return "";
        return await markdownToHtml(user.mapMarkerText);
      }
    })
  },
  bio: {
    resolveAs: {
      type: "String",
      resolver: (user: DbUser, args: void, { Users }: ResolverContext) => {
        const bio = user.biography?.originalContents;
        if (!bio) return "";
        return dataToMarkdown(bio.data, bio.type);
      }
    }
  },
  htmlBio: {
    resolveAs: {
      type: "String!",
      resolver: (user: DbUser, args: void, { Users }: ResolverContext) => {
        const bio = user.biography;
        return bio?.html || "";
      }
    }
  },
  rateLimitNextAbleToComment: {
    nullable: true,
    resolveAs: {
      type: GraphQLJSON,
      arguments: 'postId: String',
      resolver: async (user: DbUser, args: {postId: string | null}, context: ResolverContext): Promise<RateLimitInfo|null> => {
        return rateLimitDateWhenUserNextAbleToComment(user, args.postId, context);
      }
    },
  },
  rateLimitNextAbleToPost: {
    nullable: true,
    resolveAs: {
      type: GraphQLJSON,
      arguments: 'eventForm: Boolean',
      resolver: async (user: DbUser, args: { eventForm?: boolean }, context: ResolverContext): Promise<RateLimitInfo|null> => {
        const { eventForm } = args
        if (eventForm) return null

        const rateLimit = await rateLimitDateWhenUserNextAbleToPost(user);
        if (rateLimit) {
          return rateLimit
        } else {
          return null
        }
      }
    }
  },
  recentKarmaInfo: {
    nullable: true,
    resolveAs: {
      type: GraphQLJSON,
      resolver: async (user: DbUser, args, context: ResolverContext): Promise<RecentKarmaInfo> => {
        return getRecentKarmaInfo(user._id)
      }
    }
  }
});

addGraphQLSchema(`
  type NewUserCompletedProfile {
    username: String,
    slug: String,
    displayName: String,
    subscribedToDigest: Boolean,
    usernameUnset: Boolean
  }
`)

type NewUserUpdates = {
  username: string
  email?: string
  subscribeToDigest: boolean
  acceptedTos: boolean
}

addGraphQLSchema(`
  type UserCoreTagReads {
    tagId: String,
    userReadCount: Int
  }
`)

addGraphQLResolvers({
  Mutation: {
    async NewUserCompleteProfile(root: void, { username, email, subscribeToDigest, acceptedTos }: NewUserUpdates, context: ResolverContext) {
      const { currentUser } = context
      if (!currentUser) {
        throw new Error('Cannot change username without being logged in')
      }
      // Check they accepted the terms of use
      if (isEAForum && !acceptedTos) {
        throw new Error("You must accept the terms of use to continue");
      }
      // Only for new users. Existing users should need to contact support to
      // change their usernames
      if (!currentUser.usernameUnset) {
        throw new Error('Only new users can set their username this way')
      }
      // Check for uniqueness
      const existingUser = await Users.findOne({username})
      if (existingUser && existingUser._id !== currentUser._id) {
        throw new Error('Username already exists')
      }
      // Check for someone setting an email when they already have one
      if (email && getUserEmail(currentUser)) {
        throw new Error('You already have an email address')
      }
      // Check for email uniqueness
      if (email && await userFindOneByEmail(email)) {
        throw new Error('Email already taken')
      }
      // Check for valid email
      if (email && !SimpleSchema.RegEx.Email.test(email)) {
        throw new Error('Invalid email')
      }
      const updatedUser = (await updateMutator({
        collection: Users,
        documentId: currentUser._id,
        set: {
          usernameUnset: false,
          username,
          displayName: username,
          slug: await Utils.getUnusedSlugByCollectionName("Users", slugify(username)),
          ...(email ? {email} : {}),
          subscribedToDigest: subscribeToDigest,
          acceptedTos,
        },
        // We've already done necessary gating
        validate: false
      })).data
      // Don't want to return the whole object without more permission checking
      return pick(updatedUser, 'username', 'slug', 'displayName', 'subscribedToCurated', 'usernameUnset')
    },
    async UserExpandFrontpageSection(
      _root: void,
      {section, expanded}: {section: string, expanded: boolean},
      {currentUser, repos}: ResolverContext,
    ) {
      if (!currentUser) {
        throw new Error("You must login to do this");
      }
      expanded = Boolean(expanded);
      await repos.users.setExpandFrontpageSection(currentUser._id, section, expanded);
      return expanded;
    },
    async UserUpdateSubforumMembership(root: void, { tagId, member }: {tagId: string, member: boolean}, context: ResolverContext) {
      const { currentUser } = context
      if (!currentUser) {
        throw new Error('Cannot join subforum without being logged in')
      }

      if ((member && currentUser.profileTagIds?.includes(tagId)) || (!member && !currentUser.profileTagIds?.includes(tagId))) {
        throw new Error(member ? 'User is aleady a member of this subforum' : 'User is not a member of this subforum so cannot leave')
      }

      const newProfileTagIds = member ? [...(currentUser.profileTagIds || []), tagId] : currentUser.profileTagIds?.filter(id => id !== tagId) || []
      const updatedUser = await updateMutator({
        collection: Users,
        documentId: currentUser._id,
        set: {
          profileTagIds: newProfileTagIds
        },
        validate: false
      })
      
      return updatedUser
    },
  },

  Query: {
    async UserReadsPerCoreTag(root: void, {userId}: {userId: string}, context: ResolverContext) {
      const { currentUser } = context
      const user = await Users.findOne({_id: userId})

      // Must be logged in and have permission to view this user's data
      if (!userId || !currentUser || !user || !userCanEditUser(currentUser, user)) {
        throw new Error('Not authorized')
      }
      
      return context.repos.posts.getUserReadsPerCoreTag(userId)
    },
    async GetRandomUser(root: void, {userIsAuthor}: {userIsAuthor: 'optional'|'required'}, context: ResolverContext) {
      const { currentUser } = context
      if (!userIsAdminOrMod(currentUser)) {
        throw new Error('Must be an admin/mod to get a random user')
      }
      
      if (userIsAuthor === 'optional') {
        return new UsersRepo().getRandomActiveUser()
      } else if (userIsAuthor === 'required') {
        return new UsersRepo().getRandomActiveAuthor()
      } else {
        throw new Error('Invalid user type type')
      }
    },
  },
})

addGraphQLMutation(
  'NewUserCompleteProfile(username: String!, subscribeToDigest: Boolean!, email: String, acceptedTos: Boolean): NewUserCompletedProfile'
)
addGraphQLMutation(
  'UserExpandFrontpageSection(section: String!, expanded: Boolean!): Boolean'
)
addGraphQLMutation(
  'UserUpdateSubforumMembership(tagId: String!, member: Boolean!): User'
)
addGraphQLQuery('UserReadsPerCoreTag(userId: String!): [UserCoreTagReads]')
addGraphQLQuery('GetRandomUser(userIsAuthor: String!): User')

defineQuery({
  name: "GetUserDialogueUsefulData",
  resultType: "UserDialogueUsefulData",
  fn: async (root: void, _: any, context: ResolverContext) => {
    const { currentUser } = context
    if (!currentUser) {
      throw new Error('User must be logged in to get top upvoted users');
    }

    const [dialogueUsers, topUsers, activeDialogueMatchSeekers] = await Promise.all([
      new UsersRepo().getUsersWhoHaveMadeDialogues(),
      new UsersRepo().getUsersTopUpvotedUsers(currentUser),
      new UsersRepo().getActiveDialogueMatchSeekers(100),
    ]);

    const results: UserDialogueUsefulData = {
      dialogueUsers: dialogueUsers.map(user => ({ ...user, displayName: userGetDisplayName(user) })),
      topUsers: topUsers,
      activeDialogueMatchSeekers: activeDialogueMatchSeekers.map(user => ({ ...user, displayName: userGetDisplayName(user) })),
    }
    return results
  }
});

defineQuery({
  name: "GetDialogueMatchedUsers",
  resultType: "[User]!",
  fn: async (root, _, context) => {
    const { currentUser } = context
    if (!currentUser) {
      throw new Error('User must be logged in to get matched users');
    }

    const matchedUsers = await new UsersRepo().getDialogueMatchedUsers(currentUser._id);
    return accessFilterMultiple(currentUser, Users, matchedUsers, context);
  }
});

defineQuery({
  name: "GetDialogueRecommendedUsers",
  resultType: "[User]!",
  fn: async (root, _, context) => {
    const { currentUser } = context
    if (!currentUser) {
      throw new Error('User must be logged in to get recommended users');
    }

    const upvotedUsers = await context.repos.users.getUsersTopUpvotedUsers(currentUser, 35, 30)
    const recommendedUsers = await context.repos.users.getDialogueRecommendedUsers(currentUser._id, upvotedUsers);

    // Shuffle and limit the list to 2 users
    const shuffled = recommendedUsers.sort(() => 0.5 - Math.random());
    const sampleSize = 2;

    return accessFilterMultiple(currentUser, Users, shuffled.slice(0, sampleSize), context);
  }
}); 

defineQuery({
  name: "IsDisplayNameTaken",
  argTypes: "(displayName: String!)",
  resultType: "Boolean!",
  fn: async (
    _root: void,
    {displayName}: {displayName: string},
    context: ResolverContext,
  ) => {
    const {currentUser} = context;
    if (!currentUser) {
      throw new Error("You must be logged in to do this");
    }
    const isTaken = await context.repos.users.isDisplayNameTaken(displayName);
    return isTaken;
  }
});

1	import { markdownToHtml, dataToMarkdown } from '../editor/conversionUtils';	18✔
2	import Users from '../../lib/collections/users/collection';	18✔
3	import { accessFilterMultiple, augmentFieldsDict, denormalizedField } from '../../lib/utils/schemaUtils'	18✔
4	import { addGraphQLMutation, addGraphQLQuery, addGraphQLResolvers, addGraphQLSchema, slugify, updateMutator, Utils } from '../vulcan-lib';	18✔
5	import pick from 'lodash/pick';	18✔
6	import SimpleSchema from 'simpl-schema';	18✔
7	import {getUserEmail, userCanEditUser, userGetDisplayName} from "../../lib/collections/users/helpers";	18✔
8	import {userFindOneByEmail} from "../commonQueries";	18✔
9	import { isEAForum } from '../../lib/instanceSettings';	18✔
10	import GraphQLJSON from 'graphql-type-json';	18✔
11	import { getRecentKarmaInfo, rateLimitDateWhenUserNextAbleToComment, rateLimitDateWhenUserNextAbleToPost } from '../rateLimitUtils';	18✔
12	import { RateLimitInfo, RecentKarmaInfo } from '../../lib/rateLimits/types';
13	import { userIsAdminOrMod } from '../../lib/vulcan-users/permissions';	18✔
14	import { UsersRepo } from '../repos';	18✔
15	import { defineQuery } from '../utils/serverGraphqlUtil';	18✔
16	import { UserDialogueUsefulData } from "../../components/users/DialogueMatchingPage";
17
18
19	addGraphQLSchema(`
20	type CommentCountTag {
21	name: String!
22	comment_count: Int!
23	}
24	type TopCommentedTagUser {
25	_id: ID!
26	username: String!
27	displayName: String!
28	total_power: Float!
29	tag_comment_counts: [CommentCountTag!]!
30	}
31	type UpvotedUser {
32	_id: ID!
33	username: String!
34	displayName: String!
35	total_power: Float!
36	power_values: String!
37	vote_counts: Int!
38	total_agreement: Float!
39	agreement_values: String!
40	recently_active_matchmaking: Boolean!
41	}
42	type UserDialogueUsefulData {
43	dialogueUsers: [User]
44	topUsers: [UpvotedUser]
45	activeDialogueMatchSeekers: [User]
46	}
47	`)	18✔
48
49	augmentFieldsDict(Users, {
50	htmlMapMarkerText: {
51	...denormalizedField({
52	needsUpdate: (data: Partial<DbUser>) => ('mapMarkerText' in data),	179✔
53	getValue: async (user: DbUser) => {
UNCOV 54	if (!user.mapMarkerText) return "";	×
55	return await markdownToHtml(user.mapMarkerText);	×
56	}
57	})
58	},
59	bio: {
60	resolveAs: {
61	type: "String",
62	resolver: (user: DbUser, args: void, { Users }: ResolverContext) => {
UNCOV 63	const bio = user.biography?.originalContents;	×
64	if (!bio) return "";	×
65	return dataToMarkdown(bio.data, bio.type);	×
66	}
67	}
68	},
69	htmlBio: {
70	resolveAs: {
71	type: "String!",
72	resolver: (user: DbUser, args: void, { Users }: ResolverContext) => {
73	const bio = user.biography;	2✔
74	return bio?.html \|\| "";	2!
75	}
76	}
77	},
78	rateLimitNextAbleToComment: {
79	nullable: true,
80	resolveAs: {
81	type: GraphQLJSON,
82	arguments: 'postId: String',
83	resolver: async (user: DbUser, args: {postId: string \| null}, context: ResolverContext): Promise<RateLimitInfo\|null> => {
UNCOV 84	return rateLimitDateWhenUserNextAbleToComment(user, args.postId, context);	×
85	}
86	},
87	},
88	rateLimitNextAbleToPost: {
89	nullable: true,
90	resolveAs: {
91	type: GraphQLJSON,
92	arguments: 'eventForm: Boolean',
93	resolver: async (user: DbUser, args: { eventForm?: boolean }, context: ResolverContext): Promise<RateLimitInfo\|null> => {
UNCOV 94	const { eventForm } = args	×
95	if (eventForm) return null	×
96
UNCOV 97	const rateLimit = await rateLimitDateWhenUserNextAbleToPost(user);	×
98	if (rateLimit) {	×
99	return rateLimit	×
100	} else {
UNCOV 101	return null	×
102	}
103	}
104	}
105	},
106	recentKarmaInfo: {
107	nullable: true,
108	resolveAs: {
109	type: GraphQLJSON,
110	resolver: async (user: DbUser, args, context: ResolverContext): Promise<RecentKarmaInfo> => {
UNCOV 111	return getRecentKarmaInfo(user._id)	×
112	}
113	}
114	}
115	});	18✔
116
117	addGraphQLSchema(`
118	type NewUserCompletedProfile {
119	username: String,
120	slug: String,
121	displayName: String,
122	subscribedToDigest: Boolean,
123	usernameUnset: Boolean
124	}
125	`)	18✔
126
127	type NewUserUpdates = {
128	username: string
129	email?: string
130	subscribeToDigest: boolean
131	acceptedTos: boolean
132	}
133
134	addGraphQLSchema(`
135	type UserCoreTagReads {
136	tagId: String,
137	userReadCount: Int
138	}
139	`)	18✔
140
141	addGraphQLResolvers({
142	Mutation: {
143	async NewUserCompleteProfile(root: void, { username, email, subscribeToDigest, acceptedTos }: NewUserUpdates, context: ResolverContext) {
UNCOV 144	const { currentUser } = context	×
145	if (!currentUser) {	×
146	throw new Error('Cannot change username without being logged in')	×
147	}
148	// Check they accepted the terms of use
UNCOV 149	if (isEAForum && !acceptedTos) {	×
150	throw new Error("You must accept the terms of use to continue");	×
151	}
152	// Only for new users. Existing users should need to contact support to
153	// change their usernames
UNCOV 154	if (!currentUser.usernameUnset) {	×
155	throw new Error('Only new users can set their username this way')	×
156	}
157	// Check for uniqueness
UNCOV 158	const existingUser = await Users.findOne({username})	×
159	if (existingUser && existingUser._id !== currentUser._id) {	×
160	throw new Error('Username already exists')	×
161	}
162	// Check for someone setting an email when they already have one
UNCOV 163	if (email && getUserEmail(currentUser)) {	×
164	throw new Error('You already have an email address')	×
165	}
166	// Check for email uniqueness
UNCOV 167	if (email && await userFindOneByEmail(email)) {	×
168	throw new Error('Email already taken')	×
169	}
170	// Check for valid email
UNCOV 171	if (email && !SimpleSchema.RegEx.Email.test(email)) {	×
172	throw new Error('Invalid email')	×
173	}
UNCOV 174	const updatedUser = (await updateMutator({	×
175	collection: Users,
176	documentId: currentUser._id,
177	set: {
178	usernameUnset: false,
179	username,
180	displayName: username,
181	slug: await Utils.getUnusedSlugByCollectionName("Users", slugify(username)),
182	...(email ? {email} : {}),	×
183	subscribedToDigest: subscribeToDigest,
184	acceptedTos,
185	},
186	// We've already done necessary gating
187	validate: false
188	})).data
189	// Don't want to return the whole object without more permission checking
UNCOV 190	return pick(updatedUser, 'username', 'slug', 'displayName', 'subscribedToCurated', 'usernameUnset')	×
191	},
192	async UserExpandFrontpageSection(
193	_root: void,
194	{section, expanded}: {section: string, expanded: boolean},
195	{currentUser, repos}: ResolverContext,
196	) {
UNCOV 197	if (!currentUser) {	×
198	throw new Error("You must login to do this");	×
199	}
UNCOV 200	expanded = Boolean(expanded);	×
201	await repos.users.setExpandFrontpageSection(currentUser._id, section, expanded);	×
202	return expanded;	×
203	},
204	async UserUpdateSubforumMembership(root: void, { tagId, member }: {tagId: string, member: boolean}, context: ResolverContext) {
UNCOV 205	const { currentUser } = context	×
206	if (!currentUser) {	×
207	throw new Error('Cannot join subforum without being logged in')	×
208	}
209
UNCOV 210	if ((member && currentUser.profileTagIds?.includes(tagId)) \|\| (!member && !currentUser.profileTagIds?.includes(tagId))) {	×
211	throw new Error(member ? 'User is aleady a member of this subforum' : 'User is not a member of this subforum so cannot leave')	×
212	}
213
UNCOV 214	const newProfileTagIds = member ? [...(currentUser.profileTagIds \|\| []), tagId] : currentUser.profileTagIds?.filter(id => id !== tagId) \|\| []	×
215	const updatedUser = await updateMutator({	×
216	collection: Users,
217	documentId: currentUser._id,
218	set: {
219	profileTagIds: newProfileTagIds
220	},
221	validate: false
222	})
223
UNCOV 224	return updatedUser	×
225	},
226	},
227
228	Query: {
229	async UserReadsPerCoreTag(root: void, {userId}: {userId: string}, context: ResolverContext) {
UNCOV 230	const { currentUser } = context	×
231	const user = await Users.findOne({_id: userId})	×
232
233	// Must be logged in and have permission to view this user's data
UNCOV 234	if (!userId \|\| !currentUser \|\| !user \|\| !userCanEditUser(currentUser, user)) {	×
235	throw new Error('Not authorized')	×
236	}
237
UNCOV 238	return context.repos.posts.getUserReadsPerCoreTag(userId)	×
239	},
240	async GetRandomUser(root: void, {userIsAuthor}: {userIsAuthor: 'optional'\|'required'}, context: ResolverContext) {
UNCOV 241	const { currentUser } = context	×
242	if (!userIsAdminOrMod(currentUser)) {	×
243	throw new Error('Must be an admin/mod to get a random user')	×
244	}
245
UNCOV 246	if (userIsAuthor === 'optional') {	×
247	return new UsersRepo().getRandomActiveUser()	×
248	} else if (userIsAuthor === 'required') {	×
249	return new UsersRepo().getRandomActiveAuthor()	×
250	} else {
UNCOV 251	throw new Error('Invalid user type type')	×
252	}
253	},
254	},
255	})	18✔
256
257	addGraphQLMutation(
258	'NewUserCompleteProfile(username: String!, subscribeToDigest: Boolean!, email: String, acceptedTos: Boolean): NewUserCompletedProfile'
259	)	18✔
260	addGraphQLMutation(
261	'UserExpandFrontpageSection(section: String!, expanded: Boolean!): Boolean'
262	)	18✔
263	addGraphQLMutation(
264	'UserUpdateSubforumMembership(tagId: String!, member: Boolean!): User'
265	)	18✔
266	addGraphQLQuery('UserReadsPerCoreTag(userId: String!): [UserCoreTagReads]')	18✔
267	addGraphQLQuery('GetRandomUser(userIsAuthor: String!): User')	18✔
268
269	defineQuery({
270	name: "GetUserDialogueUsefulData",
271	resultType: "UserDialogueUsefulData",
272	fn: async (root: void, _: any, context: ResolverContext) => {
UNCOV 273	const { currentUser } = context	×
274	if (!currentUser) {	×
275	throw new Error('User must be logged in to get top upvoted users');	×
276	}
277
UNCOV 278	const [dialogueUsers, topUsers, activeDialogueMatchSeekers] = await Promise.all([	×
279	new UsersRepo().getUsersWhoHaveMadeDialogues(),
280	new UsersRepo().getUsersTopUpvotedUsers(currentUser),
281	new UsersRepo().getActiveDialogueMatchSeekers(100),
282	]);
283
UNCOV 284	const results: UserDialogueUsefulData = {	×
285	dialogueUsers: dialogueUsers.map(user => ({ ...user, displayName: userGetDisplayName(user) })),	×
286	topUsers: topUsers,
UNCOV 287	activeDialogueMatchSeekers: activeDialogueMatchSeekers.map(user => ({ ...user, displayName: userGetDisplayName(user) })),	×
288	}
UNCOV 289	return results	×
290	}
291	});	18✔
292
293	defineQuery({
294	name: "GetDialogueMatchedUsers",
295	resultType: "[User]!",
296	fn: async (root, _, context) => {
UNCOV 297	const { currentUser } = context	×
298	if (!currentUser) {	×
299	throw new Error('User must be logged in to get matched users');	×
300	}
301
UNCOV 302	const matchedUsers = await new UsersRepo().getDialogueMatchedUsers(currentUser._id);	×
303	return accessFilterMultiple(currentUser, Users, matchedUsers, context);	×
304	}
305	});	18✔
306
307	defineQuery({
308	name: "GetDialogueRecommendedUsers",
309	resultType: "[User]!",
310	fn: async (root, _, context) => {
UNCOV 311	const { currentUser } = context	×
312	if (!currentUser) {	×
313	throw new Error('User must be logged in to get recommended users');	×
314	}
315
UNCOV 316	const upvotedUsers = await context.repos.users.getUsersTopUpvotedUsers(currentUser, 35, 30)	×
317	const recommendedUsers = await context.repos.users.getDialogueRecommendedUsers(currentUser._id, upvotedUsers);	×
318
319	// Shuffle and limit the list to 2 users
UNCOV 320	const shuffled = recommendedUsers.sort(() => 0.5 - Math.random());	×
321	const sampleSize = 2;	×
322
UNCOV 323	return accessFilterMultiple(currentUser, Users, shuffled.slice(0, sampleSize), context);	×
324	}
325	});	18✔
326
327	defineQuery({
328	name: "IsDisplayNameTaken",
329	argTypes: "(displayName: String!)",
330	resultType: "Boolean!",
331	fn: async (
332	_root: void,
333	{displayName}: {displayName: string},
334	context: ResolverContext,
335	) => {
UNCOV 336	const {currentUser} = context;	×
337	if (!currentUser) {	×
338	throw new Error("You must be logged in to do this");	×
339	}
UNCOV 340	const isTaken = await context.repos.users.isDisplayNameTaken(displayName);	×
341	return isTaken;	×
342	}
343	});

ForumMagnum / ForumMagnum / 9166296059

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