8862829927

Committed 27 Apr 2024 09:58PM UTC coverage: 31.955% (-0.01%) from 31.969%

Build # 8862829927

Build Type

Pull #9196

github

Committed by

web-flow

Commit Message

Merge 48eae85dc into b17921864

Pull Request Pull Request #9196: Mark denormalized editable fields as nullable and fix associated type errors

Run Details

4714 of 38544 branches covered (12.23%)

Branch coverage included in aggregate %.

1 of 14 new or added lines in 10 files covered. (7.14%)

14 existing lines in 2 files now uncovered.

27502 of 62274 relevant lines covered (44.16%)

180.06 hits per line

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

19.86

/packages/lesswrong/server/resolvers/revisionResolvers.ts

import Revisions, { PLAINTEXT_DESCRIPTION_LENGTH, PLAINTEXT_HTML_TRUNCATION_LENGTH } from '../../lib/collections/revisions/collection'
import { dataToMarkdown, dataToHTML, dataToCkEditor } from '../editor/conversionUtils'
import { highlightFromHTML, truncate } from '../../lib/editor/ellipsize';
import { htmlStartingAtHash } from '../extractHighlights';
import { augmentFieldsDict } from '../../lib/utils/schemaUtils'
import { defineMutation, defineQuery } from '../utils/serverGraphqlUtil';
import { compile as compileHtmlToText } from 'html-to-text'
import sanitizeHtml, {IFrame} from 'sanitize-html';
import * as _ from 'underscore';
import { dataToDraftJS } from './toDraft';
import { sanitize, sanitizeAllowedTags } from '../../lib/vulcan-lib/utils';
import { htmlToTextDefault } from '../../lib/htmlToText';
import { tagMinimumKarmaPermissions, tagUserHasSufficientKarma } from '../../lib/collections/tags/helpers';
import { afterCreateRevisionCallback, buildRevision } from '../editor/make_editable_callbacks';
import isEqual from 'lodash/isEqual';
import { createMutator, updateMutator } from '../vulcan-lib/mutators';
import { EditorContents } from '../../components/editor/Editor';
import { userOwns } from '../../lib/vulcan-users/permissions';
import { getLatestRev, getNextVersion, htmlToChangeMetrics } from '../editor/utils';
import { parseDocumentFromString } from '../../lib/domParser';
import { extractTableOfContents } from '../../lib/tableOfContents';

// Use html-to-text's compile() wrapper (baking in options) to make it faster when called repeatedly
const htmlToTextPlaintextDescription = compileHtmlToText({
  wordwrap: false,
  selectors: [
    { selector: "img", format: "skip" },
    { selector: "a", options: { ignoreHref: true } },
    { selector: "p", options: { leadingLineBreaks: 1 } },
    { selector: "h1", options: { trailingLineBreaks: 1, uppercase: false } },
    { selector: "h2", options: { trailingLineBreaks: 1, uppercase: false } },
    { selector: "h3", options: { trailingLineBreaks: 1, uppercase: false } },
  ]
});

