@atproto/ozone 0.2.9 → 0.2.11

package/src/api/report/queryActivities.ts

@@ -1,64 +0,0 @@
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import { ReportView } from '../../lexicon/types/tools/ozone/report/defs.js'
-import { getReportsByIds } from '../../mod-service/report.js'
-import {
-  formatActivityView,
-  queryReportActivities,
-} from '../../report/activity.js'
-import { buildReportView, hydrateReportInfo } from '../../report/views.js'
-import { getPdsAccountInfos } from '../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.report.queryActivities({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ params, auth, req }) => {
-      const db = ctx.db
-      const modService = ctx.modService(db)
-      const labelers = ctx.reqLabelers(req)
-
-      const { activities, cursor: nextCursor } = await queryReportActivities(
-        db,
-        params,
-      )
-
-      // Dedupe report IDs across the page. Many activities can share the
-      // same report so we want one bulk fetch + hydrate rather than N.
-      const reportIds = Array.from(new Set(activities.map((a) => a.reportId)))
-
-      const queueService = ctx.queueService(db)
-      const teamService = ctx.teamService(db)
-      const reports = await getReportsByIds(db, reportIds)
-      const hydrated = await hydrateReportInfo(
-        reports,
-        modService.views,
-        (dids) => getPdsAccountInfos(ctx, dids),
-        (queueIds) => queueService.getViewsByIds(queueIds),
-        (dids) => teamService.viewByDids(dids),
-        labelers,
-      )
-      const reportViews = new Map<number, ReportView>()
-      for (const report of reports) {
-        reportViews.set(
-          report.id,
-          buildReportView(report, hydrated, auth.credentials.isModerator),
-        )
-      }
-
-      const createdByDids = Array.from(
-        new Set(activities.map((a) => a.createdBy)),
-      )
-      const memberViews = await teamService.viewByDids(createdByDids)
-
-      return {
-        encoding: 'application/json',
-        body: {
-          activities: activities.map((activity) =>
-            formatActivityView(activity, memberViews, reportViews),
-          ),
-          cursor: nextCursor,
-        },
-      }
-    },
-  })
-}

package/src/api/report/queryReports.ts

@@ -1,44 +0,0 @@
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import { queryReports } from '../../mod-service/report.js'
-import { buildReportView, hydrateReportInfo } from '../../report/views.js'
-import { getPdsAccountInfos } from '../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.report.queryReports({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ params, auth, req }) => {
-      const db = ctx.db
-      const modService = ctx.modService(db)
-      const labelers = ctx.reqLabelers(req)
-
-      const { reports: reportsToReturn, cursor } = await queryReports(
-        db,
-        params,
-      )
-
-      const queueService = ctx.queueService(db)
-      const teamService = ctx.teamService(db)
-      const hydrated = await hydrateReportInfo(
-        reportsToReturn,
-        modService.views,
-        (dids) => getPdsAccountInfos(ctx, dids),
-        (queueIds) => queueService.getViewsByIds(queueIds),
-        (dids) => teamService.viewByDids(dids),
-        labelers,
-      )
-
-      const reportViews = reportsToReturn.map((report) =>
-        buildReportView(report, hydrated, auth.credentials.isModerator),
-      )
-
-      return {
-        encoding: 'application/json',
-        body: {
-          cursor,
-          reports: reportViews,
-        },
-      }
-    },
-  })
-}

package/src/api/report/reassignQueue.ts

