8738978301

Committed 18 Apr 2024 01:38PM UTC coverage: 32.066% (-0.009%) from 32.075%

Build # 8738978301

Build Type

Pull #9134

github

Committed by

Will-Howard

Commit Message

revert minor change

Pull Request Pull Request #9134: Improve startup sequence of the client bundle

Run Details

4685 of 37976 branches covered (12.34%)

Branch coverage included in aggregate %.

1 of 39 new or added lines in 4 files covered. (2.56%)

2 existing lines in 2 files now uncovered.

27170 of 61366 relevant lines covered (44.28%)

182.02 hits per line

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

17.91

/packages/lesswrong/server/apolloServer.ts

import { ApolloServer } from 'apollo-server-express';
import { GraphQLError, GraphQLFormattedError } from 'graphql';

import { isDevelopment, getInstanceSettings, getServerPort, isProduction } from '../lib/executionEnvironment';
import { renderWithCache, getThemeOptionsFromReq } from './vulcan-lib/apollo-ssr/renderPage';

import { pickerMiddleware, addStaticRoute } from './vulcan-lib/staticRoutes';
import voyagerMiddleware from 'graphql-voyager/middleware/express';
import { graphiqlMiddleware } from './vulcan-lib/apollo-server/graphiql';
import getPlaygroundConfig from './vulcan-lib/apollo-server/playground';

import { getExecutableSchema } from './vulcan-lib/apollo-server/initGraphQL';
import { getUserFromReq, configureSentryScope, getContextFromReqAndRes } from './vulcan-lib/apollo-server/context';

import universalCookiesMiddleware from 'universal-cookie-express';

import { formatError } from 'apollo-errors';

import * as Sentry from '@sentry/node';
import express from 'express'
import { app } from './expressServer';
import path from 'path'
import { getPublicSettings, getPublicSettingsLoaded } from '../lib/settingsCache';
import { embedAsGlobalVar } from './vulcan-lib/apollo-ssr/renderUtil';
import { addStripeMiddleware } from './stripeMiddleware';
import { addAuthMiddlewares, expressSessionSecretSetting } from './authenticationMiddlewares';
import { addForumSpecificMiddleware } from './forumSpecificMiddleware';
import { addSentryMiddlewares, logGraphqlQueryStarted, logGraphqlQueryFinished } from './logging';
import { addClientIdMiddleware } from './clientIdMiddleware';
import { classesForAbTestGroups } from '../lib/abTestImpl';
import expressSession from 'express-session';
import MongoStore from './vendor/ConnectMongo/MongoStore';
import { ckEditorTokenHandler } from './ckEditor/ckEditorToken';
import { getEAGApplicationData } from './zohoUtils';
import { faviconUrlSetting, isEAForum, testServerSetting, performanceMetricLoggingEnabled, isDatadogEnabled } from '../lib/instanceSettings';
import { parseRoute, parsePath } from '../lib/vulcan-core/appContext';
import { globalExternalStylesheets } from '../themes/globalStyles/externalStyles';
import { addCypressRoutes } from './testingSqlClient';
import { addCrosspostRoutes } from './fmCrosspost/routes';
import { getUserEmail } from "../lib/collections/users/helpers";
import { inspect } from "util";
import { renderJssSheetPreloads } from './utils/renderJssSheetImports';
import { datadogMiddleware } from './datadog/datadogMiddleware';
import { Sessions } from '../lib/collections/sessions';
import { addServerSentEventsEndpoint } from "./serverSentEvents";
import { botRedirectMiddleware } from './botRedirect';
import { hstsMiddleware } from './hsts';
import { getClientBundle } from './utils/bundleUtils';
import { isElasticEnabled } from './search/elastic/elasticSettings';
import ElasticController from './search/elastic/ElasticController';
import type { ApolloServerPlugin, GraphQLRequestContext, GraphQLRequestListener } from 'apollo-server-plugin-base';
import { asyncLocalStorage, closePerfMetric, openPerfMetric, perfMetricMiddleware, setAsyncStoreValue } from './perfMetrics';
import { addAdminRoutesMiddleware } from './adminRoutesMiddleware'
import { createAnonymousContext } from './vulcan-lib';

/**
 * Try to set the response status, but log an error if the headers have already been sent.
 */
const trySetResponseStatus = ({ response, status }: { response: express.Response, status: number; }) => {
  if (!response.headersSent) {
    response.status(status);
  } else if (response.statusCode !== status) {
    const message = `Tried to set status to ${status} but headers have already been sent with status ${response.statusCode}. This may be due to enableResourcePrefetch wrongly being set to true.`;
    if (isProduction) {
      // eslint-disable-next-line no-console
      console.error(message);
    } else {
      throw new Error(message);
    }
  }

  return response;
}

/**
 * If allowed, write the prefetchPrefix to the response so the client can start downloading resources
 */
