From 994406e5cea886444838ce71c4aaee46663be1a9 Mon Sep 17 00:00:00 2001
From: Flam3rboy <34555296+Flam3rboy@users.noreply.github.com>
Date: Sun, 19 Sep 2021 18:46:22 +0200
Subject: [PATCH 1/5] :art: remove deleteMessageAttachments and move to entity

---
 .../#channel_id/messages/#message_id/index.ts        |  3 ---
 api/src/util/Attachments.ts                          | 12 ------------
 api/src/util/index.ts                                |  1 -
 util/src/entities/Attachment.ts                      |  9 ++++++++-
 4 files changed, 8 insertions(+), 17 deletions(-)
 delete mode 100644 api/src/util/Attachments.ts

diff --git a/api/src/routes/channels/#channel_id/messages/#message_id/index.ts b/api/src/routes/channels/#channel_id/messages/#message_id/index.ts
index b5220fab..7f7de264 100644
--- a/api/src/routes/channels/#channel_id/messages/#message_id/index.ts
+++ b/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({
diff --git a/api/src/util/Attachments.ts b/api/src/util/Attachments.ts
deleted file mode 100644
index addda97f..00000000
--- a/api/src/util/Attachments.ts
+++ /dev/null
@@ -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
-}
diff --git a/api/src/util/index.ts b/api/src/util/index.ts
index 4b1e8e77..3e47ce4e 100644
--- a/api/src/util/index.ts
+++ b/api/src/util/index.ts
@@ -1,5 +1,4 @@
 export * from "./Base64";
-export * from "./cdn";
 export * from "./FieldError";
 export * from "./ipAddress";
 export * from "./Message";
diff --git a/util/src/entities/Attachment.ts b/util/src/entities/Attachment.ts
index ca893400..82c5ecf5 100644
--- a/util/src/entities/Attachment.ts
+++ b/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")
@@ -31,4 +33,9 @@ export class Attachment extends BaseClass {
 	@JoinColumn({ name: "message_id" })
 	@ManyToOne(() => require("./Message").Message, (message: import("./Message").Message) => message.attachments)
 	message: import("./Message").Message;
+
+	@BeforeRemove()
+	onDelete() {
+		return deleteFile(new URL(this.url).pathname);
+	}
 }

From 705206ec1b020bbae2b92de1e98e8a7609a6c850 Mon Sep 17 00:00:00 2001
From: Flam3rboy <34555296+Flam3rboy@users.noreply.github.com>
Date: Sun, 19 Sep 2021 18:47:38 +0200
Subject: [PATCH 2/5] :art: add orphanedRowAction and cascade onDelete to
 entities

---
 util/package-lock.json       | Bin 446397 -> 459190 bytes
 util/package.json            |   2 +
 util/src/entities/Channel.ts |  71 +++++++++++++++++++++++++++++++----
 util/src/entities/Guild.ts   |  54 +++++++++++++++++++++-----
 util/src/entities/Message.ts |  11 ++++--
 util/src/util/cdn.ts         |  54 ++++++++++++++++++++++++++
 util/src/util/index.ts       |   1 +
 7 files changed, 173 insertions(+), 20 deletions(-)
 create mode 100644 util/src/util/cdn.ts

diff --git a/util/package-lock.json b/util/package-lock.json
index 4b0f1f1517e9ee45bfdacc0a32ed79d16784a74c..e5a62d0f36a1fa06c3e0b137b0fd5e4f3349a0d8 100644
GIT binary patch
delta 5089
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
UTdsz2A;@5N&2aB+s#^m80lVCg3;+NC

delta 219
zcmV<103`pmgB-n|8?fgAv;P630h1782(!rp^oz6Em5vCrZ=Z1lvm>Q@1G6uzZ6C8>
z%v(IS>j?qm9k=2x0Y@N*TTlVFTTlYTF1Im(0<*!B+R`7FAdv>2mwYe-4!5900~sur
z>9hk4w>!560|A$Cv;!Bno^k`w)VD@W1S1HyWL5;`1Gjuz1W*H)7mx)Gw?JY9X&Sd+
zeFWGvw=1&*ni-b{r~((4TLc6VmmnYkHJ3jx0eH72)C6c7w}bEm_WPGHfdbRFAMXV#
Vp_kM{1HQMvkp{jbw=TB^h)U^@SL^@)

diff --git a/util/package.json b/util/package.json
index 751484af..2fa93f9b 100644
--- a/util/package.json
+++ b/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",
diff --git a/util/src/entities/Channel.ts b/util/src/entities/Channel.ts
index fc954f63..0196fb3e 100644
--- a/util/src/entities/Channel.ts
+++ b/util/src/entities/Channel.ts
@@ -1,12 +1,26 @@
-import { Column, Entity, JoinColumn, JoinTable, ManyToMany, ManyToOne, OneToMany, RelationId } from "typeorm";
+import {
+	Column,
+	Entity,
+	FindConditions,
+	JoinColumn,
+	ManyToOne,
+	ObjectID,
+	OneToMany,
+	RelationId,
+	RemoveOptions,
+} from "typeorm";
 import { BaseClass } from "./BaseClass";
 import { Guild } from "./Guild";
-import { Message } from "./Message";
 import { User } from "./User";
 import { HTTPError } from "lambert-server";
 import { emitEvent, getPermission, Snowflake } from "../util";
 import { ChannelCreateEvent } 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";
 
 export enum ChannelType {
 	GUILD_TEXT = 0, // a text channel within a server
@@ -31,20 +45,22 @@ 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",
+		onDelete: "CASCADE",
+	})
 	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;
