Setting up JWT Authentication in Typescript with Express, MongoDB, Babel, Prettier, ESLint, and Husky: Part 2

1
├── src
2
│   ├── bin
3
│   │   └── www.ts
4
│   ├── config
5
│   │   └── db.config.ts
6
│   ├── constants
7
│   │   ├── api.constant.ts
8
│   │   ├── dateformat.constant.ts
9
│   │   ├── http.code.constant.ts
10
│   │   ├── http.reason.constant.ts
11
│   │   ├── message.constant.ts
12
│   │   ├── model.constant.ts
13
│   │   ├── number.constant.ts
14
│   │   ├── path.constant.ts
15
│   │   └── regex.constant.ts
16
│   ├── controllers
17
│   │   ├── auth.controller.ts
18
│   │   └── user.controller.ts
19
│   ├── env
20
│   │   └── variable.env.ts
21
│   ├── interfaces
22
│   │   ├── controller.interface.ts
23
│   │   └── user.interface.ts
24
│   ├── middlewares
25
│   │   ├── authenticated.middleware.ts
26
│   │   ├── error.middleware.ts
27
│   │   └── validation.middleware.ts
28
│   ├── models
29
│   │   └── user.model.ts
30
│   ├── repositories
31
│   │   └── user.repository.ts
32
│   ├── schemas
33
│   │   └── user.schema.ts
34
│   ├── security
35
│   │   └── user.security.ts
36
│   ├── services
37
│   │   ├── auth.service.ts
38
│   │   └── user.service.ts
39
│   ├── types
40
│   │   └── express
41
│   │       └── index.d.ts
42
│   ├── utils
43
│   │   └── exceptions
44
│   │   │   └── http.exception.ts
45
│   │   └── logger.util.ts
46
│   └── validations
47
│       ├── token.validation.ts
48
│       ├── user.validation.ts
49
│       └── variable.validation.ts
50
├── .babelrc
51
├── .env
52
├── .env.example
53
├── .eslintignore
54
├── .eslintrc
55
├── .gitattributes
56
├── .gitignore
57
├── .npmrc
58
├── .nvmrc
59
├── .prettierignore
60
├── .prettierrc
61
├── commitlint.config.js
62
├── package.json
63
├── README.md
64
├── tsconfig.json
65
└── yarn.lock

1
{
2
  ...,
3
  "paths": {
4
    "@/bin/*": [
5
      "bin/*"
6
    ],
7
    "@/config/*": [
8
      "config/*"
9
    ],
10
    "@/constants/*": [
11
      "constants/*"
12
    ],
13
    "@/controllers/*": [
14
      "controllers/*"
15
    ],
16
    "@/env/*": [
17
      "env/*"
18
    ],
19
    "@/interfaces/*": [
20
      "interfaces/*"
21
    ],
22
    "@/middlewares/*": [
23
      "middlewares/*"
24
    ],
25
    "@/models/*": [
26
      "models/*"
27
    ],
28
    "@/repositories/*": [
29
      "repositories/*"
30
    ],
31
    "@/routers/*": [
32
      "routers/*"
33
    ],
34
    "@/schemas/*": [
35
      "schemas/*"
36
    ],
37
    "@/security/*": [
38
      "security/*"
39
    ],
40
    "@/services/*": [
41
      "services/*"
42
    ],
43
    "@/utils/*": [
44
      "utils/*"
45
    ],
46
    "@/validations/*": [
47
      "validations/*"
48
    ],
49
  },
50
}

1
{
2
  ...,
3
    "_moduleAliases": {
4
    "@/bin": "build/bin",
5
    "@/config": "build/config",
6
    "@/constants": "build/constants",
7
    "@/controllers": "build/controllers",
8
    "@/env": "build/env",
9
    "@/interfaces": "build/interfaces",
10
    "@/middlewares": "build/middlewares",
11
    "@/models": "build/models",
12
    "@/repositories": "build/repositories",
13
    "@/routers": "build/routers",
14
    "@/schemas": "build/schemas",
15
    "@/security": "build/security",
16
    "@/services": "build/services",
17
    "@/utils": "build/utils",
18
    "@/validations": "build/validations"
19
  }
20
}

1
import {cleanEnv, str, port} from 'envalid';
2

