9550888291

Committed 17 Jun 2024 03:59PM UTC coverage: 32.007% (+0.2%) from 31.84%

Build # 9550888291

Build Type

Pull #9301

github

Committed by

web-flow

Commit Message

Apply suggestions from code review

Styling changes

Co-authored-by: JP Addison <johnpaddison@gmail.com>

Pull Request Pull Request #9301: Normalized posts contents

Run Details

4909 of 39589 branches covered (12.4%)

Branch coverage included in aggregate %.

125 of 234 new or added lines in 43 files covered. (53.42%)

11 existing lines in 10 files now uncovered.

28201 of 63858 relevant lines covered (44.16%)

191.03 hits per line

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

82.3

/packages/lesswrong/server/editor/make_editable_callbacks.ts

import {getCollectionHooks} from '../mutationCallbacks'
import {Revisions} from '../../lib/collections/revisions/collection'
import {extractVersionsFromSemver} from '../../lib/editor/utils'
import {ensureIndex} from '../../lib/collectionIndexUtils'
import {htmlToPingbacks} from '../pingbacks'
import {
  editableCollections,
  editableCollectionsFields,
  sealEditableFields,
} from '../../lib/editor/make_editable'
import {getCollection} from '../../lib/vulcan-lib/getCollection'
import {CallbackHook} from '../../lib/vulcan-lib/callbacks'
import {createMutator, validateCreateMutation} from '../vulcan-lib/mutators'
import {dataToHTML, dataToWordCount} from './conversionUtils'
import {Globals} from '../../lib/vulcan-lib/config'
import {notifyUsersAboutMentions, PingbackDocumentPartial} from './mentions-notify'
import {getLatestRev, getNextVersion, htmlToChangeMetrics, isBeingUndrafted, MaybeDrafteable} from './utils'
import { Comments } from '../../lib/collections/comments'
import isEqual from 'lodash/isEqual'
import { fetchFragmentSingle } from '../fetchFragment'
import { getLatestContentsRevision } from '@/lib/collections/revisions/helpers'
import { MakeEditableOptions, editableCollectionsFieldOptions } from '@/lib/editor/makeEditableOptions'

// TODO: Now that the make_editable callbacks use createMutator to create
// revisions, we can now add these to the regular ${collection}.create.after
// callbacks
interface AfterCreateRevisionCallbackContext {
  revisionID: string
}
export const afterCreateRevisionCallback = new CallbackHook<[AfterCreateRevisionCallbackContext]>("revisions.afterRevisionCreated");

function getInitialVersion(document: DbPost|DbObject) {
  if ((document as DbPost).draft) {
    return '0.1.0'
  } else {
    return '1.0.0'
  }
}

function versionIsDraft(semver: string, collectionName: CollectionNameString) {
  if (collectionName === "Tags")
    return false;
  const {major} = extractVersionsFromSemver(semver)
  return major===0;
}

ensureIndex(Revisions, {documentId: 1, version: 1, fieldName: 1, editedAt: 1})

export async function buildRevision({ originalContents, currentUser, dataWithDiscardedSuggestions }: {
  originalContents: DbRevision["originalContents"],
  currentUser: DbUser,
  dataWithDiscardedSuggestions?: string
}) {

  if (!originalContents) throw new Error ("Can't build revision without originalContents")

  const { data, type } = originalContents;
  const readerVisibleData = dataWithDiscardedSuggestions ?? data
  const html = await dataToHTML(readerVisibleData, type, { sanitize: !currentUser.isAdmin })
  const wordCount = await dataToWordCount(readerVisibleData, type)

  return {
    html, wordCount, originalContents,
    editedAt: new Date(),
    userId: currentUser._id,
  };
}

// Given a revised document, check whether fieldName (a content-editor field) is
// different from the previous revision (or there is no previous revision).
export const revisionIsChange = async (doc: AnyBecauseTodo, fieldName: string): Promise<boolean> => {
  const id = doc._id;
  const previousVersion = await getLatestRev(id, fieldName);

  if (!previousVersion)
    return true;

  if (!isEqual(doc[fieldName].originalContents, previousVersion.originalContents)) {
    return true;
  }

  if (doc[fieldName].commitMessage && doc[fieldName].commitMessage.length>0) {
    return true;
  }

  return false;
}

