11915670336

Committed 19 Nov 2024 02:54PM UTC coverage: 31.139% (+0.006%) from 31.133%

Build # 11915670336

Build Type

Pull #9717

github

Committed by

oetherington

Commit Message

Denormalize crosspost revision draft status

Pull Request Pull Request #9717: Crossposting refactor (Part 2 - enable new routes)

Run Details

5088 of 43345 branches covered (11.74%)

Branch coverage included in aggregate %.

32 of 55 new or added lines in 12 files covered. (58.18%)

8 existing lines in 4 files now uncovered.

30001 of 69340 relevant lines covered (43.27%)

172.31 hits per line

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

29.11

/packages/lesswrong/server/fmCrosspost/crosspost.ts

import pick from 'lodash/pick'
import Users from "../../lib/collections/users/collection";
import { randomId } from "../../lib/random";
import { loggerConstructor } from "../../lib/utils/logging";
import { extractDenormalizedData } from "./denormalizedFields";
import { UpdateCallbackProperties, getCollectionHooks } from "../mutationCallbacks";
import type { Crosspost, DenormalizedCrosspostData } from "./types";
import {
  createCrosspostToken,
  updateCrosspostToken,
} from "@/server/crossposting/tokens";
import { getLatestContentsRevision } from '@/lib/collections/revisions/helpers';
import {
  createCrosspostRoute,
  updateCrosspostRoute,
} from "@/lib/fmCrosspost/routes";
import { makeV2CrossSiteRequest } from "@/server/crossposting/crossSiteRequest";
import Revisions from '@/lib/collections/revisions/collection';

const assertPostIsCrosspostable = (
  post: DbPost,
  logger: ReturnType<typeof loggerConstructor>,
) => {
  if (post.isEvent) {
    logger('post is an event, throwing')
    throw new Error("Events cannot be crossposted");
  }
  if (post.shortform) {
    loggerConstructor('post is a shortform, throwing')
    throw new Error("Quick takes cannot be crossposted");
  }
}

export async function performCrosspost(post: DbPost): Promise<DbPost> {
  const logger = loggerConstructor('callbacks-posts')
  logger('performCrosspost()')
  logger('post info:', pick(post, ['title', 'fmCrosspost']))
  // TODO: validate userId owns foreignPost && currentUser === userId || currentUser.isAdmin
  if (!post.fmCrosspost || !post.userId || post.draft) {
    logger('post is not a crosspost or is a draft, returning')
    return post;
  }

  const {isCrosspost, hostedHere, foreignPostId} = post.fmCrosspost;
  if (!isCrosspost || !hostedHere || foreignPostId) {
    logger ('post is not a crosspost, or is a foreign-hosted crosspost, or has already been crossposted, returning')
    return post;
  }

  assertPostIsCrosspostable(post, logger);

  const user = await Users.findOne({_id: post.userId});
  if (!user || !user.fmCrosspostUserId) {
    logger('user has not connected an account, throwing')
    throw new Error("You have not connected a crossposting account yet");
  }

  // If we're creating a new post without making a draft first then we won't have an ID yet
  if (!post._id) {
    logger('we must be creating a new post, assigning a random ID')
    post._id = randomId();
  }

  // Grab the normalized contents from the revision
  const revision = await getLatestContentsRevision(post);

  const token = await createCrosspostToken.create({
    localUserId: post.userId,
    foreignUserId: user.fmCrosspostUserId,
    postId: post._id,
    ...extractDenormalizedData(post),
    contents: {
      originalContents: revision?.originalContents,
      draft: revision?.draft ?? false,
    },
  });

  const {postId} = await makeV2CrossSiteRequest(
    createCrosspostRoute,
    {token},
    "Failed to create crosspost",
  );

  logger('crosspost successful, setting foreignPostId:', postId)
  post.fmCrosspost.foreignPostId = postId;
  return post;
}

