@atproto/ozone 0.1.50 → 0.1.52

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

@@ -20,7 +20,11 @@ export interface QueryParams {
   /** Retrieve events created before a given timestamp */
   createdBefore?: string
   subject?: string
-  /** If true, events on all record types (posts, lists, profile etc.) owned by the did are returned */
+  /** If specified, only events where the subject belongs to the given collections will be returned. When subjectType is set to 'account', this will be ignored. */
+  collections?: string[]
+  /** If specified, only events where the subject is of the given type (account or record) will be returned. When this is set to 'account' the 'collections' parameter will be ignored. When includeAllUserRecords or subject is set, this will be ignored. */
+  subjectType?: 'account' | 'record' | (string & {})
+  /** If true, events on all record types (posts, lists, profile etc.) or records from given 'collections' param, owned by the did are returned. */
   includeAllUserRecords: boolean
   limit: number
   /** If true, only events with comments are returned */

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

@@ -10,7 +10,7 @@ import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
 import * as ToolsOzoneModerationDefs from './defs'
 
 export interface QueryParams {
-  /** All subjects belonging to the account specified in the 'subject' param will be returned. */
+  /** All subjects, or subjects from given 'collections' param, belonging to the account specified in the 'subject' param will be returned. */
   includeAllUserRecords?: boolean
   /** The subject to get the status for. */
   subject?: string
@@ -43,6 +43,10 @@ export interface QueryParams {
   tags?: string[]
   excludeTags?: string[]
   cursor?: string
+  /** If specified, subjects belonging to the given collections will be returned. When subjectType is set to 'account', this will be ignored. */
+  collections?: string[]
+  /** If specified, subjects of the given type (account or record) will be returned. When this is set to 'account' the 'collections' parameter will be ignored. When includeAllUserRecords or subject is set, this will be ignored. */
+  subjectType?: 'account' | 'record' | (string & {})
 }
 
 export type InputSchema = undefined

package/src/lexicon/types/tools/ozone/set/addValues.ts

@@ -0,0 +1,41 @@
+/**
+ * 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'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** Name of the set to add values to */
+  name: string
+  /** Array of string values to add to the set */
+  values: string[]
+  [k: string]: unknown
+}
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | void
+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/set/defs.ts

@@ -0,0 +1,44 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+
+export interface Set {
+  name: string
+  description?: string
+  [k: string]: unknown
+}
+
+export function isSet(v: unknown): v is Set {
+  return (
+    isObj(v) && hasProp(v, '$type') && v.$type === 'tools.ozone.set.defs#set'
+  )
+}
+
+export function validateSet(v: unknown): ValidationResult {
+  return lexicons.validate('tools.ozone.set.defs#set', v)
+}
+
+export interface SetView {
+  name: string
+  description?: string
+  setSize: number
+  createdAt: string
+  updatedAt: string
+  [k: string]: unknown
+}
+
+export function isSetView(v: unknown): v is SetView {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'tools.ozone.set.defs#setView'
+  )
+}
+
+export function validateSetView(v: unknown): ValidationResult {
+  return lexicons.validate('tools.ozone.set.defs#setView', v)
+}

package/src/lexicon/types/tools/ozone/set/deleteSet.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'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** Name of the set to delete */
+  name: string
+  [k: string]: unknown
+}
+
+export interface OutputSchema {
+  [k: string]: unknown
+}
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+  error?: 'SetNotFound'
+}
+
+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/set/deleteValues.ts

@@ -0,0 +1,42 @@
+/**
+ * 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'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** Name of the set to delete values from */
+  name: string
+  /** Array of string values to delete from the set */
+  values: string[]
+  [k: string]: unknown
+}
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+  error?: 'SetNotFound'
+}
+
+export type HandlerOutput = HandlerError | void
+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/set/getValues.ts

