api/controllers/UserController.ts

import { Request } from "express";
import User from "../../models/User";
import Controller from "../Controller";
import { body, validationResult } from 'express-validator';
import bcrypt from 'bcrypt';
import jwt from 'jsonwebtoken';
import KeyValuePair from "../../types/KeyValuePair";
import { promise } from "zod";
import Response from "../Response";

export default class UserController extends Controller {
    middleware(): KeyValuePair<Function[]> {
        return {
            create: [
                body(["password"]).isLength({ min: 2 }), 
                body(["username"]).custom(async username => {
                    const user = await User.findOne({ username });

                    if (user) {
                        return Promise.reject("Username is already in use");
                    }

                    return username;
                }),
                body(["discord_id"]).custom(value => /\d+/g.test(value) ? value : Promise.reject("Invalid Snowflake Given"))
            ]
        };
    }

    public async index() {
        return await User.find().limit(30);
    }

    public async create(request: Request) {
        return new Response(403);
        
        const errors = validationResult(request);

        if (!errors.isEmpty()) {
            return { errors: errors.array(), error_type: 'validation' };
        } 

        const user = new User();

        user.username = request.body.username;
        user.discord_id = request.body.discord_id;
        user.createdAt = new Date();

        try {
            await user.save();
        }
        catch (e) {
            return { error: "DB validation error", error_type: 'db_validation' };
        }

        const salt = await bcrypt.genSalt();
        user.password = await bcrypt.hash(request.body.password, salt);

        const token = await jwt.sign({
            username: user.username,
            discord_id: user.discord_id,
            _id: user.id
        }, process.env.JWT_SECRET!, {
            expiresIn: "2 days",
            issuer: "SudoBot API",
        });

        user.token = token;
        
        try {
            await user.save();
        }
        catch (e) {
            return { error: "Token signing error", error_type: 'token_signing' };
        }

        user.password = undefined;
        return user;
    }
}
1	rakin	326	import { Request } from "express";
2	rakin	348	import User from "../../models/User";
3	rakin	326	import Controller from "../Controller";
4	rakin	348	import { body, validationResult } from 'express-validator';
5			import bcrypt from 'bcrypt';
6			import jwt from 'jsonwebtoken';
7			import KeyValuePair from "../../types/KeyValuePair";
8			import { promise } from "zod";
9			import Response from "../Response";
10	rakin	326
11			export default class UserController extends Controller {
12	rakin	348	middleware(): KeyValuePair<Function[]> {
13			return {
14			create: [
15			body(["password"]).isLength({ min: 2 }),
16			body(["username"]).custom(async username => {
17			const user = await User.findOne({ username });
18
19			if (user) {
20			return Promise.reject("Username is already in use");
21			}
22
23			return username;
24			}),
25			body(["discord_id"]).custom(value => /\d+/g.test(value) ? value : Promise.reject("Invalid Snowflake Given"))
26			]
27			};
28	rakin	326	}
29	rakin	348
30			public async index() {
31			return await User.find().limit(30);
32			}
33
34			public async create(request: Request) {
35			return new Response(403);
36
37			const errors = validationResult(request);
38
39			if (!errors.isEmpty()) {
40			return { errors: errors.array(), error_type: 'validation' };
41			}
42
43			const user = new User();
44
45			user.username = request.body.username;
46			user.discord_id = request.body.discord_id;
47			user.createdAt = new Date();
48
49			try {
50			await user.save();
51			}
52			catch (e) {
53			return { error: "DB validation error", error_type: 'db_validation' };
54			}
55
56			const salt = await bcrypt.genSalt();
57			user.password = await bcrypt.hash(request.body.password, salt);
58
59			const token = await jwt.sign({
60			username: user.username,
61			discord_id: user.discord_id,
62			_id: user.id
63			}, process.env.JWT_SECRET!, {
64			expiresIn: "2 days",
65			issuer: "SudoBot API",
66			});
67
68			user.token = token;
69
70			try {
71			await user.save();
72			}
73			catch (e) {
74			return { error: "Token signing error", error_type: 'token_signing' };
75			}
76
77			user.password = undefined;
78			return user;
79			}
80	rakin	326	}