@@ -100,6 +116,41 @@ export class Channel extends BaseClass {
 	@Column({ nullable: true })
 	topic?: string;
 
+	@OneToMany(() => Invite, (invite: Invite) => invite.channel, {
+		cascade: true,
+		orphanedRowAction: "delete",
+		onDelete: "CASCADE",
+	})
+	invites?: Invite[];
+
+	@OneToMany(() => Message, (message: Message) => message.channel, {
+		cascade: true,
+		orphanedRowAction: "delete",
+		onDelete: "CASCADE",
+	})
+	messages?: Message[];
+
+	@OneToMany(() => VoiceState, (voice_state: VoiceState) => voice_state.channel, {
+		cascade: true,
+		orphanedRowAction: "delete",
+		onDelete: "CASCADE",
+	})
+	voice_states?: VoiceState[];
+
+	@OneToMany(() => ReadState, (read_state: ReadState) => read_state.channel, {
+		cascade: true,
+		orphanedRowAction: "delete",
+		onDelete: "CASCADE",
+	})
+	read_states?: ReadState[];
+
+	@OneToMany(() => Webhook, (webhook: Webhook) => webhook.channel, {
+		cascade: true,
+		orphanedRowAction: "delete",
+		onDelete: "CASCADE",
+	})
+	webhooks?: Webhook[];
+
 	// TODO: DM channel
 	static async createChannel(
 		channel: Partial<Channel>,
@@ -162,6 +213,10 @@ export class Channel extends BaseClass {
 
 		return channel;
 	}
+
+	isDm() {
+		return this.type === ChannelType.DM || this.type === ChannelType.GROUP_DM;
+	}
 }
 
 export interface ChannelPermissionOverwrite {
diff --git a/util/src/entities/Guild.ts b/util/src/entities/Guild.ts
index 7b5d2908..d46d2161 100644
--- a/util/src/entities/Guild.ts
+++ b/util/src/entities/Guild.ts
@@ -81,7 +81,11 @@ 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",
+		onDelete: "CASCADE",
+	})
 	bans: Ban[];
 
 	@Column({ nullable: true })
@@ -124,15 +128,27 @@ 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",
+		onDelete: "CASCADE",
+	})
 	channels: Channel[];
 
 	@Column({ nullable: true })
