api/controllers/ConfigController.ts

import deepmerge from "deepmerge";
import dot from "dot-object";
import { Response as ExpressResponse } from "express";
import { z } from "zod";
import { Action } from "../../decorators/Action";
import { RequireAuth } from "../../decorators/RequireAuth";
import { Validate } from "../../decorators/Validate";
import { GuildConfigSchema } from "../../types/GuildConfigSchema";
import { logError } from "../../utils/logger";
import Controller from "../Controller";
import Request from "../Request";
import Response from "../Response";

export default class ConfigController extends Controller {
    guildConfigAccessControl(request: Request, response: ExpressResponse) {
        if (!request.user!.guilds.includes(request.params.id)) {
            response.status(403).json({
                error: "You don't have permission to access this resource."
            });

            return false;
        }

        return true;
    }

    @Action("GET", "/config/:id")
    @RequireAuth()
    public async index(request: Request, response: ExpressResponse) {
        if (!this.guildConfigAccessControl(request, response)) {
            return;
        }

        let commands: string[] | undefined = undefined;

        if (request.query?.commands?.toString()?.toLowerCase() === "true") {
            commands = [];

            for (const [, command] of this.client.commands) {
                if (!commands.includes(command.name)) {
                    commands.push(command.name);
                }
            }
        }

        return {
            config: this.client.configManager.config[request.params.id] ?? null,
            commands
        };
    }

    @Action("PUT", "/config/:id")
    @RequireAuth()
    @Validate(
        z.object({
            data: GuildConfigSchema,
            returnOld: z.boolean().default(false),
            returnNew: z.boolean().default(false)
        })
    )
    public async updatePut(request: Request, response: ExpressResponse) {
        if (!this.guildConfigAccessControl(request, response)) {
            return;
        }

        const oldConfig = this.client.configManager.config[request.params.id];
        console.log(request.parsedBody);

        if (request.parsedBody) {
            this.client.configManager.config[request.params.id] = deepmerge(oldConfig as object, request.parsedBody.data ?? {}, {
                arrayMerge: (target, source, options) => {
                    return source;
                }
            });
            console.log(oldConfig?.prefix, this.client.configManager.config[request.params.id]?.prefix);
        }

        await this.client.configManager.write();

        try {
            await this.client.configManager.load();
        } catch (e) {
            logError(e);
            logError("Configuration was corrupted. Restoring the old configuration.");
            this.client.configManager.config[request.params.id] = oldConfig;
            await this.client.configManager.write();
        }

        return {
            success: true,
            old: request.parsedBody?.returnOld ? oldConfig : undefined,
            new: request.parsedBody?.returnNew ? this.client.configManager.config[request.params.id] : undefined
        };
    }

