Merge branch 'master' into unittests

README.md

@@ -28,7 +28,7 @@ This repository contains:
 
 ## [Ressources](https://docs.fosscord.com/resources/)
 
--   [Contributing](https://docs.fosscord.com/contributing/)
+-   [Contributing](https://docs.fosscord.com/contributing/server/)
 
 ## [Download](https://github.com/fosscord/fosscord-server/releases)
 

api/client_test/index.html

@@ -19,7 +19,7 @@
 				ASSET_ENDPOINT: "",
 				MEDIA_PROXY_ENDPOINT: "https://media.discordapp.net",
 				WIDGET_ENDPOINT: `//${location.host}/widget`,
-				INVITE_HOST: `${location.hostname}`,
+				INVITE_HOST: `${location.host}/invite`,
 				GUILD_TEMPLATE_HOST: "discord.new",
 				GIFT_CODE_HOST: "discord.gift",
 				RELEASE_CHANNEL: "stable",
@@ -45,9 +45,9 @@
 				`{"trace":false,"canary":false,"logGatewayEvents":true,"logOverlayEvents":true,"logAnalyticsEvents":true,"sourceMapsEnabled":false,"axeEnabled":false}`
 			);
 		</script>
-		<script src="/assets/1dfc47a02b92fa11de87.js"></script>
+		<script src="/assets/479a2f1e7d625dc134b9.js"></script>
-		<script src="/assets/60611ef20efa1f11238a.js"></script>
+		<script src="/assets/a15fd133a1d2d77a2424.js"></script>
-		<script src="/assets/b83bc9f9c08cf5073adf.js"></script>
+		<script src="/assets/97e6fa22aa08ee4daa5e.js"></script>
-		<script src="/assets/e92920082b09191a5bb0.js"></script>
+		<script src="/assets/9b2b7f0632acd0c5e781.js"></script>
 	</body>
 </html>

api/package.json

@@ -70,6 +70,7 @@
 	},
 	"dependencies": {
 		"@fosscord/util": "file:../util",
+		"@types/morgan": "^1.9.3",
 		"ajv": "8.6.2",
 		"ajv-formats": "^2.1.1",
 		"amqplib": "^0.8.0",
@@ -93,6 +94,7 @@
 		"mongoose": "^5.12.3",
 		"mongoose-autopopulate": "^0.12.3",
 		"mongoose-long": "^0.3.2",
+		"morgan": "^1.10.0",
 		"multer": "^1.4.2",
 		"node-fetch": "^2.6.1",
 		"patch-package": "^6.4.7",

api/src/Server.ts

@@ -1,3 +1,4 @@
+import { OptionsJson } from 'body-parser';
 import "missing-native-js-functions";
 import { Connection } from "mongoose";
 import { Server, ServerOptions } from "lambert-server";
@@ -11,6 +12,7 @@ import path from "path";
 import { initRateLimits } from "./middlewares/RateLimit";
 import TestClient from "./middlewares/TestClient";
 import { initTranslation } from "./middlewares/Translation";
+import morgan from "morgan";
 
 export interface FosscordServerOptions extends ServerOptions {}
 
@@ -36,6 +38,29 @@ export class FosscordServer extends Server {
 		await Config.init();
 		await initEvent();
 
+
+		/* 
+		DOCUMENTATION: uses LOG_REQUESTS environment variable
+		
+		# only log 200 and 204
+		LOG_REQUESTS=200 204
+		# log everything except 200 and 204
+		LOG_REQUESTS=-200 204
+		# log all requests
+		LOG_REQUESTS=-
+		*/
+
+		let logRequests = process.env["LOG_REQUESTS"] != undefined;
+		if(logRequests) {
+			this.app.use(morgan("combined", {
+				skip: (req, res) => {
+					var skip = !(process.env["LOG_REQUESTS"]?.includes(res.statusCode.toString()) ?? false);
+					if(process.env["LOG_REQUESTS"]?.charAt(0) == '-') skip = !skip;
+					return skip;
+				}
+			}));
+		}
+
 		this.app.use(CORS);
 		this.app.use(BodyParser({ inflate: true, limit: "10mb" }));
 
@@ -65,6 +90,9 @@ export class FosscordServer extends Server {
 		this.app.use(ErrorHandler);
 		TestClient(this.app);
 
+		if(logRequests){
+			console.log("Warning: Request logging is enabled! This will spam your console!\nTo disable this, unset the 'LOG_REQUESTS' environment variable!");
+		}
 		return super.start();
 	}
 }

api/src/routes/auth/register.ts

@@ -1,5 +1,5 @@
 import { Request, Response, Router } from "express";
-import { trimSpecial, User, Snowflake, Config, defaultSettings } from "@fosscord/util";
+import { trimSpecial, User, Snowflake, Config, defaultSettings, Member, Invite } from "@fosscord/util";
 import bcrypt from "bcrypt";
 import { EMAIL_REGEX, FieldErrors, route } from "@fosscord/api";
 import "missing-native-js-functions";
@@ -19,7 +19,7 @@ export interface RegisterSchema {
 	 * @minLength 1
 	 * @maxLength 72
 	 */
-	password: string; // TODO: use password strength of config
+	password?: string;
 	consent: boolean;
 	/**
 	 * @TJS-format email
@@ -60,7 +60,6 @@ router.post("/", route({ body: "RegisterSchema" }), async (req: Request, res: Re
 	}
 
 	console.log("register", req.body.email, req.body.username, ip);
-	// TODO: automatically join invite
 	// TODO: gift_code_sku_id?
 	// TODO: check password strength
 
@@ -87,13 +86,6 @@ router.post("/", route({ body: "RegisterSchema" }), async (req: Request, res: Re
 		});
 	}
 
-	// require invite to register -> e.g. for organizations to send invites to their employees
-	if (register.requireInvite && !invite) {
-		throw FieldErrors({
-			email: { code: "INVITE_ONLY", message: req.t("auth:register.INVITE_ONLY") }
-		});
-	}
-
 	if (email) {
 		// replace all dots and chars after +, if its a gmail.com email
 		if (!email) throw FieldErrors({ email: { code: "INVALID_EMAIL", message: req.t("auth:register.INVALID_EMAIL") } });
@@ -109,13 +101,13 @@ router.post("/", route({ body: "RegisterSchema" }), async (req: Request, res: Re
 				}
 			});
 		}
-	} else if (register.email.necessary) {
+	} else if (register.email.required) {
 		throw FieldErrors({
 			email: { code: "BASE_TYPE_REQUIRED", message: req.t("common:field.BASE_TYPE_REQUIRED") }
 		});
 	}
 
-	if (register.dateOfBirth.necessary && !date_of_birth) {
+	if (register.dateOfBirth.required && !date_of_birth) {
 		throw FieldErrors({
 			date_of_birth: { code: "BASE_TYPE_REQUIRED", message: req.t("common:field.BASE_TYPE_REQUIRED") }
 		});
@@ -162,8 +154,14 @@ router.post("/", route({ body: "RegisterSchema" }), async (req: Request, res: Re
 		// TODO: check captcha
 	}
 
-	// the salt is saved in the password refer to bcrypt docs
+	if (password) {
-	password = await bcrypt.hash(password, 12);
+		// the salt is saved in the password refer to bcrypt docs
+		password = await bcrypt.hash(password, 12);
+	} else if (register.password.required) {
+		throw FieldErrors({
+			password: { code: "BASE_TYPE_REQUIRED", message: req.t("common:field.BASE_TYPE_REQUIRED") }
+		});
+	}
 
 	let exists;
 	// randomly generates a discriminator between 1 and 9999 and checks max five times if it already exists
@@ -202,7 +200,7 @@ router.post("/", route({ body: "RegisterSchema" }), async (req: Request, res: Re
 		premium_type: 2,
 		bio: "",
 		mfa_enabled: false,
-		verified: false,
+		verified: true,
 		disabled: false,
 		deleted: false,
 		email: email,
@@ -217,6 +215,16 @@ router.post("/", route({ body: "RegisterSchema" }), async (req: Request, res: Re
 		fingerprints: []
 	}).save();
 
+	if (invite) {
+		// await to fail if the invite doesn't exist (necessary for requireInvite to work properly) (username only signups are possible)
+		await Invite.joinGuild(user.id, invite);
+	} else if (register.requireInvite) {
+		// require invite to register -> e.g. for organizations to send invites to their employees
+		throw FieldErrors({
+			email: { code: "INVITE_ONLY", message: req.t("auth:register.INVITE_ONLY") }
+		});
+	}
+
 	return res.json({ token: await generateToken(user.id) });
 });
 

api/src/routes/channels/#channel_id/index.ts

@@ -1,6 +1,16 @@
-import { ChannelDeleteEvent, Channel, ChannelUpdateEvent, emitEvent, ChannelType, ChannelPermissionOverwriteType } from "@fosscord/util";
+import {
-import { Router, Response, Request } from "express";
+	Channel,
+	ChannelDeleteEvent,
+	ChannelPermissionOverwriteType,
+	ChannelType,
+	ChannelUpdateEvent,
+	emitEvent,
+	Recipient,
+	handleFile
+} from "@fosscord/util";
+import { Request, Response, Router } from "express";
 import { route } from "@fosscord/api";
+
 const router: Router = Router();
 // TODO: delete channel
 // TODO: Get channel
@@ -16,23 +26,35 @@ router.get("/", route({ permission: "VIEW_CHANNEL" }), async (req: Request, res:
 router.delete("/", route({ permission: "MANAGE_CHANNELS" }), async (req: Request, res: Response) => {
 	const { channel_id } = req.params;
 
-	const channel = await Channel.findOneOrFail({ id: channel_id });
+	const channel = await Channel.findOneOrFail({ where: { id: channel_id }, relations: ["recipients"] });
 
-	// TODO: Dm channel "close" not delete
+	if (channel.type === ChannelType.DM) {
-	const data = channel;
+		const recipient = await Recipient.findOneOrFail({ where: { channel_id: channel_id, user_id: req.user_id } });
+		recipient.closed = true;
+		await Promise.all([
+			recipient.save(),
+			emitEvent({ event: "CHANNEL_DELETE", data: channel, user_id: req.user_id } as ChannelDeleteEvent)
+		]);
+	} else if (channel.type === ChannelType.GROUP_DM) {
+		await Channel.removeRecipientFromChannel(channel, req.user_id);
+	} else {
+		await Promise.all([
+			Channel.delete({ id: channel_id }),
+			emitEvent({ event: "CHANNEL_DELETE", data: channel, channel_id } as ChannelDeleteEvent)
+		]);
+	}
 
-	await Promise.all([emitEvent({ event: "CHANNEL_DELETE", data, channel_id } as ChannelDeleteEvent), Channel.delete({ id: channel_id })]);
+	res.send(channel);
-
-	res.send(data);
 });
 
 export interface ChannelModifySchema {
 	/**
 	 * @maxLength 100
 	 */
-	name: string;
+	name?: string;
-	type: ChannelType;
+	type?: ChannelType;
 	topic?: string;
+	icon?: string | null;
 	bitrate?: number;
 	user_limit?: number;
 	rate_limit_per_user?: number;
@@ -53,6 +75,7 @@ export interface ChannelModifySchema {
 router.patch("/", route({ body: "ChannelModifySchema", permission: "MANAGE_CHANNELS" }), async (req: Request, res: Response) => {
 	var payload = req.body as ChannelModifySchema;
 	const { channel_id } = req.params;
+	if (payload.icon) payload.icon = await handleFile(`/channel-icons/${channel_id}`, payload.icon);
 
 	const channel = await Channel.findOneOrFail({ id: channel_id });
 	channel.assign(payload);

api/src/routes/channels/#channel_id/messages/#message_id/ack.ts

@@ -26,7 +26,7 @@ router.post("/", route({ body: "MessageAcknowledgeSchema" }), async (req: Reques
 		data: {
 			channel_id,
 			message_id,
-			version: 496
+			version: 3763
 		}
 	} as MessageAckEvent);
 

api/src/routes/channels/#channel_id/messages/#message_id/index.ts

@@ -3,7 +3,6 @@ import { Router, Response, Request } from "express";
 import { route } from "@fosscord/api";
 import { handleMessage, postHandleMessage } from "@fosscord/api";
 import { MessageCreateSchema } from "../index";
-import { deleteMessageAttachments } from "@fosscord/api/util/Attachments";
 
 const router = Router();
 // TODO: message content/embed string length limit
@@ -34,7 +33,6 @@ router.patch("/", route({ body: "MessageCreateSchema", permission: "SEND_MESSAGE
 	});
 
 	await Promise.all([
-		await deleteMessageAttachments(message_id, new_message.attachments), //This delete all the attachments not in the array
 		new_message!.save(),
 		await emitEvent({
 			event: "MESSAGE_UPDATE",
@@ -60,7 +58,6 @@ router.delete("/", route({}), async (req: Request, res: Response) => {
 		permission.hasThrow("MANAGE_MESSAGES");
 	}
 
-	await deleteMessageAttachments(message_id);
 	await Message.delete({ id: message_id });
 
 	await emitEvent({

api/src/routes/channels/#channel_id/messages/index.ts

@@ -1,10 +1,19 @@
 import { Router, Response, Request } from "express";
-import { Attachment, Channel, ChannelType, Embed, getPermission, Message } from "@fosscord/util";
+import {
+	Attachment,
+	Channel,
+	ChannelType,
+	DmChannelDTO,
+	Embed,
+	emitEvent,
+	getPermission,
+	Message,
+	MessageCreateEvent,
+	uploadFile
+} from "@fosscord/util";
 import { HTTPError } from "lambert-server";
-import { route } from "@fosscord/api";
+import { handleMessage, postHandleMessage, route } from "@fosscord/api";
 import multer from "multer";
-import { sendMessage } from "@fosscord/api";
-import { uploadFile } from "@fosscord/api";
 import { FindManyOptions, LessThan, MoreThan } from "typeorm";
 
 const router: Router = Router();
@@ -62,9 +71,9 @@ router.get("/", async (req: Request, res: Response) => {
 	if (!channel) throw new HTTPError("Channel not found", 404);
 
 	isTextChannel(channel.type);
-	const around = `${req.query.around}`;
+	const around = req.query.around ? `${req.query.around}` : undefined;
-	const before = `${req.query.before}`;
+	const before = req.query.before ? `${req.query.before}` : undefined;
-	const after = `${req.query.after}`;
+	const after = req.query.after ? `${req.query.after}` : undefined;
 	const limit = Number(req.query.limit) || 50;
 	if (limit < 1 || limit > 100) throw new HTTPError("limit must be between 1 and 100");
 
@@ -151,10 +160,11 @@ router.post(
 				return res.status(400).json(error);
 			}
 		}
+		const channel = await Channel.findOneOrFail({ where: { id: channel_id }, relations: ["recipients", "recipients.user"] });
 
 		const embeds = [];
 		if (body.embed) embeds.push(body.embed);
-		const data = await sendMessage({
+		let message = await handleMessage({
 			...body,
 			type: 0,
 			pinned: false,
@@ -162,9 +172,41 @@ router.post(
 			embeds,
 			channel_id,
 			attachments,
-			edited_timestamp: undefined
+			edited_timestamp: undefined,
+			timestamp: new Date()
 		});
 
-		return res.json(data);
+		message = await message.save();
+
+		await channel.assign({ last_message_id: message.id }).save();
+
+		if (channel.isDm()) {
+			const channel_dto = await DmChannelDTO.from(channel);
+
+			for (let recipient of channel.recipients!) {
+				if (recipient.closed) {
+					await emitEvent({
+						event: "CHANNEL_CREATE",
+						data: channel_dto.excludedRecipients([recipient.user_id]),
+						user_id: recipient.user_id
+					});
+				}
+			}
+
+			//Only one recipients should be closed here, since in group DMs the recipient is deleted not closed
+			await Promise.all(
+				channel
+					.recipients!.filter((r) => r.closed)
+					.map(async (r) => {
+						r.closed = false;
+						return await r.save();
+					})
+			);
+		}
+
+		await emitEvent({ event: "MESSAGE_CREATE", channel_id: channel_id, data: message } as MessageCreateEvent);
+		postHandleMessage(message).catch((e) => {}); // no await as it shouldnt block the message send function and silently catch error
+
+		return res.json(message);
 	}
 );

api/src/routes/channels/#channel_id/recipients.ts

@@ -1,5 +1,57 @@
-import { Router, Response, Request } from "express";
+import { Request, Response, Router } from "express";
+import { Channel, ChannelRecipientAddEvent, ChannelType, DiscordApiErrors, DmChannelDTO, emitEvent, PublicUserProjection, Recipient, User } from "@fosscord/util";
+
 const router: Router = Router();
-// TODO:
+
+router.put("/:user_id", async (req: Request, res: Response) => {
+	const { channel_id, user_id } = req.params;
+	const channel = await Channel.findOneOrFail({ where: { id: channel_id }, relations: ["recipients"] });
+
+	if (channel.type !== ChannelType.GROUP_DM) {
+		const recipients = [
+			...channel.recipients!.map(r => r.user_id),
+			user_id
+		].unique()
+
+		const new_channel = await Channel.createDMChannel(recipients, req.user_id)
+		return res.status(201).json(new_channel);
+	} else {
+		if (channel.recipients!.map(r => r.user_id).includes(user_id)) {
+			throw DiscordApiErrors.INVALID_RECIPIENT //TODO is this the right error?
+		}
+
+		channel.recipients!.push(new Recipient({ channel_id: channel_id, user_id: user_id }));
+		await channel.save()
+
+		await emitEvent({
+			event: "CHANNEL_CREATE",
+			data: await DmChannelDTO.from(channel, [user_id]),
+			user_id: user_id
+		});
+
+		await emitEvent({
+			event: "CHANNEL_RECIPIENT_ADD", data: {
+				channel_id: channel_id,
+				user: await User.findOneOrFail({ where: { id: user_id }, select: PublicUserProjection })
+			}, channel_id: channel_id
+		} as ChannelRecipientAddEvent);
+		return res.sendStatus(204);
+	}
+});
+
+router.delete("/:user_id", async (req: Request, res: Response) => {
+	const { channel_id, user_id } = req.params;
+	const channel = await Channel.findOneOrFail({ where: { id: channel_id }, relations: ["recipients"] });
+	if (!(channel.type === ChannelType.GROUP_DM && (channel.owner_id === req.user_id || user_id === req.user_id)))
+		throw DiscordApiErrors.MISSING_PERMISSIONS
+
+	if (!channel.recipients!.map(r => r.user_id).includes(user_id)) {
+		throw DiscordApiErrors.INVALID_RECIPIENT //TODO is this the right error?
+	}
+
+	await Channel.removeRecipientFromChannel(channel, user_id)
+
+	return res.sendStatus(204);
+});
 
 export default router;

api/src/routes/guilds/#guild_id/delete.ts

@@ -13,15 +13,8 @@ router.post("/", route({}), async (req: Request, res: Response) => {
 	const guild = await Guild.findOneOrFail({ where: { id: guild_id }, select: ["owner_id"] });
 	if (guild.owner_id !== req.user_id) throw new HTTPError("You are not the owner of this guild", 401);
 
-	// do not put everything into promise all, because of "QueryFailedError: SQLITE_CONSTRAINT: FOREIGN KEY constraint failed"
-
-	await Message.delete({ guild_id }); // messages must be deleted before channel
-
 	await Promise.all([
-		Role.delete({ guild_id }),
+		Guild.delete({ id: guild_id }), // this will also delete all guild related data
-		Channel.delete({ guild_id }),
-		Emoji.delete({ guild_id }),
-		Member.delete({ guild_id }),
 		emitEvent({
 			event: "GUILD_DELETE",
 			data: {
@@ -31,9 +24,6 @@ router.post("/", route({}), async (req: Request, res: Response) => {
 		} as GuildDeleteEvent)
 	]);
 
-	await Invite.delete({ guild_id }); // invite must be deleted after channel
-	await Guild.delete({ id: guild_id }); // guild must be deleted after everything else
-
 	return res.sendStatus(204);
 });
 

api/src/routes/guilds/#guild_id/index.ts

@@ -1,8 +1,7 @@
 import { Request, Response, Router } from "express";
-import { emitEvent, getPermission, Guild, GuildUpdateEvent, Member } from "@fosscord/util";
+import { emitEvent, getPermission, Guild, GuildUpdateEvent, handleFile, Member } from "@fosscord/util";
 import { HTTPError } from "lambert-server";
 import { route } from "@fosscord/api";
-import { handleFile } from "@fosscord/api";
 import "missing-native-js-functions";
 import { GuildCreateSchema } from "../index";
 

api/src/routes/guilds/index.ts

@@ -1,7 +1,6 @@
 import { Router, Request, Response } from "express";
-import { Role, Guild, Snowflake, Config, User, Member, Channel } from "@fosscord/util";
+import { Role, Guild, Snowflake, Config, Member, Channel, DiscordApiErrors, handleFile } from "@fosscord/util";
 import { route } from "@fosscord/api";
-import { DiscordApiErrors } from "@fosscord/util";
 import { ChannelModifySchema } from "../channels/#channel_id";
 
 const router: Router = Router();
@@ -34,6 +33,7 @@ router.post("/", route({ body: "GuildCreateSchema" }), async (req: Request, res:
 
 	await Guild.insert({
 		name: body.name,
+		icon: await handleFile(`/icons/${guild_id}`, body.icon as string),
 		region: Config.get().regions.default,
 		owner_id: req.user_id,
 		afk_timeout: 300,

api/src/routes/invites/index.ts

@@ -15,14 +15,9 @@ router.get("/:code", route({}), async (req: Request, res: Response) => {
 
 router.post("/:code", route({}), async (req: Request, res: Response) => {
 	const { code } = req.params;
+	const invite = await Invite.joinGuild(req.user_id, code);
 
-	const invite = await Invite.findOneOrFail({ code });
+	res.json(invite);
-	if (invite.uses++ >= invite.max_uses) await Invite.delete({ code });
-	else await invite.save();
-
-	await Member.addToGuild(req.user_id, invite.guild_id);
-
-	res.status(200).send(invite);
 });
 
 // * cant use permission of route() function because path doesn't have guild_id/channel_id

api/src/routes/sticker-packs/#id/index.ts

@@ -0,0 +1,18 @@
+import { Request, Response, Router } from "express";
+
+const router: Router = Router();
+
+router.get("/", async (req: Request, res: Response) => {
+	//TODO
+	res.json({
+		id: "",
+		stickers: [],
+		name: "",
+		sku_id: "",
+		cover_sticker_id: "",
+		description: "",
+		banner_asset_id: ""
+	}).status(200);
+});
+
+export default router;

api/src/routes/sticker-packs/index.ts

@@ -0,0 +1,10 @@
+import { Request, Response, Router } from "express";
+
+const router: Router = Router();
+
+router.get("/", async (req: Request, res: Response) => {
+	//TODO
+	res.json({ sticker_packs: [] }).status(200);
+});
+
+export default router;

api/src/routes/users/#id/profile.ts

@@ -19,6 +19,7 @@ router.get("/", route({ test: { response: { body: "UserProfileResponse" } } }),
 		connected_accounts: user.connected_accounts,
 		premium_guild_since: null, // TODO
 		premium_since: null, // TODO
+		mutual_guilds: [], // TODO {id: "", nick: null} when ?with_mutual_guilds=true
 		user: {
 			username: user.username,
 			discriminator: user.discriminator,

api/src/routes/users/@me/channels.ts

@@ -1,15 +1,12 @@
-import { Router, Request, Response } from "express";
+import { Request, Response, Router } from "express";
-import { Channel, ChannelCreateEvent, ChannelType, Snowflake, trimSpecial, User, emitEvent, Recipient } from "@fosscord/util";
+import { Recipient, DmChannelDTO, Channel } from "@fosscord/util";
-import { HTTPError } from "lambert-server";
 import { route } from "@fosscord/api";
-import { In } from "typeorm";
 
 const router: Router = Router();
 
 router.get("/", route({}), async (req: Request, res: Response) => {
-	const recipients = await Recipient.find({ where: { user_id: req.user_id }, relations: ["channel"] });
+	const recipients = await Recipient.find({ where: { user_id: req.user_id, closed: false }, relations: ["channel", "channel.recipients"] });
-
+	res.json(await Promise.all(recipients.map(r => DmChannelDTO.from(r.channel, [req.user_id]))));
-	res.json(recipients.map((x) => x.channel));
 });
 
 export interface DmChannelCreateSchema {
@@ -19,30 +16,7 @@ export interface DmChannelCreateSchema {
 
 router.post("/", route({ body: "DmChannelCreateSchema" }), async (req: Request, res: Response) => {
 	const body = req.body as DmChannelCreateSchema;
-
+	res.json(await Channel.createDMChannel(body.recipients, req.user_id, body.name));
-	body.recipients = body.recipients.filter((x) => x !== req.user_id).unique();
-
-	const recipients = await User.find({ where: body.recipients.map((x) => ({ id: x })) });
-
-	if (recipients.length !== body.recipients.length) {
-		throw new HTTPError("Recipient/s not found");
-	}
-
-	const type = body.recipients.length === 1 ? ChannelType.DM : ChannelType.GROUP_DM;
-	const name = trimSpecial(body.name);
-
-	const channel = await new Channel({
-		name,
-		type,
-		// owner_id only for group dm channels
-		created_at: new Date(),
-		last_message_id: null,
-		recipients: [...body.recipients.map((x) => new Recipient({ user_id: x })), new Recipient({ user_id: req.user_id })]
-	}).save();
-
-	await emitEvent({ event: "CHANNEL_CREATE", data: channel, user_id: req.user_id } as ChannelCreateEvent);
-
-	res.json(channel);
 });
 
 export default router;

api/src/routes/users/@me/connections.ts

@@ -0,0 +1,11 @@
+import { Request, Response, Router } from "express";
+import { route } from "@fosscord/api";
+
+const router: Router = Router();
+
+router.get("/", route({}), async (req: Request, res: Response) => {
+	//TODO
+	res.json([]).status(200);
+});
+
+export default router;

api/src/routes/users/@me/index.ts

@@ -1,7 +1,6 @@
 import { Router, Request, Response } from "express";
-import { User, PrivateUserProjection, emitEvent, UserUpdateEvent } from "@fosscord/util";
+import { User, PrivateUserProjection, emitEvent, UserUpdateEvent, handleFile } from "@fosscord/util";
 import { route } from "@fosscord/api";
-import { handleFile } from "@fosscord/api";
 
 const router: Router = Router();
 

api/src/routes/users/@me/relationships.ts

@@ -18,13 +18,23 @@ const router = Router();
 const userProjection: (keyof User)[] = ["relationships", ...PublicUserProjection];
 
 router.get("/", route({}), async (req: Request, res: Response) => {
-	const user = await User.findOneOrFail({ where: { id: req.user_id }, relations: ["relationships"] });
+	const user = await User.findOneOrFail({ where: { id: req.user_id }, relations: ["relationships", "relationships.to"] });
 
-	return res.json(user.relationships);
+	//TODO DTO
+	const related_users = user.relationships.map((r) => {
+		return {
+			id: r.to.id,
+			type: r.type,
+			nickname: null,
+			user: r.to.toPublicUser()
+		};
+	});
+
+	return res.json(related_users);
 });
 
 export interface RelationshipPutSchema {
-	type: RelationshipType;
+	type?: RelationshipType;
 }
 
 router.put("/:id", route({ body: "RelationshipPutSchema" }), async (req: Request, res: Response) => {
@@ -32,7 +42,7 @@ router.put("/:id", route({ body: "RelationshipPutSchema" }), async (req: Request
 		req,
 		res,
 		await User.findOneOrFail({ id: req.params.id }, { relations: ["relationships", "relationships.to"], select: userProjection }),
-		req.body.type
+		req.body.type ?? RelationshipType.friends
 	);
 });
 
@@ -48,7 +58,10 @@ router.post("/", route({ body: "RelationshipPostSchema" }), async (req: Request,
 		await User.findOneOrFail({
 			relations: ["relationships", "relationships.to"],
 			select: userProjection,
-			where: req.body as { discriminator: string; username: string }
+			where: {
+				discriminator: String(req.body.discriminator).padStart(4, "0"), //Discord send the discriminator as integer, we need to add leading zeroes
+				username: req.body.username
+			}
 		}),
 		req.body.type
 	);

api/src/util/Attachments.ts

@@ -1,12 +0,0 @@
-import { Attachment } from "@fosscord/util";
-import { deleteFile } from "@fosscord/api";
-import { URL } from "url";
-
-export async function deleteMessageAttachments(messageId: string, keep?: Attachment[]) {
-	let attachments = await Attachment.find({ message_id: messageId });
-	if (keep)
-		attachments = attachments.filter(x => !keep.map(k => k.id).includes(x.id));
-	await Promise.all(attachments.map(a => a.remove()));
-
-	attachments.forEach(a => deleteFile((new URL(a.url)).pathname)); //We don't need to await since this is done on the cdn
-}

api/src/util/cdn.ts

@@ -42,9 +42,9 @@ export async function handleFile(path: string, body?: string): Promise<string |
 export async function deleteFile(path: string) {
 	const response = await fetch(`${Config.get().cdn.endpoint || "http://localhost:3003"}${path}`, {
 		headers: {
-			signature: Config.get().security.requestSignature,
+			signature: Config.get().security.requestSignature
 		},
-		method: "DELETE",
+		method: "DELETE"
 	});
 	const result = await response.json();
 

api/src/util/index.ts

@@ -1,5 +1,4 @@
 export * from "./Base64";
-export * from "./cdn";
 export * from "./FieldError";
 export * from "./ipAddress";
 export * from "./Message";

api/src/util/route.ts

@@ -14,6 +14,7 @@ export const ajv = new Ajv({
 	parseDate: true,
 	allowDate: true,
 	schemas,
+	coerceTypes: true,
 	messages: true,
 	strict: true,
 	strictRequired: true

bundle/.vscode/launch.json

@@ -10,9 +10,11 @@
 			"request": "launch",
 			"name": "Launch server bundle",
 			"program": "${workspaceFolder}/dist/start.js",
+			"runtimeArgs": ["-r", "./tsconfig-paths-bootstrap.js"],
 			"preLaunchTask": "tsc: build - tsconfig.json",
-			"outFiles": ["${workspaceFolder}/dist/**/*.js"],
+			"outFiles": ["${workspaceFolder}/dist/**/*.js", "${workspaceFolder}/node_modules/@fosscord/**/*.js"],
-			"envFile": "${workspaceFolder}/.env"
+			"envFile": "${workspaceFolder}/.env",
+			"outDir": "${workspaceFolder}/dist"
 		}
 	]
 }

bundle/package.json

@@ -44,7 +44,7 @@
 		"@types/uuid": "^8.3.0",
 		"@types/ws": "^7.4.0",
 		"@zerollup/ts-transform-paths": "^1.7.18",
-		"ts-patch": "^1.4.4",
+		"ts-node": "^10.2.1",
 		"typescript": "^4.3.5"
 	},
 	"dependencies": {

bundle/src/start.ts

@@ -13,7 +13,7 @@ if (cluster.isMaster && !process.env.masterStarted) {
 		initStats();
 
 		if (cores === 1) {
-			require("./Server.js");
+			require("./Server");
 			return;
 		}
 
@@ -23,10 +23,12 @@ if (cluster.isMaster && !process.env.masterStarted) {
 		}
 
 		cluster.on("exit", (worker: any, code: any, signal: any) => {
-			console.log(`[Worker] died with pid: ${worker.process.pid} , restarting ...`);
+			console.log(
+				`[Worker] died with pid: ${worker.process.pid} , restarting ...`
+			);
 			cluster.fork();
 		});
 	})();
 } else {
-	require("./Server.js");
+	require("./Server");
 }

cdn/src/Server.ts

@@ -58,6 +58,9 @@ export class CDNServer extends Server {
 		this.app.use("/team-icons/", avatarsRoute);
 		this.log("verbose", "[Server] Route /team-icons registered");
 
+		this.app.use("/channel-icons/", avatarsRoute);
+		this.log("verbose", "[Server] Route /channel-icons registered");
+
 		return super.start();
 	}
 

gateway/src/listener/listener.ts

@@ -32,7 +32,7 @@ export async function setupListener(this: WebSocket) {
 	});
 	const guilds = members.map((x) => x.guild);
 	const recipients = await Recipient.find({
-		where: { user_id: this.user_id },
+		where: { user_id: this.user_id, closed: false },
 		relations: ["channel"],
 	});
 	const dm_channels = recipients.map((x) => x.channel);
@@ -116,7 +116,7 @@ async function consume(this: WebSocket, opts: EventOpts) {
 					.has("VIEW_CHANNEL")
 			)
 				return;
-		// TODO: check if user has permission to channel
+			//No break needed here, we need to call the listenEvent function below
 		case "GUILD_CREATE":
 			this.events[id] = await listenEvent(id, consumer, listenOpts);
 			break;

gateway/src/opcodes/Identify.ts

@@ -88,20 +88,17 @@ export async function onIdentify(this: WebSocket, data: Payload) {
 	const user_guild_settings_entries = members.map((x) => x.settings);
 
 	const recipients = await Recipient.find({
-		where: { user_id: this.user_id },
+		where: { user_id: this.user_id, closed: false },
 		relations: ["channel", "channel.recipients", "channel.recipients.user"],
 		// TODO: public user selection
 	});
 	const channels = recipients.map((x) => {
 		// @ts-ignore
 		x.channel.recipients = x.channel.recipients?.map((x) => x.user);
-		// @ts-ignore
+		//TODO is this needed? check if users in group dm that are not friends are sent in the READY event
-		users = users.concat(x.channel.recipients);
+		//users = users.concat(x.channel.recipients);
-		if (x.channel.type === ChannelType.DM) {
+		if (x.channel.isDm()) {
-			x.channel.recipients = [
+			x.channel.recipients = x.channel.recipients!.filter((x) => x.id !== this.user_id);
-				// @ts-ignore
-				x.channel.recipients.find((x) => x.id !== this.user_id),
-			];
 		}
 		return x.channel;
 	});
@@ -111,16 +108,19 @@ export async function onIdentify(this: WebSocket, data: Payload) {
 	});
 	if (!user) return this.close(CLOSECODES.Authentication_failed);
 
-	const public_user = {
+	for (let relation of user.relationships) {
-		username: user.username,
+		const related_user = relation.to
-		discriminator: user.discriminator,
+		const public_related_user = {
-		id: user.id,
+			username: related_user.username,
-		public_flags: user.public_flags,
+			discriminator: related_user.discriminator,
-		avatar: user.avatar,
+			id: related_user.id,
-		bot: user.bot,
+			public_flags: related_user.public_flags,
-		bio: user.bio,
+			avatar: related_user.avatar,
-	};
+			bot: related_user.bot,
-	users.push(public_user);
+			bio: related_user.bio,
+		};
+		users.push(public_related_user);
+	}
 
 	const session_id = genSessionId();
 	this.session_id = session_id; //Set the session of the WebSocket object
@@ -201,7 +201,7 @@ export async function onIdentify(this: WebSocket, data: Payload) {
 		// @ts-ignore
 		experiments: experiments, // TODO
 		guild_join_requests: [], // TODO what is this?
-		users: users.unique(), // TODO
+		users: users.unique(),
 		merged_members: merged_members,
 		// shard // TODO: only for bots sharding
 		// application // TODO for applications

gateway/src/opcodes/index.ts

@@ -21,5 +21,6 @@ export default {
 	8: onRequestGuildMembers,
 	// 9: Invalid Session
 	// 10: Hello
+	// 13: Dm_update
 	14: onLazyRequest,
 };

util/package.json

@@ -31,6 +31,7 @@
 		"@types/amqplib": "^0.8.1",
 		"@types/jsonwebtoken": "^8.5.0",
 		"@types/mongoose-autopopulate": "^0.10.1",
+		"@types/multer": "^1.4.7",
 		"@types/node": "^14.17.9",
 		"@types/node-fetch": "^2.5.12",
 		"jest": "^27.0.6"
@@ -44,6 +45,7 @@
 		"jsonwebtoken": "^8.5.1",
 		"lambert-server": "^1.2.10",
 		"missing-native-js-functions": "^1.2.15",
+		"multer": "^1.4.3",
 		"node-fetch": "^2.6.1",
 		"patch-package": "^6.4.7",
 		"pg": "^8.7.1",

util/src/dtos/DmChannelDTO.ts

@@ -0,0 +1,35 @@
+import { MinimalPublicUserDTO } from "./UserDTO";
+import { Channel, PublicUserProjection, User } from "../entities";
+
+export class DmChannelDTO {
+	icon: string | null;
+	id: string;
+	last_message_id: string | null;
+	name: string | null;
+	origin_channel_id: string | null;
+	owner_id?: string;
+	recipients: MinimalPublicUserDTO[];
+	type: number;
+
+	static async from(channel: Channel, excluded_recipients: string[] = [], origin_channel_id?: string) {
+		const obj = new DmChannelDTO()
+		obj.icon = channel.icon || null
+		obj.id = channel.id
+		obj.last_message_id = channel.last_message_id || null
+		obj.name = channel.name || null
+		obj.origin_channel_id = origin_channel_id || null
+		obj.owner_id = channel.owner_id
+		obj.type = channel.type
+		obj.recipients = (await Promise.all(channel.recipients!.filter(r => !excluded_recipients.includes(r.user_id)).map(async r => {
+			return await User.findOneOrFail({ where: { id: r.user_id }, select: PublicUserProjection })
+		}))).map(u => new MinimalPublicUserDTO(u))
+		return obj
+	}
+
+	excludedRecipients(excluded_recipients: string[]): DmChannelDTO {
+		return {
+			...this,
+			recipients: this.recipients.filter(r => !excluded_recipients.includes(r.id))
+		}
+	}
+}

util/src/dtos/UserDTO.ts

@@ -0,0 +1,17 @@
+import { User } from "../entities";
+
+export class MinimalPublicUserDTO {
+	avatar?: string | null;
+	discriminator: string;
+	id: string;
+	public_flags: number;
+	username: string;
+
+	constructor(user: User) {
+		this.avatar = user.avatar
+		this.discriminator = user.discriminator
+		this.id = user.id
+		this.public_flags = user.public_flags
+		this.username = user.username
+	}
+}

util/src/dtos/index.ts

@@ -0,0 +1,2 @@
+export * from "./DmChannelDTO";
+export * from "./UserDTO";

util/src/entities/Application.ts

@@ -41,7 +41,9 @@ export class Application extends BaseClass {
 	verify_key: string;
 
 	@JoinColumn({ name: "team_id" })
-	@ManyToOne(() => Team)
+	@ManyToOne(() => Team, {
+		onDelete: "CASCADE",
+	})
 	team?: Team;
 
 	@JoinColumn({ name: "guild_id" })

util/src/entities/Attachment.ts

@@ -1,4 +1,6 @@
-import { Column, Entity, JoinColumn, ManyToOne, RelationId } from "typeorm";
+import { BeforeRemove, Column, Entity, JoinColumn, ManyToOne, RelationId } from "typeorm";
+import { URL } from "url";
+import { deleteFile } from "../util/cdn";
 import { BaseClass } from "./BaseClass";
 
 @Entity("attachments")
@@ -29,6 +31,13 @@ export class Attachment extends BaseClass {
 	message_id: string;
 
 	@JoinColumn({ name: "message_id" })
-	@ManyToOne(() => require("./Message").Message, (message: import("./Message").Message) => message.attachments)
+	@ManyToOne(() => require("./Message").Message, (message: import("./Message").Message) => message.attachments, {
+		onDelete: "CASCADE",
+	})
 	message: import("./Message").Message;
+
+	@BeforeRemove()
+	onDelete() {
+		return deleteFile(new URL(this.url).pathname);
+	}
 }

util/src/entities/Ban.ts

@@ -10,7 +10,9 @@ export class Ban extends BaseClass {
 	user_id: string;
 
 	@JoinColumn({ name: "user_id" })
-	@ManyToOne(() => User)
+	@ManyToOne(() => User, {
+		onDelete: "CASCADE",
+	})
 	user: User;
 
 	@Column({ nullable: true })
@@ -18,7 +20,9 @@ export class Ban extends BaseClass {
 	guild_id: string;
 
 	@JoinColumn({ name: "guild_id" })
-	@ManyToOne(() => Guild)
+	@ManyToOne(() => Guild, {
+		onDelete: "CASCADE",
+	})
 	guild: Guild;
 
 	@Column({ nullable: true })

util/src/entities/BaseClass.ts

@@ -1,5 +1,15 @@
 import "reflect-metadata";
-import { BaseEntity, BeforeInsert, BeforeUpdate, EntityMetadata, FindConditions, PrimaryColumn } from "typeorm";
+import {
+	BaseEntity,
+	BeforeInsert,
+	BeforeUpdate,
+	EntityMetadata,
+	FindConditions,
+	getConnection,
+	getManager,
+	PrimaryColumn,
+	RemoveOptions,
+} from "typeorm";
 import { Snowflake } from "../util/Snowflake";
 import "missing-native-js-functions";
 
@@ -69,6 +79,42 @@ export class BaseClassWithoutId extends BaseEntity {
 		const repository = this.getRepository();
 		return repository.decrement(conditions, propertyPath, value);
 	}
+
+	// static async delete<T>(criteria: FindConditions<T>, options?: RemoveOptions) {
+	// 	if (!criteria) throw new Error("You need to specify delete criteria");
+
+	// 	const repository = this.getRepository();
+	// 	const promises = repository.metadata.relations.map(async (x) => {
+	// 		if (x.orphanedRowAction !== "delete") return;
+
+	// 		const foreignKey =
+	// 			x.foreignKeys.find((key) => key.entityMetadata === repository.metadata) ||
+	// 			x.inverseRelation?.foreignKeys[0]; // find foreign key for this entity
+	// 		if (!foreignKey) {
+	// 			throw new Error(
+	// 				`Foreign key not found for entity ${repository.metadata.name} in relation ${x.propertyName}`
+	// 			);
+	// 		}
+	// 		const id = (criteria as any)[foreignKey.referencedColumnNames[0]];
+	// 		if (!id) throw new Error("id missing in criteria options " + foreignKey.referencedColumnNames);
+
+	// 		if (x.relationType === "many-to-many") {
+	// 			return getConnection()
+	// 				.createQueryBuilder()
+	// 				.relation(this, x.propertyName)
+	// 				.of(id)
+	// 				.remove({ [foreignKey.columnNames[0]]: id });
+	// 		} else if (
+	// 			x.relationType === "one-to-one" ||
+	// 			x.relationType === "many-to-one" ||
+	// 			x.relationType === "one-to-many"
+	// 		) {
+	// 			return (x.inverseEntityMetadata.target as any).delete({ [foreignKey.columnNames[0]]: id });
+	// 		}
+	// 	});
+	// 	await Promise.all(promises);
+	// 	return super.delete(criteria, options);
+	// }
 }
 
 export class BaseClass extends BaseClassWithoutId {

util/src/entities/Channel.ts

@@ -1,12 +1,17 @@
-import { Column, Entity, JoinColumn, JoinTable, ManyToMany, ManyToOne, OneToMany, RelationId } from "typeorm";
+import { Column, Entity, JoinColumn, ManyToOne, OneToMany, RelationId } from "typeorm";
 import { BaseClass } from "./BaseClass";
 import { Guild } from "./Guild";
-import { Message } from "./Message";
+import { PublicUserProjection, User } from "./User";
-import { User } from "./User";
 import { HTTPError } from "lambert-server";
-import { emitEvent, getPermission, Snowflake } from "../util";
+import { containsAll, emitEvent, getPermission, Snowflake, trimSpecial } from "../util";
-import { ChannelCreateEvent } from "../interfaces";
+import { ChannelCreateEvent, ChannelRecipientRemoveEvent } from "../interfaces";
 import { Recipient } from "./Recipient";
+import { Message } from "./Message";
+import { ReadState } from "./ReadState";
+import { Invite } from "./Invite";
+import { VoiceState } from "./VoiceState";
+import { Webhook } from "./Webhook";
+import { DmChannelDTO } from "../dtos";
 
 export enum ChannelType {
 	GUILD_TEXT = 0, // a text channel within a server
@@ -31,26 +36,29 @@ export class Channel extends BaseClass {
 	@Column({ nullable: true })
 	name?: string;
 
+	@Column({ type: "text", nullable: true })
+	icon?: string | null;
+
 	@Column({ type: "simple-enum", enum: ChannelType })
 	type: ChannelType;
 
-	@OneToMany(() => Recipient, (recipient: Recipient) => recipient.channel, { cascade: true })
+	@OneToMany(() => Recipient, (recipient: Recipient) => recipient.channel, {
+		cascade: true,
+		orphanedRowAction: "delete",
+	})
 	recipients?: Recipient[];
 
 	@Column({ nullable: true })
-	@RelationId((channel: Channel) => channel.last_message)
 	last_message_id: string;
 
-	@JoinColumn({ name: "last_message_id" })
-	@ManyToOne(() => Message)
-	last_message?: Message;
-
 	@Column({ nullable: true })
 	@RelationId((channel: Channel) => channel.guild)
 	guild_id?: string;
 
 	@JoinColumn({ name: "guild_id" })
-	@ManyToOne(() => Guild)
+	@ManyToOne(() => Guild, {
+		onDelete: "CASCADE",
+	})
 	guild: Guild;
 
 	@Column({ nullable: true })
@@ -100,6 +108,36 @@ export class Channel extends BaseClass {
 	@Column({ nullable: true })
 	topic?: string;
 
+	@OneToMany(() => Invite, (invite: Invite) => invite.channel, {
+		cascade: true,
+		orphanedRowAction: "delete",
+	})
+	invites?: Invite[];
+
+	@OneToMany(() => Message, (message: Message) => message.channel, {
+		cascade: true,
+		orphanedRowAction: "delete",
+	})
+	messages?: Message[];
+
+	@OneToMany(() => VoiceState, (voice_state: VoiceState) => voice_state.channel, {
+		cascade: true,
+		orphanedRowAction: "delete",
+	})
+	voice_states?: VoiceState[];
+
+	@OneToMany(() => ReadState, (read_state: ReadState) => read_state.channel, {
+		cascade: true,
+		orphanedRowAction: "delete",
+	})
+	read_states?: ReadState[];
+
+	@OneToMany(() => Webhook, (webhook: Webhook) => webhook.channel, {
+		cascade: true,
+		orphanedRowAction: "delete",
+	})
+	webhooks?: Webhook[];
+
 	// TODO: DM channel
 	static async createChannel(
 		channel: Partial<Channel>,
@@ -162,6 +200,123 @@ export class Channel extends BaseClass {
 
 		return channel;
 	}
+
+	static async createDMChannel(recipients: string[], creator_user_id: string, name?: string) {
+		recipients = recipients.unique().filter((x) => x !== creator_user_id);
+		const otherRecipientsUsers = await User.find({ where: recipients.map((x) => ({ id: x })) });
+
+		// TODO: check config for max number of recipients
+		if (otherRecipientsUsers.length !== recipients.length) {
+			throw new HTTPError("Recipient/s not found");
+		}
+
+		const type = recipients.length === 1 ? ChannelType.DM : ChannelType.GROUP_DM;
+
+		let channel = null;
+
+		const channelRecipients = [...recipients, creator_user_id];
+
+		const userRecipients = await Recipient.find({
+			where: { user_id: creator_user_id },
+			relations: ["channel", "channel.recipients"],
+		});
+
+		for (let ur of userRecipients) {
+			let re = ur.channel.recipients!.map((r) => r.user_id);
+			if (re.length === channelRecipients.length) {
+				if (containsAll(re, channelRecipients)) {
+					if (channel == null) {
+						channel = ur.channel;
+						await ur.assign({ closed: false }).save();
+					}
+				}
+			}
+		}
+
+		if (channel == null) {
+			name = trimSpecial(name);
+
+			channel = await new Channel({
+				name,
+				type,
+				owner_id: type === ChannelType.DM ? undefined : creator_user_id,
+				created_at: new Date(),
+				last_message_id: null,
+				recipients: channelRecipients.map(
+					(x) =>
+						new Recipient({ user_id: x, closed: !(type === ChannelType.GROUP_DM || x === creator_user_id) })
+				),
+			}).save();
+		}
+
+		const channel_dto = await DmChannelDTO.from(channel);
+
+		if (type === ChannelType.GROUP_DM) {
+			for (let recipient of channel.recipients!) {
+				await emitEvent({
+					event: "CHANNEL_CREATE",
+					data: channel_dto.excludedRecipients([recipient.user_id]),
+					user_id: recipient.user_id,
+				});
+			}
+		} else {
+			await emitEvent({ event: "CHANNEL_CREATE", data: channel_dto, user_id: creator_user_id });
+		}
+
+		return channel_dto.excludedRecipients([creator_user_id]);
+	}
+
+	static async removeRecipientFromChannel(channel: Channel, user_id: string) {
+		await Recipient.delete({ channel_id: channel.id, user_id: user_id });
+		channel.recipients = channel.recipients?.filter((r) => r.user_id !== user_id);
+
+		if (channel.recipients?.length === 0) {
+			await Channel.deleteChannel(channel);
+			await emitEvent({
+				event: "CHANNEL_DELETE",
+				data: await DmChannelDTO.from(channel, [user_id]),
+				user_id: user_id,
+			});
+			return;
+		}
+
+		await emitEvent({
+			event: "CHANNEL_DELETE",
+			data: await DmChannelDTO.from(channel, [user_id]),
+			user_id: user_id,
+		});
+
+		//If the owner leave we make the first recipient in the list the new owner
+		if (channel.owner_id === user_id) {
+			channel.owner_id = channel.recipients!.find((r) => r.user_id !== user_id)!.user_id; //Is there a criteria to choose the new owner?
+			await emitEvent({
+				event: "CHANNEL_UPDATE",
+				data: await DmChannelDTO.from(channel, [user_id]),
+				channel_id: channel.id,
+			});
+		}
+
+		await channel.save();
+
+		await emitEvent({
+			event: "CHANNEL_RECIPIENT_REMOVE",
+			data: {
+				channel_id: channel.id,
+				user: await User.findOneOrFail({ where: { id: user_id }, select: PublicUserProjection }),
+			},
+			channel_id: channel.id,
+		} as ChannelRecipientRemoveEvent);
+	}
+
+	static async deleteChannel(channel: Channel) {
+		await Message.delete({ channel_id: channel.id }); //TODO we should also delete the attachments from the cdn but to do that we need to move cdn.ts in util
+		//TODO before deleting the channel we should check and delete other relations
+		await Channel.delete({ id: channel.id });
+	}
+
+	isDm() {
+		return this.type === ChannelType.DM || this.type === ChannelType.GROUP_DM;
+	}
 }
 
 export interface ChannelPermissionOverwrite {

util/src/entities/Config.ts

@@ -110,13 +110,13 @@ export interface ConfigValue {
 	};
 	register: {
 		email: {
-			necessary: boolean; // we have to use necessary instead of required as the cli tool uses json schema and can't use required
+			required: boolean;
 			allowlist: boolean;
 			blocklist: boolean;
 			domains: string[];
 		};
 		dateOfBirth: {
-			necessary: boolean;
+			required: boolean;
 			minimum: number; // in years
 		};
 		requireCaptcha: boolean;
@@ -125,6 +125,7 @@ export interface ConfigValue {
 		allowMultipleAccounts: boolean;
 		blockProxies: boolean;
 		password: {
+			required: boolean;
 			minLength: number;
 			minNumbers: number;
 			minUpperCase: number;
@@ -246,14 +247,14 @@ export const DefaultConfigOptions: ConfigValue = {
 	},
 	register: {
 		email: {
-			necessary: true,
+			required: false,
 			allowlist: false,
 			blocklist: true,
 			domains: [], // TODO: efficiently save domain blocklist in database
 			// domains: fs.readFileSync(__dirname + "/blockedEmailDomains.txt", { encoding: "utf8" }).split("\n"),
 		},
 		dateOfBirth: {
-			necessary: true,
+			required: false,
 			minimum: 13,
 		},
 		requireInvite: false,
@@ -262,6 +263,7 @@ export const DefaultConfigOptions: ConfigValue = {
 		allowMultipleAccounts: true,
 		blockProxies: true,
 		password: {
+			required: false,
 			minLength: 8,
 			minNumbers: 2,
 			minUpperCase: 2,

util/src/entities/ConnectedAccount.ts

@@ -11,7 +11,9 @@ export class ConnectedAccount extends BaseClass {
 	user_id: string;
 
 	@JoinColumn({ name: "user_id" })
-	@ManyToOne(() => User)
+	@ManyToOne(() => User, {
+		onDelete: "CASCADE",
+	})
 	user: User;
 
 	@Column({ select: false })

util/src/entities/Emoji.ts

@@ -15,7 +15,9 @@ export class Emoji extends BaseClass {
 	guild_id: string;
 
 	@JoinColumn({ name: "guild_id" })
-	@ManyToOne(() => Guild)
+	@ManyToOne(() => Guild, {
+		onDelete: "CASCADE",
+	})
 	guild: Guild;
 
 	@Column()

util/src/entities/Guild.ts

@@ -81,7 +81,10 @@ export class Guild extends BaseClass {
 	// application?: string;
 
 	@JoinColumn({ name: "ban_ids" })
-	@OneToMany(() => Ban, (ban: Ban) => ban.guild)
+	@OneToMany(() => Ban, (ban: Ban) => ban.guild, {
+		cascade: true,
+		orphanedRowAction: "delete",
+	})
 	bans: Ban[];
 
 	@Column({ nullable: true })
@@ -124,15 +127,26 @@ export class Guild extends BaseClass {
 	@Column({ nullable: true })
 	presence_count?: number; // users online
 
-	@OneToMany(() => Member, (member: Member) => member.guild)
+	@OneToMany(() => Member, (member: Member) => member.guild, {
+		cascade: true,
+		orphanedRowAction: "delete",
+		onDelete: "CASCADE",
+	})
 	members: Member[];
 
 	@JoinColumn({ name: "role_ids" })
-	@OneToMany(() => Role, (role: Role) => role.guild)
+	@OneToMany(() => Role, (role: Role) => role.guild, {
+		cascade: true,
+		orphanedRowAction: "delete",
+		onDelete: "CASCADE",
+	})
 	roles: Role[];
 
 	@JoinColumn({ name: "channel_ids" })
-	@OneToMany(() => Channel, (channel: Channel) => channel.guild)
+	@OneToMany(() => Channel, (channel: Channel) => channel.guild, {
+		cascade: true,
+		orphanedRowAction: "delete",
+	})
 	channels: Channel[];
 
 	@Column({ nullable: true })
@@ -144,23 +158,43 @@ export class Guild extends BaseClass {
 	template: Template;
 
 	@JoinColumn({ name: "emoji_ids" })
-	@OneToMany(() => Emoji, (emoji: Emoji) => emoji.guild)
+	@OneToMany(() => Emoji, (emoji: Emoji) => emoji.guild, {
+		cascade: true,
+		orphanedRowAction: "delete",
+		onDelete: "CASCADE",
+	})
 	emojis: Emoji[];
 
 	@JoinColumn({ name: "sticker_ids" })
-	@OneToMany(() => Sticker, (sticker: Sticker) => sticker.guild)
+	@OneToMany(() => Sticker, (sticker: Sticker) => sticker.guild, {
+		cascade: true,
+		orphanedRowAction: "delete",
+		onDelete: "CASCADE",
+	})
 	stickers: Sticker[];
 
 	@JoinColumn({ name: "invite_ids" })
-	@OneToMany(() => Invite, (invite: Invite) => invite.guild)
+	@OneToMany(() => Invite, (invite: Invite) => invite.guild, {
+		cascade: true,
+		orphanedRowAction: "delete",
+		onDelete: "CASCADE",
+	})
 	invites: Invite[];
 
 	@JoinColumn({ name: "voice_state_ids" })
-	@OneToMany(() => VoiceState, (voicestate: VoiceState) => voicestate.guild)
+	@OneToMany(() => VoiceState, (voicestate: VoiceState) => voicestate.guild, {
+		cascade: true,
+		orphanedRowAction: "delete",
+		onDelete: "CASCADE",
+	})
 	voice_states: VoiceState[];
 
 	@JoinColumn({ name: "webhook_ids" })
-	@OneToMany(() => Webhook, (webhook: Webhook) => webhook.guild)
+	@OneToMany(() => Webhook, (webhook: Webhook) => webhook.guild, {
+		cascade: true,
+		orphanedRowAction: "delete",
+		onDelete: "CASCADE",
+	})
 	webhooks: Webhook[];
 
 	@Column({ nullable: true })

util/src/entities/Invite.ts

@@ -1,4 +1,5 @@
 import { Column, Entity, JoinColumn, ManyToOne, PrimaryColumn, RelationId } from "typeorm";
+import { Member } from ".";
 import { BaseClass } from "./BaseClass";
 import { Channel } from "./Channel";
 import { Guild } from "./Guild";
@@ -34,7 +35,9 @@ export class Invite extends BaseClass {
 	guild_id: string;
 
 	@JoinColumn({ name: "guild_id" })
-	@ManyToOne(() => Guild)
+	@ManyToOne(() => Guild, {
+		onDelete: "CASCADE",
+	})
 	guild: Guild;
 
 	@Column({ nullable: true })
@@ -42,7 +45,9 @@ export class Invite extends BaseClass {
 	channel_id: string;
 
 	@JoinColumn({ name: "channel_id" })
-	@ManyToOne(() => Channel)
+	@ManyToOne(() => Channel, {
+		onDelete: "CASCADE",
+	})
 	channel: Channel;
 
 	@Column({ nullable: true })
@@ -58,9 +63,20 @@ export class Invite extends BaseClass {
 	target_user_id: string;
 
 	@JoinColumn({ name: "target_user_id" })
-	@ManyToOne(() => User)
+	@ManyToOne(() => User, {
+		onDelete: "CASCADE",
+	})
 	target_user?: string; // could be used for "User specific invites" https://github.com/fosscord/fosscord/issues/62
 
 	@Column({ nullable: true })
 	target_user_type?: number;
+
+	static async joinGuild(user_id: string, code: string) {
+		const invite = await Invite.findOneOrFail({ code });
+		if (invite.uses++ >= invite.max_uses && invite.max_uses !== 0) await Invite.delete({ code });
+		else await invite.save();
+
+		await Member.addToGuild(user_id, invite.guild_id);
+		return invite;
+	}
 }

util/src/entities/Member.ts

@@ -39,7 +39,9 @@ export class Member extends BaseClassWithoutId {
 	id: string;
 
 	@JoinColumn({ name: "id" })
-	@ManyToOne(() => User)
+	@ManyToOne(() => User, {
+		onDelete: "CASCADE",
+	})
 	user: User;
 
 	@Column()
@@ -47,7 +49,9 @@ export class Member extends BaseClassWithoutId {
 	guild_id: string;
 
 	@JoinColumn({ name: "guild_id" })
-	@ManyToOne(() => Guild)
+	@ManyToOne(() => Guild, {
+		onDelete: "CASCADE",
+	})
 	guild: Guild;
 
 	@Column({ nullable: true })
@@ -55,7 +59,6 @@ export class Member extends BaseClassWithoutId {
 
 	@JoinTable({
 		name: "member_roles",
-
 		joinColumn: { name: "index", referencedColumnName: "index" },
 		inverseJoinColumn: {
 			name: "role_id",

util/src/entities/Message.ts

@@ -8,12 +8,14 @@ import {
 	Column,
 	CreateDateColumn,
 	Entity,
+	FindConditions,
 	JoinColumn,
 	JoinTable,
 	ManyToMany,
 	ManyToOne,
 	OneToMany,
 	RelationId,
+	RemoveOptions,
 	UpdateDateColumn,
 } from "typeorm";
 import { BaseClass } from "./BaseClass";
@@ -52,7 +54,9 @@ export class Message extends BaseClass {
 	channel_id: string;
 
 	@JoinColumn({ name: "channel_id" })
-	@ManyToOne(() => Channel)
+	@ManyToOne(() => Channel, {
+		onDelete: "CASCADE",
+	})
 	channel: Channel;
 
 	@Column({ nullable: true })
@@ -60,7 +64,9 @@ export class Message extends BaseClass {
 	guild_id?: string;
 
 	@JoinColumn({ name: "guild_id" })
-	@ManyToOne(() => Guild)
+	@ManyToOne(() => Guild, {
+		onDelete: "CASCADE",
+	})
 	guild?: Guild;
 
 	@Column({ nullable: true })
@@ -68,7 +74,9 @@ export class Message extends BaseClass {
 	author_id: string;
 
 	@JoinColumn({ name: "author_id", referencedColumnName: "id" })
-	@ManyToOne(() => User)
+	@ManyToOne(() => User, {
+		onDelete: "CASCADE",
+	})
 	author?: User;
 
 	@Column({ nullable: true })
@@ -112,7 +120,7 @@ export class Message extends BaseClass {
 	mention_everyone?: boolean;
 
 	@JoinTable({ name: "message_user_mentions" })
-	@ManyToMany(() => User)
+	@ManyToMany(() => User, { orphanedRowAction: "delete", onDelete: "CASCADE", cascade: true })
 	mentions: User[];
 
 	@JoinTable({ name: "message_role_mentions" })
@@ -127,8 +135,10 @@ export class Message extends BaseClass {
 	@ManyToMany(() => Sticker)
 	sticker_items?: Sticker[];
 
-	@JoinColumn({ name: "attachment_ids" })
+	@OneToMany(() => Attachment, (attachment: Attachment) => attachment.message, {
-	@OneToMany(() => Attachment, (attachment: Attachment) => attachment.message, { cascade: true })
+		cascade: true,
+		orphanedRowAction: "delete",
+	})
 	attachments?: Attachment[];
 
 	@Column({ type: "simple-json" })

util/src/entities/ReadState.ts

@@ -15,7 +15,9 @@ export class ReadState extends BaseClass {
 	channel_id: string;
 
 	@JoinColumn({ name: "channel_id" })
-	@ManyToOne(() => Channel)
+	@ManyToOne(() => Channel, {
+		onDelete: "CASCADE",
+	})
 	channel: Channel;
 
 	@Column({ nullable: true })
@@ -23,7 +25,9 @@ export class ReadState extends BaseClass {
 	user_id: string;
 
 	@JoinColumn({ name: "user_id" })
-	@ManyToOne(() => User)
+	@ManyToOne(() => User, {
+		onDelete: "CASCADE",
+	})
 	user: User;
 
 	@Column({ nullable: true })

util/src/entities/Recipient.ts

@@ -8,7 +8,9 @@ export class Recipient extends BaseClass {
 	channel_id: string;
 
 	@JoinColumn({ name: "channel_id" })
-	@ManyToOne(() => require("./Channel").Channel)
+	@ManyToOne(() => require("./Channel").Channel, {
+		onDelete: "CASCADE",
+	})
 	channel: import("./Channel").Channel;
 
 	@Column()
@@ -16,8 +18,13 @@ export class Recipient extends BaseClass {
 	user_id: string;
 
 	@JoinColumn({ name: "user_id" })
-	@ManyToOne(() => require("./User").User)
+	@ManyToOne(() => require("./User").User, {
+		onDelete: "CASCADE",
+	})
 	user: import("./User").User;
 
+	@Column({ default: false })
+	closed: boolean;
+
 	// TODO: settings/mute/nick/added at/encryption keys/read_state
 }

util/src/entities/Relationship.ts

@@ -17,7 +17,9 @@ export class Relationship extends BaseClass {
 	from_id: string;
 
 	@JoinColumn({ name: "from_id" })
-	@ManyToOne(() => User)
+	@ManyToOne(() => User, {
+		onDelete: "CASCADE",
+	})
 	from: User;
 
 	@Column({})
@@ -25,7 +27,9 @@ export class Relationship extends BaseClass {
 	to_id: string;
 
 	@JoinColumn({ name: "to_id" })
-	@ManyToOne(() => User)
+	@ManyToOne(() => User, {
+		onDelete: "CASCADE",
+	})
 	to: User;
 
 	@Column({ nullable: true })

util/src/entities/Role.ts

@@ -10,7 +10,9 @@ export class Role extends BaseClass {
 	guild_id: string;
 
 	@JoinColumn({ name: "guild_id" })
-	@ManyToOne(() => Guild)
+	@ManyToOne(() => Guild, {
+		onDelete: "CASCADE",
+	})
 	guild: Guild;
 
 	@Column()

util/src/entities/Session.ts

@@ -11,7 +11,9 @@ export class Session extends BaseClass {
 	user_id: string;
 
 	@JoinColumn({ name: "user_id" })
-	@ManyToOne(() => User)
+	@ManyToOne(() => User, {
+		onDelete: "CASCADE",
+	})
 	user: User;
 
 	//TODO check, should be 32 char long hex string

util/src/entities/Sticker.ts

@@ -31,7 +31,9 @@ export class Sticker extends BaseClass {
 	guild_id?: string;
 
 	@JoinColumn({ name: "guild_id" })
-	@ManyToOne(() => Guild)
+	@ManyToOne(() => Guild, {
+		onDelete: "CASCADE",
+	})
 	guild?: Guild;
 
 	@Column({ type: "simple-enum", enum: StickerType })

util/src/entities/Team.ts

@@ -9,7 +9,9 @@ export class Team extends BaseClass {
 	icon?: string;
 
 	@JoinColumn({ name: "member_ids" })
-	@OneToMany(() => TeamMember, (member: TeamMember) => member.team)
+	@OneToMany(() => TeamMember, (member: TeamMember) => member.team, {
+		orphanedRowAction: "delete",
+	})
 	members: TeamMember[];
 
 	@Column()

util/src/entities/TeamMember.ts

@@ -20,7 +20,9 @@ export class TeamMember extends BaseClass {
 	team_id: string;
 
 	@JoinColumn({ name: "team_id" })
-	@ManyToOne(() => require("./Team").Team, (team: import("./Team").Team) => team.members)
+	@ManyToOne(() => require("./Team").Team, (team: import("./Team").Team) => team.members, {
+		onDelete: "CASCADE",
+	})
 	team: import("./Team").Team;
 
 	@Column({ nullable: true })
@@ -28,6 +30,8 @@ export class TeamMember extends BaseClass {
 	user_id: string;
 
 	@JoinColumn({ name: "user_id" })
-	@ManyToOne(() => User)
+	@ManyToOne(() => User, {
+		onDelete: "CASCADE",
+	})
 	user: User;
 }

util/src/entities/User.ts

@@ -124,14 +124,20 @@ export class User extends BaseClass {
 	flags: string; // UserFlags
 
 	@Column()
-	public_flags: string;
+	public_flags: number;
 
 	@JoinColumn({ name: "relationship_ids" })
-	@OneToMany(() => Relationship, (relationship: Relationship) => relationship.from)
+	@OneToMany(() => Relationship, (relationship: Relationship) => relationship.from, {
+		cascade: true,
+		orphanedRowAction: "delete",
+	})
 	relationships: Relationship[];
 
 	@JoinColumn({ name: "connected_account_ids" })
-	@OneToMany(() => ConnectedAccount, (account: ConnectedAccount) => account.user)
+	@OneToMany(() => ConnectedAccount, (account: ConnectedAccount) => account.user, {
+		cascade: true,
+		orphanedRowAction: "delete",
+	})
 	connected_accounts: ConnectedAccount[];
 
 	@Column({ type: "simple-json", select: false })

util/src/entities/VoiceState.ts

@@ -13,7 +13,9 @@ export class VoiceState extends BaseClass {
 	guild_id: string;
 
 	@JoinColumn({ name: "guild_id" })
-	@ManyToOne(() => Guild)
+	@ManyToOne(() => Guild, {
+		onDelete: "CASCADE",
+	})
 	guild?: Guild;
 
 	@Column({ nullable: true })
@@ -21,7 +23,9 @@ export class VoiceState extends BaseClass {
 	channel_id: string;
 
 	@JoinColumn({ name: "channel_id" })
-	@ManyToOne(() => Channel)
+	@ManyToOne(() => Channel, {
+		onDelete: "CASCADE",
+	})
 	channel: Channel;
 
 	@Column({ nullable: true })
@@ -29,11 +33,15 @@ export class VoiceState extends BaseClass {
 	user_id: string;
 
 	@JoinColumn({ name: "user_id" })
-	@ManyToOne(() => User)
+	@ManyToOne(() => User, {
+		onDelete: "CASCADE",
+	})
 	user: User;
 
 	// @JoinColumn([{ name: "user_id", referencedColumnName: "id" },{ name: "guild_id", referencedColumnName: "guild_id" }])
-	// @ManyToOne(() => Member)
+	// @ManyToOne(() => Member, {
+	// 	onDelete: "CASCADE",
+	// })
 	//TODO find a way to make it work without breaking Guild.voice_states
 	member: Member;
 

util/src/entities/Webhook.ts

@@ -32,7 +32,9 @@ export class Webhook extends BaseClass {
 	guild_id: string;
 
 	@JoinColumn({ name: "guild_id" })
-	@ManyToOne(() => Guild)
+	@ManyToOne(() => Guild, {
+		onDelete: "CASCADE",
+	})
 	guild: Guild;
 
 	@Column({ nullable: true })
@@ -40,7 +42,9 @@ export class Webhook extends BaseClass {
 	channel_id: string;
 
 	@JoinColumn({ name: "channel_id" })
-	@ManyToOne(() => Channel)
+	@ManyToOne(() => Channel, {
+		onDelete: "CASCADE",
+	})
 	channel: Channel;
 
 	@Column({ nullable: true })
@@ -48,7 +52,9 @@ export class Webhook extends BaseClass {
 	application_id: string;
 
 	@JoinColumn({ name: "application_id" })
-	@ManyToOne(() => Application)
+	@ManyToOne(() => Application, {
+		onDelete: "CASCADE",
+	})
 	application: Application;
 
 	@Column({ nullable: true })
@@ -56,7 +62,9 @@ export class Webhook extends BaseClass {
 	user_id: string;
 
 	@JoinColumn({ name: "user_id" })
-	@ManyToOne(() => User)
+	@ManyToOne(() => User, {
+		onDelete: "CASCADE",
+	})
 	user: User;
 
 	@Column({ nullable: true })
@@ -64,6 +72,8 @@ export class Webhook extends BaseClass {
 	source_guild_id: string;
 
 	@JoinColumn({ name: "source_guild_id" })
-	@ManyToOne(() => Guild)
+	@ManyToOne(() => Guild, {
+		onDelete: "CASCADE",
+	})
 	source_guild: Guild;
 }

util/src/index.ts

@@ -4,6 +4,7 @@ import "reflect-metadata";
 export * from "./util/index";
 export * from "./interfaces/index";
 export * from "./entities/index";
+export * from "./dtos/index";
 
 // import Config from "../util/Config";
 // import db, { MongooseCache, toObject } from "./util/Database";

util/src/interfaces/Event.ts

@@ -127,6 +127,22 @@ export interface ChannelPinsUpdateEvent extends Event {
 	};
 }
 
+export interface ChannelRecipientAddEvent extends Event {
+	event: "CHANNEL_RECIPIENT_ADD";
+	data: {
+		channel_id: string;
+		user: User;
+	};
+}
+
+export interface ChannelRecipientRemoveEvent extends Event {
+	event: "CHANNEL_RECIPIENT_REMOVE";
+	data: {
+		channel_id: string;
+		user: User;
+	};
+}
+
 export interface GuildCreateEvent extends Event {
 	event: "GUILD_CREATE";
 	data: Guild & {
@@ -436,6 +452,8 @@ export type EventData =
 	| ChannelUpdateEvent
 	| ChannelDeleteEvent
 	| ChannelPinsUpdateEvent
+	| ChannelRecipientAddEvent
+	| ChannelRecipientRemoveEvent
 	| GuildCreateEvent
 	| GuildUpdateEvent
 	| GuildDeleteEvent
@@ -482,6 +500,8 @@ export enum EVENTEnum {
 	ChannelUpdate = "CHANNEL_UPDATE",
 	ChannelDelete = "CHANNEL_DELETE",
 	ChannelPinsUpdate = "CHANNEL_PINS_UPDATE",
+	ChannelRecipientAdd = "CHANNEL_RECIPIENT_ADD",
+	ChannelRecipientRemove = "CHANNEL_RECIPIENT_REMOVE",
 	GuildCreate = "GUILD_CREATE",
 	GuildUpdate = "GUILD_UPDATE",
 	GuildDelete = "GUILD_DELETE",
@@ -525,6 +545,8 @@ export type EVENT =
 	| "CHANNEL_UPDATE"
 	| "CHANNEL_DELETE"
 	| "CHANNEL_PINS_UPDATE"
+	| "CHANNEL_RECIPIENT_ADD"
+	| "CHANNEL_RECIPIENT_REMOVE"
 	| "GUILD_CREATE"
 	| "GUILD_UPDATE"
 	| "GUILD_DELETE"

util/src/util/Array.ts

@@ -0,0 +1,3 @@
+export function containsAll(arr: any[], target: any[]) {
+	return target.every(v => arr.includes(v));
+}

util/src/util/Database.ts

@@ -21,7 +21,7 @@ export function initDatabase() {
 		//
 		entities: Object.values(Models).filter((x) => x.constructor.name !== "Object"),
 		synchronize: true,
-		logging: false,
+		logging: true,
 		cache: {
 			duration: 1000 * 3, // cache all find queries for 3 seconds
 		},

util/src/util/Permissions.ts

@@ -92,6 +92,7 @@ export class Permissions extends BitField {
 	}
 
 	overwriteChannel(overwrites: ChannelPermissionOverwrite[]) {
+		if (!overwrites) return this
 		if (!this.cache) throw new Error("permission chache not available");
 		overwrites = overwrites.filter((x) => {
 			if (x.type === 0 && this.cache.roles?.some((r) => r.id === x.id)) return true;

util/src/util/cdn.ts

@@ -0,0 +1,54 @@
+import FormData from "form-data";
+import { HTTPError } from "lambert-server";
+import fetch from "node-fetch";
+import { Config } from "./Config";
+import multer from "multer";
+
+export async function uploadFile(path: string, file: Express.Multer.File) {
+	const form = new FormData();
+	form.append("file", file.buffer, {
+		contentType: file.mimetype,
+		filename: file.originalname,
+	});
+
+	const response = await fetch(`${Config.get().cdn.endpoint || "http://localhost:3003"}${path}`, {
+		headers: {
+			signature: Config.get().security.requestSignature,
+			...form.getHeaders(),
+		},
+		method: "POST",
+		body: form,
+	});
+	const result = await response.json();
+
+	if (response.status !== 200) throw result;
+	return result;
+}
+
+export async function handleFile(path: string, body?: string): Promise<string | undefined> {
+	if (!body || !body.startsWith("data:")) return body;
+	try {
+		const mimetype = body.split(":")[1].split(";")[0];
+		const buffer = Buffer.from(body.split(",")[1], "base64");
+
+		// @ts-ignore
+		const { id } = await uploadFile(path, { buffer, mimetype, originalname: "banner" });
+		return id;
+	} catch (error) {
+		console.error(error);
+		throw new HTTPError("Invalid " + path);
+	}
+}
+
+export async function deleteFile(path: string) {
+	const response = await fetch(`${Config.get().cdn.endpoint || "http://localhost:3003"}${path}`, {
+		headers: {
+			signature: Config.get().security.requestSignature,
+		},
+		method: "DELETE",
+	});
+	const result = await response.json();
+
+	if (response.status !== 200) throw result;
+	return result;
+}

util/src/util/index.ts

@@ -1,6 +1,7 @@
 export * from "./ApiError";
 export * from "./BitField";
 export * from "./checkToken";
+export * from "./cdn";
 export * from "./Config";
 export * from "./Constants";
 export * from "./Database";
@@ -12,3 +13,4 @@ export * from "./RabbitMQ";
 export * from "./Regex";
 export * from "./Snowflake";
 export * from "./String";
+export * from "./Array";