4410939844

Build Type

github

Committed by GitHub

Commit Message

Merge 1f79a241a into 1ca06dc0d

Pull Request Pull Request #880: Bump @typescript-eslint/eslint-plugin from 5.54.1 to 5.55.0

Run Details

499 of 524 branches covered (95.23%)

1119 of 1119 relevant lines covered (100.0%)

385.91 hits per line

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

93.06

/src/server.ts

import express, { ErrorRequestHandler, RequestHandler, json } from "express";
import compression from "compression";
import fileUpload from "express-fileupload";
import https from "https";
import { Logger } from "winston";
import { AppConfig, CommonConfig, ServerConfig } from "./config-type";
import { ResultHandlerError } from "./errors";
import { isLoggerConfig, makeErrorFromAnything } from "./common-helpers";
import { createLogger } from "./logger";
import { defaultResultHandler, lastResortHandler } from "./result-handler";
import { Routing, initRouting } from "./routing";
import createHttpError from "http-errors";

type AnyResultHandler = NonNullable<CommonConfig["errorHandler"]>;

export const createParserFailureHandler =
  (errorHandler: AnyResultHandler, logger: Logger): ErrorRequestHandler =>
  (error, request, response, next) => {
    if (!error) {
      return next();
    }
    errorHandler.handler({
      error,
      request,
      response,
      logger,
      input: request.body,
      output: null,
    });
  };

export const createNotFoundHandler =
  (errorHandler: AnyResultHandler, logger: Logger): RequestHandler =>
  (request, response) => {
    const error = createHttpError(
      404,
      `Can not ${request.method} ${request.path}`
    );
    try {
      errorHandler.handler({
        request,
        response,
        logger,
        error,
        input: null,
        output: null,
      });
    } catch (e) {
      lastResortHandler({
        response,
        logger,
        error: new ResultHandlerError(makeErrorFromAnything(e).message, error),
      });
    }
  };

export function attachRouting(
  config: AppConfig & CommonConfig,
  routing: Routing
) {
  const logger = isLoggerConfig(config.logger)
    ? createLogger(config.logger)
    : config.logger;
  initRouting({ app: config.app, routing, logger, config });
  const errorHandler = config.errorHandler || defaultResultHandler;
  const notFoundHandler = createNotFoundHandler(errorHandler, logger);
  return { notFoundHandler, logger };
}

export function createServer(
  config: ServerConfig & CommonConfig,
  routing: Routing
) {
  const logger = isLoggerConfig(config.logger)
    ? createLogger(config.logger)
    : config.logger;
  const app = express();
  app.disable("x-powered-by");
  const errorHandler = config.errorHandler || defaultResultHandler;
  const compressor = config.server.compression
    ? compression({
        ...(typeof config.server.compression === "object"
          ? config.server.compression
          : {}),
      })
    : undefined;
  const jsonParser = config.server.jsonParser || json();
  const multipartParser = config.server.upload
    ? fileUpload({
        ...(typeof config.server.upload === "object"
          ? config.server.upload
          : {}),
        abortOnLimit: false,
        parseNested: true,
      })
    : undefined;

  const middlewares = ([] as RequestHandler[])
    .concat(compressor || [])
    .concat(jsonParser)
    .concat(multipartParser || []);
  app.use(middlewares);
  app.use(createParserFailureHandler(errorHandler, logger));
  initRouting({ app, routing, logger, config });
  app.use(createNotFoundHandler(errorHandler, logger));

  const httpServer = app.listen(config.server.listen, () => {
    logger.info(`Listening ${config.server.listen}`);
  });

  let httpsServer: https.Server | undefined;
  if (config.https) {
    httpsServer = https
      .createServer(config.https.options, app)
      .listen(config.https.listen, () => {
        logger.info(`Listening ${config.https!.listen}`);
      });
  }

  return { app, httpServer, httpsServer, logger };
}