augmentFieldsDict(Revisions, {
  markdown: {
    type: String,
    resolveAs: {
      type: 'String',
      resolver: ({originalContents}): string | null => originalContents
        ? dataToMarkdown(originalContents.data, originalContents.type)
        : null,
    },
    nullable: true,
  },
  draftJS: {
    type: Object,
    resolveAs: {
      type: 'JSON',
      resolver: ({originalContents}) => originalContents
        ? dataToDraftJS(originalContents.data, originalContents.type)
        : null,
    }
  },
  ckEditorMarkup: {
    type: String,
    resolveAs: {
      type: 'String',
      resolver: ({originalContents, html}) => originalContents
        // For ckEditorMarkup we just fall back to HTML, since it's a superset of html
        ? (originalContents.type === 'ckEditorMarkup' ? originalContents.data : html)
        : null,
    }
  },
  htmlHighlight: {
    type: String,
    resolveAs: {
      type: 'String!',
      resolver: ({html}): string => highlightFromHTML(html)
    }
  },
  htmlHighlightStartingAtHash: {
    type: String,
    resolveAs: {
      type: 'String!',
      arguments: 'hash: String',
      resolver: async (revision: DbRevision, args: {hash: string}, context: ResolverContext): Promise<string> => {
        const {hash} = args;
        const rawHtml = revision?.html;

        if (!rawHtml) return '';
        
        // Process the HTML through the table of contents generator (which has
        // the byproduct of marking section headers with anchors)
        const toc = extractTableOfContents(parseDocumentFromString(rawHtml));
        const html = toc?.html || rawHtml;
        
        if (!html) return '';
        
        const startingFromHash = htmlStartingAtHash(html, hash);
        const highlight = highlightFromHTML(startingFromHash);
        return highlight;
      },
    }
  },
  plaintextDescription: {
    type: String,
    resolveAs: {
      type: 'String!',
      resolver: ({html}): string => {
        if (!html) return ""
        const truncatedHtml = truncate(html, PLAINTEXT_HTML_TRUNCATION_LENGTH)
        return htmlToTextPlaintextDescription(truncatedHtml).substring(0, PLAINTEXT_DESCRIPTION_LENGTH);
      }
    }
  },
  // Plaintext version, except that specially-formatted blocks like blockquotes are filtered out, for use in highly-abridged displays like SingleLineComment.
  plaintextMainText: {
    type: String,
    resolveAs: {
      type: 'String!',
      resolver: ({html}): string => {
        if (!html) return ""

        const mainTextHtml = sanitizeHtml(
          html, {
            allowedTags: _.without(sanitizeAllowedTags, 'blockquote', 'img'),
            nonTextTags: ['blockquote', 'img', 'style'],
            
            exclusiveFilter: function(element: IFrame) {
              return (element.attribs?.class === 'spoilers' || element.attribs?.class === 'spoiler' || element.attribs?.class === "spoiler-v2");
            }
          }
        )
        const truncatedHtml = truncate(mainTextHtml, PLAINTEXT_HTML_TRUNCATION_LENGTH)
        return htmlToTextDefault(truncatedHtml)
          .substring(0, PLAINTEXT_DESCRIPTION_LENGTH)
      }
    }
  },
})

defineQuery({
  name: "convertDocument",
  resultType: "JSON",
  argTypes: "(document: JSON, targetFormat: String)",
  fn: async (root: void, {document, targetFormat}: {document: any, targetFormat: string}, context: ResolverContext) => {
    switch (targetFormat) {
      case "html":
        return {
          type: "html",
          value: await dataToHTML(document.value, document.type),
        };
        break;
      case "draftJS":
        return {
          type: "draftJS",
          value: dataToDraftJS(document.value, document.type)
        };
      case "ckEditorMarkup":
        return {
          type: "ckEditorMarkup",
          value: await dataToCkEditor(document.value, document.type),
        };
        break;
      case "markdown":
        return {
          type: "markdown",
          value: dataToMarkdown(document.value, document.type),
        };
    }
  },
});

defineQuery({
  name: "latestGoogleDocMetadata",
  resultType: "JSON",
  argTypes: "(postId: String!, version: String)",
  fn: async (root: void, { postId, version }: { postId: string; version?: string }, context: ResolverContext) => {
    const query = {
      documentId: postId,
      googleDocMetadata: { $exists: true },
      ...(version && { version: { $lte: version } }),
    };
    const latestRevisionWithMetadata = await Revisions.findOne(
      query,
      { sort: { editedAt: -1 } },
      { googleDocMetadata: 1 }
    );
    return latestRevisionWithMetadata ? latestRevisionWithMetadata.googleDocMetadata : null;
  },
});

defineMutation({
  name: "revertTagToRevision",
  resultType: "Tag",
  argTypes: "(tagId: String!, revertToRevisionId: String!)",
  fn: async (root: void, { tagId, revertToRevisionId }: { tagId: string, revertToRevisionId: string }, context: ResolverContext) => {
    const { currentUser, loaders, Tags } = context;
    if (!tagUserHasSufficientKarma(currentUser, 'edit')) {
      throw new Error(`Must be logged in and have ${tagMinimumKarmaPermissions['edit']} karma to revert tags to older revisions`);
    }

    const [tag, revertToRevision, latestRevision] = await Promise.all([
      loaders.Tags.load(tagId),
      loaders.Revisions.load(revertToRevisionId),
      getLatestRev(tagId, 'description')
    ]);

    const anyDiff = !isEqual(tag.description?.originalContents, revertToRevision.originalContents);

    if (!tag)               throw new Error('Invalid tagId');
    if (!revertToRevision)  throw new Error('Invalid revisionId');
    // I don't think this should be possible if we find a revision to revert to, but...
    if (!latestRevision)    throw new Error('Tag is missing latest revision');
    if (!anyDiff)           throw new Error(`Can't find difference between revisions`);

    await updateMutator({
      collection: Tags,
      context,
      documentId: tag._id,
      data: {
        description: {
          originalContents: revertToRevision.originalContents,
        },
      },
      currentUser,
    });
  }
});