@@ -144,23 +160,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 })
diff --git a/util/src/entities/Message.ts b/util/src/entities/Message.ts
index 506db71a..0712f545 100644
--- a/util/src/entities/Message.ts
+++ b/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";
@@ -112,7 +114,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 +129,11 @@ export class Message extends BaseClass {
 	@ManyToMany(() => Sticker)
 	sticker_items?: Sticker[];
 
-	@JoinColumn({ name: "attachment_ids" })
-	@OneToMany(() => Attachment, (attachment: Attachment) => attachment.message, { cascade: true })
+	@OneToMany(() => Attachment, (attachment: Attachment) => attachment.message, {
+		cascade: true,
+		orphanedRowAction: "delete",
+		onDelete: "CASCADE",
+	})
 	attachments?: Attachment[];
 
 	@Column({ type: "simple-json" })
diff --git a/util/src/util/cdn.ts b/util/src/util/cdn.ts
new file mode 100644
index 00000000..754d6244
--- /dev/null
+++ b/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;
+}
diff --git a/util/src/util/index.ts b/util/src/util/index.ts
index 4e92f017..1ae96da9 100644
--- a/util/src/util/index.ts
+++ b/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";

From ce09e01c2154072dfb52fceaca33a6106d2e1220 Mon Sep 17 00:00:00 2001
From: Flam3rboy <34555296+Flam3rboy@users.noreply.github.com>
Date: Mon, 20 Sep 2021 17:11:22 +0200
Subject: [PATCH 3/5] :construction: auto delete relations

---
 api/src/routes/channels/#channel_id/index.ts |  20 +++++---
 util/package-lock.json                       | Bin 459190 -> 459116 bytes
 util/src/entities/BaseClass.ts               |  49 ++++++++++++++++++-
 util/src/entities/Channel.ts                 |  12 +----
 util/src/util/Database.ts                    |   2 +-
 5 files changed, 64 insertions(+), 19 deletions(-)

diff --git a/api/src/routes/channels/#channel_id/index.ts b/api/src/routes/channels/#channel_id/index.ts
index 3f434f5e..1063b151 100644
--- a/api/src/routes/channels/#channel_id/index.ts
+++ b/api/src/routes/channels/#channel_id/index.ts
@@ -1,6 +1,15 @@
-import { Channel, ChannelDeleteEvent, ChannelPermissionOverwriteType, ChannelType, ChannelUpdateEvent, emitEvent, Recipient } from "@fosscord/util";
+import {
+	Channel,
+	ChannelDeleteEvent,
+	ChannelPermissionOverwriteType,
+	ChannelType,
+	ChannelUpdateEvent,
+	emitEvent,
+	Recipient,
+	handleFile
+} from "@fosscord/util";
 import { Request, Response, Router } from "express";
-import { handleFile, route } from "@fosscord/api";
+import { route } from "@fosscord/api";
 
 const router: Router = Router();
 // TODO: delete channel
