Dekescordes/spacebar
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

✨ typeorm api rewrite done

Browse Source
This commit is contained in:
Flam3rboy 2021-08-29 00:03:40 +02:00
parent c21c342821
commit e99008a1a5
48 changed files with 465 additions and 991 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
api/src/Server.ts
View File

@ -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 (db as Promise<Connection>);
await this.setupSchema();
await initDatabase();
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

2
api/src/index.ts
View File

@ -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";

2
api/src/middlewares/Authentication.ts
View File

@ -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);

56
api/src/routes/auth/register.ts
View File

@ -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();

26
api/src/routes/channels/#channel_id/index.ts
View File

@ -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({
event: "CHANNEL_UPDATE",
data,
channel_id
} as ChannelUpdateEvent);
res.send(data);
res.send(channel);
});
export default router;

4
api/src/routes/channels/#channel_id/invites.ts
View File

@ -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);

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

@ -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",

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

@ -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
message = await Message.findOneOrFailAndUpdate({ id: message_id }, opts, { new: true }).populate("author");
await emitEvent({
event: "MESSAGE_UPDATE",
channel_id,
data: { ...message, nonce: undefined }
} as MessageUpdateEvent);
await Promise.all([
message.save(),
await emitEvent({
event: "MESSAGE_UPDATE",
channel_id,
data: { ...message, nonce: undefined }
} 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 message = await Message.findOneOrFail({ id: message_id }, { author_id: true });
const channel = await Channel.findOneOrFail({ id: channel_id });
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",

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

@ -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 emitEvent({
event: "MESSAGE_REACTION_REMOVE_EMOJI",
channel_id,
data: {
await Promise.all([
message.save(),
emitEvent({
event: "MESSAGE_REACTION_REMOVE_EMOJI",
channel_id,
message_id,
guild_id: channel.guild_id,
emoji
}
} as MessageReactionRemoveEmojiEvent);
data: {
channel_id,
message_id,
guild_id: message.guild_id,
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);

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

@ -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",

30
api/src/routes/channels/#channel_id/messages/index.ts
View File

@ -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>;
if (after) query = Message.find({ channel_id, id: { $gt: after } });
else if (before) query = Message.find({ channel_id, id: { $lt: before } });
else if (around)
query = Message.find({
channel_id,
id: { $gt: (BigInt(around) - BigInt(halfLimit)).toString(), $lt: (BigInt(around) + BigInt(halfLimit)).toString() }
});
else {
query = Message.find({ channel_id });
var query: FindManyOptions<Message> & { where: { id?: any } } = { order: { id: "DESC" }, take: limit, where: { channel_id } };
if (after) query.where.id = MoreThan(after);
else if (before) query.where.id = LessThan(before);
else if (around) {
query.where.id = [
MoreThan((BigInt(around) - BigInt(halfLimit)).toString()),
LessThan((BigInt(around) + BigInt(halfLimit)).toString())
];
}
query = query.sort({ id: -1 });
const messages = await query.limit(limit);
const messages = await Message.find(query);
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);

29
api/src/routes/channels/#channel_id/permissions.ts
View File

@ -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(
{ id: channel_id },
{ $pull: { permission_overwrites: { id: overwrite_id } } },
{ new: true }
);
const channel = await Channel.findOneOrFail({ id: channel_id });
if (!channel.guild_id) throw new HTTPError("Channel not found", 404);
await emitEvent({
event: "CHANNEL_UPDATE",
channel_id,
data: channel
} as ChannelUpdateEvent);
channel.permission_overwrites = channel.permission_overwrites.filter((x) => x.id === overwrite_id);
await Promise.all([
channel.save(),
emitEvent({
event: "CHANNEL_UPDATE",
channel_id,
data: channel
} as ChannelUpdateEvent)
]);
return res.sendStatus(204);
});

78
api/src/routes/channels/#channel_id/pins.ts
View File

@ -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 });
const message = await Message.findOneOrFail({ id: message_id });
await emitEvent({
event: "MESSAGE_UPDATE",
channel_id,
data: message
} as MessageUpdateEvent);
await emitEvent({
event: "CHANNEL_PINS_UPDATE",
channel_id,
data: {
await Promise.all([
Message.update({ id: message_id }, { pinned: true }),
emitEvent({
event: "MESSAGE_UPDATE",
channel_id,
guild_id: channel.guild_id,
last_pin_timestamp: undefined
}
} as ChannelPinsUpdateEvent);
data: message
} as MessageUpdateEvent),
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({
event: "MESSAGE_UPDATE",
channel_id,
data: message
} as MessageUpdateEvent);
await Promise.all([
message.save(),
await emitEvent({
event: "CHANNEL_PINS_UPDATE",
channel_id,
data: {
emitEvent({
event: "MESSAGE_UPDATE",
channel_id,
guild_id: channel.guild_id,
last_pin_timestamp: undefined
}
} as ChannelPinsUpdateEvent);
data: message
} as MessageUpdateEvent),
emitEvent({
event: "CHANNEL_PINS_UPDATE",
channel_id,
data: {
channel_id,
guild_id: channel.guild_id,
last_pin_timestamp: undefined
}
} as ChannelPinsUpdateEvent)
]);
res.sendStatus(204);
});

4
api/src/routes/channels/#channel_id/typing.ts
View File

@ -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,

2
api/src/routes/channels/#channel_id/webhooks.ts
View File

@ -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);

69
api/src/routes/guilds/#guild_id/bans.ts
View File

@ -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 });
if (!guild) throw new HTTPError("Guild not found", 404);
var bans = await Ban.find({ guild_id: guild_id }, { user_id: true, reason: true });
var bans = await Ban.find({ guild_id: guild_id });
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 = await new BanModel({
const ban = new Ban({
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({
event: "GUILD_BAN_ADD",
data: {
guild_id: guild_id,
user: banned_user
},
guild_id: guild_id
} as GuildBanAddEvent);
await Promise.all([
Member.removeFromGuild(banned_user_id, guild_id),
ban.save(),
emitEvent({
event: "GUILD_BAN_ADD",
data: {
guild_id: guild_id,
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 guild = await Guild.exists({ id: guild_id });
if (!guild) throw new HTTPError("Guild not found", 404);
const banned_user = await User.getPublicUser(banned_user_id);
const perms = await getPermission(req.user_id, guild_id);
perms.hasThrow("BAN_MEMBERS");
await Ban.deleteOne({
user_id: banned_user_id,
guild_id
});
await Promise.all([
Ban.delete({
user_id: banned_user_id,
guild_id
}),
await emitEvent({
event: "GUILD_BAN_REMOVE",
data: {
guild_id,
user: banned_user
},
guild_id
} as GuildBanRemoveEvent);
emitEvent({
event: "GUILD_BAN_REMOVE",
data: {
guild_id,
user: banned_user
},
guild_id
} as GuildBanRemoveEvent)
]);
return res.status(204).send();
});

19
api/src/routes/guilds/#guild_id/delete.ts
View File

@ -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 }),
User.updateMany({ guilds: guild_id }, { $pull: { guilds: guild_id } }),
Role.deleteMany({ guild_id }),
Channel.deleteMany({ guild_id }),
Emoji.deleteMany({ guild_id }),
Invite.deleteMany({ guild_id }),
Message.deleteMany({ guild_id }),
Member.deleteMany({ guild_id })
Guild.delete({ id: guild_id }),
Role.delete({ guild_id }),
Channel.delete({ guild_id }),
Emoji.delete({ guild_id }),
Invite.delete({ guild_id }),
Message.delete({ guild_id }),
Member.delete({ guild_id })
]);
return res.sendStatus(204);

39
api/src/routes/guilds/#guild_id/index.ts
View File

@ -1,19 +1,5 @@
import { Request, Response, Router } from "express";
import {
Channel,
emitEvent,
EmojiModel,
getPermission,
GuildDeleteEvent,
Guild,
GuildUpdateEvent,
InviteModel,
Member,
Message,
Role,
toObject,
User
} from "@fosscord/util";
import { emitEvent, getPermission, Guild, GuildUpdateEvent, Member } 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 member = await Member.exists({ guild_id: guild_id, id: req.user_id });
if (!member) throw new HTTPError("You are not a member of the guild you are trying to access", 401);
const [guild, member_count, member] = await Promise.all([
Guild.findOneOrFail({ id: guild_id }),
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({
path: "joined_at",
match: { id: req.user_id }
});
const data = guild;
const guild = await Guild.findOneOrFail({ id: guild_id });
guild.assign(body);
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;

2
api/src/routes/guilds/#guild_id/invites.ts
View File

@ -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();

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

@ -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({
event: "GUILD_MEMBER_UPDATE",
guild_id,
data: member
} as GuildMemberUpdateEvent);
Promise.all([
member.save(),
emitEvent({
event: "GUILD_MEMBER_UPDATE",
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);
});

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

@ -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();
});

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

@ -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);
});

21
api/src/routes/guilds/#guild_id/members/index.ts
View File

@ -1,8 +1,7 @@
import { Request, Response, Router } from "express";
import { Guild, Member, toObject } from "@fosscord/util";
import { HTTPError } from "lambert-server";
import { Guild, Member, PublicMemberProjection } from "@fosscord/util";
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
if (!req.query.limit) req.query.limit = 1;
const { limit, after } = (<unknown>req.query) as { limit: number; after: string };
const query = after ? { id: { $gt: after } } : {};
const { limit, after } = (<unknown>req.query) as { limit?: number; after?: string };
const query = after ? { id: MoreThan(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);
});

