refactor: initial moves

shared/lib/config.ts

@@ -0,0 +1,204 @@
+import { readFileSync, existsSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { z } from 'zod';
+
+const configPath = join(import.meta.dir, '..', '..', 'config', 'config.json');
+
+export interface GameConfigType {
+    leveling: {
+        base: number;
+        exponent: number;
+        chat: {
+            cooldownMs: number;
+            minXp: number;
+            maxXp: number;
+        }
+    },
+    economy: {
+        daily: {
+            amount: bigint;
+            streakBonus: bigint;
+            weeklyBonus: bigint;
+            cooldownMs: number;
+        },
+        transfers: {
+            allowSelfTransfer: boolean;
+            minAmount: bigint;
+        },
+        exam: {
+            multMin: number;
+            multMax: number;
+        }
+    },
+    inventory: {
+        maxStackSize: bigint;
+        maxSlots: number;
+    },
+    commands: Record<string, boolean>;
+    lootdrop: {
+        activityWindowMs: number;
+        minMessages: number;
+        spawnChance: number;
+        cooldownMs: number;
+        reward: {
+            min: number;
+            max: number;
+            currency: string;
+        }
+    };
+    studentRole: string;
+    visitorRole: string;
+    colorRoles: string[];
+    welcomeChannelId?: string;
+    welcomeMessage?: string;
+    feedbackChannelId?: string;
+    terminal?: {
+        channelId: string;
+        messageId: string;
+    };
+    moderation: {
+        prune: {
+            maxAmount: number;
+            confirmThreshold: number;
+            batchSize: number;
+            batchDelayMs: number;
+        };
+        cases: {
+            dmOnWarn: boolean;
+            logChannelId?: string;
+            autoTimeoutThreshold?: number;
+        };
+    };
+    system: Record<string, any>;
+}
+
+// Initial default config state
+export const config: GameConfigType = {} as GameConfigType;
+
+const bigIntSchema = z.union([z.string(), z.number(), z.bigint()])
+    .refine((val) => {
+        try {
+            BigInt(val);
+            return true;
+        } catch {
+            return false;
+        }
+    }, { message: "Must be a valid integer" })
+    .transform((val) => BigInt(val));
+
+const configSchema = z.object({
+    leveling: z.object({
+        base: z.number(),
+        exponent: z.number(),
+        chat: z.object({
+            cooldownMs: z.number(),
+            minXp: z.number(),
+            maxXp: z.number(),
+        })
+    }),
+    economy: z.object({
+        daily: z.object({
+            amount: bigIntSchema,
+            streakBonus: bigIntSchema,
+            weeklyBonus: bigIntSchema.default(50n),
+            cooldownMs: z.number(),
+        }),
+        transfers: z.object({
+            allowSelfTransfer: z.boolean(),
+            minAmount: bigIntSchema,
+        }),
+        exam: z.object({
+            multMin: z.number(),
+            multMax: z.number(),
+        })
+    }),
+    inventory: z.object({
+        maxStackSize: bigIntSchema,
+        maxSlots: z.number(),
+    }),
+    commands: z.record(z.string(), z.boolean()),
+    lootdrop: z.object({
+        activityWindowMs: z.number(),
+        minMessages: z.number(),
+        spawnChance: z.number(),
+        cooldownMs: z.number(),
+        reward: z.object({
+            min: z.number(),
+            max: z.number(),
+            currency: z.string(),
+        })
+
+    }),
+    studentRole: z.string(),
+    visitorRole: z.string(),
+    colorRoles: z.array(z.string()).default([]),
+    welcomeChannelId: z.string().optional(),
+    welcomeMessage: z.string().optional(),
+    feedbackChannelId: z.string().optional(),
+    terminal: z.object({
+        channelId: z.string(),
+        messageId: z.string()
+    }).optional(),
+    moderation: z.object({
+        prune: z.object({
+            maxAmount: z.number().default(100),
+            confirmThreshold: z.number().default(50),
+            batchSize: z.number().default(100),
+            batchDelayMs: z.number().default(1000)
+        }),
+        cases: z.object({
+            dmOnWarn: z.boolean().default(true),
+            logChannelId: z.string().optional(),
+            autoTimeoutThreshold: z.number().optional()
+        })
+    }).default({
+        prune: {
+            maxAmount: 100,
+            confirmThreshold: 50,
+            batchSize: 100,
+            batchDelayMs: 1000
+        },
+        cases: {
+            dmOnWarn: true
+        }
+    }),
+    system: z.record(z.string(), z.any()).default({}),
+});
+
+export function reloadConfig() {
+    if (!existsSync(configPath)) {
+        throw new Error(`Config file not found at ${configPath}`);
+    }
+
+    const raw = readFileSync(configPath, 'utf-8');
+    const rawConfig = JSON.parse(raw);
+
+    // Update config object in place
+    // We use Object.assign to keep the reference to the exported 'config' object same
+    const validatedConfig = configSchema.parse(rawConfig);
+    Object.assign(config, validatedConfig);
+
+    console.log("🔄 Config reloaded from disk.");
+}
+
+// Initial load
+reloadConfig();
+
+// Backwards compatibility alias
+export const GameConfig = config;
+
+export function saveConfig(newConfig: unknown) {
+    // Validate and transform input
+    const validatedConfig = configSchema.parse(newConfig);
+
+    const replacer = (key: string, value: any) => {
+        if (typeof value === 'bigint') {
+            return value.toString();
+        }
+        return value;
+    };
+
+    const jsonString = JSON.stringify(validatedConfig, replacer, 4);
+    writeFileSync(configPath, jsonString, 'utf-8');
+    reloadConfig();
+}