Refactor-to-more-stateless

backend/src/app.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach } from '@jest/globals'
 import request from 'supertest'
-import { ExpressAppInitializer } from './app'
+import { ExpressAppFactory } from './app'
 import { Express } from 'express'
 import { assertErrorResponse } from './test_utils/assert'
 
@@ -13,7 +13,7 @@ describe('API', () => {
   let app: Express
 
   beforeEach(() => {
-    app = ExpressAppInitializer.createNullApp()
+    app = ExpressAppFactory.createNullApp()
   })
 
   it('should return back duty tend to create', async () => {

backend/src/app.ts

@@ -5,39 +5,38 @@ import express, {
   Response,
   Router,
 } from 'express'
-import { DutiesRouterInitializer } from './route/duties'
+import { DutiesRouterFactory } from './route/duties'
 import morgan from 'morgan'
 import { ApplicationContext } from './context'
 
-export class ExpressAppInitializer {
-  private readonly app: Express
-
+export class ExpressAppFactory {
   static async createApp(applicationContext: ApplicationContext) {
     const dutiesRouter =
-      await DutiesRouterInitializer.createRouter(applicationContext)
-    const initializer = new ExpressAppInitializer({
-      dutiesRouter: dutiesRouter,
+      await DutiesRouterFactory.createRouter(applicationContext)
+    return ExpressAppFactory.internalCreateApp({
+      dutiesRouter,
     })
-    return initializer.app
   }
 
   static createNullApp() {
-    const initializer = new ExpressAppInitializer({
-      dutiesRouter: DutiesRouterInitializer.createNullRouter(),
+    return ExpressAppFactory.internalCreateApp({
+      dutiesRouter: DutiesRouterFactory.createNullRouter(),
     })
-    return initializer.app
   }
 
-  private constructor({ dutiesRouter }: { dutiesRouter: Router }) {
-    this.app = express()
-    this.setPreRoutingMiddlewares()
-    this.app.use('/duties', dutiesRouter)
+  private static internalCreateApp({ dutiesRouter }: { dutiesRouter: Router }) {
+    const app = express()
+    this.setPreRoutingMiddlewares(app)
+
+    app.use('/duties', dutiesRouter)
+
+    return app
   }
 
-  private setPreRoutingMiddlewares() {
-    this.app.use(morgan('tiny'))
-    this.app.use(allowCors)
-    this.app.use(express.json())
+  private static setPreRoutingMiddlewares(app: Express) {
+    app.use(morgan('tiny'))
+    app.use(allowCors)
+    app.use(express.json())
   }
 }
 

backend/src/index.ts

@@ -1,10 +1,10 @@
 import { env } from 'process'
-import { ExpressAppInitializer } from './app'
+import { ExpressAppFactory } from './app'
 import { newApplicationContextFromEnv } from './context'
 
 const port = env.PORT || 8080
 
-ExpressAppInitializer.createApp(newApplicationContextFromEnv())
+ExpressAppFactory.createApp(newApplicationContextFromEnv())
   .then((app) => {
     app.listen(port, () => {
       console.log(`Server running on port ${port}`)

backend/src/route/duties.ts

@@ -8,30 +8,29 @@ import { Duty } from '../models/duty'
 import { ApplicationContext } from '../context'
 import { RouteErrorHandler } from './util'
 import { createRouter } from './route'
-import { Router } from 'express'
-
-export class DutiesRouterInitializer {
-  private router: Router
-
-  private dutyRepository: DutyRepository
 
+export class DutiesRouterFactory {
   static async createRouter(applicationContext: ApplicationContext) {
     const dutyRepository = await PostgresDutyRepository.create(
       applicationContext.postgresContext,
     )
-    return new DutiesRouterInitializer({ dutyRepository }).router
+    return new DutiesRouterFactory({ dutyRepository }).createRouter()
   }
 
   static createNullRouter() {
-    return new DutiesRouterInitializer({
+    return new DutiesRouterFactory({
       dutyRepository: new InMemoryDutyRepository(),
-    }).router
+    }).createRouter()
   }
 
+  private dutyRepository: DutyRepository
+
   private constructor({ dutyRepository }: { dutyRepository: DutyRepository }) {
     this.dutyRepository = dutyRepository
+  }
 
-    const router = createRouter([
+  private createRouter() {
+    return createRouter([
       {
         path: '/',
         method: 'post',
@@ -58,8 +57,6 @@ export class DutiesRouterInitializer {
         handler: this.deleteDuty,
       },
     ])
-
-    this.router = router
   }
 
   private createDuty = async (req: Request, res: Response) => {