68
api/src/routes/guilds/#guild_id/roles.ts
View File

@ -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({
id: role_id,
guild_id: guild_id
});
await emitEvent({
event: "GUILD_ROLE_DELETE",
guild_id,
data: {
await Promise.all([
Role.delete({
id: role_id,
guild_id: guild_id
}),
emitEvent({
event: "GUILD_ROLE_DELETE",
guild_id,
role_id
}
} as GuildRoleDeleteEvent);
data: {
guild_id,
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(
{
id: role_id,
guild_id: guild_id
},
// @ts-ignore
body,
{ new: true }
);
const role = new Role({ ...body, role_id, guild_id, permissions: perms.bitfield & (body.permissions || 0n) });
await emitEvent({
event: "GUILD_ROLE_UPDATE",
guild_id,
data: {
await Promise.all([
role.save(),
emitEvent({
event: "GUILD_ROLE_UPDATE",
guild_id,
role
}
} as GuildRoleUpdateEvent);
data: {
guild_id,
role
}
} as GuildRoleUpdateEvent)
]);
res.json(role);
});

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

@ -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 });
if (!guild.vanity_url_code) return res.json({ code: null });
const { uses } = await Invite.findOneOrFail({ code: guild.vanity_url_code });
const guild = await Guild.findOneOrFail({ where: { id: guild_id }, relations: ["vanity_url"] });
if (!guild.vanity_url) return res.json({ code: null });
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);
if (!code) code = null;
const code = req.body.code.replace(InviteRegex);
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(
{ code: guild.vanity_url_code },
{
guild.vanity_url_code = 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
},
{ upsert: true }
);
}).save()
]);
return res.json({ code: code });
});

