10694035938

Committed 04 Sep 2024 02:28AM UTC coverage: 31.912% (+0.03%) from 31.878%

Build # 10694035938

Build Type

Pull #9704

github

Committed by

ben-pace

Commit Message

teeny changes

Pull Request Pull Request #9704: Curation Page

Run Details

5027 of 41142 branches covered (12.22%)

Branch coverage included in aggregate %.

58 of 94 new or added lines in 15 files covered. (61.7%)

879 existing lines in 27 files now uncovered.

29390 of 66708 relevant lines covered (44.06%)

188.34 hits per line

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

42.24

/packages/lesswrong/server/vulcan-lib/apollo-server/context.ts

/**
 * Context prop of the ApolloServer config
 *
 * It sets up the server options based on the current request
 * Replacement to the syntax graphqlExpress(async req => {... })
 * Current pattern:
 * @see https://www.apollographql.com/docs/apollo-server/migration-two-dot.html#request-headers
 * @see https://github.com/apollographql/apollo-server/issues/1066
 * Previous implementation:
 * @see https://github.com/apollographql/apollo-server/issues/420
 */

import { configureScope } from '@sentry/node';
import DataLoader from 'dataloader';
import { getCollectionsByName } from '../../../lib/vulcan-lib/collections';
import findByIds from '../findbyids';
import { getHeaderLocale } from '../intl';
import * as _ from 'underscore';
import { hashLoginToken, tokenExpiration, userIsBanned } from '../../loginTokens';
import type { Request, Response } from 'express';
import {getUserEmail} from "../../../lib/collections/users/helpers";
import { getAllRepos, UsersRepo } from '../../repos';
import UserActivities from '../../../lib/collections/useractivities/collection';
import { getCookieFromReq } from '../../utils/httpUtil';
import { isEAForum } from '../../../lib/instanceSettings';
import { userChangedCallback } from '../../../lib/vulcan-lib/callbacks';
import { asyncLocalStorage } from '../../perfMetrics';
import { visitorGetsDynamicFrontpage } from '../../../lib/betas';

// From https://github.com/apollographql/meteor-integration/blob/master/src/server.js
export const getUser = async (loginToken: string): Promise<DbUser|null> => {
  if (loginToken) {
    if (typeof loginToken !== 'string')
      throw new Error("Login token is not a string");

    const hashedToken = hashLoginToken(loginToken)

    const user = await new UsersRepo().getUserByLoginToken(hashedToken);

    if (user && !userIsBanned(user)) {
      // find the right login token corresponding, the current user may have
      // several sessions logged on different browsers / computers
      const tokenInformation = user.services.resume.loginTokens.find(
        (tokenInfo: AnyBecauseTodo) => tokenInfo.hashedToken === hashedToken
      )

      const expiresAt = tokenExpiration(tokenInformation.when)

      const isExpired = expiresAt < new Date()

      if (!isExpired) {
        return user
      }
    }
  }
  
  return null;
}

// @see https://www.apollographql.com/docs/react/recipes/meteor#Server
const setupAuthToken = async (user: DbUser|null): Promise<{
  userId: string|null,
  currentUser: DbUser|null,
}> => {
  if (user) {
    // identify user to any server-side analytics providers
    await userChangedCallback.runCallbacks({
      iterator: user,
      properties: [],
    });
    return {
      userId: user._id,
      currentUser: user,
    };
  } else {
    return {
      userId: null,
      currentUser: null,
    };
  }
};

// Generate a set of DataLoader objects, one per collection, to be added to a resolver context
export const generateDataLoaders = (): {
  loaders: Record<CollectionNameString, DataLoader<string,any>>
  extraLoaders: Record<string,any>
} => {
  const loaders = _.mapObject(getCollectionsByName(), (collection,name) =>
    new DataLoader(
      (ids: Array<string>) => findByIds(collection, ids),
      { cache: true, }
    )
  ) as Record<CollectionNameString, DataLoader<string,any>>;
  
  return {
    loaders,
    extraLoaders: {}
  };
};


export function requestIsFromGreaterWrong(req?: Request): boolean {
  if (!req) return false;
  const userAgent = req.headers?.["user-agent"];
  if (!userAgent) return false;
  if (typeof userAgent !== "string") return false;
  return userAgent.startsWith("Dexador");
}

