@atproto/ozone 0.1.46 → 0.1.47

package/src/api/moderation/getRepos.ts

@@ -0,0 +1,41 @@
+import { Server } from '../../lexicon'
+import AppContext from '../../context'
+import { addAccountInfoToRepoViewDetail, getPdsAccountInfos } from '../util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.moderation.getRepos({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ params, auth, req }) => {
+      const { dids } = params
+      const db = ctx.db
+      const labelers = ctx.reqLabelers(req)
+      const [partialRepos, accountInfo] = await Promise.all([
+        ctx.modService(db).views.repoDetails(dids, labelers),
+        getPdsAccountInfos(ctx, dids),
+      ])
+
+      const repos = dids.map((did) => {
+        const partialRepo = partialRepos.get(did)
+        if (!partialRepo) {
+          return {
+            did,
+            $type: 'tools.ozone.moderation.defs#repoViewNotFound',
+          }
+        }
+        return {
+          $type: 'tools.ozone.moderation.defs#repoViewDetail',
+          ...addAccountInfoToRepoViewDetail(
+            partialRepo,
+            accountInfo.get(did) || null,
+            auth.credentials.isModerator,
+          ),
+        }
+      })
+
+      return {
+        encoding: 'application/json',
+        body: { repos },
+      }
+    },
+  })
+}

package/src/api/util.ts

@@ -28,19 +28,26 @@ import {
 } from '../lexicon/types/tools/ozone/team/defs'
 import { ids } from '../lexicon/lexicons'
 
-export const getPdsAccountInfo = async (
+export const getPdsAccountInfos = async (
   ctx: AppContext,
-  did: string,
-): Promise<AccountView | null> => {
+  dids: string[],
+): Promise<Map<string, AccountView | null>> => {
+  const results = new Map<string, AccountView | null>()
+
   const agent = ctx.pdsAgent
-  if (!agent) return null
-  const auth = await ctx.pdsAuth(ids.ComAtprotoAdminGetAccountInfo)
-  if (!auth) return null
+  if (!agent) return results
+
+  const auth = await ctx.pdsAuth(ids.ComAtprotoAdminGetAccountInfos)
+  if (!auth) return results
+
   try {
-    const res = await agent.api.com.atproto.admin.getAccountInfo({ did }, auth)
-    return res.data
+    const res = await agent.com.atproto.admin.getAccountInfos({ dids }, auth)
+    res.data.infos.forEach((info) => {
+      results.set(info.did, info)
+    })
+    return results
   } catch {
-    return null
+    return results
   }
 }
 

package/src/db/migrations/20241001T205730722Z-subject-status-review-state-index.ts

@@ -0,0 +1,15 @@
+import { Kysely } from 'kysely'
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await db.schema
+    .createIndex('moderation_subject_status_review_state_idx')
+    .on('moderation_subject_status')
+    .column('reviewState')
+    .execute()
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await db.schema
+    .dropIndex('moderation_subject_status_review_state_idx')
+    .execute()
+}

package/src/db/migrations/index.ts

@@ -13,3 +13,4 @@ export * as _20240430T211332580Z from './20240521T211332580Z-member'
 export * as _20240814T003647759Z from './20240814T003647759Z-event-created-at-index'
 export * as _20240903T205730722Z from './20240903T205730722Z-add-template-lang'
 export * as _20240904T205730722Z from './20240904T205730722Z-add-subject-did-index'
+export * as _20241001T205730722Z from './20241001T205730722Z-subject-status-review-state-index'

package/src/lexicon/index.ts

@@ -166,7 +166,9 @@ import * as ToolsOzoneCommunicationUpdateTemplate from './types/tools/ozone/comm
 import * as ToolsOzoneModerationEmitEvent from './types/tools/ozone/moderation/emitEvent'
 import * as ToolsOzoneModerationGetEvent from './types/tools/ozone/moderation/getEvent'
 import * as ToolsOzoneModerationGetRecord from './types/tools/ozone/moderation/getRecord'
+import * as ToolsOzoneModerationGetRecords from './types/tools/ozone/moderation/getRecords'
 import * as ToolsOzoneModerationGetRepo from './types/tools/ozone/moderation/getRepo'
+import * as ToolsOzoneModerationGetRepos from './types/tools/ozone/moderation/getRepos'
 import * as ToolsOzoneModerationQueryEvents from './types/tools/ozone/moderation/queryEvents'
 import * as ToolsOzoneModerationQueryStatuses from './types/tools/ozone/moderation/queryStatuses'
 import * as ToolsOzoneModerationSearchRepos from './types/tools/ozone/moderation/searchRepos'
@@ -2262,6 +2264,17 @@ export class ToolsOzoneModerationNS {
     return this._server.xrpc.method(nsid, cfg)
   }
 
+  getRecords<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ToolsOzoneModerationGetRecords.Handler<ExtractAuth<AV>>,
+      ToolsOzoneModerationGetRecords.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'tools.ozone.moderation.getRecords' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
   getRepo<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,
@@ -2273,6 +2286,17 @@ export class ToolsOzoneModerationNS {
     return this._server.xrpc.method(nsid, cfg)
   }
 
