@helyx/module-automod 1.0.1

package/dist/repository-model.js

@@ -0,0 +1,132 @@
+export const RULE_FIELDS = [
+    "rule_id",
+    "guild_id",
+    "name",
+    "category",
+    "rule_kind",
+    "status",
+    "document_json",
+    "native_rule_id",
+    "native_fingerprint",
+    "operation_key",
+    "configuration_revision",
+    "revision",
+    "created_by_user_id",
+    "updated_by_user_id",
+    "created_at",
+    "updated_at",
+];
+export const RECEIPT_FIELDS = [
+    "receipt_id",
+    "guild_id",
+    "event_key",
+    "rule_id",
+    "rule_revision",
+    "configuration_revision",
+    "native_rule_id",
+    "source",
+    "detector_version",
+    "scoring_version",
+    "term_id",
+    "detection_method",
+    "confidence_class",
+    "confidence_score",
+    "effective_threshold",
+    "correlation_id",
+    "subject_user_id",
+    "channel_id",
+    "message_id",
+    "alert_system_message_id",
+    "action_type",
+    "claim_key",
+    "moderation_case_id",
+    "outcome",
+    "safe_code",
+    "occurred_at",
+    "created_at",
+];
+export function mapRule(row) {
+    return {
+        ruleId: requiredString(row.rule_id),
+        guildId: requiredString(row.guild_id),
+        name: requiredString(row.name),
+        category: requiredString(row.category),
+        kind: requiredString(row.rule_kind),
+        status: requiredString(row.status),
+        draft: storedDraft(requiredString(row.document_json)),
+        nativeRuleId: optionalString(row.native_rule_id),
+        nativeFingerprint: optionalString(row.native_fingerprint),
+        operationKey: requiredString(row.operation_key),
+        configurationRevision: requiredString(row.configuration_revision),
+        revision: requiredNumber(row.revision),
+        createdByUserId: optionalString(row.created_by_user_id),
+        updatedByUserId: optionalString(row.updated_by_user_id),
+        createdAt: requiredDate(row.created_at),
+        updatedAt: requiredDate(row.updated_at),
+    };
+}
+function storedDraft(value) {
+    const draft = JSON.parse(value);
+    return {
+        ...draft,
+        enhancedNormalisedMatching: draft.enhancedNormalisedMatching !== false,
+        enhancedFuzzyMatching: draft.enhancedFuzzyMatching === true,
+    };
+}
+export function mapReceipt(row) {
+    return {
+        receiptId: requiredString(row.receipt_id),
+        guildId: requiredString(row.guild_id),
+        eventKey: requiredString(row.event_key),
+        ruleId: requiredString(row.rule_id),
+        ruleRevision: requiredNumber(row.rule_revision),
+        configurationRevision: requiredString(row.configuration_revision),
+        nativeRuleId: optionalString(row.native_rule_id),
+        source: requiredString(row.source),
+        detectorVersion: optionalString(row.detector_version),
+        scoringVersion: optionalString(row.scoring_version),
+        termId: optionalString(row.term_id),
+        detectionMethod: optionalString(row.detection_method),
+        confidenceClass: optionalString(row.confidence_class),
+        confidenceScore: optionalNumber(row.confidence_score),
+        effectiveThreshold: optionalNumber(row.effective_threshold),
+        correlationId: optionalString(row.correlation_id),
+        subjectUserId: optionalString(row.subject_user_id),
+        channelId: optionalString(row.channel_id),
+        messageId: optionalString(row.message_id),
+        alertSystemMessageId: optionalString(row.alert_system_message_id),
+        actionType: requiredString(row.action_type),
+        claimKey: requiredString(row.claim_key),
+        moderationCaseId: optionalString(row.moderation_case_id),
+        outcome: requiredString(row.outcome),
+        safeCode: optionalString(row.safe_code),
+        occurredAt: requiredDate(row.occurred_at),
+        createdAt: requiredDate(row.created_at),
+    };
+}
+function requiredString(value) {
+    if (typeof value !== "string")
+        throw new Error("Auto Moderation record is invalid.");
+    return value;
+}
+function optionalString(value) {
+    return typeof value === "string" ? value : null;
+}
+function optionalNumber(value) {
+    if (value === undefined || value === null)
+        return null;
+    if (typeof value !== "number")
+        throw new Error("Auto Moderation record is invalid.");
+    return value;
+}
+function requiredNumber(value) {
+    if (typeof value !== "number")
+        throw new Error("Auto Moderation record is invalid.");
+    return value;
+}
+function requiredDate(value) {
+    if (!(value instanceof Date))
+        throw new Error("Auto Moderation record is invalid.");
+    return value;
+}
+//# sourceMappingURL=repository-model.js.map

package/dist/repository.d.ts

