rf user to tylescript

.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/domain/user/.gitignore

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

app/domain/user/userController.js → app/domain/user/userController.ts

@@ -1,34 +1,38 @@
+import {UserService} from "./userService";
+
 const HttpStatus = require('http-status-codes');
 
-class UserController {
-    constructor(userService) {
-        this.userService = userService
+import {Request, Response} from "express"
+
+export class UserController {
+
+    constructor(private userService: UserService) {
     }
 
-    async getAll(request, response) {
+    async getAll(request: Request, response: Response) {
         const users = await this.userService.getAll();
         response.status(HttpStatus.OK).json(users);
     }
 
-    async get(request, response) {
+    async get(request: Request, response: Response) {
         const user = await this.userService.get(request.params.id);
         response.status(HttpStatus.OK).json(user);
     }
 
-    async create(request, response) {
+    async create(request: Request, response: Response) {
         const user = await this.userService.create(request.body);
         response.status(HttpStatus.CREATED).json(user);
     }
 
-    async update(request, response) {
+    async update(request: Request, response: Response) {
         const user = await this.userService.update(request.params.id, request.body);
         response.status(HttpStatus.OK).json(user);
     }
 
-    async delete(request, response) {
+    async delete(request: Request, response: Response) {
         await this.userService.delete(request.params.id);
         response.sendStatus(HttpStatus.NO_CONTENT);
     }
 }
 
-module.exports = UserController;
+module.exports = UserController;

app/domain/user/userRepository.js → app/domain/user/userRepository.ts

@@ -1,29 +1,33 @@
+import Knex = require("knex");
+
 const USERS = 'Users';
 const FIELD = ['id', 'name', 'login', 'email'];
 
-class UserRepository {
+interface User {
+}
+
+export class UserRepository {
 
-    constructor(knex) {
-        this.knex = knex;
+    constructor(private knex: Knex) {
     }
 
     getAll() {
         return this.knex.select(FIELD).from(USERS);
     }
 
-    get(id) {
+    get(id: number) {
         return this.knex.first(FIELD).from(USERS).where({id});
     }
 
-    create(user) {
+    create(user: User) {
         return this.knex.insert(user, FIELD).into(USERS);
     }
 
-    update(id, user) {
+    update(id: number, user: User) {
         return this.knex.update(user, FIELD).into(USERS).where({id});
     }
 
-    delete(id) {
+    delete(id: number) {
         return this.knex.delete().from(USERS).where({id: +id});
     }
 

app/domain/user/userRouter.ts

@@ -0,0 +1,31 @@
+import {UserValidation} from "./userValidation";
+import {UserController} from "./userController";
+
+const wrapAsync = require('app/util/wrapAsync');
+
+const express = require('express');
+import {Request, Response, NextFunction} from "express"
+
+export class UserRouter extends express.Router {
+
+    constructor(userValidation: UserValidation, userController: UserController) {
+        super();
+
+        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 = UserRouter;

app/domain/user/userSchema.ts

@@ -0,0 +1,27 @@
+import Joi from "joi";
+
+export const create = Joi.object()
+    .options({abortEarly: false})
+    .keys({
+        name: Joi.string().required().min(3).label('User name'),
+        login: Joi.string().required().min(5).label('User login'),
+        email: Joi.string().email().required().label('User email'),
+        password: Joi.string().required().label('User password'),
+        confirmPassword: Joi.string().valid(Joi.ref('password')).required().options({language: {any: {allowOnly: 'must match password'}}}).label('User confirm password')
+    }).required().label('body');
+
+
+export const update = Joi.object()
+    .options({abortEarly: false})
+    .keys({
+        name: Joi.string().required().min(3).label('User name'),
+        login: Joi.string().required().min(5).label('User login'),
+        email: Joi.string().email().required().label('User email'),
+        password: Joi.string().optional().label('User password'),
+        confirmPassword: Joi.string().optional().valid(Joi.ref('password')).optional().options({language: {any: {allowOnly: 'must match password'}}}).label('User confirm password')
+    }).required().label('body');
+
+module.exports = {
+    create,
+    update
+};

app/domain/user/userService.js → app/domain/user/userService.ts

@@ -1,16 +1,22 @@
+import {UserRepository} from "./userRepository";
+
 const NotFoundError = require('app/error/notFoundError');
 
-class UserService {
+interface UserDto {
+    id: number;
+    confirmPassword: number;
+}
+
+export class UserService {
 
-    constructor(userRepository) {
-        this.userRepository = userRepository;
+    constructor(private userRepository: UserRepository) {
     }
 
     async getAll() {
         return this.userRepository.getAll();
     }
 
-    async get(id) {
+    async get(id: number) {
         const user = await this.userRepository.get(id);
         if (typeof user === 'undefined') {
             throw new NotFoundError(`No user ${id}`);
@@ -19,14 +25,14 @@ class UserService {
         return user
     }
 
-    async create(user) {
+    async create(user: UserDto) {
         // FIXME create new object
         delete user.id;
         delete user.confirmPassword;
         return this.userRepository.create(user);
     }
 
-    async update(id, user) {
+    async update(id: number, user: UserDto) {
         const existingUser = await this.userRepository.get(id);
         if (typeof existingUser === 'undefined') {
             throw new NotFoundError(`No user ${id}`);
@@ -37,7 +43,7 @@ class UserService {
         return this.userRepository.update(id, user);
     }
 
-    async delete(id) {
+    async delete(id: number) {
         const existingUser = await this.userRepository.get(id);
         if (typeof existingUser === 'undefined') {
             throw new NotFoundError(`No user ${id}`);

app/domain/user/userValidation.js → app/domain/user/userValidation.ts

@@ -4,19 +4,19 @@ const userSchema = require('app/domain/user/userSchema');
 
 const BedRequestError = require('app/error/badRequestError');
 
-class UserValidation {
+export class UserValidation {
 
-    async createValidator(request, response, next) {
+    async createValidator(request: any, response: any, next: any) {
         await joiValidate(request.body, userSchema.create, BedRequestError);
 
         next();
     }
 
-    async updateValidator(request, response, next) {
+    async updateValidator(request: any, response: any, next: any) {
         await joiValidate(request.body, userSchema.update, BedRequestError);
 
         next();
     }
 }
 
-module.exports = UserValidation;
+module.exports = UserValidation;