@@ -20,15 +29,14 @@ router.delete("/", route({ permission: "MANAGE_CHANNELS" }), async (req: Request
 	const channel = await Channel.findOneOrFail({ where: { id: channel_id }, relations: ["recipients"] });
 
 	if (channel.type === ChannelType.DM) {
-		const recipient = await Recipient.findOneOrFail({ where: { channel_id: channel_id, user_id: req.user_id } })
-		recipient.closed = true
+		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)
+		await Channel.removeRecipientFromChannel(channel, req.user_id);
 	} else {
 		//TODO messages in this channel should be deleted before deleting the channel
 		await Promise.all([
diff --git a/util/package-lock.json b/util/package-lock.json
index e5a62d0f36a1fa06c3e0b137b0fd5e4f3349a0d8..f412961430c0fff63d0f6f363743b7c9e0762666 100644
GIT binary patch
delta 1821
zcmciBOKjV890zbYb{oiO8Csb}N!o^qmCY1C@^Zv8Pq(oXI}fL^>BVv4yp!hbRGQRw
znu>%(5tjH%2*#ud&SjCXgpi7aI3OX!<G!szKqVL}9Cp|N$W{q%+{pEN`u)DY-{<2?
z)?c@+d+%Anb{fF}e*>P<_ibh{^%HE-f3e!Z_GQz8AjO*Ha-7C|-LRUkgi|8wsf*4;
z!Jn*D3#qQxgDajy*-^tHTydrAVtBvMP5Hb&(Y+xviqNY#3+_-hn92F;#gfAn_O;u&
z<Z#P255cbIJYer<I1B7U(=+-vXE1Q(5I$opAHq*V`q7h@^uGd+4pIB88FGQGG(sGY
zcynn6ynF;dbw9jpvI~qe(hGFrO*!Y~L=qjO1gejQD00xRU}_!>v9W50ps5W<HceM0
zwT=}zB_3}JMY_0(#n4XHp=u0;<9)Wna3M^N;x!McZ`o$SW)!yS^A?MK>%v+6#?p!5
z`{(=956aRvS+gFcW{xXr4HPNUi=$f78y~DF5$|#)A6!+5uGXw((_x>`#1l<CmsMQ2
zl*Q1#kjL`Hfx1DfH7_GcVZ7qcm&Jls?f5edg+~iajwN;C{Os_EN>stOS0GG3`KDRd
zJ~##B>!X|0OTMy_?-xR1FUbd_nuC+0-ho?;w^%Y6;+MVrpw<bw)vo00g-g6U-^vG+
zo^PG5l4T~<^eBz>)Jmb7aq#}0%HtFpbF#hbAMO?)3J{AB2KJ|*b3ncZEhH0u|A3?2
z+G<8v#{&rxTNOyTmf3K$J7s1)S#?DSO>la{M4jZcAcl4Q66fp(7@<U?@hGi&0?V`-
z3@XhA(<(J;4LYsqylw@HR`@af6^jo%VuBWp+tbi@EI2?WaB$~Uh|oWJaY5i#Lw#R%
zLr&)iw&IO8is?SZYSB!%S{HNPhL{pHHA68;6s@pqIjCkEJ(g2Kp-ewfq}>FWYtnHy
z>U1WhUa5xDnXW%kV!-b&K^J!R*C1nm&Gf|&;LCSL+rIwB<QzzCO)dypE3VYUBG;~C
zL?wf!TXGZil%0(bS;pM{a9fe^e5WQBC_?K-DY}W{B*|-83SDUyxUjGyYs+n%k&{_Z
zia@!1p%iPy!aDRC4kEjg^Wdw`;d90<AN=*T@sk7c9oV67zF;01Klq0p<OcTNV4Hy-
z!k_*pv(*2=>@9H)T>Tz4gNr}HX8q=pWhCrzNWZ%K@PpVO|9}@xj0@cT*RUOrvu{GC
z!QP+n$>EOI4uPW?<cU#pXTcnV%nkYHPyHJiqv)bEE}}qAA~Qy94f#wQm(<g5e}Y(y
p(*|<eKQ5oPoxArC<L<o)RUeB_a1cSBJq9X1G%;<wyE{4C`Ww*lZrA_-

delta 1769
zcmciBONbkF90zcwGn=h_tX*tD*X&D>)t#=Hye2b<r89Z#ypo;FWG0Vpkz_J?PLfHo
zdEQnJ_2hzo<bSFlf~Qhi7aGvgx(5&SAiJWVf>iJUi>~fodr)%`1kdLBy?puc{e6CW
z!+Gyb=bf8Qu&<Kf)7feG`p@Vr_|>@#xEGf+y1;SjdYB$2f;cXAQc}iX{SmR)wRFn6
z(Z^$wR*NUHy+*fZ36vj?M@v<Au&!5q1R0F$6*?eglZ`wn>J`hQ7K%NZsc!9V&o3gV
z?-d&SemW2B$LJKWFAHGjWykL3;^Aq;2b+&j0@%wl;PKi;ICqS`FwXWKq05>bPxs|C
zp~)oA@v2hZikVcdU9NCu-<L>cQe_X<6ZLjQE?ZketJF3<!@6$NXvQ%8ZbDDEt9_oU
ztP8<RCeEfjMIn@H5a9i_IUs-XJlKEMHEuiu?eEd2;Gu%d!rO-^`%mQ9J-d2#2FPg=
zNYo|Z=`CrhE1?FBw$ce!Yqr*DB+HdfmQd?kc)@G-G#Ayjr3UU}Qscrxg2?H?p%n5*
zI~!uY)hB8eV{hfeVcpN<i(#G@Q~gwRNCWpzbGyfsV!`dJ7zuA(!=6D%a3U;f$#SIN
zDGx2eExUuZnWmD>2xE%L9y^G3Og3DNg}hYQh*2?;YUYS+Xx-c3Rk!SqmY9^ks^wcg
zl5Q%4W;^YQR<d=e(vIXl`f#TR58gvu@WFXx1!SouO^Equ(Y7{<oSL%vwys8SNgI?x
zl&slgU$&W)skB-KTk?slDF>1i>8o&cQt1wbV#sPK=D^e|(TE^<WyzMiBHy=o4j^yM
z!4>EDxvrjJ;JH)C%IIhY`BH*zWQu@)TtnPo@8czHpft2vLJA4>Dlhas-oBI$tmo8j
zy%q{KaXhAW`dlbZRLX;pK&LaTwk{a0yw<GYnO-I`jOKzySsxb6nkVLAl4VXXl2#5N
z>D3z#H<8i9%~PNK2yuPN1q*LG7GVAebAsbnF)geVan9wkR5fj7N-VE+@Sad_7QF<M
z8?ZS$WAP=UU9#%|Ha4^y%0?(tEDTz-fKy?m;B7R5WVYb#1SDg;PTexIoj|lTKAC`B
z23>@g{OBya^0{Lc@qj(oOHfWB3!`rt^v(wpbO%oo*xI}M*m-#2Yjhgk{ssN+-wK^$
zeXk)<{tJB$?*D+Uy~92|x_OAMIwlSho?JoZNBhU<^>hC}H@N)`G7raP)9{N6*vx40
zPc(UbGW15iP3)`mB=Etz_pyc1$vy0doshTr8wXFY(ZQ3c0+^ULc=sZ9`9I)B?2co#
F^*4PsW#|9^

diff --git a/util/src/entities/BaseClass.ts b/util/src/entities/BaseClass.ts
index 9b2ce058..2a621f40 100644
--- a/util/src/entities/BaseClass.ts
+++ b/util/src/entities/BaseClass.ts
@@ -1,5 +1,14 @@
 import "reflect-metadata";
-import { BaseEntity, BeforeInsert, BeforeUpdate, EntityMetadata, FindConditions, PrimaryColumn } from "typeorm";
+import {
+	BaseEntity,
+	BeforeInsert,
+	BeforeUpdate,
+	EntityMetadata,
+	FindConditions,
+	getConnection,
+	PrimaryColumn,
+	RemoveOptions,
+} from "typeorm";
 import { Snowflake } from "../util/Snowflake";
 import "missing-native-js-functions";
 
@@ -69,6 +78,44 @@ 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((x) => {
+			if (x.orphanedRowAction !== "delete") return;
+			if (typeof x.type === "string") 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}`
+				);
+			}
+			console.log(foreignKey);
+			const id = (criteria as any)[foreignKey.referencedColumnNames[0]];
+			if (!id) throw new Error("id missing in criteria options");
+
+			if (x.relationType === "many-to-many" || x.relationType === "one-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") {
+				return getConnection()
+					.createQueryBuilder()
+					.from(x.inverseEntityMetadata, "user")
+					.of(id)
+					.remove({ [foreignKey.name]: id });
+			}
+		});
+		await Promise.all(promises);
+		return super.delete(criteria, options);
+	}
 }
 
 export class BaseClass extends BaseClassWithoutId {
diff --git a/util/src/entities/Channel.ts b/util/src/entities/Channel.ts
index b1f75f33..74611eea 100644
--- a/util/src/entities/Channel.ts
+++ b/util/src/entities/Channel.ts
@@ -1,14 +1,4 @@
-import {
-	Column,
-	Entity,
-	FindConditions,
-	JoinColumn,
-	ManyToOne,
-	ObjectID,
-	OneToMany,
-	RelationId,
-	RemoveOptions,
-} from "typeorm";
+import { Column, Entity, JoinColumn, ManyToOne, OneToMany, RelationId } from "typeorm";
 import { BaseClass } from "./BaseClass";
 import { Guild } from "./Guild";
 import { PublicUserProjection, User } from "./User";
diff --git a/util/src/util/Database.ts b/util/src/util/Database.ts
index d3844cd9..c22d8abd 100644
--- a/util/src/util/Database.ts
+++ b/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
 		},

From 0247df3e4248e6bd336cc528fc56fceb845fd786 Mon Sep 17 00:00:00 2001
From: Flam3rboy <34555296+Flam3rboy@users.noreply.github.com>
Date: Mon, 20 Sep 2021 18:02:57 +0200
Subject: [PATCH 4/5] :sparkles: finish and fix .delete() for one-to-many
 relations

---
 util/src/entities/BaseClass.ts | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/util/src/entities/BaseClass.ts b/util/src/entities/BaseClass.ts
index 2a621f40..8a0b7a26 100644
--- a/util/src/entities/BaseClass.ts
+++ b/util/src/entities/BaseClass.ts
@@ -83,7 +83,7 @@ export class BaseClassWithoutId extends BaseEntity {
 		if (!criteria) throw new Error("You need to specify delete criteria");
 
 		const repository = this.getRepository();
-		const promises = repository.metadata.relations.map((x) => {
+		const promises = repository.metadata.relations.map(async (x) => {
 			if (x.orphanedRowAction !== "delete") return;
 			if (typeof x.type === "string") return;
 
@@ -95,22 +95,23 @@ export class BaseClassWithoutId extends BaseEntity {
 					`Foreign key not found for entity ${repository.metadata.name} in relation ${x.propertyName}`
 				);
 			}
-			console.log(foreignKey);
 			const id = (criteria as any)[foreignKey.referencedColumnNames[0]];
 			if (!id) throw new Error("id missing in criteria options");
 
-			if (x.relationType === "many-to-many" || x.relationType === "one-to-many") {
+			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") {
+			} else if (
+				x.relationType === "one-to-one" ||
+				x.relationType === "many-to-one" ||
+				x.relationType === "one-to-many"
+			) {
 				return getConnection()
-					.createQueryBuilder()
-					.from(x.inverseEntityMetadata, "user")
-					.of(id)
-					.remove({ [foreignKey.name]: id });
+					.getRepository(x.inverseEntityMetadata.target)
+					.delete({ [foreignKey.columnNames[0]]: id });
 			}
 		});
 		await Promise.all(promises);

From 62f9b35185bacfe5cc0bfcf34c485fc72bea9f10 Mon Sep 17 00:00:00 2001
From: Flam3rboy <34555296+Flam3rboy@users.noreply.github.com>
Date: Mon, 20 Sep 2021 20:22:56 +0200
Subject: [PATCH 5/5] :bug: fix .delete -> add onDelete: "CASCADE"

---
 api/src/routes/guilds/#guild_id/delete.ts | 12 +---
 util/src/entities/Application.ts          |  4 +-
 util/src/entities/Attachment.ts           |  4 +-
 util/src/entities/Ban.ts                  |  8 ++-
 util/src/entities/BaseClass.ts            | 68 +++++++++++------------
 util/src/entities/Channel.ts              | 10 +---
 util/src/entities/ConnectedAccount.ts     |  4 +-
 util/src/entities/Emoji.ts                |  4 +-
 util/src/entities/Guild.ts                |  2 -
 util/src/entities/Invite.ts               | 12 +++-
 util/src/entities/Member.ts               |  9 ++-
 util/src/entities/Message.ts              | 13 +++--
 util/src/entities/ReadState.ts            |  8 ++-
 util/src/entities/Recipient.ts            |  8 ++-
 util/src/entities/Relationship.ts         |  8 ++-
 util/src/entities/Role.ts                 |  4 +-
 util/src/entities/Session.ts              |  4 +-
 util/src/entities/Sticker.ts              |  4 +-
 util/src/entities/Team.ts                 |  4 +-
 util/src/entities/TeamMember.ts           |  8 ++-
 util/src/entities/User.ts                 | 10 +++-
 util/src/entities/VoiceState.ts           | 16 ++++--
 util/src/entities/Webhook.ts              | 20 +++++--
 23 files changed, 150 insertions(+), 94 deletions(-)

diff --git a/api/src/routes/guilds/#guild_id/delete.ts b/api/src/routes/guilds/#guild_id/delete.ts
index 7c3c5530..bd158c56 100644
--- a/api/src/routes/guilds/#guild_id/delete.ts
+++ b/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 }),
-		Channel.delete({ guild_id }),
-		Emoji.delete({ guild_id }),
-		Member.delete({ guild_id }),
+		Guild.delete({ id: guild_id }), // this will also delete all guild related data
 		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);
 });
 
diff --git a/util/src/entities/Application.ts b/util/src/entities/Application.ts
index 2092cd4e..fab3d93f 100644
--- a/util/src/entities/Application.ts
+++ b/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" })
diff --git a/util/src/entities/Attachment.ts b/util/src/entities/Attachment.ts
index 82c5ecf5..7b4b17eb 100644
--- a/util/src/entities/Attachment.ts
+++ b/util/src/entities/Attachment.ts
@@ -31,7 +31,9 @@ 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()
diff --git a/util/src/entities/Ban.ts b/util/src/entities/Ban.ts
index e8a6d648..9504bd8e 100644
--- a/util/src/entities/Ban.ts
+++ b/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 })
diff --git a/util/src/entities/BaseClass.ts b/util/src/entities/BaseClass.ts
index 8a0b7a26..d18757f2 100644
--- a/util/src/entities/BaseClass.ts
+++ b/util/src/entities/BaseClass.ts
@@ -6,6 +6,7 @@ import {
 	EntityMetadata,
 	FindConditions,
 	getConnection,
+	getManager,
 	PrimaryColumn,
 	RemoveOptions,
 } from "typeorm";
@@ -79,44 +80,41 @@ export class BaseClassWithoutId extends BaseEntity {
 		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");
+	// 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;
-			if (typeof x.type === "string") return;
+	// 	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");
+	// 		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 getConnection()
-					.getRepository(x.inverseEntityMetadata.target)
-					.delete({ [foreignKey.columnNames[0]]: id });
-			}
-		});
-		await Promise.all(promises);
-		return super.delete(criteria, options);
-	}
+	// 		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 {
diff --git a/util/src/entities/Channel.ts b/util/src/entities/Channel.ts
index 74611eea..ece82bd0 100644
--- a/util/src/entities/Channel.ts
+++ b/util/src/entities/Channel.ts
@@ -45,7 +45,6 @@ export class Channel extends BaseClass {
 	@OneToMany(() => Recipient, (recipient: Recipient) => recipient.channel, {
 		cascade: true,
 		orphanedRowAction: "delete",
-		onDelete: "CASCADE",
 	})
 	recipients?: Recipient[];
 
@@ -57,7 +56,9 @@ export class Channel extends BaseClass {
 	guild_id?: string;
 
 	@JoinColumn({ name: "guild_id" })
-	@ManyToOne(() => Guild)
+	@ManyToOne(() => Guild, {
+		onDelete: "CASCADE",
+	})
 	guild: Guild;
 
 	@Column({ nullable: true })
@@ -110,35 +111,30 @@ export class Channel extends BaseClass {
 	@OneToMany(() => Invite, (invite: Invite) => invite.channel, {
 		cascade: true,
 		orphanedRowAction: "delete",
-		onDelete: "CASCADE",
 	})
 	invites?: Invite[];
 
 	@OneToMany(() => Message, (message: Message) => message.channel, {
 		cascade: true,
 		orphanedRowAction: "delete",
-		onDelete: "CASCADE",
 	})
 	messages?: Message[];
 
 	@OneToMany(() => VoiceState, (voice_state: VoiceState) => voice_state.channel, {
 		cascade: true,
 		orphanedRowAction: "delete",
-		onDelete: "CASCADE",
 	})
 	voice_states?: VoiceState[];
 
 	@OneToMany(() => ReadState, (read_state: ReadState) => read_state.channel, {
 		cascade: true,
 		orphanedRowAction: "delete",
-		onDelete: "CASCADE",
 	})
 	read_states?: ReadState[];
 
 	@OneToMany(() => Webhook, (webhook: Webhook) => webhook.channel, {
 		cascade: true,
 		orphanedRowAction: "delete",
-		onDelete: "CASCADE",
 	})
 	webhooks?: Webhook[];
 
diff --git a/util/src/entities/ConnectedAccount.ts b/util/src/entities/ConnectedAccount.ts
index 59a8f423..b8aa2889 100644
--- a/util/src/entities/ConnectedAccount.ts
+++ b/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 })
diff --git a/util/src/entities/Emoji.ts b/util/src/entities/Emoji.ts
index 181aff2c..a252d9f4 100644
--- a/util/src/entities/Emoji.ts
+++ b/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()
diff --git a/util/src/entities/Guild.ts b/util/src/entities/Guild.ts
index d46d2161..e107937d 100644
--- a/util/src/entities/Guild.ts
+++ b/util/src/entities/Guild.ts
@@ -84,7 +84,6 @@ export class Guild extends BaseClass {
 	@OneToMany(() => Ban, (ban: Ban) => ban.guild, {
 		cascade: true,
 		orphanedRowAction: "delete",
-		onDelete: "CASCADE",
 	})
 	bans: Ban[];
 
@@ -147,7 +146,6 @@ export class Guild extends BaseClass {
 	@OneToMany(() => Channel, (channel: Channel) => channel.guild, {
 		cascade: true,
 		orphanedRowAction: "delete",
-		onDelete: "CASCADE",
 	})
 	channels: Channel[];
 
diff --git a/util/src/entities/Invite.ts b/util/src/entities/Invite.ts
index afad9c02..cb308823 100644
--- a/util/src/entities/Invite.ts
+++ b/util/src/entities/Invite.ts
@@ -34,7 +34,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 +44,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,7 +62,9 @@ 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 })
diff --git a/util/src/entities/Member.ts b/util/src/entities/Member.ts
index 66f5d9a1..feb9c069 100644
--- a/util/src/entities/Member.ts
+++ b/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",
diff --git a/util/src/entities/Message.ts b/util/src/entities/Message.ts
index 0712f545..c4901693 100644
--- a/util/src/entities/Message.ts
+++ b/util/src/entities/Message.ts
@@ -54,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 })
@@ -62,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 })
@@ -70,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 })
@@ -132,7 +138,6 @@ export class Message extends BaseClass {
 	@OneToMany(() => Attachment, (attachment: Attachment) => attachment.message, {
 		cascade: true,
 		orphanedRowAction: "delete",
-		onDelete: "CASCADE",
 	})
 	attachments?: Attachment[];
 
diff --git a/util/src/entities/ReadState.ts b/util/src/entities/ReadState.ts
index 8dd05b21..68e867a0 100644
--- a/util/src/entities/ReadState.ts
+++ b/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 })
diff --git a/util/src/entities/Recipient.ts b/util/src/entities/Recipient.ts
index bb280588..a945f938 100644
--- a/util/src/entities/Recipient.ts
+++ b/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,7 +18,9 @@ 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 })
diff --git a/util/src/entities/Relationship.ts b/util/src/entities/Relationship.ts
index 61b3ac82..e016b36b 100644
--- a/util/src/entities/Relationship.ts
+++ b/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 })
diff --git a/util/src/entities/Role.ts b/util/src/entities/Role.ts
index 33c8d272..9fca99a5 100644
--- a/util/src/entities/Role.ts
+++ b/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()
diff --git a/util/src/entities/Session.ts b/util/src/entities/Session.ts
index d42a8f98..7cc325f5 100644
--- a/util/src/entities/Session.ts
+++ b/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
diff --git a/util/src/entities/Sticker.ts b/util/src/entities/Sticker.ts
index 7730a86a..ab224d1d 100644
--- a/util/src/entities/Sticker.ts
+++ b/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 })
diff --git a/util/src/entities/Team.ts b/util/src/entities/Team.ts
index beb8bf68..22140b7f 100644
--- a/util/src/entities/Team.ts
+++ b/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()
diff --git a/util/src/entities/TeamMember.ts b/util/src/entities/TeamMember.ts
index 6b184d08..bdfdccf0 100644
--- a/util/src/entities/TeamMember.ts
+++ b/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;
 }
diff --git a/util/src/entities/User.ts b/util/src/entities/User.ts
index cef88777..4c86b2d8 100644
--- a/util/src/entities/User.ts
+++ b/util/src/entities/User.ts
@@ -127,11 +127,17 @@ export class User extends BaseClass {
 	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 })
diff --git a/util/src/entities/VoiceState.ts b/util/src/entities/VoiceState.ts
index 56eb244e..75748a01 100644
--- a/util/src/entities/VoiceState.ts
+++ b/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;
 
diff --git a/util/src/entities/Webhook.ts b/util/src/entities/Webhook.ts
index 12ba0d08..8382435f 100644
--- a/util/src/entities/Webhook.ts
+++ b/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;
 }