@atproto/ozone 0.0.16 → 0.0.17-next.1

package/src/api/{admin/createCommunicationTemplate.ts → communication/createTemplate.ts}

@@ -3,8 +3,8 @@ import { Server } from '../../lexicon'
 import AppContext from '../../context'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.admin.createCommunicationTemplate({
-    auth: ctx.authVerifier.modOrRole,
+  server.tools.ozone.communication.createTemplate({
+    auth: ctx.authVerifier.modOrAdminToken,
     handler: async ({ input, auth }) => {
       const access = auth.credentials
       const db = ctx.db

package/src/api/{admin/deleteCommunicationTemplate.ts → communication/deleteTemplate.ts}

@@ -3,8 +3,8 @@ import { Server } from '../../lexicon'
 import AppContext from '../../context'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.admin.deleteCommunicationTemplate({
-    auth: ctx.authVerifier.modOrRole,
+  server.tools.ozone.communication.deleteTemplate({
+    auth: ctx.authVerifier.modOrAdminToken,
     handler: async ({ input, auth }) => {
       const access = auth.credentials
       const db = ctx.db

package/src/api/{admin/listCommunicationTemplates.ts → communication/listTemplates.ts}

@@ -3,8 +3,8 @@ import { Server } from '../../lexicon'
 import AppContext from '../../context'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.admin.listCommunicationTemplates({
-    auth: ctx.authVerifier.modOrRole,
+  server.tools.ozone.communication.listTemplates({
+    auth: ctx.authVerifier.modOrAdminToken,
     handler: async ({ auth }) => {
       const access = auth.credentials
       const db = ctx.db

package/src/api/{admin/updateCommunicationTemplate.ts → communication/updateTemplate.ts}

@@ -3,8 +3,8 @@ import { Server } from '../../lexicon'
 import AppContext from '../../context'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.admin.updateCommunicationTemplate({
-    auth: ctx.authVerifier.modOrRole,
+  server.tools.ozone.communication.updateTemplate({
+    auth: ctx.authVerifier.modOrAdminToken,
     handler: async ({ input, auth }) => {
       const access = auth.credentials
       const db = ctx.db

package/src/api/index.ts

@@ -1,20 +1,20 @@
 import { Server } from '../lexicon'
 import AppContext from '../context'
-import createReport from './moderation/createReport'
-import emitModerationEvent from './admin/emitModerationEvent'
-import searchRepos from './admin/searchRepos'
-import adminGetRecord from './admin/getRecord'
-import getRepo from './admin/getRepo'
-import queryModerationStatuses from './admin/queryModerationStatuses'
-import queryModerationEvents from './admin/queryModerationEvents'
-import getModerationEvent from './admin/getModerationEvent'
+import createReport from './report/createReport'
+import emitEvent from './moderation/emitEvent'
+import searchRepos from './moderation/searchRepos'
+import adminGetRecord from './moderation/getRecord'
+import getRepo from './moderation/getRepo'
+import queryStatuses from './moderation/queryStatuses'
+import queryEvents from './moderation/queryEvents'
+import getEvent from './moderation/getEvent'
 import queryLabels from './label/queryLabels'
 import subscribeLabels from './label/subscribeLabels'
-import fetchLabels from './temp/fetchLabels'
-import createCommunicationTemplate from './admin/createCommunicationTemplate'
-import updateCommunicationTemplate from './admin/updateCommunicationTemplate'
-import deleteCommunicationTemplate from './admin/deleteCommunicationTemplate'
-import listCommunicationTemplates from './admin/listCommunicationTemplates'
+import fetchLabels from './label/fetchLabels'
+import createTemplate from './communication/createTemplate'
+import updateTemplate from './communication/updateTemplate'
+import deleteTemplate from './communication/deleteTemplate'
+import listTemplates from './communication/listTemplates'
 import proxied from './proxied'
 
 export * as health from './health'
@@ -23,20 +23,20 @@ export * as wellKnown from './well-known'
 
 export default function (server: Server, ctx: AppContext) {
   createReport(server, ctx)
-  emitModerationEvent(server, ctx)
+  emitEvent(server, ctx)
   searchRepos(server, ctx)
   adminGetRecord(server, ctx)
   getRepo(server, ctx)
-  getModerationEvent(server, ctx)
-  queryModerationEvents(server, ctx)
-  queryModerationStatuses(server, ctx)
+  getEvent(server, ctx)
+  queryEvents(server, ctx)
+  queryStatuses(server, ctx)
   queryLabels(server, ctx)
   subscribeLabels(server, ctx)
   fetchLabels(server, ctx)
-  listCommunicationTemplates(server, ctx)
-  createCommunicationTemplate(server, ctx)
-  updateCommunicationTemplate(server, ctx)
-  deleteCommunicationTemplate(server, ctx)
+  listTemplates(server, ctx)
+  createTemplate(server, ctx)
+  updateTemplate(server, ctx)
+  deleteTemplate(server, ctx)
   proxied(server, ctx)
   return server
 }

package/src/api/{temp → label}/fetchLabels.ts

@@ -1,6 +1,5 @@
 import { Server } from '../../lexicon'
 import AppContext from '../../context'
-import { formatLabel } from '../../mod-service/util'
 import {
   UNSPECCED_TAKEDOWN_BLOBS_LABEL,
   UNSPECCED_TAKEDOWN_LABEL,
@@ -8,7 +7,7 @@ import {
 
 export default function (server: Server, ctx: AppContext) {
   server.com.atproto.temp.fetchLabels({
-    auth: ctx.authVerifier.standardOptionalOrRole,
+    auth: ctx.authVerifier.standardOptionalOrAdminToken,
     handler: async ({ auth, params }) => {
       const { limit } = params
       const since =
@@ -29,7 +28,10 @@ export default function (server: Server, ctx: AppContext) {
         .limit(limit)
         .execute()
 
-      const labels = labelRes.map((l) => formatLabel(l))
+      const modSrvc = ctx.modService(ctx.db)
+      const labels = await Promise.all(
+        labelRes.map((l) => modSrvc.views.formatLabelAndEnsureSig(l)),
+      )
 
       return {
         encoding: 'application/json',

package/src/api/label/queryLabels.ts

@@ -2,7 +2,6 @@ import { Server } from '../../lexicon'
 import AppContext from '../../context'
 import { InvalidRequestError } from '@atproto/xrpc-server'
 import { sql } from 'kysely'
-import { formatLabel } from '../../mod-service/util'
 
 export default function (server: Server, ctx: AppContext) {
   server.com.atproto.label.queryLabels(async ({ params }) => {
@@ -44,7 +43,10 @@ export default function (server: Server, ctx: AppContext) {
 
     const res = await builder.execute()
 
-    const labels = res.map((l) => formatLabel(l))
+    const modSrvc = ctx.modService(ctx.db)
+    const labels = await Promise.all(
+      res.map((l) => modSrvc.views.formatLabelAndEnsureSig(l)),
+    )
     const resCursor = res.at(-1)?.id.toString(10)
 
     return {

package/src/api/moderation/emitEvent.ts

@@ -0,0 +1,218 @@
+import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
+import { Server } from '../../lexicon'
+import AppContext from '../../context'
+import {
+  isModEventDivert,
+  isModEventEmail,
+  isModEventLabel,
+  isModEventReverseTakedown,
+  isModEventTakedown,
+} from '../../lexicon/types/tools/ozone/moderation/defs'
+import { HandlerInput } from '../../lexicon/types/tools/ozone/moderation/emitEvent'
+import { subjectFromInput } from '../../mod-service/subject'
+import { ModerationLangService } from '../../mod-service/lang'
+import { retryHttp } from '../../util'
+import { ModeratorOutput, AdminTokenOutput } from '../../auth-verifier'
+
+const handleModerationEvent = async ({
+  ctx,
+  input,
+  auth,
+}: {
+  ctx: AppContext
+  input: HandlerInput
+  auth: ModeratorOutput | AdminTokenOutput
+}) => {
+  const access = auth.credentials
+  const createdBy =
+    auth.credentials.type === 'moderator'
+      ? auth.credentials.iss
+      : input.body.createdBy
+  const db = ctx.db
+  const moderationService = ctx.modService(db)
+  const { event } = input.body
+  const isTakedownEvent = isModEventTakedown(event)
+  const isReverseTakedownEvent = isModEventReverseTakedown(event)
+  const isLabelEvent = isModEventLabel(event)
+  const subject = subjectFromInput(
+    input.body.subject,
+    input.body.subjectBlobCids,
+  )
+
+  // apply access rules
+
+  // if less than moderator access then can only take ack and escalation actions
+  if (isTakedownEvent || isReverseTakedownEvent) {
+    if (!access.isModerator) {
+      throw new AuthRequiredError(
+        'Must be a full moderator to take this type of action',
+      )
+    }
+
+    // Non admins should not be able to take down feed generators
+    if (
+      !access.isAdmin &&
+      subject.recordPath?.includes('app.bsky.feed.generator/')
+    ) {
+      throw new AuthRequiredError(
+        'Must be a full admin to take this type of action on feed generators',
+      )
+    }
+  }
+  // if less than moderator access then can not apply labels
+  if (!access.isModerator && isLabelEvent) {
+    throw new AuthRequiredError('Must be a full moderator to label content')
+  }
+
+  if (isLabelEvent) {
+    validateLabels([
+      ...(event.createLabelVals ?? []),
+      ...(event.negateLabelVals ?? []),
+    ])
+  }
+
+  if (isTakedownEvent || isReverseTakedownEvent) {
+    const status = await moderationService.getStatus(subject)
+
+    if (status?.takendown && isTakedownEvent) {
+      throw new InvalidRequestError(`Subject is already taken down`)
+    }
+
+    if (!status?.takendown && isReverseTakedownEvent) {
+      throw new InvalidRequestError(`Subject is not taken down`)
+    }
+
+    if (status?.takendown && isReverseTakedownEvent && subject.isRecord()) {
+      // due to the way blob status is modeled, we should reverse takedown on all
+      // blobs for the record being restored, which aren't taken down on another record.
+      subject.blobCids = status.blobCids ?? []
+    }
+  }
+
+  if (isModEventEmail(event) && event.content) {
+    // sending email prior to logging the event to avoid a long transaction below
+    if (!subject.isRepo()) {
+      throw new InvalidRequestError('Email can only be sent to a repo subject')
+    }
+    const { content, subjectLine } = event
+    await retryHttp(() =>
+      ctx.modService(db).sendEmail({
+        subject: subjectLine,
+        content,
+        recipientDid: subject.did,
+      }),
+    )
+  }
+
+  if (isModEventDivert(event) && subject.isRecord()) {
+    if (!ctx.blobDiverter) {
+      throw new InvalidRequestError(
+        'BlobDiverter not configured for this service',
+      )
+    }
+    await ctx.blobDiverter.uploadBlobOnService(subject.info())
+  }
+
+  const moderationEvent = await db.transaction(async (dbTxn) => {
+    const moderationTxn = ctx.modService(dbTxn)
+
+    const result = await moderationTxn.logEvent({
+      event,
+      subject,
+      createdBy,
+    })
+
+    const moderationLangService = new ModerationLangService(moderationTxn)
+    await moderationLangService.tagSubjectWithLang({
+      subject,
+      createdBy: ctx.cfg.service.did,
+      subjectStatus: result.subjectStatus,
+    })
+
+    if (subject.isRepo()) {
+      if (isTakedownEvent) {
+        const isSuspend = !!result.event.durationInHours
+        await moderationTxn.takedownRepo(subject, result.event.id, isSuspend)
+      } else if (isReverseTakedownEvent) {
+        await moderationTxn.reverseTakedownRepo(subject)
+      }
+    }
+
+    if (subject.isRecord()) {
+      if (isTakedownEvent) {
+        await moderationTxn.takedownRecord(subject, result.event.id)
+      } else if (isReverseTakedownEvent) {
+        await moderationTxn.reverseTakedownRecord(subject)
+      }
+    }
+
+    if (isLabelEvent) {
+      await moderationTxn.formatAndCreateLabels(
+        result.event.subjectUri ?? result.event.subjectDid,
+        result.event.subjectCid,
+        {
+          create: result.event.createLabelVals?.length
+            ? result.event.createLabelVals.split(' ')
+            : undefined,
+          negate: result.event.negateLabelVals?.length
+            ? result.event.negateLabelVals.split(' ')
+            : undefined,
+        },
+      )
+    }
+
+    return result.event
+  })
+
+  return moderationService.views.formatEvent(moderationEvent)
+}
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.moderation.emitEvent({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ input, auth }) => {
+      const moderationEvent = await handleModerationEvent({
+        input,
+        auth,
+        ctx,
+      })
+
+      // On divert events, we need to automatically take down the blobs
+      if (isModEventDivert(input.body.event)) {
+        await handleModerationEvent({
+          auth,
+          ctx,
+          input: {
+            ...input,
+            body: {
+              ...input.body,
+              event: {
+                ...input.body.event,
+                $type: 'tools.ozone.moderation.defs#modEventTakedown',
+                comment:
+                  '[DIVERT_SIDE_EFFECT]: Automatically taking down after divert event',
+              },
+            },
+          },
+        })
+      }
+
+      return {
+        encoding: 'application/json',
+        body: moderationEvent,
+      }
+    },
+  })
+}
+
+const validateLabels = (labels: string[]) => {
+  for (const label of labels) {
+    for (const char of badChars) {
+      if (label.includes(char)) {
+        throw new InvalidRequestError(`Invalid label: ${label}`)
+      }
+    }
+  }
+}
+
+const badChars = [' ', ',', ';', `'`, `"`]

package/src/api/{admin/getModerationEvent.ts → moderation/getEvent.ts}

@@ -2,8 +2,8 @@ import { Server } from '../../lexicon'
 import AppContext from '../../context'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.admin.getModerationEvent({
-    auth: ctx.authVerifier.modOrRole,
+  server.tools.ozone.moderation.getEvent({
+    auth: ctx.authVerifier.modOrAdminToken,
     handler: async ({ params }) => {
       const { id } = params
       const db = ctx.db

package/src/api/{admin → moderation}/getRecord.ts

@@ -1,12 +1,12 @@
 import { InvalidRequestError } from '@atproto/xrpc-server'
 import { Server } from '../../lexicon'
 import AppContext from '../../context'
-import { addAccountInfoToRepoView, getPdsAccountInfo } from './util'
+import { addAccountInfoToRepoView, getPdsAccountInfo } from '../util'
 import { AtUri } from '@atproto/syntax'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.admin.getRecord({
-    auth: ctx.authVerifier.modOrRole,
+  server.tools.ozone.moderation.getRecord({
+    auth: ctx.authVerifier.modOrAdminToken,
     handler: async ({ params, auth }) => {
       const db = ctx.db
 

package/src/api/{admin → moderation}/getRepo.ts

@@ -1,11 +1,11 @@
 import { InvalidRequestError } from '@atproto/xrpc-server'
 import { Server } from '../../lexicon'
 import AppContext from '../../context'
-import { addAccountInfoToRepoViewDetail, getPdsAccountInfo } from './util'
+import { addAccountInfoToRepoViewDetail, getPdsAccountInfo } from '../util'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.admin.getRepo({
-    auth: ctx.authVerifier.modOrRole,
+  server.tools.ozone.moderation.getRepo({
+    auth: ctx.authVerifier.modOrAdminToken,
     handler: async ({ params, auth }) => {
       const { did } = params
       const db = ctx.db

package/src/api/{admin/queryModerationEvents.ts → moderation/queryEvents.ts}

@@ -1,10 +1,10 @@
 import { Server } from '../../lexicon'
 import AppContext from '../../context'
-import { getEventType } from '../moderation/util'
+import { getEventType } from '../util'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.admin.queryModerationEvents({
-    auth: ctx.authVerifier.modOrRole,
+  server.tools.ozone.moderation.queryEvents({
+    auth: ctx.authVerifier.modOrAdminToken,
     handler: async ({ params }) => {
       const {
         subject,

package/src/api/{admin/queryModerationStatuses.ts → moderation/queryStatuses.ts}

@@ -1,10 +1,10 @@
 import { Server } from '../../lexicon'
 import AppContext from '../../context'
-import { getReviewState } from '../moderation/util'
+import { getReviewState } from '../util'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.admin.queryModerationStatuses({
-    auth: ctx.authVerifier.modOrRole,
+  server.tools.ozone.moderation.queryStatuses({
+    auth: ctx.authVerifier.modOrAdminToken,
     handler: async ({ params }) => {
       const {
         subject,

package/src/api/{admin → moderation}/searchRepos.ts

@@ -3,8 +3,8 @@ import AppContext from '../../context'
 import { mapDefined } from '@atproto/common'
 
 export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.admin.searchRepos({
-    auth: ctx.authVerifier.modOrRole,
+  server.tools.ozone.moderation.searchRepos({
+    auth: ctx.authVerifier.modOrAdminToken,
     handler: async ({ params }) => {
       const modService = ctx.modService(ctx.db)
 

package/src/api/proxied.ts

@@ -3,7 +3,7 @@ import AppContext from '../context'
 
 export default function (server: Server, ctx: AppContext) {
   server.app.bsky.actor.getProfile({
-    auth: ctx.authVerifier.modOrRole,
+    auth: ctx.authVerifier.moderator,
     handler: async (request) => {
       const res = await ctx.appviewAgent.api.app.bsky.actor.getProfile(
         request.params,
@@ -17,7 +17,7 @@ export default function (server: Server, ctx: AppContext) {
   })
 
   server.app.bsky.actor.getProfiles({
-    auth: ctx.authVerifier.modOrRole,
+    auth: ctx.authVerifier.moderator,
     handler: async (request) => {
       const res = await ctx.appviewAgent.api.app.bsky.actor.getProfiles(
         request.params,
@@ -31,7 +31,7 @@ export default function (server: Server, ctx: AppContext) {
   })
 
   server.app.bsky.feed.getAuthorFeed({
-    auth: ctx.authVerifier.modOrRole,
+    auth: ctx.authVerifier.moderator,
     handler: async (request) => {
       const res = await ctx.appviewAgent.api.app.bsky.feed.getAuthorFeed(
         request.params,
@@ -45,7 +45,7 @@ export default function (server: Server, ctx: AppContext) {
   })
 
   server.app.bsky.feed.getPostThread({
-    auth: ctx.authVerifier.modOrRole,
+    auth: ctx.authVerifier.moderator,
     handler: async (request) => {
       const res = await ctx.appviewAgent.api.app.bsky.feed.getPostThread(
         request.params,
@@ -59,7 +59,7 @@ export default function (server: Server, ctx: AppContext) {
   })
 
   server.app.bsky.feed.getFeedGenerator({
-    auth: ctx.authVerifier.modOrRole,
+    auth: ctx.authVerifier.moderator,
     handler: async (request) => {
       const res = await ctx.appviewAgent.api.app.bsky.feed.getFeedGenerator(
         request.params,
@@ -73,7 +73,7 @@ export default function (server: Server, ctx: AppContext) {
   })
 
   server.app.bsky.graph.getFollows({
-    auth: ctx.authVerifier.modOrRole,
+    auth: ctx.authVerifier.moderator,
     handler: async (request) => {
       const res = await ctx.appviewAgent.api.app.bsky.graph.getFollows(
         request.params,
@@ -87,7 +87,7 @@ export default function (server: Server, ctx: AppContext) {
   })
 
   server.app.bsky.graph.getFollowers({
-    auth: ctx.authVerifier.modOrRole,
+    auth: ctx.authVerifier.moderator,
     handler: async (request) => {
       const res = await ctx.appviewAgent.api.app.bsky.graph.getFollowers(
         request.params,
@@ -101,7 +101,7 @@ export default function (server: Server, ctx: AppContext) {
   })
 
   server.app.bsky.graph.getList({
-    auth: ctx.authVerifier.modOrRole,
+    auth: ctx.authVerifier.moderator,
     handler: async (request) => {
       const res = await ctx.appviewAgent.api.app.bsky.graph.getList(
         request.params,

package/src/api/{moderation → report}/createReport.ts

@@ -1,6 +1,6 @@
 import { Server } from '../../lexicon'
 import AppContext from '../../context'
-import { getReasonType } from './util'
+import { getReasonType } from '../util'
 import { subjectFromInput } from '../../mod-service/subject'
 import { REASONAPPEAL } from '../../lexicon/types/com/atproto/moderation/defs'
 import { ForbiddenError } from '@atproto/xrpc-server'
@@ -8,8 +8,7 @@ import { ModerationLangService } from '../../mod-service/lang'
 
 export default function (server: Server, ctx: AppContext) {
   server.com.atproto.moderation.createReport({
-    // @TODO anonymous reports w/ optional auth are a temporary measure
-    auth: ctx.authVerifier.standardOptionalOrRole,
+    auth: ctx.authVerifier.standard,
     handler: async ({ input, auth }) => {
       const requester =
         'iss' in auth.credentials ? auth.credentials.iss : ctx.cfg.service.did

package/src/api/util.ts

@@ -0,0 +1,119 @@
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import { InputSchema as ReportInput } from '../lexicon/types/com/atproto/moderation/createReport'
+import {
+  REASONOTHER,
+  REASONSPAM,
+  REASONMISLEADING,
+  REASONRUDE,
+  REASONSEXUAL,
+  REASONVIOLATION,
+  REASONAPPEAL,
+} from '../lexicon/types/com/atproto/moderation/defs'
+import { AccountView } from '../lexicon/types/com/atproto/admin/defs'
+import {
+  RepoView,
+  RepoViewDetail,
+  REVIEWCLOSED,
+  REVIEWESCALATED,
+  REVIEWOPEN,
+} from '../lexicon/types/tools/ozone/moderation/defs'
+import { ModerationEvent } from '../db/schema/moderation_event'
+import { ModerationSubjectStatusRow } from '../mod-service/types'
+import AppContext from '../context'
+
+export const getPdsAccountInfo = async (
+  ctx: AppContext,
+  did: string,
+): Promise<AccountView | null> => {
+  const agent = ctx.pdsAgent
+  if (!agent) return null
+  const auth = await ctx.pdsAuth()
+  if (!auth) return null
+  try {
+    const res = await agent.api.com.atproto.admin.getAccountInfo({ did }, auth)
+    return res.data
+  } catch {
+    return null
+  }
+}
+
+export const addAccountInfoToRepoViewDetail = (
+  repoView: RepoViewDetail,
+  accountInfo: AccountView | null,
+  includeEmail = false,
+): RepoViewDetail => {
+  if (!accountInfo) return repoView
+  return {
+    ...repoView,
+    email: includeEmail ? accountInfo.email : undefined,
+    invitedBy: accountInfo.invitedBy,
+    invitesDisabled: accountInfo.invitesDisabled,
+    inviteNote: accountInfo.inviteNote,
+    invites: accountInfo.invites,
+    emailConfirmedAt: accountInfo.emailConfirmedAt,
+  }
+}
+
+export const addAccountInfoToRepoView = (
+  repoView: RepoView,
+  accountInfo: AccountView | null,
+  includeEmail = false,
+): RepoView => {
+  if (!accountInfo) return repoView
+  return {
+    ...repoView,
+    email: includeEmail ? accountInfo.email : undefined,
+    invitedBy: accountInfo.invitedBy,
+    invitesDisabled: accountInfo.invitesDisabled,
+    inviteNote: accountInfo.inviteNote,
+  }
+}
+
+export const getReasonType = (reasonType: ReportInput['reasonType']) => {
+  if (reasonTypes.has(reasonType)) {
+    return reasonType as NonNullable<ModerationEvent['meta']>['reportType']
+  }
+  throw new InvalidRequestError('Invalid reason type')
+}
+
+export const getEventType = (type: string) => {
+  if (eventTypes.has(type)) {
+    return type as ModerationEvent['action']
+  }
+  throw new InvalidRequestError('Invalid event type')
+}
+
+export const getReviewState = (reviewState?: string) => {
+  if (!reviewState) return undefined
+  if (reviewStates.has(reviewState)) {
+    return reviewState as ModerationSubjectStatusRow['reviewState']
+  }
+  throw new InvalidRequestError('Invalid review state')
+}
+
+const reviewStates = new Set([REVIEWCLOSED, REVIEWESCALATED, REVIEWOPEN])
+
+const reasonTypes = new Set([
+  REASONOTHER,
+  REASONSPAM,
+  REASONMISLEADING,
+  REASONRUDE,
+  REASONSEXUAL,
+  REASONVIOLATION,
+  REASONAPPEAL,
+])
+
+const eventTypes = new Set([
+  'tools.ozone.moderation.defs#modEventTakedown',
+  'tools.ozone.moderation.defs#modEventAcknowledge',
+  'tools.ozone.moderation.defs#modEventEscalate',
+  'tools.ozone.moderation.defs#modEventComment',
+  'tools.ozone.moderation.defs#modEventLabel',
+  'tools.ozone.moderation.defs#modEventReport',
+  'tools.ozone.moderation.defs#modEventMute',
+  'tools.ozone.moderation.defs#modEventUnmute',
+  'tools.ozone.moderation.defs#modEventReverseTakedown',
+  'tools.ozone.moderation.defs#modEventEmail',
+  'tools.ozone.moderation.defs#modEventResolveAppeal',
+  'tools.ozone.moderation.defs#modEventTag',
+])