const maybePrefetchResources = async ({
  request,
  response,
  enableResourcePrefetch,
  prefetchPrefix
}: {
  request: express.Request;
  response: express.Response;
  enableResourcePrefetch?: boolean | ((req: express.Request, res: express.Response, context: ResolverContext) => Promise<boolean>);
  prefetchPrefix: string;
}) => {
  const prefetchResources =
    typeof enableResourcePrefetch === "function"
      ? await enableResourcePrefetch(request, response, createAnonymousContext())
      : enableResourcePrefetch;

  if (prefetchResources) {
    response.setHeader("X-Accel-Buffering", "no"); // force nginx to send start of response immediately
    trySetResponseStatus({ response, status: 200 });
    response.write(prefetchPrefix);
  }
  return prefetchResources;
};

class ApolloServerLogging implements ApolloServerPlugin<ResolverContext> {
  requestDidStart({ request, context }: GraphQLRequestContext<ResolverContext>): GraphQLRequestListener<ResolverContext> {
    const { operationName = 'unknownGqlOperation', query, variables } = request;

    //remove sensitive data from variables such as password
    let filteredVariables = variables;
    if (variables) {
      filteredVariables =  Object.keys(variables).reduce((acc, key) => {
        return (key === 'password') ?  acc : { ...acc, [key]: variables[key] };
      }, {});
    }

    let startedRequestMetric: IncompletePerfMetric;
    if (performanceMetricLoggingEnabled.get()) {
      startedRequestMetric = openPerfMetric({
        op_type: 'query',
        op_name: operationName,
        parent_trace_id: context.perfMetric?.trace_id,
        extra_data: filteredVariables,
        gql_string: query
      });  
    }

    if (query) {
      logGraphqlQueryStarted(operationName, query, variables);
    }
    
    return {
      willSendResponse() { // hook for transaction finished
        if (performanceMetricLoggingEnabled.get()) {
          closePerfMetric(startedRequestMetric);
        }

        if (query) {
          logGraphqlQueryFinished(operationName, query);
        }
      }
    };
  }
}

export type AddMiddlewareType = typeof app.use;

