@atproto/ozone 0.2.4 → 0.2.6

package/src/db/migrations/index.ts

@@ -41,3 +41,4 @@ export * as _20260313T000000000Z from './20260313T000000000Z-add-report-activity
 export * as _20260318T152058935Z from './20260318T152058935Z-add-report-stat.js'
 export * as _20260428T000000000Z from './20260428T000000000Z-add-expiring-tag-table.js'
 export * as _20260513T202941104Z from './20260513T202941104Z-add-subject-convo-id.js'
+export * as _20260602T120000000Z from './20260602T120000000Z-add-report-activity-created-index.js'

package/src/db/migrations/provider.ts

@@ -1,4 +1,5 @@
-import { Kysely, Migration, MigrationProvider } from 'kysely'
+import { Kysely } from 'kysely'
+import { Migration, MigrationProvider } from 'kysely/migration'
 
 // Passes a context argument to migrations. We use this to thread the dialect into migrations
 

package/src/db/pagination.ts

@@ -1,4 +1,4 @@
-import { DynamicModule, sql } from 'kysely'
+import { DynamicModule, SqlBool, sql } from 'kysely'
 import { InvalidRequestError } from '@atproto/xrpc-server'
 import { AnyQb, DbRef } from './types.js'
 
@@ -66,16 +66,16 @@ export abstract class GenericKeyset<R, LR extends LabeledResult> {
     if (tryIndex) {
       // The tryIndex param will likely disappear and become the default implementation: here for now for gradual rollout query-by-query.
       if (direction === 'asc') {
-        return sql`((${this.primary}, ${this.secondary}) > (${labeled.primary}, ${labeled.secondary}))`
+        return sql<SqlBool>`((${this.primary}, ${this.secondary}) > (${labeled.primary}, ${labeled.secondary}))`
       } else {
-        return sql`((${this.primary}, ${this.secondary}) < (${labeled.primary}, ${labeled.secondary}))`
+        return sql<SqlBool>`((${this.primary}, ${this.secondary}) < (${labeled.primary}, ${labeled.secondary}))`
       }
     } else {
       // @NOTE this implementation can struggle to use an index on (primary, secondary) for pagination due to the "or" usage.
       if (direction === 'asc') {
-        return sql`((${this.primary} > ${labeled.primary}) or (${this.primary} = ${labeled.primary} and ${this.secondary} > ${labeled.secondary}))`
+        return sql<SqlBool>`((${this.primary} > ${labeled.primary}) or (${this.primary} = ${labeled.primary} and ${this.secondary} > ${labeled.secondary}))`
       } else {
-        return sql`((${this.primary} < ${labeled.primary}) or (${this.primary} = ${labeled.primary} and ${this.secondary} < ${labeled.secondary}))`
+        return sql<SqlBool>`((${this.primary} < ${labeled.primary}) or (${this.primary} = ${labeled.primary} and ${this.secondary} < ${labeled.secondary}))`
       }
     }
   }
