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	import { Request } from "express";
2	import User from "../../models/User";
3	import Controller from "../Controller";
4	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
11	export default class UserController extends Controller {
12	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	}
29
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	}