Merge pull request #63 from chomosuke/shangzhel/lifecycle

Implement app lifecycle

server/src/server.ts

@@ -1,9 +1,11 @@
 import { ArgumentParser } from 'argparse';
-import express from 'express';
+import express, { ErrorRequestHandler, RequestHandler } from 'express';
+import { readFile } from 'fs/promises';
 import { createConnection } from 'mongoose';
 import { resolve } from 'path';
 import { env } from 'process';
 import { ApiRouter } from './api/api-router';
+import { HttpStatusError } from './api/HttpStatusError';
 
 interface IArgs {
   dist: string;
@@ -12,6 +14,41 @@ interface IArgs {
   secret: string;
 }
 
+type ServeIndexRequestHandlerAsync =
+  (distPath: string, ...args: Parameters<RequestHandler>) => Promise<void>;
+
+const serveIndexAsync: ServeIndexRequestHandlerAsync = async (distPath, _req, res) => {
+  const index = resolve(distPath, 'index.html');
+  let file: Buffer;
+  try {
+    file = await readFile(index);
+  } catch {
+    throw new HttpStatusError(404);
+  }
+  res.status(200).contentType('.html').send(file);
+};
+
+function serveIndex(distPath: string): RequestHandler {
+  /* eslint-disable-next-line @typescript-eslint/no-shadow */
+  const serveIndex: RequestHandler = (...args) => {
+    serveIndexAsync(distPath, ...args).catch(args[2]);
+  };
+
+  return serveIndex;
+}
+
+/* eslint-disable-next-line @typescript-eslint/no-unused-vars */
+const errorHandler: ErrorRequestHandler = (err, _req, res, _next) => {
+  if (err) {
+    if (err instanceof HttpStatusError) {
+      res.status(err.code).send(err.message);
+      return;
+    }
+  }
+
+  res.sendStatus(500);
+};
+
 async function main() {
   const parser = new ArgumentParser();
   parser.add_argument('-d', '--dist');
@@ -36,6 +73,8 @@ async function main() {
 
   app.use('/api', apiRouter.router);
   app.use(dist);
+  app.get('*', serveIndex(distPath));
+  app.use(errorHandler);
 
   console.log(`Listening on port ${port}...`);
   app.listen(port);

shared/src/__tests__/ensure.ts

@@ -0,0 +1,85 @@
+import { ensureArray, ensureObject, ensureType } from '../ensure';
+
+const map = {
+  undefined,
+  number: Number(),
+  bigint: BigInt(Number()),
+  boolean: Boolean(),
+  string: String(),
+  symbol: Symbol('symbol'),
+  object: Object(),
+  function() { },
+};
+
+/* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+function asTypeTag(tag: string): any {
+  return tag;
+}
+
+describe('ensure tests', () => {
+  describe('ensureType tests', () => {
+    describe('Success tests', () => {
+      Object
+        .entries(map)
+        .forEach(([k, v]) => test(k, () => {
+          expect(() => ensureType(v, asTypeTag(k))).not.toThrow();
+        }));
+
+      test('null', () => {
+        expect(() => ensureType(null, 'object')).not.toThrow();
+      });
+    });
+
+    describe('Fail tests', () => {
+      Object
+        .entries(map)
+        .forEach(([k0, v]) => describe(k0, () => {
+          Object
+            .keys(map)
+            .filter((k1) => k0 !== k1)
+            .map((k1) => test(k1, () => {
+              expect(() => ensureType(v, asTypeTag(k1))).toThrow();
+            }));
+        }));
+
+      describe('null', () => {
+        Object
+          .keys(map)
+          .filter((k) => k !== 'object')
+          .map((k) => test(k, () => {
+            expect(() => ensureType(null, asTypeTag(k))).toThrow();
+          }));
+      });
+    });
+  });
+
+  describe('ensureObject tests', () => {
+    test('Success test', () => {
+      expect(() => ensureObject(Object())).not.toThrow();
+    });
+
+    describe('Fail tests', () => {
+      Object
+        .entries(map)
+        .filter(([k]) => k !== 'object')
+        .map(([k, v]) => test(k, () => {
+          expect(() => ensureObject(v)).toThrow();
+        }));
+    });
+  });
+
+  describe('ensureArray tests', () => {
+    test('Success test', () => {
+      expect(() => ensureArray([])).not.toThrow();
+    });
+
+    describe('Fail tests', () => {
+      Object
+        .entries(map)
+        .concat([['null', null]])
+        .map(([k, v]) => test(k, () => {
+          expect(() => ensureArray(v)).toThrow();
+        }));
+    });
+  });
+});

shared/src/ensure.ts

@@ -0,0 +1,33 @@
+import type { TypeOfTag } from 'typescript';
+
+export type AnyUnknown = { [k: string]: unknown };
+
+export function ensureType(value: unknown, type: 'undefined'): undefined;
+export function ensureType(value: unknown, type: 'number'): number;
+export function ensureType(value: unknown, type: 'bigint'): bigint;
+export function ensureType(value: unknown, type: 'boolean'): boolean;
+export function ensureType(value: unknown, type: 'string'): string;
+export function ensureType(value: unknown, type: 'symbol'): symbol;
+export function ensureType(value: unknown, type: 'object'): AnyUnknown | null;
+export function ensureType(value: unknown, type: 'function'): CallableFunction;
+
+export function ensureType(value: unknown, type: TypeOfTag): unknown {
+  if (typeof value !== type) throw new Error(`typeof value is not ${type}`);
+
+  return value;
+}
+
+export function ensureObject(value: unknown): AnyUnknown {
+  if (value == null) throw new Error('value is nullish');
+
+  const ensured = ensureType(value, 'object');
+  if (ensured == null) throw new Error('ensured is null');
+
+  return ensured;
+}
+
+export function ensureArray(value: unknown): unknown[] {
+  if (!(value instanceof Array)) throw new Error(`value is not instanceof ${Array.name}`);
+
+  return value;
+}

shared/src/index.ts

@@ -1 +1,2 @@
 export * from './api-types';
+export * from './ensure';

web/build.mjs

@@ -49,6 +49,7 @@ webpack({
   },
   plugins: [
     new HtmlWebpackPlugin({
+      publicPath: '/',
       title: args.title,
       template: src('index.ejs')
     })

web/package.json

@@ -18,6 +18,7 @@
     "@types/react-router-dom": "^5.1.8",
     "@types/react-test-renderer": "^17.0.1",
     "argparse": "^2.0.1",
+    "buffer": "^6.0.3",
     "history": "^5.0.1",
     "html-webpack-plugin": "^5.3.2",
     "prop-types": "^15.7.2",