@atproto/ozone 0.2.9 → 0.2.11

package/src/mod-service/subject.ts

@@ -1,311 +0,0 @@
-import { AtUri } from '@atproto/syntax'
-import { InvalidRequestError } from '@atproto/xrpc-server'
-import * as ChatBskyConvoDefs from '../lexicon/types/chat/bsky/convo/defs.js'
-import { RepoRef, isRepoRef } from '../lexicon/types/com/atproto/admin/defs.js'
-import { InputSchema as ReportInput } from '../lexicon/types/com/atproto/moderation/createReport.js'
-import * as ComAtprotoRepoStrongRef from '../lexicon/types/com/atproto/repo/strongRef.js'
-import { InputSchema as ActionInput } from '../lexicon/types/tools/ozone/moderation/emitEvent.js'
-import { $Typed, asPredicate } from '../lexicon/util.js'
-import { ModerationEventRow, ModerationSubjectStatusRow } from './types.js'
-
-type SubjectInput = ReportInput['subject'] | ActionInput['subject']
-
-type StrongRef = ComAtprotoRepoStrongRef.Main
-const isStrongRef = asPredicate(ComAtprotoRepoStrongRef.validateMain)
-
-type MessageRef = ChatBskyConvoDefs.MessageRef
-const isValidMessageRef = asPredicate(ChatBskyConvoDefs.validateMessageRef)
-
-type ConvoRef = ChatBskyConvoDefs.ConvoRef
-const isValidConvoRef = asPredicate(ChatBskyConvoDefs.validateConvoRef)
-
-const isMessageRefWithoutConvoId = (
-  subject: unknown,
-): subject is $Typed<Omit<MessageRef, 'convoId'> & { convoId?: string }> =>
-  subject != null &&
-  typeof subject === 'object' &&
-  isValidMessageRef({ convoId: '', ...subject })
-
-/**
- * Cast subject input into ModSubject.
- * @description Represents the subject types that can appear in the moderation event stream.
- * NOTE: Downstream services should be updated to handle new subject types including appview.
- */
-export const subjectFromInput = (
-  subject: SubjectInput,
-  blobs?: string[],
-): ModSubject => {
-  if (isRepoRef(subject)) {
-    if (blobs && blobs.length > 0) {
-      throw new InvalidRequestError('Blobs do not apply to repo subjects')
-    }
-    return new RepoSubject(subject.did)
-  }
-  if (isStrongRef(subject)) {
-    return new RecordSubject(subject.uri, subject.cid, blobs)
-  }
-  // @NOTE #messageRef is not a report input for com.atproto.moderation.createReport.
-  // we are taking advantage of the open union in order for bsky.chat to interoperate here.
-  if (isValidMessageRef(subject)) {
-    return new MessageSubject(subject.did, subject.convoId, subject.messageId)
-  }
-  // @NOTE #convoRef is a new type for reporting entire conversations.
-  // Similar to messageRef, we take advantage of the open union to support this.
-  if (isValidConvoRef(subject)) {
-    return new ConvoSubject(subject.did, subject.convoId)
-  }
-  // @TODO we should start to require subject.convoId is a string in order to properly validate
-  // the #messageRef. temporarily allowing it to be optional as a stopgap for rollout.
-  // The next "if" can be removed once convoId is consistently provided.
-  if (isMessageRefWithoutConvoId(subject)) {
-    return new MessageSubject(
-      subject.did,
-      subject.convoId ?? '',
-      subject.messageId,
-    )
-  }
-
-  throw new InvalidRequestError('Invalid subject')
-}
-
-export const subjectFromEventRow = (row: ModerationEventRow): ModSubject => {
-  if (
-    row.subjectType === 'com.atproto.repo.strongRef' &&
-    row.subjectUri &&
-    row.subjectCid
-  ) {
-    return new RecordSubject(
-      row.subjectUri,
-      row.subjectCid,
-      row.subjectBlobCids ?? [],
-    )
-  } else if (
-    row.subjectType === 'chat.bsky.convo.defs#messageRef' &&
-    row.subjectMessageId
-  ) {
-    const convoId =
-      typeof row.meta?.['convoId'] === 'string' ? row.meta['convoId'] : ''
-    return new MessageSubject(row.subjectDid, convoId, row.subjectMessageId)
-  } else if (
-    row.subjectType === 'chat.bsky.convo.defs#convoRef' &&
-    row.subjectConvoId
-  ) {
-    return new ConvoSubject(row.subjectDid, row.subjectConvoId)
-  } else {
-    return new RepoSubject(row.subjectDid)
-  }
-}
-
-export const subjectFromStatusRow = (
-  row: ModerationSubjectStatusRow,
-): ModSubject => {
-  if (row.recordPath && row.recordCid) {
-    // Not too intuitive but the recordpath is basically <collection>/<rkey>
-    // which is what the last 2 params of .make() arguments are
-    const uri = AtUri.make(row.did, ...row.recordPath.split('/')).toString()
-    return new RecordSubject(uri.toString(), row.recordCid, row.blobCids ?? [])
-  } else if (row.convoId) {
-    // Conversation subject - restore from subject status row
-    return new ConvoSubject(row.did, row.convoId)
-  } else {
-    return new RepoSubject(row.did)
-  }
-}
-
-type SubjectInfo = {
-  subjectType:
-    | 'com.atproto.admin.defs#repoRef'
-    | 'com.atproto.repo.strongRef'
-    | 'chat.bsky.convo.defs#messageRef'
-    | 'chat.bsky.convo.defs#convoRef'
-  subjectDid: string
-  subjectUri: string | null
-  subjectCid: string | null
-  subjectBlobCids: string[] | null
-  subjectMessageId: string | null
-  subjectConvoId: string | null
-  meta: Record<string, string | undefined> | null
-}
-
-export interface ModSubject {
-  did: string
-  recordPath: string | undefined
-  convoId: string | undefined
-  blobCids?: string[]
-  isRepo(): this is RepoSubject
-  isRecord(): this is RecordSubject
-  isMessage(): this is MessageSubject
-  isConvo(): this is ConvoSubject
-  info(): SubjectInfo
-  lex():
-    | $Typed<RepoRef>
-    | $Typed<StrongRef>
-    | $Typed<MessageRef>
-    | $Typed<ConvoRef>
-}
-
-export class RepoSubject implements ModSubject {
-  blobCids = undefined
-  recordPath = undefined
-  convoId = undefined
-  constructor(public did: string) {}
-  isRepo(): this is RepoSubject {
-    return true
-  }
-  isRecord(): this is RecordSubject {
-    return false
-  }
-  isMessage(): this is MessageSubject {
-    return false
-  }
-  isConvo(): this is ConvoSubject {
-    return false
-  }
-  info() {
-    return {
-      subjectType: 'com.atproto.admin.defs#repoRef' as const,
-      subjectDid: this.did,
-      subjectUri: null,
-      subjectCid: null,
-      subjectBlobCids: null,
-      subjectMessageId: null,
-      subjectConvoId: null,
-      meta: null,
-    }
-  }
-  lex(): $Typed<RepoRef> {
-    return {
-      $type: 'com.atproto.admin.defs#repoRef',
-      did: this.did,
-    }
-  }
-}
-
-export class RecordSubject implements ModSubject {
-  parsedUri: AtUri
-  did: string
-  recordPath: string
-  convoId = undefined
-  constructor(
-    public uri: string,
-    public cid: string,
-    public blobCids?: string[],
-  ) {
-    this.parsedUri = new AtUri(uri)
-    this.did = this.parsedUri.hostname
-    this.recordPath = `${this.parsedUri.collection}/${this.parsedUri.rkey}`
-  }
-  isRepo(): this is RepoSubject {
-    return false
-  }
-  isRecord(): this is RecordSubject {
-    return true
-  }
-  isMessage(): this is MessageSubject {
-    return false
-  }
-  isConvo(): this is ConvoSubject {
-    return false
-  }
-  info() {
-    return {
-      subjectType: 'com.atproto.repo.strongRef' as const,
-      subjectDid: this.did,
-      subjectUri: this.uri,
-      subjectCid: this.cid,
-      subjectBlobCids: this.blobCids ?? [],
-      subjectMessageId: null,
-      subjectConvoId: null,
-      meta: null,
-    }
-  }
-  lex(): $Typed<StrongRef> {
-    return {
-      $type: 'com.atproto.repo.strongRef',
-      uri: this.uri,
-      cid: this.cid,
-    }
-  }
-}
-
-export class MessageSubject implements ModSubject {
-  blobCids = undefined
-  recordPath = undefined
-  constructor(
-    public did: string,
-    public convoId: string,
-    public messageId: string,
-  ) {}
-  isRepo(): this is RepoSubject {
-    return false
-  }
-  isRecord(): this is RecordSubject {
-    return false
-  }
-  isMessage(): this is MessageSubject {
-    return true
-  }
-  isConvo(): this is ConvoSubject {
-    return false
-  }
-  info() {
-    return {
-      subjectType: 'chat.bsky.convo.defs#messageRef' as const,
-      subjectDid: this.did,
-      subjectUri: null,
-      subjectCid: null,
-      subjectBlobCids: null,
-      subjectMessageId: this.messageId,
-      subjectConvoId: this.convoId,
-      meta: { convoId: this.convoId || undefined },
-    }
-  }
-  lex(): $Typed<MessageRef> {
-    return {
-      $type: 'chat.bsky.convo.defs#messageRef',
-      did: this.did,
-      convoId: this.convoId,
-      messageId: this.messageId,
-    }
-  }
-}
-
-export class ConvoSubject implements ModSubject {
-  blobCids = undefined
-  recordPath = undefined
-  constructor(
-    public did: string,
-    public convoId: string,
-  ) {}
-  isRepo(): this is RepoSubject {
-    return false
-  }
-  isRecord(): this is RecordSubject {
-    return false
-  }
-  isMessage(): this is MessageSubject {
-    return false
-  }
-  isConvo(): this is ConvoSubject {
-    return true
-  }
-  info() {
-    return {
-      subjectType: 'chat.bsky.convo.defs#convoRef' as const,
-      subjectDid: this.did,
-      subjectUri: null,
-      subjectCid: null,
-      subjectBlobCids: null,
-      subjectMessageId: null,
-      subjectConvoId: this.convoId,
-      meta: { convoId: this.convoId || undefined },
-    }
-  }
-  lex(): $Typed<ConvoRef> {
-    return {
-      $type: 'chat.bsky.convo.defs#convoRef',
-      did: this.did,
-      convoId: this.convoId,
-    }
-  }
-}

