src/utils/LayerBasedPermissionManager.ts

import { PermissionOverwrite } from "@prisma/client";
import { GuildMember, PermissionsBitField, PermissionsString, Role, Snowflake } from "discord.js";
import { GetMemberPermissionInGuildResult } from "../services/PermissionManager";
import AbstractPermissionManager from "./AbstractPermissionManager";
import { logInfo } from "./logger";

export default class LayerBasedPermissionManager extends AbstractPermissionManager {
    protected cache: Record<`${Snowflake}_${"r" | "u"}_${Snowflake}`, PermissionOverwrite> = {};

    async sync() {
        const overwrites = await this.client.prisma.permissionOverwrite.findMany();

        this.cache = {};

        for (const overwrite of overwrites) {
            for (const roleId of overwrite.roles) {
                this.cache[`${overwrite.guildId}_r_${roleId}`] = overwrite;
            }

            for (const userId of overwrite.users) {
                this.cache[`${overwrite.guildId}_u_${userId}`] = overwrite;
            }
        }

        logInfo(`[${this.constructor.name}] Synchronized permission overwrites`);
    }

    isImmuneToAutoMod(member: GuildMember) {
        const { permissions } = this.getMemberPermissions(member);
        return permissions.has("ManageGuild", true);
    }

    // FIXME: This is not implemented yet
    shouldModerate(member: GuildMember, moderator: GuildMember) {
        return true;
    }

    getMemberPermissions(member: GuildMember, mergeWithDiscordPermissions = true): GetMemberPermissionInGuildResult {
        const overwriteIds = [];
        const baseUserOverwrite = this.cache[`${member.guild.id}_u_${member.user.id}`];
        const permissions = new PermissionsBitField([
            ...(mergeWithDiscordPermissions ? member.permissions.toArray() : []),
            ...((baseUserOverwrite?.grantedPermissions as PermissionsString[]) ?? [])
        ]);
        let highestRoleHavingOverwrite: Role | undefined;
        let highestOverwrite: PermissionOverwrite | undefined;

        if (baseUserOverwrite) {
            overwriteIds.push(baseUserOverwrite.id);
        }

        for (const [roleId, role] of member.roles.cache) {
            const overwrite = this.cache[`${member.guild.id}_r_${roleId}`];

            if (overwrite) {
                overwriteIds.push(overwrite.id);

                for (const permission of overwrite.grantedPermissions) {
                    permissions.add(permission as PermissionsString);
                }

                if (role.position > (highestRoleHavingOverwrite?.position ?? 0)) {
                    highestRoleHavingOverwrite = role;
                    highestOverwrite = overwrite;
                }
            }
        }

        return {
            type: "layered",
            permissions,
            highestRoleHavingOverwrite,
            highestOverwrite,
            overwriteIds
        };
    }
}
1	import { PermissionOverwrite } from "@prisma/client";
2	import { GuildMember, PermissionsBitField, PermissionsString, Role, Snowflake } from "discord.js";
3	import { GetMemberPermissionInGuildResult } from "../services/PermissionManager";
4	import AbstractPermissionManager from "./AbstractPermissionManager";
5	import { logInfo } from "./logger";
6
7	export default class LayerBasedPermissionManager extends AbstractPermissionManager {
8	protected cache: Record<`${Snowflake}_${"r" \| "u"}_${Snowflake}`, PermissionOverwrite> = {};
9
10	async sync() {
11	const overwrites = await this.client.prisma.permissionOverwrite.findMany();
12
13	this.cache = {};
14
15	for (const overwrite of overwrites) {
16	for (const roleId of overwrite.roles) {
17	this.cache[`${overwrite.guildId}_r_${roleId}`] = overwrite;
18	}
19
20	for (const userId of overwrite.users) {
21	this.cache[`${overwrite.guildId}_u_${userId}`] = overwrite;
22	}
23	}
24
25	logInfo(`[${this.constructor.name}] Synchronized permission overwrites`);
26	}
27
28	isImmuneToAutoMod(member: GuildMember) {
29	const { permissions } = this.getMemberPermissions(member);
30	return permissions.has("ManageGuild", true);
31	}
32
33	// FIXME: This is not implemented yet
34	shouldModerate(member: GuildMember, moderator: GuildMember) {
35	return true;
36	}
37
38	getMemberPermissions(member: GuildMember, mergeWithDiscordPermissions = true): GetMemberPermissionInGuildResult {
39	const overwriteIds = [];
40	const baseUserOverwrite = this.cache[`${member.guild.id}_u_${member.user.id}`];
41	const permissions = new PermissionsBitField([
42	...(mergeWithDiscordPermissions ? member.permissions.toArray() : []),
43	...((baseUserOverwrite?.grantedPermissions as PermissionsString[]) ?? [])
44	]);
45	let highestRoleHavingOverwrite: Role \| undefined;
46	let highestOverwrite: PermissionOverwrite \| undefined;
47
48	if (baseUserOverwrite) {
49	overwriteIds.push(baseUserOverwrite.id);
50	}
51
52	for (const [roleId, role] of member.roles.cache) {
53	const overwrite = this.cache[`${member.guild.id}_r_${roleId}`];
54
55	if (overwrite) {
56	overwriteIds.push(overwrite.id);
57
58	for (const permission of overwrite.grantedPermissions) {
59	permissions.add(permission as PermissionsString);
60	}
61
62	if (role.position > (highestRoleHavingOverwrite?.position ?? 0)) {
63	highestRoleHavingOverwrite = role;
64	highestOverwrite = overwrite;
65	}
66	}
67	}
68
69	return {
70	type: "layered",
71	permissions,
72	highestRoleHavingOverwrite,
73	highestOverwrite,
74	overwriteIds
75	};
76	}
77	}