refactor: upgrade with routing-controller

Author: WittBulter

app.ts

@@ -1,16 +1,14 @@
 import { createServer } from './config/application'
-import { Environment } from './config/environments/index'
+import { Environment } from './config/environments'
 import { Server } from 'http'
 
-module.exports = (async() => {
+module.exports = (async(): Promise<Server> => {
   try {
     const app = await createServer()
-    const server: Server = app.listen(Environment.port, () => {
-      console.log(`Server listening on ${Environment.port}, in ${Environment.identity} mode.`)
+    return app.listen(Environment.port, () => {
+      console.log(`server listening on ${Environment.port}, in ${Environment.identity} mode.`)
     })
-    return server
   } catch (e) {
     console.log(e)
-    process.exit(1)
   }
 })()

app/controllers/index.ts

@@ -1,2 +1,2 @@
-export * from './session.controller'
+export { SessionsController } from './sessions.controller'
 

app/controllers/session.controller.ts

@@ -0,0 +1,27 @@
+import { Sessions } from '../entities'
+import { SessionsService } from '../services'
+import { Interceptors } from '../helpers'
+import { Body, Get, JsonController, Post, QueryParam, UseInterceptor } from 'routing-controllers'
+
+
+@JsonController()
+export class SessionsController {
+  
+  constructor(
+    private sessionsService: SessionsService,
+  ) {
+  }
+  
+  
+  @Get('/sessions')
+  @UseInterceptor(Interceptors.MessageInterceptor)
+  async session(@QueryParam('username') username: string): Promise<any> {
+    return 'hello'
+  }
+  
+  @Post('/sessions')
+  async create(@Body() session: Sessions): Promise<any> {
+    const created = await this.sessionsService.create(session)
+    return { message: 'ok', created }
+  }
+}

app/controllers/sessions.controller.ts

@@ -0,0 +1,2 @@
+export * from './sessions.entity'
+

app/entities/index.ts

@@ -0,0 +1,30 @@
+import { MinLength, IsNotEmpty } from 'class-validator'
+import {
+  Entity, BaseEntity, ObjectIdColumn, CreateDateColumn, UpdateDateColumn,
+} from 'typeorm'
+
+/**
+ * All validator can be applied to all controllers.
+ * Reference document: https://github.com/typestack/class-validator
+ * How to auto validaing? see: https://github.com/typestack/routing-controllers#auto-validating-action-params
+ */
+
+@Entity()
+export class Sessions extends BaseEntity {
+  
+  @ObjectIdColumn()
+  id: string
+  
+  @MinLength(4, { message: 'username too short' })
+  @IsNotEmpty({ message: 'must include username' })
+  username: string
+  
+  @MinLength(10)
+  token: string
+  
+  @CreateDateColumn()
+  created_at: Date
+  
+  @UpdateDateColumn()
+  updated_at: Date
+}

app/entities/sessions.entity.ts

@@ -0,0 +1,5 @@
+import * as Interceptors from './interceptors'
+
+export {
+  Interceptors,
+}

app/helpers/.gitkeep

@@ -0,0 +1 @@
+export { MessageInterceptor } from './message'

app/helpers/index.ts

@@ -0,0 +1,10 @@
+import { Action, InterceptorInterface } from 'routing-controllers'
+
+
+export class MessageInterceptor implements InterceptorInterface {
+  intercept(action: Action, content: any): any {
+    if (typeof content === 'object') return content
+    return { message: content }
+  }
+}
+

app/helpers/interceptors/index.ts

@@ -1 +1 @@
-export * from './session.service'
+export * from './sessions.service'

app/helpers/interceptors/message.ts

@@ -0,0 +1,17 @@
+import { EntityManager, getMongoRepository, MongoRepository } from 'typeorm'
+import { Service } from 'typedi'
+import { Sessions } from '../entities'
+
+@Service()
+export class SessionsService {
+  repository: MongoRepository<Sessions>
+  
+  constructor() {
+    this.repository = getMongoRepository(Sessions)
+  }
+  
+  async create(session: Sessions): Promise<Sessions> {
+    return await this.repository.save(session)
+  }
+  
+}

app/models/index.ts

@@ -0,0 +1,14 @@
+version: "2"
+services:
+  koa_ex.mongo:
+    image: tutum/mongodb:3.0
+    ports:
+    - "27017:27017"
+    - "28017:28017"
+    restart: always
+    volumes:
+      - koa_ex_db:/data/db
+    env_file:
+      - ./variables.env
+volumes:
+  koa_ex_db:

app/models/session.model.ts

@@ -1,24 +1,26 @@
+import 'reflect-metadata'
 import * as Koa from 'koa'
-import * as kcors from 'kcors'
-import * as bodyParser from 'koa-bodyparser'
-import * as logger from 'koa-logger'
-import { KoaCustomResponse } from 'koa-custom-response'
-import { router } from './routers'
-import { Environment } from './environments'
-// import './connection'
+import * as controllers from '../app/controllers'
+import * as interceptors from './interceptors'
+import { Container } from 'typedi'
+import { useKoaServer, useContainer } from 'routing-controllers'
+import { useMiddlewares } from './middlewares'
+import './connection'
 
-export const createServer = async(): Promise<any> => {
-  const app = new Koa()
-  
-  app.use(kcors())
-  
-  Environment.identity !== 'test' && app.use(logger())
-  
-  app.use(bodyParser())
+const objectToArray = (dict: object): Array<any> =>
+  Object.keys(dict).map(name => dict[name])
+
+export const createServer = async(): Promise<Koa> => {
+  const koa: Koa = new Koa()
 
-  app.use(KoaCustomResponse())
+  const app: Koa = useKoaServer<Koa>(koa, {
+    routePrefix: '/apis',
+    validation: true,
+    interceptors: objectToArray(interceptors),
+    controllers: objectToArray(controllers),
+  })
 
-  app.use(router.routes()).use(router.allowedMethods())
+  useContainer(Container)
 
-  return app
+  return useMiddlewares(app)
 }

app/services/index.ts

@@ -1,19 +1,18 @@
-import * as mongoose from 'mongoose'
+import * as entities from '../app/entities'
 import { Environment } from './environments'
+import { createConnection } from 'typeorm'
+const mongo = Environment.mongo
 
-;(<any>mongoose).Promise = global.Promise
-const { user, password, host, port, database } = Environment.mongo
-const path = `mongodb://${user}:${password}@${host}:${port}/${database}`
 
-mongoose.connection
-.once('error', err => console.log(`mongodb connect error:\n${err}`))
-.once('open', () => {
-  Environment.identity !== 'test' && console.log('mongodb connect success')
+createConnection({
+  type: 'mongodb',
+  host: mongo.MONGODB_HOST,
+  port: mongo.MONGODB_PORT,
+  username: mongo.MONGODB_USER,
+  database: mongo.MONGODB_DATABASE,
+  password: mongo.MONGODB_PASS,
+  useNewUrlParser: true,
+  entities: Object.keys(entities).map(name => entities[name]),
 })
-
-mongoose.connect(path)
-.then().catch(e => console.log(e))
-
-export {
-  mongoose,
-}
+.then(() => console.log('mongodb connect success'))
+.catch(error => console.log(error))

app/services/session.service.ts

@@ -1,16 +1,14 @@
 export default {
-  
   identity: 'development',
 
   port: 3000,
 
   mongo: {
-    adapter: 'test',
-    host: '127.0.0.1',
-    port: 27017,
-    user: 'admin',
-    password: 'test',
-    database: 'test',
+    MONGODB_HOST: '127.0.0.1',
+    MONGODB_PORT: 27017,
+    MONGODB_USER: '',
+    MONGODB_PASS: '',
+    MONGODB_DATABASE: '',
   },
 
 }

app/services/sessions.service.ts

@@ -1,21 +1,26 @@
-
 import development from './development'
 import production from './production'
 import test from './test'
+const envFile = require('node-env-file')
+const path = require('path')
 
 const isProd = process.env.NODE_ENV === 'production'
 const isTest = process.env.NODE_ENV === 'test'
 
-if (isProd && (!production.mongo.user || !production.mongo.password)) {
-  console.error('mongo.production need set MONGODB_USER && MONGODB_PASS')
-  process.exit(1)
-}
 
+// use variables.env file first.
 const env = isTest ? test : (isProd ? production : development)
+const secrets = envFile(path.join(__dirname, '../../variables.env'))
+Object.keys(secrets).forEach(name => {
+  if (!secrets[name]) return
+  env.mongo[name] = secrets[name]
+})
 
-if (process.env.IN_DOCKER) {
-  env.mongo.host = 'pro.mongo'
-}
 
+// must be included mongodb configs in prod mode
+if (isProd && (!env.mongo.MONGODB_USER || !env.mongo.MONGODB_PASS)) {
+  console.error('mongo.production need set MONGODB_USER && MONGODB_PASS')
+  process.exit(1)
+}
 
 export const Environment = env

compose.yml

@@ -1,16 +1,13 @@
 export default {
-  
   identity: 'production',
 
   port: 3000,
 
   mongo: {
-    adapter: 'pro',
-    host: '127.0.0.1',
-    port: 27017,
-    user: process.env.MONGODB_USER,
-    password: process.env.MONGODB_PASS,
-    database: process.env.MONGODB_DATABASE,
+    MONGODB_HOST: '127.0.0.1',
+    MONGODB_PORT: 27017,
+    MONGODB_USER: '',
+    MONGODB_PASS: '',
+    MONGODB_DATABASE: '',
   },
-  
 }

config/application.ts

@@ -1,16 +1,14 @@
 export default {
-  
   identity: 'test',
 
   port: 3000,
 
   mongo: {
-    adapter: 'test',
-    host: '127.0.0.1',
-    port: 27017,
-    user: 'test',
-    password: 'test',
-    database: 'test',
+    MONGODB_HOST: '127.0.0.1',
+    MONGODB_PORT: 27017,
+    MONGODB_USER: '',
+    MONGODB_PASS: '',
+    MONGODB_DATABASE: '',
   },
 
 }

config/connection.ts

@@ -0,0 +1,9 @@
+import { InterceptorInterface, Action, Interceptor } from 'routing-controllers'
+
+@Interceptor()
+export class AutoAssignJSONInterceptor implements InterceptorInterface {
+  intercept(action: Action, content: any): any {
+    if (typeof content === 'object') return JSON.stringify(content)
+    return JSON.stringify({ message: content })
+  }
+}