gambling-bot-shared 1.0.5 → 1.0.7

package/dist/dev/guildDataWipe.d.ts

@@ -0,0 +1,29 @@
+export type GuildWipeEntity = 'all' | 'users' | 'transactions' | 'atm' | 'raffles' | 'predictions' | 'vip' | 'blackjack';
+export type GuildDataWipeDeleteResult = {
+    deletedCount?: number;
+};
+export type GuildDataWipeModel = {
+    deleteMany: (filter: {
+        guildId: string;
+    }) => Promise<GuildDataWipeDeleteResult>;
+};
+export type GuildDataWipeModels = {
+    transactions: GuildDataWipeModel;
+    atmRequests: GuildDataWipeModel;
+    raffles: GuildDataWipeModel;
+    predictions: GuildDataWipeModel;
+    vipRooms: GuildDataWipeModel;
+    blackjackGames: GuildDataWipeModel;
+    users: GuildDataWipeModel;
+};
+export type GuildDataWipeSummary = {
+    entities: GuildWipeEntity[];
+    deleted: Record<string, number>;
+};
+export declare function normalizeGuildWipeEntities(entities: GuildWipeEntity[]): Exclude<GuildWipeEntity, 'all'>[];
+export declare function runGuildDataWipe({ guildId, entities, models }: {
+    guildId: string;
+    entities: GuildWipeEntity[];
+    models: GuildDataWipeModels;
+}): Promise<GuildDataWipeSummary>;
+export declare function formatGuildDataWipeSummary(summary: GuildDataWipeSummary): string;

package/dist/dev/guildDataWipe.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeGuildWipeEntities = normalizeGuildWipeEntities;
+exports.runGuildDataWipe = runGuildDataWipe;
+exports.formatGuildDataWipeSummary = formatGuildDataWipeSummary;
+const formatters_1 = require("../common/formatters");
+const WIPE_ENTITY_ORDER = [
+    'transactions',
+    'atm',
+    'raffles',
+    'predictions',
+    'vip',
+    'blackjack',
+    'users'
+];
+const ENTITY_TO_MODEL_KEY = {
+    transactions: 'transactions',
+    atm: 'atmRequests',
+    raffles: 'raffles',
+    predictions: 'predictions',
+    vip: 'vipRooms',
+    blackjack: 'blackjackGames',
+    users: 'users'
+};
+const WIPE_LABELS = {
+    transactions: 'Transactions',
+    atmRequests: 'ATM requests',
+    raffles: 'Raffles',
+    predictions: 'Predictions',
+    vipRooms: 'VIP rooms',
+    blackjackGames: 'Blackjack games',
+    users: 'Users'
+};
+async function countDeleted(result) {
+    return result.deletedCount ?? 0;
+}
+function normalizeGuildWipeEntities(entities) {
+    const withoutAll = entities.filter((entity) => entity !== 'all');
+    if (withoutAll.length !== entities.length) {
+        return [...WIPE_ENTITY_ORDER];
+    }
+    const selected = new Set(withoutAll);
+    return WIPE_ENTITY_ORDER.filter((entity) => selected.has(entity));
+}
+function buildWipeTargets(guildId, entities, models) {
+    const selected = new Set(entities);
+    return WIPE_ENTITY_ORDER.filter((entity) => selected.has(entity)).map((entity) => {
+        const key = ENTITY_TO_MODEL_KEY[entity];
+        return {
+            key,
+            label: WIPE_LABELS[key],
+            entity,
+            run: async () => countDeleted(await models[key].deleteMany({ guildId }))
+        };
+    });
+}
+async function runGuildDataWipe({ guildId, entities, models }) {
+    const normalizedEntities = normalizeGuildWipeEntities(entities);
+    const targets = buildWipeTargets(guildId, normalizedEntities, models);
+    const deleted = {};
+    for (const target of targets) {
+        deleted[target.key] = await target.run();
+    }
+    return {
+        entities: normalizedEntities,
+        deleted
+    };
+}
+function formatGuildDataWipeSummary(summary) {
+    const lines = Object.entries(summary.deleted)
+        .filter(([, count]) => count > 0)
+        .map(([key, count]) => `• **${WIPE_LABELS[key] ?? key}**: ${(0, formatters_1.formatNumberToReadableString)(count)} removed`);
+    if (lines.length === 0) {
+        return 'Nothing to remove — guild operational data was already empty.';
+    }
+    return lines.join('\n');
+}

