@atproto/ozone 0.0.2

package/src/db/schema/moderation_event.ts

@@ -0,0 +1,35 @@
+import { Generated } from 'kysely'
+
+export const eventTableName = 'moderation_event'
+
+export interface ModerationEvent {
+  id: Generated<number>
+  action:
+    | 'com.atproto.admin.defs#modEventTakedown'
+    | 'com.atproto.admin.defs#modEventAcknowledge'
+    | 'com.atproto.admin.defs#modEventEscalate'
+    | 'com.atproto.admin.defs#modEventComment'
+    | 'com.atproto.admin.defs#modEventLabel'
+    | 'com.atproto.admin.defs#modEventReport'
+    | 'com.atproto.admin.defs#modEventMute'
+    | 'com.atproto.admin.defs#modEventReverseTakedown'
+    | 'com.atproto.admin.defs#modEventEmail'
+    | 'com.atproto.admin.defs#modEventResolveAppeal'
+  subjectType: 'com.atproto.admin.defs#repoRef' | 'com.atproto.repo.strongRef'
+  subjectDid: string
+  subjectUri: string | null
+  subjectCid: string | null
+  createLabelVals: string | null
+  negateLabelVals: string | null
+  comment: string | null
+  createdAt: string
+  createdBy: string
+  durationInHours: number | null
+  expiresAt: string | null
+  meta: Record<string, string | boolean> | null
+  legacyRefId: number | null
+}
+
+export type PartialDB = {
+  [eventTableName]: ModerationEvent
+}

package/src/db/schema/moderation_subject_status.ts

@@ -0,0 +1,32 @@
+import { Generated } from 'kysely'
+import {
+  REVIEWCLOSED,
+  REVIEWOPEN,
+  REVIEWESCALATED,
+} from '../../lexicon/types/com/atproto/admin/defs'
+
+export const subjectStatusTableName = 'moderation_subject_status'
+
+export interface ModerationSubjectStatus {
+  id: Generated<number>
+  did: string
+  recordPath: string
+  recordCid: string | null
+  blobCids: string[] | null
+  reviewState: typeof REVIEWCLOSED | typeof REVIEWOPEN | typeof REVIEWESCALATED
+  createdAt: string
+  updatedAt: string
+  lastReviewedBy: string | null
+  lastReviewedAt: string | null
+  lastReportedAt: string | null
+  lastAppealedAt: string | null
+  muteUntil: string | null
+  suspendUntil: string | null
+  takendown: boolean
+  appealed: boolean | null
+  comment: string | null
+}
+
+export type PartialDB = {
+  [subjectStatusTableName]: ModerationSubjectStatus
+}

package/src/db/schema/record_push_event.ts

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,19 @@
+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/types.ts

@@ -0,0 +1,15 @@
+import { Pool as PgPool } from 'pg'
+import { DynamicModule, RawBuilder, SelectQueryBuilder } from 'kysely'
+
+export type DbRef = RawBuilder | ReturnType<DynamicModule['ref']>
+
+export type AnyQb = SelectQueryBuilder<any, any, any>
+
+export type PgOptions = {
+  url: string
+  pool?: PgPool
+  schema?: string
+  poolSize?: number
+  poolMaxUses?: number
+  poolIdleTimeoutMs?: number
+}

package/src/error.ts

@@ -0,0 +1,12 @@
+import { XRPCError } from '@atproto/xrpc-server'
+import { ErrorRequestHandler } from 'express'
+import { httpLogger as log } from './logger'
+
+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/index.ts

@@ -0,0 +1,102 @@
+import express from 'express'
+import http from 'http'
+import { AddressInfo } from 'net'
+import events from 'events'
+import { createHttpTerminator, HttpTerminator } from 'http-terminator'
+import cors from 'cors'
+import compression from 'compression'
+import API, { health, wellKnown } from './api'
+import * as error from './error'
+import { dbLogger, loggerMiddleware } from './logger'
+import { OzoneConfig, OzoneSecrets } from './config'
+import { createServer } from './lexicon'
+import AppContext, { AppContextOptions } from './context'
+
+export * from './config'
+export { Database } from './db'
+export { OzoneDaemon, EventPusher, EventReverser } from './daemon'
+export { AppContext } from './context'
+export { httpLogger } from './logger'
+
+export class OzoneService {
+  public ctx: AppContext
+  public app: express.Application
+  public server?: http.Server
+  private terminator?: HttpTerminator
+  private dbStatsInterval: NodeJS.Timer
+
+  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())
+    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 start(): Promise<http.Server> {
+    const { db, backgroundQueue } = this.ctx
+    this.dbStatsInterval = setInterval(() => {
+      dbLogger.info(
+        {
+          idleCount: db.pool.idleCount,
+          totalCount: db.pool.totalCount,
+          waitingCount: db.pool.waitingCount,
+        },
+        'db pool stats',
+      )
+      dbLogger.info(
+        {
+          runningCount: backgroundQueue.queue.pending,
+          waitingCount: backgroundQueue.queue.size,
+        },
+        'background queue stats',
+      )
+    }, 10000)
+    const server = this.app.listen(this.ctx.cfg.service.port)
+    this.server = server
+    server.keepAliveTimeout = 90000
+    this.terminator = createHttpTerminator({ server })
+    await events.once(server, 'listening')
+    const { port } = server.address() as AddressInfo
+    this.ctx.assignPort(port)
+    return server
+  }
+
+  async destroy(): Promise<void> {
+    await this.terminator?.terminate()
+    await this.ctx.backgroundQueue.destroy()
+    await this.ctx.db.close()
+    clearInterval(this.dbStatsInterval)
+  }
+}
+
+export default OzoneService