@@ -0,0 +1,133 @@
+import { type AutoModerationEnhancedResultV1, type ModuleRecordService, type ModuleRecordWriteValue, type ServiceAccess } from "@helyx/sdk";
+import type { AutoModerationRuleDraft, AutoModerationRuleStatus } from "./domain.js";
+import { type StoredAutoModerationReceipt, type StoredAutoModerationRule } from "./repository-model.js";
+export type { StoredAutoModerationReceipt, StoredAutoModerationRule, } from "./repository-model.js";
+export declare class AutoModerationRepository {
+    #private;
+    constructor(services: ServiceAccess | ModuleRecordService);
+    listRules(input: {
+        guildId: string;
+        limit: number;
+        cursor?: readonly ModuleRecordWriteValue[];
+        search?: string;
+        status?: string;
+    }): Promise<{
+        items: StoredAutoModerationRule[];
+        nextCursor: readonly ModuleRecordWriteValue[] | null;
+    }>;
+    findRule(guildId: string, ruleId: string): Promise<StoredAutoModerationRule | null>;
+    findByNativeRuleId(guildId: string, nativeRuleId: string): Promise<StoredAutoModerationRule | null>;
+    listPublishedGuildIds(limit?: number): Promise<string[]>;
+    listAllPublishedRules(guildId: string): Promise<StoredAutoModerationRule[]>;
+    createDraft(input: {
+        guildId: string;
+        ruleId?: string;
+        draft: AutoModerationRuleDraft;
+        actorUserId: string;
+        occurredAt: Date;
+    }): Promise<StoredAutoModerationRule>;
+    updateRule(input: {
+        current: StoredAutoModerationRule;
+        draft?: AutoModerationRuleDraft;
+        status?: AutoModerationRuleStatus;
+        nativeRuleId?: string | null;
+        nativeFingerprint?: string | null;
+        configurationRevision?: string;
+        actorUserId: string | null;
+        action: string;
+        occurredAt: Date;
+    }): Promise<StoredAutoModerationRule | null>;
+    deleteDraft(input: {
+        current: StoredAutoModerationRule;
+        actorUserId: string;
+    }): Promise<{
+        deleted: boolean;
+    }>;
+    appendReceipt(input: {
+        guildId: string;
+        eventKey: string;
+        rule: StoredAutoModerationRule;
+        nativeRuleId: string;
+        subjectUserId: string;
+        channelId: string | null;
+        messageId: string | null;
+        alertSystemMessageId: string | null;
+        actionType: string;
+        claimKey: string;
+        occurredAt: Date;
+    }): Promise<{
+        created: boolean;
+    }>;
+    appendEnhancedReceipt(input: {
+        result: AutoModerationEnhancedResultV1;
+        rule: StoredAutoModerationRule;
+        claimKey: string;
+        occurredAt: Date;
+    }): Promise<{
+        created: boolean;
+    }>;
+    settleReceipt(input: {
+        guildId: string;
+        eventKey: string;
+        outcome: string;
+        moderationCaseId?: string;
+        safeCode?: string;
+    }): Promise<void>;
+    findReceiptByEventKey(input: {
+        guildId: string;
+        eventKey: string;
+    }): Promise<{
+        outcome: string;
+        moderationCaseId: string | null;
+        safeCode: string | null;
+    } | null>;
+    claimEnforcement(input: {
+        guildId: string;
+        claimKey: string;
+        rule: StoredAutoModerationRule;
+        subjectUserId: string;
+        channelId: string | null;
+        messageId: string | null;
+        actionFamily: string;
+        source: "native" | "enhanced";
+        requestFingerprint: string;
+        occurredAt: Date;
+    }): Promise<{
+        created: boolean;
+        conflict: boolean;
+        source: "native" | "enhanced";
+        outcome: string;
+        moderationCaseId: string | null;
+        repeatOrdinal: number | null;
+        selectedAction: string | null;
+        safeCode: string | null;
+    }>;
+    disassociateCaseLinks(input: {
+        guildId: string;
+        moderationCaseId: string;
+    }): Promise<{
+        detachedRecords: number;
+    }>;
+    settleClaim(input: {
+        guildId: string;
+        claimKey: string;
+        moderationCaseId?: string;
+        repeatOrdinal?: number;
+        selectedAction?: string;
+        outcome: string;
+        safeCode?: string;
+        occurredAt: Date;
+    }): Promise<void>;
+    listReceipts(input: {
+        guildId: string;
+        limit: number;
+        cursor?: readonly ModuleRecordWriteValue[];
+        ruleId?: string;
+        outcome?: string;
+    }): Promise<{
+        items: StoredAutoModerationReceipt[];
+        nextCursor: readonly ModuleRecordWriteValue[] | null;
+    }>;
+    findReceipt(guildId: string, receiptId: string): Promise<StoredAutoModerationReceipt | null>;
+}
+//# sourceMappingURL=repository.d.ts.map