export function startWebserver() {
  const addMiddleware: AddMiddlewareType = (...args: any[]) => app.use(...args);
  const config = { path: '/graphql' };
  const expressSessionSecret = expressSessionSecretSetting.get()

  app.use(universalCookiesMiddleware());

  // Required for passport-auth0, and for login redirects
  if (expressSessionSecret) {
    // express-session middleware, with MongoStore providing it a collection
    // to store stuff in. This adds a `req.session` field to requests, with
    // fancy accessors/setters. The only thing we actually use this for, however,
    // is redirects that happen on return from an OAuth login. So we can scope
    // this to only routes that start with /auth without loss of functionality.
    // We do this because if we don't it adds a webserver-to-database roundtrip
    // (or sometimes three) to each request.
    const store = new MongoStore({
      collection: Sessions,
    });
    app.use('/auth', expressSession({
      secret: expressSessionSecret,
      resave: false,
      saveUninitialized: false,
      store,
      cookie: {
        // NB: Although the Set-Cookie HTTP header takes seconds,
        // express-session wants milliseconds for some reason
        maxAge: 1000 * 60 * 60 * 24 * 365 * 10
      }
    }))
  }

  app.use(express.urlencoded({ extended: true })); // We send passwords + username via urlencoded form parameters
  app.use('/analyticsEvent', express.json({ limit: '50mb' }));
  app.use('/ckeditor-webhook', express.json({ limit: '50mb' }));

  if (isElasticEnabled) {
    // We register this here (before the auth middleware) to avoid blocking
    // search requests whilst waiting to fetch the current user from Postgres,
    // which is never actually used.
    ElasticController.addRoutes(app);
  }

  addStripeMiddleware(addMiddleware);
  // Most middleware need to run after those added by addAuthMiddlewares, so that they can access the user that passport puts on the request.  Be careful if moving it!
  addAuthMiddlewares(addMiddleware);
  addAdminRoutesMiddleware(addMiddleware);
  addForumSpecificMiddleware(addMiddleware);
  addSentryMiddlewares(addMiddleware);
  addClientIdMiddleware(addMiddleware);
  if (isDatadogEnabled) {
    app.use(datadogMiddleware);
  }
  app.use(pickerMiddleware);
  app.use(botRedirectMiddleware);
  app.use(hstsMiddleware);
  
  // create server
  // given options contains the schema
  const apolloServer = new ApolloServer({
    // graphql playground (replacement to graphiql), available on the app path
    playground: getPlaygroundConfig(config.path),
    introspection: true,
    debug: isDevelopment,
    
    schema: getExecutableSchema(),
    formatError: (e: GraphQLError): GraphQLFormattedError => {
      Sentry.captureException(e);
      const {message, ...properties} = e;
      // eslint-disable-next-line no-console
      console.error(`[GraphQLError: ${message}]`, inspect(properties, {depth: null}));
      // TODO: Replace sketchy apollo-errors package with something first-party
      // and that doesn't require a cast here
      return formatError(e) as any;
    },
    //tracing: isDevelopment,
    tracing: false,
    cacheControl: true,
    context: async ({ req, res }: { req: express.Request, res: express.Response }) => {
      const context = await getContextFromReqAndRes(req, res);
      configureSentryScope(context);
      setAsyncStoreValue('resolverContext', context);
      return context;
    },
    plugins: [new ApolloServerLogging()],
  });

  app.use('/graphql', express.json({ limit: '50mb' }));
  app.use('/graphql', express.text({ type: 'application/graphql' }));
  app.use('/graphql', perfMetricMiddleware);
  apolloServer.applyMiddleware({ app })

  addStaticRoute("/js/bundle.js", ({query}, req, res, context) => {
    const {bundleHash, bundleBuffer, bundleBrotliBuffer} = getClientBundle();
    let headers: Record<string,string> = {}
    const acceptBrotli = req.headers['accept-encoding'] && req.headers['accept-encoding'].includes('br')

    if ((query.hash && query.hash !== bundleHash) || (acceptBrotli && bundleBrotliBuffer === null)) {
      // If the query specifies a hash, but it's wrong, this probably means there's a
      // version upgrade in progress, and the SSR and the bundle were handled by servers
      // on different versions. Serve whatever bundle we have (there's really not much
      // else to do), but set the Cache-Control header differently so that it will be
      // fixed on the next refresh.
      //
      // If the client accepts brotli compression but we don't have a valid brotli compressed bundle,
      // that either means we are running locally (in which case chache control isn't important), or that
      // the brotli bundle is currently being built (in which case set a short cache TTL to prevent the CDN
      // from serving the uncompressed bundle for too long).
      headers = {
        "Cache-Control": "public, max-age=60",
        "Content-Type": "text/javascript; charset=utf-8"
      }
    } else {
      headers = {
        "Cache-Control": "public, max-age=604800, immutable",
        "Content-Type": "text/javascript; charset=utf-8"
      }
    }

    if (bundleBrotliBuffer !== null && acceptBrotli) {
      headers["Content-Encoding"] = "br";
      res.writeHead(200, headers);
      res.end(bundleBrotliBuffer);
    } else {
      res.writeHead(200, headers);
      res.end(bundleBuffer);
    }
  });
  // Setup CKEditor Token
  app.use("/ckeditor-token", ckEditorTokenHandler)
  
  // Static files folder
  app.use(express.static(path.join(__dirname, '../../client')))
  app.use(express.static(path.join(__dirname, '../../../public'), {
    setHeaders: (res, requestPath) => {
      const relativePath = path.relative(__dirname, requestPath);
      if (relativePath.startsWith("../../../public/reactionImages")) {
        res.set("Cache-Control", "public, max-age=604800, immutable");
      }
    }
  }))
  
  // Voyager is a GraphQL schema visual explorer
  app.use("/graphql-voyager", voyagerMiddleware({
    endpointUrl: config.path,
  }));
  // Setup GraphiQL
  app.use("/graphiql", graphiqlMiddleware({
    endpointURL: config.path,
    passHeader: "'Authorization': localStorage['Meteor.loginToken']", // eslint-disable-line quotes
  }));
  
  app.get('/api/eag-application-data', async function(req, res, next) {
    if (!isEAForum) {
      next()
      return
    }
    
    const currentUser = await getUserFromReq(req)
    if (!currentUser) {
      res.status(403).send("Not logged in")
      return
    }

    const userEmail = getUserEmail(currentUser)
    if (!userEmail) {
      res.status(403).send("User does not have email")
      return
    }
    
    const eagApp = await getEAGApplicationData(userEmail)
  })

  addCrosspostRoutes(app);
  addCypressRoutes(app);

  if (testServerSetting.get()) {
    app.post('/api/quit', (_req, res) => {
      res.status(202).send('Quiting server');
      process.kill(estrellaPid, 'SIGQUIT');
    })
  }

  addServerSentEventsEndpoint(app);

  app.get('/node_modules/*', (req, res) => {
    // Under some circumstances (I'm not sure exactly what the trigger is), the
    // Chrome JS debugger tries to load a bunch of /node_modules/... paths
    // (presumably for some sort of source mapping). If these were treated as
    // normal pageloads, this would produce a ton of console-log spam, which is
    // disruptive. So instead just serve a minimal 404.
    res.status(404);
    res.end("");
  });

  app.get('*', async (request, response) => {
    response.setHeader("Content-Type", "text/html; charset=utf-8"); // allows compression

    if (!getPublicSettingsLoaded()) throw Error('Failed to render page because publicSettings have not yet been initialized on the server')
    const publicSettingsHeader = `<script> var publicSettings = ${JSON.stringify(getPublicSettings())}</script>`

    const {bundleHash} = getClientBundle();
    const clientScript = `<script async src="/js/bundle.js?hash=${bundleHash}"></script>`
    const instanceSettingsHeader = embedAsGlobalVar("publicInstanceSettings", getInstanceSettings().public);

    // Check whether the requested route has enableResourcePrefetch. If it does,
    // we send HTTP status and headers early, before we actually rendered the
    // page, so that the browser can get started on loading the stylesheet and
    // JS bundle while SSR is still in progress.
    const parsedRoute = parseRoute({
      location: parsePath(request.url)
    });
    
    const user = await getUserFromReq(request);
    const themeOptions = getThemeOptionsFromReq(request, user);
    const jssStylePreload = renderJssSheetPreloads(themeOptions);
    const externalStylesPreload = globalExternalStylesheets.map(url =>
      `<link rel="stylesheet" type="text/css" href="${url}">`
    ).join("");
    
    const faviconHeader = `<link rel="shortcut icon" href="${faviconUrlSetting.get()}"/>`;
    
    // The part of the header which can be sent before the page is rendered.
    // This includes an open tag for <html> and <head> but not the matching
    // close tags, since there's stuff inside that depends on what actually
    // gets rendered. The browser will pick up any references in the still-open
    // tag and start fetching the, without waiting for the closing tag.
    const prefetchPrefix = (
      '<!doctype html>\n'
      + '<html lang="en">\n'
      + '<head>\n'
        + jssStylePreload
        + externalStylesPreload
        + instanceSettingsHeader
        + faviconHeader
        + publicSettingsHeader // Must come before clientScript
        + clientScript
    );

    // Note: this may write to the response
    const prefetchResourcesPromise = maybePrefetchResources({
      request,
      response,
      enableResourcePrefetch: parsedRoute.currentRoute?.enableResourcePrefetch,
      prefetchPrefix
    });

    const renderResultPromise = performanceMetricLoggingEnabled.get()
      ? asyncLocalStorage.run({}, () => renderWithCache(request, response, user))
      : renderWithCache(request, response, user);

    const [prefetchingResources, renderResult] = await Promise.all([prefetchResourcesPromise, renderResultPromise]);

    if (renderResult.aborted) {
      trySetResponseStatus({ response, status: 499 });
      response.end();
      return;
    }

    const {
      ssrBody,
      headers,
      serializedApolloState,
      serializedForeignApolloState,
      jssSheets,
      status,
      redirectUrl,
      renderedAt,
      allAbTestGroups,
    } = renderResult;

    if (!getPublicSettingsLoaded()) throw Error('Failed to render page because publicSettings have not yet been initialized on the server')
    
    // TODO: Move this up into prefetchPrefix. Take the <link> that loads the stylesheet out of renderRequest and move that up too.
    const themeOptionsHeader = embedAsGlobalVar("themeOptions", themeOptions);
    
    // Finally send generated HTML with initial data to the client
    if (redirectUrl) {
      // eslint-disable-next-line no-console
      console.log(`Redirecting to ${redirectUrl}`);
      trySetResponseStatus({ response, status: status || 301 }).redirect(redirectUrl);
    } else {
      trySetResponseStatus({ response, status: status || 200 });

      response.write(
        (prefetchingResources ? '' : prefetchPrefix)
          + headers.join('\n')
          + themeOptionsHeader
          + jssSheets
        + '</head>\n'
        + '<body class="'+classesForAbTestGroups(allAbTestGroups)+'">\n'
          + ssrBody + '\n'
        + '</body>\n'
        + embedAsGlobalVar("ssrRenderedAt", renderedAt) + '\n'
        + serializedApolloState + '\n'
        + serializedForeignApolloState + '\n'
        + '</html>\n')
      response.end();
    }
  })

  // Start Server
  const port = getServerPort();
  const env = process.env.NODE_ENV || 'production'
  const server = app.listen({ port }, () => {
    // eslint-disable-next-line no-console
    return console.info(`Server running on http://localhost:${port} [${env}]`)
  })
  server.keepAliveTimeout = 120000;
  
  // Route used for checking whether the server is ready for an auto-refresh
  // trigger. Added last so that async stuff can't lead to auto-refresh
  // happening before the server is ready.
  addStaticRoute('/api/ready', ({query}, _req, res, next) => {
    res.end('true');
  });
}

