@helyx/module-moderation 1.0.1

package/dist/repository-model.js

@@ -0,0 +1,318 @@
+export const CASE_FIELDS = [
+    "case_id",
+    "guild_id",
+    "case_number",
+    "operation_key",
+    "subject_user_id",
+    "actor_user_id",
+    "source",
+    "source_module_id",
+    "source_event_id",
+    "action",
+    "reason",
+    "private_note",
+    "evidence_channel_id",
+    "evidence_message_id",
+    "related_case_id",
+    "requested_duration_seconds",
+    "delete_message_seconds",
+    "demote_role_ids",
+    "observed_action_type",
+    "observed_timeout_duration_seconds",
+    "repeat_rule_id",
+    "repeat_rule_revision",
+    "repeat_configuration_revision",
+    "repeat_policy_fingerprint",
+    "repeat_window_starts_at",
+    "repeat_offence_ordinal",
+    "repeat_offence_count",
+    "open_violation_thread",
+    "state",
+    "safe_outcome",
+    "revision",
+    "disassociated_at",
+    "settled_at",
+    "retention_expires_at",
+    "retention_processed_at",
+    "created_at",
+    "updated_at",
+];
+export const ATTEMPT_FIELDS = [
+    "attempt_id",
+    "guild_id",
+    "case_id",
+    "operation_key",
+    "actor_user_id",
+    "attempt_number",
+    "action",
+    "reason",
+    "outcome",
+    "safe_code",
+    "removed_role_ids",
+    "requested_duration_seconds",
+    "requested_demote_role_ids",
+    "created_at",
+    "updated_at",
+];
+export const DM_RECEIPT_FIELDS = [
+    "receipt_id",
+    "guild_id",
+    "case_id",
+    "template_revision",
+    "delivery_state",
+    "safe_code",
+    "message_id",
+    "attempted_at",
+    "created_at",
+    "updated_at",
+];
+export const THREAD_FIELDS = [
+    "delivery_id",
+    "guild_id",
+    "case_id",
+    "case_revision",
+    "operation_key",
+    "parent_channel_id",
+    "access_role_id",
+    "thread_id",
+    "control_token",
+    "control_message_id",
+    "member_state",
+    "evidence_state",
+    "opening_state",
+    "notification_state",
+    "close_state",
+    "resolution_state",
+    "attempt_count",
+    "fence_token",
+    "safe_code",
+    "retry_at",
+    "created_at",
+    "updated_at",
+];
+export function mapCase(row) {
+    return {
+        caseId: text(row, "case_id"),
+        guildId: text(row, "guild_id"),
+        caseNumber: number(row, "case_number"),
+        operationKey: text(row, "operation_key"),
+        subjectUserId: optionalText(row, "subject_user_id"),
+        actorUserId: optionalText(row, "actor_user_id"),
+        source: text(row, "source"),
+        sourceModuleId: text(row, "source_module_id"),
+        sourceEventId: optionalText(row, "source_event_id"),
+        action: text(row, "action"),
+        reason: text(row, "reason"),
+        privateNote: optionalText(row, "private_note"),
+        evidenceChannelId: optionalText(row, "evidence_channel_id"),
+        evidenceMessageId: optionalText(row, "evidence_message_id"),
+        relatedCaseId: optionalText(row, "related_case_id"),
+        requestedDurationSeconds: optionalNumber(row, "requested_duration_seconds"),
+        deleteMessageSeconds: optionalNumber(row, "delete_message_seconds"),
+        demoteRoleIds: jsonStrings(row, "demote_role_ids"),
+        observedActionType: optionalText(row, "observed_action_type"),
+        observedTimeoutDurationSeconds: optionalNumber(row, "observed_timeout_duration_seconds"),
+        repeatRuleId: optionalText(row, "repeat_rule_id"),
+        repeatRuleRevision: optionalNumber(row, "repeat_rule_revision"),
+        repeatConfigurationRevision: optionalText(row, "repeat_configuration_revision"),
+        repeatPolicyFingerprint: optionalText(row, "repeat_policy_fingerprint"),
+        repeatWindowStartsAt: optionalDate(row, "repeat_window_starts_at"),
+        repeatOffenceOrdinal: optionalNumber(row, "repeat_offence_ordinal"),
+        repeatOffenceCount: optionalNumber(row, "repeat_offence_count"),
+        openViolationThread: boolean(row, "open_violation_thread"),
+        state: text(row, "state"),
+        safeOutcome: optionalText(row, "safe_outcome"),
+        revision: number(row, "revision"),
+        disassociatedAt: optionalDate(row, "disassociated_at"),
+        settledAt: optionalDate(row, "settled_at"),
+        retentionExpiresAt: optionalDate(row, "retention_expires_at"),
+        retentionProcessedAt: optionalDate(row, "retention_processed_at"),
+        createdAt: date(row, "created_at"),
+        updatedAt: date(row, "updated_at"),
+    };
+}
+export function mapAttempt(row) {
+    return {
+        attemptId: text(row, "attempt_id"),
+        guildId: text(row, "guild_id"),
+        caseId: text(row, "case_id"),
+        operationKey: text(row, "operation_key"),
+        actorUserId: optionalText(row, "actor_user_id"),
+        attemptNumber: number(row, "attempt_number"),
+        action: text(row, "action"),
+        reason: text(row, "reason"),
+        outcome: text(row, "outcome"),
+        safeCode: optionalText(row, "safe_code"),
+        removedRoleIds: jsonStrings(row, "removed_role_ids"),
+        requestedDurationSeconds: optionalNumber(row, "requested_duration_seconds"),
+        demoteRoleIds: jsonStrings(row, "requested_demote_role_ids"),
+        createdAt: date(row, "created_at"),
+        updatedAt: date(row, "updated_at"),
+    };
+}
+export function mapDmReceipt(row) {
+    return {
+        receiptId: text(row, "receipt_id"),
+        guildId: text(row, "guild_id"),
+        caseId: text(row, "case_id"),
+        templateRevision: number(row, "template_revision"),
+        deliveryState: text(row, "delivery_state"),
+        safeCode: optionalText(row, "safe_code"),
+        messageId: optionalText(row, "message_id"),
+        attemptedAt: optionalDate(row, "attempted_at"),
+        createdAt: date(row, "created_at"),
+        updatedAt: date(row, "updated_at"),
+    };
+}
+export function mapThreadDelivery(row) {
+    return {
+        deliveryId: text(row, "delivery_id"),
+        guildId: text(row, "guild_id"),
+        caseId: text(row, "case_id"),
+        caseRevision: number(row, "case_revision"),
+        operationKey: text(row, "operation_key"),
+        parentChannelId: optionalText(row, "parent_channel_id"),
+        accessRoleId: optionalText(row, "access_role_id"),
+        threadId: optionalText(row, "thread_id"),
+        controlToken: optionalText(row, "control_token"),
+        controlMessageId: optionalText(row, "control_message_id"),
+        memberState: text(row, "member_state"),
+        evidenceState: text(row, "evidence_state"),
+        openingState: text(row, "opening_state"),
+        notificationState: text(row, "notification_state"),
+        closeState: text(row, "close_state"),
+        resolutionState: text(row, "resolution_state"),
+        attemptCount: number(row, "attempt_count"),
+        fenceToken: number(row, "fence_token"),
+        safeCode: optionalText(row, "safe_code"),
+        retryAt: optionalDate(row, "retry_at"),
+        createdAt: date(row, "created_at"),
+        updatedAt: date(row, "updated_at"),
+    };
+}
+export function dmReceiptWrite(input) {
+    return compact({
+        receipt_id: input.receiptId,
+        guild_id: input.guildId,
+        case_id: input.caseId,
+        template_revision: input.templateRevision,
+        delivery_state: input.deliveryState,
+        safe_code: input.safeCode,
+        message_id: input.messageId,
+        attempted_at: input.attemptedAt,
+        created_at: input.createdAt,
+        updated_at: input.updatedAt,
+    });
+}
+export function threadDeliveryWrite(input) {
+    return compact({
+        delivery_id: input.deliveryId,
+        guild_id: input.guildId,
+        case_id: input.caseId,
+        case_revision: input.caseRevision,
+        operation_key: input.operationKey,
+        parent_channel_id: input.parentChannelId,
+        access_role_id: input.accessRoleId,
+        thread_id: input.threadId,
+        control_token: input.controlToken,
+        control_message_id: input.controlMessageId,
+        member_state: input.memberState,
+        evidence_state: input.evidenceState,
+        opening_state: input.openingState,
+        notification_state: input.notificationState,
+        close_state: input.closeState,
+        resolution_state: input.resolutionState,
+        attempt_count: input.attemptCount,
+        fence_token: input.fenceToken,
+        safe_code: input.safeCode,
+        retry_at: input.retryAt,
+        created_at: input.createdAt,
+        updated_at: input.updatedAt,
+    });
+}
+export const THREAD_PROPERTY_FIELDS = {
+    caseRevision: "case_revision",
+    operationKey: "operation_key",
+    parentChannelId: "parent_channel_id",
+    accessRoleId: "access_role_id",
+    threadId: "thread_id",
+    controlToken: "control_token",
+    controlMessageId: "control_message_id",
+    memberState: "member_state",
+    evidenceState: "evidence_state",
+    openingState: "opening_state",
+    notificationState: "notification_state",
+    closeState: "close_state",
+    resolutionState: "resolution_state",
+    attemptCount: "attempt_count",
+    fenceToken: "fence_token",
+    safeCode: "safe_code",
+    retryAt: "retry_at",
+    updatedAt: "updated_at",
+};
+function compact(input) {
+    const values = {};
+    const clear = [];
+    for (const [key, value] of Object.entries(input)) {
+        if (value === null)
+            clear.push(key);
+        else
+            values[key] = value;
+    }
+    return { values, clear };
+}
+function text(row, key) {
+    const value = row[key];
+    if (typeof value !== "string")
+        throw new Error(`Invalid ${key} record value.`);
+    return value;
+}
+function optionalText(row, key) {
+    const value = row[key];
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value !== "string")
+        throw new Error(`Invalid ${key} record value.`);
+    return value;
+}
+function number(row, key) {
+    const value = row[key];
+    if (typeof value !== "number")
+        throw new Error(`Invalid ${key} record value.`);
+    return value;
+}
+function optionalNumber(row, key) {
+    const value = row[key];
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value !== "number")
+        throw new Error(`Invalid ${key} record value.`);
+    return value;
+}
+function boolean(row, key) {
+    const value = row[key];
+    if (typeof value !== "boolean")
+        throw new Error(`Invalid ${key} record value.`);
+    return value;
+}
+function date(row, key) {
+    const value = row[key];
+    if (!(value instanceof Date))
+        throw new Error(`Invalid ${key} record value.`);
+    return value;
+}
+function optionalDate(row, key) {
+    const value = row[key];
+    if (value === null || value === undefined)
+        return null;
+    if (!(value instanceof Date))
+        throw new Error(`Invalid ${key} record value.`);
+    return value;
+}
+function jsonStrings(row, key) {
+    const value = JSON.parse(text(row, key));
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string"))
+        throw new Error(`Invalid ${key} record value.`);
+    return value;
+}
+//# sourceMappingURL=repository-model.js.map