package/src/mod-service/types.ts

@@ -1,96 +0,0 @@
-import { type Selectable } from 'kysely'
-import { ModerationEvent } from '../db/schema/moderation_event.js'
-import { ModerationSubjectStatus } from '../db/schema/moderation_subject_status.js'
-import { ModEventView } from '../lexicon/types/tools/ozone/moderation/defs.js'
-import { ModSubject } from './subject.js'
-
-export type ModerationEventRow = Selectable<ModerationEvent>
-export type ReversibleModerationEvent = Pick<
-  ModerationEventRow,
-  'createdBy' | 'comment' | 'action'
-> & {
-  createdAt?: Date
-  subject: ModSubject
-}
-
-export type ModerationEventRowWithHandle = ModerationEventRow & {
-  subjectHandle?: string | null
-  creatorHandle?: string | null
-}
-export type ModerationSubjectStatusRow = Selectable<ModerationSubjectStatus>
-export type ModerationSubjectStatusRowWithStats = ModerationSubjectStatusRow & {
-  // account_events_stats
-  takedownCount: number | null
-  suspendCount: number | null
-  escalateCount: number | null
-  reportCount: number | null
-  appealCount: number | null
-
-  // account_record_events_stats
-  totalReports: number | null
-  reportedCount: number | null
-  escalatedCount: number | null
-  appealedCount: number | null
-
-  // account_record_status_stats
-  subjectCount: number | null
-  pendingCount: number | null
-  processedCount: number | null
-  takendownCount: number | null
-
-  // account_strike
-  strikeCount: number | null
-  totalStrikeCount: number | null
-  firstStrikeAt: string | null
-  lastStrikeAt: string | null
-}
-
-export type ModerationSubjectStatusRowWithHandle =
-  ModerationSubjectStatusRowWithStats & { handle: string | null }
-
-export type ModEventType = ModEventView['event']
-
-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
-
-export type ReporterStats = {
-  did: string
-  accountReportCount: number
-  recordReportCount: number
-  reportedAccountCount: number
-  reportedRecordCount: number
-  takendownAccountCount: number
-  takendownRecordCount: number
-  labeledAccountCount: number
-  labeledRecordCount: number
-}
-
-export type ReporterStatsResult = {
-  accountReportCount?: number
-  recordReportCount?: number
-  reportedAccountCount?: number
-  reportedRecordCount?: number
-  takendownAccountCount?: number
-  takendownRecordCount?: number
-  labeledAccountCount?: number
-  labeledRecordCount?: number
-}

