9978832599

Committed 17 Jul 2024 05:33PM UTC coverage: 31.91% (+0.05%) from 31.861%

Build # 9978832599

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9421 from ForumMagnum/people-directory-topics

[EA] People directory topics

Run Details

4903 of 40244 branches covered (12.18%)

Branch coverage included in aggregate %.

38 of 80 new or added lines in 11 files covered. (47.5%)

2 existing lines in 2 files now uncovered.

28638 of 64868 relevant lines covered (44.15%)

180.48 hits per line

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

28.97

/packages/lesswrong/server/tagging/tagCallbacks.ts

import { Tags } from '../../lib/collections/tags/collection';
import { TagRels } from '../../lib/collections/tagRels/collection';
import { Posts } from '../../lib/collections/posts/collection';
import Users from '../../lib/collections/users/collection';
import { voteCallbacks } from '../../lib/voting/vote';
import { performVoteServer } from '../voteServer';
import { getCollectionHooks } from '../mutationCallbacks';
import { updateDenormalizedContributorsList } from '../resolvers/tagResolvers';
import { taggingNameSetting } from '../../lib/instanceSettings';
import { updateMutator } from '../vulcan-lib';
import { updatePostDenormalizedTags } from './helpers';
import { elasticSyncDocument } from '../search/elastic/elasticCallbacks';

function isValidTagName(name: string) {
  if (!name || !name.length)
    return false;
  return true;
}

function normalizeTagName(name: string) {
  // If the name starts with a hash, strip it off
  if (name.startsWith("#"))
    return name.substr(1);
  else
    return name;
}

getCollectionHooks("Tags").createValidate.add(async (validationErrors: Array<any>, {document: tag}: {document: DbTag}) => {
  if (!tag.name || !tag.name.length)
    throw new Error("Name is required");
  if (!isValidTagName(tag.name))
    throw new Error(`Invalid ${taggingNameSetting.get()} name (use only letters, digits and dash)`);
  
  // If the name starts with a hash, strip it off
  const normalizedName = normalizeTagName(tag.name);
  if (tag.name !== normalizedName) {
    tag = {
      ...tag,
      name: normalizedName,
    };
  }
  
  // Name must be unique
  const existing = await Tags.find({name: normalizedName, deleted:false}).fetch();
  if (existing.length > 0)
    throw new Error(`A ${taggingNameSetting.get()} by that name already exists`);
  
  return validationErrors;
});

getCollectionHooks("Tags").updateValidate.add(async (validationErrors: Array<any>, {oldDocument, newDocument}: {oldDocument: DbTag, newDocument: DbTag}) => {
  if (!isValidTagName(newDocument.name))
    throw new Error(`Invalid ${taggingNameSetting.get()} name`);

  const newName = normalizeTagName(newDocument.name);
  if (oldDocument.name !== newName) { // Tag renamed?
    const existing = await Tags.find({name: newName, deleted:false}).fetch();
    if (existing.length > 0)
      throw new Error(`A ${taggingNameSetting.get()} by that name already exists`);
  }
  
  if (newDocument.name !== newName) {
    newDocument = {
      ...newDocument, name: newName
    }
  }
  
  return validationErrors;
});

getCollectionHooks("Tags").updateAfter.add(async (newDoc: DbTag, {oldDocument}: {oldDocument: DbTag}) => {
  // If this is soft deleting a tag, then cascade to also soft delete any
  // tagRels that go with it.
  if (newDoc.deleted && !oldDocument.deleted) {
    await TagRels.rawUpdateMany({ tagId: newDoc._id }, { $set: { deleted: true } }, { multi: true });
  }
  return newDoc;
});