28
api/src/routes/guilds/#guild_id/welcome_screen.ts
View File

@ -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 { GuildAddChannelToWelcomeScreenSchema } from "../../../schema/Guild";
import { getPublicUser } from "../../../util/User";
import { GuildUpdateWelcomeScreenSchema } from "../../../schema/Guild";
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))
throw new Error("Welcome Channel exists");
await Guild.findOneOrFailAndUpdate(
{
id: guild_id
},
{ $push: { "welcome_screen.welcome_channels": channelObject } }
);
if (body.welcome_channels) guild.welcome_screen.welcome_channels = body.welcome_channels; // TODO: check if they exist and are valid
if (body.description) guild.welcome_screen.description = body.description;
if (body.enabled != null) guild.welcome_screen.enabled = body.enabled;
res.sendStatus(204);
});

95
api/src/routes/guilds/#guild_id/widget.json.ts
View File

@ -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[] = [];
await Channel.find({ guild_id: guild_id, type: 2 }, { permission_overwrites: { $elemMatch: { id: guild_id } } })
.select("id name position permission_overwrites")
.sort({ position: 1 })
.cursor()
.eachAsync((doc) => {
// Only return channels where @everyone has the CONNECT permission
if (
doc.permission_overwrites === undefined ||
Permissions.channelPermission(doc.permission_overwrites, Permissions.FLAGS.CONNECT) === Permissions.FLAGS.CONNECT
) {
channels.push({
id: doc.id,
name: doc.name,
position: doc.position
});
}
});
const channels = [] as any[];
(await Channel.find({ where: { guild_id: guild_id, type: 2 }, order: { position: "ASC" } })).filter((doc) => {
// Only return channels where @everyone has the CONNECT permission
if (
doc.permission_overwrites === undefined ||
Permissions.channelPermission(doc.permission_overwrites, Permissions.FLAGS.CONNECT) === Permissions.FLAGS.CONNECT
) {
channels.push({
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[] = [];
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;
});
let members = await Member.find({ where: { guild_id: guild_id } });
// Construct object to respond with
const data = {

17
api/src/routes/guilds/index.ts
View File

@ -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 });
if (user.guilds.length >= maxGuilds) {
const guild_count = await Member.count({ where: { id: req.user_id } });
if (guild_count >= 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 });
});