package/dist/dev/index.d.ts

@@ -1,4 +1,5 @@
 export * from './devAccess';
 export * from './bonusStressTest';
 export * from './casinoMonteCarlo';
+export * from './guildDataWipe';
 export * from './yieldToEventLoop';

package/dist/dev/index.js

@@ -17,4 +17,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./devAccess"), exports);
 __exportStar(require("./bonusStressTest"), exports);
 __exportStar(require("./casinoMonteCarlo"), exports);
+__exportStar(require("./guildDataWipe"), exports);
 __exportStar(require("./yieldToEventLoop"), exports);

package/dist/guild/guildConfiguration.mongoose.d.ts

@@ -81,6 +81,15 @@ export declare const GuildConfigurationSchema: Schema<TGuildConfiguration, impor
     }, "id"> & {
         id: string;
     }> | undefined;
+    bannedRoleId?: import("mongoose").SchemaDefinitionProperty<string, TGuildConfiguration, import("mongoose").Document<unknown, {}, TGuildConfiguration, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TGuildConfiguration & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
     casinoSettings?: import("mongoose").SchemaDefinitionProperty<{
         dice: {
             winMultiplier: number;

package/dist/guild/guildConfiguration.mongoose.js

@@ -53,6 +53,10 @@ exports.GuildConfigurationSchema = new mongoose_1.Schema({
         type: String,
         default: ''
     },
+    bannedRoleId: {
+        type: String,
+        default: ''
+    },
     casinoSettings: {
         type: mongoose_1.Schema.Types.Mixed,
         default: defaultConfig_1.defaultCasinoSettings

package/dist/guild/schemas/guild.forms.d.ts

@@ -19,6 +19,7 @@ export declare const channelsFormSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const managerRoleFormSchema: z.ZodObject<{
     managerRoleId: z.ZodString;
+    bannedRoleId: z.ZodString;
 }, z.core.$strip>;
 export declare const globalSettingsFormSchema: z.ZodObject<{
     disableRegistrations: z.ZodBoolean;

package/dist/guild/schemas/guild.forms.js

@@ -17,7 +17,8 @@ exports.channelsFormSchema = zod_1.default.object({
     raffle: raffle_forms_1.raffleChannelsFormSchema
 });
 exports.managerRoleFormSchema = zod_1.default.object({
-    managerRoleId: zod_1.default.string()
+    managerRoleId: zod_1.default.string(),
+    bannedRoleId: zod_1.default.string()
 });
 exports.globalSettingsFormSchema = zod_1.default.object({
     disableRegistrations: zod_1.default.boolean(),

package/dist/guild/types/guildConfiguration.d.ts

@@ -19,6 +19,7 @@ export type TGuildConfiguration = {
         logs: string;
     };
     managerRoleId: string;
+    bannedRoleId: string;
     casinoSettings: typeof defaultCasinoSettings;
     vipSettings: {
         roleOwnerId: string;

package/dist/transactions/constants/staffAudit.d.ts

@@ -8,7 +8,10 @@ export declare const STAFF_ADMIN_ACTIONS: {
     readonly PREDICTION_PAYOUT: "prediction-payout";
     readonly PREDICTION_CANCEL: "prediction-cancel";
     readonly ATM_REJECT: "atm-reject";
+    readonly USER_BAN: "user-ban";
+    readonly USER_UNBAN: "user-unban";
+    readonly USER_NOTE: "user-note";
 };
 export type StaffAdminAction = (typeof STAFF_ADMIN_ACTIONS)[keyof typeof STAFF_ADMIN_ACTIONS];
-export declare const STAFF_ACTION_CATEGORIES: readonly ["balance", "atm", "vip", "raffle", "prediction"];
+export declare const STAFF_ACTION_CATEGORIES: readonly ["balance", "atm", "vip", "raffle", "prediction", "user"];
 export type StaffActionCategory = (typeof STAFF_ACTION_CATEGORIES)[number];

package/dist/transactions/constants/staffAudit.js

@@ -10,12 +10,16 @@ exports.STAFF_ADMIN_ACTIONS = {
     PREDICTION_END: 'prediction-end',
     PREDICTION_PAYOUT: 'prediction-payout',
     PREDICTION_CANCEL: 'prediction-cancel',
-    ATM_REJECT: 'atm-reject'
+    ATM_REJECT: 'atm-reject',
+    USER_BAN: 'user-ban',
+    USER_UNBAN: 'user-unban',
+    USER_NOTE: 'user-note'
 };
 exports.STAFF_ACTION_CATEGORIES = [
     'balance',
     'atm',
     'vip',
     'raffle',
-    'prediction'
+    'prediction',
+    'user'
 ];

package/dist/user/index.d.ts

@@ -1 +1,2 @@
 export * from './types/user';
+export * from './utils/userModeration';

package/dist/user/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types/user"), exports);
+__exportStar(require("./utils/userModeration"), exports);

package/dist/user/types/user.d.ts

@@ -1,3 +1,15 @@
+export type TUserStaffNote = {
+    text: string;
+    authorId: string;
+    createdAt: Date;
+};
+export type TUserBanHistoryEntry = {
+    bannedAt: Date;
+    bannedBy: string;
+    unbannedAt: Date | null;
+    unbannedBy: string | null;
+    reason?: string;
+};
 export type TUser = {
     userId: string;
     guildId: string;
@@ -6,6 +18,11 @@ export type TUser = {
     lockedBalance: number;
     lastDailyClaim: Date | null;
     dailyStreak: number;
+    banned: boolean;
+    bannedAt: Date | null;
+    bannedBy: string | null;
+    banHistory: TUserBanHistoryEntry[];
+    staffNotes: TUserStaffNote[];
     createdAt: Date;
     updatedAt: Date;
 };

package/dist/user/user.mongoose.d.ts

@@ -72,6 +72,51 @@ export declare const UserSchema: Schema<TUser, import("mongoose").Model<TUser, a
     }, "id"> & {
         id: string;
     }> | undefined;
+    banned?: import("mongoose").SchemaDefinitionProperty<boolean, TUser, import("mongoose").Document<unknown, {}, TUser, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TUser & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    bannedAt?: import("mongoose").SchemaDefinitionProperty<Date | null, TUser, import("mongoose").Document<unknown, {}, TUser, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TUser & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    bannedBy?: import("mongoose").SchemaDefinitionProperty<string | null, TUser, import("mongoose").Document<unknown, {}, TUser, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TUser & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    banHistory?: import("mongoose").SchemaDefinitionProperty<import("./types/user").TUserBanHistoryEntry[], TUser, import("mongoose").Document<unknown, {}, TUser, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TUser & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    staffNotes?: import("mongoose").SchemaDefinitionProperty<import("./types/user").TUserStaffNote[], TUser, import("mongoose").Document<unknown, {}, TUser, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TUser & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
     createdAt?: import("mongoose").SchemaDefinitionProperty<Date, TUser, import("mongoose").Document<unknown, {}, TUser, {
         id: string;
     }, import("mongoose").DefaultSchemaOptions> & Omit<TUser & {

package/dist/user/user.mongoose.js

@@ -2,6 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserSchema = void 0;
 const mongoose_1 = require("mongoose");
+const UserStaffNoteSchema = new mongoose_1.Schema({
+    text: { type: String, required: true },
+    authorId: { type: String, required: true },
+    createdAt: { type: Date, required: true }
+}, { _id: false });
+const UserBanHistoryEntrySchema = new mongoose_1.Schema({
+    bannedAt: { type: Date, required: true },
+    bannedBy: { type: String, required: true },
+    unbannedAt: { type: Date, default: null },
+    unbannedBy: { type: String, default: null },
+    reason: { type: String }
+}, { _id: false });
 exports.UserSchema = new mongoose_1.Schema({
     userId: { type: String, required: true },
     guildId: { type: String, required: true },
@@ -9,6 +21,11 @@ exports.UserSchema = new mongoose_1.Schema({
     bonusBalance: { type: Number, default: 0 }, // BONUS (non-withdrawable)
     lockedBalance: { type: Number, default: 0 }, // ONLY for in-flight bets
     lastDailyClaim: { type: Date, default: null },
-    dailyStreak: { type: Number, default: 0 }
+    dailyStreak: { type: Number, default: 0 },
+    banned: { type: Boolean, default: false },
+    bannedAt: { type: Date, default: null },
+    bannedBy: { type: String, default: null },
+    banHistory: { type: [UserBanHistoryEntrySchema], default: [] },
+    staffNotes: { type: [UserStaffNoteSchema], default: [] }
 }, { timestamps: true });
 exports.UserSchema.index({ userId: 1, guildId: 1 }, { unique: true });

package/dist/user/utils/userModeration.d.ts

@@ -0,0 +1,16 @@
+import type { TUser, TUserBanHistoryEntry, TUserStaffNote } from '../types/user';
+export declare const USER_BANNED_ERROR = "USER_BANNED";
+export declare const USER_BANNED_MESSAGE = "Your account is restricted. Contact server staff.";
+export declare function isUserBanned(user: Pick<TUser, 'banned'>): boolean;
+export declare function normalizeStaffNote(text: string): string | null;
+export declare function appendStaffNote(notes: TUserStaffNote[], entry: TUserStaffNote, maxNotes?: number): TUserStaffNote[];
+export declare function startBanHistoryEntry({ history, bannedBy, reason, maxEntries }: {
+    history: TUserBanHistoryEntry[];
+    bannedBy: string;
+    reason?: string;
+    maxEntries?: number;
+}): TUserBanHistoryEntry[];
+export declare function closeLatestBanHistoryEntry({ history, unbannedBy }: {
+    history: TUserBanHistoryEntry[];
+    unbannedBy: string;
+}): TUserBanHistoryEntry[];

package/dist/user/utils/userModeration.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USER_BANNED_MESSAGE = exports.USER_BANNED_ERROR = void 0;
+exports.isUserBanned = isUserBanned;
+exports.normalizeStaffNote = normalizeStaffNote;
+exports.appendStaffNote = appendStaffNote;
+exports.startBanHistoryEntry = startBanHistoryEntry;
+exports.closeLatestBanHistoryEntry = closeLatestBanHistoryEntry;
+exports.USER_BANNED_ERROR = 'USER_BANNED';
+exports.USER_BANNED_MESSAGE = 'Your account is restricted. Contact server staff.';
+function isUserBanned(user) {
+    return Boolean(user.banned);
+}
+function normalizeStaffNote(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return null;
+    return trimmed.slice(0, 500);
+}
+function appendStaffNote(notes, entry, maxNotes = 50) {
+    return [entry, ...notes].slice(0, maxNotes);
+}
+function startBanHistoryEntry({ history, bannedBy, reason, maxEntries = 50 }) {
+    const entry = {
+        bannedAt: new Date(),
+        bannedBy,
+        unbannedAt: null,
+        unbannedBy: null,
+        ...(reason ? { reason } : {})
+    };
+    return [entry, ...history].slice(0, maxEntries);
+}
+function closeLatestBanHistoryEntry({ history, unbannedBy }) {
+    const openIndex = history.findIndex((entry) => entry.unbannedAt === null);
+    if (openIndex === -1)
+        return history;
+    const updated = [...history];
+    updated[openIndex] = {
+        ...updated[openIndex],
+        unbannedAt: new Date(),
+        unbannedBy
+    };
+    return updated;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gambling-bot-shared",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "license": "MIT",
   "type": "commonjs",
   "repository": {