defineMutation({
  name: "autosaveRevision",
  resultType: "Revision",
  schema: `
    input AutosaveContentType {
      type: String
      value: ContentTypeData
    }
  `,
  argTypes: "(postId: String!, contents: AutosaveContentType!)",
  fn: async (_, { postId, contents }: { postId: string, contents: EditorContents }, context): Promise<DbRevision> => {
    const { currentUser, loaders } = context;
    if (!currentUser) {
      throw new Error('Cannot autosave revision while logged out');
    }

    const post = await loaders.Posts.load(postId);
    if (!userOwns(currentUser, post)) {
      throw new Error('Must be post author to autosave');
    }

    const postContentsFieldName = 'contents';
    const updateSemverType = 'patch';

    const [previousRev, html] = await Promise.all([
      getLatestRev(postId, postContentsFieldName),
      dataToHTML(contents.value, contents.type, { sanitize: !currentUser.isAdmin })
    ]);

    const nextVersion = getNextVersion(previousRev, updateSemverType, post.draft);
    const changeMetrics = htmlToChangeMetrics(previousRev?.html || "", html);

    const newRevision: Partial<DbRevision> = {
      ...await buildRevision({
        originalContents: { type: contents.type, data: contents.value },
        currentUser,
      }),
      documentId: postId,
      fieldName: postContentsFieldName,
      collectionName: 'Posts',
      version: nextVersion,
      draft: true,
      updateType: updateSemverType,
      changeMetrics,
    };

    const { data: createdRevision } = await createMutator({
      collection: Revisions,
      document: newRevision,
      context,
      currentUser,
      validate: false
    });

    // TODO: not sure if we need these?  The aren't called by `saveDocumentRevision` in `ckEditorWebhook.ts` after creating a new revision from ckeditor's cloud autosave
    await afterCreateRevisionCallback.runCallbacksAsync([{ revisionID: createdRevision._id }]);

    return createdRevision;
  }
});