const updateCrosspost = async (
  foreignPostId: string,
  latestRevisionId: string | null,
  denormalizedData: DenormalizedCrosspostData,
) => {
  const revision = latestRevisionId
    ? await Revisions.findOne({_id: latestRevisionId})
    : null;
  const token = await updateCrosspostToken.create({
    ...denormalizedData,
    postId: foreignPostId,
    contents: {
      originalContents: revision?.originalContents,
      draft: revision?.draft ?? false,
    },
  });
  await makeV2CrossSiteRequest(
    updateCrosspostRoute,
    {token},
    "Failed to update crosspost",
  );
}

/**
 * TODO-HACK: We will kick the can down the road on actually removing the
 * crosspost data from the foreign server -- set it as a draft.
 */
const removeCrosspost = async <T extends Crosspost>(post: T) => {
  if (!post.fmCrosspost || !post.fmCrosspost.foreignPostId) {
    // eslint-disable-next-line no-console
    console.warn("Cannot remove crosspost that doesn't exist");
    return;
  }
  await updateCrosspost(post.fmCrosspost.foreignPostId, post.contents_latest, {
    ...extractDenormalizedData(post),
    draft: true,
  });
}

export async function handleCrosspostUpdate(
  data: Partial<DbPost>,
  {oldDocument, newDocument, currentUser}: UpdateCallbackProperties<"Posts">
): Promise<Partial<DbPost>> {
  const logger = loggerConstructor('callbacks-posts')
  logger('handleCrosspostUpdate()')
  const {userId, fmCrosspost} = newDocument;
  const shouldRemoveCrosspost =
    (oldDocument.fmCrosspost && data.fmCrosspost === null) ||
    (oldDocument.fmCrosspost?.isCrosspost && data.fmCrosspost?.isCrosspost === false)
  if (shouldRemoveCrosspost) {
    logger('crosspost should be removed, removing')
    await removeCrosspost(newDocument);
  }
  if (!fmCrosspost?.isCrosspost) {
    logger('post is not a crosspost, returning')
    return data;
  }
  if (!fmCrosspost?.hostedHere) {
    logger('post is not a hosted here, returning')
    return data;
  }

  if (fmCrosspost.foreignPostId) {
    assertPostIsCrosspostable(newDocument, logger);

    logger('denormalized fields changed, updating crosspost')
    const denormalizedData = extractDenormalizedData(newDocument);
    // Hack to deal with site admins moving posts to draft
    // Admins of non-local posts cannot cause source post to be set to draft
    if (
      denormalizedData.draft &&
      !oldDocument.draft &&
      !fmCrosspost.hostedHere &&
      currentUser?._id !== userId // Users can setting their own posts to draft affects both sites
    ) {
      logger('needed to use the terrible hack, not updating foreign post draft status')
      denormalizedData.draft = oldDocument.draft;
      denormalizedData.deletedDraft = oldDocument.deletedDraft;
    }
    logger('denormalizedData:', denormalizedData)
    const latestRevisionId =
      data.contents_latest ??
      newDocument.contents_latest ??
      oldDocument.contents_latest;
    await updateCrosspost(fmCrosspost.foreignPostId, latestRevisionId, denormalizedData);
    logger('crosspost updated successfully')
    // TODO-HACK: Drafts are very bad news for crossposts, so we will unlink in
    // such cases. See sad message to users in ForeignCrosspostEditForm.tsx.
    if (newDocument.draft && !oldDocument.draft) {
      logger('hack: post is now a draft, unlinking crosspost')
      return {
        ...newDocument,
        fmCrosspost: {
          ...fmCrosspost,
          foreignPostId: null,
        },
      }
    }
    return data;
  }

  return performCrosspost({ ...newDocument, ...data });
}

export const addCrosspostingCallbacks = () => {
  getCollectionHooks("Posts").newSync.add(performCrosspost);
  getCollectionHooks("Posts").updateBefore.add(handleCrosspostUpdate);
}

