Switch from express to web-listener

Author: davidje13

backend/package-lock.json

@@ -6,22 +6,19 @@
     "lint": "tsc && prettier --check .",
     "build": "rm -rf build && rollup --config rollup.config.mjs && cp -r src/static build && chmod +x build/index.js",
     "build-watch": "rollup --watch --config rollup.config.mjs",
-    "start": "npm run build && NODE_ENV=development build/index.js",
     "test": "lean-test --preprocess tsc --parallel"
   },
   "dependencies": {
     "authentication-backend": "1.3.x",
     "collection-storage": "3.x",
-    "express": "5.x",
-    "express-static-gzip": "3.x",
     "ioredis": "5.x",
     "json-immutability-helper": "4.0.x",
     "jwt-simple": "0.5.x",
     "mongodb": "6.x",
     "pg": "8.x",
     "pwd-hasher": "2.x",
-    "shared-reducer": "5.x",
-    "websocket-express": "4.x",
+    "shared-reducer": "6.x",
+    "web-listener": "0.13.2",
     "ws": "8.x"
   },
   "devDependencies": {

backend/package.json

@@ -1,14 +1,13 @@
+import { getAddressURL, Router, sendJSON, WebListener } from 'web-listener';
 import request from 'superwstest';
-import { WebSocketExpress } from 'websocket-express';
 import { TestLogger } from './TestLogger';
 import { testConfig } from './testConfig';
-import { addressToString, testServerRunner } from './testServerRunner';
+import { testServerRunner } from './testServerRunner';
 import type { GiphyResponse } from '../services/GiphyService';
 import { appFactory } from '../app';
 
 describe('API giphy', () => {
   const MOCK_GIPHY = testServerRunner(async () => {
-    const giphyApp = new WebSocketExpress();
     const response: GiphyResponse = {
       meta: { status: 200 },
       data: [
@@ -34,20 +33,19 @@ describe('API giphy', () => {
       ],
       pagination: {},
     };
-    giphyApp.use(WebSocketExpress.urlencoded({ extended: false }));
-    giphyApp.get('/gifs/search', (_, res) => {
-      res.json(response);
-    });
+    const giphyApp = new WebListener(
+      new Router().get('/gifs/search', (_, res) => sendJSON(res, response)),
+    );
 
-    return { run: giphyApp.createServer() };
+    return { run: giphyApp };
   });
 
   const PROPS = testServerRunner(async (getTyped) => {
     const app = await appFactory(
       new TestLogger(),
       testConfig({
         giphy: {
-          baseUrl: addressToString(getTyped(MOCK_GIPHY).server.address()),
+          baseUrl: getAddressURL(getTyped(MOCK_GIPHY).server.address()),
           apiKey: 'my-giphy-key',
         },
       }),

backend/src/api-tests/giphy.test.ts

@@ -94,7 +94,7 @@ describe('API retros', () => {
       expect(response.body.token).toBeTruthy();
     });
 
-    it('responds HTTP Bad Request if data is missing', async (props) => {
+    it('responds HTTP Unprocessable Entity if data is missing', async (props) => {
       const { server, hooks } = props.getTyped(PROPS);
 
       const userToken = getUserToken(hooks, 'me');
@@ -103,9 +103,9 @@ describe('API retros', () => {
         .post('/api/retros')
         .send({ slug: 'new-retro', name: 'Meh' })
         .set('Authorization', `Bearer ${userToken}`)
-        .expect(400);
+        .expect(422);
 
-      expect(response.body.error).toEqual('Expected string');
+      expect(response.body.error).toEqual('Expected string at .password');
     });
 
     it('responds HTTP Bad Request if data is blank', async (props) => {

backend/src/api-tests/retros.test.ts

@@ -1,22 +1,27 @@
-import { WebSocketExpress } from 'websocket-express';
+import {
+  getAddressURL,
+  requestHandler,
+  sendJSON,
+  WebListener,
+} from 'web-listener';
 import request from 'superwstest';
 import jwt from 'jwt-simple';
 import { TestLogger } from './TestLogger';
 import { testConfig } from './testConfig';
-import { testServerRunner, addressToString } from './testServerRunner';
+import { testServerRunner } from './testServerRunner';
 import { appFactory } from '../app';
 
 describe('/api/sso/service', () => {
   const MOCK_SSO = testServerRunner(() => {
-    const ssoApp = new WebSocketExpress();
-    ssoApp.use(WebSocketExpress.urlencoded({ extended: false }));
-    ssoApp.get('/', (_, res) => {
-      res.json({
-        aud: 'my-client-id',
-        sub: 'my-external-id',
-      });
-    });
-    return { run: ssoApp.createServer() };
+    const ssoApp = new WebListener(
+      requestHandler((_, res) =>
+        sendJSON(res, {
+          aud: 'my-client-id',
+          sub: 'my-external-id',
+        }),
+      ),
+    );
+    return { run: ssoApp };
   });
 
   const APP = testServerRunner(async (getTyped) => ({
@@ -27,7 +32,7 @@ describe('/api/sso/service', () => {
           google: {
             clientId: 'my-client-id',
             authUrl: 'foo',
-            tokenInfoUrl: addressToString(getTyped(MOCK_SSO).server.address()),
+            tokenInfoUrl: getAddressURL(getTyped(MOCK_SSO).server.address()),
           },
         },
       }),

backend/src/api-tests/sso.test.ts

@@ -1,9 +1,9 @@
-import { WebSocketExpress } from 'websocket-express';
 import request from 'superwstest';
 import { TestLogger } from './TestLogger';
 import { testConfig } from './testConfig';
-import { testServerRunner, addressToString } from './testServerRunner';
+import { testServerRunner } from './testServerRunner';
 import { appFactory } from '../app';
+import { getAddressURL, requestHandler, WebListener } from 'web-listener';
 
 describe('API static content', () => {
   describe('Embedded', () => {
@@ -18,7 +18,7 @@ describe('API static content', () => {
         .get('/')
         .expect(200)
         .expect('Content-Type', /text\/html/)
-        .expect('Vary', 'Accept-Encoding');
+        .expect('Vary', 'accept-encoding');
 
       expect(response.text).toContain('<title>Example Static Resource</title>');
     });
@@ -43,7 +43,7 @@ describe('API static content', () => {
         .expect(200)
         .expect('Content-Type', /text\/html/)
         .expect('Content-Encoding', 'gzip')
-        .expect('Vary', 'Accept-Encoding');
+        .expect('Vary', 'accept-encoding');
 
       expect(response.text).toContain(
         '<title>Example Compressed Static Resource</title>',
@@ -57,7 +57,7 @@ describe('API static content', () => {
         .get('/foobar')
         .expect(200)
         .expect('Content-Type', /text\/html/)
-        .expect('Vary', 'Accept-Encoding');
+        .expect('Vary', 'accept-encoding');
 
       expect(response.text).toContain('<title>Example Static Resource</title>');
     });
@@ -71,7 +71,7 @@ describe('API static content', () => {
         .expect(200)
         .expect('Content-Type', /text\/html/)
         .expect('Content-Encoding', 'gzip')
-        .expect('Vary', 'Accept-Encoding');
+        .expect('Vary', 'accept-encoding');
 
       expect(response.text).toContain('<title>Example Static Resource</title>');
     });
@@ -84,7 +84,7 @@ describe('API static content', () => {
         .expect(200);
 
       const vary = response.header['vary'] || '';
-      expect(vary).not(toContain('Content-Type'));
+      expect(vary).not(toContain('content-type'));
     });
 
     it('adds common headers', async (props) => {
@@ -134,18 +134,17 @@ describe('API static content', () => {
 
   describe('Proxy', () => {
     const PROXY = testServerRunner(() => {
-      const proxyApp = new WebSocketExpress();
-      proxyApp.get('/', (_, res) => {
-        res.send('proxied content here');
-      });
-      return { run: proxyApp.createServer() };
+      const proxyApp = new WebListener(
+        requestHandler((_, res) => res.end('proxied content here')),
+      );
+      return { run: proxyApp };
     });
 
     const PROPS = testServerRunner(async (getTyped) => ({
       run: await appFactory(
         new TestLogger(),
         testConfig({
-          forwardHost: addressToString(getTyped(PROXY).server.address()),
+          forwardHost: getAddressURL(getTyped(PROXY).server.address()),
         }),
       ),
     }));

backend/src/api-tests/static.test.ts

@@ -16,7 +16,7 @@ const baseTestConfig: ConfigT = {
   serverBindAddress: '',
   trustProxy: false,
   log: { file: '' },
-  analytics: { eventDetail: 'none', clientErrorDetail: 'none' },
+  analytics: { eventDetail: 'none', clientErrorDetail: 'message' },
   password: { workFactor: 1, secretPepper: '' },
   passwordCheck: { baseUrl: '' },
   token: { secretPassphrase: '' },

backend/src/api-tests/testConfig.ts

@@ -1,45 +1,32 @@
 import type { Server } from 'node:http';
-import type { AddressInfo } from 'node:net';
+import { type WebListener } from 'web-listener';
 import type { TypedParameter } from 'lean-test';
 import { App } from '../app';
+import type { TestLogger } from './TestLogger';
 
-type Runnable = Server | App;
+type Runnable = WebListener | App;
 type MaybePromise<T> = T | Promise<T>;
 
-export function addressToString(addr: AddressInfo | string | null): string {
-  if (!addr) {
-    throw new Error('Test server is not running');
-  }
-  if (typeof addr === 'string') {
-    return addr;
-  }
-  const { address, family, port } = addr;
-  const host = family === 'IPv6' ? `[${address}]` : address;
-  return `http://${host}:${port}`;
-}
-
-export const testServerRunner = <T extends { run: Runnable }>(
+export const testServerRunner = <
+  T extends { run: Runnable; logger?: TestLogger },
+>(
   serverFn: (getTyped: <T>(key: TypedParameter<T>) => T) => MaybePromise<T>,
 ) =>
   beforeEach<{ server: Server } & Omit<T, 'run'>>(
     async ({ setParameter, getTyped }) => {
-      let server: Server;
       const { run, ...extras } = await serverFn(getTyped);
-      if (run instanceof App) {
-        server = run.express.createServer();
-      } else {
-        server = run;
-      }
+      const listener = run instanceof App ? run.listener : run;
+      const server = await listener.listen(0, '127.0.0.1');
       setParameter({ ...extras, server });
-      await new Promise<void>((resolve) =>
-        server.listen(0, '127.0.0.1', resolve),
-      );
 
       return async () => {
-        await new Promise((resolve) => server.close(resolve));
+        await server.closeWithTimeout('end of test', 0);
         if (run instanceof App) {
           await run.close();
         }
+        for (const log of extras.logger?.logs ?? []) {
+          console.log(log);
+        }
       };
     },
   );