✨ typeorm api rewrite done

api/src/Server.ts

@@ -2,7 +2,7 @@ import "missing-native-js-functions";
 import { Connection } from "mongoose";
 import { Server, ServerOptions } from "lambert-server";
 import { Authentication, CORS } from "./middlewares/";
-import { Config, db, initEvent } from "@fosscord/util";
+import { Config, initDatabase, initEvent } from "@fosscord/util";
 import { ErrorHandler } from "./middlewares/ErrorHandler";
 import { BodyParser } from "./middlewares/BodyParser";
 import { Router, Request, Response, NextFunction } from "express";
@@ -31,30 +31,13 @@ export class FosscordServer extends Server {
 		super({ ...opts, errorHandler: false, jsonBody: false });
 	}
 
-	async setupSchema() {
-		return Promise.all([
-			db.collection("users").createIndex({ id: 1 }, { unique: true }),
-			db.collection("messages").createIndex({ id: 1 }, { unique: true }),
-			db.collection("channels").createIndex({ id: 1 }, { unique: true }),
-			db.collection("guilds").createIndex({ id: 1 }, { unique: true }),
-			db.collection("members").createIndex({ id: 1, guild_id: 1 }, { unique: true }),
-			db.collection("roles").createIndex({ id: 1 }, { unique: true }),
-			db.collection("emojis").createIndex({ id: 1 }, { unique: true }),
-			db.collection("invites").createIndex({ code: 1 }, { unique: true }),
-			db.collection("invites").createIndex({ expires_at: 1 }, { expireAfterSeconds: 0 }), // after 0 seconds of expires_at the invite will get delete
-			db.collection("ratelimits").createIndex({ expires_at: 1 }, { expireAfterSeconds: 0 })
-		]);
-	}
-
 	async start() {
-		// @ts-ignore
+		await initDatabase();
-		await (db as Promise<Connection>);
-		await this.setupSchema();
 		await Config.init();
 		await initEvent();
 
 		this.app.use(CORS);
-		this.app.use(BodyParser({ inflate: true, limit: 1024 * 1024 * 10 })); // 2MB
+		this.app.use(BodyParser({ inflate: true, limit: 1024 * 1024 * 10 })); // 10MB
 
 		const app = this.app;
 		const api = Router(); // @ts-ignore

api/src/index.ts

@@ -8,8 +8,6 @@ export * from "./schema/Message";
 export * from "./util/Constants";
 export * from "./util/instanceOf";
 export * from "./util/instanceOf";
-export * from "./util/Member";
 export * from "./util/RandomInviteID";
 export * from "./util/String";
-export * from "./util/User";
 export { check as checkPassword } from "./util/passwordStrength";

api/src/middlewares/Authentication.ts

@@ -28,7 +28,7 @@ declare global {
 export async function Authentication(req: Request, res: Response, next: NextFunction) {
 	if (req.method === "OPTIONS") return res.sendStatus(204);
 	const url = req.url.replace(API_PREFIX, "");
-	if (url.startsWith("/invites") && req.method === "GET") return next(); // @ts-ignore
+	if (url.startsWith("/invites") && req.method === "GET") return next();
 	if (
 		NO_AUTHORIZATION_ROUTES.some((x) => {
 			if (typeof x === "string") return url.startsWith(x);

api/src/routes/auth/register.ts

@@ -182,72 +182,16 @@ router.post(
 		// if nsfw_allowed is null/undefined it'll require date_of_birth to set it to true/false
 
 		const user = await new User({
-			id: Snowflake.generate(),
-			created_at: new Date(),
 			username: adjusted_username,
 			discriminator,
-			avatar: undefined,
-			accent_color: undefined,
-			banner: undefined,
-			bot: false,
-			system: false,
-			desktop: false,
-			mobile: false,
 			premium: true,
 			premium_type: 2,
-			phone: undefined,
-			bio: "",
-			mfa_enabled: false,
-			verified: false,
-			disabled: false,
-			deleted: false,
 			email: adjusted_email,
 			nsfw_allowed: true, // TODO: depending on age
-			public_flags: 0n,
-			flags: 0n, // TODO: generate default flags
 			guilds: [],
 			data: {
 				hash: adjusted_password,
 				valid_tokens_since: new Date()
-			},
-			settings: {
-				afk_timeout: 300,
-				allow_accessibility_detection: true,
-				animate_emoji: true,
-				animate_stickers: 0,
-				contact_sync_enabled: false,
-				convert_emoticons: false,
-				custom_status: {
-					emoji_id: undefined,
-					emoji_name: undefined,
-					expires_at: undefined,
-					text: undefined
-				},
-				default_guilds_restricted: false,
-				detect_platform_accounts: true,
-				developer_mode: false,
-				disable_games_tab: false,
-				enable_tts_command: true,
-				explicit_content_filter: 0,
-				friend_source_flags: { all: true },
-				gateway_connected: false,
-				gif_auto_play: true,
-				guild_folders: [],
-				guild_positions: [],
-				inline_attachment_media: true,
-				inline_embed_media: true,
-				locale: req.language,
-				message_display_compact: false,
-				native_phone_integration_enabled: true,
-				render_embeds: true,
-				render_reactions: true,
-				restricted_guilds: [],
-				show_current_game: true,
-				status: "offline",
-				stream_notifications_enabled: true,
-				theme: "dark",
-				timezone_offset: 0
-				// timezone_offset: // TODO: timezone from request
 			}
 		}).save();
 

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

@@ -1,4 +1,4 @@
-import { ChannelDeleteEvent, Channel, ChannelUpdateEvent, emitEvent, getPermission, GuildUpdateEvent, toObject } from "@fosscord/util";
+import { ChannelDeleteEvent, Channel, ChannelUpdateEvent, emitEvent, getPermission } from "@fosscord/util";
 import { Router, Response, Request } from "express";
 import { HTTPError } from "lambert-server";
 import { ChannelModifySchema } from "../../../schema/Channel";
@@ -23,7 +23,7 @@ router.delete("/", async (req: Request, res: Response) => {
 
 	const channel = await Channel.findOneOrFail({ id: channel_id });
 
-	const permission = await getPermission(req.user_id, channel?.guild_id, channel_id, { channel });
+	const permission = await getPermission(req.user_id, channel?.guild_id, channel_id);
 	permission.hasThrow("MANAGE_CHANNELS");
 
 	// TODO: Dm channel "close" not delete
@@ -31,7 +31,7 @@ router.delete("/", async (req: Request, res: Response) => {
 
 	await emitEvent({ event: "CHANNEL_DELETE", data, channel_id } as ChannelDeleteEvent);
 
-	await Channel.deleteOne({ id: channel_id });
+	await Channel.delete({ id: channel_id });
 
 	res.send(data);
 });
@@ -43,17 +43,19 @@ router.patch("/", check(ChannelModifySchema), async (req: Request, res: Response
 	const permission = await getPermission(req.user_id, undefined, channel_id);
 	permission.hasThrow("MANAGE_CHANNELS");
 
-	const channel = await Channel.findOneOrFailAndUpdate({ id: channel_id }, payload, { new: true });
+	const channel = await Channel.findOneOrFail({ id: channel_id });
+	channel.assign(payload);
 
-	const data = channel;
+	await Promise.all([
+		channel.save(),
+		emitEvent({
+			event: "CHANNEL_UPDATE",
+			data: channel,
+			channel_id
+		} as ChannelUpdateEvent)
+	]);
 
-	await emitEvent({
+	res.send(channel);
-		event: "CHANNEL_UPDATE",
-		data,
-		channel_id
-	} as ChannelUpdateEvent);
-
-	res.send(data);
 });
 
 export default router;

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

@@ -6,7 +6,7 @@ import { random } from "../../../util/RandomInviteID";
 
 import { InviteCreateSchema } from "../../../schema/Invite";
 
-import { getPermission, Channel, InviteModel, InviteCreateEvent, toObject, emitEvent } from "@fosscord/util";
+import { getPermission, Channel, Invite, InviteCreateEvent, emitEvent } from "@fosscord/util";
 
 const router: Router = Router();
 
@@ -38,7 +38,7 @@ router.post("/", check(InviteCreateSchema), async (req: Request, res: Response)
 		inviter_id: user_id
 	};
 
-	await new InviteModel(invite).save();
+	await new Invite(invite).save();
 
 	await emitEvent({ event: "INVITE_CREATE", data: invite, guild_id } as InviteCreateEvent);
 	res.status(201).send(invite);

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

@@ -14,7 +14,7 @@ router.post("/", check({ $manual: Boolean, $mention_count: Number }), async (req
 	const permission = await getPermission(req.user_id, undefined, channel_id);
 	permission.hasThrow("VIEW_CHANNEL");
 
-	await ReadState.update({ user_id: req.user_id, channel_id, message_id }, { user_id: req.user_id, channel_id, message_id });
+	await ReadState.update({ user_id: req.user_id, channel_id }, { user_id: req.user_id, channel_id, last_message_id: message_id });
 
 	await emitEvent({
 		event: "MESSAGE_ACK",

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

@@ -1,6 +1,5 @@
-import { Channel, emitEvent, getPermission, MessageDeleteEvent, Message, MessageUpdateEvent, toObject } from "@fosscord/util";
+import { Channel, emitEvent, getPermission, MessageDeleteEvent, Message, MessageUpdateEvent } from "@fosscord/util";
 import { Router, Response, Request } from "express";
-import { HTTPError } from "lambert-server";
 import { MessageCreateSchema } from "../../../../../schema/Message";
 
 import { check } from "../../../../../util/instanceOf";
@@ -12,7 +11,7 @@ router.patch("/", check(MessageCreateSchema), async (req: Request, res: Response
 	const { message_id, channel_id } = req.params;
 	var body = req.body as MessageCreateSchema;
 
-	var message = await Message.findOneOrFail({ id: message_id, channel_id }, { author_id: true, message_reference: true });
+	const message = await Message.findOneOrFail({ id: message_id, channel_id });
 
 	const permissions = await getPermission(req.user_id, undefined, channel_id);
 
@@ -29,15 +28,16 @@ router.patch("/", check(MessageCreateSchema), async (req: Request, res: Response
 		id: message_id,
 		edited_timestamp: new Date()
 	});
+	message.assign(opts);
 
-	// @ts-ignore
+	await Promise.all([
-	message = await Message.findOneOrFailAndUpdate({ id: message_id }, opts, { new: true }).populate("author");
+		message.save(),
-
+		await emitEvent({
-	await emitEvent({
+			event: "MESSAGE_UPDATE",
-		event: "MESSAGE_UPDATE",
+			channel_id,
-		channel_id,
+			data: { ...message, nonce: undefined }
-		data: { ...message, nonce: undefined }
+		} as MessageUpdateEvent)
-	} as MessageUpdateEvent);
+	]);
 
 	postHandleMessage(message);
 
@@ -49,13 +49,13 @@ router.patch("/", check(MessageCreateSchema), async (req: Request, res: Response
 router.delete("/", async (req: Request, res: Response) => {
 	const { message_id, channel_id } = req.params;
 
-	const channel = await Channel.findOneOrFail({ id: channel_id }, { guild_id: true });
+	const channel = await Channel.findOneOrFail({ id: channel_id });
-	const message = await Message.findOneOrFail({ id: message_id }, { author_id: true });
+	const message = await Message.findOneOrFail({ id: message_id });
 
 	const permission = await getPermission(req.user_id, channel.guild_id, channel_id);
 	if (message.author_id !== req.user_id) permission.hasThrow("MANAGE_MESSAGES");
 
-	await Message.deleteOne({ id: message_id });
+	await Message.delete({ id: message_id });
 
 	await emitEvent({
 		event: "MESSAGE_DELETE",

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

@@ -1,7 +1,7 @@
 import {
 	Channel,
 	emitEvent,
-	EmojiModel,
+	Emoji,
 	getPermission,
 	Member,
 	Message,
@@ -11,11 +11,11 @@ import {
 	MessageReactionRemoveEvent,
 	PartialEmoji,
 	PublicUserProjection,
-	toObject,
 	User
 } from "@fosscord/util";
 import { Router, Response, Request } from "express";
 import { HTTPError } from "lambert-server";
+import { In } from "typeorm";
 
 const router = Router();
 // TODO: check if emoji is really an unicode emoji or a prperly encoded external emoji
@@ -38,12 +38,12 @@ function getEmoji(emoji: string): PartialEmoji {
 router.delete("/", async (req: Request, res: Response) => {
 	const { message_id, channel_id } = req.params;
 
-	const channel = await Channel.findOneOrFail({ id: channel_id }, { guild_id: true });
+	const channel = await Channel.findOneOrFail({ id: channel_id });
 
 	const permissions = await getPermission(req.user_id, undefined, channel_id);
 	permissions.hasThrow("MANAGE_MESSAGES");
 
-	await Message.findOneOrFailAndUpdate({ id: message_id, channel_id }, { reactions: [] }, { new: true });
+	await Message.update({ id: message_id, channel_id }, { reactions: [] });
 
 	await emitEvent({
 		event: "MESSAGE_REACTION_REMOVE_ALL",
@@ -62,8 +62,6 @@ router.delete("/:emoji", async (req: Request, res: Response) => {
 	const { message_id, channel_id } = req.params;
 	const emoji = getEmoji(req.params.emoji);
 
-	const channel = await Channel.findOneOrFail({ id: channel_id }, { guild_id: true });
-
 	const permissions = await getPermission(req.user_id, undefined, channel_id);
 	permissions.hasThrow("MANAGE_MESSAGES");
 
@@ -73,18 +71,19 @@ router.delete("/:emoji", async (req: Request, res: Response) => {
 	if (!already_added) throw new HTTPError("Reaction not found", 404);
 	message.reactions.remove(already_added);
 
-	await Message.update({ id: message_id, channel_id }, message);
+	await Promise.all([
-
+		message.save(),
-	await emitEvent({
+		emitEvent({
-		event: "MESSAGE_REACTION_REMOVE_EMOJI",
+			event: "MESSAGE_REACTION_REMOVE_EMOJI",
-		channel_id,
-		data: {
 			channel_id,
-			message_id,
+			data: {
-			guild_id: channel.guild_id,
+				channel_id,
-			emoji
+				message_id,
-		}
+				guild_id: message.guild_id,
-	} as MessageReactionRemoveEmojiEvent);
+				emoji
+			}
+		} as MessageReactionRemoveEmojiEvent)
+	]);
 
 	res.sendStatus(204);
 });
@@ -94,14 +93,18 @@ router.get("/:emoji", async (req: Request, res: Response) => {
 	const emoji = getEmoji(req.params.emoji);
 
 	const message = await Message.findOneOrFail({ id: message_id, channel_id });
-	if (!message) throw new HTTPError("Message not found", 404);
 	const reaction = message.reactions.find((x) => (x.emoji.id === emoji.id && emoji.id) || x.emoji.name === emoji.name);
 	if (!reaction) throw new HTTPError("Reaction not found", 404);
 
 	const permissions = await getPermission(req.user_id, undefined, channel_id);
 	permissions.hasThrow("VIEW_CHANNEL");
 
-	const users = await User.find({ id: { $in: reaction.user_ids } }, PublicUserProjection);
+	const users = await User.find({
+		where: {
+			id: In(reaction.user_ids)
+		},
+		select: PublicUserProjection
+	});
 
 	res.json(users);
 });
@@ -111,7 +114,7 @@ router.put("/:emoji/:user_id", async (req: Request, res: Response) => {
 	if (user_id !== "@me") throw new HTTPError("Invalid user");
 	const emoji = getEmoji(req.params.emoji);
 
-	const channel = await Channel.findOneOrFail({ id: channel_id }, { guild_id: true });
+	const channel = await Channel.findOneOrFail({ id: channel_id });
 	const message = await Message.findOneOrFail({ id: message_id, channel_id });
 	const already_added = message.reactions.find((x) => (x.emoji.id === emoji.id && emoji.id) || x.emoji.name === emoji.name);
 
@@ -156,7 +159,7 @@ router.delete("/:emoji/:user_id", async (req: Request, res: Response) => {
 
 	const emoji = getEmoji(req.params.emoji);
 
-	const channel = await Channel.findOneOrFail({ id: channel_id }, { guild_id: true });
+	const channel = await Channel.findOneOrFail({ id: channel_id });
 	const message = await Message.findOneOrFail({ id: message_id, channel_id });
 
 	const permissions = await getPermission(req.user_id, undefined, channel_id);

api/src/routes/channels/#channel_id/messages/bulk-delete.ts

@@ -3,6 +3,7 @@ import { Channel, Config, emitEvent, getPermission, MessageDeleteBulkEvent, Mess
 import { HTTPError } from "lambert-server";
 
 import { check } from "../../../../util/instanceOf";
+import { In } from "typeorm";
 
 const router: Router = Router();
 
@@ -13,10 +14,10 @@ export default router;
 // https://discord.com/developers/docs/resources/channel#bulk-delete-messages
 router.post("/", check({ messages: [String] }), async (req: Request, res: Response) => {
 	const { channel_id } = req.params;
-	const channel = await Channel.findOneOrFail({ id: channel_id }, { permission_overwrites: true, guild_id: true });
+	const channel = await Channel.findOneOrFail({ id: channel_id });
 	if (!channel.guild_id) throw new HTTPError("Can't bulk delete dm channel messages", 400);
 
-	const permission = await getPermission(req.user_id, channel?.guild_id, channel_id, { channel });
+	const permission = await getPermission(req.user_id, channel?.guild_id, channel_id);
 	permission.hasThrow("MANAGE_MESSAGES");
 
 	const { maxBulkDelete } = Config.get().limits.message;
@@ -25,7 +26,7 @@ router.post("/", check({ messages: [String] }), async (req: Request, res: Respon
 	if (messages.length < 2) throw new HTTPError("You must at least specify 2 messages to bulk delete");
 	if (messages.length > maxBulkDelete) throw new HTTPError(`You cannot delete more than ${maxBulkDelete} messages`);
 
-	await Message.deleteMany({ id: { $in: messages } });
+	await Message.delete({ id: In(messages) });
 
 	await emitEvent({
 		event: "MESSAGE_DELETE_BULK",

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

@@ -1,5 +1,5 @@
 import { Router, Response, Request } from "express";
-import { Attachment, Channel, ChannelType, getPermission, MessageDocument, Message, toObject } from "@fosscord/util";
+import { Attachment, Channel, ChannelType, getPermission, Message } from "@fosscord/util";
 import { HTTPError } from "lambert-server";
 import { MessageCreateSchema } from "../../../../schema/Message";
 import { check, instanceOf, Length } from "../../../../util/instanceOf";
@@ -7,6 +7,7 @@ import multer from "multer";
 import { Query } from "mongoose";
 import { sendMessage } from "../../../../util/Message";
 import { uploadFile } from "../../../../util/cdn";
+import { FindManyOptions, LessThan, MoreThan } from "typeorm";
 
 const router: Router = Router();
 
@@ -55,24 +56,21 @@ router.get("/", async (req: Request, res: Response) => {
 	permissions.hasThrow("VIEW_CHANNEL");
 	if (!permissions.has("READ_MESSAGE_HISTORY")) return res.json([]);
 
-	var query: Query<MessageDocument[], MessageDocument>;
+	var query: FindManyOptions<Message> & { where: { id?: any } } = { order: { id: "DESC" }, take: limit, where: { channel_id } };
-	if (after) query = Message.find({ channel_id, id: { $gt: after } });
+
-	else if (before) query = Message.find({ channel_id, id: { $lt: before } });
+	if (after) query.where.id = MoreThan(after);
-	else if (around)
+	else if (before) query.where.id = LessThan(before);
-		query = Message.find({
+	else if (around) {
-			channel_id,
+		query.where.id = [
-			id: { $gt: (BigInt(around) - BigInt(halfLimit)).toString(), $lt: (BigInt(around) + BigInt(halfLimit)).toString() }
+			MoreThan((BigInt(around) - BigInt(halfLimit)).toString()),
-		});
+			LessThan((BigInt(around) + BigInt(halfLimit)).toString())
-	else {
+		];
-		query = Message.find({ channel_id });
 	}
 
-	query = query.sort({ id: -1 });
+	const messages = await Message.find(query);
-
-	const messages = await query.limit(limit);
 
 	return res.json(messages).map((x) => {
-		(x.reactions || []).forEach((x) => {
+		(x.reactions || []).forEach((x: any) => {
 			// @ts-ignore
 			if ((x.user_ids || []).includes(req.user_id)) x.me = true;
 			// @ts-ignore
@@ -135,7 +133,7 @@ router.post("/", messageUpload.single("file"), async (req: Request, res: Respons
 		embeds,
 		channel_id,
 		attachments,
-		edited_timestamp: null
+		edited_timestamp: undefined
 	});
 
 	return res.send(data);

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

@@ -1,4 +1,4 @@
-import { Channel, ChannelPermissionOverwrite, ChannelUpdateEvent, emitEvent, getPermission, Member, Role, toObject } from "@fosscord/util";
+import { Channel, ChannelPermissionOverwrite, ChannelUpdateEvent, emitEvent, getPermission, Member, Role } from "@fosscord/util";
 import { Router, Response, Request } from "express";
 import { HTTPError } from "lambert-server";
 
@@ -11,16 +11,16 @@ router.put("/:overwrite_id", check({ allow: String, deny: String, type: Number,
 	const { channel_id, overwrite_id } = req.params;
 	const body = req.body as { allow: bigint; deny: bigint; type: number; id: string };
 
-	var channel = await Channel.findOneOrFail({ id: channel_id }, { guild_id: true, permission_overwrites: true });
+	var channel = await Channel.findOneOrFail({ id: channel_id });
 	if (!channel.guild_id) throw new HTTPError("Channel not found", 404);
 
 	const permissions = await getPermission(req.user_id, channel.guild_id, channel_id);
 	permissions.hasThrow("MANAGE_ROLES");
 
 	if (body.type === 0) {
-		if (!(await Role.exists({ id: overwrite_id }))) throw new HTTPError("role not found", 404);
+		if (!(await Role.count({ id: overwrite_id }))) throw new HTTPError("role not found", 404);
 	} else if (body.type === 1) {
-		if (!(await Member.exists({ id: overwrite_id }))) throw new HTTPError("user not found", 404);
+		if (!(await Member.count({ id: overwrite_id }))) throw new HTTPError("user not found", 404);
 	} else throw new HTTPError("type not supported", 501);
 
 	// @ts-ignore
@@ -57,18 +57,19 @@ router.delete("/:overwrite_id", async (req: Request, res: Response) => {
 	const permissions = await getPermission(req.user_id, undefined, channel_id);
 	permissions.hasThrow("MANAGE_ROLES");
 
-	const channel = await Channel.findOneOrFailAndUpdate(
+	const channel = await Channel.findOneOrFail({ id: channel_id });
-		{ id: channel_id },
-		{ $pull: { permission_overwrites: { id: overwrite_id } } },
-		{ new: true }
-	);
 	if (!channel.guild_id) throw new HTTPError("Channel not found", 404);
 
-	await emitEvent({
+	channel.permission_overwrites = channel.permission_overwrites.filter((x) => x.id === overwrite_id);
-		event: "CHANNEL_UPDATE",
+
-		channel_id,
+	await Promise.all([
-		data: channel
+		channel.save(),
-	} as ChannelUpdateEvent);
+		emitEvent({
+			event: "CHANNEL_UPDATE",
+			channel_id,
+			data: channel
+		} as ChannelUpdateEvent)
+	]);
 
 	return res.sendStatus(204);
 });

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

@@ -1,4 +1,4 @@
-import { Channel, ChannelPinsUpdateEvent, Config, emitEvent, getPermission, Message, MessageUpdateEvent, toObject } from "@fosscord/util";
+import { Channel, ChannelPinsUpdateEvent, Config, emitEvent, getPermission, Message, MessageUpdateEvent } from "@fosscord/util";
 import { Router, Request, Response } from "express";
 import { HTTPError } from "lambert-server";
 
@@ -6,35 +6,36 @@ const router: Router = Router();
 
 router.put("/:message_id", async (req: Request, res: Response) => {
 	const { channel_id, message_id } = req.params;
-	const channel = await Channel.findOneOrFail({ id: channel_id });
+
-	const permission = await getPermission(req.user_id, channel.guild_id, channel_id);
+	const message = await Message.findOneOrFail({ id: message_id });
+	const permission = await getPermission(req.user_id, message.guild_id, channel_id);
 	permission.hasThrow("VIEW_CHANNEL");
 
 	// * in dm channels anyone can pin messages -> only check for guilds
-	if (channel.guild_id) permission.hasThrow("MANAGE_MESSAGES");
+	if (message.guild_id) permission.hasThrow("MANAGE_MESSAGES");
 
-	const pinned_count = await Messagecount({ channel_id, pinned: true });
+	const pinned_count = await Message.count({ channel_id, pinned: true });
 	const { maxPins } = Config.get().limits.channel;
 	if (pinned_count >= maxPins) throw new HTTPError("Max pin count reached: " + maxPins);
 
-	await Message.update({ id: message_id }, { pinned: true });
+	await Promise.all([
-	const message = await Message.findOneOrFail({ id: message_id });
+		Message.update({ id: message_id }, { pinned: true }),
-
+		emitEvent({
-	await emitEvent({
+			event: "MESSAGE_UPDATE",
-		event: "MESSAGE_UPDATE",
-		channel_id,
-		data: message
-	} as MessageUpdateEvent);
-
-	await emitEvent({
-		event: "CHANNEL_PINS_UPDATE",
-		channel_id,
-		data: {
 			channel_id,
-			guild_id: channel.guild_id,
+			data: message
-			last_pin_timestamp: undefined
+		} as MessageUpdateEvent),
-		}
+
-	} as ChannelPinsUpdateEvent);
+		emitEvent({
+			event: "CHANNEL_PINS_UPDATE",
+			channel_id,
+			data: {
+				channel_id,
+				guild_id: message.guild_id,
+				last_pin_timestamp: undefined
+			}
+		} as ChannelPinsUpdateEvent)
+	]);
 
 	res.sendStatus(204);
 });
@@ -48,23 +49,28 @@ router.delete("/:message_id", async (req: Request, res: Response) => {
 	permission.hasThrow("VIEW_CHANNEL");
 	if (channel.guild_id) permission.hasThrow("MANAGE_MESSAGES");
 
-	const message = await Message.findOneOrFailAndUpdate({ id: message_id }, { pinned: false }, { new: true });
+	const message = await Message.findOneOrFail({ id: message_id });
+	message.pinned = false;
 
-	await emitEvent({
+	await Promise.all([
-		event: "MESSAGE_UPDATE",
+		message.save(),
-		channel_id,
-		data: message
-	} as MessageUpdateEvent);
 
-	await emitEvent({
+		emitEvent({
-		event: "CHANNEL_PINS_UPDATE",
+			event: "MESSAGE_UPDATE",
-		channel_id,
-		data: {
 			channel_id,
-			guild_id: channel.guild_id,
+			data: message
-			last_pin_timestamp: undefined
+		} as MessageUpdateEvent),
-		}
+
-	} as ChannelPinsUpdateEvent);
+		emitEvent({
+			event: "CHANNEL_PINS_UPDATE",
+			channel_id,
+			data: {
+				channel_id,
+				guild_id: channel.guild_id,
+				last_pin_timestamp: undefined
+			}
+		} as ChannelPinsUpdateEvent)
+	]);
 
 	res.sendStatus(204);
 });

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

@@ -1,4 +1,4 @@
-import { Channel, emitEvent, Member, toObject, TypingStartEvent } from "@fosscord/util";
+import { Channel, emitEvent, Member, TypingStartEvent } from "@fosscord/util";
 import { Router, Request, Response } from "express";
 
 import { HTTPError } from "lambert-server";
@@ -17,7 +17,7 @@ router.post("/", async (req: Request, res: Response) => {
 		channel_id: channel_id,
 		data: {
 			// this is the paylod
-			member: member,
+			member: { ...member, roles: member.role_ids },
 			channel_id,
 			timestamp,
 			user_id,

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

@@ -10,7 +10,7 @@ const router: Router = Router();
 // TODO: use Image Data Type for avatar instead of String
 router.post("/", check({ name: new Length(String, 1, 80), $avatar: String }), async (req: Request, res: Response) => {
 	const channel_id = req.params.channel_id;
-	const channel = await Channel.findOneOrFail({ id: channel_id }, { guild_id: true, type: true });
+	const channel = await Channel.findOneOrFail({ id: channel_id });
 
 	isTextChannel(channel.type);
 	if (!channel.guild_id) throw new HTTPError("Not a guild channel", 400);

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

@@ -1,22 +1,17 @@
 import { Request, Response, Router } from "express";
-import { BanModel, emitEvent, getPermission, GuildBanAddEvent, GuildBanRemoveEvent, Guild, toObject } from "@fosscord/util";
+import { emitEvent, getPermission, GuildBanAddEvent, GuildBanRemoveEvent, Guild, Ban, User, Member } from "@fosscord/util";
 import { HTTPError } from "lambert-server";
 import { getIpAdress } from "../../../util/ipAddress";
 import { BanCreateSchema } from "../../../schema/Ban";
 
 import { check } from "../../../util/instanceOf";
-import { removeMember } from "../../../util/Member";
-import { getPublicUser } from "../../../util/User";
 
 const router: Router = Router();
 
 router.get("/", async (req: Request, res: Response) => {
 	const { guild_id } = req.params;
 
-	const guild = await Guild.exists({ id: guild_id });
+	var bans = await Ban.find({ guild_id: guild_id });
-	if (!guild) throw new HTTPError("Guild not found", 404);
-
-	var bans = await Ban.find({ guild_id: guild_id }, { user_id: true, reason: true });
 	return res.json(bans);
 });
 
@@ -32,29 +27,32 @@ router.put("/:user_id", check(BanCreateSchema), async (req: Request, res: Respon
 	const { guild_id } = req.params;
 	const banned_user_id = req.params.user_id;
 
-	const banned_user = await getPublicUser(banned_user_id);
+	const banned_user = await User.getPublicUser(banned_user_id);
 	const perms = await getPermission(req.user_id, guild_id);
 	perms.hasThrow("BAN_MEMBERS");
 	if (req.user_id === banned_user_id) throw new HTTPError("You can't ban yourself", 400);
+	if (perms.cache.guild?.owner_id === banned_user_id) throw new HTTPError("You can't ban the owner", 400);
 
-	await removeMember(banned_user_id, guild_id);
+	const ban = new Ban({
-
-	const ban = await new BanModel({
 		user_id: banned_user_id,
 		guild_id: guild_id,
 		ip: getIpAdress(req),
 		executor_id: req.user_id,
 		reason: req.body.reason // || otherwise empty
-	}).save();
+	});
 
-	await emitEvent({
+	await Promise.all([
-		event: "GUILD_BAN_ADD",
+		Member.removeFromGuild(banned_user_id, guild_id),
-		data: {
+		ban.save(),
-			guild_id: guild_id,
+		emitEvent({
-			user: banned_user
+			event: "GUILD_BAN_ADD",
-		},
+			data: {
-		guild_id: guild_id
+				guild_id: guild_id,
-	} as GuildBanAddEvent);
+				user: banned_user
+			},
+			guild_id: guild_id
+		} as GuildBanAddEvent)
+	]);
 
 	return res.json(ban);
 });
@@ -63,26 +61,25 @@ router.delete("/:user_id", async (req: Request, res: Response) => {
 	var { guild_id } = req.params;
 	var banned_user_id = req.params.user_id;
 
-	const banned_user = await getPublicUser(banned_user_id);
+	const banned_user = await User.getPublicUser(banned_user_id);
-	const guild = await Guild.exists({ id: guild_id });
-	if (!guild) throw new HTTPError("Guild not found", 404);
-
 	const perms = await getPermission(req.user_id, guild_id);
 	perms.hasThrow("BAN_MEMBERS");
 
-	await Ban.deleteOne({
+	await Promise.all([
-		user_id: banned_user_id,
+		Ban.delete({
-		guild_id
+			user_id: banned_user_id,
-	});
+			guild_id
+		}),
 
-	await emitEvent({
+		emitEvent({
-		event: "GUILD_BAN_REMOVE",
+			event: "GUILD_BAN_REMOVE",
-		data: {
+			data: {
-			guild_id,
+				guild_id,
-			user: banned_user
+				user: banned_user
-		},
+			},
-		guild_id
+			guild_id
-	} as GuildBanRemoveEvent);
+		} as GuildBanRemoveEvent)
+	]);
 
 	return res.status(204).send();
 });

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

@@ -1,4 +1,4 @@
-import { Channel, emitEvent, EmojiModel, GuildDeleteEvent, Guild, InviteModel, Member, Message, Role, User } from "@fosscord/util";
+import { Channel, emitEvent, GuildDeleteEvent, Guild, Member, Message, Role, Invite, Emoji } from "@fosscord/util";
 import { Router, Request, Response } from "express";
 import { HTTPError } from "lambert-server";
 
@@ -9,7 +9,7 @@ const router = Router();
 router.post("/", async (req: Request, res: Response) => {
 	var { guild_id } = req.params;
 
-	const guild = await Guild.findOneOrFail({ id: guild_id }, "owner_id");
+	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);
 
 	await emitEvent({
@@ -21,14 +21,13 @@ router.post("/", async (req: Request, res: Response) => {
 	} as GuildDeleteEvent);
 
 	await Promise.all([
-		Guild.deleteOne({ id: guild_id }),
+		Guild.delete({ id: guild_id }),
-		User.updateMany({ guilds: guild_id }, { $pull: { guilds: guild_id } }),
+		Role.delete({ guild_id }),
-		Role.deleteMany({ guild_id }),
+		Channel.delete({ guild_id }),
-		Channel.deleteMany({ guild_id }),
+		Emoji.delete({ guild_id }),
-		Emoji.deleteMany({ guild_id }),
+		Invite.delete({ guild_id }),
-		Invite.deleteMany({ guild_id }),
+		Message.delete({ guild_id }),
-		Message.deleteMany({ guild_id }),
+		Member.delete({ guild_id })
-		Member.deleteMany({ guild_id })
 	]);
 
 	return res.sendStatus(204);

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

@@ -1,19 +1,5 @@
 import { Request, Response, Router } from "express";
-import {
+import { emitEvent, getPermission, Guild, GuildUpdateEvent, Member } from "@fosscord/util";
-	Channel,
-	emitEvent,
-	EmojiModel,
-	getPermission,
-	GuildDeleteEvent,
-	Guild,
-	GuildUpdateEvent,
-	InviteModel,
-	Member,
-	Message,
-	Role,
-	toObject,
-	User
-} from "@fosscord/util";
 import { HTTPError } from "lambert-server";
 import { GuildUpdateSchema } from "../../../schema/Guild";
 
@@ -26,9 +12,15 @@ const router = Router();
 router.get("/", async (req: Request, res: Response) => {
 	const { guild_id } = req.params;
 
-	const guild = await Guild.findOneOrFail({ id: guild_id }).populate({ path: "joined_at", match: { id: req.user_id } });
+	const [guild, member_count, member] = await Promise.all([
-	const member = await Member.exists({ guild_id: guild_id, id: req.user_id });
+		Guild.findOneOrFail({ id: guild_id }),
-	if (!member) throw new HTTPError("You are not a member of the guild you are trying to access", 401);
+		Member.count({ guild_id: guild_id, id: req.user_id }),
+		Member.findOneOrFail(req.user_id)
+	]);
+	if (!member_count) throw new HTTPError("You are not a member of the guild you are trying to access", 401);
+
+	// @ts-ignore
+	guild.joined_at = member?.joined_at;
 
 	return res.json(guild);
 });
@@ -45,15 +37,12 @@ router.patch("/", check(GuildUpdateSchema), async (req: Request, res: Response)
 	if (body.banner) body.banner = await handleFile(`/banners/${guild_id}`, body.banner);
 	if (body.splash) body.splash = await handleFile(`/splashes/${guild_id}`, body.splash);
 
-	const guild = await Guild.findOneOrFailAndUpdate({ id: guild_id }, body, { new: true }).populate({
+	const guild = await Guild.findOneOrFail({ id: guild_id });
-		path: "joined_at",
+	guild.assign(body);
-		match: { id: req.user_id }
-	});
-	const data = guild;
 
-	emitEvent({ event: "GUILD_UPDATE", data: data, guild_id } as GuildUpdateEvent);
+	await Promise.all([guild.save(), emitEvent({ event: "GUILD_UPDATE", data: guild, guild_id } as GuildUpdateEvent)]);
 
-	return res.json(data);
+	return res.json(guild);
 });
 
 export default router;

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

@@ -1,4 +1,4 @@
-import { getPermission, InviteModel, toObject } from "@fosscord/util";
+import { getPermission, Invite } from "@fosscord/util";
 import { Request, Response, Router } from "express";
 
 const router = Router();

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

@@ -3,7 +3,6 @@ import {
 	Guild,
 	Member,
 	User,
-	toObject,
 	GuildMemberAddEvent,
 	getPermission,
 	PermissionResolvable,
@@ -12,15 +11,15 @@ import {
 	emitEvent
 } from "@fosscord/util";
 import { HTTPError } from "lambert-server";
-import { addMember, isMember, removeMember } from "../../../../../util/Member";
 import { check } from "../../../../../util/instanceOf";
 import { MemberChangeSchema } from "../../../../../schema/Member";
+import { In } from "typeorm";
 
 const router = Router();
 
 router.get("/", async (req: Request, res: Response) => {
 	const { guild_id, member_id } = req.params;
-	await isMember(req.user_id, guild_id);
+	await Member.IsInGuildOrFail(req.user_id, guild_id);
 
 	const member = await Member.findOneOrFail({ id: member_id, guild_id });
 
@@ -31,18 +30,22 @@ router.patch("/", check(MemberChangeSchema), async (req: Request, res: Response)
 	const { guild_id, member_id } = req.params;
 	const body = req.body as MemberChangeSchema;
 	if (body.roles) {
-		const roles = await Role.find({ id: { $in: body.roles } });
+		const roles = await Role.find({ id: In(body.roles) });
 		if (body.roles.length !== roles.length) throw new HTTPError("Roles not found", 404);
 		// TODO: check if user has permission to add role
 	}
 
-	const member = await Member.findOneOrFailAndUpdate({ id: member_id, guild_id }, body, { new: true });
+	const member = await Member.findOneOrFail({ id: member_id, guild_id });
+	member.assign(req.body);
 
-	await emitEvent({
+	Promise.all([
-		event: "GUILD_MEMBER_UPDATE",
+		member.save(),
-		guild_id,
+		emitEvent({
-		data: member
+			event: "GUILD_MEMBER_UPDATE",
-	} as GuildMemberUpdateEvent);
+			guild_id,
+			data: { ...member, roles: member.role_ids }
+		} as GuildMemberUpdateEvent)
+	]);
 
 	res.json(member);
 });
@@ -52,7 +55,7 @@ router.put("/", async (req: Request, res: Response) => {
 
 	throw new HTTPError("Maintenance: Currently you can't add a member", 403);
 	// TODO: only for oauth2 applications
-	await addMember(member_id, guild_id);
+	await Member.addToGuild(member_id, guild_id);
 	res.sendStatus(204);
 });
 
@@ -62,7 +65,7 @@ router.delete("/", async (req: Request, res: Response) => {
 	const perms = await getPermission(req.user_id, guild_id);
 	perms.hasThrow("KICK_MEMBERS");
 
-	await removeMember(member_id, guild_id);
+	await Member.removeFromGuild(member_id, guild_id);
 	res.sendStatus(204);
 });
 

api/src/routes/guilds/#guild_id/members/#member_id/nick.ts

@@ -1,8 +1,7 @@
-import { getPermission, PermissionResolvable } from "@fosscord/util";
+import { getPermission, Member, PermissionResolvable } from "@fosscord/util";
 import { Request, Response, Router } from "express";
 import { check } from "lambert-server";
 import { MemberNickChangeSchema } from "../../../../../schema/Member";
-import { changeNickname } from "../../../../../util/Member";
 
 const router = Router();
 
@@ -17,7 +16,7 @@ router.patch("/", check(MemberNickChangeSchema), async (req: Request, res: Respo
 	const perms = await getPermission(req.user_id, guild_id);
 	perms.hasThrow(permissionString);
 
-	await changeNickname(member_id, guild_id, req.body.nick);
+	await Member.changeNickname(member_id, guild_id, req.body.nick);
 	res.status(200).send();
 });
 

api/src/routes/guilds/#guild_id/members/#member_id/roles/#role_id/index.ts

@@ -1,6 +1,5 @@
-import { getPermission } from "@fosscord/util";
+import { getPermission, Member } from "@fosscord/util";
 import { Request, Response, Router } from "express";
-import { addRole, removeRole } from "../../../../../../../util/Member";
 
 const router = Router();
 
@@ -10,7 +9,7 @@ router.delete("/:member_id/roles/:role_id", async (req: Request, res: Response)
 	const perms = await getPermission(req.user_id, guild_id);
 	perms.hasThrow("MANAGE_ROLES");
 
-	await removeRole(member_id, guild_id, role_id);
+	await Member.removeRole(member_id, guild_id, role_id);
 	res.sendStatus(204);
 });
 
@@ -20,7 +19,7 @@ router.put("/:member_id/roles/:role_id", async (req: Request, res: Response) =>
 	const perms = await getPermission(req.user_id, guild_id);
 	perms.hasThrow("MANAGE_ROLES");
 
-	await addRole(member_id, guild_id, role_id);
+	await Member.addRole(member_id, guild_id, role_id);
 	res.sendStatus(204);
 });
 

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

@@ -1,8 +1,7 @@
 import { Request, Response, Router } from "express";
-import { Guild, Member, toObject } from "@fosscord/util";
+import { Guild, Member, PublicMemberProjection } from "@fosscord/util";
-import { HTTPError } from "lambert-server";
 import { instanceOf, Length } from "../../../../util/instanceOf";
-import { PublicMemberProjection, isMember } from "../../../../util/Member";
+import { MoreThan } from "typeorm";
 
 const router = Router();
 
@@ -11,7 +10,7 @@ const router = Router();
 router.get("/", async (req: Request, res: Response) => {
 	const { guild_id } = req.params;
 	const guild = await Guild.findOneOrFail({ id: guild_id });
-	await isMember(req.user_id, guild_id);
+	await Member.IsInGuildOrFail(req.user_id, guild_id);
 
 	try {
 		instanceOf({ $limit: new Length(Number, 1, 1000), $after: String }, req.query, {
@@ -23,12 +22,16 @@ router.get("/", async (req: Request, res: Response) => {
 		return res.status(400).json({ code: 50035, message: "Invalid Query", success: false, errors: error });
 	}
 
-	// @ts-ignore
+	const { limit, after } = (<unknown>req.query) as { limit?: number; after?: string };
-	if (!req.query.limit) req.query.limit = 1;
+	const query = after ? { id: MoreThan(after) } : {};
-	const { limit, after } = (<unknown>req.query) as { limit: number; after: string };
+
-	const query = after ? { id: { $gt: after } } : {};
+	const members = await Member.find({
+		where: { guild_id, ...query },
+		select: PublicMemberProjection,
+		take: limit || 1,
+		order: { id: "ASC" }
+	});
 
-	var members = await Member.find({ guild_id, ...query }, PublicMemberProjection).limit(limit);
 	return res.json(members);
 });
 

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

@@ -1,10 +1,7 @@
 import { Request, Response, Router } from "express";
 import {
 	Role,
-	Guild,
 	getPermission,
-	toObject,
-	User,
 	Snowflake,
 	Member,
 	GuildRoleCreateEvent,
@@ -16,15 +13,13 @@ import { HTTPError } from "lambert-server";
 
 import { check } from "../../../util/instanceOf";
 import { RoleModifySchema } from "../../../schema/Roles";
-import { getPublicUser } from "../../../util/User";
-import { isMember } from "../../../util/Member";
 
 const router: Router = Router();
 
 router.get("/", async (req: Request, res: Response) => {
 	const guild_id = req.params.guild_id;
 
-	await isMember(req.user_id, guild_id);
+	await Member.IsInGuildOrFail(req.user_id, guild_id);
 
 	const roles = await Role.find({ guild_id: guild_id });
 
@@ -35,12 +30,8 @@ router.post("/", check(RoleModifySchema), async (req: Request, res: Response) =>
 	const guild_id = req.params.guild_id;
 	const body = req.body as RoleModifySchema;
 
-	const guild = await Guild.findOneOrFail({ id: guild_id }, { id: true });
-	const user = await User.findOneOrFail({ id: req.user_id });
-
 	const perms = await getPermission(req.user_id, guild_id);
 	perms.hasThrow("MANAGE_ROLES");
-	if (!body.name) throw new HTTPError("You need to specify a name");
 
 	const role = await new Role({
 		...body,
@@ -49,7 +40,7 @@ router.post("/", check(RoleModifySchema), async (req: Request, res: Response) =>
 		managed: false,
 		position: 0,
 		tags: null,
-		permissions: body.permissions || 0n
+		permissions: perms.bitfield & (body.permissions || 0n)
 	}).save();
 
 	await emitEvent({
@@ -72,19 +63,20 @@ router.delete("/:role_id", async (req: Request, res: Response) => {
 	const permissions = await getPermission(req.user_id, guild_id);
 	permissions.hasThrow("MANAGE_ROLES");
 
-	await Role.deleteOne({
+	await Promise.all([
-		id: role_id,
+		Role.delete({
-		guild_id: guild_id
+			id: role_id,
-	});
+			guild_id: guild_id
-
+		}),
-	await emitEvent({
+		emitEvent({
-		event: "GUILD_ROLE_DELETE",
+			event: "GUILD_ROLE_DELETE",
-		guild_id,
-		data: {
 			guild_id,
-			role_id
+			data: {
-		}
+				guild_id,
-	} as GuildRoleDeleteEvent);
+				role_id
+			}
+		} as GuildRoleDeleteEvent)
+	]);
 
 	res.sendStatus(204);
 });
@@ -96,30 +88,22 @@ router.patch("/:role_id", check(RoleModifySchema), async (req: Request, res: Res
 	const { role_id } = req.params;
 	const body = req.body as RoleModifySchema;
 
-	const guild = await Guild.findOneOrFail({ id: guild_id }, { id: true });
-	const user = await User.findOneOrFail({ id: req.user_id });
-
 	const perms = await getPermission(req.user_id, guild_id);
 	perms.hasThrow("MANAGE_ROLES");
 
-	const role = await Role.findOneOrFailAndUpdate(
+	const role = new Role({ ...body, role_id, guild_id, permissions: perms.bitfield & (body.permissions || 0n) });
-		{
-			id: role_id,
-			guild_id: guild_id
-		},
-		// @ts-ignore
-		body,
-		{ new: true }
-	);
 
-	await emitEvent({
+	await Promise.all([
-		event: "GUILD_ROLE_UPDATE",
+		role.save(),
-		guild_id,
+		emitEvent({
-		data: {
+			event: "GUILD_ROLE_UPDATE",
 			guild_id,
-			role
+			data: {
-		}
+				guild_id,
-	} as GuildRoleUpdateEvent);
+				role
+			}
+		} as GuildRoleUpdateEvent)
+	]);
 
 	res.json(role);
 });

api/src/routes/guilds/#guild_id/vanity-url.ts

@@ -1,8 +1,7 @@
-import { Channel, ChannelType, getPermission, Guild, InviteModel, trimSpecial } from "@fosscord/util";
+import { Channel, ChannelType, getPermission, Guild, Invite, trimSpecial } from "@fosscord/util";
 import { Router, Request, Response } from "express";
 import { HTTPError } from "lambert-server";
 import { check, Length } from "../../../util/instanceOf";
-import { isMember } from "../../../util/Member";
 
 const router = Router();
 
@@ -14,42 +13,37 @@ router.get("/", async (req: Request, res: Response) => {
 	const permission = await getPermission(req.user_id, guild_id);
 	permission.hasThrow("MANAGE_GUILD");
 
-	const guild = await Guild.findOneOrFail({ id: guild_id });
+	const guild = await Guild.findOneOrFail({ where: { id: guild_id }, relations: ["vanity_url"] });
-	if (!guild.vanity_url_code) return res.json({ code: null });
+	if (!guild.vanity_url) return res.json({ code: null });
-	const { uses } = await Invite.findOneOrFail({ code: guild.vanity_url_code });
 
-	return res.json({ code: guild.vanity_url_code, uses });
+	return res.json({ code: guild.vanity_url_code, uses: guild.vanity_url.uses });
 });
 
 // TODO: check if guild is elgible for vanity url
 router.patch("/", check({ code: new Length(String, 0, 20) }), async (req: Request, res: Response) => {
 	const { guild_id } = req.params;
-	var code = req.body.code.replace(InviteRegex);
+	const code = req.body.code.replace(InviteRegex);
-	if (!code) code = null;
+
+	await Invite.findOneOrFail({ code });
 
 	const guild = await Guild.findOneOrFail({ id: guild_id });
-	const permission = await getPermission(req.user_id, guild_id, undefined, { guild });
+	const permission = await getPermission(req.user_id, guild_id);
 	permission.hasThrow("MANAGE_GUILD");
 
-	const alreadyExists = await Promise.all([
-		Guild.findOneOrFail({ vanity_url_code: code }).catch(() => null),
-		Invite.findOneOrFail({ code: code }).catch(() => null)
-	]);
-	if (alreadyExists.some((x) => x)) throw new HTTPError("Vanity url already exists", 400);
-
-	await Guild.update({ id: guild_id }, { vanity_url_code: code });
 	const { id } = await Channel.findOneOrFail({ guild_id, type: ChannelType.GUILD_TEXT });
-	await Invite.update(
+	guild.vanity_url_code = code;
-		{ code: guild.vanity_url_code },
+
-		{
+	Promise.all([
+		guild.save(),
+		Invite.delete({ code: guild.vanity_url_code }),
+		new Invite({
 			code: code,
 			uses: 0,
 			created_at: new Date(),
 			guild_id,
 			channel_id: id
-		},
+		}).save()
-		{ upsert: true }
+	]);
-	);
 
 	return res.json({ code: code });
 });

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

@@ -1,11 +1,9 @@
 import { Request, Response, Router } from "express";
-import { Guild, getPermission, toObject, Snowflake } from "@fosscord/util";
+import { Guild, getPermission, Snowflake, Member } from "@fosscord/util";
 import { HTTPError } from "lambert-server";
 
 import { check } from "../../../util/instanceOf";
-import { isMember } from "../../../util/Member";
+import { GuildUpdateWelcomeScreenSchema } from "../../../schema/Guild";
-import { GuildAddChannelToWelcomeScreenSchema } from "../../../schema/Guild";
-import { getPublicUser } from "../../../util/User";
 
 const router: Router = Router();
 
@@ -14,34 +12,24 @@ router.get("/", async (req: Request, res: Response) => {
 
 	const guild = await Guild.findOneOrFail({ id: guild_id });
 
-	await isMember(req.user_id, guild_id);
+	await Member.IsInGuildOrFail(req.user_id, guild_id);
 
 	res.json(guild.welcome_screen);
 });
 
-router.post("/", check(GuildAddChannelToWelcomeScreenSchema), async (req: Request, res: Response) => {
+router.patch("/", check(GuildUpdateWelcomeScreenSchema), async (req: Request, res: Response) => {
 	const guild_id = req.params.guild_id;
-	const body = req.body as GuildAddChannelToWelcomeScreenSchema;
+	const body = req.body as GuildUpdateWelcomeScreenSchema;
 
 	const guild = await Guild.findOneOrFail({ id: guild_id });
 
-	var channelObject = {
-		...body
-	};
-
 	const perms = await getPermission(req.user_id, guild_id);
 	perms.hasThrow("MANAGE_GUILD");
 
 	if (!guild.welcome_screen.enabled) throw new HTTPError("Welcome screen disabled", 400);
-	if (guild.welcome_screen.welcome_channels.some((channel) => channel.channel_id === body.channel_id))
+	if (body.welcome_channels) guild.welcome_screen.welcome_channels = body.welcome_channels; // TODO: check if they exist and are valid
-		throw new Error("Welcome Channel exists");
+	if (body.description) guild.welcome_screen.description = body.description;
-
+	if (body.enabled != null) guild.welcome_screen.enabled = body.enabled;
-	await Guild.findOneOrFailAndUpdate(
-		{
-			id: guild_id
-		},
-		{ $push: { "welcome_screen.welcome_channels": channelObject } }
-	);
 
 	res.sendStatus(204);
 });

api/src/routes/guilds/#guild_id/widget.json.ts

@@ -1,5 +1,5 @@
 import { Request, Response, Router } from "express";
-import { Config, Permissions, Guild, InviteModel, Channel, Member } from "@fosscord/util";
+import { Config, Permissions, Guild, Invite, Channel, Member } from "@fosscord/util";
 import { HTTPError } from "lambert-server";
 import { random } from "../../../util/RandomInviteID";
 
@@ -21,7 +21,8 @@ router.get("/", async (req: Request, res: Response) => {
 	if (!guild.widget_enabled) throw new HTTPError("Widget Disabled", 404);
 
 	// Fetch existing widget invite for widget channel
-	var invite = await Invite.findOneOrFail({ channel_id: guild.widget_channel_id, inviter_id: { $type: 10 } });
+	var invite = await Invite.findOne({ channel_id: guild.widget_channel_id });
+
 	if (guild.widget_channel_id && !invite) {
 		// Create invite for channel if none exists
 		// TODO: Refactor invite create code to a shared function
@@ -40,85 +41,29 @@ router.get("/", async (req: Request, res: Response) => {
 			inviter_id: null
 		};
 
-		invite = await new InviteModel(body).save();
+		invite = await new Invite(body).save();
 	}
 
 	// Fetch voice channels, and the @everyone permissions object
-	let channels: any[] = [];
+	const channels = [] as any[];
-	await Channel.find({ guild_id: guild_id, type: 2 }, { permission_overwrites: { $elemMatch: { id: guild_id } } })
+
-		.select("id name position permission_overwrites")
+	(await Channel.find({ where: { guild_id: guild_id, type: 2 }, order: { position: "ASC" } })).filter((doc) => {
-		.sort({ position: 1 })
+		// Only return channels where @everyone has the CONNECT permission
-		.cursor()
+		if (
-		.eachAsync((doc) => {
+			doc.permission_overwrites === undefined ||
-			// Only return channels where @everyone has the CONNECT permission
+			Permissions.channelPermission(doc.permission_overwrites, Permissions.FLAGS.CONNECT) === Permissions.FLAGS.CONNECT
-			if (
+		) {
-				doc.permission_overwrites === undefined ||
+			channels.push({
-				Permissions.channelPermission(doc.permission_overwrites, Permissions.FLAGS.CONNECT) === Permissions.FLAGS.CONNECT
+				id: doc.id,
-			) {
+				name: doc.name,
-				channels.push({
+				position: doc.position
-					id: doc.id,
+			});
-					name: doc.name,
+		}
-					position: doc.position
+	});
-				});
-			}
-		});
 
 	// Fetch members
 	// TODO: Understand how Discord's max 100 random member sample works, and apply to here (see top of this file)
-	let members: any[] = [];
+	let members = await Member.find({ where: { guild_id: guild_id } });
-	await Member.find({ guild_id: guild_id })
-		.populate({ path: "user", select: { _id: 0, username: 1, avatar: 1, presence: 1 } })
-		.select("id user nick deaf mute")
-		.cursor()
-		.eachAsync((doc) => {
-			const status = doc.user?.presence?.status || "offline";
-			if (status == "offline") return;
-
-			let item = {};
-
-			item = {
-				...item,
-				id: null, // this is updated during the sort outside of the query
-				username: doc.nick || doc.user?.username,
-				discriminator: "0000", // intended (https://github.com/discord/discord-api-docs/issues/1287)
-				avatar: null, // intended, avatar_url below will return a unique guild + user url to the avatar
-				status: status
-			};
-
-			const activity = doc.user?.presence?.activities?.[0];
-			if (activity) {
-				item = {
-					...item,
-					game: { name: activity.name }
-				};
-			}
-
-			// TODO: If the member is in a voice channel, return extra widget details
-			// Extra fields returned include deaf, mute, self_deaf, self_mute, supress, and channel_id (voice channel connected to)
-			// Get this from VoiceState
-
-			// TODO: Implement a widget-avatar endpoint on the CDN, and implement logic here to request it
-			// Get unique avatar url for guild user, cdn to serve the actual avatar image on this url
-			/*
-		const avatar = doc.user?.avatar;
-		if (avatar) {
-			const CDN_HOST = Config.get().cdn.endpoint || "http://localhost:3003";
-			const avatar_url = "/widget-avatars/" + ;
-			item = {
-				...item,
-				avatar_url: avatar_url
-			}
-		}
-		*/
-
-			members.push(item);
-		});
-
-	// Sort members, and update ids (Unable to do under the mongoose query due to https://mongoosejs.com/docs/faq.html#populate_sort_order)
-	members = members.sort((first, second) => 0 - (first.username > second.username ? -1 : 1));
-	members.forEach((x, i) => {
-		x.id = i;
-	});
 
 	// Construct object to respond with
 	const data = {

api/src/routes/guilds/index.ts

@@ -1,10 +1,8 @@
 import { Router, Request, Response } from "express";
-import { Role, Guild, Snowflake, Guild, RoleDocument, Config } from "@fosscord/util";
+import { Role, Guild, Snowflake, Config, User, Member } from "@fosscord/util";
 import { HTTPError } from "lambert-server";
 import { check } from "./../../util/instanceOf";
 import { GuildCreateSchema } from "../../schema/Guild";
-import { getPublicUser } from "../../util/User";
-import { addMember } from "../../util/Member";
 import { createChannel } from "../../util/Channel";
 
 const router: Router = Router();
@@ -15,14 +13,13 @@ router.post("/", check(GuildCreateSchema), async (req: Request, res: Response) =
 	const body = req.body as GuildCreateSchema;
 
 	const { maxGuilds } = Config.get().limits.user;
-	const user = await getPublicUser(req.user_id, { guilds: true });
+	const guild_count = await Member.count({ where: { id: req.user_id } });
-
+	if (guild_count >= maxGuilds) {
-	if (user.guilds.length >= maxGuilds) {
 		throw new HTTPError(`Maximum number of guilds reached ${maxGuilds}`, 403);
 	}
 
 	const guild_id = Snowflake.generate();
-	const guild: Guild = {
+	const guild = new Guild({
 		name: body.name,
 		region: Config.get().regions.default,
 		owner_id: req.user_id,
@@ -62,7 +59,7 @@ router.post("/", check(GuildCreateSchema), async (req: Request, res: Response) =
 		},
 		widget_channel_id: undefined,
 		widget_enabled: false
-	};
+	});
 
 	const [guild_doc, role] = await Promise.all([
 		new Guild(guild).save(),
@@ -94,14 +91,14 @@ router.post("/", check(GuildCreateSchema), async (req: Request, res: Response) =
 		body.channels?.map((x) => {
 			var id = ids.get(x.id) || Snowflake.generate();
 
-			// TODO: should we abort if parent_id is a category? (or not to allow sub category channels)
+			// TODO: should we abort if parent_id is a category? (to disallow sub category channels)
 			var parent_id = ids.get(x.parent_id);
 
 			return createChannel({ ...x, guild_id, id, parent_id }, req.user_id, { keepId: true, skipExistsCheck: true });
 		})
 	);
 
-	await addMember(req.user_id, guild_id);
+	await Member.addToGuild(req.user_id, guild_id);
 
 	res.status(201).json({ id: guild.id });
 });

api/src/routes/guilds/templates/index.ts

@@ -1,10 +1,9 @@
 import { Request, Response, Router } from "express";
 const router: Router = Router();
-import { Template, Guild, Role, Snowflake, Config, User } from "@fosscord/util";
+import { Template, Guild, Role, Snowflake, Config, User, Member } from "@fosscord/util";
 import { HTTPError } from "lambert-server";
 import { GuildTemplateCreateSchema } from "../../../schema/Guild";
 import { check } from "../../../util/instanceOf";
-import { addMember } from "../../../util/Member";
 
 router.get("/:code", async (req: Request, res: Response) => {
 	const { code } = req.params;
@@ -19,9 +18,9 @@ router.post("/:code", check(GuildTemplateCreateSchema), async (req: Request, res
 	const body = req.body as GuildTemplateCreateSchema;
 
 	const { maxGuilds } = Config.get().limits.user;
-	const user = await User.getPublicUser(req.user_id, { guilds: true });
 
-	if (user.guilds.length >= maxGuilds) {
+	const guild_count = await Member.count({ id: req.user_id });
+	if (guild_count >= maxGuilds) {
 		throw new HTTPError(`Maximum number of guilds reached ${maxGuilds}`, 403);
 	}
 
@@ -29,15 +28,13 @@ router.post("/:code", check(GuildTemplateCreateSchema), async (req: Request, res
 
 	const guild_id = Snowflake.generate();
 
-	const guild: Guild = {
+	const [guild, role] = await Promise.all([
-		...body,
+		new Guild({
-		...template.serialized_source_guild,
+			...body,
-		id: guild_id,
+			...template.serialized_source_guild,
-		owner_id: req.user_id
+			id: guild_id,
-	};
+			owner_id: req.user_id
-
+		}).save(),
-	const [guild_doc, role] = await Promise.all([
-		new Guild(guild).save(),
 		new Role({
 			id: guild_id,
 			guild_id: guild_id,
@@ -52,7 +49,7 @@ router.post("/:code", check(GuildTemplateCreateSchema), async (req: Request, res
 		}).save()
 	]);
 
-	await addMember(req.user_id, guild_id, { guild: guild_doc });
+	await Member.addToGuild(req.user_id, guild_id);
 
 	res.status(201).json({ id: guild.id });
 });

api/src/routes/invites/index.ts

@@ -1,14 +1,12 @@
 import { Router, Request, Response } from "express";
-import { getPermission, Guild, Invite } from "@fosscord/util";
+import { getPermission, Guild, Invite, Member } from "@fosscord/util";
 import { HTTPError } from "lambert-server";
-import { addMember } from "../../util/Member";
 const router: Router = Router();
 
 router.get("/:code", async (req: Request, res: Response) => {
 	const { code } = req.params;
 
 	const invite = await Invite.findOneOrFail({ code });
-	if (!invite) throw new HTTPError("Unknown Invite", 404);
 
 	res.status(200).send(invite);
 });
@@ -16,11 +14,11 @@ router.get("/:code", async (req: Request, res: Response) => {
 router.post("/:code", async (req: Request, res: Response) => {
 	const { code } = req.params;
 
-	const invite = await Invite.findOneOrFailAndUpdate({ code }, { $inc: { uses: 1 } }, { new: true });
+	const invite = await Invite.findOneOrFail({ code });
-	if (!invite) throw new HTTPError("Unknown Invite", 404);
+	if (invite.uses++ >= invite.max_uses) await Invite.delete({ code });
-	if (invite.uses >= invite.max_uses) await Invite.deleteOne({ code });
+	else await invite.save();
 
-	await addMember(req.user_id, invite.guild_id);
+	await Member.addToGuild(req.user_id, invite.guild_id);
 
 	res.status(200).send(invite);
 });
@@ -30,15 +28,12 @@ router.delete("/:code", async (req: Request, res: Response) => {
 	const invite = await Invite.findOneOrFail({ code });
 	const { guild_id, channel_id } = invite;
 
-	const guild = await Guild.findOneOrFail({ id: guild_id });
+	const permission = await getPermission(req.user_id, guild_id, channel_id);
-	const permission = await getPermission(req.user_id, guild_id, channel_id, { guild });
 
 	if (!permission.has("MANAGE_GUILD") && !permission.has("MANAGE_CHANNELS"))
 		throw new HTTPError("You missing the MANAGE_GUILD or MANAGE_CHANNELS permission", 401);
 
-	await Invite.deleteOne({ code });
+	await Promise.all([Invite.delete({ code }), Guild.update({ vanity_url_code: code }, { vanity_url_code: undefined })]);
-
-	await Guild.update({ vanity_url_code: code }, { $unset: { vanity_url_code: 1 } }).catch((e) => {});
 
 	res.json({ invite: invite });
 });

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

@@ -1,13 +1,12 @@
 import { Router, Request, Response } from "express";
-import { getPublicUser } from "../../../util/User";
+import { User } from "../../../../../util/dist";
-import { HTTPError } from "lambert-server";
 
 const router: Router = Router();
 
 router.get("/", async (req: Request, res: Response) => {
 	const { id } = req.params;
 
-	res.json(await getPublicUser(id));
+	res.json(await User.getPublicUser(id));
 });
 
 export default router;

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

@@ -1,10 +1,10 @@
 import { Router, Request, Response } from "express";
-import { getPublicUser } from "../../../util/User";
+import { User } from "../../../../../util/dist";
 
 const router: Router = Router();
 
 router.get("/", async (req: Request, res: Response) => {
-	const user = await getPublicUser(req.params.id, { data: true });
+	const user = await User.getPublicUser(req.params.id, { relations: ["connected_accounts"] });
 
 	res.json({
 		connected_accounts: user.connected_accounts,

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

@@ -1,20 +1,10 @@
 import { Router, Request, Response } from "express";
-import {
+import { Channel, ChannelCreateEvent, ChannelType, Snowflake, trimSpecial, User, emitEvent } from "@fosscord/util";
-	Channel,
-	ChannelCreateEvent,
-	toObject,
-	ChannelType,
-	Snowflake,
-	trimSpecial,
-	Channel,
-	DMChannel,
-	User,
-	emitEvent
-} from "@fosscord/util";
 import { HTTPError } from "lambert-server";
 
 import { DmChannelCreateSchema } from "../../../schema/Channel";
 import { check } from "../../../util/instanceOf";
+import { In } from "typeorm";
 
 const router: Router = Router();
 
@@ -29,8 +19,10 @@ router.post("/", check(DmChannelCreateSchema), async (req: Request, res: Respons
 
 	body.recipients = body.recipients.filter((x) => x !== req.user_id).unique();
 
-	if (!(await Promise.all(body.recipients.map((x) => User.exists({ id: x })))).every((x) => x)) {
+	const recipients = await User.find({ id: In(body.recipients) });
-		throw new HTTPError("Recipient not found");
+
+	if (recipients.length !== body.recipients.length) {
+		throw new HTTPError("Recipient/s not found");
 	}
 
 	const type = body.recipients.length === 1 ? ChannelType.DM : ChannelType.GROUP_DM;
@@ -40,13 +32,12 @@ router.post("/", check(DmChannelCreateSchema), async (req: Request, res: Respons
 		name,
 		type,
 		owner_id: req.user_id,
-		id: Snowflake.generate(),
 		created_at: new Date(),
 		last_message_id: null,
 		recipient_ids: [...body.recipients, req.user_id]
 	}).save();
 
-	await emitEvent({ event: "CHANNEL_CREATE", data: channel), user_id: req.user_id } as ChannelCreateEvent;
+	await emitEvent({ event: "CHANNEL_CREATE", data: channel, user_id: req.user_id } as ChannelCreateEvent);
 
 	res.json(channel);
 });

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

@@ -5,12 +5,19 @@ const router = Router();
 
 router.post("/", async (req: Request, res: Response) => {
 	const user = await User.findOneOrFail({ id: req.user_id }); //User object
+	let correctpass = true;
+
+	if (user.data.hash) {
+		// guest accounts can delete accounts without password
+		correctpass = await bcrypt.compare(req.body.password, user.data.hash); //Not sure if user typed right password :/
+	}
+
+	// TODO: decrement guild member count
 
-	let correctpass = await bcrypt.compare(req.body.password, user!.data.hash); //Not sure if user typed right password :/
 	if (correctpass) {
 		await Promise.all([
-			User.deleteOne({ id: req.user_id }), //Yeetus user deletus
+			User.delete({ id: req.user_id }), //Yeetus user deletus
-			Member.deleteMany({ id: req.user_id })
+			Member.delete({ id: req.user_id })
 		]);
 
 		res.sendStatus(204);

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

@@ -5,9 +5,14 @@ import bcrypt from "bcrypt";
 const router = Router();
 
 router.post("/", async (req: Request, res: Response) => {
-	const user = await User.findOneOrFail({ id: req.user_id }); //User object
+	const user = await User.findOneOrFail(req.user_id); //User object
+	let correctpass = true;
+
+	if (user.data.hash) {
+		// guest accounts can delete accounts without password
+		correctpass = await bcrypt.compare(req.body.password, user.data.hash); //Not sure if user typed right password :/
+	}
 
-	let correctpass = await bcrypt.compare(req.body.password, user!.data.hash); //Not sure if user typed right password :/
 	if (correctpass) {
 		await User.update({ id: req.user_id }, { disabled: true });
 

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

@@ -1,31 +1,26 @@
 import { Router, Request, Response } from "express";
-import { Guild, Member, User, GuildDeleteEvent, GuildMemberRemoveEvent, toObject, emitEvent } from "@fosscord/util";
+import { Guild, Member, User, GuildDeleteEvent, GuildMemberRemoveEvent, emitEvent } from "@fosscord/util";
 import { HTTPError } from "lambert-server";
-
+import { In } from "typeorm";
-import { getPublicUser } from "../../../util/User";
 
 const router: Router = Router();
 
 router.get("/", async (req: Request, res: Response) => {
-	const user = await User.findOneOrFail({ id: req.user_id }, { guilds: true });
+	const members = await Member.find({ relations: ["guild"], where: { id: req.user_id } });
-	if (!user) throw new HTTPError("User not found", 404);
 
-	var guildIDs = user.guilds || [];
+	res.json(members.map((x) => x.guild));
-	var guild = await Guild.find({ id: { $in: guildIDs } }).populate({ path: "joined_at", match: { id: req.user_id } });
-	res.json(guild);
 });
 
 // user send to leave a certain guild
 router.delete("/:id", async (req: Request, res: Response) => {
 	const guild_id = req.params.id;
-	const guild = await Guild.findOneOrFail({ id: guild_id }, { guild_id: true });
+	const guild = await Guild.findOneOrFail({ where: { id: guild_id }, select: ["owner_id"] });
 
 	if (!guild) throw new HTTPError("Guild doesn't exist", 404);
 	if (guild.owner_id === req.user_id) throw new HTTPError("You can't leave your own guild", 400);
 
 	await Promise.all([
-		Member.deleteOne({ id: req.user_id, guild_id: guild_id }),
+		Member.delete({ id: req.user_id, guild_id: guild_id }),
-		User.update({ id: req.user_id }, { $pull: { guilds: guild_id } }),
 		emitEvent({
 			event: "GUILD_DELETE",
 			data: {
@@ -35,7 +30,7 @@ router.delete("/:id", async (req: Request, res: Response) => {
 		} as GuildDeleteEvent)
 	]);
 
-	const user = await getPublicUser(req.user_id);
+	const user = await User.getPublicUser(req.user_id);
 
 	await emitEvent({
 		event: "GUILD_MEMBER_REMOVE",

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

@@ -1,6 +1,5 @@
 import { Router, Request, Response } from "express";
-import { User, toObject, PublicUserProjection } from "@fosscord/util";
+import { User } from "@fosscord/util";
-import { getPublicUser } from "../../../util/User";
 import { UserModifySchema } from "../../../schema/User";
 import { check } from "../../../util/instanceOf";
 import { handleFile } from "../../../util/cdn";
@@ -8,29 +7,29 @@ import { handleFile } from "../../../util/cdn";
 const router: Router = Router();
 
 router.get("/", async (req: Request, res: Response) => {
-	res.json(await getPublicUser(req.user_id));
+	res.json(await User.getPublicUser(req.user_id));
 });
 
-const UserUpdateProjection = {
+const UserUpdateProjection = [
-	accent_color: true,
+	"accent_color",
-	avatar: true,
+	"avatar",
-	banner: true,
+	"banner",
-	bio: true,
+	"bio",
-	bot: true,
+	"bot",
-	discriminator: true,
+	"discriminator",
-	email: true,
+	"email",
-	flags: true,
+	"flags",
-	id: true,
+	"id",
-	locale: true,
+	"locale",
-	mfa_enabled: true,
+	"mfa_enabled",
-	nsfw_alllowed: true,
+	"nsfw_alllowed",
-	phone: true,
+	"phone",
-	public_flags: true,
+	"public_flags",
-	purchased_flags: true,
+	"purchased_flags",
-	// token: true, // this isn't saved in the db and needs to be set manually
+	// "token", // this isn't saved in the db and needs to be set manually
-	username: true,
+	"username",
-	verified: true
+	"verified"
-};
+];
 
 router.patch("/", check(UserModifySchema), async (req: Request, res: Response) => {
 	const body = req.body as UserModifySchema;
@@ -38,7 +37,7 @@ router.patch("/", check(UserModifySchema), async (req: Request, res: Response) =
 	if (body.avatar) body.avatar = await handleFile(`/avatars/${req.user_id}`, body.avatar as string);
 	if (body.banner) body.banner = await handleFile(`/banners/${req.user_id}`, body.banner as string);
 
-	const user = await User.findOneOrFailAndUpdate({ id: req.user_id }, body, { projection: UserUpdateProjection, new: true });
+	const user = await new User({ ...body }, { id: req.user_id }).save();
 	// TODO: dispatch user update event
 
 	res.json(user);

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

@@ -1,13 +1,13 @@
 import { Router, Request, Response } from "express";
-import { getPublicUser } from "../../../util/User";
+import { User } from "../../../../../util/dist";
 
 const router: Router = Router();
 
 router.get("/", async (req: Request, res: Response) => {
-	const user = await getPublicUser(req.user_id, { data: true });
+	const user = await User.getPublicUser(req.user_id, { relations: ["connected_accounts"] });
 
 	res.json({
-		connected_accounts: user.data.connected_accounts,
+		connected_accounts: user.connected_accounts,
 		premium_guild_since: null, // TODO
 		premium_since: null, // TODO
 		user: {

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

@@ -2,11 +2,10 @@ import {
 	RelationshipAddEvent,
 	User,
 	PublicUserProjection,
-	toObject,
 	RelationshipType,
 	RelationshipRemoveEvent,
-	UserDocument,
+	emitEvent,
-	emitEvent
+	Relationship
 } from "@fosscord/util";
 import { Router, Response, Request } from "express";
 import { HTTPError } from "lambert-server";
@@ -15,40 +14,36 @@ import { check, Length } from "../../../util/instanceOf";
 
 const router = Router();
 
-const userProjection = { "data.relationships": true, ...PublicUserProjection };
+const userProjection: (keyof User)[] = ["relationships", ...PublicUserProjection];
 
 router.get("/", async (req: Request, res: Response) => {
-	const user = await User.findOneOrFail({ id: req.user_id }, { data: { relationships: true } }).populate({
+	const user = await User.findOneOrFail({ where: { id: req.user_id }, select: ["relationships"] });
-		path: "data.relationships.id",
+
-		model: User
+	return res.json(user.relationships);
-	});
-	return res.json(user.data.relationships);
 });
 
-async function addRelationship(req: Request, res: Response, friend: UserDocument, type: RelationshipType) {
+async function updateRelationship(req: Request, res: Response, friend: User, type: RelationshipType) {
 	const id = friend.id;
 	if (id === req.user_id) throw new HTTPError("You can't add yourself as a friend");
 
-	const user = await User.findOneOrFail({ id: req.user_id }, userProjection);
+	const user = await User.findOneOrFail(req.user_id, { relations: ["relationships"], select: userProjection });
-	const newUserRelationships = [...user.data.relationships];
-	const newFriendRelationships = [...friend.data.relationships];
 
-	var relationship = newUserRelationships.find((x) => x.id === id);
+	var relationship = user.relationships.find((x) => x.id === id);
-	const friendRequest = newFriendRelationships.find((x) => x.id === req.user_id);
+	const friendRequest = friend.relationships.find((x) => x.id === req.user_id);
 
 	if (type === RelationshipType.blocked) {
 		if (relationship) {
 			if (relationship.type === RelationshipType.blocked) throw new HTTPError("You already blocked the user");
 			relationship.type = RelationshipType.blocked;
 		} else {
-			relationship = { id, type: RelationshipType.blocked };
+			relationship = new Relationship({ id, type: RelationshipType.blocked });
-			newUserRelationships.push(relationship);
+			user.relationships.push(relationship);
 		}
 
 		if (friendRequest && friendRequest.type !== RelationshipType.blocked) {
-			newFriendRelationships.remove(friendRequest);
+			friend.relationships.remove(friendRequest);
 			await Promise.all([
-				User.update({ id: friend.id }, { "data.relationships": newFriendRelationships }),
+				user.save(),
 				emitEvent({
 					event: "RELATIONSHIP_REMOVE",
 					data: friendRequest,
@@ -58,12 +53,12 @@ async function addRelationship(req: Request, res: Response, friend: UserDocument
 		}
 
 		await Promise.all([
-			User.update({ id: req.user_id }, { "data.relationships": newUserRelationships }),
+			user.save(),
 			emitEvent({
 				event: "RELATIONSHIP_ADD",
 				data: {
 					...relationship,
-					user: { ...friend, data: undefined }
+					user: { ...friend }
 				},
 				user_id: req.user_id
 			} as RelationshipAddEvent)
@@ -72,32 +67,31 @@ async function addRelationship(req: Request, res: Response, friend: UserDocument
 		return res.sendStatus(204);
 	}
 
-	var incoming_relationship = { id: req.user_id, nickname: undefined, type: RelationshipType.incoming };
+	var incoming_relationship = new Relationship({ nickname: undefined, type: RelationshipType.incoming }, { id: req.user_id });
-	var outgoing_relationship = { id, nickname: undefined, type: RelationshipType.outgoing };
+	var outgoing_relationship = new Relationship({ nickname: undefined, type: RelationshipType.outgoing }, { id });
 
 	if (friendRequest) {
 		if (friendRequest.type === RelationshipType.blocked) throw new HTTPError("The user blocked you");
 		// accept friend request
-		// @ts-ignore
 		incoming_relationship = friendRequest;
 		incoming_relationship.type = RelationshipType.friends;
 		outgoing_relationship.type = RelationshipType.friends;
-	} else newFriendRelationships.push(incoming_relationship);
+	} else friend.relationships.push(incoming_relationship);
 
 	if (relationship) {
 		if (relationship.type === RelationshipType.outgoing) throw new HTTPError("You already sent a friend request");
 		if (relationship.type === RelationshipType.blocked) throw new HTTPError("Unblock the user before sending a friend request");
 		if (relationship.type === RelationshipType.friends) throw new HTTPError("You are already friends with the user");
-	} else newUserRelationships.push(outgoing_relationship);
+	} else user.relationships.push(outgoing_relationship);
 
 	await Promise.all([
-		User.update({ id: req.user_id }, { "data.relationships": newUserRelationships }),
+		user.save(),
-		User.update({ id: friend.id }, { "data.relationships": newFriendRelationships }),
+		friend.save(),
 		emitEvent({
 			event: "RELATIONSHIP_ADD",
 			data: {
 				...outgoing_relationship,
-				user: { ...friend, data: undefined }
+				user: { ...friend }
 			},
 			user_id: req.user_id
 		} as RelationshipAddEvent),
@@ -106,7 +100,7 @@ async function addRelationship(req: Request, res: Response, friend: UserDocument
 			data: {
 				...incoming_relationship,
 				should_notify: true,
-				user: { ...user, data: undefined }
+				user: { ...user }
 			},
 			user_id: id
 		} as RelationshipAddEvent)
@@ -116,14 +110,23 @@ async function addRelationship(req: Request, res: Response, friend: UserDocument
 }
 
 router.put("/:id", check({ $type: new Length(Number, 1, 4) }), async (req: Request, res: Response) => {
-	return await addRelationship(req, res, await User.findOneOrFail({ id: req.params.id }), req.body.type);
+	return await updateRelationship(
+		req,
+		res,
+		await User.findOneOrFail(req.params.id, { relations: ["relationships"], select: userProjection }),
+		req.body.type
+	);
 });
 
 router.post("/", check({ discriminator: String, username: String }), async (req: Request, res: Response) => {
-	return await addRelationship(
+	return await updateRelationship(
 		req,
 		res,
-		await User.findOneOrFail(req.body as { discriminator: string; username: string }),
+		await User.findOneOrFail({
+			relations: ["relationships"],
+			select: userProjection,
+			where: req.body as { discriminator: string; username: string }
+		}),
 		req.body.type
 	);
 });
@@ -132,17 +135,15 @@ router.delete("/:id", async (req: Request, res: Response) => {
 	const { id } = req.params;
 	if (id === req.user_id) throw new HTTPError("You can't remove yourself as a friend");
 
-	const user = await User.findOneOrFail({ id: req.user_id });
+	const user = await User.findOneOrFail(req.user_id, { select: userProjection, relations: ["relationships"] });
-	if (!user) throw new HTTPError("Invalid token", 400);
+	const friend = await User.findOneOrFail(id, { select: userProjection, relations: ["relationships"] });
 
-	const friend = await User.findOneOrFail({ id }, userProjection);
+	const relationship = user.relationships.find((x) => x.id === id);
-	if (!friend) throw new HTTPError("User not found", 404);
+	const friendRequest = friend.relationships.find((x) => x.id === req.user_id);
 
-	const relationship = user.data.relationships.find((x) => x.id === id);
-	const friendRequest = friend.data.relationships.find((x) => x.id === req.user_id);
 	if (relationship?.type === RelationshipType.blocked) {
 		// unblock user
-		user.data.relationships.remove(relationship);
+		user.relationships.remove(relationship);
 
 		await Promise.all([
 			user.save(),
@@ -153,8 +154,8 @@ router.delete("/:id", async (req: Request, res: Response) => {
 	if (!relationship || !friendRequest) throw new HTTPError("You are not friends with the user", 404);
 	if (friendRequest.type === RelationshipType.blocked) throw new HTTPError("The user blocked you");
 
-	user.data.relationships.remove(relationship);
+	user.relationships.remove(relationship);
-	friend.data.relationships.remove(friendRequest);
+	friend.relationships.remove(friendRequest);
 
 	await Promise.all([
 		user.save(),

api/src/schema/Guild.ts

@@ -1,4 +1,4 @@
-import { ChannelSchema, GuildChannel } from "@fosscord/util";
+import { Channel } from "@fosscord/util";
 import { Length } from "../util/instanceOf";
 import { ChannelModifySchema } from "./Channel";
 
@@ -59,54 +59,6 @@ export interface GuildUpdateSchema extends Omit<GuildCreateSchema, "channels"> {
 	preferred_locale?: string;
 }
 
-export const GuildGetSchema = {
-	id: true,
-	name: true,
-	icon: true,
-	splash: true,
-	discovery_splash: true,
-	owner: true,
-	owner_id: true,
-	permissions: true,
-	region: true,
-	afk_channel_id: true,
-	afk_timeout: true,
-	widget_enabled: true,
-	widget_channel_id: true,
-	verification_level: true,
-	default_message_notifications: true,
-	explicit_content_filter: true,
-	roles: true,
-	emojis: true,
-	features: true,
-	mfa_level: true,
-	application_id: true,
-	system_channel_id: true,
-	system_channel_flags: true,
-	rules_channel_id: true,
-	joined_at: true,
-	// large: true,
-	// unavailable: true,
-	member_count: true,
-	// voice_states: true,
-	// members: true,
-	// channels: true,
-	// presences: true,
-	max_presences: true,
-	max_members: true,
-	vanity_url_code: true,
-	description: true,
-	banner: true,
-	premium_tier: true,
-	premium_subscription_count: true,
-	preferred_locale: true,
-	public_updates_channel_id: true,
-	max_video_channel_users: true,
-	approximate_member_count: true,
-	approximate_presence_count: true
-	// welcome_screen: true,
-};
-
 export const GuildTemplateCreateSchema = {
 	name: String,
 	$avatar: String
@@ -117,16 +69,26 @@ export interface GuildTemplateCreateSchema {
 	avatar?: string;
 }
 
-export const GuildAddChannelToWelcomeScreenSchema = {
+export const GuildUpdateWelcomeScreenSchema = {
-	channel_id: String,
+	$welcome_channels: [
-	description: String,
+		{
-	$emoji_id: String,
+			channel_id: String,
-	emoji_name: String
+			description: String,
+			$emoji_id: String,
+			emoji_name: String
+		}
+	],
+	$enabled: Boolean,
+	$description: new Length(String, 0, 140)
 };
 
-export interface GuildAddChannelToWelcomeScreenSchema {
+export interface GuildUpdateWelcomeScreenSchema {
-	channel_id: string;
+	welcome_channels?: {
-	description: string;
+		channel_id: string;
-	emoji_id?: string;
+		description: string;
-	emoji_name: string;
+		emoji_id?: string;
+		emoji_name: string;
+	}[];
+	enabled?: boolean;
+	description?: string;
 }

api/src/schema/Message.ts

@@ -1,6 +1,12 @@
-import { Embed, EmbedImage } from "@fosscord/util";
+import { Embed } from "@fosscord/util";
 import { Length } from "../util/instanceOf";
 
+export const EmbedImage = {
+	$url: String,
+	$width: Number,
+	$height: Number
+};
+
 export const MessageCreateSchema = {
 	$content: new Length(String, 0, 2000),
 	$nonce: String,

api/src/schema/Roles.ts

@@ -9,7 +9,7 @@ export const RoleModifySchema = {
 
 export interface RoleModifySchema {
 	name?: string;
-	permissions?: BigInt;
+	permissions?: bigint;
 	color?: number;
 	hoist?: boolean; // whether the role should be displayed separately in the sidebar
 	mentionable?: boolean; // whether the role should be mentionable

api/src/test/mongo_test.ts

@@ -1,40 +0,0 @@
-import mongoose, { Schema, Types } from "mongoose";
-require("mongoose-long")(mongoose);
-
-const userSchema = new Schema({
-	id: String
-});
-
-const messageSchema = new Schema({
-	id: String,
-	content: String
-});
-const message = mongoose.model("message", messageSchema, "messages");
-const user = mongoose.model("user", userSchema, "users");
-
-messageSchema.virtual("u", {
-	ref: user,
-	localField: "id",
-	foreignField: "id",
-	justOne: true
-});
-
-messageSchema.set("toObject", { virtuals: true });
-messageSchema.set("toJSON", { virtuals: true });
-
-async function main() {
-	const conn = await mongoose.connect("mongodb://localhost:27017/lambert?readPreference=secondaryPreferred", {
-		useNewUrlParser: true,
-		useUnifiedTopology: false
-	});
-	console.log("connected");
-
-	// const u = await new user({ name: "test" }).save();
-	// await new message({ user: u._id, content: "test" }).save();
-
-	const test = await message.findOneOrFail({}).populate("u");
-	// @ts-ignore
-	console.log(test?.toJSON());
-}
-
-main();

api/src/test/server_benchmark.ts

@@ -1,39 +0,0 @@
-// @ts-nocheck
-import "missing-native-js-functions";
-import { config } from "dotenv";
-config();
-import { DiscordServer } from "../Server";
-import fetch from "node-fetch";
-import { promises } from "fs";
-const count = 100;
-
-async function main() {
-	const server = new DiscordServer({ port: 3000 });
-	await server.start();
-
-	const tasks = [];
-	for (let i = 0; i < count; i++) {
-		tasks.push(test());
-	}
-
-	await Promise.all(tasks);
-
-	console.log("logging in 5secs");
-	setTimeout(async () => {
-		await test();
-
-		process.exit();
-	}, 5000);
-}
-main();
-
-async function test() {
-	const res = await fetch("http://localhost:3000/api/v8/guilds/813524615463698433/members/813524464300982272", {
-		headers: {
-			authorization:
-				"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjgxMzUyNDQ2NDMwMDk4MjI3MiIsImlhdCI6MTYxNDAyOTc0Nn0.6WQiU4D5HHRi3sliHOQe1hsW-hZTEttvdtZuNIdviNI",
-		},
-	});
-
-	return await res.text();
-}

api/src/test/test.ts

@@ -1,3 +0,0 @@
-import { Snowflake } from "@fosscord/util";
-
-console.log(Snowflake.deconstruct("0"));

api/src/util/Channel.ts

@@ -1,20 +1,9 @@
-import {
+import { ChannelCreateEvent, Channel, ChannelType, emitEvent, getPermission, Snowflake } from "@fosscord/util";
-	ChannelCreateEvent,
-	Channel,
-	ChannelType,
-	emitEvent,
-	getPermission,
-	Guild,
-	Snowflake,
-	TextChannel,
-	toObject,
-	VoiceChannel
-} from "@fosscord/util";
 import { HTTPError } from "lambert-server";
 
 // TODO: DM channel
 export async function createChannel(
-	channel: Partial<TextChannel | VoiceChannel>,
+	channel: Partial<Channel>,
 	user_id: string = "0",
 	opts?: {
 		keepId?: boolean;
@@ -29,7 +18,7 @@ export async function createChannel(
 		case ChannelType.GUILD_TEXT:
 		case ChannelType.GUILD_VOICE:
 			if (channel.parent_id && !opts?.skipExistsCheck) {
-				const exists = await Channel.findOneOrFail({ id: channel.parent_id }, { guild_id: true });
+				const exists = await Channel.findOneOrFail({ id: channel.parent_id });
 				if (!exists) throw new HTTPError("Parent id channel doesn't exist", 400);
 				if (exists.guild_id !== channel.guild_id) throw new HTTPError("The category channel needs to be in the guild");
 			}

api/src/util/Member.ts

@@ -1,220 +0,0 @@
-import {
-	Guild,
-	GuildCreateEvent,
-	GuildDeleteEvent,
-	GuildMemberAddEvent,
-	GuildMemberRemoveEvent,
-	GuildMemberUpdateEvent,
-	Guild,
-	Member,
-	Role,
-	toObject,
-	User,
-	GuildDocument,
-	Config,
-	emitEvent
-} from "@fosscord/util";
-
-import { HTTPError } from "lambert-server";
-
-import { getPublicUser } from "./User";
-
-export const PublicMemberProjection = {
-	id: true,
-	guild_id: true,
-	nick: true,
-	roles: true,
-	joined_at: true,
-	pending: true,
-	deaf: true,
-	mute: true,
-	premium_since: true
-};
-
-export async function isMember(user_id: string, guild_id: string) {
-	const exists = await Member.exists({ id: user_id, guild_id });
-	if (!exists) throw new HTTPError("You are not a member of this guild", 403);
-	return exists;
-}
-
-export async function addMember(user_id: string, guild_id: string, cache?: { guild?: GuildDocument }) {
-	const user = await getPublicUser(user_id, { guilds: true });
-
-	const { maxGuilds } = Config.get().limits.user;
-	if (user.guilds.length >= maxGuilds) {
-		throw new HTTPError(`You are at the ${maxGuilds} server limit.`, 403);
-	}
-
-	const guild = cache?.guild || (await Guild.findOneOrFail({ id: guild_id }));
-
-	if (!guild) throw new HTTPError("Guild not found", 404);
-
-	if (await Member.exists({ id: user.id, guild_id })) throw new HTTPError("You are already a member of this guild", 400);
-
-	const member = {
-		id: user_id,
-		guild_id: guild_id,
-		nick: undefined,
-		roles: [guild_id], // @everyone role
-		joined_at: new Date(),
-		premium_since: undefined,
-		deaf: false,
-		mute: false,
-		pending: false
-	};
-
-	await Promise.all([
-		new Member({
-			...member,
-			read_state: {},
-			settings: {
-				channel_overrides: [],
-				message_notifications: 0,
-				mobile_push: true,
-				mute_config: null,
-				muted: false,
-				suppress_everyone: false,
-				suppress_roles: false,
-				version: 0
-			}
-		}).save(),
-
-		User.update({ id: user_id }, { $push: { guilds: guild_id } }),
-		Guild.update({ id: guild_id }, { $inc: { member_count: 1 } }),
-
-		emitEvent({
-			event: "GUILD_MEMBER_ADD",
-			data: {
-				...member,
-				user,
-				guild_id: guild_id
-			},
-			guild_id: guild_id
-		} as GuildMemberAddEvent)
-	]);
-
-	await emitEvent({
-		event: "GUILD_CREATE",
-		data: await guild
-			.populate({ path: "members", match: { guild_id } })
-			.populate({ path: "joined_at", match: { id: user.id } })
-			.execPopulate(),
-		user_id
-	} as GuildCreateEvent);
-}
-
-export async function removeMember(user_id: string, guild_id: string) {
-	const user = await getPublicUser(user_id);
-
-	const guild = await Guild.findOneOrFail({ id: guild_id }, { owner_id: true });
-	if (!guild) throw new HTTPError("Guild not found", 404);
-	if (guild.owner_id === user_id) throw new Error("The owner cannot be removed of the guild");
-	if (!(await Member.exists({ id: user.id, guild_id }))) throw new HTTPError("Is not member of this guild", 404);
-
-	// use promise all to execute all promises at the same time -> save time
-	return Promise.all([
-		Member.deleteOne({
-			id: user_id,
-			guild_id: guild_id
-		}),
-		User.update({ id: user.id }, { $pull: { guilds: guild_id } }),
-		Guild.update({ id: guild_id }, { $inc: { member_count: -1 } }),
-
-		emitEvent({
-			event: "GUILD_DELETE",
-			data: {
-				id: guild_id
-			},
-			user_id: user_id
-		} as GuildDeleteEvent),
-		emitEvent({
-			event: "GUILD_MEMBER_REMOVE",
-			data: {
-				guild_id: guild_id,
-				user: user
-			},
-			guild_id: guild_id
-		} as GuildMemberRemoveEvent)
-	]);
-}
-
-export async function addRole(user_id: string, guild_id: string, role_id: string) {
-	const user = await getPublicUser(user_id);
-
-	const role = await Role.findOneOrFail({ id: role_id, guild_id: guild_id });
-	if (!role) throw new HTTPError("role not found", 404);
-
-	var memberObj = await Member.findOneOrFailAndUpdate(
-		{
-			id: user_id,
-			guild_id: guild_id
-		},
-		{ $push: { roles: role_id } },
-		{ new: true }
-	);
-
-	if (!memberObj) throw new HTTPError("Member not found", 404);
-
-	await emitEvent({
-		event: "GUILD_MEMBER_UPDATE",
-		data: {
-			guild_id: guild_id,
-			user: user,
-			roles: memberObj.roles
-		},
-		guild_id: guild_id
-	} as GuildMemberUpdateEvent);
-}
-
-export async function removeRole(user_id: string, guild_id: string, role_id: string) {
-	const user = await getPublicUser(user_id);
-
-	const role = await Role.findOneOrFail({ id: role_id, guild_id: guild_id });
-	if (!role) throw new HTTPError("role not found", 404);
-
-	var memberObj = await Member.findOneOrFailAndUpdate(
-		{
-			id: user_id,
-			guild_id: guild_id
-		},
-		{ $pull: { roles: role_id } },
-		{ new: true }
-	);
-
-	if (!memberObj) throw new HTTPError("Member not found", 404);
-
-	await emitEvent({
-		event: "GUILD_MEMBER_UPDATE",
-		data: {
-			guild_id: guild_id,
-			user: user,
-			roles: memberObj.roles
-		},
-		guild_id: guild_id
-	} as GuildMemberUpdateEvent);
-}
-
-export async function changeNickname(user_id: string, guild_id: string, nickname: string) {
-	const user = await getPublicUser(user_id);
-
-	var memberObj = await Member.findOneOrFailAndUpdate(
-		{
-			id: user_id,
-			guild_id: guild_id
-		},
-		{ nick: nickname },
-		{ new: true }
-	);
-
-	if (!memberObj) throw new HTTPError("Member not found", 404);
-
-	await emitEvent({
-		event: "GUILD_MEMBER_UPDATE",
-		data: {
-			guild_id: guild_id,
-			user: user,
-			nick: nickname
-		},
-		guild_id: guild_id
-	} as GuildMemberUpdateEvent);
-}

api/src/util/Message.ts

@@ -8,18 +8,17 @@ import {
 	getPermission,
 	CHANNEL_MENTION,
 	Snowflake,
-	PublicMemberProjection,
 	USER_MENTION,
 	ROLE_MENTION,
 	Role,
 	EVERYONE_MENTION,
-	HERE_MENTION
+	HERE_MENTION,
+	MessageType
 } from "@fosscord/util";
 import { HTTPError } from "lambert-server";
 import fetch from "node-fetch";
 import cheerio from "cheerio";
 
-import { MessageType } from "@fosscord/util/dist/util/Constants";
 // TODO: check webhook, application, system author
 
 const LINK_REGEX = /https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)/g;
@@ -61,7 +60,7 @@ export async function handleMessage(opts: Partial<Message>): Promise<Message> {
 	}
 
 	var content = opts.content;
-	var mention_channels_ids = [] as string[];
+	var mention_channel_ids = [] as string[];
 	var mention_role_ids = [] as string[];
 	var mention_user_ids = [] as string[];
 	var mention_everyone = false;
@@ -70,7 +69,7 @@ export async function handleMessage(opts: Partial<Message>): Promise<Message> {
 	if (content) {
 		content = content.trim();
 		for (const [_, mention] of content.matchAll(CHANNEL_MENTION)) {
-			if (!mention_channels_ids.includes(mention)) mention_channels_ids.push(mention);
+			if (!mention_channel_ids.includes(mention)) mention_channel_ids.push(mention);
 		}
 
 		for (const [_, mention] of content.matchAll(USER_MENTION)) {
@@ -92,11 +91,12 @@ export async function handleMessage(opts: Partial<Message>): Promise<Message> {
 	}
 
 	// TODO: check and put it all in the body
+
 	return {
 		...opts,
 		guild_id: channel.guild_id,
 		channel_id: opts.channel_id,
-		mention_channels_ids,
+		mention_channel_ids,
 		mention_role_ids,
 		mention_user_ids,
 		mention_everyone,
@@ -104,7 +104,7 @@ export async function handleMessage(opts: Partial<Message>): Promise<Message> {
 		embeds: opts.embeds || [],
 		reactions: opts.reactions || [],
 		type: opts.type ?? 0
-	};
+	} as Message;
 }
 
 // TODO: cache link result in db
@@ -163,10 +163,7 @@ export async function postHandleMessage(message: Message) {
 export async function sendMessage(opts: Partial<Message>) {
 	const message = await handleMessage({ ...opts, id: Snowflake.generate(), timestamp: new Date() });
 
-	const data = await new Message(message)
+	const data = await new Message(message).save();
-		.populate({ path: "member", select: PublicMemberProjection })
-		.populate("referenced_message")
-		.save();
 
 	await emitEvent({ event: "MESSAGE_CREATE", channel_id: opts.channel_id, data } as MessageCreateEvent);