@atproto/ozone 0.2.8 → 0.2.11

package/src/api/util.ts

@@ -1,265 +0,0 @@
-import { InvalidRequestError } from '@atproto/xrpc-server'
-import { AdminTokenOutput, ModeratorOutput } from '../auth-verifier.js'
-import { AppContext } from '../context.js'
-import { Member } from '../db/schema/member.js'
-import { ModerationEvent } from '../db/schema/moderation_event.js'
-import { ids } from '../lexicon/lexicons.js'
-import { AccountView } from '../lexicon/types/com/atproto/admin/defs.js'
-import { REASONAPPEAL } from '../lexicon/types/com/atproto/moderation/defs.js'
-import {
-  REVIEWCLOSED,
-  REVIEWESCALATED,
-  REVIEWNONE,
-  REVIEWOPEN,
-  RepoView,
-  RepoViewDetail,
-} from '../lexicon/types/tools/ozone/moderation/defs.js'
-import {
-  ROLEADMIN,
-  ROLEMODERATOR,
-  ROLETRIAGE,
-  ROLEVERIFIER,
-} from '../lexicon/types/tools/ozone/team/defs.js'
-import { ModerationSubjectStatusRow } from '../mod-service/types.js'
-
-export const getAuthDid = (
-  auth: ModeratorOutput | AdminTokenOutput,
-  serviceDid: string,
-): string | undefined => {
-  return auth.credentials.type === 'moderator'
-    ? auth.credentials.iss
-    : auth.credentials.type === 'admin_token'
-      ? serviceDid
-      : undefined
-}
-
-export const getPdsAccountInfos = async (
-  ctx: AppContext,
-  dids: string[],
-): Promise<Map<string, AccountView | null>> => {
-  const results = new Map<string, AccountView | null>()
-
-  const agent = ctx.pdsAgent
-  if (!agent || !dids.length) return results
-
-  const auth = await ctx.pdsAuth(ids.ComAtprotoAdminGetAccountInfos)
-  if (!auth) return results
-
-  try {
-    const res = await agent.com.atproto.admin.getAccountInfos({ dids }, auth)
-    res.data.infos.forEach((info) => {
-      results.set(info.did, info)
-    })
-    return results
-  } catch {
-    return results
-  }
-}
-
-function un$type<T extends object>(obj: T): Omit<T, '$type'> {
-  if ('$type' in obj) {
-    const { $type: _, ...rest } = obj
-    return rest
-  }
-  return obj
-}
-
-export const addAccountInfoToRepoViewDetail = (
-  repoView: RepoView | RepoViewDetail,
-  accountInfo: AccountView | null,
-  includeEmail = false,
-): RepoViewDetail => {
-  if (!accountInfo) {
-    return un$type({
-      ...repoView,
-      moderation: un$type(repoView.moderation),
-    })
-  }
-
-  const {
-    email,
-    deactivatedAt,
-    emailConfirmedAt,
-    inviteNote,
-    invitedBy,
-    invites,
-    invitesDisabled,
-    threatSignatures,
-    // pick some duplicate/unwanted details out
-    $type: _accountType,
-    did: _did,
-    handle: _handle,
-    indexedAt: _indexedAt,
-    relatedRecords: _relatedRecords,
-    ...otherAccountInfo
-  } = accountInfo
-  return {
-    ...otherAccountInfo,
-    ...un$type(repoView),
-    moderation: un$type(repoView.moderation),
-    email: includeEmail ? email : undefined,
-    invitedBy,
-    invitesDisabled,
-    inviteNote,
-    invites,
-    emailConfirmedAt,
-    deactivatedAt,
-    threatSignatures,
-  }
-}
-
-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,
-    deactivatedAt: accountInfo.deactivatedAt,
-    threatSignatures: accountInfo.threatSignatures,
-  }
-}
-
-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,
-  REVIEWNONE,
-])
-
-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#modEventMuteReporter',
-  'tools.ozone.moderation.defs#modEventUnmuteReporter',
-  'tools.ozone.moderation.defs#modEventReverseTakedown',
-  'tools.ozone.moderation.defs#modEventEmail',
-  'tools.ozone.moderation.defs#modEventResolveAppeal',
-  'tools.ozone.moderation.defs#modEventTag',
-  'tools.ozone.moderation.defs#modEventDivert',
-  'tools.ozone.moderation.defs#accountEvent',
-  'tools.ozone.moderation.defs#identityEvent',
-  'tools.ozone.moderation.defs#recordEvent',
-  'tools.ozone.moderation.defs#modEventPriorityScore',
-  'tools.ozone.moderation.defs#ageAssuranceEvent',
-  'tools.ozone.moderation.defs#ageAssuranceOverrideEvent',
-  'tools.ozone.moderation.defs#ageAssurancePurgeEvent',
-  'tools.ozone.moderation.defs#revokeAccountCredentialsEvent',
-  'tools.ozone.moderation.defs#scheduleTakedownEvent',
-  'tools.ozone.moderation.defs#cancelScheduledTakedownEvent',
-])
-
-export const getMemberRole = (role: string) => {
-  if (memberRoles.has(role)) {
-    return role as Member['role']
-  }
-  throw new InvalidRequestError('Invalid member role')
-}
-
-const memberRoles = new Set([
-  ROLEADMIN,
-  ROLEMODERATOR,
-  ROLETRIAGE,
-  ROLEVERIFIER,
-])
-
-export const OZONE_APPEAL_REASON_TYPE = 'tools.ozone.report.defs#reasonAppeal'
-const APPEAL_REASON_TYPES = [REASONAPPEAL, OZONE_APPEAL_REASON_TYPE]
-export const isAppealReport = (reasonType?: string): boolean => {
-  return !!reasonType && APPEAL_REASON_TYPES.includes(reasonType)
-}
-
-export const getSafelinkPattern = (pattern: string): SafelinkPatternType => {
-  if (safelinkPatterns.has(pattern)) {
-    return pattern as SafelinkPatternType
-  }
-  throw new InvalidRequestError('Invalid safelink pattern type')
-}
-
-export const getSafelinkAction = (action: string): SafelinkActionType => {
-  if (safelinkActions.has(action)) {
-    return action as SafelinkActionType
-  }
-  throw new InvalidRequestError('Invalid safelink action type')
-}
-
-export const getSafelinkReason = (reason: string): SafelinkReasonType => {
-  if (safelinkReasons.has(reason)) {
-    return reason as SafelinkReasonType
-  }
-  throw new InvalidRequestError('Invalid safelink reason type')
-}
-
-export const getSafelinkEventType = (eventType: string): SafelinkEventType => {
-  if (safelinkEventTypes.has(eventType)) {
-    return eventType as SafelinkEventType
-  }
-  throw new InvalidRequestError('Invalid safelink event type')
-}
-
-export type SafelinkEventType = 'addRule' | 'updateRule' | 'removeRule'
-export type SafelinkPatternType = 'domain' | 'url'
-export type SafelinkActionType = 'block' | 'warn' | 'whitelist'
-export type SafelinkReasonType = 'csam' | 'spam' | 'phishing' | 'none'
-
-const safelinkPatterns = new Set(['domain', 'url'])
-const safelinkActions = new Set(['block', 'warn', 'whitelist'])
-const safelinkReasons = new Set(['csam', 'spam', 'phishing', 'none'])
-const safelinkEventTypes = new Set(['addRule', 'updateRule', 'removeRule'])
-
-export const getScheduledActionType = (action: string): ScheduledActionType => {
-  if (scheduledActionTypes.has(action)) {
-    return action as ScheduledActionType
-  }
-  throw new InvalidRequestError('Invalid scheduled action type')
-}
-
-export const getScheduledActionStatus = (
-  status: string,
-): ScheduledActionStatus => {
-  if (scheduledActionStatuses.has(status)) {
-    return status as ScheduledActionStatus
-  }
-  throw new InvalidRequestError('Invalid scheduled action status')
-}
-
-export type ScheduledActionType = 'takedown'
-export type ScheduledActionStatus =
-  | 'pending'
-  | 'executed'
-  | 'cancelled'
-  | 'failed'
-
-const scheduledActionTypes = new Set(['takedown'])
-const scheduledActionStatuses = new Set([
-  'pending',
-  'executed',
-  'cancelled',
-  'failed',
-])