1	import { ApolloServer } from 'apollo-server-express';	54✔
2	import { GraphQLError, GraphQLFormattedError } from 'graphql';
3
4	import { isDevelopment, getInstanceSettings, getServerPort, isProduction } from '../lib/executionEnvironment';	18✔
5	import { renderWithCache, getThemeOptionsFromReq } from './vulcan-lib/apollo-ssr/renderPage';	18✔
6
7	import { pickerMiddleware, addStaticRoute } from './vulcan-lib/staticRoutes';	18✔
8	import voyagerMiddleware from 'graphql-voyager/middleware/express';	18✔
9	import { graphiqlMiddleware } from './vulcan-lib/apollo-server/graphiql';	18✔
10	import getPlaygroundConfig from './vulcan-lib/apollo-server/playground';	18✔
11
12	import { getExecutableSchema } from './vulcan-lib/apollo-server/initGraphQL';	18✔
13	import { getUserFromReq, configureSentryScope, getContextFromReqAndRes } from './vulcan-lib/apollo-server/context';	18✔
14
15	import universalCookiesMiddleware from 'universal-cookie-express';	18✔
16
17	import { formatError } from 'apollo-errors';	18✔
18
19	import * as Sentry from '@sentry/node';	18✔
20	import express from 'express'	18✔
21	import { app } from './expressServer';	18✔
22	import path from 'path'	18✔
23	import { getPublicSettings, getPublicSettingsLoaded } from '../lib/settingsCache';	18✔
24	import { embedAsGlobalVar } from './vulcan-lib/apollo-ssr/renderUtil';	18✔
25	import { addStripeMiddleware } from './stripeMiddleware';	18✔
26	import { addAuthMiddlewares, expressSessionSecretSetting } from './authenticationMiddlewares';	18✔
27	import { addForumSpecificMiddleware } from './forumSpecificMiddleware';	18✔
28	import { addSentryMiddlewares, logGraphqlQueryStarted, logGraphqlQueryFinished } from './logging';	18✔
29	import { addClientIdMiddleware } from './clientIdMiddleware';	18✔
30	import { classesForAbTestGroups } from '../lib/abTestImpl';	18✔
31	import expressSession from 'express-session';	18✔
32	import MongoStore from './vendor/ConnectMongo/MongoStore';	18✔
33	import { ckEditorTokenHandler } from './ckEditor/ckEditorToken';	18✔
34	import { getEAGApplicationData } from './zohoUtils';	18✔
35	import { faviconUrlSetting, isEAForum, testServerSetting, performanceMetricLoggingEnabled, isDatadogEnabled } from '../lib/instanceSettings';	18✔
36	import { parseRoute, parsePath } from '../lib/vulcan-core/appContext';	18✔
37	import { globalExternalStylesheets } from '../themes/globalStyles/externalStyles';	18✔
38	import { addCypressRoutes } from './testingSqlClient';	18✔
39	import { addCrosspostRoutes } from './fmCrosspost/routes';	18✔
40	import { getUserEmail } from "../lib/collections/users/helpers";	18✔
41	import { inspect } from "util";	18✔
42	import { renderJssSheetPreloads } from './utils/renderJssSheetImports';	18✔
43	import { datadogMiddleware } from './datadog/datadogMiddleware';	18✔
44	import { Sessions } from '../lib/collections/sessions';	18✔
45	import { addServerSentEventsEndpoint } from "./serverSentEvents";	18✔
46	import { botRedirectMiddleware } from './botRedirect';	18✔
47	import { hstsMiddleware } from './hsts';	18✔
48	import { getClientBundle } from './utils/bundleUtils';	18✔
49	import { isElasticEnabled } from './search/elastic/elasticSettings';	18✔
50	import ElasticController from './search/elastic/ElasticController';	18✔
51	import type { ApolloServerPlugin, GraphQLRequestContext, GraphQLRequestListener } from 'apollo-server-plugin-base';
52	import { asyncLocalStorage, closePerfMetric, openPerfMetric, perfMetricMiddleware, setAsyncStoreValue } from './perfMetrics';	18✔
53	import { addAdminRoutesMiddleware } from './adminRoutesMiddleware'	18✔
54	import { createAnonymousContext } from './vulcan-lib';	18✔
55
56	/**
57	* Try to set the response status, but log an error if the headers have already been sent.
58	*/
59	const trySetResponseStatus = ({ response, status }: { response: express.Response, status: number; }) => {	18✔
60	if (!response.headersSent) {	×
61	response.status(status);	×
62	} else if (response.statusCode !== status) {	×
63	const message = `Tried to set status to ${status} but headers have already been sent with status ${response.statusCode}. This may be due to enableResourcePrefetch wrongly being set to true.`;	×
64	if (isProduction) {	×
65	// eslint-disable-next-line no-console
66	console.error(message);	×
67	} else {
68	throw new Error(message);	×
69	}
70	}
71
72	return response;	×
73	}
74
75	/**
76	* If allowed, write the prefetchPrefix to the response so the client can start downloading resources
77	*/
78	const maybePrefetchResources = async ({	18✔
79	request,
80	response,
81	enableResourcePrefetch,
82	prefetchPrefix
83	}: {
84	request: express.Request;
85	response: express.Response;
86	enableResourcePrefetch?: boolean \| ((req: express.Request, res: express.Response, context: ResolverContext) => Promise<boolean>);
87	prefetchPrefix: string;
88	}) => {
89	const prefetchResources =
90	typeof enableResourcePrefetch === "function"	×
91	? await enableResourcePrefetch(request, response, createAnonymousContext())	×
92	: enableResourcePrefetch;
93
94	if (prefetchResources) {	×
95	response.setHeader("X-Accel-Buffering", "no"); // force nginx to send start of response immediately	×
96	trySetResponseStatus({ response, status: 200 });	×
97	response.write(prefetchPrefix);	×
98	}
99	return prefetchResources;	×
100	};
101
102	class ApolloServerLogging implements ApolloServerPlugin<ResolverContext> {
103	requestDidStart({ request, context }: GraphQLRequestContext<ResolverContext>): GraphQLRequestListener<ResolverContext> {
104	const { operationName = 'unknownGqlOperation', query, variables } = request;	×
105
106	//remove sensitive data from variables such as password
107	let filteredVariables = variables;	×
108	if (variables) {	×
109	filteredVariables = Object.keys(variables).reduce((acc, key) => {	×
110	return (key === 'password') ? acc : { ...acc, [key]: variables[key] };	×
111	}, {});
112	}
113
114	let startedRequestMetric: IncompletePerfMetric;
115	if (performanceMetricLoggingEnabled.get()) {	×
116	startedRequestMetric = openPerfMetric({	×
117	op_type: 'query',
118	op_name: operationName,
119	parent_trace_id: context.perfMetric?.trace_id,	×
120	extra_data: filteredVariables,
121	gql_string: query
122	});
123	}
124
125	if (query) {	×
126	logGraphqlQueryStarted(operationName, query, variables);	×
127	}
128
129	return {	×
130	willSendResponse() { // hook for transaction finished
131	if (performanceMetricLoggingEnabled.get()) {	×
132	closePerfMetric(startedRequestMetric);	×
133	}
134
135	if (query) {	×
136	logGraphqlQueryFinished(operationName, query);	×
137	}
138	}
139	};
140	}
141	}
142
143	export type AddMiddlewareType = typeof app.use;
144
145	export function startWebserver() {
146	const addMiddleware: AddMiddlewareType = (...args: any[]) => app.use(...args);	×
147	const config = { path: '/graphql' };	×
148	const expressSessionSecret = expressSessionSecretSetting.get()	×
149
150	app.use(universalCookiesMiddleware());	×
151
152	// Required for passport-auth0, and for login redirects
153	if (expressSessionSecret) {	×
154	// express-session middleware, with MongoStore providing it a collection
155	// to store stuff in. This adds a `req.session` field to requests, with
156	// fancy accessors/setters. The only thing we actually use this for, however,
157	// is redirects that happen on return from an OAuth login. So we can scope
158	// this to only routes that start with /auth without loss of functionality.
159	// We do this because if we don't it adds a webserver-to-database roundtrip
160	// (or sometimes three) to each request.
161	const store = new MongoStore({	×
162	collection: Sessions,
163	});
164	app.use('/auth', expressSession({	×
165	secret: expressSessionSecret,
166	resave: false,
167	saveUninitialized: false,
168	store,
169	cookie: {
170	// NB: Although the Set-Cookie HTTP header takes seconds,
171	// express-session wants milliseconds for some reason
172	maxAge: 1000 * 60 * 60 * 24 * 365 * 10
173	}
174	}))
175	}
176
177	app.use(express.urlencoded({ extended: true })); // We send passwords + username via urlencoded form parameters	×
178	app.use('/analyticsEvent', express.json({ limit: '50mb' }));	×
179	app.use('/ckeditor-webhook', express.json({ limit: '50mb' }));	×
180
181	if (isElasticEnabled) {	×
182	// We register this here (before the auth middleware) to avoid blocking
183	// search requests whilst waiting to fetch the current user from Postgres,
184	// which is never actually used.
185	ElasticController.addRoutes(app);	×
186	}
187
188	addStripeMiddleware(addMiddleware);	×
189	// Most middleware need to run after those added by addAuthMiddlewares, so that they can access the user that passport puts on the request. Be careful if moving it!
190	addAuthMiddlewares(addMiddleware);	×
191	addAdminRoutesMiddleware(addMiddleware);	×
192	addForumSpecificMiddleware(addMiddleware);	×
193	addSentryMiddlewares(addMiddleware);	×
194	addClientIdMiddleware(addMiddleware);	×
195	if (isDatadogEnabled) {	×
196	app.use(datadogMiddleware);	×
197	}
198	app.use(pickerMiddleware);	×
199	app.use(botRedirectMiddleware);	×
200	app.use(hstsMiddleware);	×
201
202	// create server
203	// given options contains the schema
204	const apolloServer = new ApolloServer({	×
205	// graphql playground (replacement to graphiql), available on the app path
206	playground: getPlaygroundConfig(config.path),
207	introspection: true,
208	debug: isDevelopment,
209
210	schema: getExecutableSchema(),
211	formatError: (e: GraphQLError): GraphQLFormattedError => {
212	Sentry.captureException(e);	×
213	const {message, ...properties} = e;	×
214	// eslint-disable-next-line no-console
215	console.error(`[GraphQLError: ${message}]`, inspect(properties, {depth: null}));	×
216	// TODO: Replace sketchy apollo-errors package with something first-party
217	// and that doesn't require a cast here
218	return formatError(e) as any;	×
219	},
220	//tracing: isDevelopment,
221	tracing: false,
222	cacheControl: true,
223	context: async ({ req, res }: { req: express.Request, res: express.Response }) => {
224	const context = await getContextFromReqAndRes(req, res);	×
225	configureSentryScope(context);	×
226	setAsyncStoreValue('resolverContext', context);	×
227	return context;	×
228	},
229	plugins: [new ApolloServerLogging()],
230	});
231
232	app.use('/graphql', express.json({ limit: '50mb' }));	×
233	app.use('/graphql', express.text({ type: 'application/graphql' }));	×
234	app.use('/graphql', perfMetricMiddleware);	×
235	apolloServer.applyMiddleware({ app })	×
236
237	addStaticRoute("/js/bundle.js", ({query}, req, res, context) => {	×
238	const {bundleHash, bundleBuffer, bundleBrotliBuffer} = getClientBundle();	×
239	let headers: Record<string,string> = {}	×
240	const acceptBrotli = req.headers['accept-encoding'] && req.headers['accept-encoding'].includes('br')	×
241
242	if ((query.hash && query.hash !== bundleHash) \|\| (acceptBrotli && bundleBrotliBuffer === null)) {	×
243	// If the query specifies a hash, but it's wrong, this probably means there's a
244	// version upgrade in progress, and the SSR and the bundle were handled by servers
245	// on different versions. Serve whatever bundle we have (there's really not much
246	// else to do), but set the Cache-Control header differently so that it will be
247	// fixed on the next refresh.
248	//
249	// If the client accepts brotli compression but we don't have a valid brotli compressed bundle,
250	// that either means we are running locally (in which case chache control isn't important), or that
251	// the brotli bundle is currently being built (in which case set a short cache TTL to prevent the CDN
252	// from serving the uncompressed bundle for too long).
253	headers = {	×
254	"Cache-Control": "public, max-age=60",
255	"Content-Type": "text/javascript; charset=utf-8"
256	}
257	} else {
258	headers = {	×
259	"Cache-Control": "public, max-age=604800, immutable",
260	"Content-Type": "text/javascript; charset=utf-8"
261	}
262	}
263
264	if (bundleBrotliBuffer !== null && acceptBrotli) {	×
265	headers["Content-Encoding"] = "br";	×
266	res.writeHead(200, headers);	×
267	res.end(bundleBrotliBuffer);	×
268	} else {
269	res.writeHead(200, headers);	×
270	res.end(bundleBuffer);	×
271	}
272	});
273	// Setup CKEditor Token
274	app.use("/ckeditor-token", ckEditorTokenHandler)	×
275
276	// Static files folder
277	app.use(express.static(path.join(__dirname, '../../client')))	×
278	app.use(express.static(path.join(__dirname, '../../../public'), {	×
279	setHeaders: (res, requestPath) => {
280	const relativePath = path.relative(__dirname, requestPath);	×
281	if (relativePath.startsWith("../../../public/reactionImages")) {	×
282	res.set("Cache-Control", "public, max-age=604800, immutable");	×
283	}
284	}
285	}))
286
287	// Voyager is a GraphQL schema visual explorer
288	app.use("/graphql-voyager", voyagerMiddleware({	×
289	endpointUrl: config.path,
290	}));
291	// Setup GraphiQL
292	app.use("/graphiql", graphiqlMiddleware({	×
293	endpointURL: config.path,
294	passHeader: "'Authorization': localStorage['Meteor.loginToken']", // eslint-disable-line quotes
295	}));
296
297	app.get('/api/eag-application-data', async function(req, res, next) {	×
298	if (!isEAForum) {	×
299	next()	×
300	return	×
301	}
302
303	const currentUser = await getUserFromReq(req)	×
304	if (!currentUser) {	×
305	res.status(403).send("Not logged in")	×
306	return	×
307	}
308
309	const userEmail = getUserEmail(currentUser)	×
310	if (!userEmail) {	×
311	res.status(403).send("User does not have email")	×
312	return	×
313	}
314
315	const eagApp = await getEAGApplicationData(userEmail)	×
316	})
317
318	addCrosspostRoutes(app);	×
319	addCypressRoutes(app);	×
320
321	if (testServerSetting.get()) {	×
322	app.post('/api/quit', (_req, res) => {	×
323	res.status(202).send('Quiting server');	×
324	process.kill(estrellaPid, 'SIGQUIT');	×
325	})
326	}
327
328	addServerSentEventsEndpoint(app);	×
329
330	app.get('/node_modules/*', (req, res) => {	×
331	// Under some circumstances (I'm not sure exactly what the trigger is), the
332	// Chrome JS debugger tries to load a bunch of /node_modules/... paths
333	// (presumably for some sort of source mapping). If these were treated as
334	// normal pageloads, this would produce a ton of console-log spam, which is
335	// disruptive. So instead just serve a minimal 404.
336	res.status(404);	×
337	res.end("");	×
338	});
339
340	app.get('*', async (request, response) => {	×
341	response.setHeader("Content-Type", "text/html; charset=utf-8"); // allows compression	×
342
NEW 343	if (!getPublicSettingsLoaded()) throw Error('Failed to render page because publicSettings have not yet been initialized on the server')	×
NEW 344	const publicSettingsHeader = `<script> var publicSettings = ${JSON.stringify(getPublicSettings())}</script>`	×
345
346	const {bundleHash} = getClientBundle();	×
NEW 347	const clientScript = `<script async src="/js/bundle.js?hash=${bundleHash}"></script>`	×
348	const instanceSettingsHeader = embedAsGlobalVar("publicInstanceSettings", getInstanceSettings().public);	×
349
350	// Check whether the requested route has enableResourcePrefetch. If it does,
351	// we send HTTP status and headers early, before we actually rendered the
352	// page, so that the browser can get started on loading the stylesheet and
353	// JS bundle while SSR is still in progress.
354	const parsedRoute = parseRoute({	×
355	location: parsePath(request.url)
356	});
357
358	const user = await getUserFromReq(request);	×
359	const themeOptions = getThemeOptionsFromReq(request, user);	×
360	const jssStylePreload = renderJssSheetPreloads(themeOptions);	×
361	const externalStylesPreload = globalExternalStylesheets.map(url =>	×
362	`<link rel="stylesheet" type="text/css" href="${url}">`	×
363	).join("");
364
365	const faviconHeader = `<link rel="shortcut icon" href="${faviconUrlSetting.get()}"/>`;	×
366
367	// The part of the header which can be sent before the page is rendered.
368	// This includes an open tag for <html> and <head> but not the matching
369	// close tags, since there's stuff inside that depends on what actually
370	// gets rendered. The browser will pick up any references in the still-open
371	// tag and start fetching the, without waiting for the closing tag.
372	const prefetchPrefix = (
373	'<!doctype html>\n'	×
374	+ '<html lang="en">\n'
375	+ '<head>\n'
376	+ jssStylePreload
377	+ externalStylesPreload
378	+ instanceSettingsHeader
379	+ faviconHeader
380	+ publicSettingsHeader // Must come before clientScript
381	+ clientScript
382	);
383
384	// Note: this may write to the response
385	const prefetchResourcesPromise = maybePrefetchResources({	×
386	request,
387	response,
388	enableResourcePrefetch: parsedRoute.currentRoute?.enableResourcePrefetch,	×
389	prefetchPrefix
390	});
391
392	const renderResultPromise = performanceMetricLoggingEnabled.get()	×
393	? asyncLocalStorage.run({}, () => renderWithCache(request, response, user))	×
394	: renderWithCache(request, response, user);
395
396	const [prefetchingResources, renderResult] = await Promise.all([prefetchResourcesPromise, renderResultPromise]);	×
397
398	if (renderResult.aborted) {	×
399	trySetResponseStatus({ response, status: 499 });	×
400	response.end();	×
401	return;	×
402	}
403
404	const {
405	ssrBody,
406	headers,
407	serializedApolloState,
408	serializedForeignApolloState,
409	jssSheets,
410	status,
411	redirectUrl,
412	renderedAt,
413	allAbTestGroups,
414	} = renderResult;	×
415
416	if (!getPublicSettingsLoaded()) throw Error('Failed to render page because publicSettings have not yet been initialized on the server')	×
417
418	// TODO: Move this up into prefetchPrefix. Take the <link> that loads the stylesheet out of renderRequest and move that up too.
419	const themeOptionsHeader = embedAsGlobalVar("themeOptions", themeOptions);	×
420
421	// Finally send generated HTML with initial data to the client
422	if (redirectUrl) {	×
423	// eslint-disable-next-line no-console
424	console.log(`Redirecting to ${redirectUrl}`);	×
425	trySetResponseStatus({ response, status: status \|\| 301 }).redirect(redirectUrl);	×
426	} else {
427	trySetResponseStatus({ response, status: status \|\| 200 });	×
428
429	response.write(	×
430	(prefetchingResources ? '' : prefetchPrefix)	×
431	+ headers.join('\n')
432	+ themeOptionsHeader
433	+ jssSheets
434	+ '</head>\n'
435	+ '<body class="'+classesForAbTestGroups(allAbTestGroups)+'">\n'
436	+ ssrBody + '\n'
437	+ '</body>\n'
438	+ embedAsGlobalVar("ssrRenderedAt", renderedAt) + '\n'
439	+ serializedApolloState + '\n'
440	+ serializedForeignApolloState + '\n'
441	+ '</html>\n')
442	response.end();	×
443	}
444	})
445
446	// Start Server
447	const port = getServerPort();	×
448	const env = process.env.NODE_ENV \|\| 'production'	×
449	const server = app.listen({ port }, () => {	×
450	// eslint-disable-next-line no-console
451	return console.info(`Server running on http://localhost:${port} [${env}]`)	×
452	})
453	server.keepAliveTimeout = 120000;	×
454
455	// Route used for checking whether the server is ready for an auto-refresh
456	// trigger. Added last so that async stuff can't lead to auto-refresh
457	// happening before the server is ready.
458	addStaticRoute('/api/ready', ({query}, _req, res, next) => {	×
459	res.end('true');	×
460	});
461	}

ForumMagnum / ForumMagnum / 8738978301

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