chore: update prettier tab width for consistency (#175)

packages/api/utils/guild.ts

@@ -1,163 +1,163 @@
 import { evaluatePermission, permissions } from '@roleypoly/misc-utils/hasPermission';
 import {
-    Features,
-    Guild,
-    GuildData as GuildDataT,
-    OwnRoleInfo,
-    Role,
-    RoleSafety,
+  Features,
+  Guild,
+  GuildData as GuildDataT,
+  OwnRoleInfo,
+  Role,
+  RoleSafety,
 } from '@roleypoly/types';
 import { AuthType, cacheLayer, discordFetch } from './api-tools';
 import { botClientID, botToken } from './config';
 import { GuildData, Guilds } from './kv';
 
 type APIGuild = {
-    // Only relevant stuff
-    id: string;
-    name: string;
-    icon: string;
-    roles: APIRole[];
+  // Only relevant stuff
+  id: string;
+  name: string;
+  icon: string;
+  roles: APIRole[];
 };
 
 type APIRole = {
-    id: string;
-    name: string;
-    color: number;
-    position: number;
-    permissions: string;
-    managed: boolean;
+  id: string;
+  name: string;
+  color: number;
+  position: number;
+  permissions: string;
+  managed: boolean;
 };
 
 export const getGuild = cacheLayer(
-    Guilds,
-    (id: string) => `guilds/${id}`,
-    async (id: string) => {
-        const guildRaw = await discordFetch<APIGuild>(
-            `/guilds/${id}`,
-            botToken,
-            AuthType.Bot
-        );
+  Guilds,
+  (id: string) => `guilds/${id}`,
+  async (id: string) => {
+    const guildRaw = await discordFetch<APIGuild>(
+      `/guilds/${id}`,
+      botToken,
+      AuthType.Bot
+    );
 
-        if (!guildRaw) {
-            return null;
-        }
+    if (!guildRaw) {
+      return null;
+    }
 
-        const botMemberRoles =
-            (await getGuildMemberRoles({
-                serverID: id,
-                userID: botClientID,
-            })) || [];
+    const botMemberRoles =
+      (await getGuildMemberRoles({
+        serverID: id,
+        userID: botClientID,
+      })) || [];
 
-        const highestRolePosition = botMemberRoles.reduce<number>((highest, roleID) => {
-            const role = guildRaw.roles.find((guildRole) => guildRole.id === roleID);
-            if (!role) {
-                return highest;
-            }
+    const highestRolePosition = botMemberRoles.reduce<number>((highest, roleID) => {
+      const role = guildRaw.roles.find((guildRole) => guildRole.id === roleID);
+      if (!role) {
+        return highest;
+      }
 
-            // If highest is a bigger number, it stays the highest.
-            if (highest > role.position) {
-                return highest;
-            }
+      // If highest is a bigger number, it stays the highest.
+      if (highest > role.position) {
+        return highest;
+      }
 
-            return role.position;
-        }, 0);
+      return role.position;
+    }, 0);
 
-        const roles = guildRaw.roles.map<Role>((role) => ({
-            id: role.id,
-            name: role.name,
-            color: role.color,
-            managed: role.managed,
-            position: role.position,
-            permissions: role.permissions,
-            safety: calculateRoleSafety(role, highestRolePosition),
-        }));
+    const roles = guildRaw.roles.map<Role>((role) => ({
+      id: role.id,
+      name: role.name,
+      color: role.color,
+      managed: role.managed,
+      position: role.position,
+      permissions: role.permissions,
+      safety: calculateRoleSafety(role, highestRolePosition),
+    }));
 
-        // Filters the raw guild data into data we actually want
-        const guild: Guild & OwnRoleInfo = {
-            id: guildRaw.id,
-            name: guildRaw.name,
-            icon: guildRaw.icon,
-            roles,
-            highestRolePosition,
-        };
+    // Filters the raw guild data into data we actually want
+    const guild: Guild & OwnRoleInfo = {
+      id: guildRaw.id,
+      name: guildRaw.name,
+      icon: guildRaw.icon,
+      roles,
+      highestRolePosition,
+    };
 
-        return guild;
-    },
-    60 * 60 * 2 // 2 hour TTL
+    return guild;
+  },
+  60 * 60 * 2 // 2 hour TTL
 );
 
 type GuildMemberIdentity = {
-    serverID: string;
-    userID: string;
+  serverID: string;
+  userID: string;
 };
 
 type APIMember = {
-    // Only relevant stuff, again.
-    roles: string[];
+  // Only relevant stuff, again.
+  roles: string[];
 };
 
 const guildMemberRolesIdentity = ({ serverID, userID }: GuildMemberIdentity) =>
-    `guilds/${serverID}/members/${userID}/roles`;
+  `guilds/${serverID}/members/${userID}/roles`;
 
 export const getGuildMemberRoles = cacheLayer<GuildMemberIdentity, Role['id'][]>(
-    Guilds,
-    guildMemberRolesIdentity,
-    async ({ serverID, userID }) => {
-        const discordMember = await discordFetch<APIMember>(
-            `/guilds/${serverID}/members/${userID}`,
-            botToken,
-            AuthType.Bot
-        );
+  Guilds,
+  guildMemberRolesIdentity,
+  async ({ serverID, userID }) => {
+    const discordMember = await discordFetch<APIMember>(
+      `/guilds/${serverID}/members/${userID}`,
+      botToken,
+      AuthType.Bot
+    );
 
-        if (!discordMember) {
-            return null;
-        }
+    if (!discordMember) {
+      return null;
+    }
 
-        return discordMember.roles;
-    },
-    60 * 5 // 5 minute TTL
+    return discordMember.roles;
+  },
+  60 * 5 // 5 minute TTL
 );
 
 export const updateGuildMemberRoles = async (
-    identity: GuildMemberIdentity,
-    roles: Role['id'][]
+  identity: GuildMemberIdentity,
+  roles: Role['id'][]
 ) => {
-    await Guilds.put(guildMemberRolesIdentity(identity), roles, 60 * 5);
+  await Guilds.put(guildMemberRolesIdentity(identity), roles, 60 * 5);
 };
 
 export const getGuildData = async (id: string): Promise<GuildDataT> => {
-    const guildData = await GuildData.get<GuildDataT>(id);
+  const guildData = await GuildData.get<GuildDataT>(id);
 
-    if (!guildData) {
-        return {
-            id,
-            message: '',
-            categories: [],
-            features: Features.None,
-        };
-    }
+  if (!guildData) {
+    return {
+      id,
+      message: '',
+      categories: [],
+      features: Features.None,
+    };
+  }
 
-    return guildData;
+  return guildData;
 };
 
 const calculateRoleSafety = (role: Role | APIRole, highestBotRolePosition: number) => {
-    let safety = RoleSafety.Safe;
+  let safety = RoleSafety.Safe;
 
-    if (role.managed) {
-        safety |= RoleSafety.ManagedRole;
-    }
+  if (role.managed) {
+    safety |= RoleSafety.ManagedRole;
+  }
 
-    if (role.position > highestBotRolePosition) {
-        safety |= RoleSafety.HigherThanBot;
-    }
+  if (role.position > highestBotRolePosition) {
+    safety |= RoleSafety.HigherThanBot;
+  }
 
-    const permBigInt = BigInt(role.permissions);
-    if (
-        evaluatePermission(permBigInt, permissions.ADMINISTRATOR) ||
-        evaluatePermission(permBigInt, permissions.MANAGE_ROLES)
-    ) {
-        safety |= RoleSafety.DangerousPermissions;
-    }
+  const permBigInt = BigInt(role.permissions);
+  if (
+    evaluatePermission(permBigInt, permissions.ADMINISTRATOR) ||
+    evaluatePermission(permBigInt, permissions.MANAGE_ROLES)
+  ) {
+    safety |= RoleSafety.DangerousPermissions;
+  }
 
-    return safety;
+  return safety;
 };