@atproto/ozone 0.1.53 → 0.1.55

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

@@ -22,6 +22,16 @@ export interface QueryParams {
   reportedBefore?: string
   /** Search subjects reviewed after a given timestamp */
   reviewedAfter?: string
+  /** Search subjects where the associated record/account was deleted after a given timestamp */
+  hostingDeletedAfter?: string
+  /** Search subjects where the associated record/account was deleted before a given timestamp */
+  hostingDeletedBefore?: string
+  /** Search subjects where the associated record/account was updated after a given timestamp */
+  hostingUpdatedAfter?: string
+  /** Search subjects where the associated record/account was updated before a given timestamp */
+  hostingUpdatedBefore?: string
+  /** Search subjects by the status of the associated record/account */
+  hostingStatuses?: string[]
   /** Search subjects reviewed before a given timestamp */
   reviewedBefore?: string
   /** By default, we don't include muted subjects in the results. Set this to true to include them. */

package/src/lexicon/types/tools/ozone/setting/defs.ts

@@ -0,0 +1,37 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+
+export interface Option {
+  key: string
+  did: string
+  value: {}
+  description?: string
+  createdAt?: string
+  updatedAt?: string
+  managerRole?:
+    | 'tools.ozone.team.defs#roleModerator'
+    | 'tools.ozone.team.defs#roleTriage'
+    | 'tools.ozone.team.defs#roleAdmin'
+    | (string & {})
+  scope: 'instance' | 'personal' | (string & {})
+  createdBy: string
+  lastUpdatedBy: string
+  [k: string]: unknown
+}
+
+export function isOption(v: unknown): v is Option {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'tools.ozone.setting.defs#option'
+  )
+}
+
+export function validateOption(v: unknown): ValidationResult {
+  return lexicons.validate('tools.ozone.setting.defs#option', v)
+}

package/src/lexicon/types/tools/ozone/setting/listOptions.ts

@@ -0,0 +1,53 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import * as ToolsOzoneSettingDefs from './defs'
+
+export interface QueryParams {
+  limit: number
+  cursor?: string
+  scope: 'instance' | 'personal' | (string & {})
+  /** Filter keys by prefix */
+  prefix?: string
+  /** Filter for only the specified keys. Ignored if prefix is provided */
+  keys?: string[]
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  cursor?: string
+  options: ToolsOzoneSettingDefs.Option[]
+  [k: string]: unknown
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

package/src/lexicon/types/tools/ozone/setting/removeOptions.ts

@@ -0,0 +1,49 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  keys: string[]
+  scope: 'instance' | 'personal' | (string & {})
+  [k: string]: unknown
+}
+
+export interface OutputSchema {
+  [k: string]: unknown
+}
+
+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 | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

package/src/lexicon/types/tools/ozone/setting/upsertOption.ts

@@ -0,0 +1,58 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import * as ToolsOzoneSettingDefs from './defs'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  key: string
+  scope: 'instance' | 'personal' | (string & {})
+  value: {}
+  description?: string
+  managerRole?:
+    | 'tools.ozone.team.defs#roleModerator'
+    | 'tools.ozone.team.defs#roleTriage'
+    | 'tools.ozone.team.defs#roleAdmin'
+    | (string & {})
+  [k: string]: unknown
+}
+
+export interface OutputSchema {
+  option: ToolsOzoneSettingDefs.Option
+  [k: string]: unknown
+}
+
+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 | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

package/src/mod-service/index.ts

@@ -18,6 +18,9 @@ import {
   isModEventTakedown,
   isModEventEmail,
   isModEventTag,
+  isAccountEvent,
+  isIdentityEvent,
+  isRecordEvent,
   REVIEWESCALATED,
   REVIEWOPEN,
 } from '../lexicon/types/tools/ozone/moderation/defs'
@@ -386,6 +389,25 @@ export class ModerationService {
       }
     }
 
