RF to typescript

.env.example

@@ -0,0 +1,5 @@
+DB_HOST=localhost
+DB_PORT=5432
+DB_NAME=user-service-prod
+DB_USER=user-service
+DB_PASSWORD=user-service-password

.gitignore

@@ -1,5 +1,6 @@
 .env*
 output/
+.DS_Store
 .idea/
 .nyc_output/
 coverage/

Makefile

@@ -12,6 +12,7 @@ COMPOSE := docker-compose -f docker-compose.yml
 install:
 	@echo "--- Installing dependencies."
 	npm install
+	npm run build
 
 .PHONY: build
 build:

app/.gitignore

@@ -0,0 +1 @@
+*.js

app/application.ts

@@ -0,0 +1,20 @@
+import UserRouter from "./domain/user/userRouter";
+import GroupRouter from "./domain/group/groupRouter";
+import errorHandler from "./util/errorHandler";
+import ApplicationContext from "./applicationContext";
+
+const express = require('express')();
+const bodyParser = require('body-parser');
+
+const applicationContext = new ApplicationContext();
+
+const userRouter = new UserRouter(applicationContext.userValidation, applicationContext.userController);
+const groupRouter = new GroupRouter(applicationContext.groupValidation, applicationContext.groupController);
+
+express.use(bodyParser.json());
+express.use('/users', userRouter);
+express.use('/groups', groupRouter);
+express.use(errorHandler);
+
+export default express;
+module.exports = express;

app/applicationContext.js → app/applicationContext.ts

@@ -1,16 +1,19 @@
-const knex = require('../database/knex');
-
-const UserRepository = require('app/domain/user/userRepository');
-const UserService    = require('app/domain/user/userService');
-const UserController = require('app/domain/user/userController');
-const UserValidation = require('app/domain/user/userValidation');
+import UserController from "./domain/user/userController";
+import UserValidation from "./domain/user/userValidation";
+import GroupController from "./domain/group/groupController";
+import GroupValidation from "./domain/group/groupValidation";
+import UserRepository from "./domain/user/userRepository";
+import UserService from "./domain/user/userService";
+import GroupRepository from "./domain/group/groupRepository";
+import GroupService from "./domain/group/groupService";
 
-const GroupRepository = require('app/domain/group/groupRepository');
-const GroupService    = require('app/domain/group/groupService');
-const GroupController = require('app/domain/group/groupController');
-const GroupValidation = require('app/domain/group/groupValidation');
+const knex = require('../database/knex');
 
