RSCord/ServerSpacebarOld
Archived
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' into unittests

Browse Source
This commit is contained in:
Flam3rboy 2021-09-20 21:49:42 +02:00
commit 16a3d1b334
70 changed files with 1446 additions and 1066 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

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

1441
api/assets/schemas.json
View File

File diff suppressed because it is too large Load Diff

10
api/client_test/index.html
View File

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

BIN
api/package-lock.json generated
View File

Binary file not shown.

2
api/package.json
View File

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

28
api/src/Server.ts
View File

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

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

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

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

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

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

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

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

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

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

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

56
api/src/routes/channels/#channel_id/recipients.ts
View File

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

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

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

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

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

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

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

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

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

18
api/src/routes/sticker-packs/#id/index.ts Normal file
View File

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

10
api/src/routes/sticker-packs/index.ts Normal file
View File

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

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

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

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

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

11
api/src/routes/users/@me/connections.ts Normal file
View File

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

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

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

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

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

12
api/src/util/Attachments.ts
View File

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

4
api/src/util/cdn.ts
View File

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

1
api/src/util/index.ts
View File

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

1
api/src/util/route.ts
View File

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

6
bundle/.vscode/launch.json vendored
View File

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

BIN
bundle/package-lock.json generated
View File

Binary file not shown.

2
bundle/package.json
View File

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

8
bundle/src/start.ts
View File

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

3
cdn/src/Server.ts
View File

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

4
gateway/src/listener/listener.ts
View File

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

38
gateway/src/opcodes/Identify.ts
View File

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

1
gateway/src/opcodes/index.ts
View File

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

BIN
util/package-lock.json generated
View File

Binary file not shown.

2
util/package.json
View File

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

35
util/src/dtos/DmChannelDTO.ts Normal file
View File

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

17
util/src/dtos/UserDTO.ts Normal file
View File

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

2
util/src/dtos/index.ts Normal file
View File

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

4
util/src/entities/Application.ts
View File

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

13
util/src/entities/Attachment.ts
View File

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

8
util/src/entities/Ban.ts
View File

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

48
util/src/entities/BaseClass.ts
View File

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

179
util/src/entities/Channel.ts
View File

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

10
util/src/entities/Config.ts
View File

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

4
util/src/entities/ConnectedAccount.ts
View File

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

4
util/src/entities/Emoji.ts
View File

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

52
util/src/entities/Guild.ts
View File

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

22
util/src/entities/Invite.ts
View File

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

9
util/src/entities/Member.ts
View File

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

22
util/src/entities/Message.ts
View File

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

8
util/src/entities/ReadState.ts
View File

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

11
util/src/entities/Recipient.ts
View File

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

8
util/src/entities/Relationship.ts
View File

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

4
util/src/entities/Role.ts
View File

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

4
util/src/entities/Session.ts
View File

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

4
util/src/entities/Sticker.ts
View File

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

4
util/src/entities/Team.ts
View File

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

8
util/src/entities/TeamMember.ts
View File

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

12
util/src/entities/User.ts
View File

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

16
util/src/entities/VoiceState.ts
View File

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

20
util/src/entities/Webhook.ts
View File

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

1
util/src/index.ts
View File

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

22
util/src/interfaces/Event.ts
View File

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

3
util/src/util/Array.ts Normal file
View File

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

2
util/src/util/Database.ts
View File

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

1
util/src/util/Permissions.ts
View File

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

54
util/src/util/cdn.ts Normal file
View File

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

2
util/src/util/index.ts
View File

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