25
api/src/routes/guilds/templates/index.ts
View File

@ -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 = {
...body,
...template.serialized_source_guild,
id: guild_id,
owner_id: req.user_id
};
const [guild_doc, role] = await Promise.all([
new Guild(guild).save(),
const [guild, role] = await Promise.all([
new Guild({
...body,
...template.serialized_source_guild,
id: guild_id,
owner_id: req.user_id
}).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 });
});

19
api/src/routes/invites/index.ts
View File

@ -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 });
if (!invite) throw new HTTPError("Unknown Invite", 404);
if (invite.uses >= invite.max_uses) await Invite.deleteOne({ code });
const invite = await Invite.findOneOrFail({ code });
if (invite.uses++ >= invite.max_uses) await Invite.delete({ 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, { guild });
const permission = await getPermission(req.user_id, guild_id, channel_id);
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 Guild.update({ vanity_url_code: code }, { $unset: { vanity_url_code: 1 } }).catch((e) => {});
await Promise.all([Invite.delete({ code }), Guild.update({ vanity_url_code: code }, { vanity_url_code: undefined })]);
res.json({ invite: invite });
});

5
api/src/routes/users/#id/index.ts
View File

@ -1,13 +1,12 @@
import { Router, Request, Response } from "express";
import { getPublicUser } from "../../../util/User";
import { HTTPError } from "lambert-server";
import { User } from "../../../../../util/dist";
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;

4
api/src/routes/users/#id/profile.ts
View File

@ -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,

23
api/src/routes/users/@me/channels.ts
View File

@ -1,20 +1,10 @@
import { Router, Request, Response } from "express";
import {
Channel,
ChannelCreateEvent,
toObject,
ChannelType,
Snowflake,
trimSpecial,
Channel,
DMChannel,
User,
emitEvent
} from "@fosscord/util";
import { Channel, ChannelCreateEvent, ChannelType, Snowflake, trimSpecial, 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)) {
throw new HTTPError("Recipient not found");
const recipients = await User.find({ id: In(body.recipients) });
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);
});

13
api/src/routes/users/@me/delete.ts
View File

@ -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
Member.deleteMany({ id: req.user_id })
User.delete({ id: req.user_id }), //Yeetus user deletus
Member.delete({ id: req.user_id })
]);
res.sendStatus(204);

9
api/src/routes/users/@me/disable.ts
View File

@ -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 });

19
api/src/routes/users/@me/guilds.ts
View File

