@atproto/ozone 0.2.9 → 0.2.11

package/src/db/schema/moderation_subject_status.ts

@@ -1,52 +0,0 @@
-import { Generated } from 'kysely'
-import {
-  REVIEWCLOSED,
-  REVIEWESCALATED,
-  REVIEWNONE,
-  REVIEWOPEN,
-} from '../../lexicon/types/tools/ozone/moderation/defs.js'
-
-export const subjectStatusTableName = 'moderation_subject_status'
-
-export interface ModerationSubjectStatus {
-  id: Generated<number>
-
-  // unique columns
-  did: string
-  recordPath: string
-  convoId: string
-
-  recordCid: string | null
-  blobCids: string[] | null
-  reviewState:
-    | typeof REVIEWCLOSED
-    | typeof REVIEWOPEN
-    | typeof REVIEWESCALATED
-    | typeof REVIEWNONE
-  createdAt: string
-  updatedAt: string
-  lastReviewedBy: string | null
-  lastReviewedAt: string | null
-  lastReportedAt: string | null
-  lastAppealedAt: string | null
-  hostingUpdatedAt: string | null
-  hostingDeletedAt: string | null
-  hostingCreatedAt: string | null
-  hostingDeactivatedAt: string | null
-  hostingReactivatedAt: string | null
-  hostingStatus: string | null
-  muteUntil: string | null
-  muteReportingUntil: string | null
-  suspendUntil: string | null
-  takendown: boolean
-  appealed: boolean | null
-  comment: string | null
-  tags: string[] | null
-  priorityScore?: number
-  ageAssuranceState: string
-  ageAssuranceUpdatedBy?: string | null
-}
-
-export type PartialDB = {
-  [subjectStatusTableName]: ModerationSubjectStatus
-}

package/src/db/schema/moderator_assignment.ts

@@ -1,16 +0,0 @@
-import { Generated } from 'kysely'
-
-export const moderatorAssignmentTableName = 'moderator_assignment'
-
-export interface ModeratorAssignment {
-  id: Generated<number>
-  did: string
-  reportId: number | null
-  queueId: number | null
-  startAt: string
-  endAt: string | null
-}
-
-export type PartialDB = {
-  [moderatorAssignmentTableName]: ModeratorAssignment
-}

package/src/db/schema/ozone_set.ts

@@ -1,24 +0,0 @@
-import { Generated, GeneratedAlways } from 'kysely'
-
-export const ozoneSetTableName = 'set_detail'
-export const ozoneSetValueTableName = 'set_value'
-
-export interface SetDetail {
-  id: GeneratedAlways<number>
-  name: string
-  description: string | null
-  createdAt: Generated<Date>
-  updatedAt: Generated<Date>
-}
-
-export interface SetValue {
-  id: GeneratedAlways<number>
-  setId: number
-  value: string
-  createdAt: Generated<Date>
-}
-
-export type PartialDB = {
-  [ozoneSetTableName]: SetDetail
-  [ozoneSetValueTableName]: SetValue
-}

package/src/db/schema/record_events_stats.ts

@@ -1,15 +0,0 @@
-import { GeneratedAlways, Selectable } from 'kysely'
-
-export const tableName = 'record_events_stats'
-
-export type RecordEventsStats = {
-  subjectDid: GeneratedAlways<string>
-  subjectUri: GeneratedAlways<string>
-  escalateCount: GeneratedAlways<number>
-  reportCount: GeneratedAlways<number>
-  appealCount: GeneratedAlways<number>
-}
-
-export type RecordEventsStatsRow = Selectable<RecordEventsStats>
-
-export type PartialDB = { [tableName]: RecordEventsStats }

package/src/db/schema/record_push_event.ts

