@helyx/module-account-gate 1.0.15 → 1.1.3

package/dist/panel-resource.js

@@ -1,16 +1,14 @@
 import { DashboardActionValidationError, HELYX_SERVICE_NAMES, } from "@helyx/sdk";
-import { ACCOUNT_GATE_COMPONENTS, ACCOUNT_GATE_IDENTITY } from "./contracts.js";
+import { ACCOUNT_GATE_IDENTITY } from "./contracts.js";
 import { parseAccountGateConfiguration } from "./configuration.js";
 import { managedResourceSummary } from "./managed-resource-summary.js";
-import { hashPasswordEntryPhrase } from "./password-entry.js";
+import { queuePanelMessageCleanup } from "./panel-maintenance.js";
+import { DEFAULT_PANEL_MESSAGES, panelAccessType, panelDetail as detail, panelLimitError, panelMessage, panelMessageFromValue, panelNumber as numberValue, panelPasswordFromRow, panelString as stringValue, savedPanelMessage, } from "./panel-model.js";
+import { claimPanelMutation, finalizePanelMutation, } from "./panel-mutations.js";
+import { configuredPanelAccessType as configuredAccessType, inspectedPanelDetail as inspectedDetail, panelPasswordForCreate, panelPasswordForUpdate, } from "./panel-presentation.js";
 import { accountGateRecords } from "./records.js";
-const VIOLET = 0x7c3aed;
+export { getGatePanelRuntime, hasPasswordGatePanel } from "./panel-runtime.js";
 const MAX_GATE_PANELS = 10;
