diff --git a/util/src/entities/Application.ts b/util/src/entities/Application.ts
new file mode 100644
index 00000000..2092cd4e
--- /dev/null
+++ b/util/src/entities/Application.ts
@@ -0,0 +1,107 @@
+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 {
+ @Column()
+ name: string;
+
+ @Column({ nullable: true })
+ icon?: string;
+
+ @Column()
+ description: string;
+
+ @Column({ type: "simple-array", nullable: true })
+ rpc_origins?: string[];
+
+ @Column()
+ bot_public: boolean;
+
+ @Column()
+ bot_require_code_grant: boolean;
+
+ @Column({ nullable: true })
+ terms_of_service_url?: string;
+
+ @Column({ nullable: true })
+ privacy_policy_url?: string;
+
+ @JoinColumn({ name: "owner_id" })
+ @ManyToOne(() => User)
+ owner?: User;
+
+ @Column({ nullable: true })
+ summary?: string;
+
+ @Column()
+ verify_key: string;
+
+ @JoinColumn({ name: "team_id" })
+ @ManyToOne(() => Team)
+ team?: Team;
+
+ @JoinColumn({ name: "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 })
+ primary_sku_id?: string; // if this application is a game sold, this field will be the id of the "Game SKU" that is created,
+
+ @Column({ nullable: true })
+ slug?: string; // if this application is a game sold, this field will be the URL slug that links to the store page
+
+ @Column({ nullable: true })
+ cover_image?: string; // the application's default rich presence invite cover image hash
+
+ @Column()
+ flags: string; // the application's public flags
+}
+
+export interface ApplicationCommand {
+ id: string;
+ application_id: string;
+ name: string;
+ description: string;
+ options?: ApplicationCommandOption[];
+}
+
+export interface ApplicationCommandOption {
+ type: ApplicationCommandOptionType;
+ name: string;
+ description: string;
+ required?: boolean;
+ choices?: ApplicationCommandOptionChoice[];
+ options?: ApplicationCommandOption[];
+}
+
+export interface ApplicationCommandOptionChoice {
+ name: string;
+ value: string | number;
+}
+
+export enum ApplicationCommandOptionType {
+ SUB_COMMAND = 1,
+ SUB_COMMAND_GROUP = 2,
+ STRING = 3,
+ INTEGER = 4,
+ BOOLEAN = 5,
+ USER = 6,
+ CHANNEL = 7,
+ ROLE = 8,
+}
+
+export interface ApplicationCommandInteractionData {
+ id: string;
+ name: string;
+ options?: ApplicationCommandInteractionDataOption[];
+}
+
+export interface ApplicationCommandInteractionDataOption {
+ name: string;
+ value?: any;
+ options?: ApplicationCommandInteractionDataOption[];
+}
diff --git a/util/src/entities/Attachment.ts b/util/src/entities/Attachment.ts
new file mode 100644
index 00000000..ca893400
--- /dev/null
+++ b/util/src/entities/Attachment.ts
@@ -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;
+}
diff --git a/util/src/entities/AuditLog.ts b/util/src/entities/AuditLog.ts
new file mode 100644
index 00000000..ceeb21fd
--- /dev/null
+++ b/util/src/entities/AuditLog.ts
@@ -0,0 +1,145 @@
+import { Column, Entity, JoinColumn, ManyToOne, RelationId } from "typeorm";
+import { BaseClass } from "./BaseClass";
+import { ChannelPermissionOverwrite } from "./Channel";
+import { User } from "./User";
+
+export enum AuditLogEvents {
+ GUILD_UPDATE = 1,
+ CHANNEL_CREATE = 10,
+ CHANNEL_UPDATE = 11,
+ CHANNEL_DELETE = 12,
+ CHANNEL_OVERWRITE_CREATE = 13,
+ CHANNEL_OVERWRITE_UPDATE = 14,
+ CHANNEL_OVERWRITE_DELETE = 15,
+ MEMBER_KICK = 20,
+ MEMBER_PRUNE = 21,
+ MEMBER_BAN_ADD = 22,
+ MEMBER_BAN_REMOVE = 23,
+ MEMBER_UPDATE = 24,
+ MEMBER_ROLE_UPDATE = 25,
+ MEMBER_MOVE = 26,
+ MEMBER_DISCONNECT = 27,
+ BOT_ADD = 28,
+ ROLE_CREATE = 30,
+ ROLE_UPDATE = 31,
+ ROLE_DELETE = 32,
+ INVITE_CREATE = 40,
+ INVITE_UPDATE = 41,
+ INVITE_DELETE = 42,
+ WEBHOOK_CREATE = 50,
+ WEBHOOK_UPDATE = 51,
+ WEBHOOK_DELETE = 52,
+ EMOJI_CREATE = 60,
+ EMOJI_UPDATE = 61,
+ EMOJI_DELETE = 62,
+ MESSAGE_DELETE = 72,
+ MESSAGE_BULK_DELETE = 73,
+ MESSAGE_PIN = 74,
+ MESSAGE_UNPIN = 75,
+ INTEGRATION_CREATE = 80,
+ INTEGRATION_UPDATE = 81,
+ INTEGRATION_DELETE = 82,
+}
+
+@Entity("audit_logs")
+export class AuditLogEntry extends BaseClass {
+ @JoinColumn({ name: "target_id" })
+ @ManyToOne(() => User)
+ target?: User;
+
+ @Column({ nullable: true })
+ @RelationId((auditlog: AuditLogEntry) => auditlog.user)
+ user_id: string;
+
+ @JoinColumn({ name: "user_id" })
+ @ManyToOne(() => User)
+ user: User;
+
+ @Column({
+ type: "simple-enum",
+ enum: AuditLogEvents,
+ })
+ action_type: AuditLogEvents;
+
+ @Column({ type: "simple-json", nullable: true })
+ options?: {
+ delete_member_days?: string;
+ members_removed?: string;
+ channel_id?: string;
+ messaged_id?: string;
+ count?: string;
+ id?: string;
+ type?: string;
+ role_name?: string;
+ };
+
+ @Column()
+ @Column({ type: "simple-json" })
+ changes: AuditLogChange[];
+
+ @Column({ nullable: true })
+ reason?: string;
+}
+
+export interface AuditLogChange {
+ new_value?: AuditLogChangeValue;
+ old_value?: AuditLogChangeValue;
+ key: string;
+}
+
+export interface AuditLogChangeValue {
+ name?: string;
+ description?: string;
+ icon_hash?: string;
+ splash_hash?: string;
+ discovery_splash_hash?: string;
+ banner_hash?: string;
+ owner_id?: string;
+ region?: string;
+ preferred_locale?: string;
+ afk_channel_id?: string;
+ afk_timeout?: number;
+ rules_channel_id?: string;
+ public_updates_channel_id?: string;
+ mfa_level?: number;
+ verification_level?: number;
+ explicit_content_filter?: number;
+ default_message_notifications?: number;
+ vanity_url_code?: string;
+ $add?: {}[];
+ $remove?: {}[];
+ prune_delete_days?: number;
+ widget_enabled?: boolean;
+ widget_channel_id?: string;
+ system_channel_id?: string;
+ position?: number;
+ topic?: string;
+ bitrate?: number;
+ permission_overwrites?: ChannelPermissionOverwrite[];
+ nsfw?: boolean;
+ application_id?: string;
+ rate_limit_per_user?: number;
+ permissions?: string;
+ color?: number;
+ hoist?: boolean;
+ mentionable?: boolean;
+ allow?: string;
+ deny?: string;
+ code?: string;
+ channel_id?: string;
+ inviter_id?: string;
+ max_uses?: number;
+ uses?: number;
+ max_age?: number;
+ temporary?: boolean;
+ deaf?: boolean;
+ mute?: boolean;
+ nick?: string;
+ avatar_hash?: string;
+ id?: string;
+ type?: number;
+ enable_emoticons?: boolean;
+ expire_behavior?: number;
+ expire_grace_period?: number;
+ user_limit?: number;
+}
diff --git a/util/src/entities/Ban.ts b/util/src/entities/Ban.ts
new file mode 100644
index 00000000..e8a6d648
--- /dev/null
+++ b/util/src/entities/Ban.ts
@@ -0,0 +1,37 @@
+import { Column, Entity, JoinColumn, ManyToOne, RelationId } from "typeorm";
+import { BaseClass } from "./BaseClass";
+import { Guild } from "./Guild";
+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;
+
+ @Column({ nullable: true })
+ @RelationId((ban: Ban) => ban.guild)
+ guild_id: string;
+
+ @JoinColumn({ name: "guild_id" })
+ @ManyToOne(() => Guild)
+ guild: Guild;
+
+ @Column({ nullable: true })
+ @RelationId((ban: Ban) => ban.executor)
+ executor_id: string;
+
+ @JoinColumn({ name: "executor_id" })
+ @ManyToOne(() => User)
+ executor: User;
+
+ @Column()
+ ip: string;
+
+ @Column({ nullable: true })
+ reason?: string;
+}
diff --git a/util/src/entities/BaseClass.ts b/util/src/entities/BaseClass.ts
new file mode 100644
index 00000000..0856ccd1
--- /dev/null
+++ b/util/src/entities/BaseClass.ts
@@ -0,0 +1,77 @@
+import "reflect-metadata";
+import { BaseEntity, BeforeInsert, BeforeUpdate, EntityMetadata, FindConditions, PrimaryColumn } from "typeorm";
+import { Snowflake } from "../util/Snowflake";
+import "missing-native-js-functions";
+
+// TODO use class-validator https://typeorm.io/#/validation with class annotators (isPhone/isEmail) combined with types from typescript-json-schema
+// btw. we don't use class-validator for everything, because we need to explicitly set the type instead of deriving it from typescript also it doesn't easily support nested objects
+
+export class BaseClass extends BaseEntity {
+ @PrimaryColumn()
+ id: string = Snowflake.generate();
+
+ // @ts-ignore
+ constructor(public props?: any) {
+ super();
+ this.assign(props);
+ }
+
+ get construct(): any {
+ return this.constructor;
+ }
+
+ get metadata() {
+ return this.construct.getRepository().metadata as EntityMetadata;
+ }
+
+ assign(props: any) {
+ if (!props || typeof props !== "object") return;
+ delete props.opts;
+ delete props.props;
+
+ 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;
+ // @ts-ignore
+ const setter = this[`set${key.capitalize()}`];
+
+ if (setter) {
+ setter.call(this, props[key]);
+ } else {
+ // @ts-ignore
+ this[key] = props[key];
+ }
+ }
+ }
+
+ @BeforeUpdate()
+ @BeforeInsert()
+ validate() {
+ this.assign(this.props);
+ return this;
+ }
+
+ toJSON(): any {
+ 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) {
+ const repository = this.getRepository();
+ return repository.increment(conditions, propertyPath, value);
+ }
+
+ static decrement<T extends BaseClass>(conditions: FindConditions<T>, propertyPath: string, value: number | string) {
+ const repository = this.getRepository();
+ return repository.decrement(conditions, propertyPath, value);
+ }
+}
diff --git a/util/src/entities/Channel.ts b/util/src/entities/Channel.ts
new file mode 100644
index 00000000..e3586dfc
--- /dev/null
+++ b/util/src/entities/Channel.ts
@@ -0,0 +1,171 @@
+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
+ DM = 1, // a direct message between users
+ GUILD_VOICE = 2, // a voice channel within a server
+ GROUP_DM = 3, // a direct message between multiple users
+ GUILD_CATEGORY = 4, // an organizational category that contains up to 50 channels
+ GUILD_NEWS = 5, // a channel that users can follow and crosspost into their own server
+ GUILD_STORE = 6, // a channel in which game developers can sell their game on Discord
+}
+
+@Entity("channels")
+export class Channel extends BaseClass {
+ @Column()
+ created_at: Date;
+
+ @Column()
+ name: string;
+
+ @Column({ type: "simple-enum", enum: ChannelType })
+ type: ChannelType;
+
+ @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)
+ last_message?: Message;
+
+ @Column({ nullable: true })
+ @RelationId((channel: Channel) => channel.guild)
+ guild_id?: string;
+
+ @JoinColumn({ name: "guild_id" })
+ @ManyToOne(() => Guild)
+ guild: Guild;
+
+ @Column({ nullable: true })
+ @RelationId((channel: Channel) => channel.parent)
+ parent_id: string;
+
+ @JoinColumn({ name: "parent_id" })
+ @ManyToOne(() => Channel)
+ parent?: Channel;
+
+ @Column({ nullable: true })
+ @RelationId((channel: Channel) => channel.owner)
+ owner_id: string;
+
+ @JoinColumn({ name: "owner_id" })
+ @ManyToOne(() => User)
+ owner: User;
+
+ @Column({ nullable: true })
+ last_pin_timestamp?: number;
+
+ @Column({ nullable: true })
+ default_auto_archive_duration?: number;
+
+ @Column()
+ position: number;
+
+ @Column({ type: "simple-json" })
+ permission_overwrites: ChannelPermissionOverwrite[];
+
+ @Column({ nullable: true })
+ video_quality_mode?: number;
+
+ @Column({ nullable: true })
+ bitrate?: number;
+
+ @Column({ nullable: true })
+ user_limit?: number;
+
+ @Column({ nullable: true })
+ nsfw?: boolean;
+
+ @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 {
+ allow: bigint; // for bitfields we use bigints
+ deny: bigint; // for bitfields we use bigints
+ id: string;
+ type: ChannelPermissionOverwriteType;
+}
+
+export enum ChannelPermissionOverwriteType {
+ role = 0,
+ member = 1,
+}
diff --git a/util/src/entities/Config.ts b/util/src/entities/Config.ts
new file mode 100644
index 00000000..5eb55933
--- /dev/null
+++ b/util/src/entities/Config.ts
@@ -0,0 +1,280 @@
+import { Column, Entity, JoinColumn, ManyToOne } from "typeorm";
+import { BaseClass } from "./BaseClass";
+import crypto from "crypto";
+import { Snowflake } from "../util/Snowflake";
+
+@Entity("config")
+export class ConfigEntity extends BaseClass {
+ @Column({ type: "simple-json" })
+ value: ConfigValue;
+}
+
+export interface RateLimitOptions {
+ bot?: number;
+ count: number;
+ window: number;
+ onyIp?: boolean;
+}
+
+export interface Region {
+ id: string;
+ name: string;
+ endpoint: string;
+ location?: {
+ latitude: number;
+ longitude: number;
+ };
+ vip: boolean;
+ custom: boolean;
+ deprecated: boolean;
+}
+
+export interface KafkaBroker {
+ ip: string;
+ port: number;
+}
+
+export interface ConfigValue {
+ gateway: {
+ endpointClient: string | null;
+ endpoint: string | null;
+ };
+ cdn: {
+ endpointClient: string | null;
+ endpoint: string | null;
+ };
+ general: {
+ instance_id: string;
+ };
+ permissions: {
+ user: {
+ createGuilds: boolean;
+ };
+ };
+ limits: {
+ user: {
+ maxGuilds: number;
+ maxUsername: number;
+ maxFriends: number;
+ };
+ guild: {
+ maxRoles: number;
+ maxMembers: number;
+ maxChannels: number;
+ maxChannelsInCategory: number;
+ hideOfflineMember: number;
+ };
+ message: {
+ maxCharacters: number;
+ maxTTSCharacters: number;
+ maxReactions: number;
+ maxAttachmentSize: number;
+ maxBulkDelete: number;
+ };
+ channel: {
+ maxPins: number;
+ maxTopic: number;
+ };
+ rate: {
+ ip: Omit<RateLimitOptions, "bot_count">;
+ global: RateLimitOptions;
+ error: RateLimitOptions;
+ routes: {
+ guild: RateLimitOptions;
+ webhook: RateLimitOptions;
+ channel: RateLimitOptions;
+ auth: {
+ login: RateLimitOptions;
+ register: RateLimitOptions;
+ };
+ // TODO: rate limit configuration for all routes
+ };
+ };
+ };
+ security: {
+ autoUpdate: boolean | number;
+ requestSignature: string;
+ jwtSecret: string;
+ forwadedFor: string | null; // header to get the real user ip address
+ captcha: {
+ enabled: boolean;
+ service: "recaptcha" | "hcaptcha" | null; // TODO: hcaptcha, custom
+ sitekey: string | null;
+ secret: string | null;
+ };
+ ipdataApiKey: string | null;
+ };
+ login: {
+ requireCaptcha: boolean;
+ };
+ register: {
+ email: {
+ necessary: boolean; // we have to use necessary instead of required as the cli tool uses json schema and can't use required
+ allowlist: boolean;
+ blocklist: boolean;
+ domains: string[];
+ };
+ dateOfBirth: {
+ necessary: boolean;
+ minimum: number; // in years
+ };
+ requireCaptcha: boolean;
+ requireInvite: boolean;
+ allowNewRegistration: boolean;
+ allowMultipleAccounts: boolean;
+ blockProxies: boolean;
+ password: {
+ minLength: number;
+ minNumbers: number;
+ minUpperCase: number;
+ minSymbols: number;
+ };
+ };
+ regions: {
+ default: string;
+ useDefaultAsOptimal: boolean;
+ available: Region[];
+ };
+ rabbitmq: {
+ host: string | null;
+ };
+ kafka: {
+ brokers: KafkaBroker[] | null;
+ };
+}
+
+export const DefaultConfigOptions: ConfigValue = {
+ gateway: {
+ endpointClient: null,
+ endpoint: null,
+ },
+ cdn: {
+ endpointClient: null,
+ endpoint: null,
+ },
+ general: {
+ instance_id: Snowflake.generate(),
+ },
+ permissions: {
+ user: {
+ createGuilds: true,
+ },
+ },
+ limits: {
+ user: {
+ maxGuilds: 100,
+ maxUsername: 32,
+ maxFriends: 1000,
+ },
+ guild: {
+ maxRoles: 250,
+ maxMembers: 250000,
+ maxChannels: 500,
+ maxChannelsInCategory: 50,
+ hideOfflineMember: 1000,
+ },
+ message: {
+ maxCharacters: 2000,
+ maxTTSCharacters: 200,
+ maxReactions: 20,
+ maxAttachmentSize: 8388608,
+ maxBulkDelete: 100,
+ },
+ channel: {
+ maxPins: 50,
+ maxTopic: 1024,
+ },
+ rate: {
+ ip: {
+ count: 500,
+ window: 5,
+ },
+ global: {
+ count: 20,
+ window: 5,
+ bot: 250,
+ },
+ error: {
+ count: 10,
+ window: 5,
+ },
+ routes: {
+ guild: {
+ count: 5,
+ window: 5,
+ },
+ webhook: {
+ count: 10,
+ window: 5,
+ },
+ channel: {
+ count: 10,
+ window: 5,
+ },
+ auth: {
+ login: {
+ count: 5,
+ window: 60,
+ },
+ register: {
+ count: 2,
+ window: 60 * 60 * 12,
+ },
+ },
+ },
+ },
+ },
+ security: {
+ autoUpdate: true,
+ requestSignature: crypto.randomBytes(32).toString("base64"),
+ jwtSecret: crypto.randomBytes(256).toString("base64"),
+ forwadedFor: null,
+ // forwadedFor: "X-Forwarded-For" // nginx/reverse proxy
+ // forwadedFor: "CF-Connecting-IP" // cloudflare:
+ captcha: {
+ enabled: false,
+ service: null,
+ sitekey: null,
+ secret: null,
+ },
+ ipdataApiKey: "eca677b284b3bac29eb72f5e496aa9047f26543605efe99ff2ce35c9",
+ },
+ login: {
+ requireCaptcha: false,
+ },
+ register: {
+ email: {
+ necessary: true,
+ 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,
+ minimum: 13,
+ },
+ requireInvite: false,
+ requireCaptcha: true,
+ allowNewRegistration: true,
+ allowMultipleAccounts: true,
+ blockProxies: true,
+ password: {
+ minLength: 8,
+ minNumbers: 2,
+ minUpperCase: 2,
+ minSymbols: 0,
+ },
+ },
+ regions: {
+ default: "fosscord",
+ useDefaultAsOptimal: true,
+ available: [{ id: "fosscord", name: "Fosscord", endpoint: "127.0.0.1", vip: false, custom: false, deprecated: false }],
+ },
+ rabbitmq: {
+ host: null,
+ },
+ kafka: {
+ brokers: null,
+ },
+};
diff --git a/util/src/entities/ConnectedAccount.ts b/util/src/entities/ConnectedAccount.ts
new file mode 100644
index 00000000..75982d01
--- /dev/null
+++ b/util/src/entities/ConnectedAccount.ts
@@ -0,0 +1,38 @@
+import { Column, Entity, JoinColumn, ManyToOne, RelationId } from "typeorm";
+import { BaseClass } from "./BaseClass";
+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;
+
+ @Column({ select: false })
+ access_token: string;
+
+ @Column({ select: false })
+ friend_sync: boolean;
+
+ @Column()
+ name: string;
+
+ @Column({ select: false })
+ revoked: boolean;
+
+ @Column({ select: false })
+ show_activity: boolean;
+
+ @Column()
+ type: string;
+
+ @Column()
+ verifie: boolean;
+
+ @Column({ select: false })
+ visibility: number;
+}
diff --git a/util/src/entities/Emoji.ts b/util/src/entities/Emoji.ts
new file mode 100644
index 00000000..181aff2c
--- /dev/null
+++ b/util/src/entities/Emoji.ts
@@ -0,0 +1,29 @@
+import { Column, Entity, JoinColumn, ManyToOne } from "typeorm";
+import { BaseClass } from "./BaseClass";
+import { Guild } from "./Guild";
+import { Role } from "./Role";
+
+@Entity("emojis")
+export class Emoji extends BaseClass {
+ @Column()
+ animated: boolean;
+
+ @Column()
+ available: boolean; // whether this emoji can be used, may be false due to loss of Server Boosts
+
+ @Column()
+ guild_id: string;
+
+ @JoinColumn({ name: "guild_id" })
+ @ManyToOne(() => Guild)
+ guild: Guild;
+
+ @Column()
+ managed: boolean;
+
+ @Column()
+ name: string;
+
+ @Column()
+ require_colons: boolean;
+}
diff --git a/util/src/entities/Guild.ts b/util/src/entities/Guild.ts
new file mode 100644
index 00000000..032a9415
--- /dev/null
+++ b/util/src/entities/Guild.ts
@@ -0,0 +1,212 @@
+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)
+ afk_channel?: Channel;
+
+ @Column({ nullable: true })
+ afk_timeout?: number;
+
+ // * commented out -> use owner instead
+ // application id of the guild creator if it is bot-created
+ // @Column({ nullable: true })
+ // application?: string;
+
+ @JoinColumn({ name: "ban_ids" })
+ @OneToMany(() => Ban, (ban: Ban) => ban.guild)
+ bans: Ban[];
+
+ @Column({ nullable: true })
+ banner?: string;
+
+ @Column({ nullable: true })
+ default_message_notifications?: number;
+
+ @Column({ nullable: true })
+ description?: string;
+
+ @Column({ nullable: true })
+ discovery_splash?: string;
+
+ @Column({ nullable: true })
+ explicit_content_filter?: number;
+
+ @Column({ type: "simple-array" })
+ features: string[]; //TODO use enum
+
+ @Column({ nullable: true })
+ icon?: string;
+
+ @Column({ nullable: true })
+ large?: boolean;
+
+ @Column({ nullable: true })
+ max_members?: number; // e.g. default 100.000
+
+ @Column({ nullable: true })
+ max_presences?: number;
+
+ @Column({ nullable: true })
+ max_video_channel_users?: number; // ? default: 25, is this max 25 streaming or watching
+
+ @Column({ nullable: true })
+ member_count?: number;
+
+ @Column({ nullable: true })
+ presence_count?: number; // users online
+
+ @OneToMany(() => Member, (member: Member) => member.guild)
+ members: Member[];
+
+ @JoinColumn({ name: "role_ids" })
+ @OneToMany(() => Role, (role: Role) => role.guild)
+ roles: Role[];
+
+ @JoinColumn({ name: "channel_ids" })
+ @OneToMany(() => Channel, (channel: Channel) => channel.guild)
+ channels: Channel[];
+
+ @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[];
+
+ @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", referencedColumnName: "id" }])
+ @ManyToOne(() => User)
+ owner: User;
+
+ @Column({ nullable: true })
+ preferred_locale?: string; // only community guilds can choose this
+
+ @Column({ nullable: true })
+ premium_subscription_count?: number;
+
+ @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" })
+ @ManyToOne(() => Channel)
+ public_updates_channel?: Channel;
+
+ @Column({ nullable: true })
+ @RelationId((guild: Guild) => guild.rules_channel)
+ rules_channel_id?: string;
+
+ @JoinColumn({ name: "rules_channel_id" })
+ @ManyToOne(() => Channel)
+ rules_channel?: string;
+
+ @Column({ nullable: true })
+ region?: string;
+
+ @Column({ nullable: true })
+ splash?: string;
+
+ @Column({ nullable: true })
+ @RelationId((guild: Guild) => guild.system_channel)
+ system_channel_id?: string;
+
+ @JoinColumn({ name: "system_channel_id" })
+ @ManyToOne(() => Channel)
+ system_channel?: Channel;
+
+ @Column({ nullable: true })
+ system_channel_flags?: number;
+
+ @Column({ nullable: true })
+ unavailable?: boolean;
+
+ @Column({ nullable: true })
+ @RelationId((guild: Guild) => guild.vanity_url)
+ vanity_url_code?: string;
+
+ @JoinColumn({ name: "vanity_url_code" })
+ @ManyToOne(() => Invite)
+ vanity_url?: Invite;
+
+ @Column({ nullable: true })
+ verification_level?: number;
+
+ @Column({ type: "simple-json" })
+ welcome_screen: {
+ enabled: boolean;
+ description: string;
+ welcome_channels: {
+ description: string;
+ emoji_id?: string;
+ emoji_name: string;
+ channel_id: string;
+ }[];
+ };
+
+ @Column({ nullable: true })
+ @RelationId((guild: Guild) => guild.widget_channel)
+ widget_channel_id?: string;
+
+ @JoinColumn({ name: "widget_channel_id" })
+ @ManyToOne(() => Channel)
+ widget_channel?: Channel;
+
+ @Column({ nullable: true })
+ widget_enabled?: boolean;
+}
diff --git a/util/src/entities/Invite.ts b/util/src/entities/Invite.ts
new file mode 100644
index 00000000..01e22294
--- /dev/null
+++ b/util/src/entities/Invite.ts
@@ -0,0 +1,64 @@
+import { Column, Entity, JoinColumn, ManyToOne, PrimaryColumn, RelationId } from "typeorm";
+import { BaseClass } from "./BaseClass";
+import { Channel } from "./Channel";
+import { Guild } from "./Guild";
+import { User } from "./User";
+
+@Entity("invites")
+export class Invite extends BaseClass {
+ @PrimaryColumn()
+ code: string;
+
+ @Column()
+ temporary: boolean;
+
+ @Column()
+ uses: number;
+
+ @Column()
+ max_uses: number;
+
+ @Column()
+ max_age: number;
+
+ @Column()
+ created_at: Date;
+
+ @Column()
+ expires_at: Date;
+
+ @Column({ nullable: true })
+ @RelationId((invite: Invite) => invite.guild)
+ guild_id: string;
+
+ @JoinColumn({ name: "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;
+
+ @Column({ nullable: true })
+ @RelationId((invite: Invite) => invite.inviter)
+ inviter_id: string;
+
+ @JoinColumn({ name: "inviter_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)
+ target_user?: string; // could be used for "User specific invites" https://github.com/fosscord/fosscord/issues/62
+
+ @Column({ nullable: true })
+ target_user_type?: number;
+}
diff --git a/util/src/entities/Member.ts b/util/src/entities/Member.ts
new file mode 100644
index 00000000..d2d78bb9
--- /dev/null
+++ b/util/src/entities/Member.ts
@@ -0,0 +1,287 @@
+import { PublicUser, User } from "./User";
+import { BaseClass } from "./BaseClass";
+import { Column, Entity, JoinColumn, JoinTable, ManyToMany, ManyToOne, OneToMany, RelationId } from "typeorm";
+import { Guild } from "./Guild";
+import { Config, emitEvent } from "../util";
+import {
+ GuildCreateEvent,
+ GuildDeleteEvent,
+ GuildMemberAddEvent,
+ GuildMemberRemoveEvent,
+ GuildMemberUpdateEvent,
+} from "../interfaces";
+import { HTTPError } from "lambert-server";
+import { Role } from "./Role";
+
+@Entity("members")
+export class Member extends BaseClass {
+ @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;
+
+ @Column({ nullable: true })
+ nick?: string;
+
+ @JoinTable({ name: "member_roles" })
+ @ManyToMany(() => Role)
+ roles: Role[];
+
+ @Column()
+ joined_at: Date;
+
+ @Column({ nullable: true })
+ premium_since?: number;
+
+ @Column()
+ deaf: boolean;
+
+ @Column()
+ mute: boolean;
+
+ @Column()
+ pending: boolean;
+
+ @Column({ type: "simple-json" })
+ settings: UserGuildSettings;
+
+ // TODO: update
+ @Column({ type: "simple-json" })
+ read_state: Record<string, string | null>;
+
+ static async IsInGuildOrFail(user_id: string, guild_id: string) {
+ if (await Member.count({ id: user_id, guild: { id: guild_id } })) return true;
+ throw new HTTPError("You are not member of this guild", 403);
+ }
+
+ static async removeFromGuild(user_id: string, guild_id: string) {
+ const guild = await Guild.findOneOrFail({ select: ["owner_id"], where: { id: guild_id } });
+ if (guild.owner_id === user_id) throw new Error("The owner cannot be removed of the guild");
+ const member = await Member.findOneOrFail({ where: { id: user_id, guild_id }, relations: ["user"] });
+
+ // use promise all to execute all promises at the same time -> save time
+ return Promise.all([
+ Member.delete({
+ id: user_id,
+ guild_id: guild_id,
+ }),
+ Guild.decrement({ id: guild_id }, "member_count", -1),
+
+ emitEvent({
+ event: "GUILD_DELETE",
+ data: {
+ id: guild_id,
+ },
+ user_id: user_id,
+ } as GuildDeleteEvent),
+ emitEvent({
+ event: "GUILD_MEMBER_REMOVE",
+ data: {
+ guild_id: guild_id,
+ user: member.user,
+ },
+ guild_id: guild_id,
+ } as GuildMemberRemoveEvent),
+ ]);
+ }
+
+ 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", "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.roles.push(new Role({ id: role_id }));
+
+ 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,
+ } 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", "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.roles = member.roles.filter((x) => x.id == role_id);
+
+ 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,
+ } as GuildMemberUpdateEvent),
+ ]);
+ }
+
+ static async changeNickname(user_id: string, guild_id: string, nickname: string) {
+ const member = await Member.findOneOrFail({
+ where: {
+ id: user_id,
+ guild_id: guild_id,
+ },
+ relations: ["user"],
+ });
+ member.nick = nickname;
+
+ await Promise.all([
+ member.save(),
+
+ emitEvent({
+ event: "GUILD_MEMBER_UPDATE",
+ data: {
+ guild_id: guild_id,
+ user: member.user,
+ nick: nickname,
+ },
+ guild_id: guild_id,
+ } as GuildMemberUpdateEvent),
+ ]);
+ }
+
+ static async addToGuild(user_id: string, guild_id: string) {
+ const user = await User.getPublicUser(user_id);
+
+ const { maxGuilds } = Config.get().limits.user;
+ const guild_count = await Member.count({ id: user_id });
+ if (guild_count >= maxGuilds) {
+ throw new HTTPError(`You are at the ${maxGuilds} server limit.`, 403);
+ }
+
+ const guild = await Guild.findOneOrFail({
+ where: {
+ id: guild_id,
+ },
+ relations: ["channels", "emojis", "members", "roles", "stickers"],
+ });
+
+ 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 = {
+ id: user_id,
+ guild_id: guild_id,
+ nick: undefined,
+ roles: [guild_id], // @everyone role
+ joined_at: new Date(),
+ premium_since: undefined,
+ deaf: false,
+ mute: false,
+ pending: false,
+ };
+ // @ts-ignore
+ guild.joined_at = member.joined_at.toISOString();
+
+ await Promise.all([
+ Member.insert({
+ ...member,
+ roles: undefined,
+ read_state: {},
+ settings: {
+ channel_overrides: [],
+ message_notifications: 0,
+ mobile_push: true,
+ muted: false,
+ suppress_everyone: false,
+ suppress_roles: false,
+ version: 0,
+ },
+ }),
+ Guild.increment({ id: guild_id }, "member_count", 1),
+ emitEvent({
+ event: "GUILD_MEMBER_ADD",
+ data: {
+ ...member,
+ user,
+ guild_id: guild_id,
+ },
+ guild_id: guild_id,
+ } as GuildMemberAddEvent),
+ emitEvent({
+ event: "GUILD_CREATE",
+ data: { ...guild, members: [...guild.members, member] },
+ user_id,
+ } as GuildCreateEvent),
+ ]);
+ }
+}
+
+export interface UserGuildSettings {
+ channel_overrides: {
+ channel_id: string;
+ message_notifications: number;
+ mute_config: MuteConfig;
+ muted: boolean;
+ }[];
+ message_notifications: number;
+ mobile_push: boolean;
+ mute_config: MuteConfig;
+ muted: boolean;
+ suppress_everyone: boolean;
+ suppress_roles: boolean;
+ version: number;
+}
+
+export interface MuteConfig {
+ end_time: number;
+ selected_time_window: number;
+}
+
+export type PublicMemberKeys =
+ | "id"
+ | "guild_id"
+ | "nick"
+ | "roles"
+ | "joined_at"
+ | "pending"
+ | "deaf"
+ | "mute"
+ | "premium_since";
+
+export const PublicMemberProjection: PublicMemberKeys[] = [
+ "id",
+ "guild_id",
+ "nick",
+ "roles",
+ "joined_at",
+ "pending",
+ "deaf",
+ "mute",
+ "premium_since",
+];
+
+// @ts-ignore
+export type PublicMember = Pick<Member, Omit<PublicMemberKeys, "roles">> & {
+ user: PublicUser;
+ roles: string[]; // only role ids not objects
+};
diff --git a/util/src/entities/Message.ts b/util/src/entities/Message.ts
new file mode 100644
index 00000000..542b2b55
--- /dev/null
+++ b/util/src/entities/Message.ts
@@ -0,0 +1,264 @@
+import { User } from "./User";
+import { Member } from "./Member";
+import { Role } from "./Role";
+import { Channel } from "./Channel";
+import { InteractionType } from "../interfaces/Interaction";
+import { Application } from "./Application";
+import {
+ Column,
+ CreateDateColumn,
+ Entity,
+ JoinColumn,
+ JoinTable,
+ ManyToMany,
+ ManyToOne,
+ OneToMany,
+ RelationId,
+ UpdateDateColumn,
+} from "typeorm";
+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,
+ RECIPIENT_ADD = 1,
+ RECIPIENT_REMOVE = 2,
+ CALL = 3,
+ CHANNEL_NAME_CHANGE = 4,
+ CHANNEL_ICON_CHANGE = 5,
+ CHANNEL_PINNED_MESSAGE = 6,
+ GUILD_MEMBER_JOIN = 7,
+ USER_PREMIUM_GUILD_SUBSCRIPTION = 8,
+ USER_PREMIUM_GUILD_SUBSCRIPTION_TIER_1 = 9,
+ USER_PREMIUM_GUILD_SUBSCRIPTION_TIER_2 = 10,
+ USER_PREMIUM_GUILD_SUBSCRIPTION_TIER_3 = 11,
+ CHANNEL_FOLLOW_ADD = 12,
+ GUILD_DISCOVERY_DISQUALIFIED = 14,
+ GUILD_DISCOVERY_REQUALIFIED = 15,
+ REPLY = 19,
+ APPLICATION_COMMAND = 20,
+}
+
+@Entity("messages")
+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;
+
+ @Column({ nullable: true })
+ @RelationId((message: Message) => message.guild)
+ guild_id?: string;
+
+ @JoinColumn({ name: "guild_id" })
+ @ManyToOne(() => Guild)
+ guild?: Guild;
+
+ @Column({ nullable: true })
+ @RelationId((message: Message) => message.author)
+ author_id: string;
+
+ @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;
+
+ @Column({ nullable: true })
+ @RelationId((message: Message) => message.webhook)
+ webhook_id: string;
+
+ @JoinColumn({ name: "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;
+
+ @Column({ nullable: true })
+ content?: string;
+
+ @Column()
+ @CreateDateColumn()
+ timestamp: Date;
+
+ @Column()
+ @UpdateDateColumn()
+ edited_timestamp?: Date;
+
+ @Column({ nullable: true })
+ tts?: boolean;
+
+ @Column({ nullable: true })
+ mention_everyone?: boolean;
+
+ @JoinTable({ name: "message_user_mentions" })
+ @ManyToMany(() => User)
+ mentions: User[];
+
+ @JoinTable({ name: "message_role_mentions" })
+ @ManyToMany(() => Role)
+ mention_roles: Role[];
+
+ @JoinTable({ name: "message_channel_mentions" })
+ @ManyToMany(() => Channel)
+ mention_channels: Channel[];
+
+ @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[];
+
+ @Column({ type: "simple-json" })
+ reactions: Reaction[];
+
+ @Column({ type: "text", nullable: true })
+ nonce?: string | number;
+
+ @Column({ nullable: true })
+ pinned?: boolean;
+
+ @Column({ type: "simple-enum", enum: MessageType })
+ type: MessageType;
+
+ @Column({ type: "simple-json", nullable: true })
+ activity?: {
+ type: number;
+ party_id: string;
+ };
+
+ @Column({ nullable: true })
+ flags?: string;
+ @Column({ type: "simple-json", nullable: true })
+ message_reference?: {
+ message_id: string;
+ channel_id?: string;
+ guild_id?: string;
+ };
+
+ @JoinColumn({ name: "message_reference_id" })
+ @ManyToOne(() => Message)
+ referenced_message?: Message;
+
+ @Column({ type: "simple-json", nullable: true })
+ interaction?: {
+ id: string;
+ type: InteractionType;
+ name: string;
+ user_id: string; // the user who invoked the interaction
+ // user: User; // TODO: autopopulate user
+ };
+
+ @Column({ type: "simple-json", nullable: true })
+ components?: MessageComponent[];
+}
+
+export interface MessageComponent {
+ type: number;
+ style?: number;
+ label?: string;
+ emoji?: PartialEmoji;
+ custom_id?: string;
+ url?: string;
+ disabled?: boolean;
+ components: MessageComponent[];
+}
+
+export enum MessageComponentType {
+ ActionRow = 1,
+ Button = 2,
+}
+
+export interface Embed {
+ title?: string; //title of embed
+ type?: EmbedType; // type of embed (always "rich" for webhook embeds)
+ description?: string; // description of embed
+ url?: string; // url of embed
+ timestamp?: Date; // timestamp of embed content
+ color?: number; // color code of the embed
+ footer?: {
+ text: string;
+ icon_url?: string;
+ proxy_icon_url?: string;
+ }; // footer object footer information
+ image?: EmbedImage; // image object image information
+ thumbnail?: EmbedImage; // thumbnail object thumbnail information
+ video?: EmbedImage; // video object video information
+ provider?: {
+ name?: string;
+ url?: string;
+ }; // provider object provider information
+ author?: {
+ name?: string;
+ url?: string;
+ icon_url?: string;
+ proxy_icon_url?: string;
+ }; // author object author information
+ fields?: {
+ name: string;
+ value: string;
+ inline?: boolean;
+ }[];
+}
+
+export enum EmbedType {
+ rich = "rich",
+ image = "image",
+ video = "video",
+ gifv = "gifv",
+ article = "article",
+ link = "link",
+}
+
+export interface EmbedImage {
+ url?: string;
+ proxy_url?: string;
+ height?: number;
+ width?: number;
+}
+
+export interface Reaction {
+ count: number;
+ //// not saved in the database // me: boolean; // whether the current user reacted using this emoji
+ emoji: PartialEmoji;
+ user_ids: string[];
+}
+
+export interface PartialEmoji {
+ id?: string;
+ name: string;
+ animated?: boolean;
+}
+
+export interface AllowedMentions {
+ parse?: ("users" | "roles" | "everyone")[];
+ roles?: string[];
+ users?: string[];
+ replied_user?: boolean;
+}
diff --git a/util/src/entities/RateLimit.ts b/util/src/entities/RateLimit.ts
new file mode 100644
index 00000000..fa9c32c1
--- /dev/null
+++ b/util/src/entities/RateLimit.ts
@@ -0,0 +1,20 @@
+import { Column, Entity } from "typeorm";
+import { BaseClass } from "./BaseClass";
+
+@Entity("rate_limits")
+export class RateLimit extends BaseClass {
+ @Column()
+ id: "global" | "error" | string; // channel_239842397 | guild_238927349823 | webhook_238923423498
+
+ @Column() // no relation as it also
+ executor_id: string;
+
+ @Column()
+ hits: number;
+
+ @Column()
+ blocked: boolean;
+
+ @Column()
+ expires_at: Date;
+}
diff --git a/util/src/entities/ReadState.ts b/util/src/entities/ReadState.ts
new file mode 100644
index 00000000..8dd05b21
--- /dev/null
+++ b/util/src/entities/ReadState.ts
@@ -0,0 +1,45 @@
+import { Column, Entity, JoinColumn, ManyToOne, RelationId } from "typeorm";
+import { BaseClass } from "./BaseClass";
+import { Channel } from "./Channel";
+import { Message } from "./Message";
+import { User } from "./User";
+
+// for read receipts
+// notification cursor and public read receipt need to be forwards-only (the former to prevent re-pinging when marked as unread, and the latter to be acceptable as a legal acknowledgement in criminal proceedings), and private read marker needs to be advance-rewind capable
+// public read receipt ≥ notification cursor ≥ private fully read marker
+
+@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;
+
+ @Column({ nullable: true })
+ @RelationId((read_state: ReadState) => read_state.user)
+ user_id: string;
+
+ @JoinColumn({ name: "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)
+ last_message?: Message;
+
+ @Column({ nullable: true })
+ last_pin_timestamp?: Date;
+
+ @Column()
+ mention_count: number;
+
+ @Column()
+ manual: boolean;
+}
diff --git a/util/src/entities/Recipient.ts b/util/src/entities/Recipient.ts
new file mode 100644
index 00000000..75d5b94d
--- /dev/null
+++ b/util/src/entities/Recipient.ts
@@ -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
+}
diff --git a/util/src/entities/Relationship.ts b/util/src/entities/Relationship.ts
new file mode 100644
index 00000000..5935f5b6
--- /dev/null
+++ b/util/src/entities/Relationship.ts
@@ -0,0 +1,27 @@
+import { Column, Entity, JoinColumn, ManyToOne, RelationId } from "typeorm";
+import { BaseClass } from "./BaseClass";
+import { User } from "./User";
+
+export enum RelationshipType {
+ outgoing = 4,
+ incoming = 3,
+ blocked = 2,
+ friends = 1,
+}
+
+@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;
+
+ @Column({ nullable: true })
+ nickname?: string;
+
+ @Column({ type: "simple-enum", enum: RelationshipType })
+ type: RelationshipType;
+}
diff --git a/util/src/entities/Role.ts b/util/src/entities/Role.ts
new file mode 100644
index 00000000..33c8d272
--- /dev/null
+++ b/util/src/entities/Role.ts
@@ -0,0 +1,43 @@
+import { Column, Entity, JoinColumn, ManyToOne, RelationId } from "typeorm";
+
+import { BaseClass } from "./BaseClass";
+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;
+
+ @Column()
+ color: number;
+
+ @Column()
+ hoist: boolean;
+
+ @Column()
+ managed: boolean;
+
+ @Column()
+ mentionable: boolean;
+
+ @Column()
+ name: string;
+
+ @Column()
+ permissions: string;
+
+ @Column()
+ position: number;
+
+ @Column({ type: "simple-json", nullable: true })
+ tags?: {
+ bot_id?: string;
+ integration_id?: string;
+ premium_subscriber?: boolean;
+ };
+}
diff --git a/util/src/entities/Sticker.ts b/util/src/entities/Sticker.ts
new file mode 100644
index 00000000..7730a86a
--- /dev/null
+++ b/util/src/entities/Sticker.ts
@@ -0,0 +1,42 @@
+import { Column, Entity, JoinColumn, ManyToOne } from "typeorm";
+import { BaseClass } from "./BaseClass";
+import { Guild } from "./Guild";
+
+export enum StickerType {
+ STANDARD = 1,
+ GUILD = 2,
+}
+
+export enum StickerFormatType {
+ PNG = 1,
+ APNG = 2,
+ LOTTIE = 3,
+}
+
+@Entity("stickers")
+export class Sticker extends BaseClass {
+ @Column()
+ name: string;
+
+ @Column({ nullable: true })
+ description?: string;
+
+ @Column()
+ tags: string;
+
+ @Column()
+ pack_id: string;
+
+ @Column({ nullable: true })
+ guild_id?: string;
+
+ @JoinColumn({ name: "guild_id" })
+ @ManyToOne(() => Guild)
+ guild?: Guild;
+
+ @Column({ type: "simple-enum", enum: StickerType })
+ type: StickerType;
+
+ @Column({ type: "simple-enum", enum: StickerFormatType })
+ format_type: StickerFormatType;
+}
diff --git a/util/src/entities/Team.ts b/util/src/entities/Team.ts
new file mode 100644
index 00000000..beb8bf68
--- /dev/null
+++ b/util/src/entities/Team.ts
@@ -0,0 +1,25 @@
+import { Column, Entity, JoinColumn, ManyToMany, ManyToOne, OneToMany, RelationId } from "typeorm";
+import { BaseClass } from "./BaseClass";
+import { TeamMember } from "./TeamMember";
+import { User } from "./User";
+
+@Entity("teams")
+export class Team extends BaseClass {
+ @Column({ nullable: true })
+ icon?: string;
+
+ @JoinColumn({ name: "member_ids" })
+ @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)
+ owner_user: User;
+}
diff --git a/util/src/entities/TeamMember.ts b/util/src/entities/TeamMember.ts
new file mode 100644
index 00000000..6b184d08
--- /dev/null
+++ b/util/src/entities/TeamMember.ts
@@ -0,0 +1,33 @@
+import { Column, Entity, JoinColumn, ManyToOne, RelationId } from "typeorm";
+import { BaseClass } from "./BaseClass";
+import { User } from "./User";
+
+export enum TeamMemberState {
+ INVITED = 1,
+ ACCEPTED = 2,
+}
+
+@Entity("team_members")
+export class TeamMember extends BaseClass {
+ @Column({ type: "simple-enum", enum: TeamMemberState })
+ membership_state: TeamMemberState;
+
+ @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.members)
+ team: import("./Team").Team;
+
+ @Column({ nullable: true })
+ @RelationId((member: TeamMember) => member.user)
+ user_id: string;
+
+ @JoinColumn({ name: "user_id" })
+ @ManyToOne(() => User)
+ user: User;
+}
diff --git a/util/src/entities/Template.ts b/util/src/entities/Template.ts
new file mode 100644
index 00000000..76f77ba6
--- /dev/null
+++ b/util/src/entities/Template.ts
@@ -0,0 +1,44 @@
+import { Column, Entity, JoinColumn, ManyToOne, PrimaryColumn, RelationId } from "typeorm";
+import { BaseClass } from "./BaseClass";
+import { Guild } from "./Guild";
+import { User } from "./User";
+
+@Entity("templates")
+export class Template extends BaseClass {
+ @PrimaryColumn()
+ code: string;
+
+ @Column()
+ name: string;
+
+ @Column({ nullable: true })
+ description?: string;
+
+ @Column({ nullable: true })
+ usage_count?: number;
+
+ @Column({ nullable: true })
+ @RelationId((template: Template) => template.creator)
+ creator_id: string;
+
+ @JoinColumn({ name: "creator_id" })
+ @ManyToOne(() => User)
+ creator: User;
+
+ @Column()
+ created_at: Date;
+
+ @Column()
+ updated_at: Date;
+
+ @Column({ nullable: true })
+ @RelationId((template: Template) => template.source_guild)
+ source_guild_id: string;
+
+ @JoinColumn({ name: "source_guild_id" })
+ @ManyToOne(() => Guild)
+ source_guild: Guild;
+
+ @Column({ type: "simple-json" })
+ serialized_source_guild: Guild;
+}
diff --git a/util/src/entities/User.ts b/util/src/entities/User.ts
new file mode 100644
index 00000000..39f654be
--- /dev/null
+++ b/util/src/entities/User.ts
@@ -0,0 +1,243 @@
+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"
+ | "discriminator"
+ | "id"
+ | "public_flags"
+ | "avatar"
+ | "accent_color"
+ | "banner"
+ | "bio"
+ | "bot";
+export const PublicUserProjection: PublicUserKeys[] = [
+ "username",
+ "discriminator",
+ "id",
+ "public_flags",
+ "avatar",
+ "accent_color",
+ "banner",
+ "bio",
+ "bot",
+];
+
+// Private user data that should never get sent to the client
+export type PublicUser = Pick<User, PublicUserKeys>;
+
+@Entity("users")
+export class User extends BaseClass {
+ @Column()
+ username: string; // username max length 32, min 2 (should be configurable)
+
+ @Column()
+ discriminator: string; // #0001 4 digit long string from #0001 - #9999
+
+ setDiscriminator(val: string) {
+ const number = Number(val);
+ if (isNaN(number)) throw new Error("invalid discriminator");
+ if (number <= 0 || number > 10000) throw new Error("discriminator must be between 1 and 9999");
+ this.discriminator = val.toString().padStart(4, "0");
+ }
+
+ @Column({ nullable: true })
+ avatar?: string; // hash of the user avatar
+
+ @Column({ nullable: true })
+ accent_color?: number; // banner color of user
+
+ @Column({ nullable: true })
+ banner?: string; // hash of the user banner
+
+ @Column({ nullable: true })
+ phone?: string; // phone number of the user
+
+ @Column()
+ desktop: boolean; // if the user has desktop app installed
+
+ @Column()
+ mobile: boolean; // if the user has mobile app installed
+
+ @Column()
+ premium: boolean; // if user bought nitro
+
+ @Column()
+ premium_type: number; // nitro level
+
+ @Column()
+ bot: boolean; // if user is bot
+
+ @Column()
+ bio: string; // short description of the user (max 190 chars -> should be configurable)
+
+ @Column()
+ system: boolean; // shouldn't be used, the api sents this field type true, if the generated message comes from a system generated author
+
+ @Column()
+ nsfw_allowed: boolean; // if the user is older than 18 (resp. Config)
+
+ @Column()
+ mfa_enabled: boolean; // if multi factor authentication is enabled
+
+ @Column()
+ created_at: Date = new Date(); // registration date
+
+ @Column()
+ verified: boolean; // if the user is offically verified
+
+ @Column()
+ disabled: boolean; // if the account is disabled
+
+ @Column()
+ deleted: boolean; // if the user was deleted
+
+ @Column({ nullable: true })
+ email?: string; // email of the user
+
+ @Column()
+ flags: string; // UserFlags
+
+ @Column()
+ public_flags: string;
+
+ @JoinColumn({ name: "relationship_ids" })
+ @OneToMany(() => Relationship, (relationship: Relationship) => relationship.user, { cascade: true })
+ relationships: Relationship[];
+
+ @JoinColumn({ name: "connected_account_ids" })
+ @OneToMany(() => ConnectedAccount, (account: ConnectedAccount) => account.user)
+ connected_accounts: ConnectedAccount[];
+
+ @Column({ type: "simple-json", select: false })
+ data: {
+ valid_tokens_since: Date; // all tokens with a previous issue date are invalid
+ hash?: string; // hash of the password, salt is saved in password (bcrypt)
+ };
+
+ @Column({ type: "simple-array" })
+ 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(
+ { id: user_id },
+ {
+ ...opts,
+ select: [...PublicUserProjection, ...(opts?.select || [])],
+ }
+ );
+ if (!user) throw new HTTPError("User not found", 404);
+ return user;
+ }
+}
+
+export const defaultSettings: UserSettings = {
+ afk_timeout: 300,
+ allow_accessibility_detection: true,
+ animate_emoji: true,
+ animate_stickers: 0,
+ contact_sync_enabled: false,
+ convert_emoticons: false,
+ custom_status: {
+ emoji_id: undefined,
+ emoji_name: undefined,
+ expires_at: undefined,
+ text: undefined,
+ },
+ default_guilds_restricted: false,
+ detect_platform_accounts: true,
+ developer_mode: false,
+ disable_games_tab: false,
+ enable_tts_command: true,
+ explicit_content_filter: 0,
+ friend_source_flags: { all: true },
+ gateway_connected: false,
+ gif_auto_play: true,
+ guild_folders: [],
+ guild_positions: [],
+ inline_attachment_media: true,
+ inline_embed_media: true,
+ locale: "en",
+ message_display_compact: false,
+ native_phone_integration_enabled: true,
+ render_embeds: true,
+ render_reactions: true,
+ restricted_guilds: [],
+ show_current_game: true,
+ status: "offline",
+ stream_notifications_enabled: true,
+ theme: "dark",
+ timezone_offset: 0,
+ // timezone_offset: // TODO: timezone from request
+};
+
+export interface UserSettings {
+ afk_timeout: number;
+ allow_accessibility_detection: boolean;
+ animate_emoji: boolean;
+ animate_stickers: number;
+ contact_sync_enabled: boolean;
+ convert_emoticons: boolean;
+ custom_status: {
+ emoji_id?: string;
+ emoji_name?: string;
+ expires_at?: number;
+ text?: string;
+ };
+ default_guilds_restricted: boolean;
+ detect_platform_accounts: boolean;
+ developer_mode: boolean;
+ disable_games_tab: boolean;
+ enable_tts_command: boolean;
+ explicit_content_filter: number;
+ friend_source_flags: { all: boolean };
+ gateway_connected: boolean;
+ gif_auto_play: boolean;
+ // every top guild is displayed as a "folder"
+ guild_folders: {
+ color: number;
+ guild_ids: string[];
+ id: number;
+ name: string;
+ }[];
+ guild_positions: string[]; // guild ids ordered by position
+ inline_attachment_media: boolean;
+ inline_embed_media: boolean;
+ locale: string; // en_US
+ message_display_compact: boolean;
+ native_phone_integration_enabled: boolean;
+ render_embeds: boolean;
+ render_reactions: boolean;
+ restricted_guilds: string[];
+ show_current_game: boolean;
+ status: "online" | "offline" | "dnd" | "idle";
+ stream_notifications_enabled: boolean;
+ theme: "dark" | "white"; // dark
+ timezone_offset: number; // e.g -60
+}
+
+export class UserFlags extends BitField {
+ static FLAGS = {
+ DISCORD_EMPLOYEE: BigInt(1) << BigInt(0),
+ PARTNERED_SERVER_OWNER: BigInt(1) << BigInt(1),
+ HYPESQUAD_EVENTS: BigInt(1) << BigInt(2),
+ BUGHUNTER_LEVEL_1: BigInt(1) << BigInt(3),
+ HOUSE_BRAVERY: BigInt(1) << BigInt(6),
+ HOUSE_BRILLIANCE: BigInt(1) << BigInt(7),
+ HOUSE_BALANCE: BigInt(1) << BigInt(8),
+ EARLY_SUPPORTER: BigInt(1) << BigInt(9),
+ TEAM_USER: BigInt(1) << BigInt(10),
+ SYSTEM: BigInt(1) << BigInt(12),
+ BUGHUNTER_LEVEL_2: BigInt(1) << BigInt(14),
+ VERIFIED_BOT: BigInt(1) << BigInt(16),
+ EARLY_VERIFIED_BOT_DEVELOPER: BigInt(1) << BigInt(17),
+ };
+}
diff --git a/util/src/entities/VoiceState.ts b/util/src/entities/VoiceState.ts
new file mode 100644
index 00000000..c5040cf1
--- /dev/null
+++ b/util/src/entities/VoiceState.ts
@@ -0,0 +1,56 @@
+import { Column, Entity, JoinColumn, ManyToOne, RelationId } from "typeorm";
+import { BaseClass } from "./BaseClass";
+import { Channel } from "./Channel";
+import { Guild } from "./Guild";
+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;
+
+ @Column({ nullable: true })
+ @RelationId((voice_state: VoiceState) => voice_state.channel)
+ channel_id: string;
+
+ @JoinColumn({ name: "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;
+
+ @Column()
+ session_id: string;
+
+ @Column()
+ deaf: boolean;
+
+ @Column()
+ mute: boolean;
+
+ @Column()
+ self_deaf: boolean;
+
+ @Column()
+ self_mute: boolean;
+
+ @Column({ nullable: true })
+ self_stream?: boolean;
+
+ @Column()
+ self_video: boolean;
+
+ @Column()
+ suppress: boolean; // whether this user is muted by the current user
+}
diff --git a/util/src/entities/Webhook.ts b/util/src/entities/Webhook.ts
new file mode 100644
index 00000000..12ba0d08
--- /dev/null
+++ b/util/src/entities/Webhook.ts
@@ -0,0 +1,69 @@
+import { Column, Entity, JoinColumn, ManyToOne, RelationId } from "typeorm";
+import { Application } from "./Application";
+import { BaseClass } from "./BaseClass";
+import { Channel } from "./Channel";
+import { Guild } from "./Guild";
+import { User } from "./User";
+
+export enum WebhookType {
+ Incoming = 1,
+ ChannelFollower = 2,
+}
+
+@Entity("webhooks")
+export class Webhook extends BaseClass {
+ @Column()
+ id: string;
+
+ @Column({ type: "simple-enum", enum: WebhookType })
+ type: WebhookType;
+
+ @Column({ nullable: true })
+ name?: string;
+
+ @Column({ nullable: true })
+ avatar?: string;
+
+ @Column({ nullable: true })
+ token?: string;
+
+ @Column({ nullable: true })
+ @RelationId((webhook: Webhook) => webhook.guild)
+ guild_id: string;
+
+ @JoinColumn({ name: "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;
+
+ @Column({ nullable: true })
+ @RelationId((webhook: Webhook) => webhook.application)
+ application_id: string;
+
+ @JoinColumn({ name: "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;
+
+ @Column({ nullable: true })
+ @RelationId((webhook: Webhook) => webhook.guild)
+ source_guild_id: string;
+
+ @JoinColumn({ name: "source_guild_id" })
+ @ManyToOne(() => Guild)
+ source_guild: Guild;
+}
diff --git a/util/src/entities/index.ts b/util/src/entities/index.ts
new file mode 100644
index 00000000..aa37ae2e
--- /dev/null
+++ b/util/src/entities/index.ts
@@ -0,0 +1,25 @@
+export * from "./Application";
+export * from "./Attachment";
+export * from "./AuditLog";
+export * from "./Ban";
+export * from "./BaseClass";
+export * from "./Channel";
+export * from "./Config";
+export * from "./ConnectedAccount";
+export * from "./Emoji";
+export * from "./Guild";
+export * from "./Invite";
+export * from "./Member";
+export * from "./Message";
+export * from "./RateLimit";
+export * from "./ReadState";
+export * from "./Recipient";
+export * from "./Relationship";
+export * from "./Role";
+export * from "./Sticker";
+export * from "./Team";
+export * from "./TeamMember";
+export * from "./Template";
+export * from "./User";
+export * from "./VoiceState";
+export * from "./Webhook";
|