package/src/api/verification/grantVerifications.ts

@@ -1,90 +0,0 @@
-import { Selectable } from 'kysely'
-import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
-import { AppContext } from '../../context.js'
-import { Verification } from '../../db/schema/verification.js'
-import { Server } from '../../lexicon/index.js'
-import { getReposForVerifications } from '../../verification/util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.verification.grantVerifications({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input, auth, req }) => {
-      if (!ctx.cfg.verifier) {
-        throw new InvalidRequestError('Verifier not configured')
-      }
-
-      if (!auth.credentials.isVerifier) {
-        throw new AuthRequiredError(
-          'Must be an admin or verifier to grant verifications',
-        )
-      }
-
-      const modViews = ctx.modService(ctx.db).views
-      const profilesBefore = await modViews.getProfiles(
-        input.body.verifications.map((v) => v.subject),
-      )
-
-      // Filter out any subject for which, the current issuer already has a valid verification record indexed
-      const verificationsToBeGranted = input.body.verifications.filter(
-        (verificationInput) => {
-          const hasValidVerification = profilesBefore
-            .get(verificationInput.subject)
-            ?.verification?.verifications.find(
-              (v) => v.issuer === ctx.cfg.verifier?.did && v.isValid,
-            )
-          return !hasValidVerification
-        },
-      )
-
-      const verificationIssuer = ctx.verificationIssuer(ctx.cfg.verifier)
-      const verificationService = ctx.verificationService(ctx.db)
-      const { grantedVerifications, failedVerifications } =
-        await verificationIssuer.verify(verificationsToBeGranted)
-
-      if (!grantedVerifications.length) {
-        return {
-          encoding: 'application/json',
-          body: {
-            verifications: [],
-            failedVerifications,
-          },
-        }
-      }
-
-      const createdVerifications: Selectable<Verification>[] = []
-      const verificationEntries =
-        await verificationService.create(grantedVerifications)
-
-      const dids = new Set<string>([ctx.cfg.verifier.did])
-
-      for (const verification of verificationEntries) {
-        createdVerifications.push(verification)
-        dids.add(verification.subject)
-      }
-
-      const didsArr = Array.from(dids)
-      const [repos, profiles] = await Promise.all([
-        getReposForVerifications(
-          ctx,
-          ctx.reqLabelers(req),
-          ctx.modService(ctx.db),
-          didsArr,
-          auth.credentials.isModerator,
-        ),
-        modViews.getProfiles(didsArr),
-      ])
-      const verifications = verificationService.view(
-        createdVerifications,
-        repos,
-        profiles,
-      )
-      return {
-        encoding: 'application/json',
-        body: {
-          verifications,
-          failedVerifications,
-        },
-      }
-    },
-  })
-}