3
const validate = (): void => {
4
  cleanEnv(process.env, {
5
    NODE_ENV: str({
6
      choices: ['development', 'production'],
7
    }),
8
    PORT: port({default: 3030}),
9
    DATABASE_URL: str(),
10
    JWT_SECRET: str(),
11
    PASS_SECRET: str(),
12
  });
13
};
14

15
export default validate;

1
import 'dotenv/config';
2

3
import VariableValidate from '@/validations/variable.validation';
4

5
class Variable {
6
  public static readonly NODE_ENV: string = process.env.NODE_ENV!;
7

8
  public static readonly PORT: number = Number(process.env.PORT)!;
9

10
  public static readonly DATABASE_URL: string = process.env.DATABASE_URL!;
11

12
  public static readonly JWT_SECRET: string = process.env.JWT_SECRET!;
13

14
  public static readonly PASS_SECRET: string = process.env.PASS_SECRET!;
15

16
  constructor() {
17
    this.initialise();
18
  }
19

20
  private initialise(): void {
21
    VariableValidate();
22
  }
23
}
24

25
export default Variable;

1
class Dateformat {
2
  public static readonly YYYY_MM_DD_HH_MM_SS_MS: string =
3
    'YYYY-MM-DD HH:mm:ss:ms';
4
}
5

6
export default Dateformat;

1
class Path {
2
  public static readonly LOGS_ALL: string = 'logs/all.log';
3

4
  public static readonly LOGS_ERROR: string = 'logs/error.log';
5
}
6
export default Path;

1
import winston from 'winston';
2
import Variable from '@/env/variable.env';
3

4
import ConstantDateFormat from '@/constants/dateformat.constant';
5
import ConstantPath from '@/constants/path.constant';
6

7
const levels = {
8
  error: 0,
9
  warn: 1,
10
  info: 2,
11
  http: 3,
12
  debug: 4,
13
};
14

15
const level = () => {
16
  const env = Variable.NODE_ENV || 'development';
17
  const isDevelopment = env === 'development';
18
  return isDevelopment ? 'debug' : 'warn';
19
};
20

21
const colors = {
22
  error: 'red',
23
  warn: 'yellow',
24
  info: 'green',
25
  http: 'magenta',
26
  debug: 'white',
27
};
28

29
winston.addColors(colors);
30

31
const format = winston.format.combine(
32
  winston.format.timestamp({
33
    format: ConstantDateFormat.YYYY_MM_DD_HH_MM_SS_MS,
34
  }),
35
  winston.format.colorize({all: true}),
36
  winston.format.printf(
37
    (info) => `${info.timestamp} ${info.level}: ${info.message}`,
38
  ),
39
);
40

41
const transports = [
42
  new winston.transports.Console(),
43
  new winston.transports.File({
44
    filename: ConstantPath.LOGS_ERROR,
45
    level: 'error',
46
  }),
47
  new winston.transports.File({filename: ConstantPath.LOGS_ALL}),
48
];
49

50
const logger = winston.createLogger({
51
  level: level(),
52
  levels,
53
  format,
54
  transports,
55
});
56

57
export default logger;

1
import {connect} from 'mongoose';
2
import logger from '@/utils/logger.util';
3

4
const connectDb = async (URL: string) => {
5
  try {
6
    const connection: any = await connect(URL);
7
    logger.info(`Mongo DB is connected to: ${connection.connection.host}`);
8
  } catch (err) {
9
    logger.error(`An error ocurred\n\r\n\r${err}`);
10
  }
11
};
12

13
export default connectDb;

1
import express, {Application, Request, Response, NextFunction} from 'express';
2

3
import compression from 'compression';
4
import cookieParser from 'cookie-parser';
5
import cors from 'cors';
6
import helmet from 'helmet';
7

8
import ErrorMiddleware from '@/middlewares/error.middleware';
9
import HttpException from '@/utils/exceptions/http.exception';
10
import Controller from '@/interfaces/controller.interface';
11

12
import connectDb from '@/config/db.config';
13

14
// variable
15
import Variable from '@/env/variable.env';
16

17
// api constant
18
import ConstantAPI from '@/constants/api.constant';
19

20
// message constant
21
import ConstantMessage from '@/constants/message.constant';
22

23
// http constant
24
import ConstantHttpCode from '@/constants/http.code.constant';
25
import ConstantHttpReason from '@/constants/http.reason.constant';
26