    @Action("PATCH", "/config/:id")
    @RequireAuth()
    @Validate(
        z.object({
            data: z.record(z.string(), z.any()),
            returnOld: z.boolean().default(false),
            returnNew: z.boolean().default(false)
        })
    )
    public async updatePatch(request: Request, response: ExpressResponse) {
        if (!this.guildConfigAccessControl(request, response)) {
            return;
        }

        const oldConfig = this.client.configManager.config[request.params.id];

        if (request.parsedBody) {
            const { parsedBody } = request;
            const configObject = dot.object(parsedBody.data);
            const result = GuildConfigSchema.safeParse(configObject);

            if (result.success) {
                this.client.configManager.config[request.params.id] = deepmerge(oldConfig as object, result.data);
            } else {
                return new Response({
                    status: 400,
                    body: result.error
                });
            }

            await this.client.configManager.write();

            try {
                await this.client.configManager.load();
            } catch (e) {
                logError(e);
                logError("Configuration was corrupted. Restoring the old configuration.");
                this.client.configManager.config[request.params.id] = oldConfig;
                await this.client.configManager.write();
            }

            return {
                success: true,
                old: request.parsedBody?.returnOld ? oldConfig : undefined,
                new: request.parsedBody?.returnNew ? this.client.configManager.config[request.params.id] : undefined
            };
        }
    }
}
1	import deepmerge from "deepmerge";
2	import dot from "dot-object";
3	import { Response as ExpressResponse } from "express";
4	import { z } from "zod";
5	import { Action } from "../../decorators/Action";
6	import { RequireAuth } from "../../decorators/RequireAuth";
7	import { Validate } from "../../decorators/Validate";
8	import { GuildConfigSchema } from "../../types/GuildConfigSchema";
9	import { logError } from "../../utils/logger";
10	import Controller from "../Controller";
11	import Request from "../Request";
12	import Response from "../Response";
13
14	export default class ConfigController extends Controller {
15	guildConfigAccessControl(request: Request, response: ExpressResponse) {
16	if (!request.user!.guilds.includes(request.params.id)) {
17	response.status(403).json({
18	error: "You don't have permission to access this resource."
19	});
20
21	return false;
22	}
23
24	return true;
25	}
26
27	@Action("GET", "/config/:id")
28	@RequireAuth()
29	public async index(request: Request, response: ExpressResponse) {
30	if (!this.guildConfigAccessControl(request, response)) {
31	return;
32	}
33
34	let commands: string[] \| undefined = undefined;
35
36	if (request.query?.commands?.toString()?.toLowerCase() === "true") {
37	commands = [];
38
39	for (const [, command] of this.client.commands) {
40	if (!commands.includes(command.name)) {
41	commands.push(command.name);
42	}
43	}
44	}
45
46	return {
47	config: this.client.configManager.config[request.params.id] ?? null,
48	commands
49	};
50	}
51
52	@Action("PUT", "/config/:id")
53	@RequireAuth()
54	@Validate(
55	z.object({
56	data: GuildConfigSchema,
57	returnOld: z.boolean().default(false),
58	returnNew: z.boolean().default(false)
59	})
60	)
61	public async updatePut(request: Request, response: ExpressResponse) {
62	if (!this.guildConfigAccessControl(request, response)) {
63	return;
64	}
65
66	const oldConfig = this.client.configManager.config[request.params.id];
67	console.log(request.parsedBody);
68
69	if (request.parsedBody) {
70	this.client.configManager.config[request.params.id] = deepmerge(oldConfig as object, request.parsedBody.data ?? {}, {
71	arrayMerge: (target, source, options) => {
72	return source;
73	}
74	});
75	console.log(oldConfig?.prefix, this.client.configManager.config[request.params.id]?.prefix);
76	}
77
78	await this.client.configManager.write();
79
80	try {
81	await this.client.configManager.load();
82	} catch (e) {
83	logError(e);
84	logError("Configuration was corrupted. Restoring the old configuration.");
85	this.client.configManager.config[request.params.id] = oldConfig;
86	await this.client.configManager.write();
87	}
88
89	return {
90	success: true,
91	old: request.parsedBody?.returnOld ? oldConfig : undefined,
92	new: request.parsedBody?.returnNew ? this.client.configManager.config[request.params.id] : undefined
93	};
94	}
95
96	@Action("PATCH", "/config/:id")
97	@RequireAuth()
98	@Validate(
99	z.object({
100	data: z.record(z.string(), z.any()),
101	returnOld: z.boolean().default(false),
102	returnNew: z.boolean().default(false)
103	})
104	)
105	public async updatePatch(request: Request, response: ExpressResponse) {
106	if (!this.guildConfigAccessControl(request, response)) {
107	return;
108	}
109
110	const oldConfig = this.client.configManager.config[request.params.id];
111
112	if (request.parsedBody) {
113	const { parsedBody } = request;
114	const configObject = dot.object(parsedBody.data);
115	const result = GuildConfigSchema.safeParse(configObject);
116
117	if (result.success) {
118	this.client.configManager.config[request.params.id] = deepmerge(oldConfig as object, result.data);
119	} else {
120	return new Response({
121	status: 400,
122	body: result.error
123	});
124	}
125
126	await this.client.configManager.write();
127
128	try {
129	await this.client.configManager.load();
130	} catch (e) {
131	logError(e);
132	logError("Configuration was corrupted. Restoring the old configuration.");
133	this.client.configManager.config[request.params.id] = oldConfig;
134	await this.client.configManager.write();
135	}
136
137	return {
138	success: true,
139	old: request.parsedBody?.returnOld ? oldConfig : undefined,
140	new: request.parsedBody?.returnNew ? this.client.configManager.config[request.params.id] : undefined
141	};
142	}
143	}
144	}