@helyx/module-account-gate 1.0.15 → 1.1.3

package/dist/panel-model.js

@@ -0,0 +1,128 @@
+import { DashboardActionValidationError } from "@helyx/sdk";
+import { ACCOUNT_GATE_COMPONENTS } from "./contracts.js";
+const VIOLET = 0x7c3aed;
+export 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 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",
+            },
+        ],
+    };
+}
+export function panelDetail(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: panelString(row.panel_id),
+        revision: panelNumber(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: panelString(row.channel_id),
+            messageId: panelString(row.message_id),
+            accessType,
+            passwordConfigured: accessType === "password" && panelPasswordFromRow(row) !== null,
+        },
+        value: {
+            channelId: panelString(row.channel_id),
+            messageId: panelString(row.message_id),
+            accessType,
+            messageBody: savedPanelMessage(row),
+            replacementPhrase: "",
+        },
+        updatedAt: updatedAt.toISOString(),
+    };
+}
+export function panelAccessType(row) {
+    const value = row.access_type;
+    if (value === "password" || value === "emoji")
+        return value;
+    return "challenges";
+}
+export 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;
+}
+export function savedPanelMessage(row) {
+    const message = row.message_body;
+    return typeof message === "string" && message.length > 0
+        ? message
+        : DEFAULT_PANEL_MESSAGES[panelAccessType(row)];
+}
+export function panelPasswordFromRow(row) {
+    if (typeof row.password_hash !== "string" || row.password_hash.length < 1)
+        return null;
+    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,
+    };
+}
+export 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;
+}
+export function panelLimitError() {
+    return new DashboardActionValidationError("You have reached your limit of 10 gate panels. Delete an unused gate before publishing another.");
+}
+export function panelString(value) {
+    if (typeof value !== "string")
+        throw new Error("Access Control panel record is invalid");
+    return value;
+}
+export function panelNumber(value) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value))
+        throw new Error("Access Control panel record is invalid");
+    return value;
+}
+//# sourceMappingURL=panel-model.js.map

package/dist/panel-mutations.d.ts

@@ -0,0 +1,24 @@
+import type { ModuleRecordService } from "@helyx/sdk";
+interface PanelPasswordMutation {
+    encodedHash: string;
+    ignoreCase: boolean;
+    trimWhitespace: boolean;
+}
+interface PanelAuditContext {
+    actorUserId: string;
+    correlationId: string;
+    guildId: string;
+}
+export declare function claimPanelMutation(records: ModuleRecordService, current: Readonly<Record<string, unknown>>, input: PanelAuditContext & {
+    action: "updated" | "repaired" | "reposted" | "delete";
+    messageBody: string;
+    accessType: "challenges" | "password" | "emoji";
+    password: PanelPasswordMutation | null;
+}): Promise<Readonly<Record<string, unknown>> | null>;
+export declare function finalizePanelMutation(records: ModuleRecordService, claimed: Readonly<Record<string, unknown>>, input: PanelAuditContext & {
+    action: "updated" | "repaired" | "reposted";
+    channelId: string;
+    messageId: string;
+}): Promise<Readonly<Record<string, unknown>> | null>;
+export {};
+//# sourceMappingURL=panel-mutations.d.ts.map

package/dist/panel-mutations.js