+  getRepos<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ToolsOzoneModerationGetRepos.Handler<ExtractAuth<AV>>,
+      ToolsOzoneModerationGetRepos.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'tools.ozone.moderation.getRepos' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
   queryEvents<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,

package/src/lexicon/lexicons.ts

@@ -1686,6 +1686,11 @@ export const schemaDict = {
             },
           },
         },
+        errors: [
+          {
+            name: 'RecordNotFound',
+          },
+        ],
       },
     },
   },
@@ -11643,6 +11648,49 @@ export const schemaDict = {
       },
     },
   },
+  ToolsOzoneModerationGetRecords: {
+    lexicon: 1,
+    id: 'tools.ozone.moderation.getRecords',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get details about some records.',
+        parameters: {
+          type: 'params',
+          required: ['uris'],
+          properties: {
+            uris: {
+              type: 'array',
+              maxLength: 100,
+              items: {
+                type: 'string',
+                format: 'at-uri',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['records'],
+            properties: {
+              records: {
+                type: 'array',
+                items: {
+                  type: 'union',
+                  refs: [
+                    'lex:tools.ozone.moderation.defs#recordViewDetail',
+                    'lex:tools.ozone.moderation.defs#recordViewNotFound',
+                  ],
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   ToolsOzoneModerationGetRepo: {
     lexicon: 1,
     id: 'tools.ozone.moderation.getRepo',
@@ -11675,6 +11723,49 @@ export const schemaDict = {
       },
     },
   },
+  ToolsOzoneModerationGetRepos: {
+    lexicon: 1,
+    id: 'tools.ozone.moderation.getRepos',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get details about some repositories.',
+        parameters: {
+          type: 'params',
+          required: ['dids'],
+          properties: {
+            dids: {
+              type: 'array',
+              maxLength: 100,
+              items: {
+                type: 'string',
+                format: 'did',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['repos'],
+            properties: {
+              repos: {
+                type: 'array',
+                items: {
+                  type: 'union',
+                  refs: [
+                    'lex:tools.ozone.moderation.defs#repoViewDetail',
+                    'lex:tools.ozone.moderation.defs#repoViewNotFound',
+                  ],
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   ToolsOzoneModerationQueryEvents: {
     lexicon: 1,
     id: 'tools.ozone.moderation.queryEvents',
@@ -12491,7 +12582,9 @@ export const ids = {
   ToolsOzoneModerationEmitEvent: 'tools.ozone.moderation.emitEvent',
   ToolsOzoneModerationGetEvent: 'tools.ozone.moderation.getEvent',
   ToolsOzoneModerationGetRecord: 'tools.ozone.moderation.getRecord',
+  ToolsOzoneModerationGetRecords: 'tools.ozone.moderation.getRecords',
   ToolsOzoneModerationGetRepo: 'tools.ozone.moderation.getRepo',
+  ToolsOzoneModerationGetRepos: 'tools.ozone.moderation.getRepos',
   ToolsOzoneModerationQueryEvents: 'tools.ozone.moderation.queryEvents',
   ToolsOzoneModerationQueryStatuses: 'tools.ozone.moderation.queryStatuses',
   ToolsOzoneModerationSearchRepos: 'tools.ozone.moderation.searchRepos',

package/src/lexicon/types/com/atproto/repo/getRecord.ts

@@ -39,6 +39,7 @@ export interface HandlerSuccess {
 export interface HandlerError {
   status: number
   message?: string
+  error?: 'RecordNotFound'
 }
 
 export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough

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

@@ -0,0 +1,50 @@
+/**
+ * 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 ToolsOzoneModerationDefs from './defs'
+
+export interface QueryParams {
+  uris: string[]
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  records: (
+    | ToolsOzoneModerationDefs.RecordViewDetail
+    | ToolsOzoneModerationDefs.RecordViewNotFound
+    | { $type: string; [k: string]: unknown }
+  )[]
+  [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/moderation/getRepos.ts

@@ -0,0 +1,50 @@
+/**
+ * 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 ToolsOzoneModerationDefs from './defs'
+
+export interface QueryParams {
+  dids: string[]
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  repos: (
+    | ToolsOzoneModerationDefs.RepoViewDetail
+    | ToolsOzoneModerationDefs.RepoViewNotFound
+    | { $type: string; [k: string]: unknown }
+  )[]
+  [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/mod-service/views.ts

@@ -223,25 +223,33 @@ export class ModerationViews {
     }
   }
 
-  async repoDetail(
-    did: string,
+  async repoDetails(
+    dids: string[],
     labelers?: ParsedLabelers,
-  ): Promise<RepoViewDetail | undefined> {
+  ): Promise<Map<string, RepoView>> {
+    const results = new Map<string, RepoView>()
     const [repos, localLabels, externalLabels] = await Promise.all([
-      this.repos([did]),
-      this.labels(did),
-      this.getExternalLabels([did], labelers),
+      this.repos(dids),
+      this.labels(dids),
+      this.getExternalLabels(dids, labelers),
     ])
-    const repo = repos.get(did)
-    if (!repo) return
 
-    return {
-      ...repo,
-      moderation: {
-        ...repo.moderation,
-      },
-      labels: [...localLabels, ...externalLabels],
-    }
+    repos.forEach((repo, did) => {
+      const labels = [
+        ...(localLabels.get(did) || []),
+        ...(externalLabels.get(did) || []),
+      ]
+      const repoView = {
+        ...repo,
+        labels,
+        moderation: {
+          ...repo.moderation,
+        },
+      }
+      results.set(did, repoView)
+    })
+
+    return results
   }
 
   async fetchRecords(
@@ -308,47 +316,59 @@ export class ModerationViews {
     }, new Map<string, RecordView>())
   }
 
-  async recordDetail(
-    subject: RecordSubject,
+  async recordDetails(
+    subjects: RecordSubject[],
     labelers?: ParsedLabelers,
-  ): Promise<RecordViewDetail | undefined> {
-    const [records, subjectStatusesResult] = await Promise.all([
-      this.records([subject]),
-      this.getSubjectStatus([subject.uri]),
-    ])
-    const record = records.get(subject.uri)
-    if (!record) return undefined
+  ): Promise<Map<string, RecordViewDetail>> {
+    const subjectUris = subjects.map((s) => s.uri)
+    const [records, subjectStatusesResult, localLabels, externalLabels] =
+      await Promise.all([
+        this.records(subjects),
+        this.getSubjectStatus(subjectUris),
+        this.labels(subjectUris),
+        this.getExternalLabels(subjectUris, labelers),
+      ])
+
+    const results = new Map<string, RecordViewDetail>()
+
+    await Promise.all(
+      Array.from(records.entries()).map(async ([uri, record]) => {
+        const selfLabels = getSelfLabels({
+          uri: record.uri,
+          cid: record.cid,
+          record: record.value,
+        })
 
-    const status = subjectStatusesResult.get(subject.uri)
+        const status = subjectStatusesResult.get(uri)
+        const blobs = await this.blob(findBlobRefs(record.value))
 
-    const [blobs, labels, externalLabels, subjectStatus] = await Promise.all([
-      this.blob(findBlobRefs(record.value)),
-      this.labels(record.uri),
-      this.getExternalLabels([record.uri], labelers),
-      status ? this.formatSubjectStatus(status) : Promise.resolve(undefined),
-    ])
-    const selfLabels = getSelfLabels({
-      uri: record.uri,
-      cid: record.cid,
-      record: record.value,
-    })
+        results.set(uri, {
+          ...record,
+          blobs,
+          moderation: {
+            ...record.moderation,
+            subjectStatus: status
+              ? this.formatSubjectStatus(status)
+              : undefined,
+          },
+          labels: [
+            ...(localLabels.get(uri) || []),
+            ...selfLabels,
+            ...(externalLabels.get(uri) || []),
+          ],
+        })
+      }),
+    )
 
-    return {
-      ...record,
-      blobs,
-      moderation: {
-        ...record.moderation,
-        subjectStatus,
-      },
-      labels: [...labels, ...selfLabels, ...externalLabels],
-    }
+    return results
   }
 
   async getExternalLabels(
     subjects: string[],
     labelers?: ParsedLabelers,
-  ): Promise<Label[]> {
-    if (!labelers?.dids.length && !labelers?.redact.size) return []
+  ): Promise<Map<string, Label[]>> {
+    const results = new Map<string, Label[]>()
+    if (!labelers?.dids.length && !labelers?.redact.size) return results
     try {
       const {
         data: { labels },
@@ -356,13 +376,20 @@ export class ModerationViews {
         uriPatterns: subjects,
         sources: labelers.dids,
       })
-      return labels
+      labels.forEach((label) => {
+        if (!results.has(label.uri)) {
+          results.set(label.uri, [label])
+          return
+        }
+        results.get(label.uri)?.push(label)
+      })
+      return results
     } catch (err) {
       httpLogger.error(
         { err, subjects, labelers },
         'failed to resolve labels from appview',
       )
-      return []
+      return results
     }
   }
 
@@ -452,14 +479,28 @@ export class ModerationViews {
     })
   }
 
-  async labels(subject: string, includeNeg?: boolean): Promise<Label[]> {
+  async labels(
+    subjects: string[],
+    includeNeg?: boolean,
+  ): Promise<Map<string, Label[]>> {
+    const labels = new Map<string, Label[]>()
     const res = await this.db.db
       .selectFrom('label')
-      .where('label.uri', '=', subject)
+      .where('label.uri', 'in', subjects)
       .if(!includeNeg, (qb) => qb.where('neg', '=', false))
       .selectAll()
       .execute()
-    return Promise.all(res.map((l) => this.formatLabelAndEnsureSig(l)))
+
+    await Promise.all(
+      res.map(async (labelRow) => {
+        const signedLabel = await this.formatLabelAndEnsureSig(labelRow)
+        if (!labels.has(labelRow.uri)) {
+          labels.set(labelRow.uri, [])
+        }
+        labels.get(labelRow.uri)?.push(signedLabel)
+      }),
+    )
+    return labels
   }
 
   async formatLabelAndEnsureSig(row: LabelRow) {