27
class App {
28
  public app: Application;
29
  private DATABASE_URL: string;
30

31
  constructor(controllers: Controller[]) {
32
    this.app = express();
33
    this.DATABASE_URL = Variable.DATABASE_URL;
34

35
    this.initialiseDatabaseConnection(this.DATABASE_URL);
36
    this.initialiseConfig();
37
    this.initialiseRoutes();
38
    this.initialiseControllers(controllers);
39
    this.initialiseErrorHandling();
40
  }
41

42
  private initialiseConfig(): void {
43
    this.app.use(express.json());
44
    this.app.use(express.urlencoded({extended: true}));
45
    this.app.use(cookieParser());
46
    this.app.use(compression());
47
    this.app.use(cors());
48
    this.app.use(helmet());
49
  }
50

51
  private initialiseRoutes(): void {
52
    this.app.get(
53
      ConstantAPI.ROOT,
54
      (_req: Request, res: Response, next: NextFunction) => {
55
        try {
56
          return res.status(ConstantHttpCode.OK).json({
57
            status: {
58
              code: ConstantHttpCode.OK,
59
              msg: ConstantHttpReason.OK,
60
            },
61
            msg: ConstantMessage.API_WORKING,
62
          });
63
        } catch (err: any) {
64
          return next(
65
            new HttpException(
66
              ConstantHttpCode.INTERNAL_SERVER_ERROR,
67
              ConstantHttpReason.INTERNAL_SERVER_ERROR,
68
              err.message,
69
            ),
70
          );
71
        }
72
      },
73
    );
74
  }
75

76
  private initialiseControllers(controllers: Controller[]): void {
77
    controllers.forEach((controller: Controller) => {
78
      this.app.use(ConstantAPI.API, controller.router);
79
    });
80
  }
81

82
  private initialiseErrorHandling(): void {
83
    this.app.use(ErrorMiddleware);
84
  }
85

86
  private initialiseDatabaseConnection(url: string): void {
87
    connectDb(url);
88
  }
89
}
90

91
export default App;

1
class Number {
2
  // user
3
  public static readonly USERNAME_MIN_LENGTH: number = 3;
4
  public static readonly USERNAME_MAX_LENGTH: number = 20;
5
  public static readonly NAME_MIN_LENGTH: number = 3;
6
  public static readonly NAME_MAX_LENGTH: number = 80;
7
  public static readonly EMAIL_MAX_LENGTH: number = 50;
8
  public static readonly PASSWORD_MIN_LENGTH: number = 8;
9
  public static readonly PHONE_MIN_LENGTH: number = 10;
10
  public static readonly PHONE_MAX_LENGTH: number = 20;
11
  public static readonly ADDRESS_MIN_LENGTH: number = 10;
12
  public static readonly ADDRESS_MAX_LENGTH: number = 200;
13
}
14

15
export default Number;

1
import mongoose from 'mongoose';
2
import ConstantNumber from '@/constants/number.constant';
3

4
const UserSchema = new mongoose.Schema(
5
  {
6
    username: {
7
      type: String,
8
      required: true,
9
      unique: true,
10
      min: ConstantNumber.USERNAME_MIN_LENGTH,
11
      max: ConstantNumber.USERNAME_MAX_LENGTH,
12
    },
13
    name: {
14
      type: String,
15
      required: true,
16
      min: ConstantNumber.NAME_MIN_LENGTH,
17
      max: ConstantNumber.NAME_MAX_LENGTH,
18
    },
19
    email: {
20
      type: String,
21
      required: true,
22
      unique: true,
23
      max: ConstantNumber.EMAIL_MAX_LENGTH,
24
    },
25
    password: {
26
      type: String,
27
      required: true,
28
      min: ConstantNumber.PASSWORD_MIN_LENGTH,
29
    },
30
    phone: {
31
      type: String,
32
      required: true,
33
      unique: true,
34
      min: ConstantNumber.PHONE_MIN_LENGTH,
35
      max: ConstantNumber.PHONE_MAX_LENGTH,
36
    },
37
    address: {
38
      type: String,
39
      required: true,
40
      min: ConstantNumber.ADDRESS_MIN_LENGTH,
41
      max: ConstantNumber.ADDRESS_MAX_LENGTH,
42
    },
43
    isAdmin: {
44
      type: Boolean,
45
      default: true,
46
    },
47
  },
48
  {
49
    versionKey: false,
50
    timestamps: true,
51
  },
52
);
53

