@atproto/ozone 0.1.146 → 0.1.148

package/src/mod-service/profile.ts

@@ -4,6 +4,7 @@ import { OzoneConfig } from '../config'
 import {
   REASONAPPEAL,
   REASONMISLEADING,
+  REASONOTHER,
   REASONRUDE,
   REASONSEXUAL,
   REASONSPAM,
@@ -13,58 +14,53 @@ import { httpLogger } from '../logger'
 
 // Reverse mapping from new ozone namespaced reason types to old com.atproto namespaced reason types
 export const NEW_TO_OLD_REASON_MAPPING: Record<string, string> = {
-  'tools.ozone.report.defs#reasonMisleadingSpam': REASONSPAM,
-  'tools.ozone.report.defs#reasonRuleOther': REASONVIOLATION,
-  'tools.ozone.report.defs#reasonMisleadingOther': REASONMISLEADING,
-  'tools.ozone.report.defs#reasonSexualUnlabeled': REASONSEXUAL,
-  'tools.ozone.report.defs#reasonHarassmentOther': REASONRUDE,
   'tools.ozone.report.defs#reasonAppeal': REASONAPPEAL,
-  // Map all violence-related reasons to REASONVIOLATION
-  'tools.ozone.report.defs#reasonViolenceAnimalWelfare': REASONVIOLATION,
+  'tools.ozone.report.defs#reasonOther': REASONOTHER,
+
+  'tools.ozone.report.defs#reasonViolenceAnimal': REASONVIOLATION,
   'tools.ozone.report.defs#reasonViolenceThreats': REASONVIOLATION,
   'tools.ozone.report.defs#reasonViolenceGraphicContent': REASONVIOLATION,
-  'tools.ozone.report.defs#reasonViolenceSelfHarm': REASONVIOLATION,
   'tools.ozone.report.defs#reasonViolenceGlorification': REASONVIOLATION,
   'tools.ozone.report.defs#reasonViolenceExtremistContent': REASONVIOLATION,
   'tools.ozone.report.defs#reasonViolenceTrafficking': REASONVIOLATION,
   'tools.ozone.report.defs#reasonViolenceOther': REASONVIOLATION,
-  // Map all sexual-related reasons to REASONSEXUAL
+
   'tools.ozone.report.defs#reasonSexualAbuseContent': REASONSEXUAL,
   'tools.ozone.report.defs#reasonSexualNCII': REASONSEXUAL,
-  'tools.ozone.report.defs#reasonSexualSextortion': REASONSEXUAL,
   'tools.ozone.report.defs#reasonSexualDeepfake': REASONSEXUAL,
   'tools.ozone.report.defs#reasonSexualAnimal': REASONSEXUAL,
+  'tools.ozone.report.defs#reasonSexualUnlabeled': REASONSEXUAL,
   'tools.ozone.report.defs#reasonSexualOther': REASONSEXUAL,
-  // Map all child safety reasons to REASONVIOLATION
+
   'tools.ozone.report.defs#reasonChildSafetyCSAM': REASONVIOLATION,
   'tools.ozone.report.defs#reasonChildSafetyGroom': REASONVIOLATION,
-  'tools.ozone.report.defs#reasonChildSafetyMinorPrivacy': REASONVIOLATION,
-  'tools.ozone.report.defs#reasonChildSafetyEndangerment': REASONVIOLATION,
+  'tools.ozone.report.defs#reasonChildSafetyPrivacy': REASONVIOLATION,
   'tools.ozone.report.defs#reasonChildSafetyHarassment': REASONVIOLATION,
-  'tools.ozone.report.defs#reasonChildSafetyPromotion': REASONVIOLATION,
   'tools.ozone.report.defs#reasonChildSafetyOther': REASONVIOLATION,
-  // Map all harassment reasons to REASONRUDE
+
   'tools.ozone.report.defs#reasonHarassmentTroll': REASONRUDE,
   'tools.ozone.report.defs#reasonHarassmentTargeted': REASONRUDE,
   'tools.ozone.report.defs#reasonHarassmentHateSpeech': REASONRUDE,
   'tools.ozone.report.defs#reasonHarassmentDoxxing': REASONRUDE,
-  // Map all misleading reasons to REASONMISLEADING
+  'tools.ozone.report.defs#reasonHarassmentOther': REASONRUDE,
+
   'tools.ozone.report.defs#reasonMisleadingBot': REASONMISLEADING,
   'tools.ozone.report.defs#reasonMisleadingImpersonation': REASONMISLEADING,
+  'tools.ozone.report.defs#reasonMisleadingSpam': REASONSPAM,
   'tools.ozone.report.defs#reasonMisleadingScam': REASONMISLEADING,
-  'tools.ozone.report.defs#reasonMisleadingSyntheticContent': REASONMISLEADING,
-  'tools.ozone.report.defs#reasonMisleadingMisinformation': REASONMISLEADING,
-  // Map all rule-related reasons to REASONVIOLATION
+  'tools.ozone.report.defs#reasonMisleadingElections': REASONMISLEADING,
+  'tools.ozone.report.defs#reasonMisleadingOther': REASONMISLEADING,
+
   'tools.ozone.report.defs#reasonRuleSiteSecurity': REASONVIOLATION,
-  'tools.ozone.report.defs#reasonRuleStolenContent': REASONVIOLATION,
   'tools.ozone.report.defs#reasonRuleProhibitedSales': REASONVIOLATION,
   'tools.ozone.report.defs#reasonRuleBanEvasion': REASONVIOLATION,
-  // Map all civic reasons to REASONMISLEADING
-  'tools.ozone.report.defs#reasonCivicElectoralProcess': REASONMISLEADING,
-  'tools.ozone.report.defs#reasonCivicDisclosure': REASONMISLEADING,
-  'tools.ozone.report.defs#reasonCivicInterference': REASONMISLEADING,
-  'tools.ozone.report.defs#reasonCivicMisinformation': REASONMISLEADING,
-  'tools.ozone.report.defs#reasonCivicImpersonation': REASONMISLEADING,
+  'tools.ozone.report.defs#reasonRuleOther': REASONVIOLATION,
+
+  'tools.ozone.report.defs#reasonSelfHarmContent': REASONVIOLATION,
+  'tools.ozone.report.defs#reasonSelfHarmED': REASONVIOLATION,
+  'tools.ozone.report.defs#reasonSelfHarmStunts': REASONVIOLATION,
+  'tools.ozone.report.defs#reasonSelfHarmSubstances': REASONVIOLATION,
+  'tools.ozone.report.defs#reasonSelfHarmOther': REASONVIOLATION,
 }
 
 interface CacheEntry {

package/src/mod-service/views.ts

@@ -44,6 +44,7 @@ import {
   isModEventTag,
   isModEventTakedown,
   isRecordEvent,
+  isScheduleTakedownEvent,
 } from '../lexicon/types/tools/ozone/moderation/defs'
 import { Un$Typed, asPredicate } from '../lexicon/util'
 import { dbLogger, httpLogger } from '../logger'
@@ -262,6 +263,12 @@ export class ModerationViews {
       event.status = ifString(meta.status)!
     }
 
+    if (isScheduleTakedownEvent(event)) {
+      event.executeAt = ifString(meta.executeAt)
+      event.executeAfter = ifString(meta.executeAfter)
+      event.executeUntil = ifString(meta.executeUntil)
+    }
+
     return eventView
   }
 

package/src/scheduled-action/service.ts

@@ -0,0 +1,279 @@
+import { Selectable } from 'kysely'
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import { ScheduledActionStatus, ScheduledActionType } from '../api/util'
+import { Database } from '../db'
+import { ScheduledAction } from '../db/schema/scheduled-action'
+import { ScheduledActionView } from '../lexicon/types/tools/ozone/moderation/defs'
+import { dbLogger } from '../logger'
+import { SchedulingParams } from './types'
+
+export type ScheduledActionServiceCreator = (
+  db: Database,
+) => ScheduledActionService
+
+export class ScheduledActionService {
+  constructor(public db: Database) {}
+
+  static creator() {
+    return (db: Database) => new ScheduledActionService(db)
+  }
+
+  formatScheduledAction(
+    action: Selectable<ScheduledAction>,
+  ): ScheduledActionView {
+    return {
+      id: action.id,
+      action: action.action,
+      eventData: action.eventData as { [x: string]: unknown } | undefined,
+      did: action.did,
+      executeAt: action.executeAt
+        ? new Date(action.executeAt).toISOString()
+        : undefined,
+      executeAfter: action.executeAfter
+        ? new Date(action.executeAfter).toISOString()
+        : undefined,
+      executeUntil: action.executeUntil
+        ? new Date(action.executeUntil).toISOString()
+        : undefined,
+      randomizeExecution: action.randomizeExecution,
+      createdBy: action.createdBy,
+      createdAt: new Date(action.createdAt).toISOString(),
+      updatedAt: new Date(action.updatedAt).toISOString(),
+      status: action.status,
+      lastExecutedAt: action.lastExecutedAt
+        ? new Date(action.lastExecutedAt).toISOString()
+        : undefined,
+      lastFailureReason: action.lastFailureReason || undefined,
+      executionEventId: action.executionEventId || undefined,
+    }
+  }
+
+  async scheduleAction(
+    schedulingParams: SchedulingParams,
+  ): Promise<Selectable<ScheduledAction>> {
+    const { action, eventData, did, createdBy } = schedulingParams
+
+    // Only allow one pending action at a time for a given subject and action type
+    const existingAction = await this.getPendingActionForSubject(did, action)
+    if (existingAction) {
+      throw new InvalidRequestError(
+        'A pending scheduled action already exists for this subject',
+        'ActionAlreadyExists',
+      )
+    }
+
+    // When a time-range for action is specified, ensure that the range is valid
+    if (
+      'executeAfter' in schedulingParams &&
+      schedulingParams.executeAfter &&
+      schedulingParams.executeUntil &&
+      schedulingParams.executeAfter >= schedulingParams.executeUntil
+    ) {
+      throw new InvalidRequestError(
+        'executeAfter must be before executeUntil',
+        'InvalidScheduling',
+      )
+    }
+
+    const now = new Date().toISOString()
+    const randomizeExecution =
+      !('executeAt' in schedulingParams) && 'executeAfter' in schedulingParams
+
+    const scheduledAction = await this.db.db
+      .insertInto('scheduled_action')
+      .values({
+        action,
+        eventData: JSON.stringify(eventData),
+        did,
+        executeAt: randomizeExecution
+          ? null
+          : schedulingParams.executeAt?.toISOString(),
+        executeAfter: randomizeExecution
+          ? schedulingParams.executeAfter?.toISOString()
+          : null,
+        executeUntil: randomizeExecution
+          ? schedulingParams.executeUntil?.toISOString()
+          : null,
+        randomizeExecution,
+        createdBy,
+        createdAt: now,
+        updatedAt: now,
+        status: 'pending',
+      })
+      .returningAll()
+      .executeTakeFirstOrThrow()
+
+    return scheduledAction
+  }
+
+  async getPendingActionForSubject(
+    did: string,
+    action: ScheduledActionType,
+  ): Promise<Selectable<ScheduledAction> | null> {
+    const scheduledAction = await this.db.db
+      .selectFrom('scheduled_action')
+      .selectAll()
+      .where('did', '=', did)
+      .where('action', '=', action)
+      .where('status', '=', 'pending')
+      .executeTakeFirst()
+
+    return scheduledAction || null
+  }
+
+  async listScheduledActions({
+    cursor,
+    limit = 50,
+    startTime,
+    endTime,
+    subjects,
+    statuses = [],
+    direction = 'desc',
+  }: {
+    cursor?: string
+    limit?: number
+    startTime?: Date
+    endTime?: Date
+    subjects?: string[]
+    statuses: ScheduledActionStatus[]
+    direction?: 'asc' | 'desc'
+  }): Promise<{
+    actions: Selectable<ScheduledAction>[]
+    cursor?: string
+  }> {
+    let query = this.db.db
+      .selectFrom('scheduled_action')
+      .where('status', 'in', statuses)
+      .selectAll()
+
+    if (subjects && subjects.length > 0) {
+      query = query.where('did', 'in', subjects)
+    }
+
+    if (startTime) {
+      query = query.where((qb) => {
+        return qb
+          .orWhere('executeAt', '>=', startTime.toISOString())
+          .orWhere('executeAfter', '>=', startTime.toISOString())
+      })
+    }
+
+    if (endTime) {
+      query = query.where((qb) => {
+        return qb
+          .orWhere('executeAt', '<=', endTime.toISOString())
+          .orWhere('executeUntil', '<=', endTime.toISOString())
+          .orWhere((sqb) => {
+            return sqb
+              .where('executeUntil', 'is', null)
+              .where('executeAfter', '<=', endTime.toISOString())
+          })
+      })
+    }
+
+    if (cursor) {
+      query = query.where(
+        'id',
+        direction === 'asc' ? '>' : '<',
+        parseInt(cursor, 10),
+      )
+    }
+
+    const actions = await query.orderBy('id', direction).limit(limit).execute()
+
+    return {
+      actions,
+      cursor: actions.at(-1)?.id?.toString(),
+    }
+  }
+
+  async cancelScheduledActions(subjects: string[]): Promise<{
+    succeeded: string[]
+    failed: { did: string; error: string; errorCode?: string }[]
+  }> {
+    const succeeded: string[] = []
+    const failed: { did: string; error: string; errorCode?: string }[] = []
+
+    for (const did of subjects) {
+      try {
+        const result = await this.db.db
+          .updateTable('scheduled_action')
+          .set({
+            status: 'cancelled',
+            updatedAt: new Date().toISOString(),
+          })
+          .where('did', '=', did)
+          .where('status', '=', 'pending')
+          .executeTakeFirst()
+
+        if (result.numUpdatedRows && result.numUpdatedRows > 0) {
+          succeeded.push(did)
+        } else {
+          failed.push({
+            did,
+            error: 'No pending scheduled actions found for subject',
+            errorCode: 'NoPendingActions',
+          })
+        }
+      } catch (err) {
+        dbLogger.error({ err, subjects }, 'Error cancelling scheduled action')
+        failed.push({
+          did,
+          error: 'Unknown error',
+          errorCode: 'DatabaseError',
+        })
+      }
+    }
+
+    return { succeeded, failed }
+  }
+
+  async getPendingActionsToExecute(
+    now: Date,
+  ): Promise<Selectable<ScheduledAction>[]> {
+    return await this.db.db
+      .selectFrom('scheduled_action')
+      .selectAll()
+      .where('status', '=', 'pending')
+      .where((qb) => {
+        return qb
+          .orWhere('executeAfter', '<=', now.toISOString())
+          .orWhere('executeAt', '<=', now.toISOString())
+      })
+      .execute()
+  }
+
+  async markActionAsExecuted(
+    actionId: number,
+    executionEventId: number,
+  ): Promise<void> {
+    const now = new Date().toISOString()
+    await this.db.db
+      .updateTable('scheduled_action')
+      .set({
+        status: 'executed',
+        lastExecutedAt: now,
+        executionEventId,
+        updatedAt: now,
+      })
+      .where('id', '=', actionId)
+      .execute()
+  }
+
+  async markActionAsFailed(
+    actionId: number,
+    failureReason: string,
+  ): Promise<void> {
+    const now = new Date().toISOString()
+    await this.db.db
+      .updateTable('scheduled_action')
+      .set({
+        status: 'failed',
+        lastExecutedAt: now,
+        lastFailureReason: failureReason,
+        updatedAt: now,
+      })
+      .where('id', '=', actionId)
+      .execute()
+  }
+}

package/src/scheduled-action/types.ts

@@ -0,0 +1,17 @@
+import { ScheduledActionType } from '../api/util'
+
+export type ExecutionSchedule =
+  | {
+      executeAt: Date
+    }
+  | {
+      executeAfter: Date
+      executeUntil?: Date
+    }
+
+export type SchedulingParams = {
+  action: ScheduledActionType
+  eventData: unknown
+  did: string
+  createdBy: string
+} & ExecutionSchedule

package/tests/__snapshots__/scheduled-action.test.ts.snap

@@ -0,0 +1,61 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`scheduled action management listScheduledActions allows moderators to list all scheduled actions 1`] = `
+Array [
+  Object {
+    "action": "takedown",
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(1)",
+    "did": "user(0)",
+    "eventData": Object {
+      "$type": "tools.ozone.moderation.scheduleAction#takedown",
+      "comment": "test",
+      "policies": Array [
+        "spam",
+      ],
+    },
+    "executeAfter": "1970-01-01T00:00:00.000Z",
+    "executeUntil": "1970-01-01T00:00:00.000Z",
+    "id": 3,
+    "randomizeExecution": true,
+    "status": "pending",
+    "updatedAt": "1970-01-01T00:00:00.000Z",
+  },
+  Object {
+    "action": "takedown",
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(1)",
+    "did": "user(2)",
+    "eventData": Object {
+      "$type": "tools.ozone.moderation.scheduleAction#takedown",
+      "comment": "test",
+      "policies": Array [
+        "spam",
+      ],
+    },
+    "executeAt": "1970-01-01T00:00:00.000Z",
+    "id": 2,
+    "randomizeExecution": false,
+    "status": "pending",
+    "updatedAt": "1970-01-01T00:00:00.000Z",
+  },
+  Object {
+    "action": "takedown",
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(1)",
+    "did": "user(3)",
+    "eventData": Object {
+      "$type": "tools.ozone.moderation.scheduleAction#takedown",
+      "comment": "test",
+      "policies": Array [
+        "spam",
+      ],
+    },
+    "executeAt": "1970-01-01T00:00:00.000Z",
+    "id": 1,
+    "randomizeExecution": false,
+    "status": "pending",
+    "updatedAt": "1970-01-01T00:00:00.000Z",
+  },
+]
+`;