10459419523

Committed 19 Aug 2024 07:06PM UTC coverage: 32.167% (-0.02%) from 32.191%

Build # 10459419523

Build Type

Pull #9602

github

Committed by

jpaddison3

Commit Message

denormalizing the newly normalized contents for use in creating crossposts

Co-authored-by: oetherington <ollie@etherington.xyz>

Pull Request Pull Request #9602: Crossposting refactor (Part 1)

Run Details

5016 of 40366 branches covered (12.43%)

Branch coverage included in aggregate %.

39 of 147 new or added lines in 10 files covered. (26.53%)

5 existing lines in 3 files now uncovered.

28994 of 65364 relevant lines covered (44.36%)

191.53 hits per line

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

23.3

/packages/lesswrong/server/fmCrosspost/resolvers.ts

import type { Request } from "express";
import { isLeft } from 'fp-ts/Either';
import { crosspostUserAgent } from "../../lib/apollo/links";
import Users from "../../lib/collections/users/collection";
import { addGraphQLMutation, addGraphQLQuery, addGraphQLResolvers } from "../../lib/vulcan-lib";
import { ApiError, UnauthorizedError } from "./errors";
import { validateCrosspostingKarmaThreshold } from "./helpers";
import { makeApiUrl, PostRequestTypes, PostResponseTypes, ValidatedPostRouteName, validatedPostRoutes, ValidatedPostRoutes } from "./routes";
import { ConnectCrossposterArgs, GetCrosspostRequest } from "./types";
import { DatabaseServerSetting } from "../databaseSettings";
import stringify from "json-stringify-deterministic";
import LRU from "lru-cache";
import { isE2E } from "@/lib/executionEnvironment";
import { connectCrossposterToken } from "../crossposting/tokens";
// import { makeV2CrossSiteRequest } from "../crossposting/crossSiteRequest";
// import {
//   connectCrossposterRoute,
//   unlinkCrossposterRoute,
// } from "@/lib/fmCrosspost/routes";

export const fmCrosspostTimeoutMsSetting = new DatabaseServerSetting<number>('fmCrosspostTimeoutMs', 15000)

export const TOS_NOT_ACCEPTED_ERROR = 'You must accept the terms of use before you can publish this post';
export const TOS_NOT_ACCEPTED_REMOTE_ERROR = 'You must read and accept the Terms of Use on the EA Forum in order to crosspost.  To do so, go to https://forum.effectivealtruism.org/newPost and accept the Terms of Use presented above the draft post.';

const getUserId = (req?: Request) => {
  const userId = req?.user?._id;
  if (!userId) {
    throw new UnauthorizedError();
  }
  return userId;
}

const foreignPostCache = new LRU<string, Promise<AnyBecauseHard>>({
  maxAge: 1000 * 60 * 30, // 30 minute TTL
  updateAgeOnGet: false,
  max: 100,
});

export const makeCrossSiteRequest = async <RouteName extends ValidatedPostRouteName>(
  routeName: RouteName,
  body: PostRequestTypes<RouteName>,
  onErrorMessage: string,
): Promise<PostResponseTypes<RouteName>> => {
  const route: ValidatedPostRoutes[RouteName] = validatedPostRoutes[routeName];
  const apiUrl = makeApiUrl(route.path);
  let result: Response;

  const controller = new AbortController();
  // Timeout early to avoid this causing frontpage loads to time out
  const timeoutId = setTimeout(() => controller.abort(), fmCrosspostTimeoutMsSetting.get());

  try {
    result = await fetch(apiUrl, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "User-Agent": crosspostUserAgent,
      },
      body: JSON.stringify(body),
      signal: controller.signal,
    });
  } catch (e) {
    clearTimeout(timeoutId); // Clear the timeout when an error occurs

    if (e.name === 'AbortError') {
      throw new ApiError(500, "Crosspost request timed out");
    }

    if (e.cause?.code === 'ECONNREFUSED' && e.cause?.port === 4000) {
      // We're testing locally, and the x-post server isn't running
      return { document: {} }
    } else {
      throw e
    }
  }

  clearTimeout(timeoutId); // Clear the timeout when the request completes

  // Assertion is safe because either we got a result or we threw an error or returned
  const json = await result!.json();
  const validatedResponse = route.responseValidator.decode(json);
  if (isLeft(validatedResponse) || 'error' in json) {
    // eslint-disable-next-line no-console
    console.error("Cross-site request failed:", json);
    let errorMessage = onErrorMessage;
    // TODO: temporary patch for surfacing 
    if ('error' in json && json.error === TOS_NOT_ACCEPTED_ERROR) {
      errorMessage = TOS_NOT_ACCEPTED_REMOTE_ERROR;
    }
    throw new ApiError(500, errorMessage);
  }
  
  return validatedResponse.right;
}

