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

✨ delete _ids from entities

Browse Source
This commit is contained in:
Flam3rboy 2021-08-31 17:54:09 +02:00
parent 1d7d3b3022
commit 3d929755fb
31 changed files with 382 additions and 241 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
util/package-lock.json generated
View File

@ -24,7 +24,7 @@
"reflect-metadata": "^0.1.13",
"sqlite3": "^5.0.2",
"typeorm": "^0.2.37",
"typescript": "^4.3.5",
"typescript": "^4.4.2",
"typescript-json-schema": "^0.50.1"
},
"devDependencies": {
@ -8235,9 +8235,9 @@
"integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="
},
"node_modules/typescript": {
"version": "4.3.5",
"resolved": "https://registry.npmjs.org/typescript/-/typescript-4.3.5.tgz",
"integrity": "sha512-DqQgihaQ9cUrskJo9kIyW/+g0Vxsk8cDtZ52a3NGh0YNTfpUSArXSohyUGnvbPazEPLu398C0UxmKSOrPumUzA==",
"version": "4.4.2",
"resolved": "https://registry.npmjs.org/typescript/-/typescript-4.4.2.tgz",
"integrity": "sha512-gzP+t5W4hdy4c+68bfcv0t400HVJMMd2+H9B7gae1nQlBzCqvrXX+6GL/b3GAgyTH966pzrZ70/fRjwAtZksSQ==",
"bin": {
"tsc": "bin/tsc",
"tsserver": "bin/tsserver"
@ -15150,9 +15150,9 @@
}
},
"typescript": {
"version": "4.3.5",
"resolved": "https://registry.npmjs.org/typescript/-/typescript-4.3.5.tgz",
"integrity": "sha512-DqQgihaQ9cUrskJo9kIyW/+g0Vxsk8cDtZ52a3NGh0YNTfpUSArXSohyUGnvbPazEPLu398C0UxmKSOrPumUzA=="
"version": "4.4.2",
"resolved": "https://registry.npmjs.org/typescript/-/typescript-4.4.2.tgz",
"integrity": "sha512-gzP+t5W4hdy4c+68bfcv0t400HVJMMd2+H9B7gae1nQlBzCqvrXX+6GL/b3GAgyTH966pzrZ70/fRjwAtZksSQ=="
},
"typescript-json-schema": {
"version": "0.50.1",

2
util/package.json
View File

@ -51,7 +51,7 @@
"reflect-metadata": "^0.1.13",
"sqlite3": "^5.0.2",
"typeorm": "^0.2.37",
"typescript": "^4.3.5",
"typescript": "^4.4.2",
"typescript-json-schema": "^0.50.1"
},
"jest": {

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

@ -2,6 +2,7 @@ import { Column, Entity, JoinColumn, ManyToOne, RelationId } from "typeorm";
import { BaseClass } from "./BaseClass";
import { Guild } from "./Guild";
import { Team } from "./Team";
import { User } from "./User";
@Entity("applications")
export class Application extends BaseClass {
@ -29,8 +30,9 @@ export class Application extends BaseClass {
@Column({ nullable: true })
privacy_policy_url?: string;
@Column()
owner_id: string;
@JoinColumn({ name: "owner_id" })
@ManyToOne(() => User)
owner?: User;
@Column({ nullable: true })
summary?: string;
@ -38,18 +40,12 @@ export class Application extends BaseClass {
@Column()
verify_key: string;
@RelationId((application: Application) => application.team)
team_id: string;
@JoinColumn({ name: "team_id" })
@ManyToOne(() => Team, (team: Team) => team.id)
@ManyToOne(() => Team)
team?: Team;
@RelationId((application: Application) => application.guild)
guild_id: string;
@JoinColumn({ name: "guild_id" })
@ManyToOne(() => Guild, (guild: Guild) => guild.id)
@ManyToOne(() => Guild)
guild: Guild; // if this application is a game sold, this field will be the guild to which it has been linked
@Column({ nullable: true })

34
util/src/entities/Attachment.ts Normal file
View File

@ -0,0 +1,34 @@
import { Column, Entity, JoinColumn, ManyToOne, RelationId } from "typeorm";
import { BaseClass } from "./BaseClass";
@Entity("attachments")
export class Attachment extends BaseClass {
@Column()
filename: string; // name of file attached
@Column()
size: number; // size of file in bytes
@Column()
url: string; // source url of file
@Column()
proxy_url: string; // a proxied url of file
@Column({ nullable: true })
height?: number; // height of file (if image)
@Column({ nullable: true })
width?: number; // width of file (if image)
@Column({ nullable: true })
content_type?: string;
@Column({ nullable: true })
@RelationId((attachment: Attachment) => attachment.message)
message_id: string;
@JoinColumn({ name: "message_id" })
@ManyToOne(() => require("./Message").Message, (message: import("./Message").Message) => message.attachments)
message: import("./Message").Message;
}

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

@ -43,18 +43,16 @@ export enum AuditLogEvents {
@Entity("audit_logs")
export class AuditLogEntry extends BaseClass {
@RelationId((auditlog: AuditLogEntry) => auditlog.target)
target_id: string;
@JoinColumn({ name: "target_id" })
@ManyToOne(() => User, (user: User) => user.id)
@ManyToOne(() => User)
target?: User;
@Column({ nullable: true })
@RelationId((auditlog: AuditLogEntry) => auditlog.user)
user_id: string;
@JoinColumn({ name: "user_id" })
@ManyToOne(() => User, (user: User) => user.id)
@ManyToOne(() => User)
user: User;
@Column({

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

@ -5,25 +5,28 @@ import { User } from "./User";
@Entity("bans")
export class Ban extends BaseClass {
@Column({ nullable: true })
@RelationId((ban: Ban) => ban.user)
user_id: string;
@JoinColumn({ name: "user_id" })
@ManyToOne(() => User, (user: User) => user.id)
@ManyToOne(() => User)
user: User;
@Column({ nullable: true })
@RelationId((ban: Ban) => ban.guild)
guild_id: string;
@JoinColumn({ name: "guild_id" })
@ManyToOne(() => Guild, (guild: Guild) => guild.id)
@ManyToOne(() => Guild)
guild: Guild;
@Column({ nullable: true })
@RelationId((ban: Ban) => ban.executor)
executor_id: string;
@JoinColumn({ name: "executor_id" })
@ManyToOne(() => User, (user: User) => user.id)
@ManyToOne(() => User)
executor: User;
@Column()

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

@ -1,13 +1,5 @@
import "reflect-metadata";
import {
BaseEntity,
BeforeInsert,
BeforeUpdate,
EntityMetadata,
FindConditions,
FindManyOptions,
PrimaryColumn,
} from "typeorm";
import { BaseEntity, BeforeInsert, BeforeUpdate, EntityMetadata, FindConditions, PrimaryColumn } from "typeorm";
import { Snowflake } from "../util/Snowflake";
import "missing-native-js-functions";
@ -16,13 +8,12 @@ import "missing-native-js-functions";
export class BaseClass extends BaseEntity {
@PrimaryColumn()
id: string;
id: string = Snowflake.generate();
// @ts-ignore
constructor(public props?: any, public opts: { id?: string } = {}) {
constructor(public props?: any) {
super();
this.id = this.opts.id || Snowflake.generate();
this.assign(props);
}
get construct(): any {
@ -35,13 +26,15 @@ export class BaseClass extends BaseEntity {
assign(props: any) {
if (!props || typeof props !== "object") return;
delete props.id;
delete props.opts;
delete props.props;
const properties = new Set(this.metadata.columns.map((x: any) => x.propertyName));
// will not include relational properties (e.g. @RelationId @ManyToMany)
const properties = new Set(
this.metadata.columns
.map((x: any) => x.propertyName)
.concat(this.metadata.relations.map((x) => x.propertyName))
);
// will not include relational properties
for (const key in props) {
if (!properties.has(key)) continue;
@ -65,8 +58,11 @@ export class BaseClass extends BaseEntity {
}
toJSON(): any {
// @ts-ignore
return Object.fromEntries(this.metadata.columns.map((x) => [x.propertyName, this[x.propertyName]]));
return Object.fromEntries(
this.metadata.columns // @ts-ignore
.map((x) => [x.propertyName, this[x.propertyName]]) // @ts-ignore
.concat(this.metadata.relations.map((x) => [x.propertyName, this[x.propertyName]]))
);
}
static increment<T extends BaseClass>(conditions: FindConditions<T>, propertyPath: string, value: number | string) {

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

@ -1,8 +1,12 @@
import { Column, Entity, JoinColumn, ManyToMany, ManyToOne, RelationId } from "typeorm";
import { Column, Entity, JoinColumn, JoinTable, ManyToMany, ManyToOne, OneToMany, RelationId } from "typeorm";
import { BaseClass } from "./BaseClass";
import { Guild } from "./Guild";
import { Message } from "./Message";
import { User } from "./User";
import { HTTPError } from "lambert-server";
import { emitEvent, getPermission, Snowflake } from "../util";
import { ChannelCreateEvent } from "../interfaces";
import { Recipient } from "./Recipient";
export enum ChannelType {
GUILD_TEXT = 0, // a text channel within a server
@ -25,40 +29,39 @@ export class Channel extends BaseClass {
@Column({ type: "simple-enum", enum: ChannelType })
type: ChannelType;
@Column("simple-array")
@RelationId((channel: Channel) => channel.recipients)
recipient_ids: string[];
@JoinColumn({ name: "recipient_ids" })
@ManyToMany(() => User, (user: User) => user.id)
recipients?: User[];
@OneToMany(() => Recipient, (recipient: Recipient) => recipient.channel, { cascade: true })
recipients?: Recipient[];
@Column({ nullable: true })
@RelationId((channel: Channel) => channel.last_message)
last_message_id: string;
@JoinColumn({ name: "last_message_id" })
@ManyToOne(() => Message, (message: Message) => message.id)
@ManyToOne(() => Message)
last_message?: Message;
@Column({ nullable: true })
@RelationId((channel: Channel) => channel.guild)
guild_id?: string;
@JoinColumn({ name: "guild_id" })
@ManyToOne(() => Guild, (guild: Guild) => guild.id)
@ManyToOne(() => Guild)
guild: Guild;
@Column({ nullable: true })
@RelationId((channel: Channel) => channel.parent)
parent_id: string;
@JoinColumn({ name: "parent_id" })
@ManyToOne(() => Channel, (channel: Channel) => channel.id)
@ManyToOne(() => Channel)
parent?: Channel;
@Column({ nullable: true })
@RelationId((channel: Channel) => channel.owner)
owner_id: string;
@JoinColumn({ name: "owner_id" })
@ManyToOne(() => User, (user: User) => user.id)
@ManyToOne(() => User)
owner: User;
@Column({ nullable: true })
@ -82,14 +85,77 @@ export class Channel extends BaseClass {
@Column({ nullable: true })
user_limit?: number;
@Column()
nsfw: boolean;
@Column({ nullable: true })
nsfw?: boolean;
@Column()
rate_limit_per_user: number;
@Column({ nullable: true })
rate_limit_per_user?: number;
@Column({ nullable: true })
topic?: string;
// TODO: DM channel
static async createChannel(
channel: Partial<Channel>,
user_id: string = "0",
opts?: {
keepId?: boolean;
skipExistsCheck?: boolean;
skipPermissionCheck?: boolean;
skipEventEmit?: boolean;
}
) {
if (!opts?.skipPermissionCheck) {
// Always check if user has permission first
const permissions = await getPermission(user_id, channel.guild_id);
permissions.hasThrow("MANAGE_CHANNELS");
}
switch (channel.type) {
case ChannelType.GUILD_TEXT:
case ChannelType.GUILD_VOICE:
if (channel.parent_id && !opts?.skipExistsCheck) {
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");
}
break;
case ChannelType.GUILD_CATEGORY:
break;
case ChannelType.DM:
case ChannelType.GROUP_DM:
throw new HTTPError("You can't create a dm channel in a guild");
// TODO: check if guild is community server
case ChannelType.GUILD_STORE:
case ChannelType.GUILD_NEWS:
default:
throw new HTTPError("Not yet supported");
}
if (!channel.permission_overwrites) channel.permission_overwrites = [];
// TODO: auto generate position
channel = {
...channel,
...(!opts?.keepId && { id: Snowflake.generate() }),
created_at: new Date(),
position: channel.position || 0,
};
await Promise.all([
Channel.insert(channel),
!opts?.skipEventEmit
? emitEvent({
event: "CHANNEL_CREATE",
data: channel,
guild_id: channel.guild_id,
} as ChannelCreateEvent)
: Promise.resolve(),
]);
return channel;
}
}
export interface ChannelPermissionOverwrite {

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

@ -199,12 +199,12 @@ export const DefaultConfigOptions: ConfigValue = {
window: 5,
},
webhook: {
count: 5,
window: 20,
count: 10,
window: 5,
},
channel: {
count: 5,
window: 20,
count: 10,
window: 5,
},
auth: {
login: {

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

@ -4,11 +4,12 @@ import { User } from "./User";
@Entity("connected_accounts")
export class ConnectedAccount extends BaseClass {
@Column({ nullable: true })
@RelationId((account: ConnectedAccount) => account.user)
user_id: string;
@JoinColumn({ name: "user_id" })
@ManyToOne(() => User, (user: User) => user.connected_accounts)
@ManyToOne(() => User)
user: User;
@Column({ select: false })

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

@ -1,4 +1,4 @@
import { Column, Entity, JoinColumn, ManyToMany, ManyToOne, RelationId } from "typeorm";
import { Column, Entity, JoinColumn, ManyToOne } from "typeorm";
import { BaseClass } from "./BaseClass";
import { Guild } from "./Guild";
import { Role } from "./Role";
@ -15,7 +15,7 @@ export class Emoji extends BaseClass {
guild_id: string;
@JoinColumn({ name: "guild_id" })
@ManyToOne(() => Guild, (guild: Guild) => guild.emojis)
@ManyToOne(() => Guild)
guild: Guild;
@Column()
@ -26,11 +26,4 @@ export class Emoji extends BaseClass {
@Column()
require_colons: boolean;
@RelationId((emoji: Emoji) => emoji.roles)
role_ids: string[];
@JoinColumn({ name: "role_ids" })
@ManyToMany(() => Role, (role: Role) => role.id)
roles: Role[]; // roles this emoji is whitelisted to (new discord feature?)
}

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

@ -1,20 +1,30 @@
import { Column, Entity, JoinColumn, ManyToMany, ManyToOne, OneToMany, OneToOne, RelationId } from "typeorm";
import { Ban } from "./Ban";
import { BaseClass } from "./BaseClass";
import { Channel } from "./Channel";
import { Emoji } from "./Emoji";
import { Invite } from "./Invite";
import { Member } from "./Member";
import { Role } from "./Role";
import { Sticker } from "./Sticker";
import { Template } from "./Template";
import { User } from "./User";
import { VoiceState } from "./VoiceState";
import { Webhook } from "./Webhook";
// TODO: application_command_count, application_command_counts: {1: 0, 2: 0, 3: 0}
// TODO: guild_scheduled_events
// TODO: stage_instances
// TODO: threads
@Entity("guilds")
export class Guild extends BaseClass {
@Column({ nullable: true })
@RelationId((guild: Guild) => guild.afk_channel)
afk_channel_id?: string;
@JoinColumn({ name: "afk_channel_id" })
@ManyToOne(() => Channel, (channel: Channel) => channel.id)
@ManyToOne(() => Channel)
afk_channel?: Channel;
@Column({ nullable: true })
@ -25,6 +35,10 @@ export class Guild extends BaseClass {
// @Column({ nullable: true })
// application?: string;
@JoinColumn({ name: "ban_ids" })
@OneToMany(() => Ban, (ban: Ban) => ban.guild)
bans: Ban[];
@Column({ nullable: true })
banner?: string;
@ -64,52 +78,57 @@ export class Guild extends BaseClass {
@Column({ nullable: true })
presence_count?: number; // users online
@RelationId((guild: Guild) => guild.members)
member_ids: string[];
@JoinColumn({ name: "member_ids" })
@OneToMany(() => Member, (member: Member) => member.guild)
members: Member[];
@RelationId((guild: Guild) => guild.roles)
role_ids: string[];
@JoinColumn({ name: "role_ids" })
@OneToMany(() => Role, (role: Role) => role.guild)
roles: Role[];
@RelationId((guild: Guild) => guild.channels)
channel_ids: string[];
@JoinColumn({ name: "channel_ids" })
@OneToMany(() => Channel, (channel: Channel) => channel.guild)
channels: Channel[];
@RelationId((guild: Guild) => guild.emojis)
emoji_ids: string[];
@Column({ nullable: true })
@RelationId((guild: Guild) => guild.template)
template_id: string;
@JoinColumn({ name: "template_id" })
@ManyToOne(() => Template)
template: Template;
@JoinColumn({ name: "emoji_ids" })
@OneToMany(() => Emoji, (emoji: Emoji) => emoji.guild)
emojis: Emoji[];
@RelationId((guild: Guild) => guild.voice_states)
voice_state_ids: string[];
@JoinColumn({ name: "sticker_ids" })
@OneToMany(() => Sticker, (sticker: Sticker) => sticker.guild)
stickers: Sticker[];
@JoinColumn({ name: "invite_ids" })
@OneToMany(() => Invite, (invite: Invite) => invite.guild)
invites: Invite[];
@JoinColumn({ name: "voice_state_ids" })
@OneToMany(() => VoiceState, (voicestate: VoiceState) => voicestate.guild)
voice_states: VoiceState[];
@JoinColumn({ name: "webhook_ids" })
@OneToMany(() => Webhook, (webhook: Webhook) => webhook.guild)
webhooks: Webhook[];
@Column({ nullable: true })
mfa_level?: number;
@Column()
name: string;
@Column({ nullable: true })
@RelationId((guild: Guild) => guild.owner)
owner_id: string;
@JoinColumn({ name: "owner_id" })
@OneToOne(() => User)
@JoinColumn([{ name: "owner_id", referencedColumnName: "id" }])
@ManyToOne(() => User)
owner: User;
@Column({ nullable: true })
@ -121,18 +140,20 @@ export class Guild extends BaseClass {
@Column({ nullable: true })
premium_tier?: number; // nitro boost level
@Column({ nullable: true })
@RelationId((guild: Guild) => guild.public_updates_channel)
public_updates_channel_id: string;
@JoinColumn({ name: "public_updates_channel_id" })
@OneToOne(() => Channel, (channel: Channel) => channel.id)
@ManyToOne(() => Channel)
public_updates_channel?: Channel;
@Column({ nullable: true })
@RelationId((guild: Guild) => guild.rules_channel)
rules_channel_id?: string;
@JoinColumn({ name: "rules_channel_id" })
@OneToOne(() => Channel, (channel: Channel) => channel.id)
@ManyToOne(() => Channel)
rules_channel?: string;
@Column({ nullable: true })
@ -141,11 +162,12 @@ export class Guild extends BaseClass {
@Column({ nullable: true })
splash?: string;
@Column({ nullable: true })
@RelationId((guild: Guild) => guild.system_channel)
system_channel_id?: string;
@JoinColumn({ name: "system_channel_id" })
@OneToOne(() => Channel, (channel: Channel) => channel.id)
@ManyToOne(() => Channel)
system_channel?: Channel;
@Column({ nullable: true })
@ -154,11 +176,12 @@ export class Guild extends BaseClass {
@Column({ nullable: true })
unavailable?: boolean;
@Column({ nullable: true })
@RelationId((guild: Guild) => guild.vanity_url)
vanity_url_code?: string;
@JoinColumn({ name: "vanity_url_code" })
@OneToOne(() => Invite)
@ManyToOne(() => Invite)
vanity_url?: Invite;
@Column({ nullable: true })
@ -176,11 +199,12 @@ export class Guild extends BaseClass {
}[];
};
@Column({ nullable: true })
@RelationId((guild: Guild) => guild.widget_channel)
widget_channel_id?: string;
@JoinColumn({ name: "widget_channel_id" })
@OneToOne(() => Channel, (channel: Channel) => channel.id)
@ManyToOne(() => Channel)
widget_channel?: Channel;
@Column({ nullable: true })

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

@ -27,32 +27,36 @@ export class Invite extends BaseClass {
@Column()
expires_at: Date;
@Column({ nullable: true })
@RelationId((invite: Invite) => invite.guild)
guild_id: string;
@JoinColumn({ name: "guild_id" })
@ManyToOne(() => Guild, (guild: Guild) => guild.id)
@ManyToOne(() => Guild)
guild: Guild;
@Column({ nullable: true })
@RelationId((invite: Invite) => invite.channel)
channel_id: string;
@JoinColumn({ name: "channel_id" })
@ManyToOne(() => Channel, (channel: Channel) => channel.id)
@ManyToOne(() => Channel)
channel: Channel;
@Column({ nullable: true })
@RelationId((invite: Invite) => invite.inviter)
inviter_id: string;
@JoinColumn({ name: "inviter_id" })
@ManyToOne(() => User, (user: User) => user.id)
@ManyToOne(() => User)
inviter: User;
@Column({ nullable: true })
@RelationId((invite: Invite) => invite.target_user)
target_user_id: string;
@JoinColumn({ name: "target_user_id" })
@ManyToOne(() => User, (user: User) => user.id)
@ManyToOne(() => User)
target_user?: string; // could be used for "User specific invites" https://github.com/fosscord/fosscord/issues/62
@Column({ nullable: true })

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

@ -15,27 +15,22 @@ import { Role } from "./Role";
@Entity("members")
export class Member extends BaseClass {
@RelationId((member: Member) => member.user)
user_id: string;
@JoinColumn({ name: "user_id" })
@ManyToOne(() => User, (user: User) => user.id)
@JoinColumn({ name: "id" })
@ManyToOne(() => User)
user: User;
@Column({ nullable: true })
@RelationId((member: Member) => member.guild)
guild_id: string;
@JoinColumn({ name: "guild_id" })
@ManyToOne(() => Guild, (guild: Guild) => guild.members)
@ManyToOne(() => Guild)
guild: Guild;
@Column({ nullable: true })
nick?: string;
@RelationId((member: Member) => member.roles)
role_ids: string[];
@JoinTable()
@JoinTable({ name: "member_roles" })
@ManyToMany(() => Role)
roles: Role[];
@ -62,7 +57,7 @@ export class Member extends BaseClass {
read_state: Record<string, string | null>;
static async IsInGuildOrFail(user_id: string, guild_id: string) {
if (await Member.count({ id: user_id, guild_id })) return true;
if (await Member.count({ id: user_id, guild: { id: guild_id } })) return true;
throw new HTTPError("You are not member of this guild", 403);
}
@ -99,46 +94,54 @@ export class Member extends BaseClass {
static async addRole(user_id: string, guild_id: string, role_id: string) {
const [member] = await Promise.all([
// @ts-ignore
Member.findOneOrFail({
where: { id: user_id, guild_id: guild_id },
relations: ["user"], // we don't want to load the role objects just the ids
relations: ["user", "roles"], // we don't want to load the role objects just the ids
select: ["roles.id"],
}),
await Role.findOneOrFail({ id: role_id, guild_id: guild_id }),
]);
member.role_ids.push(role_id);
member.save();
member.roles.push(new Role({ id: role_id }));
await emitEvent({
event: "GUILD_MEMBER_UPDATE",
data: {
await Promise.all([
member.save(),
emitEvent({
event: "GUILD_MEMBER_UPDATE",
data: {
guild_id: guild_id,
user: member.user,
roles: member.roles.map((x) => x.id),
},
guild_id: guild_id,
user: member.user,
roles: member.role_ids,
},
guild_id: guild_id,
} as GuildMemberUpdateEvent);
} as GuildMemberUpdateEvent),
]);
}
static async removeRole(user_id: string, guild_id: string, role_id: string) {
const [member] = await Promise.all([
// @ts-ignore
Member.findOneOrFail({
where: { id: user_id, guild_id: guild_id },
relations: ["user"], // we don't want to load the role objects just the ids
relations: ["user", "roles"], // we don't want to load the role objects just the ids
select: ["roles.id"],
}),
await Role.findOneOrFail({ id: role_id, guild_id: guild_id }),
]);
member.role_ids.remove(role_id);
member.save();
member.roles = member.roles.filter((x) => x.id == role_id);
await emitEvent({
event: "GUILD_MEMBER_UPDATE",
data: {
await Promise.all([
member.save(),
emitEvent({
event: "GUILD_MEMBER_UPDATE",
data: {
guild_id: guild_id,
user: member.user,
roles: member.roles.map((x) => x.id),
},
guild_id: guild_id,
user: member.user,
roles: member.role_ids,
},
guild_id: guild_id,
} as GuildMemberUpdateEvent);
} as GuildMemberUpdateEvent),
]);
}
static async changeNickname(user_id: string, guild_id: string, nickname: string) {
@ -175,11 +178,14 @@ export class Member extends BaseClass {
throw new HTTPError(`You are at the ${maxGuilds} server limit.`, 403);
}
const guild = await Guild.findOneOrFail(guild_id, {
const guild = await Guild.findOneOrFail({
where: {
id: guild_id,
},
relations: ["channels", "emojis", "members", "roles", "stickers"],
});
if (await Member.count({ id: user.id, guild_id }))
if (await Member.count({ id: user.id, guild: { id: guild_id } }))
throw new HTTPError("You are already a member of this guild", 400);
const member = {
@ -194,23 +200,23 @@ export class Member extends BaseClass {
pending: false,
};
// @ts-ignore
guild.joined_at = member.joined_at;
guild.joined_at = member.joined_at.toISOString();
await Promise.all([
new Member({
Member.insert({
...member,
roles: undefined,
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(),
}),
Guild.increment({ id: guild_id }, "member_count", 1),
emitEvent({
event: "GUILD_MEMBER_ADD",
@ -223,7 +229,7 @@ export class Member extends BaseClass {
} as GuildMemberAddEvent),
emitEvent({
event: "GUILD_CREATE",
data: guild,
data: { ...guild, members: [...guild.members, member] },
user_id,
} as GuildCreateEvent),
]);

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

@ -9,8 +9,10 @@ import {
CreateDateColumn,
Entity,
JoinColumn,
JoinTable,
ManyToMany,
ManyToOne,
OneToMany,
RelationId,
UpdateDateColumn,
} from "typeorm";
@ -18,6 +20,7 @@ import { BaseClass } from "./BaseClass";
import { Guild } from "./Guild";
import { Webhook } from "./Webhook";
import { Sticker } from "./Sticker";
import { Attachment } from "./Attachment";
export enum MessageType {
DEFAULT = 0,
@ -44,46 +47,52 @@ export class Message extends BaseClass {
@Column()
id: string;
@Column({ nullable: true })
@RelationId((message: Message) => message.channel)
channel_id: string;
@JoinColumn({ name: "channel_id" })
@ManyToOne(() => Channel, (channel: Channel) => channel.id)
@ManyToOne(() => Channel)
channel: Channel;
@Column({ nullable: true })
@RelationId((message: Message) => message.guild)
guild_id?: string;
@JoinColumn({ name: "guild_id" })
@ManyToOne(() => Guild, (guild: Guild) => guild.id)
@ManyToOne(() => Guild)
guild?: Guild;
@Column({ nullable: true })
@RelationId((message: Message) => message.author)
author_id: string;
@JoinColumn({ name: "author_id" })
@ManyToOne(() => User, (user: User) => user.id)
@JoinColumn({ name: "author_id", referencedColumnName: "id" })
@ManyToOne(() => User)
author?: User;
@Column({ nullable: true })
@RelationId((message: Message) => message.member)
member_id: string;
@JoinColumn({ name: "member_id" })
@ManyToOne(() => Member, (member: Member) => member.id)
@ManyToOne(() => Member)
member?: Member;
@Column({ nullable: true })
@RelationId((message: Message) => message.webhook)
webhook_id: string;
@JoinColumn({ name: "webhook_id" })
@ManyToOne(() => Webhook, (webhook: Webhook) => webhook.id)
@ManyToOne(() => Webhook)
webhook?: Webhook;
@Column({ nullable: true })
@RelationId((message: Message) => message.application)
application_id: string;
@JoinColumn({ name: "application_id" })
@ManyToOne(() => Application, (application: Application) => application.id)
@ManyToOne(() => Application)
application?: Application;
@Column({ nullable: true })
@ -103,29 +112,25 @@ export class Message extends BaseClass {
@Column({ nullable: true })
mention_everyone?: boolean;
@RelationId((message: Message) => message.mentions)
mention_user_ids: string[];
@JoinColumn({ name: "mention_user_ids" })
@ManyToMany(() => User, (user: User) => user.id)
@JoinTable({ name: "message_user_mentions" })
@ManyToMany(() => User)
mentions: User[];
@RelationId((message: Message) => message.mention_roles)
mention_role_ids: string[];
@JoinColumn({ name: "mention_role_ids" })
@ManyToMany(() => Role, (role: Role) => role.id)
@JoinTable({ name: "message_role_mentions" })
@ManyToMany(() => Role)
mention_roles: Role[];
@RelationId((message: Message) => message.mention_channels)
mention_channel_ids: string[];
@JoinColumn({ name: "mention_channel_ids" })
@ManyToMany(() => Channel, (channel: Channel) => channel.id)
@JoinTable({ name: "message_channel_mentions" })
@ManyToMany(() => Channel)
mention_channels: Channel[];
@Column({ type: "simple-json" })
attachments: Attachment[];
@JoinTable({ name: "message_stickers" })
@ManyToMany(() => Sticker)
sticker_items?: Sticker[];
@JoinColumn({ name: "attachment_ids" })
@OneToMany(() => Attachment, (attachment: Attachment) => attachment.message)
attachments?: Attachment[];
@Column({ type: "simple-json" })
embeds: Embed[];
@ -150,14 +155,6 @@ export class Message extends BaseClass {
@Column({ nullable: true })
flags?: string;
@RelationId((message: Message) => message.stickers)
sticker_ids: string[];
@JoinColumn({ name: "sticker_ids" })
@ManyToMany(() => Sticker, (sticker: Sticker) => sticker.id)
stickers?: Sticker[];
@Column({ type: "simple-json", nullable: true })
message_reference?: {
message_id: string;
@ -166,7 +163,7 @@ export class Message extends BaseClass {
};
@JoinColumn({ name: "message_reference_id" })
@ManyToOne(() => Message, (message: Message) => message.id)
@ManyToOne(() => Message)
referenced_message?: Message;
@Column({ type: "simple-json", nullable: true })
@ -178,8 +175,8 @@ export class Message extends BaseClass {
// user: User; // TODO: autopopulate user
};
@Column({ type: "simple-json" })
components: MessageComponent[];
@Column({ type: "simple-json", nullable: true })
components?: MessageComponent[];
}
export interface MessageComponent {
@ -198,17 +195,6 @@ export enum MessageComponentType {
Button = 2,
}
export interface Attachment {
id: string; // attachment id
filename: string; // name of file attached
size: number; // size of file in bytes
url: string; // source url of file
proxy_url: string; // a proxied url of file
height?: number; // height of file (if image)
width?: number; // width of file (if image)
content_type?: string;
}
export interface Embed {
title?: string; //title of embed
type?: EmbedType; // type of embed (always "rich" for webhook embeds)

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

@ -10,25 +10,28 @@ import { User } from "./User";
@Entity("read_states")
export class ReadState extends BaseClass {
@Column({ nullable: true })
@RelationId((read_state: ReadState) => read_state.channel)
channel_id: string;
@JoinColumn({ name: "channel_id" })
@ManyToOne(() => Channel, (channel: Channel) => channel.id)
@ManyToOne(() => Channel)
channel: Channel;
@Column({ nullable: true })
@RelationId((read_state: ReadState) => read_state.user)
user_id: string;
@JoinColumn({ name: "user_id" })
@ManyToOne(() => User, (user: User) => user.id)
@ManyToOne(() => User)
user: User;
@Column({ nullable: true })
@RelationId((read_state: ReadState) => read_state.last_message)
last_message_id: string;
@JoinColumn({ name: "last_message_id" })
@ManyToOne(() => Message, (message: Message) => message.id)
@ManyToOne(() => Message)
last_message?: Message;
@Column({ nullable: true })

19
util/src/entities/Recipient.ts Normal file
View File

@ -0,0 +1,19 @@
import { Column, Entity, JoinColumn, ManyToOne, RelationId } from "typeorm";
import { BaseClass } from "./BaseClass";
@Entity("recipients")
export class Recipient extends BaseClass {
@Column()
@RelationId((recipient: Recipient) => recipient.channel)
channel_id: string;
@JoinColumn({ name: "channel_id" })
@ManyToOne(() => require("./Channel").Channel)
channel: import("./Channel").Channel;
@JoinColumn({ name: "id" })
@ManyToOne(() => require("./User").User)
user: import("./User").User;
// TODO: settings/mute/nick/added at/encryption keys/read_state
}

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

@ -11,11 +11,12 @@ export enum RelationshipType {
@Entity("relationships")
export class Relationship extends BaseClass {
@Column({ nullable: true })
@RelationId((relationship: Relationship) => relationship.user)
user_id: string;
@JoinColumn({ name: "user_id" })
@ManyToOne(() => User, (user: User) => user.relationships)
@ManyToOne(() => User)
user: User;
@Column({ nullable: true })

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

@ -5,11 +5,12 @@ import { Guild } from "./Guild";
@Entity("roles")
export class Role extends BaseClass {
@Column({ nullable: true })
@RelationId((role: Role) => role.guild)
guild_id: string;
@JoinColumn({ name: "guild_id" })
@ManyToOne(() => Guild, (guild: Guild) => guild.id)
@ManyToOne(() => Guild)
guild: Guild;
@Column()

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

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

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

@ -1,4 +1,4 @@
import { Column, Entity, JoinColumn, ManyToMany, ManyToOne, RelationId } from "typeorm";
import { Column, Entity, JoinColumn, ManyToMany, ManyToOne, OneToMany, RelationId } from "typeorm";
import { BaseClass } from "./BaseClass";
import { TeamMember } from "./TeamMember";
import { User } from "./User";
@ -8,20 +8,18 @@ export class Team extends BaseClass {
@Column({ nullable: true })
icon?: string;
@RelationId((team: Team) => team.members)
member_ids: string[];
@JoinColumn({ name: "member_ids" })
@ManyToMany(() => TeamMember, (member: TeamMember) => member.id)
@OneToMany(() => TeamMember, (member: TeamMember) => member.team)
members: TeamMember[];
@Column()
name: string;
@Column({ nullable: true })
@RelationId((team: Team) => team.owner_user)
owner_user_id: string;
@JoinColumn({ name: "owner_user_id" })
@ManyToOne(() => User, (user: User) => user.id)
@ManyToOne(() => User)
owner_user: User;
}

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

@ -15,17 +15,19 @@ export class TeamMember extends BaseClass {
@Column({ type: "simple-array" })
permissions: string[];
@Column({ nullable: true })
@RelationId((member: TeamMember) => member.team)
team_id: string;
@JoinColumn({ name: "team_id" })
@ManyToOne(() => require("./Team").Team, (team: import("./Team").Team) => team.id)
@ManyToOne(() => require("./Team").Team, (team: import("./Team").Team) => team.members)
team: import("./Team").Team;
@Column({ nullable: true })
@RelationId((member: TeamMember) => member.user)
user_id: string;
@JoinColumn({ name: "user_id" })
@ManyToOne(() => User, (user: User) => user.id)
@ManyToOne(() => User)
user: User;
}

6
util/src/entities/Template.ts
View File

@ -17,11 +17,12 @@ export class Template extends BaseClass {
@Column({ nullable: true })
usage_count?: number;
@Column({ nullable: true })
@RelationId((template: Template) => template.creator)
creator_id: string;
@JoinColumn({ name: "creator_id" })
@ManyToOne(() => User, (user: User) => user.id)
@ManyToOne(() => User)
creator: User;
@Column()
@ -30,11 +31,12 @@ export class Template extends BaseClass {
@Column()
updated_at: Date;
@Column({ nullable: true })
@RelationId((template: Template) => template.source_guild)
source_guild_id: string;
@JoinColumn({ name: "source_guild_id" })
@ManyToOne(() => Guild, (guild: Guild) => guild.id)
@ManyToOne(() => Guild)
source_guild: Guild;
@Column({ type: "simple-json" })

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

@ -1,9 +1,10 @@
import { Column, Entity, FindOneOptions, JoinColumn, OneToMany, RelationId } from "typeorm";
import { Column, Entity, FindOneOptions, JoinColumn, ManyToMany, OneToMany, RelationId } from "typeorm";
import { BaseClass } from "./BaseClass";
import { BitField } from "../util/BitField";
import { Relationship } from "./Relationship";
import { ConnectedAccount } from "./ConnectedAccount";
import { HTTPError } from "lambert-server";
import { Channel } from "./Channel";
type PublicUserKeys =
| "username"
@ -105,16 +106,10 @@ export class User extends BaseClass {
@Column()
public_flags: string;
@RelationId((user: User) => user.relationships)
relationship_ids: string[]; // array of guild ids the user is part of
@JoinColumn({ name: "relationship_ids" })
@OneToMany(() => Relationship, (relationship: Relationship) => relationship.user, { cascade: true })
relationships: Relationship[];
@RelationId((user: User) => user.connected_accounts)
connected_account_ids: string[]; // array of guild ids the user is part of
@JoinColumn({ name: "connected_account_ids" })
@OneToMany(() => ConnectedAccount, (account: ConnectedAccount) => account.user)
connected_accounts: ConnectedAccount[];
@ -126,16 +121,19 @@ export class User extends BaseClass {
};
@Column({ type: "simple-array" })
fingerprints: string[] = []; // array of fingerprints -> used to prevent multiple accounts
fingerprints: string[]; // array of fingerprints -> used to prevent multiple accounts
@Column({ type: "simple-json" })
settings: UserSettings;
static async getPublicUser(user_id: string, opts?: FindOneOptions<User>) {
const user = await User.findOne(user_id, {
...opts,
select: [...PublicUserProjection, ...(opts?.select || [])],
});
const user = await User.findOne(
{ id: user_id },
{
...opts,
select: [...PublicUserProjection, ...(opts?.select || [])],
}
);
if (!user) throw new HTTPError("User not found", 404);
return user;
}

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

@ -1,4 +1,4 @@
import { Column, Entity, JoinColumn, ManyToOne, OneToOne, RelationId } from "typeorm";
import { Column, Entity, JoinColumn, ManyToOne, RelationId } from "typeorm";
import { BaseClass } from "./BaseClass";
import { Channel } from "./Channel";
import { Guild } from "./Guild";
@ -6,25 +6,28 @@ import { User } from "./User";
@Entity("voice_states")
export class VoiceState extends BaseClass {
@Column({ nullable: true })
@RelationId((voice_state: VoiceState) => voice_state.guild)
guild_id: string;
@JoinColumn({ name: "guild_id" })
@ManyToOne(() => Guild, (guild: Guild) => guild.id)
@ManyToOne(() => Guild)
guild?: Guild;
@Column({ nullable: true })
@RelationId((voice_state: VoiceState) => voice_state.channel)
channel_id: string;
@JoinColumn({ name: "channel_id" })
@ManyToOne(() => Channel, (channel: Channel) => channel.id)
@ManyToOne(() => Channel)
channel: Channel;
@Column({ nullable: true })
@RelationId((voice_state: VoiceState) => voice_state.user)
user_id: string;
@JoinColumn({ name: "user_id" })
@ManyToOne(() => User, (user: User) => user.id)
@ManyToOne(() => User)
user: User;
@Column()

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

@ -27,38 +27,43 @@ export class Webhook extends BaseClass {
@Column({ nullable: true })
token?: string;
@Column({ nullable: true })
@RelationId((webhook: Webhook) => webhook.guild)
guild_id: string;
@JoinColumn({ name: "guild_id" })
@ManyToOne(() => Guild, (guild: Guild) => guild.id)
@ManyToOne(() => Guild)
guild: Guild;
@Column({ nullable: true })
@RelationId((webhook: Webhook) => webhook.channel)
channel_id: string;
@JoinColumn({ name: "channel_id" })
@ManyToOne(() => Channel, (channel: Channel) => channel.id)
@ManyToOne(() => Channel)
channel: Channel;
@Column({ nullable: true })
@RelationId((webhook: Webhook) => webhook.application)
application_id: string;
@JoinColumn({ name: "application_id" })
@ManyToOne(() => Application, (application: Application) => application.id)
@ManyToOne(() => Application)
application: Application;
@Column({ nullable: true })
@RelationId((webhook: Webhook) => webhook.user)
user_id: string;
@JoinColumn({ name: "user_id" })
@ManyToOne(() => User, (user: User) => user.id)
@ManyToOne(() => User)
user: User;
@Column({ nullable: true })
@RelationId((webhook: Webhook) => webhook.guild)
source_guild_id: string;
@JoinColumn({ name: "source_guild_id" })
@ManyToOne(() => Guild, (guild: Guild) => guild.id)
@ManyToOne(() => Guild)
source_guild: Guild;
}

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

@ -1,4 +1,5 @@
export * from "./Application";
export * from "./Attachment";
export * from "./AuditLog";
export * from "./Ban";
export * from "./BaseClass";
@ -12,6 +13,7 @@ export * from "./Member";
export * from "./Message";
export * from "./RateLimit";
export * from "./ReadState";
export * from "./Recipient";
export * from "./Relationship";
export * from "./Role";
export * from "./Sticker";

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

@ -89,14 +89,7 @@ export interface ReadyEventData {
};
merged_members?: Omit<Member, "settings" | "user">[][];
// probably all users who the user is in contact with
users?: {
avatar: string | null;
discriminator: string;
id: string;
username: string;
bot: boolean;
public_flags: string;
}[];
users?: PublicUser[];
}
export interface ReadyEvent extends Event {
@ -130,7 +123,9 @@ export interface ChannelPinsUpdateEvent extends Event {
export interface GuildCreateEvent extends Event {
event: "GUILD_CREATE";
data: Guild;
data: Guild & {
joined_at: Date;
};
}
export interface GuildUpdateEvent extends Event {

12
util/src/tes.ts
View File

@ -5,10 +5,14 @@ import { initDatabase } from "./util";
initDatabase().then(async (x) => {
try {
const user = await new User(
{ guilds: [], discriminator: "1", username: "test", flags: "0", public_flags: "0" },
{ id: "0" }
).save();
const user = await new User({
guilds: [],
discriminator: "1",
username: "test",
flags: "0",
public_flags: "0",
id: "0",
}).save();
user.relationships = [new Relationship({ type: RelationshipType.friends })];

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

@ -7,7 +7,7 @@ var config: ConfigEntity;
export const Config = {
init: async function init() {
if (config) return config;
config = (await ConfigEntity.findOne({ id: "0" })) || new ConfigEntity({}, { id: "0" });
config = (await ConfigEntity.findOne({ id: "0" })) || new ConfigEntity({ id: "0" });
return this.set((config.value || {}).merge(DefaultConfigOptions));
},

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

@ -220,13 +220,14 @@ export async function getPermission(user_id?: string, guild_id?: string, channel
guild = await Guild.findOneOrFail({ id: guild_id });
if (guild.owner_id === user_id) return new Permissions(Permissions.FLAGS.ADMINISTRATOR);
member = await Member.findOneOrFail({ where: { guild_id, id: user_id }, relations: ["roles"] });
member = await Member.findOneOrFail({ where: { guild: guild_id, id: user_id }, relations: ["roles"] });
}
// TODO: remove guild.roles and convert recipient_ids to recipients
var permission = Permissions.finalPermission({
user: {
id: user_id,
roles: member?.role_ids || [],
roles: member?.roles.map((x) => x.id) || [],
},
guild: {
roles: member?.roles || [],
@ -234,7 +235,7 @@ export async function getPermission(user_id?: string, guild_id?: string, channel
channel: {
overwrites: channel?.permission_overwrites,
owner_id: channel?.owner_id,
recipient_ids: channel?.recipient_ids,
recipient_ids: channel?.recipients?.map((x) => x.id),
},
});