export const computeContextFromUser = async ({user, req, res, isSSR}: {
  user: DbUser|null,
  req?: Request,
  res?: Response,
  isSSR: boolean
}): Promise<ResolverContext> => {
  let visitorActivity: DbUserActivity|null = null;
  const clientId = req ? getCookieFromReq(req, "clientId") : null;
  if ((user || clientId) && (isEAForum || visitorGetsDynamicFrontpage(user))) {
    visitorActivity = user ?
      await UserActivities.findOne({visitorId: user._id, type: 'userId'}) :
      await UserActivities.findOne({visitorId: clientId, type: 'clientId'});
  }
  
  let context: ResolverContext = {
    ...getCollectionsByName(),
    ...generateDataLoaders(),
    req: req as any,
    res,
    headers: (req as any)?.headers,
    locale: (req as any)?.headers ? getHeaderLocale((req as any).headers, null) : "en-US",
    isSSR,
    isGreaterWrong: requestIsFromGreaterWrong(req),
    repos: getAllRepos(),
    clientId,
    visitorActivity,
    ...await setupAuthToken(user),
    perfMetric: asyncLocalStorage.getStore()?.requestPerfMetric,
  };

  if (user) {
    context.loaders.Users.prime(user._id, user);
  }

  return context;
}

export function configureSentryScope(context: ResolverContext) {
  const user = context.currentUser;
  
  if (user) {
    configureScope(scope => {
      scope.setUser({
        id: user._id,
        email: getUserEmail(user),
        username: context.isGreaterWrong ? `${user.username} (via GreaterWrong)` : user.username ?? undefined,
      });
    });
  } else if (context.isGreaterWrong) {
    configureScope(scope => {
      scope.setUser({
        username: context.isGreaterWrong ? `Logged out (via GreaterWrong)` : "Logged out",
      });
    });
  }
}

export const getUserFromReq = (req: AnyBecauseTodo): DbUser|null => {
  return req.user
  // return getUser(getAuthToken(req));
}

export async function getContextFromReqAndRes({req, res, isSSR}: {
  req: Request,
  res: Response,
  isSSR: boolean
}): Promise<ResolverContext> {
  const user = getUserFromReq(req);
  const context = await computeContextFromUser({user, req, res, isSSR});
  return context;
}

