fix: make givenHttpServerConfig typing compatible with TypeScript 3.6

Signed-off-by: Miroslav Bajtoš <mbajtoss@gmail.com>

Author: bajtos

packages/http-server/src/__tests__/integration/http-server.integration.ts

@@ -15,7 +15,7 @@ import * as fs from 'fs';
 import {IncomingMessage, Server, ServerResponse} from 'http';
 import * as os from 'os';
 import * as path from 'path';
-import {HttpOptions, HttpServer, HttpServerOptions} from '../../';
+import {HttpOptions, HttpServer, HttpsOptions} from '../../';
 
 describe('HttpServer (integration)', () => {
   let server: HttpServer | undefined;
@@ -181,10 +181,7 @@ describe('HttpServer (integration)', () => {
   });
 
   it('supports HTTPS protocol with a pfx file', async () => {
-    const serverOptions = givenHttpServerConfig({
-      usePfx: true,
-    });
-    const httpsServer: HttpServer = givenHttpsServer(serverOptions);
+    const httpsServer: HttpServer = givenHttpsServer({usePfx: true});
     await httpsServer.start();
     const response = await httpsGetAsync(httpsServer.url);
     expect(response.statusCode).to.equal(200);
@@ -279,7 +276,10 @@ describe('HttpServer (integration)', () => {
     usePfx?: boolean;
     host?: string;
   }): HttpServer {
-    const options: HttpServerOptions = {protocol: 'https', host};
+    const options = givenHttpServerConfig<HttpsOptions>({
+      protocol: 'https',
+      host,
+    });
     const certDir = path.resolve(__dirname, '../../../fixtures');
     if (usePfx) {
       const pfxPath = path.join(certDir, 'pfx.pfx');

packages/rest/src/__tests__/integration/rest.server.integration.ts

@@ -672,13 +672,12 @@ paths:
   it('supports HTTPS protocol with key and certificate files', async () => {
     const keyPath = path.join(FIXTURES, 'key.pem');
     const certPath = path.join(FIXTURES, 'cert.pem');
-    const options = {
+    const serverOptions = givenHttpServerConfig({
       port: 0,
       protocol: 'https',
       key: fs.readFileSync(keyPath),
       cert: fs.readFileSync(certPath),
-    };
-    const serverOptions = givenHttpServerConfig(options);
+    });
     const server = await givenAServer({rest: serverOptions});
     server.handler(dummyRequestHandler);
     await server.start();
@@ -689,13 +688,12 @@ paths:
 
   it('supports HTTPS protocol with a pfx file', async () => {
     const pfxPath = path.join(FIXTURES, 'pfx.pfx');
-    const options = {
+    const serverOptions = givenHttpServerConfig({
       port: 0,
-      protocol: 'https',
+      protocol: 'https' as 'https',
       pfx: fs.readFileSync(pfxPath),
       passphrase: 'loopback4',
-    };
-    const serverOptions = givenHttpServerConfig(options);
+    });
     const server = await givenAServer({rest: serverOptions});
     server.handler(dummyRequestHandler);
     await server.start();
@@ -756,13 +754,12 @@ paths:
   it('honors HTTPS config binding after instantiation', async () => {
     const keyPath = path.join(FIXTURES, 'key.pem');
     const certPath = path.join(FIXTURES, 'cert.pem');
-    const options = {
+    const serverOptions = givenHttpServerConfig({
       port: 0,
       protocol: 'https',
       key: undefined,
       cert: undefined,
-    };
-    const serverOptions = givenHttpServerConfig(options);
+    });
     const server = await givenAServer({rest: serverOptions});
 
     server.handler(dummyRequestHandler);

packages/testlab/src/http-server-config.ts

@@ -3,20 +3,29 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import * as path from 'path';
 import {readFileSync} from 'fs';
 import {ServerOptions as HttpsServerOptions} from 'https';
+import {ListenOptions} from 'net';
+import * as path from 'path';
 
 const FIXTURES = path.resolve(__dirname, '../fixtures');
 const DUMMY_TLS_CONFIG = {
   key: readFileSync(path.join(FIXTURES, 'key.pem')),
   cert: readFileSync(path.join(FIXTURES, 'cert.pem')),
 };
 
-export type ConfigRetval<T extends object> = T & {
+export interface HttpOptions extends ListenOptions {
+  protocol?: 'http';
+}
+
+export interface HttpsOptions extends ListenOptions, HttpsServerOptions {
+  protocol: 'https';
+}
+
+export type HostPort = {
   host: string;
   port: number;
-} & HttpsServerOptions;
+};
 
 /**
  * Create an HTTP-server configuration that works well in test environments.
@@ -27,18 +36,18 @@ export type ConfigRetval<T extends object> = T & {
  *
  * @param customConfig - Additional configuration options to apply.
  */
-export function givenHttpServerConfig<T extends object>(
-  customConfig?: T & {protocol?: string},
-): ConfigRetval<T> {
+export function givenHttpServerConfig<T extends HttpOptions | HttpsOptions>(
+  customConfig?: T,
+): HostPort & T {
   const defaults = {
     host: '127.0.0.1',
     port: 0,
     protocol: undefined,
   };
-  const config: ConfigRetval<T> = Object.assign({}, defaults, customConfig);
+  const config = Object.assign({}, defaults, customConfig);
   if (config.host === undefined) config.host = defaults.host;
   if (config.port === undefined) config.port = defaults.port;
-  if (customConfig && customConfig.protocol === 'https') {
+  if (isHttpsConfig(config)) {
     setupTlsConfig(config);
   }
   return config;
@@ -49,3 +58,9 @@ function setupTlsConfig(config: HttpsServerOptions) {
   if ('pfx' in config) return;
   Object.assign(config, DUMMY_TLS_CONFIG);
 }
+
+function isHttpsConfig(
+  config: HttpOptions | HttpsOptions,
+): config is HttpsOptions {
+  return config && config.protocol === 'https';
+}