@helyx/module-reactionroles 1.0.15 → 1.0.17

package/dist/records.js

@@ -1,151 +1,19 @@
-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;
+import { REACTION_ROLES_MODULE_ID } from "./constants.js";
+import { MessageCleanupRepository } from "./cleanup-repository.js";
+import { entrySelect, panelSelect } from "./record-schema.js";
+import { entryValues, mapPanel, panelValues, requiredDate, requiredEnum, requiredString, } from "./record-mapping.js";
+export { reactionRoleRecords, } from "./record-schema.js";
 export class ReactionRolePanelRepository {
     records;
+    #cleanup;
     constructor(records) {
         this.records = records;
+        this.#cleanup = new MessageCleanupRepository(records);
     }
     async create(input) {
         const now = input.now ?? new Date();
         const result = await this.records.replaceOwnedSet({
-            moduleId: MODULE_ID,
+            moduleId: REACTION_ROLES_MODULE_ID,
             collection: "entries",
             owner: { panel_id: input.panelId },
             values: input.entries.map((entry, position) => entryValues(input.panelId, entry, position, now)),
@@ -171,7 +39,7 @@ export class ReactionRolePanelRepository {
         const now = input.now ?? new Date();
         const revision = input.panel.revision + 1;
         const result = await this.records.replaceOwnedSet({
-            moduleId: MODULE_ID,
+            moduleId: REACTION_ROLES_MODULE_ID,
             collection: "entries",
             owner: { panel_id: input.panel.panelId },
             values: input.entries.map((entry, position) => entryValues(input.panel.panelId, entry, position, now)),
@@ -208,7 +76,7 @@ export class ReactionRolePanelRepository {
     }
     async findById(guildId, panelId) {
         const panel = await this.records.findOne({
-            moduleId: MODULE_ID,
+            moduleId: REACTION_ROLES_MODULE_ID,
             collection: "panels",
             select: panelSelect,
             where: { panel_id: panelId },
@@ -219,7 +87,7 @@ export class ReactionRolePanelRepository {
     }
     async findByMessage(guildId, messageId) {
         const panel = await this.records.findOne({
-            moduleId: MODULE_ID,
+            moduleId: REACTION_ROLES_MODULE_ID,
             collection: "panels",
             select: panelSelect,
             where: { guild_id: guildId, message_id: messageId },
@@ -228,7 +96,7 @@ export class ReactionRolePanelRepository {
     }
     async list(input) {
         const page = await this.records.findMany({
-            moduleId: MODULE_ID,
+            moduleId: REACTION_ROLES_MODULE_ID,
             collection: "panels",
             select: panelSelect,
             where: { guild_id: input.guildId },
@@ -246,7 +114,7 @@ export class ReactionRolePanelRepository {
     }
     async listReferences(input) {
         const page = await this.records.findMany({
-            moduleId: MODULE_ID,
+            moduleId: REACTION_ROLES_MODULE_ID,
             collection: "panels",
             select: ["panel_id", "title", "status", "updated_at"],
             where: { guild_id: input.guildId },
@@ -277,7 +145,7 @@ export class ReactionRolePanelRepository {
     }
     async listByChannel(guildId, channelId, limit = 100) {
         const page = await this.records.findMany({
-            moduleId: MODULE_ID,
+            moduleId: REACTION_ROLES_MODULE_ID,
             collection: "panels",
             select: panelSelect,
             where: { guild_id: guildId, channel_id: channelId },
@@ -297,7 +165,7 @@ export class ReactionRolePanelRepository {
     }
     async listInteractive(input) {
         const page = await this.records.findMany({
-            moduleId: MODULE_ID,
+            moduleId: REACTION_ROLES_MODULE_ID,
             collection: "panels",
             select: panelSelect,
             where: { status: input.status },
@@ -315,7 +183,7 @@ export class ReactionRolePanelRepository {
     }
     async markStatus(input) {
         return (await this.records.updateOne({
-            moduleId: MODULE_ID,
+            moduleId: REACTION_ROLES_MODULE_ID,
             collection: "panels",
             where: { panel_id: input.panelId },
             expected: { field: "revision", value: input.expectedRevision },
@@ -345,94 +213,36 @@ export class ReactionRolePanelRepository {
     }
     async deleteClaimed(panelId) {
         return ((await this.records.deleteMany({
-            moduleId: MODULE_ID,
+            moduleId: REACTION_ROLES_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;
+        return this.#cleanup.record(input);
     }
     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"),
-        }));
+        return this.#cleanup.list(limit);
+    }
+    listPendingCleanupPage(limit = 100, cursor) {
+        return this.#cleanup.listPage(limit, cursor);
+    }
+    findPendingCleanup(cleanupId) {
+        return this.#cleanup.find(cleanupId);
     }
     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;
+        return this.#cleanup.claim(cleanup, now);
     }
     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;
+        return this.#cleanup.complete(cleanup, now);
     }
     pendingCleanupCount(panelId) {
-        return this.records.count({
-            moduleId: MODULE_ID,
-            collection: "message_cleanup",
-            where: { panel_id: panelId, completed_at: null },
-        });
+        return this.#cleanup.count(panelId);
     }
     async #withEntries(panel) {
         const entries = await this.records.findMany({
-            moduleId: MODULE_ID,
+            moduleId: REACTION_ROLES_MODULE_ID,
             collection: "entries",
             select: entrySelect,
             where: { panel_id: requiredString(panel, "panel_id") },
@@ -449,7 +259,7 @@ export class ReactionRolePanelRepository {
             return [];
         const panelIds = panels.map((panel) => requiredString(panel, "panel_id"));
         const entries = await this.records.findManyByValues({
-            moduleId: MODULE_ID,
+            moduleId: REACTION_ROLES_MODULE_ID,
             collection: "entries",
             select: entrySelect,
             where: {},
@@ -472,7 +282,7 @@ export class ReactionRolePanelRepository {
     }
     async #listByEntryField(guildId, field, value, limit) {
         const entries = await this.records.findMany({
-            moduleId: MODULE_ID,
+            moduleId: REACTION_ROLES_MODULE_ID,
             collection: "entries",
             select: ["panel_id"],
             where: { [field]: value },
@@ -487,7 +297,7 @@ export class ReactionRolePanelRepository {
         if (uniquePanelIds.length === 0)
             return [];
         const panels = await this.records.findManyByValues({
-            moduleId: MODULE_ID,
+            moduleId: REACTION_ROLES_MODULE_ID,
             collection: "panels",
             select: panelSelect,
             where: { guild_id: guildId },
@@ -505,164 +315,3 @@ export class ReactionRolePanelRepository {
         });
     }
 }
-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;
-}

package/dist/runtime-state.d.ts

@@ -0,0 +1,9 @@
+import { ReactionRolesHealthTracker } from "./health.js";
+import type { ReactionRolesHealthSource } from "./health.js";
+import { PanelSnapshotCache, ReactionRolePanelService } from "./panel-service.js";
+export declare const reactionRoleCache: PanelSnapshotCache;
+export declare const reactionRolePanels: ReactionRolePanelService;
+export declare const reactionRoleMemberLocks: Map<string, Promise<void>>;
+export declare const reactionRoleHealth: ReactionRolesHealthTracker;
+export declare function runReactionRolePrimary<T>(operation: () => Promise<T>, source?: ReactionRolesHealthSource): Promise<T>;
+export declare function runReactionRoleFailureOnly<T>(operation: () => Promise<T>, source: ReactionRolesHealthSource): Promise<T>;

package/dist/runtime-state.js

@@ -0,0 +1,30 @@
+import { DashboardActionValidationError } from "@helyx/sdk";
+import { ReactionRolesHealthTracker } from "./health.js";
+import { PanelSnapshotCache, ReactionRolePanelService, } from "./panel-service.js";
+// Guild-worker ownership serializes dashboard and Discord mutations in one
+// runtime; the short TTL remains the correctness fence after worker turnover.
+export const reactionRoleCache = new PanelSnapshotCache();
+export const reactionRolePanels = new ReactionRolePanelService(reactionRoleCache);
+export const reactionRoleMemberLocks = new Map();
+export const reactionRoleHealth = new ReactionRolesHealthTracker();
+export async function runReactionRolePrimary(operation, source = "resource") {
+    try {
+        const result = await operation();
+        reactionRoleHealth.primarySuccess(source);
+        return result;
+    }
+    catch (error) {
+        if (!(error instanceof DashboardActionValidationError))
+            reactionRoleHealth.primaryFailure(source);
+        throw error;
+    }
+}
+export async function runReactionRoleFailureOnly(operation, source) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        reactionRoleHealth.primaryFailure(source);
+        throw error;
+    }
+}

package/manifest.json

@@ -10,7 +10,7 @@
   "healthExposure": "direct",
   "id": "helyx.reactionroles",
   "name": "Reaction Roles",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "description": "Let members select approved roles themselves.",
   "entry": "./dist/index.js",
   "framework": "^0.1.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helyx/module-reactionroles",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "description": "Configurable self-service Discord role panels for Helyx.",
   "keywords": [
     "helyx",
@@ -50,6 +50,6 @@
   },
   "dependencies": {
     "@helyx/module-manifest": ">=0.8.0 <0.9.0",
-    "@helyx/sdk": ">=0.9.0 <0.10.0"
+    "@helyx/sdk": ">=0.10.0"
   }
 }