@@ -1,21 +0,0 @@
-import { Generated } from 'kysely'
-
-export const eventTableName = 'record_push_event'
-
-export type RecordPushEventType = 'pds_takedown' | 'appview_takedown'
-
-export interface RecordPushEvent {
-  id: Generated<number>
-  eventType: RecordPushEventType
-  subjectDid: string
-  subjectUri: string
-  subjectCid: string
-  takedownRef: string | null
-  confirmedAt: Date | null
-  lastAttempted: Date | null
-  attempts: Generated<number>
-}
-
-export type PartialDB = {
-  [eventTableName]: RecordPushEvent
-}

package/src/db/schema/repo_push_event.ts

@@ -1,19 +0,0 @@
-import { Generated } from 'kysely'
-
-export const eventTableName = 'repo_push_event'
-
-export type RepoPushEventType = 'pds_takedown' | 'appview_takedown'
-
-export interface RepoPushEvent {
-  id: Generated<number>
-  eventType: RepoPushEventType
-  subjectDid: string
-  takedownRef: string | null
-  confirmedAt: Date | null
-  lastAttempted: Date | null
-  attempts: Generated<number>
-}
-
-export type PartialDB = {
-  [eventTableName]: RepoPushEvent
-}

package/src/db/schema/report.ts

@@ -1,28 +0,0 @@
-import { Generated } from 'kysely'
-
-export const reportTableName = 'report'
-
-export interface Report {
-  id: Generated<number>
-  eventId: number // References moderation_event.id
-  queueId: number | null // NULL = not yet assigned, -1 = no matching queue
-  queuedAt: string | null
-  actionEventIds: number[] | null // Array of event IDs, sorted DESC [newest, ..., oldest]
-  actionNote: string | null
-  isMuted: boolean
-  status: string // 'open', 'closed', 'escalated', 'queued', 'assigned'
-  reportType: string // Denormalized from moderation_event.meta.reportType
-  did: string // Denormalized from moderation_event.subjectDid
-  recordPath: string // '' = account/message/conversation, 'collection/rkey' = record
-  subjectMessageId: string | null // Denormalized from moderation_event.subjectMessageId
-  subjectConvoId: string | null // Denormalized from moderation_event.subjectConvoId
-  createdAt: string
-  updatedAt: string
-  assignedTo: string | null // DID of permanently assigned moderator, null if unassigned
-  assignedAt: string | null // When the permanent assignment was created
-  closedAt: string | null
-}
-
-export type PartialDB = {
-  [reportTableName]: Report
-}

package/src/db/schema/report_activity.ts

@@ -1,22 +0,0 @@
-import { Generated } from 'kysely'
-
-export const reportActivityTableName = 'report_activity'
-
-export interface ReportActivity {
-  id: Generated<number>
-  reportId: number
-  // One of: queueActivity | assignmentActivity | escalationActivity
-  //         | closeActivity | internalNoteActivity | publicNoteActivity
-  activityType: string
-  previousStatus: string | null // report status before this activity; null for note-only types
-  internalNote: string | null // moderator-only note
-  publicNote: string | null // potentially reporter-visible note
-  meta: unknown | null // loose activity-specific metadata (e.g. { assignmentId: 42 })
-  isAutomated: boolean
-  createdBy: string // DID of actor (or service DID for automated activities)
-  createdAt: string // ISO string
-}
-
-export type PartialDB = {
-  [reportActivityTableName]: ReportActivity
-}

package/src/db/schema/report_queue.ts

@@ -1,21 +0,0 @@
-import { Generated } from 'kysely'
-
-export const reportQueueTableName = 'report_queue'
-
-export interface ReportQueue {
-  id: Generated<number>
-  name: string
-  subjectTypes: string[] // ['account'] or ['record'] or ['account', 'record']
-  collection: string | null // Collection name (e.g., 'app.bsky.feed.post'), NULL for accounts
-  reportTypes: string[] // Array of report reason types (fully qualified NSIDs)
-  description: string | null // Optional description of the queue
-  createdBy: string // DID of moderator who created this queue
-  createdAt: string
-  updatedAt: string
-  enabled: boolean
-  deletedAt: string | null // NULL = active, timestamp = soft-deleted
-}
-
-export type PartialDB = {
-  [reportQueueTableName]: ReportQueue
-}