+    if (isAccountEvent(event)) {
+      meta.active = event.active
+      meta.timestamp = event.timestamp
+      if (event.status) meta.status = event.status
+    }
+
+    if (isIdentityEvent(event)) {
+      meta.timestamp = event.timestamp
+      if (event.handle) meta.handle = event.handle
+      if (event.pdsHost) meta.pdsHost = event.pdsHost
+      if (event.tombstone) meta.tombstone = event.tombstone
+    }
+
+    if (isRecordEvent(event)) {
+      meta.timestamp = event.timestamp
+      meta.op = event.op
+      if (event.cid) meta.cid = event.cid
+    }
+
     if (isModEventTakedown(event) && event.acknowledgeAccountSubjects) {
       meta.acknowledgeAccountSubjects = true
     }
@@ -758,6 +780,11 @@ export class ModerationService {
     reportedAfter,
     reportedBefore,
     includeMuted,
+    hostingDeletedBefore,
+    hostingDeletedAfter,
+    hostingUpdatedBefore,
+    hostingUpdatedAfter,
+    hostingStatuses,
     onlyMuted,
     ignoreSubjects,
     sortDirection,
@@ -780,6 +807,11 @@ export class ModerationService {
     reportedAfter?: string
     reportedBefore?: string
     includeMuted?: boolean
+    hostingDeletedBefore?: string
+    hostingDeletedAfter?: string
+    hostingUpdatedBefore?: string
+    hostingUpdatedAfter?: string
+    hostingStatuses?: string[]
     onlyMuted?: boolean
     subject?: string
     ignoreSubjects?: string[]
@@ -847,6 +879,26 @@ export class ModerationService {
       builder = builder.where('lastReviewedAt', '<', reviewedBefore)
     }
 
+    if (hostingUpdatedAfter) {
+      builder = builder.where('hostingUpdatedAt', '>', hostingUpdatedAfter)
+    }
+
+    if (hostingUpdatedBefore) {
+      builder = builder.where('hostingUpdatedAt', '<', hostingUpdatedBefore)
+    }
+
+    if (hostingDeletedAfter) {
+      builder = builder.where('hostingDeletedAt', '>', hostingDeletedAfter)
+    }
+
+    if (hostingDeletedBefore) {
+      builder = builder.where('hostingDeletedAt', '<', hostingDeletedBefore)
+    }
+
+    if (hostingStatuses?.length) {
+      builder = builder.where('hostingStatus', 'in', hostingStatuses)
+    }
+
     if (reportedAfter) {
       builder = builder.where('lastReviewedAt', '>', reportedAfter)
     }

package/src/mod-service/status.ts

@@ -126,6 +126,83 @@ const getSubjectStatusForModerationEvent = ({
   }
 }
 
+const hostingEvents = [
+  'tools.ozone.moderation.defs#accountEvent',
+  'tools.ozone.moderation.defs#identityEvent',
+  'tools.ozone.moderation.defs#recordEvent',
+]
+
+const getSubjectStatusForRecordEvent = ({
+  event,
+  currentStatus,
+}: {
+  event: ModerationEventRow
+  currentStatus?: ModerationSubjectStatusRow
+}): Partial<ModerationSubjectStatusRow> => {
+  const timestamp =
+    typeof event.meta?.timestamp === 'string'
+      ? event.meta?.timestamp
+      : event.createdAt
+
+  if (event.action === 'tools.ozone.moderation.defs#recordEvent') {
+    if (event.meta?.op === 'delete') {
+      return {
+        hostingStatus: 'deleted',
+        hostingDeletedAt: timestamp,
+      }
+    } else if (event.meta?.op === 'update') {
+      return {
+        hostingStatus: 'active',
+        hostingUpdatedAt: timestamp,
+      }
+    }
+    return {}
+  }
+
+  if (event.action === 'tools.ozone.moderation.defs#accountEvent') {
+    const status: Partial<ModerationSubjectStatusRow> = {
+      hostingUpdatedAt: timestamp,
+    }
+
+    if (event.meta?.status) {
+      status.hostingStatus = `${event.meta?.status}`
+    }
+
+    if (event.meta?.status === 'deleted') {
+      status.hostingDeletedAt = timestamp
+    } else if (event.meta?.status === 'deactivated') {
+      status.hostingDeactivatedAt = timestamp
+    } else {
+      // When deactivated accounts are re-activated, we receive the event with just the active flag set to true
+      // so we want to make sure that the hostingStatus is not set to an outdated value
+      if (
+        currentStatus?.hostingStatus === 'deactivated' &&
+        event.meta?.active
+      ) {
+        status.hostingStatus = 'active'
+        status.hostingReactivatedAt = timestamp
+      }
+    }
+
+    return status
+  }
+
+  if (event.action === 'tools.ozone.moderation.defs#identityEvent') {
+    const status: Partial<ModerationSubjectStatusRow> = {
+      hostingUpdatedAt: timestamp,
+    }
+
+    if (event.meta?.tombstone) {
+      status.hostingStatus = 'tombstoned'
+      status.hostingDeletedAt = timestamp
+    }
+
+    return status
+  }
+
+  return {}
+}
+
 // Based on a given moderation action event, this function will update the moderation status of the subject
 // If there's no existing status, it will create one
 // If the action event does not affect the status, it will do nothing
@@ -133,7 +210,7 @@ export const adjustModerationSubjectStatus = async (
   db: Database,
   moderationEvent: ModerationEventRow,
   blobCids?: string[],
-) => {
+): Promise<ModerationSubjectStatusRow | null> => {
   const {
     action,
     subjectDid,
@@ -152,6 +229,7 @@ export const adjustModerationSubjectStatus = async (
 
   db.assertTransaction()
 
+  const now = new Date().toISOString()
   const currentStatus = await db.db
     .selectFrom('moderation_subject_status')
     .where('did', '=', identifier.did)
@@ -161,6 +239,41 @@ export const adjustModerationSubjectStatus = async (
     .selectAll()
     .executeTakeFirst()
 
+  if (hostingEvents.includes(action)) {
+    const newStatus = getSubjectStatusForRecordEvent({
+      event: moderationEvent,
+      currentStatus,
+    })
+    if (!Object.keys(newStatus).length) {
+      return currentStatus || null
+    }
+
+    const status = await db.db
+      .insertInto('moderation_subject_status')
+      .values({
+        ...identifier,
+        ...newStatus,
+        // newStatus doesn't contain a reviewState or takendown so in case this is a new entry
+        // we need to set a default values so that the insert doesn't fail
+        reviewState: currentStatus ? currentStatus.reviewState : REVIEWNONE,
+        // @TODO: should we try to update this based on status property of account event?
+        // For now we're the only one emitting takedowns so i don't think it makes too much of a difference
+        takendown: currentStatus ? currentStatus.takendown : false,
+        createdAt: now,
+        updatedAt: now,
+      })
+      .onConflict((oc) =>
+        oc.constraint('moderation_status_unique_idx').doUpdateSet({
+          ...newStatus,
+          updatedAt: now,
+        }),
+      )
+      .returningAll()
+      .executeTakeFirst()
+
+    return status || null
+  }
+
   // If reporting is muted for this reporter, we don't want to update the subject status
   if (meta?.isReporterMuted) {
     return currentStatus || null
@@ -178,7 +291,6 @@ export const adjustModerationSubjectStatus = async (
     durationInHours: moderationEvent.durationInHours,
   })
 
-  const now = new Date().toISOString()
   if (
     currentStatus?.reviewState === REVIEWESCALATED &&
     subjectStatus.reviewState !== REVIEWCLOSED

package/src/mod-service/types.ts

@@ -31,3 +31,28 @@ export type ModEventType =
   | ToolsOzoneModerationDefs.ModEventMute
   | ToolsOzoneModerationDefs.ModEventReverseTakedown
   | ToolsOzoneModerationDefs.ModEventTag
+  | ToolsOzoneModerationDefs.AccountEvent
+  | ToolsOzoneModerationDefs.IdentityEvent
+  | ToolsOzoneModerationDefs.RecordEvent
+
+type AccountHostingView = {
+  $type: 'tools.ozone.moderation.defs#accountHosting'
+  status: 'active' | 'takendown' | 'suspended' | 'deleted' | 'deactivated'
+  createdAt?: Date
+  updatedAt?: Date
+  deletedAt?: Date
+  deactivatedAt?: Date
+  reactivatedAt?: Date
+}
+
+type RecordHostingView = {
+  $type: 'tools.ozone.moderation.defs#recordHosting'
+  status: 'active' | 'deleted'
+  createdAt?: Date
+  updatedAt?: Date
+  deletedAt?: Date
+}
+
+export type ModerationSubjectHostingView =
+  | AccountHostingView
+  | RecordHostingView

package/src/mod-service/views.ts

@@ -1,6 +1,10 @@
 import { sql } from 'kysely'
 import { AtUri, INVALID_HANDLE, normalizeDatetimeAlways } from '@atproto/syntax'
-import { AtpAgent, AppBskyFeedDefs } from '@atproto/api'
+import {
+  AtpAgent,
+  AppBskyFeedDefs,
+  ToolsOzoneModerationDefs,
+} from '@atproto/api'
 import { dedupeStrs } from '@atproto/common'
 import { BlobRef } from '@atproto/lexicon'
 import { Keypair } from '@atproto/crypto'
@@ -195,6 +199,25 @@ export class ModerationViews {
       eventView.event.remove = event.removedTags || []
     }
 
+    if (event.action === 'tools.ozone.moderation.defs#accountEvent') {
+      eventView.event.active = !!event.meta?.active
+      eventView.event.timestamp = event.meta?.timestamp
+      eventView.event.status = event.meta?.status
+    }
+
+    if (event.action === 'tools.ozone.moderation.defs#identityEvent') {
+      eventView.event.timestamp = event.meta?.timestamp
+      eventView.event.handle = event.meta?.handle
+      eventView.event.pdsHost = event.meta?.pdsHost
+      eventView.event.tombstone = !!event.meta?.tombstone
+    }
+
+    if (event.action === 'tools.ozone.moderation.defs#recordEvent') {
+      eventView.event.op = event.meta?.op
+      eventView.event.cid = event.meta?.cid
+      eventView.event.timestamp = event.meta?.timestamp
+    }
+
     return eventView
   }
 
@@ -574,7 +597,7 @@ export class ModerationViews {
   formatSubjectStatus(
     status: ModerationSubjectStatusRowWithHandle,
   ): SubjectStatusView {
-    return {
+    const statusView: SubjectStatusView = {
       id: status.id,
       reviewState: status.reviewState,
       createdAt: status.createdAt,
@@ -594,6 +617,26 @@ export class ModerationViews {
       tags: status.tags || [],
       subject: subjectFromStatusRow(status).lex(),
     }
+
+    if (status.recordPath !== '') {
+      statusView.hosting = {
+        $type: 'tools.ozone.moderation.defs#recordHosting',
+        updatedAt: status.hostingUpdatedAt ?? undefined,
+        deletedAt: status.hostingDeletedAt ?? undefined,
+        status: status.hostingStatus ?? 'unknown',
+      }
+    } else {
+      statusView.hosting = {
+        $type: 'tools.ozone.moderation.defs#accountHosting',
+        updatedAt: status.hostingUpdatedAt ?? undefined,
+        deletedAt: status.hostingDeletedAt ?? undefined,
+        status: status.hostingStatus ?? 'unknown',
+        deactivatedAt: status.hostingDeactivatedAt ?? undefined,
+        reactivatedAt: status.hostingReactivatedAt ?? undefined,
+      }
+    }
+
+    return statusView
   }
 
   async fetchAuthorFeed(

package/src/setting/service.ts

@@ -0,0 +1,148 @@
+import Database from '../db'
+import { Selectable } from 'kysely'
+import { Option } from '../lexicon/types/tools/ozone/setting/defs'
+import { Setting, SettingScope } from '../db/schema/setting'
+import { Member } from '../db/schema/member'
+import assert from 'node:assert'
+import { InvalidRequestError } from '@atproto/xrpc-server'
+
+export type SettingServiceCreator = (db: Database) => SettingService
+
+export class SettingService {
+  constructor(public db: Database) {}
+
+  static creator() {
+    return (db: Database) => new SettingService(db)
+  }
+
+  async query({
+    limit = 100,
+    scope,
+    did,
+    cursor,
+    prefix,
+    keys,
+  }: {
+    limit: number
+    scope?: 'personal' | 'instance'
+    did?: string
+    cursor?: string
+    prefix?: string
+    keys?: string[]
+  }): Promise<{
+    options: Selectable<Setting>[]
+    cursor?: string
+  }> {
+    let builder = this.db.db.selectFrom('setting').selectAll()
+
+    if (prefix) {
+      builder = builder.where('key', 'like', `${prefix}%`)
+    } else if (keys?.length) {
+      builder = builder.where('key', 'in', keys)
+    }
+
+    if (scope) {
+      builder = builder.where('scope', '=', scope)
+    }
+
+    if (did) {
+      builder = builder.where('did', '=', did)
+    }
+
+    if (cursor) {
+      const cursorId = parseInt(cursor, 10)
+      if (isNaN(cursorId)) {
+        throw new InvalidRequestError('invalid cursor')
+      }
+      builder = builder.where('id', '<', cursorId)
+    }
+
+    const options = await builder.orderBy('id', 'desc').limit(limit).execute()
+
+    return {
+      options,
+      cursor: options[options.length - 1]?.id.toString(),
+    }
+  }
+
+  async upsert(
+    option: Omit<Setting, 'id' | 'createdAt' | 'updatedAt'> & {
+      createdAt: Date
+      updatedAt: Date
+    },
+  ): Promise<void> {
+    await this.db.db
+      .insertInto('setting')
+      .values(option)
+      .onConflict((oc) => {
+        return oc.columns(['key', 'scope', 'did']).doUpdateSet({
+          value: option.value,
+          updatedAt: option.updatedAt,
+          description: option.description,
+          managerRole: option.managerRole,
+          lastUpdatedBy: option.lastUpdatedBy,
+        })
+      })
+      .execute()
+  }
+
+  async removeOptions(
+    keys: string[],
+    filters: {
+      did?: string
+      scope: SettingScope
+      managerRole: Member['role'][]
+    },
+  ): Promise<void> {
+    if (!keys.length) return
+
+    if (filters.scope === 'personal') {
+      assert(filters.did, 'did is required for personal scope')
+    }
+
+    let qb = this.db.db
+      .deleteFrom('setting')
+      .where('key', 'in', keys)
+      .where('scope', '=', filters.scope)
+
+    if (filters.managerRole.length) {
+      qb = qb.where('managerRole', 'in', filters.managerRole)
+    } else {
+      qb = qb.where('managerRole', 'is', null)
+    }
+
+    if (filters.did) {
+      qb = qb.where('did', '=', filters.did)
+    }
+
+    await qb.execute()
+  }
+
+  view(setting: Selectable<Setting>): Option {
+    const {
+      key,
+      value,
+      did,
+      description,
+      createdAt,
+      createdBy,
+      updatedAt,
+      lastUpdatedBy,
+      managerRole,
+      scope,
+    } = setting
+
+    return {
+      key,
+      value,
+      did,
+      scope,
+      createdBy,
+      lastUpdatedBy,
+      managerRole: managerRole || undefined,
+      description: description || undefined,
+      createdAt: createdAt.toISOString(),
+      updatedAt: updatedAt.toISOString(),
+    }
+  }
+}