@helyx/module-reactionroles 1.0.1

package/dist/records.js

@@ -0,0 +1,623 @@
+import { randomUUID } from "node:crypto";
+import { MODULE_ID } from "./constants.js";
+export const reactionRoleRecords = {
+    panels: {
+        table: "reactionroles_panels",
+        fields: {
+            panel_id: { type: "string" },
+            guild_id: { type: "string" },
+            channel_id: { type: "string" },
+            message_id: { type: "string", optional: true },
+            title: { type: "string" },
+            message_body: { type: "string" },
+            message_style: { type: "string" },
+            control_type: { type: "string" },
+            selection_mode: { type: "string" },
+            persistent_reactions: { type: "boolean" },
+            embed_colour: { type: "number", optional: true },
+            dropdown_placeholder: { type: "string", optional: true },
+            status: { type: "string" },
+            revision: { type: "number" },
+            created_by_user_id: { type: "string", optional: true },
+            updated_by_user_id: { type: "string", optional: true },
+            created_at: { type: "date" },
+            updated_at: { type: "date" },
+        },
+        uniqueKeys: [["panel_id"], ["guild_id", "message_id"]],
+        readableFields: [
+            "panel_id",
+            "guild_id",
+            "channel_id",
+            "message_id",
+            "title",
+            "message_body",
+            "message_style",
+            "control_type",
+            "selection_mode",
+            "persistent_reactions",
+            "embed_colour",
+            "dropdown_placeholder",
+            "status",
+            "revision",
+            "created_by_user_id",
+            "updated_by_user_id",
+            "created_at",
+            "updated_at",
+        ],
+        writableFields: [
+            "channel_id",
+            "message_id",
+            "title",
+            "message_body",
+            "message_style",
+            "control_type",
+            "selection_mode",
+            "persistent_reactions",
+            "embed_colour",
+            "dropdown_placeholder",
+            "status",
+            "revision",
+            "updated_by_user_id",
+            "updated_at",
+        ],
+        orderKeys: [["updated_at", "panel_id"]],
+        groupableFields: ["status"],
+    },
+    entries: {
+        table: "reactionroles_entries",
+        fields: {
+            entry_id: { type: "string" },
+            panel_id: { type: "string" },
+            position: { type: "number" },
+            role_id: { type: "string" },
+            nameplate: { type: "string" },
+            emoji_kind: { type: "string", optional: true },
+            emoji_name: { type: "string", optional: true },
+            emoji_id: { type: "string", optional: true },
+            emoji_animated: { type: "boolean", optional: true },
+            button_style: { type: "string", optional: true },
+            created_at: { type: "date" },
+            updated_at: { type: "date" },
+        },
+        uniqueKeys: [
+            ["entry_id"],
+            ["panel_id", "position"],
+            ["panel_id", "role_id"],
+        ],
+        readableFields: [
+            "entry_id",
+            "panel_id",
+            "position",
+            "role_id",
+            "nameplate",
+            "emoji_kind",
+            "emoji_name",
+            "emoji_id",
+            "emoji_animated",
+            "button_style",
+            "created_at",
+            "updated_at",
+        ],
+        orderKeys: [["position", "entry_id"]],
+    },
+    message_cleanup: {
+        table: "reactionroles_message_cleanup",
+        fields: {
+            cleanup_id: { type: "string" },
+            guild_id: { type: "string" },
+            panel_id: { type: "string" },
+            channel_id: { type: "string" },
+            message_id: { type: "string" },
+            reason: { type: "string" },
+            attempts: { type: "number" },
+            next_attempt_at: { type: "date" },
+            created_at: { type: "date" },
+            completed_at: { type: "date", optional: true },
+        },
+        uniqueKeys: [
+            ["cleanup_id"],
+            ["guild_id", "channel_id", "message_id", "reason"],
+        ],
+        readableFields: [
+            "cleanup_id",
+            "guild_id",
+            "panel_id",
+            "channel_id",
+            "message_id",
+            "reason",
+            "attempts",
+            "next_attempt_at",
+            "created_at",
+            "completed_at",
+        ],
+        writableFields: ["attempts", "next_attempt_at", "completed_at"],
+        orderKeys: [["next_attempt_at", "cleanup_id"]],
+    },
+};
+const panelSelect = reactionRoleRecords.panels.readableFields;
+const entrySelect = reactionRoleRecords.entries.readableFields;
+const cleanupSelect = reactionRoleRecords.message_cleanup.readableFields;
+export class ReactionRolePanelRepository {
+    records;
+    constructor(records) {
+        this.records = records;
+    }
+    async create(input) {
+        const now = input.now ?? new Date();
+        const result = await this.records.replaceOwnedSet({
+            moduleId: MODULE_ID,
+            collection: "entries",
+            owner: { panel_id: input.panelId },
+            values: input.entries.map((entry, position) => entryValues(input.panelId, entry, position, now)),
+            uniqueBy: ["entry_id"],
+            parent: {
+                collection: "panels",
+                values: panelValues({
+                    panelId: input.panelId,
+                    guildId: input.guildId,
+                    actorUserId: input.actorUserId,
+                    draft: input.draft,
+                    ...(input.messageId ? { messageId: input.messageId } : {}),
+                    status: input.messageId ? "active" : "pending",
+                    revision: 1,
+                    now,
+                }),
+                uniqueBy: ["panel_id"],
+            },
+        });
+        return result.applied;
+    }
+    async update(input) {
+        const now = input.now ?? new Date();
+        const revision = input.panel.revision + 1;
+        const result = await this.records.replaceOwnedSet({
+            moduleId: MODULE_ID,
+            collection: "entries",
+            owner: { panel_id: input.panel.panelId },
+            values: input.entries.map((entry, position) => entryValues(input.panel.panelId, entry, position, now)),
+            uniqueBy: ["entry_id"],
+            guard: {
+                collection: "panels",
+                where: { panel_id: input.panel.panelId },
+                expected: { field: "revision", value: input.panel.revision },
+                values: {
+                    channel_id: input.draft.channelId,
+                    ...(input.messageId === null
+                        ? {}
+                        : { message_id: input.messageId ?? input.panel.messageId ?? "" }),
+                    title: input.draft.title,
+                    message_body: input.draft.messageBody,
+                    message_style: input.draft.messageStyle,
+                    control_type: input.draft.controlType,
+                    selection_mode: input.draft.selectionMode,
+                    persistent_reactions: input.draft.persistentReactions,
+                    ...(input.draft.embedColour === undefined
+                        ? {}
+                        : { embed_colour: input.draft.embedColour }),
+                    ...(input.draft.dropdownPlaceholder === undefined
+                        ? {}
+                        : { dropdown_placeholder: input.draft.dropdownPlaceholder }),
+                    status: input.status ?? input.panel.status,
+                    revision,
+                    updated_by_user_id: input.actorUserId,
+                    updated_at: now,
+                },
+            },
+        });
+        return result.applied;
+    }
+    async findById(guildId, panelId) {
+        const panel = await this.records.findOne({
+            moduleId: MODULE_ID,
+            collection: "panels",
+            select: panelSelect,
+            where: { panel_id: panelId },
+        });
+        if (!panel || panel.guild_id !== guildId)
+            return null;
+        return this.#withEntries(panel);
+    }
+    async findByMessage(guildId, messageId) {
+        const panel = await this.records.findOne({
+            moduleId: MODULE_ID,
+            collection: "panels",
+            select: panelSelect,
+            where: { guild_id: guildId, message_id: messageId },
+        });
+        return panel ? this.#withEntries(panel) : null;
+    }
+    async list(input) {
+        const page = await this.records.findMany({
+            moduleId: MODULE_ID,
+            collection: "panels",
+            select: panelSelect,
+            where: { guild_id: input.guildId },
+            orderBy: [
+                { field: "updated_at", direction: "desc" },
+                { field: "panel_id", direction: "asc" },
+            ],
+            ...(input.cursor ? { cursor: input.cursor } : {}),
+            limit: input.limit,
+        });
+        return {
+            panels: await Promise.all(page.records.map((panel) => this.#withEntries(panel))),
+            nextCursor: page.nextCursor,
+        };
+    }
+    async listReferences(input) {
+        const page = await this.records.findMany({
+            moduleId: MODULE_ID,
+            collection: "panels",
+            select: ["panel_id", "title", "status", "updated_at"],
+            where: { guild_id: input.guildId },
+            orderBy: [
+                { field: "updated_at", direction: "desc" },
+                { field: "panel_id", direction: "asc" },
+            ],
+            ...(input.cursor ? { cursor: input.cursor } : {}),
+            limit: Math.min(100, Math.max(1, input.limit)),
+        });
+        return {
+            panels: page.records.map((panel) => ({
+                panelId: requiredString(panel, "panel_id"),
+                title: requiredString(panel, "title"),
+                status: requiredEnum(panel, "status", [
+                    "pending",
+                    "active",
+                    "disabled",
+                    "message_missing",
+                    "needs_attention",
+                    "cleanup_pending",
+                    "deleting",
+                ]),
+                updatedAt: requiredDate(panel, "updated_at"),
+            })),
+            nextCursor: page.nextCursor,
+        };
+    }
+    async listByChannel(guildId, channelId, limit = 100) {
+        const page = await this.records.findMany({
+            moduleId: MODULE_ID,
+            collection: "panels",
+            select: panelSelect,
+            where: { guild_id: guildId, channel_id: channelId },
+            orderBy: [
+                { field: "updated_at", direction: "desc" },
+                { field: "panel_id", direction: "asc" },
+            ],
+            limit: Math.min(100, Math.max(1, limit)),
+        });
+        return Promise.all(page.records.map((panel) => this.#withEntries(panel)));
+    }
+    async listByRole(guildId, roleId, limit = 100) {
+        return this.#listByEntryField(guildId, "role_id", roleId, limit);
+    }
+    async listByEmoji(guildId, emojiId, limit = 100) {
+        return this.#listByEntryField(guildId, "emoji_id", emojiId, limit);
+    }
+    async listInteractive(input) {
+        const page = await this.records.findMany({
+            moduleId: MODULE_ID,
+            collection: "panels",
+            select: panelSelect,
+            where: { status: input.status },
+            orderBy: [
+                { field: "updated_at", direction: "asc" },
+                { field: "panel_id", direction: "asc" },
+            ],
+            ...(input.cursor ? { cursor: input.cursor } : {}),
+            limit: input.limit,
+        });
+        return {
+            panels: await Promise.all(page.records.map((panel) => this.#withEntries(panel))),
+            nextCursor: page.nextCursor,
+        };
+    }
+    async markStatus(input) {
+        return (await this.records.updateOne({
+            moduleId: MODULE_ID,
+            collection: "panels",
+            where: { panel_id: input.panelId },
+            expected: { field: "revision", value: input.expectedRevision },
+            values: {
+                status: input.status,
+                revision: input.expectedRevision + 1,
+                ...(input.actorUserId
+                    ? { updated_by_user_id: input.actorUserId }
+                    : {}),
+                updated_at: input.now ?? new Date(),
+            },
+        })).updated;
+    }
+    async remove(panelId, expectedRevision, actorUserId) {
+        const claimed = await this.claimDeleting(panelId, expectedRevision, actorUserId);
+        if (!claimed)
+            return false;
+        return this.deleteClaimed(panelId);
+    }
+    claimDeleting(panelId, expectedRevision, actorUserId) {
+        return this.markStatus({
+            panelId,
+            expectedRevision,
+            actorUserId,
+            status: "deleting",
+        });
+    }
+    async deleteClaimed(panelId) {
+        return ((await this.records.deleteMany({
+            moduleId: MODULE_ID,
+            collection: "panels",
+            where: { panel_id: panelId, status: "deleting" },
+            limit: 1,
+        })).deleted === 1);
+    }
+    async recordCleanup(input) {
+        const created = await this.records.appendUnique({
+            moduleId: MODULE_ID,
+            collection: "message_cleanup",
+            values: {
+                cleanup_id: randomUUID(),
+                guild_id: input.guildId,
+                panel_id: input.panelId,
+                channel_id: input.channelId,
+                message_id: input.messageId,
+                reason: input.reason,
+                attempts: 0,
+                next_attempt_at: input.now ?? new Date(),
+                created_at: input.now ?? new Date(),
+            },
+            uniqueBy: ["guild_id", "channel_id", "message_id", "reason"],
+        });
+        return created.created;
+    }
+    async listPendingCleanup(limit = 100) {
+        const page = await this.records.findMany({
+            moduleId: MODULE_ID,
+            collection: "message_cleanup",
+            select: cleanupSelect,
+            where: { completed_at: null },
+            orderBy: [
+                { field: "next_attempt_at", direction: "asc" },
+                { field: "cleanup_id", direction: "asc" },
+            ],
+            limit: Math.min(100, Math.max(1, limit)),
+        });
+        return page.records.map((row) => ({
+            cleanupId: requiredString(row, "cleanup_id"),
+            guildId: requiredString(row, "guild_id"),
+            panelId: requiredString(row, "panel_id"),
+            channelId: requiredString(row, "channel_id"),
+            messageId: requiredString(row, "message_id"),
+            reason: requiredEnum(row, "reason", [
+                "replacement",
+                "rollback",
+                "delete",
+            ]),
+            attempts: requiredNumber(row, "attempts"),
+            nextAttemptAt: requiredDate(row, "next_attempt_at"),
+        }));
+    }
+    async claimCleanup(cleanup, now = new Date()) {
+        if (cleanup.attempts >= 10 ||
+            cleanup.nextAttemptAt.getTime() > now.getTime())
+            return null;
+        const attempts = cleanup.attempts + 1;
+        const claimed = await this.records.updateOne({
+            moduleId: MODULE_ID,
+            collection: "message_cleanup",
+            where: { cleanup_id: cleanup.cleanupId },
+            expected: { field: "attempts", value: cleanup.attempts },
+            values: {
+                attempts,
+                next_attempt_at: new Date(now.getTime() + Math.min(3_600_000, 30_000 * 2 ** cleanup.attempts)),
+            },
+        });
+        return claimed.updated ? { ...cleanup, attempts } : null;
+    }
+    async completeCleanup(cleanup, now = new Date()) {
+        return (await this.records.updateOne({
+            moduleId: MODULE_ID,
+            collection: "message_cleanup",
+            where: { cleanup_id: cleanup.cleanupId },
+            expected: { field: "attempts", value: cleanup.attempts },
+            values: { completed_at: now },
+        })).updated;
+    }
+    pendingCleanupCount(panelId) {
+        return this.records.count({
+            moduleId: MODULE_ID,
+            collection: "message_cleanup",
+            where: { panel_id: panelId, completed_at: null },
+        });
+    }
+    async #withEntries(panel) {
+        const entries = await this.records.findMany({
+            moduleId: MODULE_ID,
+            collection: "entries",
+            select: entrySelect,
+            where: { panel_id: requiredString(panel, "panel_id") },
+            orderBy: [
+                { field: "position", direction: "asc" },
+                { field: "entry_id", direction: "asc" },
+            ],
+            limit: 25,
+        });
+        return mapPanel(panel, entries.records);
+    }
+    async #listByEntryField(guildId, field, value, limit) {
+        const entries = await this.records.findMany({
+            moduleId: MODULE_ID,
+            collection: "entries",
+            select: ["panel_id"],
+            where: { [field]: value },
+            orderBy: [
+                { field: "position", direction: "asc" },
+                { field: "entry_id", direction: "asc" },
+            ],
+            limit: Math.min(100, Math.max(1, limit)),
+        });
+        const panels = await Promise.all(entries.records.map((entry) => this.findById(guildId, requiredString(entry, "panel_id"))));
+        return panels.filter((panel) => panel !== null);
+    }
+}
+function panelValues(input) {
+    return {
+        panel_id: input.panelId,
+        guild_id: input.guildId,
+        channel_id: input.draft.channelId,
+        ...(input.messageId ? { message_id: input.messageId } : {}),
+        title: input.draft.title,
+        message_body: input.draft.messageBody,
+        message_style: input.draft.messageStyle,
+        control_type: input.draft.controlType,
+        selection_mode: input.draft.selectionMode,
+        persistent_reactions: input.draft.persistentReactions,
+        ...(input.draft.embedColour === undefined
+            ? {}
+            : { embed_colour: input.draft.embedColour }),
+        ...(input.draft.dropdownPlaceholder === undefined
+            ? {}
+            : { dropdown_placeholder: input.draft.dropdownPlaceholder }),
+        status: input.status,
+        revision: input.revision,
+        created_by_user_id: input.actorUserId,
+        updated_by_user_id: input.actorUserId,
+        created_at: input.now,
+        updated_at: input.now,
+    };
+}
+function entryValues(panelId, entry, position, now) {
+    return {
+        entry_id: entry.entryId,
+        panel_id: panelId,
+        position,
+        role_id: entry.roleId,
+        nameplate: entry.nameplate,
+        ...(entry.emoji
+            ? {
+                emoji_kind: entry.emoji.kind,
+                emoji_name: entry.emoji.name,
+                ...(entry.emoji.id ? { emoji_id: entry.emoji.id } : {}),
+                emoji_animated: entry.emoji.animated,
+            }
+            : {}),
+        ...(entry.buttonStyle ? { button_style: entry.buttonStyle } : {}),
+        created_at: now,
+        updated_at: now,
+    };
+}
+function mapPanel(row, entries) {
+    return {
+        panelId: requiredString(row, "panel_id"),
+        guildId: requiredString(row, "guild_id"),
+        channelId: requiredString(row, "channel_id"),
+        messageId: nullableString(row, "message_id"),
+        title: requiredString(row, "title"),
+        messageBody: requiredString(row, "message_body"),
+        messageStyle: requiredEnum(row, "message_style", ["text", "embed"]),
+        controlType: requiredEnum(row, "control_type", [
+            "buttons",
+            "dropdown",
+            "reactions",
+        ]),
+        selectionMode: requiredEnum(row, "selection_mode", [
+            "multiple",
+            "one_only",
+        ]),
+        persistentReactions: optionalBoolean(row, "persistent_reactions", true),
+        ...(row.embed_colour === null
+            ? {}
+            : { embedColour: requiredNumber(row, "embed_colour") }),
+        ...(row.dropdown_placeholder === null
+            ? {}
+            : {
+                dropdownPlaceholder: requiredString(row, "dropdown_placeholder"),
+            }),
+        entries: entries.map((entry) => {
+            const emojiKind = nullableString(entry, "emoji_kind");
+            const emojiName = nullableString(entry, "emoji_name");
+            const emojiId = nullableString(entry, "emoji_id");
+            const emoji = emojiKind && emojiName
+                ? {
+                    kind: requiredLiteral(emojiKind, ["unicode", "custom"]),
+                    name: emojiName,
+                    ...(emojiId ? { id: emojiId } : {}),
+                    animated: entry.emoji_animated === true,
+                    identifier: emojiId ? `${emojiName}:${emojiId}` : emojiName,
+                    key: emojiId ? `custom:${emojiId}` : `unicode:${emojiName}`,
+                }
+                : null;
+            return {
+                entryId: requiredString(entry, "entry_id"),
+                roleId: requiredString(entry, "role_id"),
+                nameplate: requiredString(entry, "nameplate"),
+                ...(emoji ? { emoji: emoji.identifier } : {}),
+                ...(entry.button_style
+                    ? {
+                        buttonStyle: requiredEnum(entry, "button_style", [
+                            "primary",
+                            "secondary",
+                            "success",
+                            "danger",
+                        ]),
+                    }
+                    : {}),
+            };
+        }),
+        status: requiredEnum(row, "status", [
+            "pending",
+            "active",
+            "disabled",
+            "message_missing",
+            "needs_attention",
+            "cleanup_pending",
+            "deleting",
+        ]),
+        revision: requiredNumber(row, "revision"),
+        createdByUserId: nullableString(row, "created_by_user_id"),
+        updatedByUserId: nullableString(row, "updated_by_user_id"),
+        createdAt: requiredDate(row, "created_at"),
+        updatedAt: requiredDate(row, "updated_at"),
+    };
+}
+function requiredString(row, field) {
+    const value = row[field];
+    if (typeof value !== "string" || value.length === 0)
+        throw new Error(`Invalid Reaction Roles record field: ${field}`);
+    return value;
+}
+function nullableString(row, field) {
+    const value = row[field];
+    if (value === null || value === undefined)
+        return null;
+    return requiredString(row, field);
+}
+function requiredNumber(row, field) {
+    const value = Number(row[field]);
+    if (!Number.isSafeInteger(value))
+        throw new Error(`Invalid Reaction Roles record field: ${field}`);
+    return value;
+}
+function optionalBoolean(row, field, fallback) {
+    const value = row[field];
+    if (value === null || value === undefined)
+        return fallback;
+    if (typeof value !== "boolean")
+        throw new Error(`Invalid Reaction Roles record field: ${field}`);
+    return value;
+}
+function requiredDate(row, field) {
+    const value = row[field];
+    const date = value instanceof Date ? value : new Date(String(value));
+    if (Number.isNaN(date.getTime()))
+        throw new Error(`Invalid Reaction Roles record field: ${field}`);
+    return date;
+}
+function requiredEnum(row, field, values) {
+    return requiredLiteral(requiredString(row, field), values);
+}
+function requiredLiteral(value, values) {
+    if (!values.includes(value))
+        throw new Error("Invalid Reaction Roles record enum");
+    return value;
+}