package/src/db/schema/report_stat.ts

@@ -1,27 +0,0 @@
-import { Generated } from 'kysely'
-
-export const reportStatTableName = 'report_stat'
-
-export interface ReportStat {
-  // metadata
-  id: Generated<number>
-  computedAt: string // When this snapshot was last computed
-
-  // group
-  date: string // ISO date e.g. '2026-04-15' — the calendar day this snapshot covers
-  queueId: number | null // NULL = aggregate across all queues
-  reportTypes: string[] | null // NULL = aggregate across all report types
-  moderatorDid: string | null // NULL = aggregate, non-null = per-moderator
-
-  // stats
-  inboundCount: number | null // Reports received during this calendar day
-  pendingCount: number | null // Reports with status != 'closed' at time of computation
-  actionedCount: number | null // Reports closed during this calendar day
-  escalatedCount: number | null // Reports escalated during this calendar day
-  actionRate: number | null // actionedCount / inboundCount * 100
-  avgHandlingTimeSec: number | null // Average time from creation/assignment to close, in seconds
-}
-
-export type PartialDB = {
-  [reportStatTableName]: ReportStat
-}

package/src/db/schema/safelink.ts

@@ -1,39 +0,0 @@
-import { GeneratedAlways } from 'kysely'
-import {
-  SafelinkActionType,
-  SafelinkEventType,
-  SafelinkPatternType,
-  SafelinkReasonType,
-} from '../../api/util.js'
-
-export const safelinkRuleTableName = 'safelink_rule'
-export const safelinkEventTableName = 'safelink_event'
-
-export interface SafelinkRule {
-  id: GeneratedAlways<number>
-  url: string
-  pattern: SafelinkPatternType
-  action: SafelinkActionType
-  reason: SafelinkReasonType
-  createdBy: string
-  createdAt: string
-  updatedAt: string
-  comment: string | null
-}
-
-export interface SafelinkEvent {
-  id: GeneratedAlways<number>
-  eventType: SafelinkEventType
-  url: string
-  pattern: SafelinkPatternType
-  action: SafelinkActionType
-  reason: SafelinkReasonType
-  createdBy: string
-  createdAt: string
-  comment: string | null
-}
-
-export type PartialDB = {
-  [safelinkRuleTableName]: SafelinkRule
-  [safelinkEventTableName]: SafelinkEvent
-}

package/src/db/schema/scheduled-action.ts

@@ -1,25 +0,0 @@
-import { GeneratedAlways } from 'kysely'
-
-export const scheduledActionTableName = 'scheduled_action'
-
-export interface ScheduledAction {
-  id: GeneratedAlways<number>
-  action: string
-  eventData: unknown | null
-  did: string
-  executeAt: string | null
-  executeAfter: string | null
-  executeUntil: string | null
-  randomizeExecution: boolean
-  createdBy: string
-  createdAt: string
-  updatedAt: string
-  status: string
-  lastExecutedAt: string | null
-  lastFailureReason: string | null
-  executionEventId: number | null
-}
-
-export type PartialDB = {
-  [scheduledActionTableName]: ScheduledAction
-}

package/src/db/schema/setting.ts

@@ -1,24 +0,0 @@
-import { Generated, GeneratedAlways } from 'kysely'
-import { Member } from './member.js'
-
-export const settingTableName = 'setting'
-
-export type SettingScope = 'personal' | 'instance'
-
-export interface Setting {
-  id: GeneratedAlways<number>
-  key: string
-  value: Record<string, unknown>
-  managerRole: Member['role'] | null
-  description: string | null
-  did: string
-  scope: SettingScope
-  lastUpdatedBy: string
-  createdBy: string
-  createdAt: Generated<Date>
-  updatedAt: Generated<Date>
-}
-
-export type PartialDB = {
-  [settingTableName]: Setting
-}