function addEditableCallbacks<N extends CollectionNameString>({collection, options = {}}: {
  collection: CollectionBase<N>,
  options: MakeEditableOptions<N>,
}) {
  // The type of the DbObject containing this field
  type DbType = ObjectsByCollectionName[N];

  // The type of the mutation object that is used to update this db object.
  // TODO: This should also include a list of the editable resolver-only fields
  // but we don't currently have a way to do that - it probably needs some
  // additions to the type generation script.
  type UpdateData = Partial<DbType>;

  const {
    fieldName = "contents",
    pingbacks = false,
    normalized,
  } = options

  const collectionName = collection.collectionName;

  getCollectionHooks(collectionName).createBefore.add(
    async function editorSerializationBeforeCreate (doc: DbType, {currentUser, context}) {
    const editableField = (doc as AnyBecauseHard)[fieldName] as EditableFieldInsertion | undefined;
    if (editableField?.originalContents) {
      if (!currentUser) { throw Error("Can't create document without current user") }
      const originalContents: DbRevision["originalContents"] = editableField.originalContents
      const commitMessage = editableField.commitMessage ?? null;
      const googleDocMetadata = editableField.googleDocMetadata;
      const revision = await buildRevision({
        originalContents,
        currentUser,
      });
      const { html, wordCount } = revision;
      const version = getInitialVersion(doc)
      const userId = currentUser._id
      const editedAt = new Date()
      const changeMetrics = htmlToChangeMetrics("", html);
      const isFirstDebatePostComment = (collectionName === 'Posts' && 'debate' in doc)
        ? (!!doc.debate && fieldName === 'contents')
        : false;

      if (isFirstDebatePostComment) {
        const createFirstCommentParams: CreateMutatorParams<"Comments"> = {
          collection: Comments,
          document: {
            userId,
            contents: editableField,
            debateResponse: true,
          },
          context,
          currentUser,
        };

        // We need to validate that we'll be able to successfully create the comment in the updateFirstDebateCommentPostId callback
        // If we can't, we'll be stuck with a malformed debate post with no comments
        await validateCreateMutation(createFirstCommentParams);
      }

      const newRevision: Omit<DbRevision, "documentId" | "schemaVersion" | "_id" | "voteCount" | "baseScore" | "extendedScore" | "score" | "inactive" | "autosaveTimeoutStart" | "afBaseScore" | "afExtendedScore" | "afVoteCount" | "legacyData"> = {
        ...revision,
        fieldName,
        collectionName,
        version,
        draft: versionIsDraft(version, collectionName),
        updateType: 'initial',
        commitMessage,
        googleDocMetadata,
        changeMetrics,
        createdAt: editedAt,
      };
      const firstRevision = await createMutator({
        collection: Revisions,
        document: newRevision,
        validate: false
      });

      return {
        ...doc,
        ...(!normalized && {
          [fieldName]: {
            ...editableField,
            html, version, userId, editedAt, wordCount,
            updateType: 'initial'
          },
        }),
        [`${fieldName}_latest`]: firstRevision.data._id,
        ...(pingbacks ? {
          pingbacks: await htmlToPingbacks(html, null),
        } : null),
      }
    }
    return doc
  });

  getCollectionHooks(collectionName).updateBefore.add(
    async function editorSerializationEdit (
      docData: UpdateData,
      {oldDocument: document, newDocument, currentUser},
    ) {
    const editableField = (docData as AnyBecauseHard)[fieldName] as EditableFieldUpdate | undefined;
    if (editableField?.originalContents) {
      if (!currentUser) { throw Error("Can't create document without current user") }

      const commitMessage = editableField.commitMessage ?? null;
      const dataWithDiscardedSuggestions = editableField.dataWithDiscardedSuggestions
      delete editableField.dataWithDiscardedSuggestions

      const oldRevisionId = (document as AnyBecauseHard)?.[`${fieldName}_latest`];
      const oldRevision = oldRevisionId
        ? await fetchFragmentSingle({
          collectionName: "Revisions",
          fragmentName: "RevisionEdit",
          selector: {_id: oldRevisionId},
          currentUser: null,
          skipFiltering: true,
        })
        : null;

      const revision = await buildRevision({
        originalContents: (newDocument as AnyBecauseHard)[fieldName].originalContents,
        dataWithDiscardedSuggestions,
        currentUser,
      });
      const { html, wordCount } = revision;

      const defaultUpdateType = editableField.updateType ||
        (!oldRevision && 'initial') ||
        'minor';
      // When a document is undrafted for the first time, we ensure that this constitutes a major update
      const { major } = extractVersionsFromSemver(oldRevision?.version ?? null);
      const beingUndrafted = isBeingUndrafted(document as MaybeDrafteable, newDocument as MaybeDrafteable)
      const updateType = (beingUndrafted && (major < 1)) ? 'major' : defaultUpdateType
      const userId = currentUser._id
      const editedAt = new Date()
      const previousRev = await getLatestRev(newDocument._id, fieldName);
      const version = getNextVersion(previousRev, updateType, (newDocument as DbPost).draft)

      let newRevisionId;
      if (await revisionIsChange(newDocument, fieldName)) {
        const changeMetrics = htmlToChangeMetrics(previousRev?.html || "", html);

        const newRevision: Omit<DbRevision, '_id' | 'schemaVersion' | "voteCount" | "baseScore" | "extendedScore"| "score" | "inactive" | "autosaveTimeoutStart" | "afBaseScore" | "afExtendedScore" | "afVoteCount" | "legacyData" | "googleDocMetadata"> = {
          documentId: document._id,
          ...revision,
          fieldName,
          collectionName,
          version,
          draft: versionIsDraft(version, collectionName),
          updateType,
          commitMessage,
          changeMetrics,
          createdAt: editedAt,
        }
        const newRevisionDoc = await createMutator({
          collection: Revisions,
          document: newRevision,
          validate: false
        });
        newRevisionId = newRevisionDoc.data._id;
      } else {
        newRevisionId = previousRev!._id;
      }

      if (newRevisionId) {
        await afterCreateRevisionCallback.runCallbacksAsync([{ revisionID: newRevisionId }]);
      }

      return {
        ...docData,
        ...(!normalized && {
          [fieldName]: {
            ...editableField,
            html, version, userId, editedAt, wordCount
          },
        }),
        [`${fieldName}_latest`]: newRevisionId,
        ...(pingbacks ? {
          pingbacks: await htmlToPingbacks(html, [{
              collectionName: collection.collectionName,
              documentId: document._id,
            }]
          ),
        } : null),
      }
    }
    return docData
  });

  getCollectionHooks(collectionName).createAfter.add(
    async function editorSerializationAfterCreate(newDoc) {
    // Update revision to point to the document that owns it.
    const revisionID = (newDoc as AnyBecauseHard)[`${fieldName}_latest`];
    if (revisionID) {
      await Revisions.rawUpdateOne(
        { _id: revisionID },
        { $set: { documentId: newDoc._id } }
      );
      await afterCreateRevisionCallback.runCallbacksAsync([{ revisionID: revisionID }]);
    }
    return newDoc;
  });

  getCollectionHooks(collectionName).createAfter.add(async (newDocument, {currentUser}) => {
    if (currentUser && pingbacks && 'pingbacks' in newDocument) {
      await notifyUsersAboutMentions(currentUser, collection.typeName, newDocument)
    }

    return newDocument
  })

  if (collectionName === 'Posts' && fieldName === 'contents') {
    getCollectionHooks("Posts").createAfter.add(
      async function updateFirstDebateCommentPostId(newDoc, { context, currentUser })
    {
      const isFirstDebatePostComment = 'debate' in newDoc
          ? !!newDoc.debate
          : false;
      if (currentUser && isFirstDebatePostComment) {
        const revision = await getLatestContentsRevision(newDoc, context);
        if (!revision?.html) {
          return newDoc;
        }
        await createMutator({
          collection: Comments,
          document: {
            userId: currentUser._id,
            postId: newDoc._id,
            contents: revision as EditableFieldInsertion,
            debateResponse: true,
          },
          context,
          currentUser,
        });
      }
      return newDoc;
    });
  }

  getCollectionHooks(collectionName).updateAfter.add(async (newDocument, {oldDocument, currentUser}) => {
    if (currentUser && pingbacks && 'pingbacks' in newDocument) {
      await notifyUsersAboutMentions(currentUser, collection.typeName, newDocument, oldDocument as PingbackDocumentPartial)
    }

    return newDocument
  })

  /**
   * Reupload images to cloudinary. This is mainly for images pasted from google docs, because
   * they have fairly strict rate limits that often result in them failing to load.
   *
   * NOTE: This is still necessary even if CkEditor is configured to reupload
   * images, because images have URLs that come from Markdown or RSS sync.
   * See: https://app.asana.com/0/628521446211730/1203311932993130/f
   * It's fine to leave it here just in case though
   */
  getCollectionHooks(collectionName).editAsync.add(async (doc: DbObject, oldDoc: DbObject) => {
    const latestField = `${fieldName}_latest`;
    const hasChanged = (oldDoc as AnyBecauseHard)?.[latestField] !== (doc as AnyBecauseHard)?.[latestField];

    if (!hasChanged) return;

    await Globals.convertImagesInObject(collectionName, doc._id, fieldName);
  })
  getCollectionHooks(collectionName).newAsync.add(async (doc: DbObject) => {
    await Globals.convertImagesInObject(collectionName, doc._id, fieldName)
  })
  if (collectionName === 'Posts') {
    getCollectionHooks("Posts").newAsync.add(async (doc: DbPost) => {
      await Globals.rehostPostMetaImages(doc);
    })
  }
}