package/src/mod-service/util.ts

@@ -1,99 +0,0 @@
-import net from 'node:net'
-import { sql } from 'kysely'
-import AtpAgent from '@atproto/api'
-import { cborEncode, noUndefinedVals } from '@atproto/common'
-import { Keypair } from '@atproto/crypto'
-import { IdResolver } from '@atproto/identity'
-import { LabelRow } from '../db/schema/label.js'
-import { DbRef } from '../db/types.js'
-import { Label } from '../lexicon/types/com/atproto/label/defs.js'
-
-export type SignedLabel = Label & { sig: Uint8Array }
-
-export const formatLabel = (row: LabelRow): Label => {
-  return noUndefinedVals({
-    ver: 1,
-    src: row.src,
-    uri: row.uri,
-    cid: row.cid === '' ? undefined : row.cid,
-    val: row.val,
-    neg: row.neg === true ? true : undefined,
-    cts: row.cts,
-    exp: row.exp ?? undefined,
-    sig: row.sig ? new Uint8Array(row.sig) : undefined,
-  } satisfies Label) as unknown as Label
-}
-
-export const formatLabelRow = (
-  label: Label,
-  signingKeyId?: number,
-): Omit<LabelRow, 'id'> => {
-  return {
-    src: label.src,
-    uri: label.uri,
-    cid: label.cid ?? '',
-    val: label.val,
-    neg: !!label.neg,
-    cts: label.cts,
-    exp: label.exp ?? null,
-    sig: label.sig ? Buffer.from(label.sig) : null,
-    signingKeyId: signingKeyId ?? null,
-  }
-}
-
-export const signLabel = async (
-  label: Label,
-  signingKey: Keypair,
-): Promise<SignedLabel> => {
-  const { ver, src, uri, cid, val, neg, cts, exp } = label
-  // @TODO cborEncode now ignores undefined properties, so we might not need to
-  // reformat the label here. We might want to consider this if we ever re-visit
-  // the logic below:
-  const reformatted = noUndefinedVals({
-    ver: ver ?? 1,
-    src,
-    uri,
-    cid,
-    val,
-    neg: neg === true ? true : undefined,
-    cts,
-    exp,
-  } satisfies Label) as unknown as Label
-
-  const bytes = cborEncode(reformatted)
-  const sig = await signingKey.sign(bytes)
-  return {
-    ...reformatted,
-    sig,
-  }
-}
-
-export const isSafeUrl = (url: URL) => {
-  if (url.protocol !== 'https:') return false
-  if (!url.hostname || url.hostname === 'localhost') return false
-  if (net.isIP(url.hostname) !== 0) return false
-  return true
-}
-
-export const getPdsAgentForRepo = async (
-  idResolver: IdResolver,
-  did: string,
-  devMode?: boolean,
-) => {
-  const { pds } = await idResolver.did.resolveAtprotoData(did)
-  const url = new URL(pds)
-  if (!devMode && !isSafeUrl(url)) {
-    return { url, agent: null }
-  }
-
-  return { url, agent: new AtpAgent({ service: url }) }
-}
-
-export const dateFromDatetime = (datetime: Date) => {
-  const [date] = datetime.toISOString().split('T')
-  return date
-}
-
-export const dateFromDbDatetime = (dateRef: DbRef) => {
-  return sql<string>`SPLIT_PART(${dateRef}, 'T', 1)`
-}