feat: Introduce modular inventory item effect handling and centralize Discord interaction routing.

src/modules/inventory/effects/handlers.ts

@@ -0,0 +1,62 @@
+import { levelingService } from "@/modules/leveling/leveling.service";
+import { economyService } from "@/modules/economy/economy.service";
+import { userTimers } from "@/db/schema";
+import type { EffectHandler } from "./types";
+
+// Helper to extract duration in seconds
+const getDuration = (effect: any): number => {
+    if (effect.durationHours) return effect.durationHours * 3600;
+    if (effect.durationMinutes) return effect.durationMinutes * 60;
+    return effect.durationSeconds || 60; // Default to 60s if nothing provided
+};
+
+export const handleAddXp: EffectHandler = async (userId, effect, txFn) => {
+    await levelingService.addXp(userId, BigInt(effect.amount), txFn);
+    return `Gained ${effect.amount} XP`;
+};
+
+export const handleAddBalance: EffectHandler = async (userId, effect, txFn) => {
+    await economyService.modifyUserBalance(userId, BigInt(effect.amount), 'ITEM_USE', `Used Item`, null, txFn);
+    return `Gained ${effect.amount} 🪙`;
+};
+
+export const handleReplyMessage: EffectHandler = async (_userId, effect, _txFn) => {
+    return effect.message;
+};
+
+export const handleXpBoost: EffectHandler = async (userId, effect, txFn) => {
+    const boostDuration = getDuration(effect);
+    const expiresAt = new Date(Date.now() + boostDuration * 1000);
+    await txFn.insert(userTimers).values({
+        userId: BigInt(userId),
+        type: 'EFFECT',
+        key: 'xp_boost',
+        expiresAt: expiresAt,
+        metadata: { multiplier: effect.multiplier }
+    }).onConflictDoUpdate({
+        target: [userTimers.userId, userTimers.type, userTimers.key],
+        set: { expiresAt: expiresAt, metadata: { multiplier: effect.multiplier } }
+    });
+    return `XP Boost (${effect.multiplier}x) active for ${Math.floor(boostDuration / 60)}m`;
+};
+
+export const handleTempRole: EffectHandler = async (userId, effect, txFn) => {
+    const roleDuration = getDuration(effect);
+    const roleExpiresAt = new Date(Date.now() + roleDuration * 1000);
+    await txFn.insert(userTimers).values({
+        userId: BigInt(userId),
+        type: 'ACCESS',
+        key: `role_${effect.roleId}`,
+        expiresAt: roleExpiresAt,
+        metadata: { roleId: effect.roleId }
+    }).onConflictDoUpdate({
+        target: [userTimers.userId, userTimers.type, userTimers.key],
+        set: { expiresAt: roleExpiresAt }
+    });
+    // Actual role assignment happens in the Command layer
+    return `Temporary Role granted for ${Math.floor(roleDuration / 60)}m`;
+};
+
+export const handleColorRole: EffectHandler = async (_userId, _effect, _txFn) => {
+    return "Color Role Equipped";
+};

src/modules/inventory/effects/registry.ts

@@ -0,0 +1,18 @@
+import {
+    handleAddXp,
+    handleAddBalance,
+    handleReplyMessage,
+    handleXpBoost,
+    handleTempRole,
+    handleColorRole
+} from "./handlers";
+import type { EffectHandler } from "./types";
+
+export const effectHandlers: Record<string, EffectHandler> = {
+    'ADD_XP': handleAddXp,
+    'ADD_BALANCE': handleAddBalance,
+    'REPLY_MESSAGE': handleReplyMessage,
+    'XP_BOOST': handleXpBoost,
+    'TEMP_ROLE': handleTempRole,
+    'COLOR_ROLE': handleColorRole
+};

src/modules/inventory/effects/types.ts

@@ -0,0 +1,4 @@
+
+import type { Transaction } from "@/lib/types";
+
+export type EffectHandler = (userId: string, effect: any, txFn: Transaction) => Promise<string>;

src/modules/inventory/inventory.service.ts

@@ -8,12 +8,7 @@ import { UserError } from "@/lib/errors";
 import { withTransaction } from "@/lib/db";
 import type { Transaction, ItemUsageData } from "@/lib/types";
 
-// Helper to extract duration in seconds
-const getDuration = (effect: any): number => {
-    if (effect.durationHours) return effect.durationHours * 3600;
-    if (effect.durationMinutes) return effect.durationMinutes * 60;
-    return effect.durationSeconds || 60; // Default to 60s if nothing provided
-};
+
 
 export const inventoryService = {
     addItem: async (userId: string, itemId: number, quantity: bigint = 1n, tx?: Transaction) => {
@@ -165,53 +160,17 @@ export const inventoryService = {
             const results: string[] = [];
 
             // 2. Apply Effects
+            // 2. Apply Effects
+            const { effectHandlers } = await import("./effects/registry");
+
             for (const effect of usageData.effects) {
-                switch (effect.type) {
-                    case 'ADD_XP':
-                        await levelingService.addXp(userId, BigInt(effect.amount), txFn);
-                        results.push(`Gained ${effect.amount} XP`);
-                        break;
-                    case 'ADD_BALANCE':
-                        await economyService.modifyUserBalance(userId, BigInt(effect.amount), 'ITEM_USE', `Used ${item.name}`, null, txFn);
-                        results.push(`Gained ${effect.amount} 🪙`);
-                        break;
-                    case 'REPLY_MESSAGE':
-                        results.push(effect.message);
-                        break;
-                    case 'XP_BOOST':
-                        const boostDuration = getDuration(effect);
-                        const expiresAt = new Date(Date.now() + boostDuration * 1000);
-                        await txFn.insert(userTimers).values({
-                            userId: BigInt(userId),
-                            type: 'EFFECT',
-                            key: 'xp_boost',
-                            expiresAt: expiresAt,
-                            metadata: { multiplier: effect.multiplier }
-                        }).onConflictDoUpdate({
-                            target: [userTimers.userId, userTimers.type, userTimers.key],
-                            set: { expiresAt: expiresAt, metadata: { multiplier: effect.multiplier } }
-                        });
-                        results.push(`XP Boost (${effect.multiplier}x) active for ${Math.floor(boostDuration / 60)}m`);
-                        break;
-                    case 'TEMP_ROLE':
-                        const roleDuration = getDuration(effect);
-                        const roleExpiresAt = new Date(Date.now() + roleDuration * 1000);
-                        await txFn.insert(userTimers).values({
-                            userId: BigInt(userId),
-                            type: 'ACCESS',
-                            key: `role_${effect.roleId}`,
-                            expiresAt: roleExpiresAt,
-                            metadata: { roleId: effect.roleId }
-                        }).onConflictDoUpdate({
-                            target: [userTimers.userId, userTimers.type, userTimers.key],
-                            set: { expiresAt: roleExpiresAt }
-                        });
-                        // Actual role assignment happens in the Command layer
-                        results.push(`Temporary Role granted for ${Math.floor(roleDuration / 60)}m`);
-                        break;
-                    case 'COLOR_ROLE':
-                        results.push("Color Role Equipped");
-                        break;
+                const handler = effectHandlers[effect.type];
+                if (handler) {
+                    const result = await handler(userId, effect, txFn);
+                    results.push(result);
+                } else {
+                    console.warn(`No handler found for effect type: ${effect.type}`);
+                    results.push(`Effect ${effect.type} applied (no description)`);
                 }
             }