10745713515

Committed 06 Sep 2024 09:50PM UTC coverage: 31.867% (+0.008%) from 31.859%

Build # 10745713515

Build Type

Pull #9713

github

Committed by

web-flow

Commit Message

Merge 846563615 into 7d567d8ee

Pull Request Pull Request #9713: Merge master into LW Deploy

Run Details

5070 of 41299 branches covered (12.28%)

Branch coverage included in aggregate %.

62 of 122 new or added lines in 21 files covered. (50.82%)

6 existing lines in 1 file now uncovered.

29403 of 66880 relevant lines covered (43.96%)

185.07 hits per line

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

79.08

/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 '../utils/callbackHooks'
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");

export 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)
      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
      });

      const newRevisionId = newRevisionDoc.data._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'	112✔
2	import {Revisions} from '../../lib/collections/revisions/collection'	19✔
3	import {extractVersionsFromSemver} from '../../lib/editor/utils'	19✔
4	import {ensureIndex} from '../../lib/collectionIndexUtils'	19✔
5	import {htmlToPingbacks} from '../pingbacks'	19✔
6	import {
7	editableCollections,
8	editableCollectionsFields,
9	sealEditableFields,
10	} from '../../lib/editor/make_editable'	19✔
11	import {getCollection} from '../../lib/vulcan-lib/getCollection'	19✔
12	import { CallbackHook } from '../utils/callbackHooks'	19✔
13	import {createMutator, validateCreateMutation} from '../vulcan-lib/mutators'	19✔
14	import {dataToHTML, dataToWordCount} from './conversionUtils'	19✔
15	import {Globals} from '../../lib/vulcan-lib/config'	19✔
16	import {notifyUsersAboutMentions, PingbackDocumentPartial} from './mentions-notify'	19✔
17	import {getLatestRev, getNextVersion, htmlToChangeMetrics, isBeingUndrafted, MaybeDrafteable} from './utils'	19✔
18	import { Comments } from '../../lib/collections/comments'	19✔
19	import isEqual from 'lodash/isEqual'	19✔
20	import { fetchFragmentSingle } from '../fetchFragment'	19✔
21	import { getLatestContentsRevision } from '@/lib/collections/revisions/helpers'	19✔
22	import { MakeEditableOptions, editableCollectionsFieldOptions } from '@/lib/editor/makeEditableOptions'	19✔
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");	19✔
31
32	export 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	}	19✔
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> => {	19✔
UNCOV 72	const id = doc._id;	×
UNCOV 73	const previousVersion = await getLatestRev(id, fieldName);	×
74
UNCOV 75	if (!previousVersion)	×
UNCOV 76	return true;	×
77
UNCOV 78	if (!isEqual(doc[fieldName].originalContents, previousVersion.originalContents)) {	×
UNCOV 79	return true;	×
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	425✔
107
108	const collectionName = collection.collectionName;	425✔
109
110	getCollectionHooks(collectionName).createBefore.add(	425✔
111	async function editorSerializationBeforeCreate (doc: DbType, {currentUser, context}) {
112	const editableField = (doc as AnyBecauseHard)[fieldName] as EditableFieldInsertion \| undefined;	1,011✔
113	if (editableField?.originalContents) {	1,011✔
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	985✔
182	});
183
184	getCollectionHooks(collectionName).updateBefore.add(	425✔
185	async function editorSerializationEdit (
186	docData: UpdateData,
187	{oldDocument: document, newDocument, currentUser},
188	) {
189	const editableField = (docData as AnyBecauseHard)[fieldName] as EditableFieldUpdate \| undefined;	105✔
190	if (editableField?.originalContents) {	105✔
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	const changeMetrics = htmlToChangeMetrics(previousRev?.html \|\| "", html);	5✔
227
228	const newRevision: Omit<DbRevision, '_id' \| 'schemaVersion' \| "voteCount" \| "baseScore" \| "extendedScore"\| "score" \| "inactive" \| "autosaveTimeoutStart" \| "afBaseScore" \| "afExtendedScore" \| "afVoteCount" \| "legacyData" \| "googleDocMetadata"> = {	5✔
229	documentId: document._id,
230	...revision,
231	fieldName,
232	collectionName,
233	version,
234	draft: versionIsDraft(version, collectionName),
235	updateType,
236	commitMessage,
237	changeMetrics,
238	createdAt: editedAt,
239	};
240
241	const newRevisionDoc = await createMutator({	5✔
242	collection: Revisions,
243	document: newRevision,
244	validate: false
245	});
246
247	const newRevisionId = newRevisionDoc.data._id;	5✔
248
249	if (newRevisionId) {	5!
250	await afterCreateRevisionCallback.runCallbacksAsync([{ revisionID: newRevisionId }]);	5✔
251	}
252
253	return {	5✔
254	...docData,
255	...(!normalized && {	8✔
256	[fieldName]: {
257	...editableField,
258	html, version, userId, editedAt, wordCount
259	},
260	}),
261	[`${fieldName}_latest`]: newRevisionId,
262	...(pingbacks ? {	5✔
263	pingbacks: await htmlToPingbacks(html, [{
264	collectionName: collection.collectionName,
265	documentId: document._id,
266	}]
267	),
268	} : null),
269	}
270	}
271	return docData	100✔
272	});
273
274	getCollectionHooks(collectionName).createAfter.add(	425✔
275	async function editorSerializationAfterCreate(newDoc) {
276	// Update revision to point to the document that owns it.
277	const revisionID = (newDoc as AnyBecauseHard)[`${fieldName}_latest`];	1,011✔
278	if (revisionID) {	1,011✔
279	await Revisions.rawUpdateOne(	130✔
280	{ _id: revisionID },
281	{ $set: { documentId: newDoc._id } }
282	);
283	await afterCreateRevisionCallback.runCallbacksAsync([{ revisionID: revisionID }]);	130✔
284	}
285	return newDoc;	1,011✔
286	});
287
288	getCollectionHooks(collectionName).createAfter.add(async (newDocument, {currentUser}) => {	425✔
289	if (currentUser && pingbacks && 'pingbacks' in newDocument) {	1,011✔
290	await notifyUsersAboutMentions(currentUser, collection.typeName, newDocument)	23✔
291	}
292
293	return newDocument	1,011✔
294	})
295
296	if (collectionName === 'Posts' && fieldName === 'contents') {	425✔
297	getCollectionHooks("Posts").createAfter.add(	17✔
298	async function updateFirstDebateCommentPostId(newDoc, { context, currentUser })
299	{
300	const isFirstDebatePostComment = 'debate' in newDoc	103✔
301	? !!newDoc.debate	103!
302	: false;
303	if (currentUser && isFirstDebatePostComment) {	103!
304	const revision = await getLatestContentsRevision(newDoc, context);	×
305	if (!revision?.html) {	×
306	return newDoc;	×
307	}
308	await createMutator({	×
309	collection: Comments,
310	document: {
311	userId: currentUser._id,
312	postId: newDoc._id,
313	contents: revision as EditableFieldInsertion,
314	debateResponse: true,
315	},
316	context,
317	currentUser,
318	});
319	}
320	return newDoc;	103✔
321	});
322	}
323
324	getCollectionHooks(collectionName).updateAfter.add(async (newDocument, {oldDocument, currentUser}) => {	425✔
325	if (currentUser && pingbacks && 'pingbacks' in newDocument) {	105✔
326	await notifyUsersAboutMentions(currentUser, collection.typeName, newDocument, oldDocument as PingbackDocumentPartial)	12✔
327	}
328
329	return newDocument	105✔
330	})
331
332	/**
333	* Reupload images to cloudinary. This is mainly for images pasted from google docs, because
334	* they have fairly strict rate limits that often result in them failing to load.
335	*
336	* NOTE: This is still necessary even if CkEditor is configured to reupload
337	* images, because images have URLs that come from Markdown or RSS sync.
338	* See: https://app.asana.com/0/628521446211730/1203311932993130/f
339	* It's fine to leave it here just in case though
340	*/
341	getCollectionHooks(collectionName).editAsync.add(async (doc: DbObject, oldDoc: DbObject) => {	425✔
342	const latestField = `${fieldName}_latest`;	105✔
343	const hasChanged = (oldDoc as AnyBecauseHard)?.[latestField] !== (doc as AnyBecauseHard)?.[latestField];	105!
344
345	if (!hasChanged) return;	105✔
346
347	await Globals.convertImagesInObject(collectionName, doc._id, fieldName);	5✔
348	})
349	getCollectionHooks(collectionName).newAsync.add(async (doc: DbObject) => {	425✔
350	await Globals.convertImagesInObject(collectionName, doc._id, fieldName)	1,011✔
351	})
352	if (collectionName === 'Posts') {	425✔
353	getCollectionHooks("Posts").newAsync.add(async (doc: DbPost) => {	51✔
354	await Globals.rehostPostMetaImages(doc);	309✔
355	})
356	}
357	}
358
359	export function addAllEditableCallbacks() {
360	sealEditableFields();	17✔
361	for (let collectionName of editableCollections) {	17✔
362	for (let fieldName of editableCollectionsFields[collectionName]) {	272✔
363	const collection = getCollection(collectionName);	425✔
364	const options = editableCollectionsFieldOptions[collectionName][fieldName];	425✔
365	addEditableCallbacks({collection, options});	425✔
366	}
367	}
368	}

ForumMagnum / ForumMagnum / 10745713515

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