10907947116

Committed 17 Sep 2024 05:21PM UTC coverage: 31.854% (+0.006%) from 31.848%

Build # 10907947116

Build Type

Pull #9717

github

Committed by

oetherington

Commit Message

Merge branch 'master' into crossposting-refactor-part-2

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

Run Details

5074 of 41376 branches covered (12.26%)

Branch coverage included in aggregate %.

25 of 47 new or added lines in 10 files covered. (53.19%)

5 existing lines in 3 files now uncovered.

29454 of 67018 relevant lines covered (43.95%)

184.53 hits per line

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

21.0

/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,
  TOS_NOT_ACCEPTED_ERROR,
  TOS_NOT_ACCEPTED_REMOTE_ERROR,
} from "./errors";
import {
  validateCrosspostingKarmaThreshold,
  fmCrosspostTimeoutMsSetting,
} from "./helpers";
import { makeApiUrl, PostRequestTypes, PostResponseTypes, ValidatedPostRouteName, validatedPostRoutes, ValidatedPostRoutes } from "./routes";
import { ConnectCrossposterArgs, GetCrosspostRequest } from "./types";
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";

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

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

ForumMagnum / ForumMagnum / 10907947116

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