54
export default UserSchema;

1
class Model {
2
  public static readonly USER_MODEL: string = 'UserModel';
3
}
4

5
export default Model;

1
import {Document} from 'mongoose';
2

3
export default interface User extends Document {
4
  username: string;
5
  name: string;
6
  email: string;
7
  password: string;
8
  phone: string;
9
  address: string;
10
  isAdmin: boolean;
11
}

1
import mongoose from 'mongoose';
2

3
import UserSchema from '@/schemas/user.schema';
4
import UserInterface from '@/interfaces/user.interface';
5

6
import ConstantModel from '@/constants/model.constant';
7

8
const UserModel = mongoose.model<UserInterface>(
9
  ConstantModel.USER_MODEL,
10
  UserSchema,
11
);
12

13
export default UserModel;

1
import User from '@/models/user.model';
2
import UserInterface from '@/interfaces/user.interface';
3

4
class UserRepository {
5
  public async findAll(): Promise<UserInterface[]> {
6
    const users = await User.find({}).select('-password');
7
    return users;
8
  }
9

10
  public async findById(id: string): Promise<UserInterface | null> {
11
    const user = await User.findById(id).select('-password');
12
    return user;
13
  }
14

15
  public async findByUsername(username: string): Promise<UserInterface | null> {
16
    const user = await User.findOne({username}).select('-password');
17
    return user;
18
  }
19

20
  public async findByEmail(email: string): Promise<UserInterface | null> {
21
    const user = await User.findOne({email}).select('-password');
22
    return user;
23
  }
24

25
  public async findByPhone(phone: string): Promise<UserInterface | null> {
26
    const user = await User.findOne({phone}).select('-password');
27
    return user;
28
  }
29

30
  public async findByIdWithPassword(id: string): Promise<UserInterface | null> {
31
    const user = await User.findById(id);
32
    return user;
33
  }
34

35
  public async findByUsernameWithPassword(
36
    username: string,
37
  ): Promise<UserInterface | null> {
38
    const user = await User.findOne({username});
39
    return user;
40
  }
41

42
  public async findByEmailWithPassword(
43
    email: string,
44
  ): Promise<UserInterface | null> {
45
    const user = await User.findOne({email});
46
    return user;
47
  }
48

49
  public async findByPhoneWithPassword(
50
    phone: string,
51
  ): Promise<UserInterface | null> {
52
    const user = await User.findOne({phone});
53
    return user;
54
  }
55

56
  public async createUser(user: any): Promise<UserInterface | null> {
57
    const newUser = new User({
58
      username: user.username,
59
      name: user.name,
60
      email: user.email,
61
      password: user.password,
62
      phone: user.phone,
63
      address: user.address,
64
      isAdmin: user.isAdmin,
65
    });
66
    const savedUser = await newUser.save();
67
    return savedUser;
68
  }
69

70
  public async updateUsername(
71
    id: string,
72
    username: string,
73
  ): Promise<UserInterface | null> {
74
    const user = await User.findByIdAndUpdate(
75
      id,
76
      {username},
77
      {new: true},
78
    ).select('-password');
79
    return user;
80
  }
81

82
  public async updateName(
83
    id: string,
84
    name: string,
85
  ): Promise<UserInterface | null> {
86
    const user = await User.findByIdAndUpdate(id, {name}, {new: true}).select(
87
      '-password',
88
    );
89
    return user;
90
  }
91

92
  public async updateEmail(
93
    id: string,
94
    email: string,
95
  ): Promise<UserInterface | null> {
96
    const user = await User.findByIdAndUpdate(id, {email}, {new: true}).select(
97
      '-password',
98
    );
99
    return user;
100
  }
101

102
  public async updatePassword(
103
    id: string,
104
    password: string,
105
  ): Promise<UserInterface | null> {
106
    const user = await User.findByIdAndUpdate(
107
      id,
108
      {password},
109
      {new: true},
110
    ).select('-password');
111
    return user;
112
  }
113

114
  public async updatePhone(
115
    id: string,
116
    phone: string,
117
  ): Promise<UserInterface | null> {
118
    const user = await User.findByIdAndUpdate(id, {phone}, {new: true}).select(
119
      '-password',
120
    );
121
    return user;
122
  }
123

124
  public async updateAddress(
125
    id: string,
126
    address: string,
127
  ): Promise<UserInterface | null> {
128
    const user = await User.findByIdAndUpdate(
129
      id,
130
      {address},
131
      {new: true},
132
    ).select('-password');
133
    return user;
134
  }
135

136
  public async deleteUser(id: string): Promise<UserInterface | null> {
137
    const user = await User.findByIdAndDelete(id);
138
    return user;
139
  }
140

141
  public async getUsersStats(lastYear: Date): Promise<UserInterface[] | null> {
142
    const users = await User.aggregate([
143
      {$match: {createdAt: {$gte: lastYear}}},
144
      {
145
        $project: {
146
          month: {$month: '$createdAt'},
147
        },
148
      },
149
      {
150
        $group: {
151
          _id: '$month',
152
          total: {$sum: 1},
153
        },
154
      },
155
    ]);
156
    return users;
157
  }
158
}
159

