gambling-bot-shared 1.0.6 → 1.0.8

package/README.MD

@@ -44,7 +44,7 @@ See [docs/LOCAL_DEVELOPMENT.md](./docs/LOCAL_DEVELOPMENT.md) for the local linki
 
 ## Package imports
 
-Domain subpath exports only — see [docs/ARCHITECTURE.md](./docs/ARCHITECTURE.md) for the domain map.
+Domain subpath exports only - see [docs/ARCHITECTURE.md](./docs/ARCHITECTURE.md) for the domain map.
 
 ## GitHub / CI
 

package/dist/dev/guildDataWipe.d.ts

@@ -0,0 +1,30 @@
+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;
+    userBans: 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,88 @@
+"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',
+    userBans: 'User bans',
+    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)).flatMap((entity) => {
+        const targets = [];
+        if (entity === 'users') {
+            targets.push({
+                key: 'userBans',
+                label: WIPE_LABELS.userBans,
+                entity,
+                run: async () => countDeleted(await models.userBans.deleteMany({ guildId }))
+            });
+        }
+        const key = ENTITY_TO_MODEL_KEY[entity];
+        targets.push({
+            key,
+            label: WIPE_LABELS[key],
+            entity,
+            run: async () => countDeleted(await models[key].deleteMany({ guildId }))
+        });
+        return targets;
+    });
+}
+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/mongoose/index.d.ts

@@ -1,4 +1,5 @@
 export { UserSchema } from '../user/user.mongoose';
+export { UserBanSchema } from '../user/userBan.mongoose';
 export { VipRoomSchema } from '../vip/vipRoom.mongoose';
 export { PredictionSchema } from '../predictions/prediction.mongoose';
 export { TransactionSchema } from '../transactions/transaction.mongoose';

package/dist/mongoose/index.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BlackjackGameSchema = exports.RaffleSchema = exports.AtmRequestSchema = exports.GuildConfigurationSchema = exports.TransactionSchema = exports.PredictionSchema = exports.VipRoomSchema = exports.UserSchema = void 0;
+exports.BlackjackGameSchema = exports.RaffleSchema = exports.AtmRequestSchema = exports.GuildConfigurationSchema = exports.TransactionSchema = exports.PredictionSchema = exports.VipRoomSchema = exports.UserBanSchema = exports.UserSchema = void 0;
 var user_mongoose_1 = require("../user/user.mongoose");
 Object.defineProperty(exports, "UserSchema", { enumerable: true, get: function () { return user_mongoose_1.UserSchema; } });
+var userBan_mongoose_1 = require("../user/userBan.mongoose");
+Object.defineProperty(exports, "UserBanSchema", { enumerable: true, get: function () { return userBan_mongoose_1.UserBanSchema; } });
 var vipRoom_mongoose_1 = require("../vip/vipRoom.mongoose");
 Object.defineProperty(exports, "VipRoomSchema", { enumerable: true, get: function () { return vipRoom_mongoose_1.VipRoomSchema; } });
 var prediction_mongoose_1 = require("../predictions/prediction.mongoose");

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

@@ -10,8 +10,10 @@ export declare const STAFF_ADMIN_ACTIONS: {
     readonly ATM_REJECT: "atm-reject";
     readonly USER_BAN: "user-ban";
     readonly USER_UNBAN: "user-unban";
-    readonly USER_NOTE: "user-note";
+    readonly USER_NOTE_CREATE: "user-note-create";
+    readonly USER_NOTE_UPDATE: "user-note-update";
+    readonly USER_NOTE_DELETE: "user-note-delete";
 };
 export type StaffAdminAction = (typeof STAFF_ADMIN_ACTIONS)[keyof typeof STAFF_ADMIN_ACTIONS];
-export declare const STAFF_ACTION_CATEGORIES: readonly ["balance", "atm", "vip", "raffle", "prediction", "user"];
+export declare const STAFF_ACTION_CATEGORIES: readonly ["balance", "atm", "vip", "raffle", "prediction", "ban", "unban", "user"];
 export type StaffActionCategory = (typeof STAFF_ACTION_CATEGORIES)[number];

package/dist/transactions/constants/staffAudit.js

@@ -13,7 +13,9 @@ exports.STAFF_ADMIN_ACTIONS = {
     ATM_REJECT: 'atm-reject',
     USER_BAN: 'user-ban',
     USER_UNBAN: 'user-unban',
-    USER_NOTE: 'user-note'
+    USER_NOTE_CREATE: 'user-note-create',
+    USER_NOTE_UPDATE: 'user-note-update',
+    USER_NOTE_DELETE: 'user-note-delete'
 };
 exports.STAFF_ACTION_CATEGORIES = [
     'balance',
@@ -21,5 +23,7 @@ exports.STAFF_ACTION_CATEGORIES = [
     'vip',
     'raffle',
     'prediction',
+    'ban',
+    'unban',
     'user'
 ];

package/dist/user/index.d.ts

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

package/dist/user/index.js

@@ -16,3 +16,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);
+__exportStar(require("./userBan"), exports);

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