package/dist/repository.d.ts

@@ -0,0 +1,21 @@
+import { type ModuleRecordService, type ServiceAccess } from "@helyx/sdk";
+import { ModerationCaseRepository } from "./case-repository.js";
+import { ModerationReceiptRepository } from "./receipt-repository.js";
+import { ModerationThreadRepository } from "./thread-repository.js";
+export type { ModerationCasePage, ModerationCaseQuery, } from "./case-repository.js";
+export type { StoredModerationAttempt, StoredModerationCase, StoredModerationDmReceipt, StoredModerationThreadDelivery, } from "./repository-model.js";
+export declare class ModerationRepository {
+    readonly findCase: ModerationCaseRepository["findCase"];
+    readonly findCaseByNumber: ModerationCaseRepository["findCaseByNumber"];
+    readonly listCases: ModerationCaseRepository["listCases"];
+    readonly listAttempts: ModerationCaseRepository["listAttempts"];
+    readonly findDmReceipt: ModerationReceiptRepository["findDmReceipt"];
+    readonly upsertDmReceipt: ModerationReceiptRepository["upsertDmReceipt"];
+    readonly findThreadDelivery: ModerationThreadRepository["findThreadDelivery"];
+    readonly findThreadDeliveryByControlToken: ModerationThreadRepository["findThreadDeliveryByControlToken"];
+    readonly upsertThreadDelivery: ModerationThreadRepository["upsertThreadDelivery"];
+    readonly createThreadDelivery: ModerationThreadRepository["createThreadDelivery"];
+    readonly updateThreadDelivery: ModerationThreadRepository["updateThreadDelivery"];
+    constructor(services: ServiceAccess | ModuleRecordService);
+}
+//# sourceMappingURL=repository.d.ts.map