-class ApplicationContext {
+export default class ApplicationContext {
+    public userController: UserController;
+    public userValidation: UserValidation;
+    public groupController: GroupController;
+    public groupValidation: GroupValidation;
 
     constructor() {
         const userRepository = new UserRepository(knex);

app/domain/group/groupController.js → app/domain/group/groupController.ts

@@ -1,31 +1,33 @@
+import GroupService from "./groupService";
+import {Request, Response} from "express";
+
 const HttpStatus = require('http-status-codes');
 
-class GroupController {
-    constructor(groupService) {
-        this.groupService = groupService
+export default class GroupController {
+    constructor(private groupService: GroupService) {
     }
 
-    async getAll(request, response) {
+    async getAll(request: Request, response: Response) {
         const users = await this.groupService.getAll();
         response.status(HttpStatus.OK).json(users);
     }
 
-    async get(request, response) {
+    async get(request: Request, response: Response) {
         const user = await this.groupService.get(request.params.id);
         response.status(HttpStatus.OK).json(user);
     }
 
-    async create(request, response) {
+    async create(request: Request, response: Response) {
         const user = await this.groupService.create(request.body);
         response.status(HttpStatus.CREATED).json(user);
     }
 
-    async update(request, response) {
+    async update(request: Request, response: Response) {
         const user = await this.groupService.update(request.params.id, request.body);
         response.status(HttpStatus.OK).json(user);
     }
 
-    async delete(request, response) {
+    async delete(request: Request, response: Response) {
         await this.groupService.delete(request.params.id);
         response.sendStatus(HttpStatus.NO_CONTENT);
     }

app/domain/group/groupRepository.js → app/domain/group/groupRepository.ts

@@ -1,29 +1,33 @@
+import Knex = require("knex");
+
 const GROUPS = 'Groups';
-const FIELD  = ['id', 'name', 'admin'];
+const FIELD = ['id', 'name', 'admin'];
+
+interface Group {
+}
 
-class GroupRepository {
+export default class GroupRepository {
 
-    constructor(knex) {
-        this.knex = knex;
+    constructor(private knex: Knex) {
     }
 
     getAll() {
         return this.knex.select(FIELD).from(GROUPS);
     }
 
-    get(id) {
+    get(id: number) {
         return this.knex.first(FIELD).from(GROUPS).where({id});
     }
 
-    create(group) {
+    create(group: Group) {
         return this.knex.insert(group, FIELD).into(GROUPS);
     }
 
-    update(id, group) {
+    update(id: number, group: Group) {
         return this.knex.update(group, FIELD).into(GROUPS).where({id});
     }
 
-    delete(id) {
+    delete(id: number) {
         return this.knex.delete().from(GROUPS).where({id: +id});
     }
 

app/domain/group/groupRouter.ts

@@ -0,0 +1,32 @@
+import {NextFunction, Request, Response} from "express";
+import GroupValidation from "./groupValidation";
+import GroupController from "./groupController";
+
+import wrapAsync from "../../util/wrapAsync";
+
+const express = require('express');
+
+export default class GroupRouter extends express.Router {
+
+    constructor(userValidation: GroupValidation, userController: GroupController) {
+        super();
+
+        //FIXME see baind
+        const createUserValidator = wrapAsync((request: Request, response: Response, next: NextFunction) => userValidation.createValidator(request, response, next));
+        const updateUserValidator = wrapAsync((request: Request, response: Response, next: NextFunction) => userValidation.updateValidator(request, response, next));
+
+        const getUsers = wrapAsync((request: Request, response: Response) => userController.getAll(request, response));
+        const getUser = wrapAsync((request: Request, response: Response) => userController.get(request, response));
+        const createUser = wrapAsync((request: Request, response: Response) => userController.create(request, response));
+        const updateUser = wrapAsync((request: Request, response: Response) => userController.update(request, response));
+        const deleteUser = wrapAsync((request: Request, response: Response) => userController.delete(request, response));
+
+        this.get('/', getUsers);
+        this.get('/:id', getUser);
+        this.post('/', createUserValidator, createUser);
+        this.put('/:id', updateUserValidator, updateUser);
+        this.delete('/:id', deleteUser);
+    }
+}
+
+module.exports = GroupRouter;

app/domain/group/groupSchema.ts

@@ -0,0 +1,15 @@
+import Joi from "joi";
+
+export const update = Joi.object()
+    .options({abortEarly: false})
+    .keys({
+        name: Joi.string().required().min(3).label('Group name'),
+        admin: Joi.boolean().optional().label('Admin flag')
+    }).required().label('body');
+
+export const create = update;
+
+module.exports = {
+    create,
+    update
+};

app/domain/group/groupService.js → app/domain/group/groupService.ts

@@ -1,16 +1,21 @@
-const NotFoundError = require('app/error/notFoundError');
+import GroupRepository from "./groupRepository";
 
-class GroupService {
+import NotFoundError from "../../error/notFoundError";
 
-    constructor(groupRepository) {
-        this.groupRepository = groupRepository;
+interface GroupDto {
+    id: number;
+}
+
+export default class GroupService {
+
+    constructor(private groupRepository: GroupRepository) {
     }
 
     async getAll() {
         return this.groupRepository.getAll();
     }
 
-    async get(id) {
+    async get(id: number) {
         const group = await this.groupRepository.get(id);
         if (typeof group === 'undefined') {
             throw new NotFoundError(`No group ${id}`);
@@ -19,13 +24,13 @@ class GroupService {
         return group
     }
 
-    async create(group) {
+    async create(group: GroupDto) {
         // FIXME create new object
         delete group.id;
         return this.groupRepository.create(group);
     }
 
-    async update(id, group) {
+    async update(id: number, group: GroupDto) {
         const existingGroup = await this.groupRepository.get(id);
         if (typeof existingGroup === 'undefined') {
             throw new NotFoundError(`No group ${id}`);
@@ -35,7 +40,7 @@ class GroupService {
         return this.groupRepository.update(id, group);
     }
 
-    async delete(id) {
+    async delete(id: number) {
         const existingGroup = await this.groupRepository.get(id);
         if (typeof existingGroup === 'undefined') {
             throw new NotFoundError(`No group ${id}`);

app/domain/group/groupValidation.ts

@@ -0,0 +1,23 @@
+import {NextFunction, Request, Response} from "express";
+import {create, update} from "./groupSchema";
+
+import joiValidate from "../../util/joiValidate";
+
+import BedRequestError from "../../error/badRequestError";
+
+export default class GroupValidation {
+
+    async createValidator(request: Request, response: Response, next: NextFunction) {
+        await joiValidate(request.body, create, BedRequestError);
+
+        next();
+    }
+
+    async updateValidator(request: Request, response: Response, next: NextFunction) {
+        await joiValidate(request.body, update, BedRequestError);
+
+        next();
+    }
+}
+
+module.exports = GroupValidation;