getCollectionHooks("Tags").updateAfter.add(async (newDoc: DbTag, {oldDocument}: {oldDocument: DbTag}) => {
  // If a parent tag has been added, add this tag to the subTagIds of the parent
  if (newDoc.parentTagId === oldDocument.parentTagId) return newDoc;

  // Remove this tag from the subTagIds of the old parent
  if (oldDocument.parentTagId) {
    const oldParent = await Tags.findOne(oldDocument.parentTagId);
    await updateMutator({
      collection: Tags,
      documentId: oldDocument.parentTagId,
      // TODO change to $pull (reverse of $addToSet) once it is implemented in postgres
      set: {subTagIds: [...(oldParent?.subTagIds || []).filter((id: string) => id !== newDoc._id)]},
      validate: false,
    })
  }
  // Add this tag to the subTagIds of the new parent
  if (newDoc.parentTagId) {
    const newParent = await Tags.findOne(newDoc.parentTagId);
    await updateMutator({
      collection: Tags,
      documentId: newDoc.parentTagId,
      // TODO change to $addToSet once it is implemented in postgres
      set: {subTagIds: [...(newParent?.subTagIds || []), newDoc._id]},
      validate: false,
    })
  }
  return newDoc;
});

getCollectionHooks("TagRels").newAfter.add(async (tagRel: DbTagRel) => {
  // When you add a tag, vote for it as relevant
  var tagCreator = await Users.findOne(tagRel.userId);
  if (!tagCreator) throw new Error(`Could not find user ${tagRel.userId}`);
  const {modifiedDocument: votedTagRel} = await performVoteServer({
    document: tagRel,
    voteType: 'smallUpvote',
    collection: TagRels,
    user: tagCreator,
    skipRateLimits: true,
    selfVote: true
  })
  await updatePostDenormalizedTags(tagRel.postId);
  return {...tagRel, ...votedTagRel} as DbTagRel;
});

// Users who have this as a profile tag may need to be reexported to elastic
getCollectionHooks("Tags").updateAfter.add(async (
  newDocument: DbTag,
  {oldDocument}: {oldDocument: DbTag},
) => {
  const wasDeletedChanged = !!newDocument.deleted !== !!oldDocument.deleted;
  const wasRenamed = newDocument.name !== oldDocument.name;
  const wasSlugChanged = newDocument.slug !== oldDocument.slug;
  if (wasDeletedChanged || wasRenamed || wasSlugChanged) {
    const users = await Users.find({
      profileTagIds: oldDocument._id,
    }, {
      projection: {_id: 1},
    }).fetch();
    for (const user of users) {
      elasticSyncDocument("Users", user._id);
    }
  }
  return newDocument;
});

function voteUpdatePostDenormalizedTags({newDocument}: {newDocument: VoteableType}) {
  let postId: string;
  if ("postId" in newDocument) { // is a tagRel
    // Applying human knowledge here
    postId = (newDocument as DbTagRel)["postId"];
  } else if ("tagRelevance" in newDocument) { // is a post
    postId = newDocument["_id"];
  } else {
    return;
  }
  void updatePostDenormalizedTags(postId);
}

voteCallbacks.cancelSync.add(voteUpdatePostDenormalizedTags);
voteCallbacks.castVoteAsync.add(voteUpdatePostDenormalizedTags);

async function recomputeContributorScoresFor(votedRevision: DbRevision, vote: DbVote) {
  if (vote.collectionName !== "Revisions") return;
  if (votedRevision.collectionName !== "Tags") return;
  
  const tag = await Tags.findOne({_id: votedRevision.documentId});
  if (!tag) return;
  await updateDenormalizedContributorsList(tag);
}

voteCallbacks.castVoteAsync.add(async ({newDocument: revision, vote}: {newDocument: DbRevision, vote: DbVote}) => {
  await recomputeContributorScoresFor(revision, vote);
});

voteCallbacks.cancelAsync.add(async ({newDocument: revision, vote}: {newDocument: DbRevision, vote: DbVote}) => {
  await recomputeContributorScoresFor(revision, vote);
});