@@ -1,15 +1,9 @@
 export type TUserStaffNote = {
+    noteId: string;
     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;
@@ -21,7 +15,6 @@ export type TUser = {
     banned: boolean;
     bannedAt: Date | null;
     bannedBy: string | null;
-    banHistory: TUserBanHistoryEntry[];
     staffNotes: TUserStaffNote[];
     createdAt: Date;
     updatedAt: Date;

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

@@ -0,0 +1,13 @@
+export type TUserBan = {
+    banId: string;
+    guildId: string;
+    userId: string;
+    bannedAt: Date;
+    bannedBy: string;
+    banReason?: string;
+    unbannedAt: Date | null;
+    unbannedBy: string | null;
+    unbanReason?: string;
+    createdAt: Date;
+    updatedAt: Date;
+};

package/dist/user/types/userBan.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -99,15 +99,6 @@ export declare const UserSchema: Schema<TUser, import("mongoose").Model<TUser, a
     }, "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 & {

package/dist/user/user.mongoose.js

@@ -3,17 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserSchema = void 0;
 const mongoose_1 = require("mongoose");
 const UserStaffNoteSchema = new mongoose_1.Schema({
+    noteId: { type: String, required: true },
     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 },
@@ -25,7 +19,6 @@ exports.UserSchema = new mongoose_1.Schema({
     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/userBan.d.ts

@@ -0,0 +1,2 @@
+export * from './types/userBan';
+export * from './utils/userBan';

package/dist/user/userBan.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types/userBan"), exports);
+__exportStar(require("./utils/userBan"), exports);

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

@@ -0,0 +1,111 @@
+import { Schema } from 'mongoose';
+import { TUserBan } from './types/userBan';
+export declare const UserBanSchema: Schema<TUserBan, import("mongoose").Model<TUserBan, any, any, any, any, any, TUserBan>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, TUserBan, import("mongoose").Document<unknown, {}, TUserBan, {
+    id: string;
+}, import("mongoose").DefaultSchemaOptions> & Omit<TUserBan & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}, "id"> & {
+    id: string;
+}, {
+    banId?: import("mongoose").SchemaDefinitionProperty<string, TUserBan, import("mongoose").Document<unknown, {}, TUserBan, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TUserBan & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    guildId?: import("mongoose").SchemaDefinitionProperty<string, TUserBan, import("mongoose").Document<unknown, {}, TUserBan, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TUserBan & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    userId?: import("mongoose").SchemaDefinitionProperty<string, TUserBan, import("mongoose").Document<unknown, {}, TUserBan, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TUserBan & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    bannedAt?: import("mongoose").SchemaDefinitionProperty<Date, TUserBan, import("mongoose").Document<unknown, {}, TUserBan, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TUserBan & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    bannedBy?: import("mongoose").SchemaDefinitionProperty<string, TUserBan, import("mongoose").Document<unknown, {}, TUserBan, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TUserBan & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    banReason?: import("mongoose").SchemaDefinitionProperty<string | undefined, TUserBan, import("mongoose").Document<unknown, {}, TUserBan, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TUserBan & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    unbannedAt?: import("mongoose").SchemaDefinitionProperty<Date | null, TUserBan, import("mongoose").Document<unknown, {}, TUserBan, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TUserBan & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    unbannedBy?: import("mongoose").SchemaDefinitionProperty<string | null, TUserBan, import("mongoose").Document<unknown, {}, TUserBan, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TUserBan & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    unbanReason?: import("mongoose").SchemaDefinitionProperty<string | undefined, TUserBan, import("mongoose").Document<unknown, {}, TUserBan, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TUserBan & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    createdAt?: import("mongoose").SchemaDefinitionProperty<Date, TUserBan, import("mongoose").Document<unknown, {}, TUserBan, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TUserBan & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    updatedAt?: import("mongoose").SchemaDefinitionProperty<Date, TUserBan, import("mongoose").Document<unknown, {}, TUserBan, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TUserBan & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+}, TUserBan>;

package/dist/user/userBan.mongoose.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserBanSchema = void 0;
+const mongoose_1 = require("mongoose");
+exports.UserBanSchema = new mongoose_1.Schema({
+    banId: { type: String, required: true },
+    guildId: { type: String, required: true },
+    userId: { type: String, required: true },
+    bannedAt: { type: Date, required: true },
+    bannedBy: { type: String, required: true },
+    banReason: { type: String },
+    unbannedAt: { type: Date, default: null },
+    unbannedBy: { type: String, default: null },
+    unbanReason: { type: String }
+}, { timestamps: true });
+exports.UserBanSchema.index({ banId: 1, guildId: 1 }, { unique: true });
+exports.UserBanSchema.index({ guildId: 1, userId: 1, bannedAt: -1 });
+exports.UserBanSchema.index({ guildId: 1, userId: 1, unbannedAt: 1 });

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

@@ -0,0 +1,3 @@
+import type { TUserBan } from '../types/userBan';
+export declare function normalizeBanReason(reason?: string | null): string | undefined;
+export declare function isUserBanActive(ban: Pick<TUserBan, 'unbannedAt'>): boolean;

package/dist/user/utils/userBan.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeBanReason = normalizeBanReason;
+exports.isUserBanActive = isUserBanActive;
+const userModeration_1 = require("./userModeration");
+function normalizeBanReason(reason) {
+    const normalized = reason ? (0, userModeration_1.normalizeStaffNote)(reason) : null;
+    return normalized ?? undefined;
+}
+function isUserBanActive(ban) {
+    return ban.unbannedAt === null;
+}

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

@@ -1,16 +1,17 @@
-import type { TUser, TUserBanHistoryEntry, TUserStaffNote } from '../types/user';
+import type { TUser, 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 createStaffNoteEntry(text: string, authorId: string): TUserStaffNote | null;
+type StaffNoteLike = {
+    noteId?: string;
+    text: string;
+    authorId: string;
+    createdAt?: Date | string;
+};
+export declare function normalizeStaffNotes(notes: StaffNoteLike[]): TUserStaffNote[];
 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[];
+export declare function updateStaffNote(notes: TUserStaffNote[], noteId: string, text: string): TUserStaffNote[] | null;
+export declare function removeStaffNote(notes: TUserStaffNote[], noteId: string): TUserStaffNote[] | null;
+export {};

package/dist/user/utils/userModeration.js

@@ -3,9 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.USER_BANNED_MESSAGE = exports.USER_BANNED_ERROR = void 0;
 exports.isUserBanned = isUserBanned;
 exports.normalizeStaffNote = normalizeStaffNote;
+exports.createStaffNoteEntry = createStaffNoteEntry;
+exports.normalizeStaffNotes = normalizeStaffNotes;
 exports.appendStaffNote = appendStaffNote;
-exports.startBanHistoryEntry = startBanHistoryEntry;
-exports.closeLatestBanHistoryEntry = closeLatestBanHistoryEntry;
+exports.updateStaffNote = updateStaffNote;
+exports.removeStaffNote = removeStaffNote;
+const generateId_1 = require("../../common/generateId");
 exports.USER_BANNED_ERROR = 'USER_BANNED';
 exports.USER_BANNED_MESSAGE = 'Your account is restricted. Contact server staff.';
 function isUserBanned(user) {
@@ -17,28 +20,49 @@ function normalizeStaffNote(text) {
         return null;
     return trimmed.slice(0, 500);
 }
+function createStaffNoteEntry(text, authorId) {
+    const normalized = normalizeStaffNote(text);
+    if (!normalized)
+        return null;
+    return {
+        noteId: (0, generateId_1.generateId)(),
+        text: normalized,
+        authorId,
+        createdAt: new Date()
+    };
+}
+function normalizeStaffNotes(notes) {
+    return notes.flatMap((note) => {
+        const text = normalizeStaffNote(note.text);
+        if (!text || !note.authorId)
+            return [];
+        return [
+            {
+                noteId: typeof note.noteId === 'string' && note.noteId.length > 0
+                    ? note.noteId
+                    : (0, generateId_1.generateId)(),
+                text,
+                authorId: note.authorId,
+                createdAt: note.createdAt ? new Date(note.createdAt) : new Date()
+            }
+        ];
+    });
+}
 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
-    };
+function updateStaffNote(notes, noteId, text) {
+    const normalized = normalizeStaffNote(text);
+    if (!normalized)
+        return null;
+    const index = notes.findIndex((note) => note.noteId === noteId);
+    if (index === -1)
+        return null;
+    const updated = [...notes];
+    updated[index] = { ...updated[index], text: normalized };
     return updated;
 }
+function removeStaffNote(notes, noteId) {
+    const next = notes.filter((note) => note.noteId !== noteId);
+    return next.length === notes.length ? null : next;
+}

package/package.json

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