package/src/db/schema/signing_key.ts

@@ -1,10 +0,0 @@
-import { Generated } from 'kysely'
-
-export const tableName = 'signing_key'
-
-export interface SigningKey {
-  id: Generated<number>
-  key: string
-}
-
-export type PartialDB = { [tableName]: SigningKey }

package/src/db/schema/verification.ts

@@ -1,21 +0,0 @@
-import { Generated } from 'kysely'
-
-export const verificationTableName = 'verification'
-
-export interface Verification {
-  uri: string
-  cid: string
-  issuer: string
-  subject: string
-  handle: string
-  displayName: string
-  revokeReason: string | null
-  revokedBy: string | null
-  revokedAt: string | null
-  createdAt: string
-  updatedAt: Generated<string>
-}
-
-export type PartialDB = {
-  [verificationTableName]: Verification
-}

package/src/db/types.ts

@@ -1,24 +0,0 @@
-import { DynamicModule, RawBuilder, SelectQueryBuilder, sql } from 'kysely'
-// eslint-disable-next-line import/default
-import pg from 'pg'
-type PgPool = pg.Pool
-
-export type DbRef =
-  | RawBuilder<unknown>
-  | ReturnType<DynamicModule<unknown>['ref']>
-
-export type AnyQb = SelectQueryBuilder<any, any, any>
-
-export type PgOptions = {
-  url: string
-  pool?: PgPool
-  schema?: string
-  poolSize?: number
-  poolMaxUses?: number
-  poolIdleTimeoutMs?: number
-}
-
-export const jsonb = <T>(val: T) => {
-  if (val === null) return sql<T>`null`
-  return sql<T>`${JSON.stringify(val)}::jsonb`
-}

package/src/error.ts

@@ -1,12 +0,0 @@
-import { ErrorRequestHandler } from 'express'
-import { XRPCError } from '@atproto/xrpc-server'
-import { httpLogger as log } from './logger.js'
-
-export const handler: ErrorRequestHandler = (err, _req, res, next) => {
-  log.error({ err }, 'unexpected internal server error')
-  if (res.headersSent) {
-    return next(err)
-  }
-  const serverError = XRPCError.fromError(err)
-  res.status(serverError.type).json(serverError.payload)
-}

package/src/image-invalidator.ts

@@ -1,7 +0,0 @@
-// Invalidation is a general interface for propagating an image blob
-// takedown through any caches where a representation of it may be stored.
-// @NOTE this does not remove the blob from storage: just invalidates it from caches.
-// @NOTE keep in sync with same interface in aws/src/cloudfront.ts
-export interface ImageInvalidator {
-  invalidate(subject: string, paths: string[]): Promise<void>
-}

package/src/index.ts