export function addAllEditableCallbacks() {
  sealEditableFields();
  for (let collectionName of editableCollections) {
    for (let fieldName of editableCollectionsFields[collectionName]) {
      const collection = getCollection(collectionName);
      const options = editableCollectionsFieldOptions[collectionName][fieldName];
      addEditableCallbacks({collection, options});
    }
  }
}

1	import {getCollectionHooks} from '../mutationCallbacks'	106✔
2	import {Revisions} from '../../lib/collections/revisions/collection'	18✔
3	import {extractVersionsFromSemver} from '../../lib/editor/utils'	18✔
4	import {ensureIndex} from '../../lib/collectionIndexUtils'	18✔
5	import {htmlToPingbacks} from '../pingbacks'	18✔
6	import {
7	editableCollections,
8	editableCollectionsFields,
9	sealEditableFields,
10	} from '../../lib/editor/make_editable'	18✔
11	import {getCollection} from '../../lib/vulcan-lib/getCollection'	18✔
12	import {CallbackHook} from '../../lib/vulcan-lib/callbacks'	18✔
13	import {createMutator, validateCreateMutation} from '../vulcan-lib/mutators'	18✔
14	import {dataToHTML, dataToWordCount} from './conversionUtils'	18✔
15	import {Globals} from '../../lib/vulcan-lib/config'	18✔
16	import {notifyUsersAboutMentions, PingbackDocumentPartial} from './mentions-notify'	18✔
17	import {getLatestRev, getNextVersion, htmlToChangeMetrics, isBeingUndrafted, MaybeDrafteable} from './utils'	18✔
18	import { Comments } from '../../lib/collections/comments'	18✔
19	import isEqual from 'lodash/isEqual'	18✔
20	import { fetchFragmentSingle } from '../fetchFragment'	18✔
21	import { getLatestContentsRevision } from '@/lib/collections/revisions/helpers'	18✔
22	import { MakeEditableOptions, editableCollectionsFieldOptions } from '@/lib/editor/makeEditableOptions'	18✔
23
24	// TODO: Now that the make_editable callbacks use createMutator to create
25	// revisions, we can now add these to the regular ${collection}.create.after
26	// callbacks
27	interface AfterCreateRevisionCallbackContext {
28	revisionID: string
29	}
30	export const afterCreateRevisionCallback = new CallbackHook<[AfterCreateRevisionCallbackContext]>("revisions.afterRevisionCreated");	18✔
31
32	function getInitialVersion(document: DbPost\|DbObject) {
33	if ((document as DbPost).draft) {	26!
34	return '0.1.0'	×
35	} else {
36	return '1.0.0'	26✔
37	}
38	}
39
40	function versionIsDraft(semver: string, collectionName: CollectionNameString) {
41	if (collectionName === "Tags")	31!
42	return false;	×
43	const {major} = extractVersionsFromSemver(semver)	31✔
44	return major===0;	31✔
45	}	18✔
46
47	ensureIndex(Revisions, {documentId: 1, version: 1, fieldName: 1, editedAt: 1})
48
49	export async function buildRevision({ originalContents, currentUser, dataWithDiscardedSuggestions }: {
50	originalContents: DbRevision["originalContents"],
51	currentUser: DbUser,
52	dataWithDiscardedSuggestions?: string
53	}) {
54
55	if (!originalContents) throw new Error ("Can't build revision without originalContents")	31!
56
57	const { data, type } = originalContents;	31✔
58	const readerVisibleData = dataWithDiscardedSuggestions ?? data	31!
59	const html = await dataToHTML(readerVisibleData, type, { sanitize: !currentUser.isAdmin })	31✔
60	const wordCount = await dataToWordCount(readerVisibleData, type)	31✔
61
62	return {	31✔
63	html, wordCount, originalContents,
64	editedAt: new Date(),
65	userId: currentUser._id,
66	};
67	}
68
69	// Given a revised document, check whether fieldName (a content-editor field) is
70	// different from the previous revision (or there is no previous revision).
71	export const revisionIsChange = async (doc: AnyBecauseTodo, fieldName: string): Promise<boolean> => {	18✔
72	const id = doc._id;	5✔
73	const previousVersion = await getLatestRev(id, fieldName);	5✔
74
75	if (!previousVersion)	5✔
76	return true;	2✔
77
78	if (!isEqual(doc[fieldName].originalContents, previousVersion.originalContents)) {	3!
79	return true;	3✔
80	}
81
82	if (doc[fieldName].commitMessage && doc[fieldName].commitMessage.length>0) {	×
83	return true;	×
84	}
85
86	return false;	×
87	}
88
89	function addEditableCallbacks<N extends CollectionNameString>({collection, options = {}}: {	×
90	collection: CollectionBase<N>,
91	options: MakeEditableOptions<N>,
92	}) {
93	// The type of the DbObject containing this field
94	type DbType = ObjectsByCollectionName[N];
95
96	// The type of the mutation object that is used to update this db object.
97	// TODO: This should also include a list of the editable resolver-only fields
98	// but we don't currently have a way to do that - it probably needs some
99	// additions to the type generation script.
100	type UpdateData = Partial<DbType>;
101
102	const {
103	fieldName = "contents",	×
104	pingbacks = false,	×
105	normalized,
106	} = options	368✔
107
108	const collectionName = collection.collectionName;	368✔
109
110	getCollectionHooks(collectionName).createBefore.add(	368✔
111	async function editorSerializationBeforeCreate (doc: DbType, {currentUser, context}) {
112	const editableField = (doc as AnyBecauseHard)[fieldName] as EditableFieldInsertion \| undefined;	992✔
113	if (editableField?.originalContents) {	992✔
114	if (!currentUser) { throw Error("Can't create document without current user") }	26!
115	const originalContents: DbRevision["originalContents"] = editableField.originalContents	26✔
116	const commitMessage = editableField.commitMessage ?? null;	26!
117	const googleDocMetadata = editableField.googleDocMetadata;	26✔
118	const revision = await buildRevision({	26✔
119	originalContents,
120	currentUser,
121	});
122	const { html, wordCount } = revision;	26✔
123	const version = getInitialVersion(doc)	26✔
124	const userId = currentUser._id	26✔
125	const editedAt = new Date()	26✔
126	const changeMetrics = htmlToChangeMetrics("", html);	26✔
127	const isFirstDebatePostComment = (collectionName === 'Posts' && 'debate' in doc)	26✔
128	? (!!doc.debate && fieldName === 'contents')	27!
129	: false;
130
131	if (isFirstDebatePostComment) {	26!
132	const createFirstCommentParams: CreateMutatorParams<"Comments"> = {	×
133	collection: Comments,
134	document: {
135	userId,
136	contents: editableField,
137	debateResponse: true,
138	},
139	context,
140	currentUser,
141	};
142
143	// We need to validate that we'll be able to successfully create the comment in the updateFirstDebateCommentPostId callback
144	// If we can't, we'll be stuck with a malformed debate post with no comments
145	await validateCreateMutation(createFirstCommentParams);	×
146	}
147
148	const newRevision: Omit<DbRevision, "documentId" \| "schemaVersion" \| "_id" \| "voteCount" \| "baseScore" \| "extendedScore" \| "score" \| "inactive" \| "autosaveTimeoutStart" \| "afBaseScore" \| "afExtendedScore" \| "afVoteCount" \| "legacyData"> = {	26✔
149	...revision,
150	fieldName,
151	collectionName,
152	version,
153	draft: versionIsDraft(version, collectionName),
154	updateType: 'initial',
155	commitMessage,
156	googleDocMetadata,
157	changeMetrics,
158	createdAt: editedAt,
159	};
160	const firstRevision = await createMutator({	26✔
161	collection: Revisions,
162	document: newRevision,
163	validate: false
164	});
165
166	return {	26✔
167	...doc,
168	...(!normalized && {	51✔
169	[fieldName]: {
170	...editableField,
171	html, version, userId, editedAt, wordCount,
172	updateType: 'initial'
173	},
174	}),
175	[`${fieldName}_latest`]: firstRevision.data._id,
176	...(pingbacks ? {	26✔
177	pingbacks: await htmlToPingbacks(html, null),
178	} : null),
179	}
180	}
181	return doc	966✔
182	});
183
184	getCollectionHooks(collectionName).updateBefore.add(	368✔
185	async function editorSerializationEdit (
186	docData: UpdateData,
187	{oldDocument: document, newDocument, currentUser},
188	) {
189	const editableField = (docData as AnyBecauseHard)[fieldName] as EditableFieldUpdate \| undefined;	97✔
190	if (editableField?.originalContents) {	97✔
191	if (!currentUser) { throw Error("Can't create document without current user") }	5!
192
193	const commitMessage = editableField.commitMessage ?? null;	5!
194	const dataWithDiscardedSuggestions = editableField.dataWithDiscardedSuggestions	5✔
195	delete editableField.dataWithDiscardedSuggestions	5✔
196
197	const oldRevisionId = (document as AnyBecauseHard)?.[`${fieldName}_latest`];	5!
198	const oldRevision = oldRevisionId	5✔
199	? await fetchFragmentSingle({	5✔
200	collectionName: "Revisions",
201	fragmentName: "RevisionEdit",
202	selector: {_id: oldRevisionId},
203	currentUser: null,
204	skipFiltering: true,
205	})
206	: null;
207
208	const revision = await buildRevision({	5✔
209	originalContents: (newDocument as AnyBecauseHard)[fieldName].originalContents,
210	dataWithDiscardedSuggestions,
211	currentUser,
212	});
213	const { html, wordCount } = revision;	5✔
214
215	const defaultUpdateType = editableField.updateType \|\|	5✔
216	(!oldRevision && 'initial') \|\|
217	'minor';
218	// When a document is undrafted for the first time, we ensure that this constitutes a major update
219	const { major } = extractVersionsFromSemver(oldRevision?.version ?? null);	5✔
220	const beingUndrafted = isBeingUndrafted(document as MaybeDrafteable, newDocument as MaybeDrafteable)	5✔
221	const updateType = (beingUndrafted && (major < 1)) ? 'major' : defaultUpdateType	5!
222	const userId = currentUser._id	5✔
223	const editedAt = new Date()	5✔
224	const previousRev = await getLatestRev(newDocument._id, fieldName);	5✔
225	const version = getNextVersion(previousRev, updateType, (newDocument as DbPost).draft)	5✔
226
227	let newRevisionId;
228	if (await revisionIsChange(newDocument, fieldName)) {	5!
229	const changeMetrics = htmlToChangeMetrics(previousRev?.html \|\| "", html);	5✔
230
231	const newRevision: Omit<DbRevision, '_id' \| 'schemaVersion' \| "voteCount" \| "baseScore" \| "extendedScore"\| "score" \| "inactive" \| "autosaveTimeoutStart" \| "afBaseScore" \| "afExtendedScore" \| "afVoteCount" \| "legacyData" \| "googleDocMetadata"> = {	5✔
232	documentId: document._id,
233	...revision,
234	fieldName,
235	collectionName,
236	version,
237	draft: versionIsDraft(version, collectionName),
238	updateType,
239	commitMessage,
240	changeMetrics,
241	createdAt: editedAt,
242	}
243	const newRevisionDoc = await createMutator({	5✔
244	collection: Revisions,
245	document: newRevision,
246	validate: false
247	});
248	newRevisionId = newRevisionDoc.data._id;	5✔
249	} else {
250	newRevisionId = previousRev!._id;	×
251	}
252
253	if (newRevisionId) {	5!
254	await afterCreateRevisionCallback.runCallbacksAsync([{ revisionID: newRevisionId }]);	5✔
255	}
256
257	return {	5✔
258	...docData,
259	...(!normalized && {	8✔
260	[fieldName]: {
261	...editableField,
262	html, version, userId, editedAt, wordCount
263	},
264	}),
265	[`${fieldName}_latest`]: newRevisionId,
266	...(pingbacks ? {	5✔
267	pingbacks: await htmlToPingbacks(html, [{
268	collectionName: collection.collectionName,
269	documentId: document._id,
270	}]
271	),
272	} : null),
273	}
274	}
275	return docData	92✔
276	});
277
278	getCollectionHooks(collectionName).createAfter.add(	368✔
279	async function editorSerializationAfterCreate(newDoc) {
280	// Update revision to point to the document that owns it.
281	const revisionID = (newDoc as AnyBecauseHard)[`${fieldName}_latest`];	992✔
282	if (revisionID) {	992✔
283	await Revisions.rawUpdateOne(	125✔
284	{ _id: revisionID },
285	{ $set: { documentId: newDoc._id } }
286	);
287	await afterCreateRevisionCallback.runCallbacksAsync([{ revisionID: revisionID }]);	125✔
288	}
289	return newDoc;	992✔
290	});
291
292	getCollectionHooks(collectionName).createAfter.add(async (newDocument, {currentUser}) => {	368✔
293	if (currentUser && pingbacks && 'pingbacks' in newDocument) {	992✔
294	await notifyUsersAboutMentions(currentUser, collection.typeName, newDocument)	23✔
295	}
296
297	return newDocument	992✔
298	})
299
300	if (collectionName === 'Posts' && fieldName === 'contents') {	368✔
301	getCollectionHooks("Posts").createAfter.add(	16✔
302	async function updateFirstDebateCommentPostId(newDoc, { context, currentUser })
303	{
304	const isFirstDebatePostComment = 'debate' in newDoc	98✔
305	? !!newDoc.debate	98!
306	: false;
307	if (currentUser && isFirstDebatePostComment) {	98!
NEW 308	const revision = await getLatestContentsRevision(newDoc, context);	×
NEW 309	if (!revision?.html) {	×
NEW 310	return newDoc;	×
311	}
UNCOV 312	await createMutator({	×
313	collection: Comments,
314	document: {
315	userId: currentUser._id,
316	postId: newDoc._id,
317	contents: revision as EditableFieldInsertion,
318	debateResponse: true,
319	},
320	context,
321	currentUser,
322	});
323	}
324	return newDoc;	98✔
325	});
326	}
327
328	getCollectionHooks(collectionName).updateAfter.add(async (newDocument, {oldDocument, currentUser}) => {	368✔
329	if (currentUser && pingbacks && 'pingbacks' in newDocument) {	97✔
330	await notifyUsersAboutMentions(currentUser, collection.typeName, newDocument, oldDocument as PingbackDocumentPartial)	12✔
331	}
332
333	return newDocument	97✔
334	})
335
336	/**
337	* Reupload images to cloudinary. This is mainly for images pasted from google docs, because
338	* they have fairly strict rate limits that often result in them failing to load.
339	*
340	* NOTE: This is still necessary even if CkEditor is configured to reupload
341	* images, because images have URLs that come from Markdown or RSS sync.
342	* See: https://app.asana.com/0/628521446211730/1203311932993130/f
343	* It's fine to leave it here just in case though
344	*/
345	getCollectionHooks(collectionName).editAsync.add(async (doc: DbObject, oldDoc: DbObject) => {	368✔
346	const latestField = `${fieldName}_latest`;	97✔
347	const hasChanged = (oldDoc as AnyBecauseHard)?.[latestField] !== (doc as AnyBecauseHard)?.[latestField];	97!
348
349	if (!hasChanged) return;	97✔
350
351	await Globals.convertImagesInObject(collectionName, doc._id, fieldName);	5✔
352	})
353	getCollectionHooks(collectionName).newAsync.add(async (doc: DbObject) => {	368✔
354	await Globals.convertImagesInObject(collectionName, doc._id, fieldName)	992✔
355	})
356	if (collectionName === 'Posts') {	368✔
357	getCollectionHooks("Posts").newAsync.add(async (doc: DbPost) => {	48✔
358	await Globals.rehostPostMetaImages(doc);	294✔
359	})
360	}
361	}
362
363	export function addAllEditableCallbacks() {
364	sealEditableFields();	16✔
365	for (let collectionName of editableCollections) {	16✔
366	for (let fieldName of editableCollectionsFields[collectionName]) {	240✔
367	const collection = getCollection(collectionName);	368✔
368	const options = editableCollectionsFieldOptions[collectionName][fieldName];	368✔
369	addEditableCallbacks({collection, options});	368✔
370	}
371	}
372	}

ForumMagnum / ForumMagnum / 9550888291

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