@@ -1,68 +0,0 @@
-import { InvalidRequestError } from '@atproto/xrpc-server'
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import { getReportById } from '../../mod-service/report.js'
-import { reassignReportQueue } from '../../report/reassign.js'
-import { buildReportView, hydrateReportInfo } from '../../report/views.js'
-import { getAuthDid, getPdsAccountInfos } from '../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.report.reassignQueue({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input, auth, req }) => {
-      const createdBy =
-        getAuthDid(auth, ctx.cfg.service.did) ?? ctx.cfg.service.did
-      const db = ctx.db
-      const queueService = ctx.queueService(db)
-
-      await reassignReportQueue(db, queueService, {
-        reportId: input.body.reportId,
-        toQueueId: input.body.queueId,
-        comment: input.body.comment,
-        createdBy,
-      })
-
-      const report = await getReportById(db, input.body.reportId)
-      if (!report) {
-        throw new InvalidRequestError(
-          `Report ${input.body.reportId} not found after reassignment`,
-          'ReportNotFound',
-        )
-      }
-
-      const modService = ctx.modService(db)
-      const teamService = ctx.teamService(db)
-      const labelers = ctx.reqLabelers(req)
-
-      const [hydrated, actionEvents] = await Promise.all([
-        hydrateReportInfo(
-          [report],
-          modService.views,
-          (dids) => getPdsAccountInfos(ctx, dids),
-          (queueIds) => queueService.getViewsByIds(queueIds),
-          (dids) => teamService.viewByDids(dids),
-          labelers,
-        ),
-        Array.isArray(report.actionEventIds) && report.actionEventIds.length
-          ? modService.getEventsByIds(report.actionEventIds as number[])
-          : Promise.resolve([]),
-      ])
-
-      const actions = actionEvents.map((evt) =>
-        modService.views.formatEvent(evt),
-      )
-
-      return {
-        encoding: 'application/json',
-        body: {
-          report: buildReportView(
-            report,
-            hydrated,
-            auth.credentials.isModerator,
-            actions,
-          ),
-        },
-      }
-    },
-  })
-}

package/src/api/report/refreshStats.ts

@@ -1,27 +0,0 @@
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.report.refreshStats({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input, auth }) => {
-      const access = auth.credentials
-      if (!access.isModerator) {
-        throw new Error('Must be a moderator to refresh stats')
-      }
-
-      const { startDate, endDate, queueIds } = input.body
-      const reportStatsService = ctx.reportStatsService(ctx.db)
-      await reportStatsService.refreshDateRange({
-        startDate,
-        endDate,
-        queueIds,
-      })
-
-      return {
-        encoding: 'application/json',
-        body: {},
-      }
-    },
-  })
-}

package/src/api/report/unassignModerator.ts

@@ -1,21 +0,0 @@
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import { getAuthDid } from '../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.report.unassignModerator({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input, auth }) => {
-      const authDid = getAuthDid(auth, ctx.cfg.service.did)
-      const result = await ctx.assignmentService.unassignReport({
-        reportId: input.body.reportId,
-        createdBy: authDid,
-      })
-
-      return {
-        encoding: 'application/json',
-        body: result,
-      }
-    },
-  })
-}

package/src/api/safelink/addRule.ts

@@ -1,48 +0,0 @@
-import { AuthRequiredError } from '@atproto/xrpc-server'
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import {
-  getSafelinkAction,
-  getSafelinkPattern,
-  getSafelinkReason,
-} from '../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.safelink.addRule({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input, auth }) => {
-      const access = auth.credentials
-      const db = ctx.db
-      const { url, pattern, action, reason, comment, createdBy } = input.body
-
-      if (!access.isModerator) {
-        throw new AuthRequiredError('Must be a moderator to add URL rules')
-      }
-
-      if (access.type === 'admin_token' && !createdBy) {
-        throw new AuthRequiredError(
-          'Must specify createdBy when using admin auth',
-        )
-      }
-
-      const safelinkRuleService = ctx.safelinkRuleService(db)
-
-      const event = await safelinkRuleService.addRule({
-        url,
-        pattern: getSafelinkPattern(pattern),
-        action: getSafelinkAction(action),
-        reason: getSafelinkReason(reason),
-        createdBy:
-          access.type === 'admin_token'
-            ? createdBy || ctx.cfg.service.did
-            : access.iss,
-        comment,
-      })
-
-      return {
-        encoding: 'application/json',
-        body: safelinkRuleService.formatEvent(event),
-      }
-    },
-  })
-}

package/src/api/safelink/queryEvents.ts

@@ -1,32 +0,0 @@
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import { getSafelinkPattern } from '../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.safelink.queryEvents({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input }) => {
-      const db = ctx.db
-      const { cursor, limit, urls, patternType, sortDirection } = input.body
-
-      const safelinkRuleService = ctx.safelinkRuleService(db)
-      const result = await safelinkRuleService.queryEvents({
-        cursor,
-        limit,
-        urls,
-        patternType: patternType ? getSafelinkPattern(patternType) : undefined,
-        direction: sortDirection as 'asc' | 'desc' | undefined,
-      })
-
-      return {
-        encoding: 'application/json',
-        body: {
-          cursor: result.cursor,
-          events: result.events.map((event) =>
-            safelinkRuleService.formatEvent(event),
-          ),
-        },
-      }
-    },
-  })
-}

