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	rakinar2	577	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			}