@@ -91,7 +91,7 @@ export class StatusKeyset extends GenericKeyset<StatusKeysetParam, Cursor> {
   labelResult(result: StatusKeysetParam): Cursor
   labelResult(result: StatusKeysetParam) {
     const primaryField = (
-      this.primary as ReturnType<DynamicModule['ref']>
+      this.primary as ReturnType<DynamicModule<unknown>['ref']>
     ).dynamicReference.includes('lastReviewedAt')
       ? 'lastReviewedAt'
       : 'lastReportedAt'
@@ -134,12 +134,12 @@ export class StatusKeyset extends GenericKeyset<StatusKeysetParam, Cursor> {
     if (labeled === undefined) return
     if (direction === 'asc') {
       return !labeled.primary
-        ? sql`(${this.primary} IS NULL AND ${this.secondary} > ${labeled.secondary})`
-        : sql`((${this.primary}, ${this.secondary}) > (${labeled.primary}, ${labeled.secondary}) OR (${this.primary} is null))`
+        ? sql<SqlBool>`(${this.primary} IS NULL AND ${this.secondary} > ${labeled.secondary})`
+        : sql<SqlBool>`((${this.primary}, ${this.secondary}) > (${labeled.primary}, ${labeled.secondary}) OR (${this.primary} is null))`
     } else {
       return !labeled.primary
-        ? sql`(${this.primary} IS NULL AND ${this.secondary} < ${labeled.secondary})`
-        : sql`((${this.primary}, ${this.secondary}) < (${labeled.primary}, ${labeled.secondary}) OR (${this.primary} is null))`
+        ? sql<SqlBool>`(${this.primary} IS NULL AND ${this.secondary} < ${labeled.secondary})`
+        : sql<SqlBool>`((${this.primary}, ${this.secondary}) < (${labeled.primary}, ${labeled.secondary}) OR (${this.primary} is null))`
     }
   }
 }
@@ -244,15 +244,15 @@ export class EndAtIdKeyset extends GenericKeyset<EndAtIdKeysetParam, Cursor> {
     const primaryRef = sql`COALESCE(${this.primary}, ${PERMANENT_ENDSAT})`
     if (tryIndex) {
       if (direction === 'asc') {
-        return sql`((${primaryRef}, ${this.secondary}) > (${labeled.primary}, ${labeled.secondary}))`
+        return sql<SqlBool>`((${primaryRef}, ${this.secondary}) > (${labeled.primary}, ${labeled.secondary}))`
       } else {
-        return sql`((${primaryRef}, ${this.secondary}) < (${labeled.primary}, ${labeled.secondary}))`
+        return sql<SqlBool>`((${primaryRef}, ${this.secondary}) < (${labeled.primary}, ${labeled.secondary}))`
       }
     } else {
       if (direction === 'asc') {
-        return sql`((${primaryRef} > ${labeled.primary}) or (${primaryRef} = ${labeled.primary} and ${this.secondary} > ${labeled.secondary}))`
+        return sql<SqlBool>`((${primaryRef} > ${labeled.primary}) or (${primaryRef} = ${labeled.primary} and ${this.secondary} > ${labeled.secondary}))`
       } else {
-        return sql`((${primaryRef} < ${labeled.primary}) or (${primaryRef} = ${labeled.primary} and ${this.secondary} < ${labeled.secondary}))`
+        return sql<SqlBool>`((${primaryRef} < ${labeled.primary}) or (${primaryRef} = ${labeled.primary} and ${this.secondary} < ${labeled.secondary}))`
       }
     }
   }
@@ -314,11 +314,11 @@ export const paginate = <
   } = opts
   const keysetSql = keyset.getSql(keyset.unpack(cursor), direction, tryIndex)
   return qb