160
export default UserRepository;

1
class Regex {
2
  public static readonly USERNAME = /^(?!.*\.\.)(?!.*\.$)[^\W][\w.]{3,32}$/;
3
  public static readonly EMAIL =
4
    /^(([^<>()\\[\]\\.,;:\s@"]+(\.[^<>()\\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
5
  public static readonly PASSWORD =
6
    /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
7
  public static readonly NAME = /^[a-zA-Z ]{2,35}$/;
8
  public static readonly PHONE =
9
    /^\s*(?:\+?(\d{1,3}))?([-. (]*(\d{3})[-. )]*)?((\d{3})[-. ]*(\d{2,4})(?:[-.x ]*(\d+))?)\s*$/;
10
  public static readonly ADDRESS = /^[a-zA-Z0-9\s,'-]{10,200}$/;
11
}
12

13
export default Regex;

1
import Joi from 'joi';
2
import ConstantRegex from '@/constants/regex.constant';
3

4
class UserValidation {
5
  public register = Joi.object({
6
    username: Joi.string().max(30).required(),
7
    name: Joi.string().max(30).required(),
8
    email: Joi.string().email().required(),
9
    password: Joi.string().min(6).max(30).required(),
10
    phone: Joi.string().min(10).max(15).required(),
11
    address: Joi.string().max(100).required(),
12
  });
13

14
  public login = Joi.object({
15
    email: Joi.string().email().required(),
16
    password: Joi.string().min(6).max(30).required(),
17
  });
18

19
  public updateUsername = Joi.object({
20
    username: Joi.string().max(30).required(),
21
    password: Joi.string().min(6).max(30).required(),
22
  });
23

24
  public updateName = Joi.object({
25
    name: Joi.string().max(30).required(),
26
    password: Joi.string().min(6).max(30).required(),
27
  });
28

29
  public updateEmail = Joi.object({
30
    email: Joi.string().email().required(),
31
    password: Joi.string().min(6).max(30).required(),
32
  });
33

34
  public updatePassword = Joi.object({
35
    oldPassword: Joi.string().min(6).max(30).required(),
36
    newPassword: Joi.string().min(6).max(30).required(),
37
    confirmPassword: Joi.string().min(6).max(30).required(),
38
  });
39

40
  public updatePhone = Joi.object({
41
    phone: Joi.string().min(10).max(15).required(),
42
    password: Joi.string().min(6).max(30).required(),
43
  });
44

45
  public updateAddress = Joi.object({
46
    address: Joi.string().max(100).required(),
47
    password: Joi.string().min(6).max(30).required(),
48
  });
49

50
  public deleteUser = Joi.object({
51
    password: Joi.string().min(6).max(30).required(),
52
  });
53

54
  public validateUsername(username: string): boolean {
55
    return ConstantRegex.USERNAME.test(username);
56
  }
57

58
  public validateName(name: string): boolean {
59
    return ConstantRegex.NAME.test(name);
60
  }
61

62
  public validateEmail(email: string): boolean {
63
    return ConstantRegex.EMAIL.test(email);
64
  }
65

66
  public validatePassword(password: string): boolean {
67
    return ConstantRegex.PASSWORD.test(password);
68
  }
69

70
  public validatePhone(phone: string): boolean {
71
    return ConstantRegex.PHONE.test(phone);
72
  }
73

74
  public validateAddress(address: string): boolean {
75
    return ConstantRegex.ADDRESS.test(address);
76
  }
77
}
78

79
export default UserValidation;