@@ -1,154 +0,0 @@
-import events from 'node:events'
-import http from 'node:http'
-import { AddressInfo } from 'node:net'
-import compression from 'compression'
-import cors from 'cors'
-import express from 'express'
-// eslint-disable-next-line import/default
-import httpTerminator from 'http-terminator'
-import { DAY, SECOND } from '@atproto/common'
-import API, { health, wellKnown } from './api/index.js'
-import { OzoneConfig, OzoneSecrets } from './config/index.js'
-import { AppContext, AppContextOptions } from './context.js'
-import { Member } from './db/schema/member.js'
-import * as error from './error.js'
-import { createServer } from './lexicon/index.js'
-import { dbLogger, loggerMiddleware } from './logger.js'
-
-export * from './config/index.js'
-export { type ImageInvalidator } from './image-invalidator.js'
-export { Database } from './db/index.js'
-export { EventPusher, EventReverser, OzoneDaemon } from './daemon/index.js'
-export { AppContext } from './context.js'
-export { httpLogger } from './logger.js'
-
-export class OzoneService {
-  public ctx: AppContext
-  public app: express.Application
-  public server?: http.Server
-  private terminator?: httpTerminator.HttpTerminator
-  private dbStatsInterval?: NodeJS.Timeout
-
-  constructor(opts: { ctx: AppContext; app: express.Application }) {
-    this.ctx = opts.ctx
-    this.app = opts.app
-  }
-
-  static async create(
-    cfg: OzoneConfig,
-    secrets: OzoneSecrets,
-    overrides?: Partial<AppContextOptions>,
-  ): Promise<OzoneService> {
-    const app = express()
-    app.set('trust proxy', true)
-    app.use(cors({ maxAge: DAY / SECOND }))
-    app.use(loggerMiddleware)
-    app.use(compression())
-
-    const ctx = await AppContext.fromConfig(cfg, secrets, overrides)
-
-    let server = createServer({
-      validateResponse: false,
-      payload: {
-        jsonLimit: 100 * 1024, // 100kb
-        textLimit: 100 * 1024, // 100kb
-        blobLimit: 5 * 1024 * 1024, // 5mb
-      },
-    })
-
-    server = API(server, ctx)
-
-    app.use(health.createRouter(ctx))
-    app.use(wellKnown.createRouter(ctx))
-    app.use(server.xrpc.router)
-    app.use(error.handler)
-
-    return new OzoneService({ ctx, app })
-  }
-
-  async seedInitialMembers() {
-    const members: Array<{ role: Member['role']; did: string }> = []
-    this.ctx.cfg.access.admins.forEach((did) =>
-      members.push({
-        role: 'tools.ozone.team.defs#roleAdmin',
-        did,
-      }),
-    )
-    this.ctx.cfg.access.triage.forEach((did) =>
-      members.push({
-        role: 'tools.ozone.team.defs#roleTriage',
-        did,
-      }),
-    )
-    this.ctx.cfg.access.moderators.forEach((did) =>
-      members.push({
-        role: 'tools.ozone.team.defs#roleModerator',
-        did,
-      }),
-    )
-
-    for (const member of members) {
-      const service = this.ctx.teamService(this.ctx.db)
-      await service.upsert({
-        ...member,
-        lastUpdatedBy: this.ctx.cfg.service.did,
-      })
-    }
-  }
-
-  async start(): Promise<http.Server> {
-    if (this.dbStatsInterval) {
-      throw new Error(`${this.constructor.name} already started`)
-    }
-
-    // Any moderator that are configured via env var may not exist in the database
-    // so we need to sync them from env var to the database
-    await this.seedInitialMembers()
-
-    this.dbStatsInterval = setInterval(() => {
-      dbLogger.info(
-        {
-          idleCount: this.ctx.db.pool.idleCount,
-          totalCount: this.ctx.db.pool.totalCount,
-          waitingCount: this.ctx.db.pool.waitingCount,
-        },
-        'db pool stats',
-      )
-      dbLogger.info(
-        this.ctx.backgroundQueue.getStats(),
-        'background queue stats',
-      )
-    }, 10000)
-    await this.ctx.sequencer.start()
-    const server = this.app.listen(this.ctx.cfg.service.port)
-    this.server = server
-    server.keepAliveTimeout = 90000
-    this.terminator = httpTerminator.createHttpTerminator({ server })
-    await events.once(server, 'listening')
-    const { port } = server.address() as AddressInfo
-    this.ctx.assignPort(port)
-    return server
-  }
-
-  async destroy(): Promise<void> {
-    clearInterval(this.dbStatsInterval)
-    this.dbStatsInterval = undefined
-
-    // @TODO Use a disposable stack when Node24 becomes the min supported version
-    try {
-      await this.terminator?.terminate()
-    } finally {
-      try {
-        await this.ctx.backgroundQueue.destroy()
-      } finally {
-        try {
-          await this.ctx.sequencer.destroy()
-        } finally {
-          await this.ctx.db.close()
-        }
-      }
-    }
-  }
-}
-
-export default OzoneService