10964497749

Committed 20 Sep 2024 06:34PM UTC coverage: 31.911% (+0.04%) from 31.868%

Build # 10964497749

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9769 from ForumMagnum/master

Merge master into LW deploy

Run Details

5077 of 41301 branches covered (12.29%)

Branch coverage included in aggregate %.

108 of 297 new or added lines in 44 files covered. (36.36%)

23 existing lines in 14 files now uncovered.

29444 of 66879 relevant lines covered (44.03%)

184.99 hits per line

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

30.47

/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 { denormalizedFieldKeys, extractDenormalizedData } from "./denormalizedFields";
import { makeCrossSiteRequest } from "./resolvers";
import type { UpdateCallbackProperties } from "../mutationCallbacks";
import type { Crosspost, DenormalizedCrosspostData } from "./types";
import {
  createCrosspostToken,
  updateCrosspostToken,
} from "@/server/crossposting/tokens";
// import { getLatestContentsRevision } from '@/lib/collections/revisions/helpers';
// import { fetchFragmentSingle } from '../fetchFragment';
// import {
//   createCrosspostRoute,
//   updateCrosspostRoute,
// } from "@/lib/fmCrosspost/routes";
// import { makeV2CrossSiteRequest } from "@/server/crossposting/crossSiteRequest";

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
  // TODO: Enable to this when V2 is deployed to both sites
  // const revision = await getLatestContentsRevision(post);

  const token = await createCrosspostToken.create({
    localUserId: post.userId,
    foreignUserId: user.fmCrosspostUserId,
    postId: post._id,
    ...extractDenormalizedData(post),
    // TODO: Enable to this when V2 is deployed to both sites
    // originalContents: revision?.originalContents,
  });

  const { postId } = await makeCrossSiteRequest(
    'crosspost',
    { token },
    'Failed to create crosspost'
  );
  // TODO: Switch to this when V2 is deployed to both sites
  // 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 (postId: string, denormalizedData: DenormalizedCrosspostData) => {
  // TODO: Enable to this when V2 is deployed to both sites
  // const postOriginalContents = await fetchFragmentSingle({
  //   collectionName: "Posts",
  //   fragmentName: "PostsOriginalContents",
  //   currentUser: null,
  //   selector: postId,
  //   skipFiltering: true,
  // })

  const token = await updateCrosspostToken.create({
    ...denormalizedData,
    postId,
    // TODO: Enable to this when V2 is deployed to both sites
    // originalContents: postOriginalContents?.contents?.originalContents,
  });
  await makeCrossSiteRequest(
    'updateCrosspost',
    { token },
    "Failed to update crosspost draft status",
  );
  // TODO: Switch to this when V2 is deployed to both sites
  // 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, {
    ...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 (
    denormalizedFieldKeys.some(
      (key) => data[key] !== undefined && data[key] !== oldDocument[key]
    ) &&
    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)
    await updateCrosspost(fmCrosspost.foreignPostId, 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);
}

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

ForumMagnum / ForumMagnum / 10964497749

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