1	/**	1,917✔
2	* Context prop of the ApolloServer config
3	*
4	* It sets up the server options based on the current request
5	* Replacement to the syntax graphqlExpress(async req => {... })
6	* Current pattern:
7	* @see https://www.apollographql.com/docs/apollo-server/migration-two-dot.html#request-headers
8	* @see https://github.com/apollographql/apollo-server/issues/1066
9	* Previous implementation:
10	* @see https://github.com/apollographql/apollo-server/issues/420
11	*/
12
13	import { configureScope } from '@sentry/node';	20✔
14	import DataLoader from 'dataloader';	20✔
15	import { getCollectionsByName } from '../../../lib/vulcan-lib/collections';	20✔
16	import findByIds from '../findbyids';	20✔
17	import { getHeaderLocale } from '../intl';	20✔
18	import * as _ from 'underscore';	20✔
19	import { hashLoginToken, tokenExpiration, userIsBanned } from '../../loginTokens';	20✔
20	import type { Request, Response } from 'express';
21	import {getUserEmail} from "../../../lib/collections/users/helpers";	20✔
22	import { getAllRepos, UsersRepo } from '../../repos';	20✔
23	import UserActivities from '../../../lib/collections/useractivities/collection';	20✔
24	import { getCookieFromReq } from '../../utils/httpUtil';	20✔
25	import { isEAForum } from '../../../lib/instanceSettings';	20✔
26	import { userChangedCallback } from '../../../lib/vulcan-lib/callbacks';	20✔
27	import { asyncLocalStorage } from '../../perfMetrics';	20✔
28	import { visitorGetsDynamicFrontpage } from '../../../lib/betas';	20✔
29
30	// From https://github.com/apollographql/meteor-integration/blob/master/src/server.js
31	export const getUser = async (loginToken: string): Promise<DbUser\|null> => {	20✔
32	if (loginToken) {	×
33	if (typeof loginToken !== 'string')	×
34	throw new Error("Login token is not a string");	×
35
36	const hashedToken = hashLoginToken(loginToken)	×
37
38	const user = await new UsersRepo().getUserByLoginToken(hashedToken);	×
39
40	if (user && !userIsBanned(user)) {	×
41	// find the right login token corresponding, the current user may have
42	// several sessions logged on different browsers / computers
43	const tokenInformation = user.services.resume.loginTokens.find(	×
44	(tokenInfo: AnyBecauseTodo) => tokenInfo.hashedToken === hashedToken	×
45	)
46
47	const expiresAt = tokenExpiration(tokenInformation.when)	×
48
49	const isExpired = expiresAt < new Date()	×
50
51	if (!isExpired) {	×
52	return user	×
53	}
54	}
55	}
56
57	return null;	×
58	}
59
60	// @see https://www.apollographql.com/docs/react/recipes/meteor#Server
61	const setupAuthToken = async (user: DbUser\|null): Promise<{	20✔
62	userId: string\|null,
63	currentUser: DbUser\|null,
64	}> => {
65	if (user) {	5!
66	// identify user to any server-side analytics providers
67	await userChangedCallback.runCallbacks({	5✔
68	iterator: user,
69	properties: [],
70	});
71	return {	5✔
72	userId: user._id,
73	currentUser: user,
74	};
75	} else {
UNCOV 76	return {	×
77	userId: null,
78	currentUser: null,
79	};
80	}
81	};
82
83	// Generate a set of DataLoader objects, one per collection, to be added to a resolver context
84	export const generateDataLoaders = (): {	20✔
85	loaders: Record<CollectionNameString, DataLoader<string,any>>
86	extraLoaders: Record<string,any>
87	} => {
88	const loaders = _.mapObject(getCollectionsByName(), (collection,name) =>	1,857✔
89	new DataLoader(	152,274✔
90	(ids: Array<string>) => findByIds(collection, ids),	211✔
91	{ cache: true, }
92	)
93	) as Record<CollectionNameString, DataLoader<string,any>>;
94
95	return {	1,857✔
96	loaders,
97	extraLoaders: {}
98	};
99	};
100
101
102	export function requestIsFromGreaterWrong(req?: Request): boolean {
103	if (!req) return false;	5!
104	const userAgent = req.headers?.["user-agent"];	×
105	if (!userAgent) return false;	×
106	if (typeof userAgent !== "string") return false;	×
107	return userAgent.startsWith("Dexador");	×
108	}
109
110	export const computeContextFromUser = async ({user, req, res, isSSR}: {	20✔
111	user: DbUser\|null,
112	req?: Request,
113	res?: Response,
114	isSSR: boolean
115	}): Promise<ResolverContext> => {
116	let visitorActivity: DbUserActivity\|null = null;	5✔
117	const clientId = req ? getCookieFromReq(req, "clientId") : null;	5!
118	if ((user \|\| clientId) && (isEAForum \|\| visitorGetsDynamicFrontpage(user))) {	5!
119	visitorActivity = user ?	5✔
120	await UserActivities.findOne({visitorId: user._id, type: 'userId'}) :	5!
121	await UserActivities.findOne({visitorId: clientId, type: 'clientId'});
122	}
123
124	let context: ResolverContext = {	5✔
125	...getCollectionsByName(),
126	...generateDataLoaders(),
127	req: req as any,
128	res,
129	headers: (req as any)?.headers,	5!
130	locale: (req as any)?.headers ? getHeaderLocale((req as any).headers, null) : "en-US",	10!
131	isSSR,
132	isGreaterWrong: requestIsFromGreaterWrong(req),
133	repos: getAllRepos(),
134	clientId,
135	visitorActivity,
136	...await setupAuthToken(user),
137	perfMetric: asyncLocalStorage.getStore()?.requestPerfMetric,	5!
138	};
139
140	if (user) {	5!
141	context.loaders.Users.prime(user._id, user);	5✔
142	}
143
144	return context;	5✔
145	}
146
147	export function configureSentryScope(context: ResolverContext) {
148	const user = context.currentUser;	×
149
150	if (user) {	×
151	configureScope(scope => {	×
152	scope.setUser({	×
153	id: user._id,
154	email: getUserEmail(user),
155	username: context.isGreaterWrong ? `${user.username} (via GreaterWrong)` : user.username ?? undefined,	×
156	});
157	});
158	} else if (context.isGreaterWrong) {	×
159	configureScope(scope => {	×
160	scope.setUser({	×
161	username: context.isGreaterWrong ? `Logged out (via GreaterWrong)` : "Logged out",	×
162	});
163	});
164	}
165	}
166
167	export const getUserFromReq = (req: AnyBecauseTodo): DbUser\|null => {	20✔
168	return req.user	×
169	// return getUser(getAuthToken(req));
170	}
171
172	export async function getContextFromReqAndRes({req, res, isSSR}: {
173	req: Request,
174	res: Response,
175	isSSR: boolean
176	}): Promise<ResolverContext> {
177	const user = getUserFromReq(req);	×
178	const context = await computeContextFromUser({user, req, res, isSSR});	×
179	return context;	×
180	}

ForumMagnum / ForumMagnum / 10694035938

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