package/dist/repository.js

@@ -0,0 +1,41 @@
+import { HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+import { ModerationCaseRepository } from "./case-repository.js";
+import { ModerationReceiptRepository } from "./receipt-repository.js";
+import { ModerationThreadRepository } from "./thread-repository.js";
+export class ModerationRepository {
+    findCase;
+    findCaseByNumber;
+    listCases;
+    listAttempts;
+    findDmReceipt;
+    upsertDmReceipt;
+    findThreadDelivery;
+    findThreadDeliveryByControlToken;
+    upsertThreadDelivery;
+    createThreadDelivery;
+    updateThreadDelivery;
+    constructor(services) {
+        const records = isServiceAccess(services)
+            ? services.get(HELYX_SERVICE_NAMES.records)
+            : services;
+        const cases = new ModerationCaseRepository(records);
+        const receipts = new ModerationReceiptRepository(records);
+        const threads = new ModerationThreadRepository(records);
+        this.findCase = cases.findCase.bind(cases);
+        this.findCaseByNumber = cases.findCaseByNumber.bind(cases);
+        this.listCases = cases.listCases.bind(cases);
+        this.listAttempts = cases.listAttempts.bind(cases);
+        this.findDmReceipt = receipts.findDmReceipt.bind(receipts);
+        this.upsertDmReceipt = receipts.upsertDmReceipt.bind(receipts);
+        this.findThreadDelivery = threads.findThreadDelivery.bind(threads);
+        this.findThreadDeliveryByControlToken =
+            threads.findThreadDeliveryByControlToken.bind(threads);
+        this.upsertThreadDelivery = threads.upsertThreadDelivery.bind(threads);
+        this.createThreadDelivery = threads.createThreadDelivery.bind(threads);
+        this.updateThreadDelivery = threads.updateThreadDelivery.bind(threads);
+    }
+}
+function isServiceAccess(value) {
+    return "get" in value && typeof value.get === "function";
+}
+//# sourceMappingURL=repository.js.map

package/dist/service.d.ts

@@ -0,0 +1,75 @@
+import { type ModerationActionAttemptTerminalOutcome, type ModerationActionProviderContext, type ModerationBanDeleteMessageSeconds, type ModerationEnforcementAction, type PermissionActor, type ScheduledTaskExecutionResult, type ServiceAccess } from "@helyx/sdk";
+import type { ModerationCaseAction, ModerationCommandId } from "./contracts.js";
+export interface ModerationStaffDraft {
+    operationKey: string;
+    guildId: string;
+    actor: PermissionActor;
+    permissionId: ModerationCommandId;
+    action: Exclude<ModerationCaseAction, "delete_message" | "case_only">;
+    subjectUserId: string;
+    subjectDisplayName: string;
+    reason: string;
+    privateNote?: string;
+    evidenceMessage?: {
+        channelId: string;
+        messageId: string;
+    };
+    requestedDurationSeconds?: number;
+    deleteMessageSeconds?: ModerationBanDeleteMessageSeconds;
+    demoteRoleIds?: readonly string[];
+}
+export interface ModerationExecutionSummary {
+    outcome: "applied" | "review_required" | "failed" | "rejected";
+    caseId?: string;
+    caseNumber?: number;
+    revision?: number;
+    safeCode: string;
+}
+export type ModerationDispatchAction = ModerationEnforcementAction | {
+    type: "timeout";
+    durationSeconds: number;
+} | {
+    type: "timeout_remove";
+} | {
+    type: "unban";
+};
+export interface ModerationThreadRuntime {
+    deliver(input: {
+        services: ServiceAccess;
+        guildId: string;
+        caseId: string;
+        caseNumber: number;
+        caseRevision: number;
+        subjectUserId: string;
+        severity: "low" | "medium" | "high" | "critical";
+        operationKey: string;
+        evidence?: ModerationActionProviderContext["violationEvidence"];
+    }): Promise<"not_requested" | "created" | "already_exists" | "retry_pending" | "review_required">;
+    reconcileAccess(services: ServiceAccess, guildId: string): Promise<ScheduledTaskExecutionResult>;
+}
+export declare class ModerationService {
+    #private;
+    attachThreadRuntime(runtime: ModerationThreadRuntime): void;
+    canExecuteStaffAction(services: ServiceAccess, draft: ModerationStaffDraft): Promise<boolean>;
+    executeStaffAction(services: ServiceAccess, draft: ModerationStaffDraft): Promise<ModerationExecutionSummary>;
+    dispatchAction(services: ServiceAccess, input: {
+        guildId: string;
+        subjectUserId: string;
+        actorUserId?: string;
+        action: ModerationDispatchAction;
+        reason: string;
+        operationKey: string;
+        sourceMessage?: {
+            channelId: string;
+            messageId: string | null;
+        } | null;
+        protectedRoleIds: readonly string[];
+        revalidate(): Promise<boolean>;
+    }): Promise<{
+        outcome: ModerationActionAttemptTerminalOutcome;
+        safeCode?: string;
+        removedRoleIds?: readonly string[];
+    }>;
+    deliverViolationThread(input: Parameters<ModerationThreadRuntime["deliver"]>[0]): Promise<"not_requested" | "created" | "already_exists" | "retry_pending" | "review_required">;
+}
+//# sourceMappingURL=service.d.ts.map