const crosspostResolvers = {
  Mutation: {
    connectCrossposter: async (
      _root: void,
      {token}: ConnectCrossposterArgs,
      {req, currentUser}: ResolverContext,
    ) => {
      const localUserId = getUserId(req);

      // Throws an error if user doesn't have enough karma on the receiving forum (which is the current execution environment)
      validateCrosspostingKarmaThreshold(currentUser);

      const {foreignUserId} = await makeCrossSiteRequest(
        'connectCrossposter',
        {token, localUserId},
        "Failed to connect accounts for crossposting",
      );
      // TODO: Switch to this when V2 is deployed to both sites
      // const {foreignUserId} = await makeV2CrossSiteRequest(
      //   connectCrossposterRoute,
      //   {token, localUserId},
      //   "Failed to connect accounts for crossposting",
      // );
      await Users.rawUpdateOne({_id: localUserId}, {
        $set: {fmCrosspostUserId: foreignUserId},
      });
      return "success";
    },
    unlinkCrossposter: async (_root: void, _args: {}, {req}: ResolverContext) => {
      const localUserId = getUserId(req);
      const foreignUserId = req?.user?.fmCrosspostUserId;
      if (foreignUserId) {
        const token = await connectCrossposterToken.create({
          userId: foreignUserId,
        });
        await makeCrossSiteRequest(
          'unlinkCrossposter',
          {token},
          "Failed to unlink crossposting accounts",
        );
        // TODO: Switch to this when V2 is deployed to both sites
        // await makeV2CrossSiteRequest(
        //   unlinkCrossposterRoute,
        //   {token},
        //   "Failed to unlink crossposting accounts",
        // );
        await Users.rawUpdateOne({_id: localUserId}, {
          $unset: {fmCrosspostUserId: ""},
        });
      }
      return "success";
    },
  },
  Query: {
    getCrosspost: async (_root: void, {args}: {args: GetCrosspostRequest}) => {
      const key = stringify(args);
      let promise = isE2E ? null : foreignPostCache.get(key);
      if (!promise) {
        promise = makeCrossSiteRequest(
          'getCrosspost',
          args,
          'Failed to get crosspost'
        );
        foreignPostCache.set(key, promise);
      }
      const {document} = await promise;
      return document;
    }
  }
};

addGraphQLResolvers(crosspostResolvers);
addGraphQLMutation("connectCrossposter(token: String): String");
addGraphQLMutation("unlinkCrossposter: String");
addGraphQLQuery("getCrosspost(args: JSON): JSON");

