feat: invite tracking in log messages

Author: virtual-designer

src/main/typescript/schemas/GuildConfigSchema.ts

@@ -240,32 +240,6 @@ export const GuildConfigSchema = z.object({
         })
         .optional()
     /*
-    
-    logging: z
-        .object({
-            enabled: z.boolean().default(false),
-            bulk_delete_send_json: z.boolean().default(true),
-            primary_channel: zSnowflake.optional(),
-            message_logging_channel: zSnowflake.optional(),
-            infraction_logging_channel: zSnowflake.optional(),
-            join_leave_channel: zSnowflake.optional(),
-            saved_messages_channel: zSnowflake.optional(),
-            events: z
-                .object({
-                    message_edit: z.boolean().default(true),
-                    message_delete: z.boolean().default(true),
-                    member_join: z.boolean().default(true),
-                    member_leave: z.boolean().default(true),
-                    message_bulk_delete: z.boolean().default(true)
-                })
-                .default({
-                    message_edit: true,
-                    member_leave: true,
-                    member_join: true,
-                    message_delete: true
-                })
-        })
-        .optional(),
     message_reporting: z
         .object({
             enabled: z.boolean().default(false),
@@ -293,11 +267,6 @@ export const GuildConfigSchema = z.object({
                 .default({})
         })
         .optional(),
-    invite_tracking: z
-        .object({
-            enabled: z.boolean().default(false)
-        })
-        .optional(),
     message_filter: z
         .object({
             enabled: z.boolean().default(false),

src/main/typescript/services/AuditLoggingService.ts

@@ -1034,6 +1034,23 @@ class AuditLoggingService extends Service {
             }
         ];
 
+        const invite = await this.application
+            .service("inviteTrackingService")
+            .findInviteForMember(member);
+
+        if (invite) {
+            let value = `**Link:** ${invite.url}\n`;
+
+            value += `Inviter: ${invite.inviterId ? `<@${invite.inviterId}> (${invite.inviterId})` : "*Unavailable*"}\n`;
+            value += `Uses: ${invite.uses} / ${invite.maxUses ?? "∞"}\n`;
+            value += `Expires: ${invite.expiresAt ? time(invite.expiresAt, "R") : "*Unavailable*"}`;
+
+            fields.push({
+                name: "Invite Information",
+                value
+            });
+        }
+
         return this.send({
             guildId: member.guild.id,
             messageCreateOptions: {

src/main/typescript/services/InviteTrackingService.ts

@@ -1,12 +1,20 @@
-import { Service } from "@framework/services/Service";
+import { GatewayEventListener } from "@framework/events/GatewayEventListener";
 import { Name } from "@framework/services/Name";
-import { Collection, type Guild, type Invite, type ReadonlyCollection, Snowflake } from "discord.js";
+import { Service } from "@framework/services/Service";
 import type { HasEventListeners } from "@framework/types/HasEventListeners";
-import { GatewayEventListener } from "@framework/events/GatewayEventListener";
+import {
+    Collection,
+    GuildMember,
+    Snowflake,
+    type Guild,
+    type Invite,
+    type ReadonlyCollection
+} from "discord.js";
 
 @Name("inviteTrackingService")
 class InviteTrackingService extends Service implements HasEventListeners {
     private readonly _invites = new Collection<`${Snowflake}::${string}`, InviteInfo>();
+    private readonly _uses = new Collection<`${Snowflake}::${string}`, number>();
 
     public get invites(): ReadonlyCollection<`${Snowflake}::${string}`, InviteInfo> {
         return this._invites;
@@ -20,7 +28,8 @@ class InviteTrackingService extends Service implements HasEventListeners {
                 this._invites.set(`${guild.id}::${invite.code}`, {
                     type: "general",
                     invite,
-                    guildId: guild.id
+                    guildId: guild.id,
+                    uses: invite.uses ?? 0
                 });
             }
 
@@ -43,10 +52,15 @@ class InviteTrackingService extends Service implements HasEventListeners {
             return;
         }
 
+        if (invite.inviterId) {
+            this._uses.set(`${invite.guild.id}::${invite.code}`, 0);
+        }
+
         this._invites.set(`${invite.guild.id}::${invite.code}`, {
             type: "general",
             invite,
-            guildId: invite.guild.id
+            guildId: invite.guild.id,
+            uses: invite.uses ?? 0
         });
     }
 
@@ -57,6 +71,7 @@ class InviteTrackingService extends Service implements HasEventListeners {
         }
 
         this._invites.delete(`${invite.guild.id}::${invite.code}`);
+        this._uses.delete(`${invite.guild.id}::${invite.code}`);
     }
 
     @GatewayEventListener("guildUpdate")
@@ -76,18 +91,39 @@ class InviteTrackingService extends Service implements HasEventListeners {
             }
         }
     }
-}
 
-export type InviteInfo = {
-    type: "general";
-    invite: Invite;
-    guildId: string;
-} | {
-    type: "vanity";
-    code: string;
-    uses: number;
-    guildId: string;
-};
+    public async findInviteForMember(member: GuildMember) {
+        const invites = await member.guild.invites.fetch();
+
+        for (const invite of invites.values()) {
+            const existingUses = this._uses.get(`${member.guild.id}::${invite.code}`);
+
+            if (existingUses === undefined || invite.uses === null) {
+                continue;
+            }
+
+            if (invite.uses > existingUses) {
+                this._uses.set(`${member.guild.id}::${invite.code}`, invite.uses);
+                return invite;
+            }
+        }
+
+        return null;
+    }
+}
 
+export type InviteInfo =
+    | {
+          type: "general";
+          invite: Invite;
+          guildId: string;
+          uses: number;
+      }
+    | {
+          type: "vanity";
+          code: string;
+          uses: number;
+          guildId: string;
+      };
 
-export default InviteTrackingService;
+export default InviteTrackingService;

src/main/typescript/types/Services.ts

@@ -23,6 +23,7 @@ import type AntiMemberJoinService from "@main/automod/AntiMemberJoinService";
 import type VerificationService from "@main/automod/VerificationService";
 import type AuditLoggingService from "@main/services/AuditLoggingService";
 import type DirectiveParsingService from "@main/services/DirectiveParsingService";
+import type InviteTrackingService from "@main/services/InviteTrackingService";
 import type SystemAuditLoggingService from "@main/services/SystemAuditLoggingService";
 import type ChannelLockManager from "../services/ChannelLockManager";
 import type CommandManager from "../services/CommandManager";
@@ -57,6 +58,7 @@ export interface ServiceRecord {
     snippetManagerService: SnippetManagerService;
     antiMemberJoinService: AntiMemberJoinService;
     verificationService: VerificationService;
+    inviteTrackingService: InviteTrackingService;
 }
 
 interface ServiceRecordLocal extends ServiceRecord {}