10690578246

Committed 03 Sep 2024 09:03PM UTC coverage: 31.857% (-0.02%) from 31.878%

Build # 10690578246

Build Type

Pull #9701

github

Committed by

b0b3rt

Commit Message

throw error

Pull Request Pull Request #9701: fix graphql resolver args (wip)

Run Details

5028 of 41189 branches covered (12.21%)

Branch coverage included in aggregate %.

11 of 18 new or added lines in 4 files covered. (61.11%)

609 existing lines in 23 files now uncovered.

29356 of 66745 relevant lines covered (43.98%)

187.81 hits per line

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

21.92

/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';
import { htmlContainsFootnotes } from '../utils/htmlUtil';

// 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)
      }
    }
  },
  
  hasFootnotes: {
    type: Boolean,
    resolveAs: {
      type: 'Boolean',
      resolver: ({html}): boolean => {
        if (!html) return false;
        return htmlContainsFootnotes(html);
      },
    },
  },
})

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

ForumMagnum / ForumMagnum / 10690578246

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