@@ -0,0 +1,89 @@
+import { ACCOUNT_GATE_IDENTITY } from "./contracts.js";
+export async function claimPanelMutation(records, current, input) {
+    const revision = recordNumber(current.revision) + 1;
+    const updatedAt = new Date();
+    const values = {
+        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,
+            }
+            : {}),
+        status: "missing",
+        revision,
+        updated_at: updatedAt,
+    };
+    const result = await records.updateOne({
+        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
+        collection: "gate_panels",
+        where: {
+            guild_id: input.guildId,
+            panel_id: recordString(current.panel_id),
+        },
+        expected: { field: "revision", value: recordNumber(current.revision) },
+        values,
+        audit: {
+            guildId: input.guildId,
+            actorUserId: input.actorUserId,
+            action: `account_gate.panel_${input.action}_claimed`,
+            source: "dashboard",
+            correlationId: input.correlationId,
+            idempotencyKey: `account-gate-panel-${input.action}-claimed:${recordString(current.panel_id)}:${revision}`,
+            targetType: "account_gate_panel",
+            targetId: recordString(current.panel_id),
+            metadata: { revision },
+        },
+    });
+    return result.updated ? { ...current, ...values } : null;
+}
+export async function finalizePanelMutation(records, claimed, input) {
+    const revision = recordNumber(claimed.revision) + 1;
+    const updatedAt = new Date();
+    const values = {
+        channel_id: input.channelId,
+        message_id: input.messageId,
+        status: "posted",
+        revision,
+        updated_at: updatedAt,
+    };
+    const result = await records.updateOne({
+        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
+        collection: "gate_panels",
+        where: {
+            guild_id: input.guildId,
+            panel_id: recordString(claimed.panel_id),
+        },
+        expected: { field: "revision", value: recordNumber(claimed.revision) },
+        values,
+        audit: {
+            guildId: input.guildId,
+            actorUserId: input.actorUserId,
+            action: `account_gate.panel_${input.action}`,
+            source: "dashboard",
+            correlationId: input.correlationId,
+            idempotencyKey: `account-gate-panel-${input.action}:${recordString(claimed.panel_id)}:${revision}`,
+            targetType: "account_gate_panel",
+            targetId: recordString(claimed.panel_id),
+            metadata: {
+                revision,
+                channelId: input.channelId,
+                messageId: input.messageId,
+            },
+        },
+    });
+    return result.updated ? { ...claimed, ...values } : null;
+}
+function recordString(value) {
+    if (typeof value !== "string")
+        throw new Error("Access Control panel record is invalid");
+    return value;
+}
+function recordNumber(value) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value))
+        throw new Error("Access Control panel record is invalid");
+    return value;
+}
+//# sourceMappingURL=panel-mutations.js.map

package/dist/panel-presentation.d.ts

@@ -0,0 +1,8 @@
+import type { ManagedResourceContext, ManagedResourceDetail } from "@helyx/sdk";
+import { parseAccountGateConfiguration } from "./configuration.js";
+import type { GatePanelAccessType, PanelPassword } from "./panel-model.js";
+export declare function configuredPanelAccessType(context: ManagedResourceContext): Promise<GatePanelAccessType>;
+export declare function inspectedPanelDetail(context: ManagedResourceContext, row: Readonly<Record<string, unknown>>): Promise<ManagedResourceDetail>;
+export declare function panelPasswordForCreate(configuration: ReturnType<typeof parseAccountGateConfiguration>, accessType: GatePanelAccessType, value: Readonly<Record<string, unknown>>): Promise<PanelPassword | null>;
+export declare function panelPasswordForUpdate(context: ManagedResourceContext, current: Readonly<Record<string, unknown>>, value: Readonly<Record<string, unknown>>): Promise<PanelPassword | null>;
+//# sourceMappingURL=panel-presentation.d.ts.map

package/dist/panel-presentation.js

@@ -0,0 +1,67 @@
+import { DashboardActionValidationError, HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+import { parseAccountGateConfiguration } from "./configuration.js";
+import { ACCOUNT_GATE_IDENTITY } from "./contracts.js";
+import { panelAccessType, panelDetail, panelPasswordFromRow, panelString, replacementPhrase, } from "./panel-model.js";
+import { hashPasswordEntryPhrase } from "./password-entry.js";
+export async function configuredPanelAccessType(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;
+}
+export async function inspectedPanelDetail(context, row) {
+    const inspected = await context.services
+        .get(HELYX_SERVICE_NAMES.discordResources)
+        .inspectMessage({
+        guildId: context.guildId,
+        channelId: panelString(row.channel_id),
+        messageId: panelString(row.message_id),
+    });
+    return panelDetail(row, row.status === "posted" &&
+        inspected.exists &&
+        inspected.guildMatches &&
+        inspected.channelMatches
+        ? "posted"
+        : "missing");
+}
+export 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,
+    };
+}
+export 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,
+    };
+}
+//# sourceMappingURL=panel-presentation.js.map

package/dist/panel-resource.d.ts

@@ -1,15 +1,4 @@
-import type { ModuleManagedResource, ModuleRecordService } from "@helyx/sdk";
-type GatePanelAccessType = "challenges" | "password" | "emoji";
-interface PanelPassword {
-    encodedHash: string;
-    ignoreCase: boolean;
-    trimWhitespace: boolean;
-}
+import type { ModuleManagedResource } from "@helyx/sdk";
+export { getGatePanelRuntime, hasPasswordGatePanel } from "./panel-runtime.js";
 export declare const gatePanelResource: ModuleManagedResource;
-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>;
-export {};
 //# sourceMappingURL=panel-resource.d.ts.map