1	import Revisions, { PLAINTEXT_DESCRIPTION_LENGTH, PLAINTEXT_HTML_TRUNCATION_LENGTH } from '../../lib/collections/revisions/collection'	18✔
2	import { dataToMarkdown, dataToHTML, dataToCkEditor } from '../editor/conversionUtils'	18✔
3	import { highlightFromHTML, truncate } from '../../lib/editor/ellipsize';	18✔
4	import { htmlStartingAtHash } from '../extractHighlights';	18✔
5	import { augmentFieldsDict } from '../../lib/utils/schemaUtils'	18✔
6	import { defineMutation, defineQuery } from '../utils/serverGraphqlUtil';	18✔
7	import { compile as compileHtmlToText } from 'html-to-text'	18✔
8	import sanitizeHtml, {IFrame} from 'sanitize-html';	18✔
9	import * as _ from 'underscore';	18✔
10	import { dataToDraftJS } from './toDraft';	18✔
11	import { sanitize, sanitizeAllowedTags } from '../../lib/vulcan-lib/utils';	18✔
12	import { htmlToTextDefault } from '../../lib/htmlToText';	18✔
13	import { tagMinimumKarmaPermissions, tagUserHasSufficientKarma } from '../../lib/collections/tags/helpers';	18✔
14	import { afterCreateRevisionCallback, buildRevision } from '../editor/make_editable_callbacks';	18✔
15	import isEqual from 'lodash/isEqual';	18✔
16	import { createMutator, updateMutator } from '../vulcan-lib/mutators';	18✔
17	import { EditorContents } from '../../components/editor/Editor';
18	import { userOwns } from '../../lib/vulcan-users/permissions';	18✔
19	import { getLatestRev, getNextVersion, htmlToChangeMetrics } from '../editor/utils';	18✔
20	import { parseDocumentFromString } from '../../lib/domParser';	18✔
21	import { extractTableOfContents } from '../../lib/tableOfContents';	18✔
22
23	// Use html-to-text's compile() wrapper (baking in options) to make it faster when called repeatedly
24	const htmlToTextPlaintextDescription = compileHtmlToText({	18✔
25	wordwrap: false,
26	selectors: [
27	{ selector: "img", format: "skip" },
28	{ selector: "a", options: { ignoreHref: true } },
29	{ selector: "p", options: { leadingLineBreaks: 1 } },
30	{ selector: "h1", options: { trailingLineBreaks: 1, uppercase: false } },
31	{ selector: "h2", options: { trailingLineBreaks: 1, uppercase: false } },
32	{ selector: "h3", options: { trailingLineBreaks: 1, uppercase: false } },
33	]
34	});	18✔
35
36	augmentFieldsDict(Revisions, {
37	markdown: {
38	type: String,
39	resolveAs: {
40	type: 'String',
41	resolver: ({originalContents}): string \| null => originalContents	5!
42	? dataToMarkdown(originalContents.data, originalContents.type)
43	: null,
44	},
45	nullable: true,
46	},
47	draftJS: {
48	type: Object,
49	resolveAs: {
50	type: 'JSON',
51	resolver: ({originalContents}) => originalContents	×
52	? dataToDraftJS(originalContents.data, originalContents.type)
53	: null,
54	}
55	},
56	ckEditorMarkup: {
57	type: String,
58	resolveAs: {
59	type: 'String',
60	resolver: ({originalContents, html}) => originalContents	×
61	// For ckEditorMarkup we just fall back to HTML, since it's a superset of html
62	? (originalContents.type === 'ckEditorMarkup' ? originalContents.data : html)	×
63	: null,
64	}
65	},
66	htmlHighlight: {
67	type: String,
68	resolveAs: {
69	type: 'String!',
70	resolver: ({html}): string => highlightFromHTML(html)	×
71	}
72	},
73	htmlHighlightStartingAtHash: {
74	type: String,
75	resolveAs: {
76	type: 'String!',
77	arguments: 'hash: String',
78	resolver: async (revision: DbRevision, args: {hash: string}, context: ResolverContext): Promise<string> => {
79	const {hash} = args;	×
80	const rawHtml = revision?.html;	×
81
82	if (!rawHtml) return '';	×
83
84	// Process the HTML through the table of contents generator (which has
85	// the byproduct of marking section headers with anchors)
86	const toc = extractTableOfContents(parseDocumentFromString(rawHtml));	×
87	const html = toc?.html \|\| rawHtml;	×
88
89	if (!html) return '';	×
90
91	const startingFromHash = htmlStartingAtHash(html, hash);	×
92	const highlight = highlightFromHTML(startingFromHash);	×
93	return highlight;	×
94	},
95	}
96	},
97	plaintextDescription: {
98	type: String,
99	resolveAs: {
100	type: 'String!',
101	resolver: ({html}): string => {
102	if (!html) return ""	×
103	const truncatedHtml = truncate(html, PLAINTEXT_HTML_TRUNCATION_LENGTH)	×
104	return htmlToTextPlaintextDescription(truncatedHtml).substring(0, PLAINTEXT_DESCRIPTION_LENGTH);	×
105	}
106	}
107	},
108	// Plaintext version, except that specially-formatted blocks like blockquotes are filtered out, for use in highly-abridged displays like SingleLineComment.
109	plaintextMainText: {
110	type: String,
111	resolveAs: {
112	type: 'String!',
113	resolver: ({html}): string => {
114	if (!html) return ""	×
115
116	const mainTextHtml = sanitizeHtml(	×
117	html, {
118	allowedTags: _.without(sanitizeAllowedTags, 'blockquote', 'img'),
119	nonTextTags: ['blockquote', 'img', 'style'],
120
121	exclusiveFilter: function(element: IFrame) {
122	return (element.attribs?.class === 'spoilers' \|\| element.attribs?.class === 'spoiler' \|\| element.attribs?.class === "spoiler-v2");	×
123	}
124	}
125	)
126	const truncatedHtml = truncate(mainTextHtml, PLAINTEXT_HTML_TRUNCATION_LENGTH)	×
127	return htmlToTextDefault(truncatedHtml)	×
128	.substring(0, PLAINTEXT_DESCRIPTION_LENGTH)
129	}
130	}
131	},
132	})	18✔
133
134	defineQuery({
135	name: "convertDocument",
136	resultType: "JSON",
137	argTypes: "(document: JSON, targetFormat: String)",
138	fn: async (root: void, {document, targetFormat}: {document: any, targetFormat: string}, context: ResolverContext) => {
139	switch (targetFormat) {	×
140	case "html":
141	return {	×
142	type: "html",
143	value: await dataToHTML(document.value, document.type),
144	};
145	break;	×
146	case "draftJS":
147	return {	×
148	type: "draftJS",
149	value: dataToDraftJS(document.value, document.type)
150	};
151	case "ckEditorMarkup":
152	return {	×
153	type: "ckEditorMarkup",
154	value: await dataToCkEditor(document.value, document.type),
155	};
156	break;	×
157	case "markdown":
158	return {	×
159	type: "markdown",
160	value: dataToMarkdown(document.value, document.type),
161	};
162	}
163	},
164	});	18✔
165
166	defineQuery({
167	name: "latestGoogleDocMetadata",
168	resultType: "JSON",
169	argTypes: "(postId: String!, version: String)",
170	fn: async (root: void, { postId, version }: { postId: string; version?: string }, context: ResolverContext) => {
171	const query = {	×
172	documentId: postId,
173	googleDocMetadata: { $exists: true },
174	...(version && { version: { $lte: version } }),	×
175	};
176	const latestRevisionWithMetadata = await Revisions.findOne(	×
177	query,
178	{ sort: { editedAt: -1 } },
179	{ googleDocMetadata: 1 }
180	);
181	return latestRevisionWithMetadata ? latestRevisionWithMetadata.googleDocMetadata : null;	×
182	},
183	});	18✔
184
185	defineMutation({
186	name: "revertTagToRevision",
187	resultType: "Tag",
188	argTypes: "(tagId: String!, revertToRevisionId: String!)",
189	fn: async (root: void, { tagId, revertToRevisionId }: { tagId: string, revertToRevisionId: string }, context: ResolverContext) => {
190	const { currentUser, loaders, Tags } = context;	×
191	if (!tagUserHasSufficientKarma(currentUser, 'edit')) {	×
192	throw new Error(`Must be logged in and have ${tagMinimumKarmaPermissions['edit']} karma to revert tags to older revisions`);	×
193	}
194
195	const [tag, revertToRevision, latestRevision] = await Promise.all([	×
196	loaders.Tags.load(tagId),
197	loaders.Revisions.load(revertToRevisionId),
198	getLatestRev(tagId, 'description')
199	]);
200
NEW 201	const anyDiff = !isEqual(tag.description?.originalContents, revertToRevision.originalContents);	×
202
203	if (!tag) throw new Error('Invalid tagId');	×
204	if (!revertToRevision) throw new Error('Invalid revisionId');	×
205	// I don't think this should be possible if we find a revision to revert to, but...
206	if (!latestRevision) throw new Error('Tag is missing latest revision');	×
207	if (!anyDiff) throw new Error(`Can't find difference between revisions`);	×
208
209	await updateMutator({	×
210	collection: Tags,
211	context,
212	documentId: tag._id,
213	data: {
214	description: {
215	originalContents: revertToRevision.originalContents,
216	},
217	},
218	currentUser,
219	});
220	}
221	});	18✔
222
223	defineMutation({
224	name: "autosaveRevision",
225	resultType: "Revision",
226	schema: `
227	input AutosaveContentType {
228	type: String
229	value: ContentTypeData
230	}
231	`,
232	argTypes: "(postId: String!, contents: AutosaveContentType!)",
233	fn: async (_, { postId, contents }: { postId: string, contents: EditorContents }, context): Promise<DbRevision> => {
234	const { currentUser, loaders } = context;	×
235	if (!currentUser) {	×
236	throw new Error('Cannot autosave revision while logged out');	×
237	}
238
239	const post = await loaders.Posts.load(postId);	×
240	if (!userOwns(currentUser, post)) {	×
241	throw new Error('Must be post author to autosave');	×
242	}
243
244	const postContentsFieldName = 'contents';	×
245	const updateSemverType = 'patch';	×
246
247	const [previousRev, html] = await Promise.all([	×
248	getLatestRev(postId, postContentsFieldName),
249	dataToHTML(contents.value, contents.type, { sanitize: !currentUser.isAdmin })
250	]);
251
252	const nextVersion = getNextVersion(previousRev, updateSemverType, post.draft);	×
253	const changeMetrics = htmlToChangeMetrics(previousRev?.html \|\| "", html);	×
254
255	const newRevision: Partial<DbRevision> = {	×
256	...await buildRevision({
257	originalContents: { type: contents.type, data: contents.value },
258	currentUser,
259	}),
260	documentId: postId,
261	fieldName: postContentsFieldName,
262	collectionName: 'Posts',
263	version: nextVersion,
264	draft: true,
265	updateType: updateSemverType,
266	changeMetrics,
267	};
268
269	const { data: createdRevision } = await createMutator({	×
270	collection: Revisions,
271	document: newRevision,
272	context,
273	currentUser,
274	validate: false
275	});
276
277	// TODO: not sure if we need these? The aren't called by `saveDocumentRevision` in `ckEditorWebhook.ts` after creating a new revision from ckeditor's cloud autosave
278	await afterCreateRevisionCallback.runCallbacksAsync([{ revisionID: createdRevision._id }]);	×
279
280	return createdRevision;	×
281	}
282	});

ForumMagnum / ForumMagnum / 8862829927

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