package/src/api/verification/listVerifications.ts

@@ -1,44 +0,0 @@
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import { getReposForVerifications } from '../../verification/util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.verification.listVerifications({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ req, params, auth }) => {
-      const modViews = ctx.modService(ctx.db).views
-      const verificationService = ctx.verificationService(ctx.db)
-      const { verifications, cursor } = await verificationService.list(params)
-
-      const dids = new Set<string>()
-      for (const verification of verifications) {
-        dids.add(verification.subject)
-        dids.add(verification.issuer)
-      }
-
-      const didsArr = Array.from(dids)
-      const [repos, profiles] = await Promise.all([
-        getReposForVerifications(
-          ctx,
-          ctx.reqLabelers(req),
-          ctx.modService(ctx.db),
-          didsArr,
-          auth.credentials.isModerator,
-        ),
-        modViews.getProfiles(didsArr),
-      ])
-
-      return {
-        encoding: 'application/json',
-        body: {
-          cursor,
-          verifications: verificationService.view(
-            verifications,
-            repos,
-            profiles,
-          ),
-        },
-      }
-    },
-  })
-}

package/src/api/verification/revokeVerifications.ts

@@ -1,43 +0,0 @@
-import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.verification.revokeVerifications({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input, auth }) => {
-      if (!ctx.cfg.verifier) {
-        throw new InvalidRequestError('Verifier not configured')
-      }
-
-      if (!auth.credentials.isVerifier) {
-        throw new AuthRequiredError(
-          'Must be an admin or verifier to revoke verifications',
-        )
-      }
-
-      const verificationIssuer = ctx.verificationIssuer(ctx.cfg.verifier)
-      const { uris, revokeReason } = input.body
-      const { revokedVerifications, failedRevocations } =
-        await verificationIssuer.revoke({ uris })
-
-      if (revokedVerifications.length) {
-        const verificationService = ctx.verificationService(ctx.db)
-        await verificationService.markRevoked({
-          uris: revokedVerifications,
-          revokeReason,
-          revokedBy:
-            'iss' in auth.credentials ? auth.credentials.iss : undefined,
-        })
-      }
-
-      return {
-        encoding: 'application/json',
-        body: {
-          revokedVerifications,
-          failedRevocations,
-        },
-      }
-    },
-  })
-}

package/src/api/well-known.ts

@@ -1,46 +0,0 @@
-import { Router } from 'express'
-import { AppContext } from '../context.js'
-
-export const createRouter = (ctx: AppContext): Router => {
-  const router = Router()
-
-  router.get('/.well-known/did.json', (_req, res) => {
-    const hostname =
-      ctx.cfg.service.publicUrl && new URL(ctx.cfg.service.publicUrl).hostname
-    if (!hostname || ctx.cfg.service.did !== `did:web:${hostname}`) {
-      return res.sendStatus(404)
-    }
-    res.json({
-      '@context': [
-        'https://www.w3.org/ns/did/v1',
-        'https://w3id.org/security/multikey/v1',
-      ],
-      id: ctx.cfg.service.did,
-      verificationMethod: [
-        {
-          id: `${ctx.cfg.service.did}#atproto_label`,
-          type: 'Multikey',
-          controller: ctx.cfg.service.did,
-          publicKeyMultibase: ctx.signingKey.did().replace('did:key:', ''),
-        },
-      ],
-      service: [
-        {
-          id: '#atproto_labeler',
-          type: 'AtprotoLabeler',
-          serviceEndpoint: `https://${hostname}`,
-        },
-      ],
-    })
-  })
-
-  router.get('/.well-known/ozone-metadata.json', (_req, res) => {
-    return res.json({
-      did: ctx.cfg.service.did,
-      url: ctx.cfg.service.publicUrl,
-      publicKey: ctx.signingKey.did(),
-    })
-  })
-
-  return router
-}