@@ -0,0 +1,51 @@
+/**
+ * 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 ToolsOzoneSetDefs from './defs'
+
+export interface QueryParams {
+  name: string
+  limit: number
+  cursor?: string
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  set: ToolsOzoneSetDefs.SetView
+  values: string[]
+  cursor?: string
+  [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
+  error?: 'SetNotFound'
+}
+
+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/set/querySets.ts

@@ -0,0 +1,52 @@
+/**
+ * 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 ToolsOzoneSetDefs from './defs'
+
+export interface QueryParams {
+  limit: number
+  cursor?: string
+  namePrefix?: string
+  sortBy: 'name' | 'createdAt' | 'updatedAt'
+  /** Defaults to ascending order of name field. */
+  sortDirection: 'asc' | 'desc'
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  sets: ToolsOzoneSetDefs.SetView[]
+  cursor?: string
+  [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/set/upsertSet.ts

@@ -0,0 +1,43 @@
+/**
+ * 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 ToolsOzoneSetDefs from './defs'
+
+export interface QueryParams {}
+
+export type InputSchema = ToolsOzoneSetDefs.Set
+export type OutputSchema = ToolsOzoneSetDefs.SetView
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+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/index.ts

@@ -146,6 +146,8 @@ export class ModerationService {
     addedTags: string[]
     removedTags: string[]
     reportTypes?: string[]
+    collections: string[]
+    subjectType?: string
   }): Promise<{ cursor?: string; events: ModerationEventRow[] }> {
     const {
       subject,
@@ -164,6 +166,8 @@ export class ModerationService {
       addedTags,
       removedTags,
       reportTypes,
+      collections,
+      subjectType,
     } = opts
     const { ref } = this.db.db.dynamic
     let builder = this.db.db.selectFrom('moderation_event').selectAll()
@@ -181,6 +185,20 @@ export class ModerationService {
           .if(!subjectUri, (q) => q.where('subjectUri', 'is', null))
           .if(!!subjectUri, (q) => q.where('subjectUri', '=', subjectUri))
       }
+    } else if (subjectType === 'account') {
+      builder = builder.where('subjectUri', 'is', null)
+    } else if (subjectType === 'record') {
+      builder = builder.where('subjectUri', 'is not', null)
+    }
+
+    // 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
+      })
     }
 
     if (types.length) {
@@ -748,6 +766,8 @@ export class ModerationService {
     subject,
     tags,
     excludeTags,
+    collections,
+    subjectType,
   }: {
     includeAllUserRecords?: boolean
     cursor?: string
@@ -768,6 +788,8 @@ export class ModerationService {
     sortField: 'lastReviewedAt' | 'lastReportedAt'
     tags: string[]
     excludeTags: string[]
+    collections: string[]
+    subjectType?: string
   }) {
     let builder = this.db.db.selectFrom('moderation_subject_status').selectAll()
     const { ref } = this.db.db.dynamic
@@ -787,11 +809,25 @@ export class ModerationService {
             : qb.where('recordPath', '=', ''),
         )
       }
+    } else if (subjectType === 'account') {
+      builder = builder.where('recordPath', '=', '')
+    } else if (subjectType === 'record') {
+      builder = builder.where('recordPath', '!=', '')
+    }
+
+    // If subjectType is set to 'account' let that take priority and ignore collections filter
+    if (collections.length && subjectType !== 'account') {
+      builder = builder.where('recordPath', '!=', '').where((qb) => {
+        collections.forEach((collection) => {
+          qb = qb.orWhere('recordPath', 'like', `${collection}/%`)
+        })
+        return qb
+      })
     }
 
     if (ignoreSubjects?.length) {
       builder = builder
-        .where('moderation_subject_status.did', 'not in', ignoreSubjects)
+        .where('did', 'not in', ignoreSubjects)
         .where('recordPath', 'not in', ignoreSubjects)
     }
 

package/src/set/service.ts

@@ -0,0 +1,227 @@
+import Database from '../db'
+import { Selectable } from 'kysely'
+import { SetDetail } from '../db/schema/ozone_set'
+import { SetView } from '../lexicon/types/tools/ozone/set/defs'
+import { paginate, TimeIdKeyset } from '../db/pagination'
+
+export type SetServiceCreator = (db: Database) => SetService
+
+export class SetService {
+  constructor(public db: Database) {}
+
+  static creator() {
+    return (db: Database) => new SetService(db)
+  }
+
+  buildQueryForSetWithSize() {
+    return this.db.db.selectFrom('set_detail as s').select([
+      's.id',
+      's.name',
+      's.description',
+      's.createdAt',
+      's.updatedAt',
+      (eb) =>
+        eb
+          .selectFrom('set_value')
+          .select((e) => e.fn.count<number>('setId').as('count'))
+          .whereRef('setId', '=', 's.id')
+          .as('setSize'),
+    ])
+  }
+
+  async query({
+    limit,
+    cursor,
+    namePrefix,
+    sortBy,
+    sortDirection,
+  }: {
+    limit: number
+    cursor?: string
+    namePrefix?: string
+    sortBy: 'name' | 'createdAt' | 'updatedAt'
+    sortDirection: 'asc' | 'desc'
+  }): Promise<{
+    sets: Selectable<SetDetail & { setSize: number }>[]
+    cursor?: string
+  }> {
+    let qb = this.buildQueryForSetWithSize().limit(limit)
+
+    if (namePrefix) {
+      qb = qb.where('s.name', 'like', `${namePrefix}%`)
+    }
+
+    if (cursor) {
+      if (sortBy === 'name') {
+        qb = qb.where('s.name', sortDirection === 'asc' ? '>' : '<', cursor)
+      } else {
+        qb = qb.where(
+          `s.${sortBy}`,
+          sortDirection === 'asc' ? '>' : '<',
+          new Date(cursor),
+        )
+      }
+    }
+
+    qb = qb.orderBy(`s.${sortBy}`, sortDirection)
+
+    const sets = await qb.execute()
+    const lastItem = sets.at(-1)
+
+    return {
+      sets,
+      cursor: lastItem
+        ? sortBy === 'name'
+          ? lastItem?.name
+          : lastItem?.[sortBy].toISOString()
+        : undefined,
+    }
+  }
+
+  async getByName(name: string): Promise<Selectable<SetDetail> | undefined> {
+    const query = this.db.db
+      .selectFrom('set_detail')
+      .selectAll()
+      .where('name', '=', name)
+
+    return await query.executeTakeFirst()
+  }
+
+  async getByNameWithSize(
+    name: string,
+  ): Promise<Selectable<SetDetail & { setSize: number }> | undefined> {
+    return await this.buildQueryForSetWithSize()
+      .where('s.name', '=', name)
+      .executeTakeFirst()
+  }
+
+  async getSetWithValues({
+    name,
+    limit,
+    cursor,
+  }: {
+    name: string
+    limit: number
+    cursor?: string
+  }): Promise<
+    | {
+        set: Selectable<SetDetail & { setSize: number }>
+        values: string[]
+        cursor?: string
+      }
+    | undefined
+  > {
+    const set = await this.getByNameWithSize(name)
+    if (!set) return undefined
+
+    const { ref } = this.db.db.dynamic
+    const qb = this.db.db
+      .selectFrom('set_value')
+      .selectAll()
+      .where('setId', '=', set.id)
+
+    const keyset = new TimeIdKeyset(ref(`createdAt`), ref('id'))
+    const paginatedBuilder = paginate(qb, {
+      limit,
+      cursor,
+      keyset,
+      direction: 'asc',
+    })
+
+    const result = await paginatedBuilder.execute()
+
+    return {
+      set,
+      values: result.map((v) => v.value),
+      cursor: keyset.packFromResult(result),
+    }
+  }
+  async upsert({
+    name,
+    description,
+  }: Pick<SetDetail, 'name' | 'description'>): Promise<void> {
+    await this.db.db
+      .insertInto('set_detail')
+      .values({
+        name,
+        description,
+        updatedAt: new Date(),
+      })
+      .onConflict((oc) => {
+        // if description is provided as a string, even an empty one, update it
+        // otherwise, just update the updatedAt timestamp
+        return oc.column('name').doUpdateSet(
+          typeof description === 'string'
+            ? {
+                description,
+                updatedAt: new Date(),
+              }
+            : { updatedAt: new Date() },
+        )
+      })
+      .execute()
+  }
+
+  async addValues(setId: number, values: string[]): Promise<void> {
+    await this.db.transaction(async (txn) => {
+      const now = new Date()
+      const query = txn.db
+        .insertInto('set_value')
+        .values(
+          values.map((value) => ({
+            setId,
+            value,
+            createdAt: now,
+          })),
+        )
+        .onConflict((oc) => oc.columns(['setId', 'value']).doNothing())
+
+      await query.execute()
+
+      // Update the set's updatedAt timestamp
+      await txn.db
+        .updateTable('set_detail')
+        .set({ updatedAt: now })
+        .where('id', '=', setId)
+        .execute()
+    })
+  }
+
+  async removeValues(setId: number, values: string[]): Promise<void> {
+    if (values.length < 1) {
+      return
+    }
+    await this.db.transaction(async (txn) => {
+      const query = txn.db
+        .deleteFrom('set_value')
+        .where('setId', '=', setId)
+        .where('value', 'in', values)
+
+      await query.execute()
+
+      // Update the set's updatedAt timestamp
+      await txn.db
+        .updateTable('set_detail')
+        .set({ updatedAt: new Date() })
+        .where('id', '=', setId)
+        .execute()
+    })
+  }
+
+  async removeSet(setId: number): Promise<void> {
+    await this.db.transaction(async (txn) => {
+      await txn.db.deleteFrom('set_value').where('setId', '=', setId).execute()
+      await txn.db.deleteFrom('set_detail').where('id', '=', setId).execute()
+    })
+  }
+
+  view(set: Selectable<SetDetail> & { setSize: number }): SetView {
+    return {
+      name: set.name,
+      description: set.description || undefined,
+      setSize: set.setSize,
+      createdAt: set.createdAt.toISOString(),
+      updatedAt: set.updatedAt.toISOString(),
+    }
+  }
+}