-const DEFAULT_PANEL_MESSAGES = {
-    challenges: "Complete a short human-interaction check to access the server. Press the button below when you are ready.",
-    password: "Enter the password for this gate in the Password Entry channel. Never enter your Discord password or authentication code.",
-    emoji: "React with the configured emoji on the Emoji Entry message to continue.",
-};
 export const gatePanelResource = {
     id: "gate-panel",
     availableWhileDisabled: true,
@@ -57,14 +55,50 @@ export const gatePanelResource = {
         if (!row)
             return { deleted: false };
         assertRevision(row, input.expectedRevision);
-        await context.deleteChannelMessage(stringValue(row.channel_id), stringValue(row.message_id));
-        const result = await records(context).deleteMany({
+        const store = records(context);
+        const claimed = await claimPanelMutation(store, row, {
+            ...auditContext(context),
+            action: "delete",
+            messageBody: savedPanelMessage(row),
+            accessType: panelAccessType(row),
+            password: panelPasswordFromRow(row),
+        });
+        if (!claimed)
+            throw stalePanel();
+        const channelId = stringValue(claimed.channel_id);
+        const messageId = stringValue(claimed.message_id);
+        const removed = await context
+            .deleteChannelMessage(channelId, messageId)
+            .then(() => true)
+            .catch(() => false);
+        if (!removed)
+            await queuePanelMessageCleanup({
+                services: context.services,
+                guildId: context.guildId,
+                panelId: input.resourceId,
+                channelId,
+                messageId,
+            });
+        const result = await store.deleteOne({
             moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
             collection: "gate_panels",
             where: { guild_id: context.guildId, panel_id: input.resourceId },
-            limit: 1,
+            expected: { field: "revision", value: numberValue(claimed.revision) },
+            audit: {
+                guildId: context.guildId,
+                actorUserId: context.actor.userId,
+                action: "account_gate.panel_deleted",
+                source: "dashboard",
+                correlationId: context.correlationId,
+                idempotencyKey: `account-gate-panel-deleted:${input.resourceId}:${numberValue(claimed.revision)}`,
+                targetType: "account_gate_panel",
+                targetId: input.resourceId,
+                metadata: { channelId, messageId },
+            },
         });
-        return { deleted: result.deleted === 1 };
+        if (!result.deleted)
+            throw stalePanel();
+        return { deleted: true };
     },
     async executeAction(context, input) {
         if (input.actionId !== "repair" && input.actionId !== "repost") {
@@ -94,20 +128,31 @@ async function writePanelMessage(context, current, messageBody, accessType, pass
         !inspection.channelMatches) {
         return replacePanel(context, current, action, messageBody, accessType, password);
     }
+    const store = records(context);
+    const claimed = await claimPanelMutation(store, current, {
+        ...auditContext(context),
+        action,
+        messageBody,
+        accessType,
+        password,
+    });
+    if (!claimed)
+        throw stalePanel();
     try {
-        await context.editChannelMessage(stringValue(current.channel_id), stringValue(current.message_id), panelMessage(messageBody, accessType, stringValue(current.panel_id)));
+        await context.editChannelMessage(stringValue(claimed.channel_id), stringValue(claimed.message_id), panelMessage(messageBody, accessType, stringValue(claimed.panel_id)));
     }
     catch {
-        return replacePanel(context, current, action, messageBody, accessType, password);
+        throw new DashboardActionValidationError("The Gate panel settings were saved, but the Discord message needs repair.");
     }
-    return persistPanelRevision(context, current, {
-        channelId: stringValue(current.channel_id),
-        messageId: stringValue(current.message_id),
-        messageBody,
-        accessType,
-        password,
+    const finalized = await finalizePanelMutation(store, claimed, {
+        ...auditContext(context),
         action,
+        channelId: stringValue(claimed.channel_id),
+        messageId: stringValue(claimed.message_id),
     });
+    if (!finalized)
+        throw new DashboardActionValidationError("The Gate panel message was updated, but its final state needs repair.");
+    return detail(finalized, "posted");
 }
 async function replacePanel(context, current, action, messageBody, accessType, password) {
     const configured = await context.services
@@ -117,85 +162,56 @@ async function replacePanel(context, current, action, messageBody, accessType, p
         throw new DashboardActionValidationError("Save Access Control settings before posting the panel.");
     }
     const configuration = parseAccountGateConfiguration(configured.value);
-    const sent = await context.sendToChannel(configuration.gateChannelId, panelMessage(messageBody, accessType, stringValue(current.panel_id)));
+    const store = records(context);
+    const claimed = await claimPanelMutation(store, current, {
+        ...auditContext(context),
+        action,
+        messageBody,
+        accessType,
+        password,
+    });
+    if (!claimed)
+        throw stalePanel();
+    const sent = await context.sendToChannel(configuration.gateChannelId, panelMessage(messageBody, accessType, stringValue(claimed.panel_id)));
     try {
-        const detail = await persistPanelRevision(context, current, {
+        const finalized = await finalizePanelMutation(store, claimed, {
+            ...auditContext(context),
+            action,
             channelId: configuration.gateChannelId,
             messageId: sent.messageId,
-            messageBody,
-            accessType,
-            password,
-            action,
         });
+        if (!finalized)
+            throw stalePanel();
         try {
             await context.deleteChannelMessage(stringValue(current.channel_id), stringValue(current.message_id));
         }
         catch {
-            // The replacement is authoritative even when the old message is gone.
+            await queuePanelMessageCleanup({
+                services: context.services,
+                guildId: context.guildId,
+                panelId: stringValue(current.panel_id),
+                channelId: stringValue(current.channel_id),
+                messageId: stringValue(current.message_id),
+            });
         }
-        return detail;
+        return detail(finalized, "posted");
     }
     catch (error) {
-        await context
+        const removed = await context
             .deleteChannelMessage(configuration.gateChannelId, sent.messageId)
-            .catch(() => undefined);
+            .then(() => true)
+            .catch(() => false);
+        if (!removed)
+            await queuePanelMessageCleanup({
+                services: context.services,
+                guildId: context.guildId,
+                panelId: stringValue(current.panel_id),
+                channelId: configuration.gateChannelId,
+                messageId: sent.messageId,
+            });
         throw error;
     }
 }
-async function persistPanelRevision(context, current, input) {
-    const revision = numberValue(current.revision) + 1;
-    const updatedAt = new Date();
-    const result = await records(context).updateOne({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "gate_panels",
-        where: {
-            guild_id: context.guildId,
-            panel_id: stringValue(current.panel_id),
-        },
-        expected: { field: "revision", value: numberValue(current.revision) },
-        values: {
-            channel_id: input.channelId,
-            message_id: input.messageId,
-            message_body: input.messageBody,
-            access_type: input.accessType,
-            ...(input.password
-                ? {
-                    password_hash: input.password.encodedHash,
-                    password_ignore_case: input.password.ignoreCase,
-                    password_trim_whitespace: input.password.trimWhitespace,
-                }
-                : {}),
-            revision,
-            updated_at: updatedAt,
-        },
-        audit: {
-            guildId: context.guildId,
-            actorUserId: context.actor.userId,
-            action: `account_gate.panel_${input.action}`,
-            source: "dashboard",
-            correlationId: context.correlationId,
-            idempotencyKey: context.correlationId,
-            targetType: "account_gate_panel",
-            targetId: stringValue(current.panel_id),
-            metadata: { revision },
-        },
-    });
-    if (!result.updated) {
-        throw new DashboardActionValidationError("The Gate panel changed in another session. Reload and try again.");
-    }
-    return detail({
-        ...current,
-        channel_id: input.channelId,
-        message_id: input.messageId,
-        message_body: input.messageBody,
-        access_type: input.accessType,
-        password_hash: input.password?.encodedHash ?? null,
-        password_ignore_case: input.password?.ignoreCase ?? true,
-        password_trim_whitespace: input.password?.trimWhitespace ?? true,
-        revision,
-        updated_at: updatedAt,
-    }, "posted");
-}
 async function currentPanel(context, resourceId) {
     const current = await currentPanelOrNull(context, resourceId);
     if (!current) {
@@ -212,9 +228,8 @@ async function currentPanelOrNull(context, resourceId) {
     });
 }
 function assertRevision(current, expectedRevision) {
-    if (numberValue(current.revision) !== expectedRevision) {
-        throw new DashboardActionValidationError("The Gate panel changed in another session. Reload and try again.");
-    }
+    if (numberValue(current.revision) !== expectedRevision)
+        throw stalePanel();
 }
 async function post(context, value = {}) {
     const configured = await context.services
@@ -255,6 +270,7 @@ async function post(context, value = {}) {
                 password_trim_whitespace: password.trimWhitespace,
             }
             : {}),
+        status: "posted",
         revision: 1,
         created_at: now,
         updated_at: now,
@@ -267,19 +283,11 @@ async function post(context, value = {}) {
             values: row,
         });
         if (!created.created) {
-            await context
-                .deleteChannelMessage(configuration.gateChannelId, sent.messageId)
-                .catch(() => undefined);
-            const concurrent = await currentPanelOrNull(context, context.correlationId);
-            if (concurrent)
-                return inspectedDetail(context, concurrent);
             throw new DashboardActionValidationError("That gate-panel request was already handled. Reload the resources list.");
         }
     }
     catch (error) {
-        await context
-            .deleteChannelMessage(configuration.gateChannelId, sent.messageId)
-            .catch(() => undefined);
+        await cleanupSentMessage(context, panelId, configuration.gateChannelId, sent.messageId);
         const concurrent = await currentPanelOrNull(context, context.correlationId);
         if (concurrent)
             return inspectedDetail(context, concurrent);
@@ -300,228 +308,32 @@ async function post(context, value = {}) {
         message_body: messageBody,
     }, "posted");
 }
-function panelMessage(messageBody, accessType, panelId) {
-    if (accessType === "emoji") {
-        return {
-            allowedUserMentionIds: [],
-            componentsV2: {
-                text: [
-                    {
-                        content: messageBody,
-                        markdown: false,
-                    },
-                ],
-            },
-        };
-    }
-    return {
-        allowedUserMentionIds: [],
-        componentsV2: {
-            ...(accessType === "challenges" ? { accentColor: VIOLET } : {}),
-            text: [
-                ...(accessType === "challenges"
-                    ? [{ content: "## Complete Access Control" }]
-                    : []),
-                {
-                    content: messageBody,
-                    markdown: false,
-                },
-            ],
-        },
-        buttons: [
-            {
-                type: "button",
-                customId: `${ACCOUNT_GATE_COMPONENTS.startPrefix}${panelId}`,
-                label: "Start check",
-                style: "primary",
-            },
-        ],
-    };
-}
-async function configuredAccessType(context) {
-    const configured = await context.services
-        .get(HELYX_SERVICE_NAMES.configuration)
-        .get(context.guildId, ACCOUNT_GATE_IDENTITY.moduleId);
-    if (!configured)
-        return "challenges";
-    return parseAccountGateConfiguration(configured.value).accessType;
-}
-async function inspectedDetail(context, row) {
-    const inspected = await context.services
-        .get(HELYX_SERVICE_NAMES.discordResources)
-        .inspectMessage({
+async function cleanupSentMessage(context, panelId, channelId, messageId) {
+    const removed = await context
+        .deleteChannelMessage(channelId, messageId)
+        .then(() => true)
+        .catch(() => false);
+    if (removed)
+        return;
+    await queuePanelMessageCleanup({
+        services: context.services,
         guildId: context.guildId,
-        channelId: stringValue(row.channel_id),
-        messageId: stringValue(row.message_id),
-    });
-    return detail(row, inspected.exists && inspected.guildMatches && inspected.channelMatches
-        ? "posted"
-        : "missing");
-}
-function detail(row, status) {
-    const updatedAt = row.updated_at instanceof Date ? row.updated_at : new Date(0);
-    const accessType = panelAccessType(row);
-    const panelTitles = {
-        challenges: "Challenge gate panel",
-        password: "Password Entry instructions",
-        emoji: "Emoji Entry instructions",
-    };
-    return {
-        id: stringValue(row.panel_id),
-        revision: numberValue(row.revision),
-        status,
-        title: panelTitles[accessType],
-        description: status === "posted"
-            ? "Published and currently available."
-            : "The saved panel message is missing. Repost it to repair the panel.",
-        attributes: {
-            channelId: stringValue(row.channel_id),
-            messageId: stringValue(row.message_id),
-            accessType,
-            passwordConfigured: accessType === "password" && panelPasswordFromRow(row) !== null,
-        },
-        value: {
-            channelId: stringValue(row.channel_id),
-            messageId: stringValue(row.message_id),
-            accessType,
-            messageBody: savedPanelMessage(row),
-            replacementPhrase: "",
-        },
-        updatedAt: updatedAt.toISOString(),
-    };
-}
-function panelAccessType(row) {
-    const value = row.access_type;
-    if (value === "password" || value === "emoji")
-        return value;
-    return "challenges";
-}
-function panelMessageFromValue(value, fallback) {
-    const candidate = value.messageBody;
-    if (candidate === undefined)
-        return fallback;
-    if (typeof candidate !== "string") {
-        throw new DashboardActionValidationError("Enter a valid Access Control panel message.");
-    }
-    const normalized = candidate.trim();
-    if (normalized.length < 1 || normalized.length > 1000) {
-        throw new DashboardActionValidationError("The Access Control panel message must be between 1 and 1000 characters.");
-    }
-    return normalized;
-}
-function savedPanelMessage(row) {
-    const message = row.message_body;
-    return typeof message === "string" && message.length > 0
-        ? message
-        : DEFAULT_PANEL_MESSAGES[panelAccessType(row)];
-}
-export async function getGatePanelRuntime(store, guildId, panelId) {
-    const row = await store.findOne({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "gate_panels",
-        select: accountGateRecords.gate_panels.readableFields,
-        where: { guild_id: guildId, panel_id: panelId },
-    });
-    if (!row)
-        return null;
-    return {
-        accessType: panelAccessType(row),
-        password: panelPasswordFromRow(row),
-    };
-}
-export async function hasPasswordGatePanel(store, guildId) {
-    const page = await store.findMany({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "gate_panels",
-        select: accountGateRecords.gate_panels.readableFields,
-        where: { guild_id: guildId, access_type: "password" },
-        orderBy: [
-            { field: "guild_id", direction: "asc" },
-            { field: "created_at", direction: "asc" },
-            { field: "panel_id", direction: "asc" },
-        ],
-        limit: MAX_GATE_PANELS,
+        panelId,
+        channelId,
+        messageId,
     });
-    return page.records.some((row) => panelPasswordFromRow(row) !== null);
-}
-async function panelPasswordForCreate(configuration, accessType, value) {
-    if (accessType !== "password")
-        return null;
-    const phrase = replacementPhrase(value, true);
-    return {
-        encodedHash: await hashPasswordEntryPhrase(phrase, {
-            ignoreCase: configuration.passwordIgnoreCase,
-            trimWhitespace: configuration.passwordTrimWhitespace,
-        }),
-        ignoreCase: configuration.passwordIgnoreCase,
-        trimWhitespace: configuration.passwordTrimWhitespace,
-    };
-}
-async function panelPasswordForUpdate(context, current, value) {
-    if (panelAccessType(current) !== "password")
-        return null;
-    const existing = panelPasswordFromRow(current);
-    const phrase = replacementPhrase(value, false);
-    if (!phrase) {
-        if (existing)
-            return existing;
-        throw new DashboardActionValidationError("Enter a password containing 4 to 200 characters before publishing this panel.");
-    }
-    const configured = await context.services
-        .get(HELYX_SERVICE_NAMES.configuration)
-        .get(context.guildId, ACCOUNT_GATE_IDENTITY.moduleId);
-    if (!configured) {
-        throw new DashboardActionValidationError("Save Access Control settings before changing this password.");
-    }
-    const configuration = parseAccountGateConfiguration(configured.value);
-    return {
-        encodedHash: await hashPasswordEntryPhrase(phrase, {
-            ignoreCase: configuration.passwordIgnoreCase,
-            trimWhitespace: configuration.passwordTrimWhitespace,
-        }),
-        ignoreCase: configuration.passwordIgnoreCase,
-        trimWhitespace: configuration.passwordTrimWhitespace,
-    };
 }
-function panelPasswordFromRow(row) {
-    if (typeof row.password_hash !== "string" || row.password_hash.length < 1) {
-        return null;
-    }
+function auditContext(context) {
     return {
-        encodedHash: row.password_hash,
-        ignoreCase: typeof row.password_ignore_case === "boolean"
-            ? row.password_ignore_case
-            : true,
-        trimWhitespace: typeof row.password_trim_whitespace === "boolean"
-            ? row.password_trim_whitespace
-            : true,
+        guildId: context.guildId,
+        actorUserId: context.actor.userId,
+        correlationId: context.correlationId,
     };
 }
-function replacementPhrase(value, required) {
-    const candidate = value.replacementPhrase;
-    if ((candidate === undefined || candidate === "") && !required)
-        return "";
-    if (typeof candidate !== "string" ||
-        candidate.length < 4 ||
-        candidate.length > 200) {
-        throw new DashboardActionValidationError("Enter a password containing 4 to 200 characters.");
-    }
-    return candidate;
-}
-function panelLimitError() {
-    return new DashboardActionValidationError("You have reached your limit of 10 gate panels. Delete an unused gate before publishing another.");
+function stalePanel() {
+    return new DashboardActionValidationError("The Gate panel changed in another session. Reload and try again.");
 }
 function records(context) {
     return context.services.get(HELYX_SERVICE_NAMES.records);
 }
-function stringValue(value) {
-    if (typeof value !== "string")
-        throw new Error("Access Control panel record is invalid");
-    return value;
-}
-function numberValue(value) {
-    if (typeof value !== "number" || !Number.isSafeInteger(value))
-        throw new Error("Access Control panel record is invalid");
-    return value;
-}
 //# sourceMappingURL=panel-resource.js.map

package/dist/panel-runtime.d.ts

@@ -0,0 +1,8 @@
+import type { ModuleRecordService } from "@helyx/sdk";
+import type { GatePanelAccessType, PanelPassword } from "./panel-model.js";
+export declare function getGatePanelRuntime(store: ModuleRecordService, guildId: string, panelId: string): Promise<{
+    accessType: GatePanelAccessType;
+    password: PanelPassword | null;
+} | null>;
+export declare function hasPasswordGatePanel(store: ModuleRecordService, guildId: string): Promise<boolean>;
+//# sourceMappingURL=panel-runtime.d.ts.map

package/dist/panel-runtime.js

@@ -0,0 +1,34 @@
+import { ACCOUNT_GATE_IDENTITY } from "./contracts.js";
+import { panelAccessType, panelPasswordFromRow } from "./panel-model.js";
+import { accountGateRecords } from "./records.js";
+const MAX_GATE_PANELS = 10;
+export async function getGatePanelRuntime(store, guildId, panelId) {
+    const row = await store.findOne({
+        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
+        collection: "gate_panels",
+        select: accountGateRecords.gate_panels.readableFields,
+        where: { guild_id: guildId, panel_id: panelId },
+    });
+    if (!row)
+        return null;
+    return {
+        accessType: panelAccessType(row),
+        password: panelPasswordFromRow(row),
+    };
+}
+export async function hasPasswordGatePanel(store, guildId) {
+    const page = await store.findMany({
+        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
+        collection: "gate_panels",
+        select: accountGateRecords.gate_panels.readableFields,
+        where: { guild_id: guildId, access_type: "password" },
+        orderBy: [
+            { field: "guild_id", direction: "asc" },
+            { field: "created_at", direction: "asc" },
+            { field: "panel_id", direction: "asc" },
+        ],
+        limit: MAX_GATE_PANELS,
+    });
+    return page.records.some((row) => panelPasswordFromRow(row) !== null);
+}
+//# sourceMappingURL=panel-runtime.js.map

package/dist/records.d.ts

@@ -32,6 +32,9 @@ export declare const accountGateRecords: {
                 readonly type: "boolean";
                 readonly optional: true;
             };
+            readonly status: {
+                readonly type: "string";
+            };
             readonly revision: {
                 readonly type: "number";
             };
@@ -43,10 +46,47 @@ export declare const accountGateRecords: {
             };
         };
         readonly uniqueKeys: readonly [readonly ["panel_id"], readonly ["guild_id", "panel_id"]];
-        readonly readableFields: readonly ["panel_id", "guild_id", "channel_id", "message_id", "message_body", "access_type", "password_hash", "password_ignore_case", "password_trim_whitespace", "revision", "created_at", "updated_at"];
-        readonly writableFields: readonly ["channel_id", "message_id", "message_body", "access_type", "password_hash", "password_ignore_case", "password_trim_whitespace", "revision", "updated_at"];
+        readonly readableFields: readonly ["panel_id", "guild_id", "channel_id", "message_id", "message_body", "access_type", "password_hash", "password_ignore_case", "password_trim_whitespace", "status", "revision", "created_at", "updated_at"];
+        readonly writableFields: readonly ["channel_id", "message_id", "message_body", "access_type", "password_hash", "password_ignore_case", "password_trim_whitespace", "status", "revision", "updated_at"];
         readonly orderKeys: readonly [readonly ["guild_id", "created_at", "panel_id"]];
     };
+    readonly panel_message_cleanup: {
+        readonly table: "account_gate_panel_message_cleanup";
+        readonly fields: {
+            readonly cleanup_id: {
+                readonly type: "string";
+            };
+            readonly guild_id: {
+                readonly type: "string";
+            };
+            readonly panel_id: {
+                readonly type: "string";
+            };
+            readonly channel_id: {
+                readonly type: "string";
+            };
+            readonly message_id: {
+                readonly type: "string";
+            };
+            readonly attempts: {
+                readonly type: "number";
+            };
+            readonly next_attempt_at: {
+                readonly type: "date";
+            };
+            readonly completed_at: {
+                readonly type: "date";
+                readonly optional: true;
+            };
+            readonly created_at: {
+                readonly type: "date";
+            };
+        };
+        readonly uniqueKeys: readonly [readonly ["cleanup_id"], readonly ["guild_id", "channel_id", "message_id"]];
+        readonly readableFields: readonly ["cleanup_id", "guild_id", "panel_id", "channel_id", "message_id", "attempts", "next_attempt_at", "completed_at", "created_at"];
+        readonly writableFields: readonly ["attempts", "next_attempt_at", "completed_at"];
+        readonly orderKeys: readonly [readonly ["next_attempt_at", "cleanup_id"]];
+    };
     readonly questions: {
         readonly table: "account_gate_questions";
         readonly fields: {