@atproto/ozone 0.1.146 → 0.1.147

package/src/lexicon/types/tools/ozone/moderation/getAccountTimeline.ts

@@ -88,6 +88,8 @@ export interface TimelineItemSummary {
     | 'tools.ozone.hosting.getAccountHistory#emailConfirmed'
     | 'tools.ozone.hosting.getAccountHistory#passwordUpdated'
     | 'tools.ozone.hosting.getAccountHistory#handleUpdated'
+    | 'tools.ozone.moderation.defs#scheduleTakedownEvent'
+    | 'tools.ozone.moderation.defs#cancelScheduledTakedownEvent'
     | (string & {})
   count: number
 }

package/src/lexicon/types/tools/ozone/moderation/listScheduledActions.ts

@@ -0,0 +1,57 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as ToolsOzoneModerationDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'tools.ozone.moderation.listScheduledActions'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  /** Filter actions scheduled to execute after this time */
+  startsAfter?: string
+  /** Filter actions scheduled to execute before this time */
+  endsBefore?: string
+  /** Filter actions for specific DID subjects */
+  subjects?: string[]
+  /** Filter actions by status */
+  statuses: ('pending' | 'executed' | 'cancelled' | 'failed' | (string & {}))[]
+  /** Maximum number of results to return */
+  limit: number
+  /** Cursor for pagination */
+  cursor?: string
+}
+
+export interface OutputSchema {
+  actions: ToolsOzoneModerationDefs.ScheduledActionView[]
+  /** Cursor for next page of results */
+  cursor?: string
+}
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess

package/src/lexicon/types/tools/ozone/moderation/scheduleAction.ts

@@ -0,0 +1,123 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as ToolsOzoneModerationDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'tools.ozone.moderation.scheduleAction'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  action: $Typed<Takedown> | { $type: string }
+  /** Array of DID subjects to schedule the action for */
+  subjects: string[]
+  createdBy: string
+  scheduling: SchedulingConfig
+  modTool?: ToolsOzoneModerationDefs.ModTool
+}
+
+export type OutputSchema = ScheduledActionResults
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess
+
+/** Schedule a takedown action */
+export interface Takedown {
+  $type?: 'tools.ozone.moderation.scheduleAction#takedown'
+  comment?: string
+  /** Indicates how long the takedown should be in effect before automatically expiring. */
+  durationInHours?: number
+  /** If true, all other reports on content authored by this account will be resolved (acknowledged). */
+  acknowledgeAccountSubjects?: boolean
+  /** Names/Keywords of the policies that drove the decision. */
+  policies?: string[]
+}
+
+const hashTakedown = 'takedown'
+
+export function isTakedown<V>(v: V) {
+  return is$typed(v, id, hashTakedown)
+}
+
+export function validateTakedown<V>(v: V) {
+  return validate<Takedown & V>(v, id, hashTakedown)
+}
+
+/** Configuration for when the action should be executed */
+export interface SchedulingConfig {
+  $type?: 'tools.ozone.moderation.scheduleAction#schedulingConfig'
+  /** Exact time to execute the action */
+  executeAt?: string
+  /** Earliest time to execute the action (for randomized scheduling) */
+  executeAfter?: string
+  /** Latest time to execute the action (for randomized scheduling) */
+  executeUntil?: string
+}
+
+const hashSchedulingConfig = 'schedulingConfig'
+
+export function isSchedulingConfig<V>(v: V) {
+  return is$typed(v, id, hashSchedulingConfig)
+}
+
+export function validateSchedulingConfig<V>(v: V) {
+  return validate<SchedulingConfig & V>(v, id, hashSchedulingConfig)
+}
+
+export interface ScheduledActionResults {
+  $type?: 'tools.ozone.moderation.scheduleAction#scheduledActionResults'
+  succeeded: string[]
+  failed: FailedScheduling[]
+}
+
+const hashScheduledActionResults = 'scheduledActionResults'
+
+export function isScheduledActionResults<V>(v: V) {
+  return is$typed(v, id, hashScheduledActionResults)
+}
+
+export function validateScheduledActionResults<V>(v: V) {
+  return validate<ScheduledActionResults & V>(v, id, hashScheduledActionResults)
+}
+
+export interface FailedScheduling {
+  $type?: 'tools.ozone.moderation.scheduleAction#failedScheduling'
+  subject: string
+  error: string
+  errorCode?: string
+}
+
+const hashFailedScheduling = 'failedScheduling'
+
+export function isFailedScheduling<V>(v: V) {
+  return is$typed(v, id, hashFailedScheduling)
+}
+
+export function validateFailedScheduling<V>(v: V) {
+  return validate<FailedScheduling & V>(v, id, hashFailedScheduling)
+}

package/src/mod-service/index.ts

@@ -39,6 +39,7 @@ import {
   isModEventTag,
   isModEventTakedown,
   isRecordEvent,
+  isScheduleTakedownEvent,
 } from '../lexicon/types/tools/ozone/moderation/defs'
 import { QueryParams as QueryStatusParams } from '../lexicon/types/tools/ozone/moderation/queryStatuses'
 import { httpLogger as log } from '../logger'
@@ -532,6 +533,18 @@ export class ModerationService {
       meta.status = event.status
     }
 
+    if (isScheduleTakedownEvent(event)) {
+      if (event.executeAfter) {
+        meta.executeAfter = event.executeAfter
+      }
+      if (event.executeAt) {
+        meta.executeAt = event.executeAt
+      }
+      if (event.executeUntil) {
+        meta.executeUntil = event.executeUntil
+      }
+    }
+
     if (
       (isModEventTakedown(event) || isModEventAcknowledge(event)) &&
       event.acknowledgeAccountSubjects

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",
+  },
+]
+`;