-    .if(!!limit, (q) => q.limit(limit as number))
-    .if(!nullsLast, (q) =>
+    .$if(!!limit, (q) => q.limit(limit as number))
+    .$if(!nullsLast, (q) =>
       q.orderBy(keyset.primary, direction).orderBy(keyset.secondary, direction),
     )
-    .if(!!nullsLast, (q) =>
+    .$if(!!nullsLast, (q) =>
       q
         .orderBy(
           direction === 'asc'
@@ -331,5 +331,5 @@ export const paginate = <
             : sql`${keyset.secondary} desc nulls last`,
         ),
     )
-    .if(!!keysetSql, (qb) => (keysetSql ? qb.where(keysetSql) : qb)) as QB
+    .$if(!!keysetSql, (qb) => (keysetSql ? qb.where(keysetSql) : qb)) as QB
 }

package/src/db/types.ts

@@ -3,7 +3,9 @@ import { DynamicModule, RawBuilder, SelectQueryBuilder, sql } from 'kysely'
 import pg from 'pg'
 type PgPool = pg.Pool
 
-export type DbRef = RawBuilder | ReturnType<DynamicModule['ref']>
+export type DbRef =
+  | RawBuilder<unknown>
+  | ReturnType<DynamicModule<unknown>['ref']>
 
 export type AnyQb = SelectQueryBuilder<any, any, any>
 

package/src/index.ts

@@ -4,11 +4,8 @@ import { AddressInfo } from 'node:net'
 import compression from 'compression'
 import cors from 'cors'
 import express from 'express'
-// eslint-disable-next-line import/default, import/no-named-as-default-member
+// eslint-disable-next-line import/default
 import httpTerminator from 'http-terminator'
-// eslint-disable-next-line import/no-named-as-default-member
-const { createHttpTerminator } = httpTerminator
-type HttpTerminator = ReturnType<typeof createHttpTerminator>
 import { DAY, SECOND } from '@atproto/common'
 import API, { health, wellKnown } from './api/index.js'
 import { OzoneConfig, OzoneSecrets } from './config/index.js'
@@ -29,7 +26,7 @@ export class OzoneService {
   public ctx: AppContext
   public app: express.Application
   public server?: http.Server
-  private terminator?: HttpTerminator
+  private terminator?: httpTerminator.HttpTerminator
   private dbStatsInterval?: NodeJS.Timeout
 
   constructor(opts: { ctx: AppContext; app: express.Application }) {
@@ -108,23 +105,25 @@ export class OzoneService {
     // so we need to sync them from env var to the database
     await this.seedInitialMembers()
 
-    const { db, backgroundQueue } = this.ctx
     this.dbStatsInterval = setInterval(() => {
       dbLogger.info(
         {
-          idleCount: db.pool.idleCount,
-          totalCount: db.pool.totalCount,
-          waitingCount: db.pool.waitingCount,
+          idleCount: this.ctx.db.pool.idleCount,
+          totalCount: this.ctx.db.pool.totalCount,
+          waitingCount: this.ctx.db.pool.waitingCount,
         },
         'db pool stats',
       )
-      dbLogger.info(backgroundQueue.getStats(), 'background queue 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 = createHttpTerminator({ server })
+    this.terminator = httpTerminator.createHttpTerminator({ server })
     await events.once(server, 'listening')
     const { port } = server.address() as AddressInfo
     this.ctx.assignPort(port)
@@ -132,12 +131,23 @@ export class OzoneService {
   }
 
   async destroy(): Promise<void> {
-    await this.terminator?.terminate()
-    await this.ctx.backgroundQueue.destroy()
-    await this.ctx.sequencer.destroy()
-    await this.ctx.db.close()
     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()
+        }
+      }
+    }
   }
 }
 

package/src/jetstream/service.ts

@@ -99,7 +99,9 @@ export class Jetstream {
   /**
    * Closes the WebSocket connection.
    */
-  close() {
+  async close() {
+    // @TODO This should return a promise that fulfills when the connection is
+    // fully closed.
     this.ws?.ws?.close()
   }
 }

package/src/mod-service/index.ts

@@ -1,4 +1,4 @@
-import { Insertable, RawBuilder, sql } from 'kysely'
+import { Expression, Insertable, sql } from 'kysely'
 import { CID } from 'multiformats/cid'
 import { AtpAgent, ToolsOzoneModerationDefs } from '@atproto/api'
 import { addHoursToDate, chunkArray } from '@atproto/common'
@@ -267,21 +267,24 @@ export class ModerationService {
 
     // If subjectType is set to 'account' let that take priority and ignore collections filter
     if (collections.length && subjectType !== 'account') {
-      builder = builder.where('subjectUri', 'is not', null).where((qb) => {
-        collections.forEach((collection) => {
-          qb = qb.orWhere('subjectUri', 'like', `%/${collection}/%`)
-        })
-        return qb
-      })
+      builder = builder
+        .where('subjectUri', 'is not', null)
+        .where((eb) =>
+          eb.or(
+            collections.map((collection) =>
+              eb('subjectUri', 'like', `%/${collection}/%`),
+            ),
+          ),
+        )
     }
 
     if (types.length) {
-      builder = builder.where((qb) => {
+      builder = builder.where((eb) => {
         if (types.length === 1) {
-          return qb.where('action', '=', types[0])
+          return eb('action', '=', types[0])
         }
 
-        return qb.where('action', 'in', types)
+        return eb('action', 'in', types)
       })
     }
     if (createdBy) {
@@ -298,12 +301,11 @@ export class ModerationService {
       // the input may end in || in which case, there may be item in the array which is just '' and we want to ignore those
       const keywords = comment.split('||').filter((keyword) => !!keyword.trim())
       if (keywords.length > 1) {
-        builder = builder.where((qb) => {
-          keywords.forEach((keyword) => {
-            qb = qb.orWhere('comment', 'ilike', `%${keyword}%`)
-          })
-          return qb
-        })
+        builder = builder.where((eb) =>
+          eb.or(
+            keywords.map((keyword) => eb('comment', 'ilike', `%${keyword}%`)),
+          ),
+        )
       } else if (keywords.length === 1) {
         builder = builder.where('comment', 'ilike', `%${keywords[0]}%`)
       }
@@ -324,23 +326,26 @@ export class ModerationService {
       })
     }
     if (addedTags.length) {
-      builder = builder.where(sql`${ref('addedTags')} @> ${jsonb(addedTags)}`)
+      builder = builder.where(
+        sql<boolean>`${ref('addedTags')} @> ${jsonb(addedTags)}`,
+      )
     }
     if (removedTags.length) {
       builder = builder.where(
-        sql`${ref('removedTags')} @> ${jsonb(removedTags)}`,
+        sql<boolean>`${ref('removedTags')} @> ${jsonb(removedTags)}`,
       )
     }
     if (reportTypes?.length) {
       builder = builder.where(sql`meta->>'reportType'`, 'in', reportTypes)
     }
     if (policies?.length) {
-      builder = builder.where((qb) => {
-        policies.forEach((policy) => {
-          qb = qb.orWhere(sql`meta->>'policies'`, 'ilike', `%${policy}%`)
-        })
-        return qb
-      })
+      builder = builder.where((eb) =>
+        eb.or(
+          policies.map((policy) =>
+            eb(sql`meta->>'policies'`, 'ilike', `%${policy}%`),
+          ),
+        ),
+      )
     }
     if (modTool?.length) {
       builder = builder
@@ -446,8 +451,8 @@ export class ModerationService {
     const subjectsToBeResolved = await this.db.db
       .selectFrom('moderation_subject_status')
       .where('did', '=', did)
-      .where((qb) =>
-        qb.where('recordPath', '!=', '').orWhere('convoId', '!=', ''),
+      .where((eb) =>
+        eb.or([eb('recordPath', '!=', ''), eb('convoId', '!=', '')]),
       )
       .where('reviewState', 'in', [REVIEWESCALATED, REVIEWOPEN])
       .selectAll()
@@ -816,8 +821,9 @@ export class ModerationService {
     const now = new Date().toISOString()
     const subjects = await this.db.db
       .selectFrom('moderation_subject_status')
-      .where('suspendUntil', '<', now)
-      .orWhere('muteUntil', '<', now)
+      .where((eb) =>
+        eb.or([eb('suspendUntil', '<', now), eb('muteUntil', '<', now)]),
+      )
       .selectAll()
       .execute()
 
@@ -1206,16 +1212,17 @@ export class ModerationService {
     if (subjectType !== 'account' && collections?.length) {
       builder = builder
         .where('moderation_subject_status.recordPath', '!=', '')
-        .where((qb) => {
-          for (const collection of collections) {
-            qb = qb.orWhere(
-              'moderation_subject_status.recordPath',
-              'like',
-              `${collection}/%`,
-            )
-          }
-          return qb
-        })
+        .where((eb) =>
+          eb.or(
+            collections.map((collection) =>
+              eb(
+                'moderation_subject_status.recordPath',
+                'like',
+                `${collection}/%`,
+              ),
+            ),
+          ),
+        )
     }
 
     if (ignoreSubjects?.length) {
@@ -1325,30 +1332,32 @@ export class ModerationService {
     }
 
     if (!includeMuted) {
-      builder = builder.where((qb) =>
-        qb
-          .where(
+      builder = builder.where((eb) =>
+        eb.or([
+          eb(
             'moderation_subject_status.muteUntil',
             '<',
             new Date().toISOString(),
-          )
-          .orWhere('moderation_subject_status.muteUntil', 'is', null),
+          ),
+          eb('moderation_subject_status.muteUntil', 'is', null),
+        ]),
       )
     }
 
     if (onlyMuted) {
-      builder = builder.where((qb) =>
-        qb
-          .where(
+      builder = builder.where((eb) =>
+        eb.or([
+          eb(
             'moderation_subject_status.muteUntil',
             '>',
             new Date().toISOString(),
-          )
-          .orWhere(
+          ),
+          eb(
             'moderation_subject_status.muteReportingUntil',
             '>',
             new Date().toISOString(),
           ),
+        ]),
       )
     }
 
@@ -1356,30 +1365,28 @@ export class ModerationService {
     const conditions = parseTags(tags)
     if (conditions?.length) {
       // [["tag1"], ["tag2", "tag3"], ["tag4"]] => (tags ? 'tag1') OR (tags ? 'tag2' AND tags ? 'tag3') OR (tags ? 'tag4')
-      builder = builder.where((qb) => {
-        for (const subTags of conditions) {
-          // OR between every conditions items (subTags)
-          qb = qb.orWhere((qb) => {
+      builder = builder.where((eb) =>
+        // OR between every conditions items (subTags)
+        eb.or(
+          conditions.map((subTags) =>
             // AND between every subTags items (subTag)
-            for (const subTag of subTags) {
-              qb = qb.where(
-                sql`${ref('moderation_subject_status.tags')} ? ${subTag}`,
-              )
-            }
-            return qb
-          })
-        }
-        return qb
-      })
+            eb.and(
+              subTags.map(
+                (subTag) =>
+                  sql<boolean>`${ref('moderation_subject_status.tags')} ? ${subTag}`,
+              ),
+            ),
+          ),
+        ),
+      )
     }
 
     if (excludeTags?.length) {
-      builder = builder.where((qb) =>
-        qb
-          .where(
-            sql`NOT(${ref('moderation_subject_status.tags')} ?| array[${sql.join(excludeTags)}]::TEXT[])`,
-          )
-          .orWhere('tags', 'is', null),
+      builder = builder.where((eb) =>
+        eb.or([
+          sql<boolean>`NOT(${ref('moderation_subject_status.tags')} ?| array[${sql.join(excludeTags)}]::TEXT[])`,
+          eb('tags', 'is', null),
+        ]),
       )
     }
 
@@ -1620,15 +1627,15 @@ export class ModerationService {
     const countAll = () => {
       return sql<number>`COUNT(*)`
     }
-    const countAllDistinctBy = (ref: RawBuilder) => {
+    const countAllDistinctBy = (ref: Expression<unknown>) => {
       return sql<number>`COUNT(DISTINCT ${ref})`
     }
-    const countTakedownsDistinctBy = (ref: RawBuilder) => {
+    const countTakedownsDistinctBy = (ref: Expression<unknown>) => {
       return sql<number>`COUNT(DISTINCT ${ref}) FILTER (
         WHERE actions."action" = 'tools.ozone.moderation.defs#modEventTakedown'
       )`
     }
-    const countLabelsDistinctBy = (ref: RawBuilder) => {
+    const countLabelsDistinctBy = (ref: Expression<unknown>) => {
       return sql<number>`COUNT(DISTINCT ${ref}) FILTER (
         WHERE actions."action" = 'tools.ozone.moderation.defs#modEventLabel'
       )`

package/src/mod-service/report.ts

@@ -74,7 +74,9 @@ export async function queryReports(
     const collectionConditions = params.collections.map(
       (collection) => sql`r."recordPath" LIKE ${`${collection}/%`}`,
     )
-    builder = builder.where(sql`(${sql.join(collectionConditions, sql` OR `)})`)
+    builder = builder.where(
+      sql<boolean>`(${sql.join(collectionConditions, sql` OR `)})`,
+    )
   }
 
   if (params.reportTypes?.length) {
@@ -112,12 +114,12 @@ export async function queryReports(
     const [sortValue, id] = params.cursor.split('::')
     const sortCol = sortField === 'updatedAt' ? 'r.updatedAt' : 'r.createdAt'
     if (sortDirection === 'desc') {
-      builder = builder.where(sql`(
+      builder = builder.where(sql<boolean>`(
         ${sql.ref(sortCol)} < ${sortValue}
         OR (${sql.ref(sortCol)} = ${sortValue} AND r.id < ${Number(id)})
       )`)
     } else {
-      builder = builder.where(sql`(
+      builder = builder.where(sql<boolean>`(
         ${sql.ref(sortCol)} > ${sortValue}
         OR (${sql.ref(sortCol)} = ${sortValue} AND r.id > ${Number(id)})
       )`)
@@ -173,6 +175,25 @@ export async function getReportById(
     .executeTakeFirst()
 }
 
+export async function getReportsByIds(
+  db: Database,
+  ids: number[],
+): Promise<ReportWithEvent[]> {
+  if (!ids.length) return []
+  return reportQuery(db)
+    .where('r.id', 'in', ids)
+    .selectAll('r')
+    .select([
+      'me.subjectDid',
+      'me.subjectUri',
+      'me.subjectCid',
+      'me.createdBy as reportedBy',
+      'me.comment',
+      'me.meta',
+    ])
+    .execute()
+}
+
 export async function getLatestReport(
   db: Database,
 ): Promise<ReportWithEvent | undefined> {

package/src/mod-service/views.ts

@@ -602,7 +602,7 @@ export class ModerationViews {
       this.db.db,
     )
       .where(
-        sql<string>`${ref(
+        sql<boolean>`${ref(
           'moderation_subject_status.blobCids',
         )} @> ${JSON.stringify(blobs.map((blob) => blob.ref.toString()))}`,
       )
@@ -642,10 +642,10 @@ export class ModerationViews {
     const res = await this.db.db
       .selectFrom('label')
       .where('label.uri', 'in', subjects)
-      .where((qb) =>
-        qb.where('label.exp', 'is', null).orWhere('label.exp', '>', now),
+      .where((eb) =>
+        eb.or([eb('label.exp', 'is', null), eb('label.exp', '>', now)]),
       )
-      .if(!includeNeg, (qb) => qb.where('neg', '=', false))
+      .$if(!includeNeg, (qb) => qb.where('neg', '=', false))
       .selectAll()
       .execute()
 
@@ -688,21 +688,21 @@ export class ModerationViews {
 
     const builder = moderationSubjectStatusQueryBuilder(this.db.db)
       //
-      .where((qb) => {
-        for (const sub of parsedSubjects) {
-          qb = qb.orWhere((qb) =>
-            qb
-              .where('moderation_subject_status.did', '=', sub.did)
-              .where(
+      .where((eb) =>
+        eb.or(
+          parsedSubjects.map((sub) =>
+            eb.and([
+              eb('moderation_subject_status.did', '=', sub.did),
+              eb(
                 'moderation_subject_status.recordPath',
                 '=',
                 sub.recordPath ?? '',
-              )
-              .where('moderation_subject_status.convoId', '=', ''),
-          )
-        }
-        return qb
-      })
+              ),
+              eb('moderation_subject_status.convoId', '=', ''),
+            ]),
+          ),
+        ),
+      )
 
     const [statusRes, accountsByDid] = await Promise.all([
       builder.execute(),

package/src/queue/service.ts

@@ -204,7 +204,7 @@ export class QueueService {
     }
 
     if (subjectType !== undefined) {
-      qb = qb.where(sql`"subjectTypes" @> ${jsonb([subjectType])}`)
+      qb = qb.where(sql<boolean>`"subjectTypes" @> ${jsonb([subjectType])}`)
     }
 
     if (collection !== undefined) {
@@ -215,7 +215,7 @@ export class QueueService {
       const conditions = reportTypes.map(
         (t) => sql`"reportTypes" @> ${jsonb([t])}`,
       )
-      qb = qb.where(sql`(${sql.join(conditions, sql` OR `)})`)
+      qb = qb.where(sql<boolean>`(${sql.join(conditions, sql` OR `)})`)
     }
 
     const keyset = new TimeIdKeyset(ref('createdAt'), ref('id'))
@@ -309,9 +309,9 @@ export class QueueService {
       .limit(params.limit)
 
     if (opts?.includeUnmatched) {
-      query = query.where((qb) => {
-        return qb.orWhere('r.queueId', 'is', null).orWhere('r.queueId', '=', -1)
-      })
+      query = query.where((eb) =>
+        eb.or([eb('r.queueId', 'is', null), eb('r.queueId', '=', -1)]),
+      )
     } else {
       query = query.where('r.queueId', 'is', null)
     }