@ -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 { getPublicUser } from "../../../util/User";
import { In } from "typeorm";
const router: Router = Router();
router.get("/", async (req: Request, res: Response) => {
const user = await User.findOneOrFail({ id: req.user_id }, { guilds: true });
if (!user) throw new HTTPError("User not found", 404);
const members = await Member.find({ relations: ["guild"], where: { id: req.user_id } });
var guildIDs = user.guilds || [];
var guild = await Guild.find({ id: { $in: guildIDs } }).populate({ path: "joined_at", match: { id: req.user_id } });
res.json(guild);
res.json(members.map((x) => x.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 }),
User.update({ id: req.user_id }, { $pull: { guilds: guild_id } }),
Member.delete({ id: req.user_id, guild_id: 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",

47
api/src/routes/users/@me/index.ts
View File

@ -1,6 +1,5 @@
import { Router, Request, Response } from "express";
import { User, toObject, PublicUserProjection } from "@fosscord/util";
import { getPublicUser } from "../../../util/User";
import { User } from "@fosscord/util";
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 = {
accent_color: true,
avatar: true,
banner: true,
bio: true,
bot: true,
discriminator: true,
email: true,
flags: true,
id: true,
locale: true,
mfa_enabled: true,
nsfw_alllowed: true,
phone: true,
public_flags: true,
purchased_flags: true,
// token: true, // this isn't saved in the db and needs to be set manually
username: true,
verified: true
};
const UserUpdateProjection = [
"accent_color",
"avatar",
"banner",
"bio",
"bot",
"discriminator",
"email",
"flags",
"id",
"locale",
"mfa_enabled",
"nsfw_alllowed",
"phone",
"public_flags",
"purchased_flags",
// "token", // this isn't saved in the db and needs to be set manually
"username",
"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);

6
api/src/routes/users/@me/profile.ts
View File

@ -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: {

85
api/src/routes/users/@me/relationships.ts
View File

@ -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({
path: "data.relationships.id",
model: User
});
return res.json(user.data.relationships);
const user = await User.findOneOrFail({ where: { id: req.user_id }, select: ["relationships"] });
return res.json(user.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 newUserRelationships = [...user.data.relationships];
const newFriendRelationships = [...friend.data.relationships];
const user = await User.findOneOrFail(req.user_id, { relations: ["relationships"], select: userProjection });
var relationship = newUserRelationships.find((x) => x.id === id);
const friendRequest = newFriendRelationships.find((x) => x.id === req.user_id);
var relationship = user.relationships.find((x) => x.id === 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 };
newUserRelationships.push(relationship);
relationship = new Relationship({ id, type: RelationshipType.blocked });
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 outgoing_relationship = { id, nickname: undefined, type: RelationshipType.outgoing };
var incoming_relationship = new Relationship({ nickname: undefined, type: RelationshipType.incoming }, { id: req.user_id });
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.update({ id: friend.id }, { "data.relationships": newFriendRelationships }),
user.save(),
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 });
if (!user) throw new HTTPError("Invalid token", 400);
const user = await User.findOneOrFail(req.user_id, { select: userProjection, relations: ["relationships"] });
const friend = await User.findOneOrFail(id, { select: userProjection, relations: ["relationships"] });
const friend = await User.findOneOrFail({ id }, userProjection);
if (!friend) throw new HTTPError("User not found", 404);
const relationship = user.relationships.find((x) => x.id === id);
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);
friend.data.relationships.remove(friendRequest);
user.relationships.remove(relationship);
friend.relationships.remove(friendRequest);
await Promise.all([
user.save(),

80
api/src/schema/Guild.ts
View File

@ -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 = {
channel_id: String,
description: String,
$emoji_id: String,
emoji_name: String
export const GuildUpdateWelcomeScreenSchema = {
$welcome_channels: [
{
channel_id: String,
description: String,
$emoji_id: String,
emoji_name: String
}
],
$enabled: Boolean,
$description: new Length(String, 0, 140)
};
export interface GuildAddChannelToWelcomeScreenSchema {
channel_id: string;
description: string;
emoji_id?: string;
emoji_name: string;
export interface GuildUpdateWelcomeScreenSchema {
welcome_channels?: {
channel_id: string;
description: string;
emoji_id?: string;
emoji_name: string;
}[];
enabled?: boolean;
description?: string;
}

8
api/src/schema/Message.ts
View File

@ -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,

2
api/src/schema/Roles.ts
View File

@ -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

40
api/src/test/mongo_test.ts
View File

@ -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();

39
api/src/test/server_benchmark.ts
View File

@ -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();
}

3
api/src/test/test.ts
View File

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

17
api/src/util/Channel.ts
View File

@ -1,20 +1,9 @@
import {
ChannelCreateEvent,
Channel,
ChannelType,
emitEvent,
getPermission,
Guild,
Snowflake,
TextChannel,
toObject,
VoiceChannel
} from "@fosscord/util";
import { ChannelCreateEvent, Channel, ChannelType, emitEvent, getPermission, Snowflake } 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");
}

220
api/src/util/Member.ts
View File

@ -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);
}

19
api/src/util/Message.ts
View File

@ -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)
.populate({ path: "member", select: PublicMemberProjection })
.populate("referenced_message")
.save();
const data = await new Message(message).save();
await emitEvent({ event: "MESSAGE_CREATE", channel_id: opts.channel_id, data } as MessageCreateEvent);