1	import pick from 'lodash/pick'	71✔
2	import Users from "../../lib/collections/users/collection";	18✔
3	import { randomId } from "../../lib/random";	18✔
4	import { loggerConstructor } from "../../lib/utils/logging";	18✔
5	import { extractDenormalizedData } from "./denormalizedFields";	18✔
6	import { UpdateCallbackProperties, getCollectionHooks } from "../mutationCallbacks";	18✔
7	import type { Crosspost, DenormalizedCrosspostData } from "./types";
8	import {
9	createCrosspostToken,
10	updateCrosspostToken,
11	} from "@/server/crossposting/tokens";	18✔
12	import { getLatestContentsRevision } from '@/lib/collections/revisions/helpers';	18✔
13	import {
14	createCrosspostRoute,
15	updateCrosspostRoute,
16	} from "@/lib/fmCrosspost/routes";	18✔
17	import { makeV2CrossSiteRequest } from "@/server/crossposting/crossSiteRequest";	18✔
18	import Revisions from '@/lib/collections/revisions/collection';	18✔
19
20	const assertPostIsCrosspostable = (	18✔
21	post: DbPost,
22	logger: ReturnType<typeof loggerConstructor>,
23	) => {
24	if (post.isEvent) {	×
25	logger('post is an event, throwing')	×
26	throw new Error("Events cannot be crossposted");	×
27	}
28	if (post.shortform) {	×
29	loggerConstructor('post is a shortform, throwing')	×
30	throw new Error("Quick takes cannot be crossposted");	×
31	}
32	}
33
34	export async function performCrosspost(post: DbPost): Promise<DbPost> {
35	const logger = loggerConstructor('callbacks-posts')	103✔
36	logger('performCrosspost()')	103✔
37	logger('post info:', pick(post, ['title', 'fmCrosspost']))	103✔
38	// TODO: validate userId owns foreignPost && currentUser === userId \|\| currentUser.isAdmin
39	if (!post.fmCrosspost \|\| !post.userId \|\| post.draft) {	103!
40	logger('post is not a crosspost or is a draft, returning')	×
41	return post;	×
42	}
43
44	const {isCrosspost, hostedHere, foreignPostId} = post.fmCrosspost;	103✔
45	if (!isCrosspost \|\| !hostedHere \|\| foreignPostId) {	103!
46	logger ('post is not a crosspost, or is a foreign-hosted crosspost, or has already been crossposted, returning')	103✔
47	return post;	103✔
48	}
49
50	assertPostIsCrosspostable(post, logger);	×
51
52	const user = await Users.findOne({_id: post.userId});	×
53	if (!user \|\| !user.fmCrosspostUserId) {	×
54	logger('user has not connected an account, throwing')	×
55	throw new Error("You have not connected a crossposting account yet");	×
56	}
57
58	// If we're creating a new post without making a draft first then we won't have an ID yet
59	if (!post._id) {	×
60	logger('we must be creating a new post, assigning a random ID')	×
61	post._id = randomId();	×
62	}
63
64	// Grab the normalized contents from the revision
NEW 65	const revision = await getLatestContentsRevision(post);	×
66
67	const token = await createCrosspostToken.create({	×
68	localUserId: post.userId,
69	foreignUserId: user.fmCrosspostUserId,
70	postId: post._id,
71	...extractDenormalizedData(post),
72	contents: {
73	originalContents: revision?.originalContents,	×
74	draft: revision?.draft ?? false,	×
75	},
76	});
77
NEW 78	const {postId} = await makeV2CrossSiteRequest(	×
79	createCrosspostRoute,
80	{token},
81	"Failed to create crosspost",
82	);
83
UNCOV 84	logger('crosspost successful, setting foreignPostId:', postId)	×
85	post.fmCrosspost.foreignPostId = postId;	×
86	return post;	×
87	}
88
89	const updateCrosspost = async (	18✔
90	foreignPostId: string,
91	latestRevisionId: string \| null,
92	denormalizedData: DenormalizedCrosspostData,
93	) => {
NEW 94	const revision = latestRevisionId	×
95	? await Revisions.findOne({_id: latestRevisionId})	×
96	: null;
UNCOV 97	const token = await updateCrosspostToken.create({	×
98	...denormalizedData,
99	postId: foreignPostId,
100	contents: {
101	originalContents: revision?.originalContents,	×
102	draft: revision?.draft ?? false,	×
103	},
104	});
NEW 105	await makeV2CrossSiteRequest(	×
106	updateCrosspostRoute,
107	{token},
108	"Failed to update crosspost",
109	);
110	}
111
112	/**
113	* TODO-HACK: We will kick the can down the road on actually removing the
114	* crosspost data from the foreign server -- set it as a draft.
115	*/
116	const removeCrosspost = async <T extends Crosspost>(post: T) => {	18✔
117	if (!post.fmCrosspost \|\| !post.fmCrosspost.foreignPostId) {	×
118	// eslint-disable-next-line no-console
119	console.warn("Cannot remove crosspost that doesn't exist");	×
120	return;	×
121	}
NEW 122	await updateCrosspost(post.fmCrosspost.foreignPostId, post.contents_latest, {	×
123	...extractDenormalizedData(post),
124	draft: true,
125	});
126	}
127
128	export async function handleCrosspostUpdate(
129	data: Partial<DbPost>,
130	{oldDocument, newDocument, currentUser}: UpdateCallbackProperties<"Posts">
131	): Promise<Partial<DbPost>> {
132	const logger = loggerConstructor('callbacks-posts')	15✔
133	logger('handleCrosspostUpdate()')	15✔
134	const {userId, fmCrosspost} = newDocument;	15✔
135	const shouldRemoveCrosspost =
136	(oldDocument.fmCrosspost && data.fmCrosspost === null) \|\|	15!
137	(oldDocument.fmCrosspost?.isCrosspost && data.fmCrosspost?.isCrosspost === false)	15!
138	if (shouldRemoveCrosspost) {	15!
139	logger('crosspost should be removed, removing')	×
140	await removeCrosspost(newDocument);	×
141	}
142	if (!fmCrosspost?.isCrosspost) {	15!
143	logger('post is not a crosspost, returning')	15✔
144	return data;	15✔
145	}
NEW 146	if (!fmCrosspost?.hostedHere) {	×
NEW 147	logger('post is not a hosted here, returning')	×
NEW 148	return data;	×
149	}
150
NEW 151	if (fmCrosspost.foreignPostId) {	×
UNCOV 152	assertPostIsCrosspostable(newDocument, logger);	×
153
154	logger('denormalized fields changed, updating crosspost')	×
155	const denormalizedData = extractDenormalizedData(newDocument);	×
156	// Hack to deal with site admins moving posts to draft
157	// Admins of non-local posts cannot cause source post to be set to draft
158	if (	×
159	denormalizedData.draft &&	×
160	!oldDocument.draft &&
161	!fmCrosspost.hostedHere &&
162	currentUser?._id !== userId // Users can setting their own posts to draft affects both sites	×
163	) {
164	logger('needed to use the terrible hack, not updating foreign post draft status')	×
165	denormalizedData.draft = oldDocument.draft;	×
166	denormalizedData.deletedDraft = oldDocument.deletedDraft;	×
167	}
168	logger('denormalizedData:', denormalizedData)	×
NEW 169	const latestRevisionId =	×
170	data.contents_latest ??	×
171	newDocument.contents_latest ??
172	oldDocument.contents_latest;
NEW 173	await updateCrosspost(fmCrosspost.foreignPostId, latestRevisionId, denormalizedData);	×
UNCOV 174	logger('crosspost updated successfully')	×
175	// TODO-HACK: Drafts are very bad news for crossposts, so we will unlink in
176	// such cases. See sad message to users in ForeignCrosspostEditForm.tsx.
177	if (newDocument.draft && !oldDocument.draft) {	×
178	logger('hack: post is now a draft, unlinking crosspost')	×
179	return {	×
180	...newDocument,
181	fmCrosspost: {
182	...fmCrosspost,
183	foreignPostId: null,
184	},
185	}
186	}
187	return data;	×
188	}
189
190	return performCrosspost({ ...newDocument, ...data });	×
191	}
192
193	export const addCrosspostingCallbacks = () => {	18✔
194	getCollectionHooks("Posts").newSync.add(performCrosspost);	17✔
195	getCollectionHooks("Posts").updateBefore.add(handleCrosspostUpdate);	17✔
196	}

ForumMagnum / ForumMagnum / 11915670336

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