1	import type { Request } from "express";	54✔
2	import { isLeft } from 'fp-ts/Either';	18✔
3	import { crosspostUserAgent } from "../../lib/apollo/links";	18✔
4	import Users from "../../lib/collections/users/collection";	18✔
5	import { addGraphQLMutation, addGraphQLQuery, addGraphQLResolvers } from "../../lib/vulcan-lib";	18✔
6	import { ApiError, UnauthorizedError } from "./errors";	18✔
7	import { validateCrosspostingKarmaThreshold } from "./helpers";	18✔
8	import { makeApiUrl, PostRequestTypes, PostResponseTypes, ValidatedPostRouteName, validatedPostRoutes, ValidatedPostRoutes } from "./routes";	18✔
9	import { ConnectCrossposterArgs, GetCrosspostRequest } from "./types";
10	import { DatabaseServerSetting } from "../databaseSettings";	18✔
11	import stringify from "json-stringify-deterministic";	18✔
12	import LRU from "lru-cache";	18✔
13	import { isE2E } from "@/lib/executionEnvironment";	18✔
14	import { connectCrossposterToken } from "../crossposting/tokens";	18✔
15	// import { makeV2CrossSiteRequest } from "../crossposting/crossSiteRequest";
16	// import {
17	// connectCrossposterRoute,
18	// unlinkCrossposterRoute,
19	// } from "@/lib/fmCrosspost/routes";
20
21	export const fmCrosspostTimeoutMsSetting = new DatabaseServerSetting<number>('fmCrosspostTimeoutMs', 15000)	18✔
22
23	export const TOS_NOT_ACCEPTED_ERROR = 'You must accept the terms of use before you can publish this post';	18✔
24	export const TOS_NOT_ACCEPTED_REMOTE_ERROR = 'You must read and accept the Terms of Use on the EA Forum in order to crosspost. To do so, go to https://forum.effectivealtruism.org/newPost and accept the Terms of Use presented above the draft post.';	18✔
25
26	const getUserId = (req?: Request) => {	18✔
27	const userId = req?.user?._id;	×
28	if (!userId) {	×
29	throw new UnauthorizedError();	×
30	}
31	return userId;	×
32	}
33
34	const foreignPostCache = new LRU<string, Promise<AnyBecauseHard>>({	18✔
35	maxAge: 1000 * 60 * 30, // 30 minute TTL
36	updateAgeOnGet: false,
37	max: 100,
38	});
39
40	export const makeCrossSiteRequest = async <RouteName extends ValidatedPostRouteName>(	18✔
41	routeName: RouteName,
42	body: PostRequestTypes<RouteName>,
43	onErrorMessage: string,
44	): Promise<PostResponseTypes<RouteName>> => {
45	const route: ValidatedPostRoutes[RouteName] = validatedPostRoutes[routeName];	×
46	const apiUrl = makeApiUrl(route.path);	×
47	let result: Response;
48
49	const controller = new AbortController();	×
50	// Timeout early to avoid this causing frontpage loads to time out
51	const timeoutId = setTimeout(() => controller.abort(), fmCrosspostTimeoutMsSetting.get());	×
52
53	try {	×
54	result = await fetch(apiUrl, {	×
55	method: "POST",
56	headers: {
57	"Content-Type": "application/json",
58	"User-Agent": crosspostUserAgent,
59	},
60	body: JSON.stringify(body),
61	signal: controller.signal,
62	});
63	} catch (e) {
64	clearTimeout(timeoutId); // Clear the timeout when an error occurs	×
65
66	if (e.name === 'AbortError') {	×
67	throw new ApiError(500, "Crosspost request timed out");	×
68	}
69
70	if (e.cause?.code === 'ECONNREFUSED' && e.cause?.port === 4000) {	×
71	// We're testing locally, and the x-post server isn't running
72	return { document: {} }	×
73	} else {
74	throw e	×
75	}
76	}
77
78	clearTimeout(timeoutId); // Clear the timeout when the request completes	×
79
80	// Assertion is safe because either we got a result or we threw an error or returned
81	const json = await result!.json();	×
82	const validatedResponse = route.responseValidator.decode(json);	×
83	if (isLeft(validatedResponse) \|\| 'error' in json) {	×
84	// eslint-disable-next-line no-console
85	console.error("Cross-site request failed:", json);	×
86	let errorMessage = onErrorMessage;	×
87	// TODO: temporary patch for surfacing
88	if ('error' in json && json.error === TOS_NOT_ACCEPTED_ERROR) {	×
89	errorMessage = TOS_NOT_ACCEPTED_REMOTE_ERROR;	×
90	}
91	throw new ApiError(500, errorMessage);	×
92	}
93
94	return validatedResponse.right;	×
95	}
96
97	const crosspostResolvers = {	18✔
98	Mutation: {
99	connectCrossposter: async (
100	_root: void,
101	{token}: ConnectCrossposterArgs,
102	{req, currentUser}: ResolverContext,
103	) => {
104	const localUserId = getUserId(req);	×
105
106	// Throws an error if user doesn't have enough karma on the receiving forum (which is the current execution environment)
107	validateCrosspostingKarmaThreshold(currentUser);	×
108
109	const {foreignUserId} = await makeCrossSiteRequest(	×
110	'connectCrossposter',
111	{token, localUserId},
112	"Failed to connect accounts for crossposting",
113	);
114	// TODO: Switch to this when V2 is deployed to both sites
115	// const {foreignUserId} = await makeV2CrossSiteRequest(
116	// connectCrossposterRoute,
117	// {token, localUserId},
118	// "Failed to connect accounts for crossposting",
119	// );
UNCOV 120	await Users.rawUpdateOne({_id: localUserId}, {	×
121	$set: {fmCrosspostUserId: foreignUserId},
122	});
123	return "success";	×
124	},
125	unlinkCrossposter: async (_root: void, _args: {}, {req}: ResolverContext) => {
126	const localUserId = getUserId(req);	×
127	const foreignUserId = req?.user?.fmCrosspostUserId;	×
128	if (foreignUserId) {	×
NEW 129	const token = await connectCrossposterToken.create({	×
130	userId: foreignUserId,
131	});
UNCOV 132	await makeCrossSiteRequest(	×
133	'unlinkCrossposter',
134	{token},
135	"Failed to unlink crossposting accounts",
136	);
137	// TODO: Switch to this when V2 is deployed to both sites
138	// await makeV2CrossSiteRequest(
139	// unlinkCrossposterRoute,
140	// {token},
141	// "Failed to unlink crossposting accounts",
142	// );
UNCOV 143	await Users.rawUpdateOne({_id: localUserId}, {	×
144	$unset: {fmCrosspostUserId: ""},
145	});
146	}
147	return "success";	×
148	},
149	},
150	Query: {
151	getCrosspost: async (_root: void, {args}: {args: GetCrosspostRequest}) => {
152	const key = stringify(args);	×
153	let promise = isE2E ? null : foreignPostCache.get(key);	×
154	if (!promise) {	×
155	promise = makeCrossSiteRequest(	×
156	'getCrosspost',
157	args,
158	'Failed to get crosspost'
159	);
160	foreignPostCache.set(key, promise);	×
161	}
162	const {document} = await promise;	×
163	return document;	×
164	}
165	}
166	};	18✔
167
168	addGraphQLResolvers(crosspostResolvers);	18✔
169	addGraphQLMutation("connectCrossposter(token: String): String");	18✔
170	addGraphQLMutation("unlinkCrossposter: String");	18✔
171	addGraphQLQuery("getCrosspost(args: JSON): JSON");

ForumMagnum / ForumMagnum / 10459419523

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