package/src/api/safelink/queryRules.ts

@@ -1,58 +0,0 @@
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import {
-  getSafelinkAction,
-  getSafelinkPattern,
-  getSafelinkReason,
-} from '../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.safelink.queryRules({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input }) => {
-      const db = ctx.db
-      const {
-        cursor,
-        limit,
-        urls,
-        patternType,
-        actions,
-        reason,
-        createdBy,
-        sortDirection,
-      } = input.body
-
-      const safelinkRuleService = ctx.safelinkRuleService(db)
-      const result = await safelinkRuleService.getActiveRules({
-        cursor,
-        limit,
-        urls,
-        patternType: patternType ? getSafelinkPattern(patternType) : undefined,
-        actions:
-          actions && actions.length > 0
-            ? actions.map(getSafelinkAction)
-            : undefined,
-        reason: reason ? getSafelinkReason(reason) : undefined,
-        createdBy,
-        direction: sortDirection as 'asc' | 'desc' | undefined,
-      })
-
-      return {
-        encoding: 'application/json',
-        body: {
-          cursor: result.cursor,
-          rules: result.rules.map((rule) => ({
-            url: rule.url,
-            pattern: rule.pattern,
-            action: rule.action,
-            reason: rule.reason,
-            createdBy: rule.createdBy,
-            createdAt: new Date(rule.createdAt).toISOString(),
-            updatedAt: new Date(rule.updatedAt).toISOString(),
-            comment: rule.comment || undefined,
-          })),
-        },
-      }
-    },
-  })
-}

package/src/api/safelink/removeRule.ts

@@ -1,42 +0,0 @@
-import { AuthRequiredError } from '@atproto/xrpc-server'
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import { getSafelinkPattern } from '../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.safelink.removeRule({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input, auth }) => {
-      const access = auth.credentials
-      const db = ctx.db
-      const { url, pattern, comment, createdBy } = input.body
-
-      if (!access.isModerator) {
-        throw new AuthRequiredError('Must be a moderator to remove URL rules')
-      }
-
-      if (access.type === 'admin_token' && !createdBy) {
-        throw new AuthRequiredError(
-          'Must specify createdBy when using admin auth',
-        )
-      }
-
-      const safelinkRuleService = ctx.safelinkRuleService(db)
-
-      const event = await safelinkRuleService.removeRule({
-        url,
-        pattern: getSafelinkPattern(pattern),
-        createdBy:
-          access.type === 'admin_token'
-            ? createdBy || ctx.cfg.service.did
-            : access.iss,
-        comment,
-      })
-
-      return {
-        encoding: 'application/json',
-        body: safelinkRuleService.formatEvent(event),
-      }
-    },
-  })
-}

package/src/api/safelink/updateRule.ts

@@ -1,48 +0,0 @@
-import { AuthRequiredError } from '@atproto/xrpc-server'
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import {
-  getSafelinkAction,
-  getSafelinkPattern,
-  getSafelinkReason,
-} from '../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.safelink.updateRule({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input, auth }) => {
-      const access = auth.credentials
-      const db = ctx.db
-      const { url, pattern, action, reason, comment, createdBy } = input.body
-
-      if (!access.isModerator) {
-        throw new AuthRequiredError('Must be a moderator to update URL rules')
-      }
-
-      if (access.type === 'admin_token' && !createdBy) {
-        throw new AuthRequiredError(
-          'Must specify createdBy when using admin auth',
-        )
-      }
-
-      const safelinkRuleService = ctx.safelinkRuleService(db)
-
-      const event = await safelinkRuleService.updateRule({
-        url,
-        pattern: getSafelinkPattern(pattern),
-        action: getSafelinkAction(action),
-        reason: getSafelinkReason(reason),
-        createdBy:
-          access.type === 'admin_token'
-            ? createdBy || ctx.cfg.service.did
-            : access.iss,
-        comment,
-      })
-
-      return {
-        encoding: 'application/json',
-        body: safelinkRuleService.formatEvent(event),
-      }
-    },
-  })
-}

package/src/api/server/getConfig.ts

