10155722208

Committed 30 Jul 2024 03:37AM UTC coverage: 31.841% (-0.02%) from 31.857%

Build # 10155722208

Build Type

Pull #9556

github

Committed by

Raemon

Commit Message

fix padding

Pull Request Pull Request #9556: Minimalist Post Header

Run Details

4950 of 40709 branches covered (12.16%)

Branch coverage included in aggregate %.

25 of 81 new or added lines in 5 files covered. (30.86%)

314 existing lines in 10 files now uncovered.

28910 of 65632 relevant lines covered (44.05%)

179.27 hits per line

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

23.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 } from "./errors";
import { validateCrosspostingKarmaThreshold } from "./helpers";
import { makeApiUrl, PostRequestTypes, PostResponseTypes, ValidatedPostRouteName, validatedPostRoutes, ValidatedPostRoutes } from "./routes";
import { signToken } from "./tokens";
import { ConnectCrossposterArgs, GetCrosspostRequest, UnlinkCrossposterPayload } from "./types";
import { DatabaseServerSetting } from "../databaseSettings";
import stringify from "json-stringify-deterministic";
import LRU from "lru-cache";

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

ForumMagnum / ForumMagnum / 10155722208

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