@voltro/plugin-sanctions 0.0.0-stage → 0.88.0

package/dist/guard.d.ts

@@ -0,0 +1,83 @@
+import { AuthSubjectGuard } from '@voltro/protocol';
+import { Effect } from 'effect';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { SubjectGuard } from '@voltro/plugin-auth';
+import { YieldableError } from 'effect/Cause';
+
+declare const CATEGORIES: readonly ["cheating", "abuse", "name", "spam", "griefing", "rmt"];
+
+declare const DecisionSchema: Schema.Struct<{
+    readonly allowed: Schema.Boolean;
+    readonly actionIds: Schema.$Array<Schema.String>;
+    readonly shadow: Schema.Boolean;
+}>;
+
+declare const POINTS: readonly ["chat", "matchmaking", "trade", "ranked", "login"];
+
+declare type ReportContext = typeof ReportContextSchema.Type;
+
+declare const ReportContextSchema: Schema.Struct<{
+    readonly channelId: Schema.optional<Schema.String>;
+    readonly messageIds: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly roomId: Schema.optional<Schema.String>;
+    readonly matchId: Schema.optional<Schema.String>;
+    readonly replayRef: Schema.optional<Schema.String>;
+}>;
+
+declare type Sanction = typeof SanctionSchema.Type;
+
+declare type SanctionCategory = typeof CATEGORIES[number];
+
+declare interface SanctionCheckContext {
+    readonly channelId?: string;
+    readonly queueId?: string;
+}
+
+declare type SanctionDecision = typeof DecisionSchema.Type;
+
+declare type SanctionPoint = typeof POINTS[number];
+
+declare const SanctionSchema: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly kind: Schema.Literals<readonly ["warn", "mute", "chatBan", "matchmakingBan", "rankedBan", "tradeBan", "ban", "shadowBan", "nameReset", "rollback"]>;
+    readonly scope: Schema.Struct<{
+        readonly channels: Schema.$Array<Schema.String>;
+        readonly queues: Schema.$Array<Schema.String>;
+    }>;
+    readonly from: Schema.Number;
+    readonly until: Schema.NullOr<Schema.Number>;
+    readonly publicReason: Schema.String;
+    readonly appealable: Schema.Boolean;
+}>;
+
+declare class SanctionsError extends SanctionsError_base {
+}
+
+declare const SanctionsError_base: Schema.Class<SanctionsError, Schema.TaggedStruct<"SanctionsError", {
+    readonly code: Schema.Literals<readonly ["identity_required", "invalid_input", "forbidden", "not_found", "conflict", "rate_limited", "sanctioned", "unavailable", "export_limit"]>;
+}>, YieldableError>;
+
+/** Opt-in; the caller supplies the actual service. No auth default or boot path is changed. */
+export declare const sanctionsLoginGuard: (service: Pick<SanctionsService, "check">) => SubjectGuard;
+
+declare interface SanctionsService {
+    readonly check: (subject: Subject, point: SanctionPoint, context?: SanctionCheckContext) => Effect.Effect<SanctionDecision, SanctionsError>;
+    readonly active: (subject: Subject) => Effect.Effect<ReadonlyArray<Sanction>, SanctionsError>;
+    readonly trust: (subject: Subject) => Effect.Effect<number, SanctionsError>;
+    readonly recordSignal: (subject: Subject, input: TrustedSanctionSignal) => Effect.Effect<void, SanctionsError>;
+}
+
+/** Request-side opt-in. Existing scope caches need explicit invalidation by the host app. */
+export declare const sanctionsSubjectGuard: (service: Pick<SanctionsService, "check">) => AuthSubjectGuard;
+
+declare interface TrustedSanctionSignal {
+    readonly tenantId: string;
+    readonly targetId: string;
+    readonly requestId: string;
+    readonly category: SanctionCategory;
+    readonly confidence: number;
+    readonly context?: ReportContext;
+}
+
+export { }

package/dist/guard.js

@@ -0,0 +1,16 @@
+import { Effect as e } from "effect";
+// src/guard.ts
+var t = {
+	ok: !1,
+	code: "sanctions_check_unavailable",
+	message: "Account policy could not be checked"
+}, n = {
+	ok: !1,
+	code: "account_sanctioned",
+	message: "Account policy prevents login"
+}, r = (r) => (i) => e.suspend(() => r.check({
+	type: "user",
+	id: i.id,
+	tenantId: i.tenantId
+}, "login")).pipe(e.map((e) => e.allowed ? { ok: !0 } : n), e.catch(() => e.succeed(t)), e.catchDefect(() => e.succeed(t))), i = (r) => async (i) => i.type === "user" ? e.runPromise(e.suspend(() => r.check(i, "login")).pipe(e.map((e) => e.allowed ? { ok: !0 } : n), e.catch(() => e.succeed(t)), e.catchDefect(() => e.succeed(t)))) : { ok: !0 };
+export { r as sanctionsLoginGuard, i as sanctionsSubjectGuard };