@@ -1,35 +0,0 @@
-import { AppContext } from '../../context.js'
-import { Server, TOOLS_OZONE_TEAM } from '../../lexicon/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.server.getConfig({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ auth }) => {
-      return {
-        encoding: 'application/json',
-        body: {
-          appview: {
-            url: ctx.cfg.appview.url,
-          },
-          blobDivert: {
-            url: ctx.cfg.blobDivert?.url,
-          },
-          pds: {
-            url: ctx.cfg.pds?.url,
-          },
-          chat: {
-            url: ctx.cfg.chat?.url,
-          },
-          viewer: {
-            role: auth.credentials.isAdmin
-              ? TOOLS_OZONE_TEAM.DefsRoleAdmin
-              : auth.credentials.isModerator
-                ? TOOLS_OZONE_TEAM.DefsRoleModerator
-                : TOOLS_OZONE_TEAM.DefsRoleTriage,
-          },
-          verifierDid: ctx.cfg.verifier?.did || undefined,
-        },
-      }
-    },
-  })
-}

package/src/api/set/addValues.ts

@@ -1,28 +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.set.addValues({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input, auth }) => {
-      const access = auth.credentials
-      const db = ctx.db
-      const { name, values } = input.body
-
-      if (!access.isModerator) {
-        throw new AuthRequiredError(
-          'Must be a moderator to add values to a set',
-        )
-      }
-
-      const setService = ctx.setService(db)
-      const set = await setService.getByName(name)
-      if (!set) {
-        throw new InvalidRequestError(`Set with name "${name}" does not exist`)
-      }
-
-      await setService.addValues(set.id, values)
-    },
-  })
-}

package/src/api/set/deleteSet.ts

@@ -1,34 +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.set.deleteSet({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input, auth }) => {
-      const access = auth.credentials
-      const db = ctx.db
-      const { name } = input.body
-
-      if (!access.isModerator) {
-        throw new AuthRequiredError('Must be a moderator to delete a set')
-      }
-
-      const setService = ctx.setService(db)
-      const set = await setService.getByName(name)
-      if (!set) {
-        throw new InvalidRequestError(
-          `Set with name "${name}" does not exist`,
-          'SetNotFound',
-        )
-      }
-
-      await setService.removeSet(set.id)
-
-      return {
-        encoding: 'application/json',
-        body: {},
-      }
-    },
-  })
-}

package/src/api/set/deleteValues.ts

@@ -1,31 +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.set.deleteValues({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input, auth }) => {
-      const access = auth.credentials
-      const db = ctx.db
-      const { name, values } = input.body
-
-      if (!access.isModerator) {
-        throw new AuthRequiredError(
-          'Must be a moderator to remove values from a set',
-        )
-      }
-
-      const setService = ctx.setService(db)
-      const set = await setService.getByName(name)
-      if (!set) {
-        throw new InvalidRequestError(
-          `Set with name "${name}" does not exist`,
-          'SetNotFound',
-        )
-      }
-
-      await setService.removeValues(set.id, values)
-    },
-  })
-}

package/src/api/set/getValues.ts

@@ -1,42 +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.set.getValues({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ params, auth }) => {
-      const access = auth.credentials
-      const db = ctx.db
-      const { name, limit, cursor } = params
-
-      if (!access.isModerator) {
-        throw new AuthRequiredError('Must be a moderator to get set details')
-      }
-
-      const setService = ctx.setService(db)
-
-      const result = await setService.getSetWithValues({
-        name,
-        limit,
-        cursor,
-      })
-
-      if (!result) {
-        throw new InvalidRequestError(
-          `Set with name "${name}" not found`,
-          'SetNotFound',
-        )
-      }
-
-      return {
-        encoding: 'application/json',
-        body: {
-          set: setService.view(result.set),
-          values: result.values,
-          cursor: result.cursor,
-        },
-      }
-    },
-  })
-}

package/src/api/set/querySets.ts

@@ -1,36 +0,0 @@
-import { AuthRequiredError } 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.set.querySets({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ params, auth }) => {
-      const access = auth.credentials
-      const db = ctx.db
-      const { limit, cursor, namePrefix, sortBy, sortDirection } = params
-
-      if (!access.isModerator) {
-        throw new AuthRequiredError('Must be a moderator to query sets')
-      }
-
-      const setService = ctx.setService(db)
-
-      const queryResult = await setService.query({
-        limit,
-        cursor,
-        namePrefix,
-        sortBy,
-        sortDirection,
-      })
-
-      return {
-        encoding: 'application/json',
-        body: {
-          sets: queryResult.sets.map((set) => setService.view(set)),
-          cursor: queryResult.cursor,
-        },
-      }
-    },
-  })
-}