1	import { Tags } from '../../lib/collections/tags/collection';	18✔
2	import { TagRels } from '../../lib/collections/tagRels/collection';	18✔
3	import { Posts } from '../../lib/collections/posts/collection';
4	import Users from '../../lib/collections/users/collection';	18✔
5	import { voteCallbacks } from '../../lib/voting/vote';	18✔
6	import { performVoteServer } from '../voteServer';	18✔
7	import { getCollectionHooks } from '../mutationCallbacks';	18✔
8	import { updateDenormalizedContributorsList } from '../resolvers/tagResolvers';	18✔
9	import { taggingNameSetting } from '../../lib/instanceSettings';	18✔
10	import { updateMutator } from '../vulcan-lib';	18✔
11	import { updatePostDenormalizedTags } from './helpers';	18✔
12	import { elasticSyncDocument } from '../search/elastic/elasticCallbacks';	18✔
13
14	function isValidTagName(name: string) {
15	if (!name \|\| !name.length)	×
16	return false;	×
17	return true;	×
18	}
19
20	function normalizeTagName(name: string) {
21	// If the name starts with a hash, strip it off
22	if (name.startsWith("#"))	×
23	return name.substr(1);	×
24	else
25	return name;	×
26	}	18✔
27
28	getCollectionHooks("Tags").createValidate.add(async (validationErrors: Array<any>, {document: tag}: {document: DbTag}) => {
29	if (!tag.name \|\| !tag.name.length)	×
30	throw new Error("Name is required");	×
31	if (!isValidTagName(tag.name))	×
32	throw new Error(`Invalid ${taggingNameSetting.get()} name (use only letters, digits and dash)`);	×
33
34	// If the name starts with a hash, strip it off
35	const normalizedName = normalizeTagName(tag.name);	×
36	if (tag.name !== normalizedName) {	×
37	tag = {	×
38	...tag,
39	name: normalizedName,
40	};
41	}
42
43	// Name must be unique
44	const existing = await Tags.find({name: normalizedName, deleted:false}).fetch();	×
45	if (existing.length > 0)	×
46	throw new Error(`A ${taggingNameSetting.get()} by that name already exists`);	×
47
48	return validationErrors;	×
49	});	18✔
50
51	getCollectionHooks("Tags").updateValidate.add(async (validationErrors: Array<any>, {oldDocument, newDocument}: {oldDocument: DbTag, newDocument: DbTag}) => {
52	if (!isValidTagName(newDocument.name))	×
53	throw new Error(`Invalid ${taggingNameSetting.get()} name`);	×
54
55	const newName = normalizeTagName(newDocument.name);	×
56	if (oldDocument.name !== newName) { // Tag renamed?	×
57	const existing = await Tags.find({name: newName, deleted:false}).fetch();	×
58	if (existing.length > 0)	×
59	throw new Error(`A ${taggingNameSetting.get()} by that name already exists`);	×
60	}
61
62	if (newDocument.name !== newName) {	×
63	newDocument = {	×
64	...newDocument, name: newName
65	}
66	}
67
68	return validationErrors;	×
69	});	18✔
70
71	getCollectionHooks("Tags").updateAfter.add(async (newDoc: DbTag, {oldDocument}: {oldDocument: DbTag}) => {
72	// If this is soft deleting a tag, then cascade to also soft delete any
73	// tagRels that go with it.
74	if (newDoc.deleted && !oldDocument.deleted) {	×
75	await TagRels.rawUpdateMany({ tagId: newDoc._id }, { $set: { deleted: true } }, { multi: true });	×
76	}
77	return newDoc;	×
78	});	18✔
79
80	getCollectionHooks("Tags").updateAfter.add(async (newDoc: DbTag, {oldDocument}: {oldDocument: DbTag}) => {
81	// If a parent tag has been added, add this tag to the subTagIds of the parent
82	if (newDoc.parentTagId === oldDocument.parentTagId) return newDoc;	×
83
84	// Remove this tag from the subTagIds of the old parent
85	if (oldDocument.parentTagId) {	×
86	const oldParent = await Tags.findOne(oldDocument.parentTagId);	×
87	await updateMutator({	×
88	collection: Tags,
89	documentId: oldDocument.parentTagId,
90	// TODO change to $pull (reverse of $addToSet) once it is implemented in postgres
91	set: {subTagIds: [...(oldParent?.subTagIds \|\| []).filter((id: string) => id !== newDoc._id)]},	×
92	validate: false,
93	})
94	}
95	// Add this tag to the subTagIds of the new parent
96	if (newDoc.parentTagId) {	×
97	const newParent = await Tags.findOne(newDoc.parentTagId);	×
98	await updateMutator({	×
99	collection: Tags,
100	documentId: newDoc.parentTagId,
101	// TODO change to $addToSet once it is implemented in postgres
102	set: {subTagIds: [...(newParent?.subTagIds \|\| []), newDoc._id]},	×
103	validate: false,
104	})
105	}
106	return newDoc;	×
107	});	18✔
108
109	getCollectionHooks("TagRels").newAfter.add(async (tagRel: DbTagRel) => {
110	// When you add a tag, vote for it as relevant
111	var tagCreator = await Users.findOne(tagRel.userId);	×
112	if (!tagCreator) throw new Error(`Could not find user ${tagRel.userId}`);	×
113	const {modifiedDocument: votedTagRel} = await performVoteServer({	×
114	document: tagRel,
115	voteType: 'smallUpvote',
116	collection: TagRels,
117	user: tagCreator,
118	skipRateLimits: true,
119	selfVote: true
120	})
121	await updatePostDenormalizedTags(tagRel.postId);	×
122	return {...tagRel, ...votedTagRel} as DbTagRel;	×
123	});	18✔
124
125	// Users who have this as a profile tag may need to be reexported to elastic
126	getCollectionHooks("Tags").updateAfter.add(async (
127	newDocument: DbTag,
128	{oldDocument}: {oldDocument: DbTag},
129	) => {
NEW 130	const wasDeletedChanged = !!newDocument.deleted !== !!oldDocument.deleted;	×
NEW 131	const wasRenamed = newDocument.name !== oldDocument.name;	×
NEW 132	const wasSlugChanged = newDocument.slug !== oldDocument.slug;	×
NEW 133	if (wasDeletedChanged \|\| wasRenamed \|\| wasSlugChanged) {	×
NEW 134	const users = await Users.find({	×
135	profileTagIds: oldDocument._id,
136	}, {
137	projection: {_id: 1},
138	}).fetch();
NEW 139	for (const user of users) {	×
NEW 140	elasticSyncDocument("Users", user._id);	×
141	}
142	}
NEW 143	return newDocument;	×
144	});
145
146	function voteUpdatePostDenormalizedTags({newDocument}: {newDocument: VoteableType}) {
147	let postId: string;
148	if ("postId" in newDocument) { // is a tagRel	149✔
149	// Applying human knowledge here
150	postId = (newDocument as DbTagRel)["postId"];	31✔
151	} else if ("tagRelevance" in newDocument) { // is a post	118✔
152	postId = newDocument["_id"];	18✔
153	} else {
154	return;	100✔
155	}
156	void updatePostDenormalizedTags(postId);	49✔
157	}
158
159	voteCallbacks.cancelSync.add(voteUpdatePostDenormalizedTags);	18✔
160	voteCallbacks.castVoteAsync.add(voteUpdatePostDenormalizedTags);	18✔
161
162	async function recomputeContributorScoresFor(votedRevision: DbRevision, vote: DbVote) {
163	if (vote.collectionName !== "Revisions") return;	149✔
164	if (votedRevision.collectionName !== "Tags") return;	2!
165
166	const tag = await Tags.findOne({_id: votedRevision.documentId});	2✔
167	if (!tag) return;	2!
168	await updateDenormalizedContributorsList(tag);	2✔
169	}
170
171	voteCallbacks.castVoteAsync.add(async ({newDocument: revision, vote}: {newDocument: DbRevision, vote: DbVote}) => {	18✔
172	await recomputeContributorScoresFor(revision, vote);	142✔
173	});
174
175	voteCallbacks.cancelAsync.add(async ({newDocument: revision, vote}: {newDocument: DbRevision, vote: DbVote}) => {	18✔
176	await recomputeContributorScoresFor(revision, vote);	7✔
177	});

ForumMagnum / ForumMagnum / 9978832599

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