1	import express, { ErrorRequestHandler, RequestHandler, json } from "express";	168✔
2	import compression from "compression";	168✔
3	import fileUpload from "express-fileupload";	168✔
4	import https from "https";	168✔
5	import { Logger } from "winston";
6	import { AppConfig, CommonConfig, ServerConfig } from "./config-type";
7	import { ResultHandlerError } from "./errors";	168✔
8	import { isLoggerConfig, makeErrorFromAnything } from "./common-helpers";	168✔
9	import { createLogger } from "./logger";	168✔
10	import { defaultResultHandler, lastResortHandler } from "./result-handler";	168✔
11	import { Routing, initRouting } from "./routing";	168✔
12	import createHttpError from "http-errors";	168✔
13
14	type AnyResultHandler = NonNullable<CommonConfig["errorHandler"]>;
15
16	export const createParserFailureHandler =	168✔
17	(errorHandler: AnyResultHandler, logger: Logger): ErrorRequestHandler =>	168✔
18	(error, request, response, next) => {	48✔
19	if (!error) {	16✔
20	return next();	8✔
21	}
22	errorHandler.handler({	8✔
23	error,
24	request,
25	response,
26	logger,
27	input: request.body,
28	output: null,
29	});
30	};
31
32	export const createNotFoundHandler =	168✔
33	(errorHandler: AnyResultHandler, logger: Logger): RequestHandler =>	168✔
34	(request, response) => {	64✔
35	const error = createHttpError(	24✔
36	404,
37	`Can not ${request.method} ${request.path}`
38	);
39	try {	24✔
40	errorHandler.handler({	24✔
41	request,
42	response,
43	logger,
44	error,
45	input: null,
46	output: null,
47	});
48	} catch (e) {
49	lastResortHandler({	8✔
50	response,
51	logger,
52	error: new ResultHandlerError(makeErrorFromAnything(e).message, error),
53	});
54	}
55	};
56
57	export function attachRouting(	168✔
58	config: AppConfig & CommonConfig,
59	routing: Routing
60	) {
61	const logger = isLoggerConfig(config.logger)	8!
62	? createLogger(config.logger)
63	: config.logger;
64	initRouting({ app: config.app, routing, logger, config });	8✔
65	const errorHandler = config.errorHandler \|\| defaultResultHandler;	8!
66	const notFoundHandler = createNotFoundHandler(errorHandler, logger);	8✔
67	return { notFoundHandler, logger };	8✔
68	}
69
70	export function createServer(	168✔
71	config: ServerConfig & CommonConfig,
72	routing: Routing
73	) {
74	const logger = isLoggerConfig(config.logger)	40✔
75	? createLogger(config.logger)
76	: config.logger;
77	const app = express();	40✔
78	app.disable("x-powered-by");	40✔
79	const errorHandler = config.errorHandler \|\| defaultResultHandler;	40✔
80	const compressor = config.server.compression	40✔
81	? compression({
82	...(typeof config.server.compression === "object"	16✔
83	? config.server.compression
84	: {}),
85	})
86	: undefined;
87	const jsonParser = config.server.jsonParser \|\| json();	40✔
88	const multipartParser = config.server.upload	40!
89	? fileUpload({
90	...(typeof config.server.upload === "object"	×
91	? config.server.upload
92	: {}),
93	abortOnLimit: false,
94	parseNested: true,
95	})
96	: undefined;
97
98	const middlewares = ([] as RequestHandler[])	40✔
99	.concat(compressor \|\| [])	72✔
100	.concat(jsonParser)
101	.concat(multipartParser \|\| []);	80✔
102	app.use(middlewares);	40✔
103	app.use(createParserFailureHandler(errorHandler, logger));	40✔
104	initRouting({ app, routing, logger, config });	40✔
105	app.use(createNotFoundHandler(errorHandler, logger));	40✔
106
107	const httpServer = app.listen(config.server.listen, () => {	40✔
108	logger.info(`Listening ${config.server.listen}`);	40✔
109	});
110
111	let httpsServer: https.Server \| undefined;
112	if (config.https) {	40✔
113	httpsServer = https	8✔
114	.createServer(config.https.options, app)
115	.listen(config.https.listen, () => {
116	logger.info(`Listening ${config.https!.listen}`);	8✔
117	});
118	}
119
120	return { app, httpServer, httpsServer, logger };	40✔
121	}

RobinTail / express-zod-api / 4410939844

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