@atproto/ozone 0.2.9 → 0.2.11

package/src/tag-service/language-tagger.ts

@@ -1,101 +0,0 @@
-import lande from 'lande'
-import {
-  AppBskyActorProfile,
-  AppBskyFeedGenerator,
-  AppBskyFeedPost,
-  AppBskyGraphList,
-} from '@atproto/api'
-import { langLogger as log } from '../logger.js'
-import { ContentTagger } from './content-tagger.js'
-import { code3ToCode2 } from './language-data.js'
-
-const ifString = (value: unknown): string | undefined =>
-  typeof value === 'string' ? value : undefined
-const isStringProp = (obj: object, prop: string): string | undefined =>
-  prop in obj ? ifString(obj[prop]) : undefined
-
-export class LanguageTagger extends ContentTagger {
-  tagPrefix = 'lang:'
-
-  isApplicable(): boolean {
-    return !!this.subjectStatus && !this.tagAlreadyExists()
-  }
-
-  async buildTags(): Promise<string[]> {
-    try {
-      const recordLangs = await this.getRecordLang()
-      return recordLangs
-        ? recordLangs.map((lang) => `${this.tagPrefix}${lang}`)
-        : [`${this.tagPrefix}und`]
-    } catch (err) {
-      log.error({ subject: this.subject, err }, 'Error getting record langs')
-      return []
-    }
-  }
-
-  getTextFromRecord(recordValue: Record<string, unknown>): string | undefined {
-    let text: string | undefined
-
-    if (AppBskyGraphList.isRecord(recordValue)) {
-      text =
-        isStringProp(recordValue, 'description') ||
-        isStringProp(recordValue, 'name')
-    } else if (
-      AppBskyFeedGenerator.isRecord(recordValue) ||
-      AppBskyActorProfile.isRecord(recordValue)
-    ) {
-      text =
-        isStringProp(recordValue, 'description') ||
-        isStringProp(recordValue, 'displayName')
-    } else if (AppBskyFeedPost.isRecord(recordValue)) {
-      text = isStringProp(recordValue, 'text')
-    }
-
-    return text?.trim()
-  }
-
-  async getRecordLang(): Promise<string[] | null> {
-    const langs = new Set<string>()
-
-    if (
-      this.subject.isRepo() ||
-      (this.subject.isRecord() &&
-        this.subject.uri.endsWith('/app.bsky.actor.profile/self'))
-    ) {
-      const feed = await this.moderationService.views.fetchAuthorFeed(
-        this.subject.did,
-      )
-      feed.forEach((item) => {
-        const itemLangs = item.post.record['langs'] as string[] | null
-        if (itemLangs?.length) {
-          // Pick the first fragment of the lang code so that instead of `en-US` and `en-GB` we get `en`
-          itemLangs.forEach((lang) => langs.add(lang.split('-')[0]))
-        }
-      })
-    }
-
-    if (this.subject.isRecord()) {
-      const recordByUri = await this.moderationService.views.fetchRecords([
-        this.subject,
-      ])
-      const record = recordByUri.get(this.subject.uri)
-      const recordLang = record?.value.langs as string[] | null
-      const recordText = record
-        ? this.getTextFromRecord(record.value)
-        : undefined
-      if (recordLang?.length) {
-        recordLang
-          .map((lang) => lang.split('-')[0])
-          .forEach((lang) => langs.add(lang))
-      } else if (recordText) {
-        const detectedLanguages = lande(recordText)
-        if (detectedLanguages.length) {
-          const langCode = code3ToCode2(detectedLanguages[0][0])
-          if (langCode) langs.add(langCode)
-        }
-      }
-    }
-
-    return langs.size > 0 ? Array.from(langs) : null
-  }
-}

package/src/tag-service/util.ts

@@ -1,13 +0,0 @@
-import { ReasonType } from '../lexicon/types/com/atproto/moderation/defs.js'
-
-export const getTagForReport = (reasonType: ReasonType) => {
-  const reasonWithoutPrefix = reasonType
-    .replace('com.atproto.moderation.defs#reason', '')
-    .replace('tools.ozone.report.defs#reason', '')
-
-  const kebabCase = reasonWithoutPrefix
-    .replace(/([a-z])([A-Z])/g, '$1-$2')
-    .toLowerCase()
-
-  return `report:${kebabCase}`
-}

package/src/team/index.ts

@@ -1,296 +0,0 @@
-import { Selectable } from 'kysely'
-import AtpAgent from '@atproto/api'
-import { chunkArray } from '@atproto/common'
-import { InvalidRequestError } from '@atproto/xrpc-server'
-import { Database } from '../db/index.js'
-import { Member } from '../db/schema/member.js'
-import { ids } from '../lexicon/lexicons.js'
-import { ProfileViewDetailed } from '../lexicon/types/app/bsky/actor/defs.js'
-import { Member as TeamMember } from '../lexicon/types/tools/ozone/team/defs.js'
-import { httpLogger } from '../logger.js'
-import { AuthHeaders } from '../mod-service/views.js'
-
-export type TeamServiceCreator = (db: Database) => TeamService
-
-export class TeamService {
-  constructor(
-    public db: Database,
-    private appviewAgent: AtpAgent,
-    private appviewDid: string,
-    private createAuthHeaders: (
-      aud: string,
-      method: string,
-    ) => Promise<AuthHeaders>,
-  ) {}
-
-  static creator(
-    appviewAgent: AtpAgent,
-    appviewDid: string,
-    createAuthHeaders: (aud: string, method: string) => Promise<AuthHeaders>,
-  ) {
-    return (db: Database) =>
-      new TeamService(db, appviewAgent, appviewDid, createAuthHeaders)
-  }
-
-  async list({
-    cursor,
-    limit = 25,
-    roles,
-    disabled,
-    q,
-  }: {
-    q?: string
-    cursor?: string
-    limit?: number
-    disabled?: boolean
-    roles?: string[]
-  }): Promise<{ members: Selectable<Member>[]; cursor?: string }> {
-    let builder = this.db.db.selectFrom('member').selectAll()
-    if (cursor) {
-      builder = builder.where('createdAt', '>', new Date(cursor))
-    }
-    if (roles !== undefined) {
-      const knownRoles = roles.filter(
-        (r) =>
-          r === 'tools.ozone.team.defs#roleAdmin' ||
-          r === 'tools.ozone.team.defs#roleModerator' ||
-          r === 'tools.ozone.team.defs#roleVerifier' ||
-          r === 'tools.ozone.team.defs#roleTriage',
-      )
-
-      // Optimization: no need to query to know that no values will be returned
-      if (!knownRoles.length) return { members: [] }
-
-      builder = builder.where('role', 'in', knownRoles)
-    }
-    if (disabled !== undefined) {
-      builder = builder.where('disabled', disabled ? 'is' : 'is not', true)
-    }
-    if (q) {
-      builder = builder.where((eb) =>
-        eb.or([
-          eb('handle', 'ilike', `%${q}%`),
-          eb('displayName', 'ilike', `%${q}%`),
-        ]),
-      )
-    }
-
-    const members = await builder
-      .limit(limit)
-      .orderBy('createdAt', 'asc')
-      .orderBy('handle', 'asc')
-      .execute()
-
-    return { members, cursor: members.at(-1)?.createdAt.toISOString() }
-  }
-
-  async create({
-    role,
-    did,
-    disabled,
-    updatedAt,
-    createdAt,
-    lastUpdatedBy,
-  }: Omit<Selectable<Member>, 'createdAt' | 'updatedAt'> & {
-    createdAt?: Date
-    updatedAt?: Date
-  }): Promise<Selectable<Member>> {
-    const now = new Date()
-    const newMember = await this.db.db
-      .insertInto('member')
-      .values({
-        role,
-        did,
-        disabled,
-        lastUpdatedBy,
-        updatedAt: updatedAt || now,
-        createdAt: createdAt || now,
-      })
-      .returningAll()
-      .executeTakeFirstOrThrow()
-
-    return newMember
-  }
-
-  async upsert({
-    role,
-    did,
-    lastUpdatedBy,
-  }: Pick<
-    Selectable<Member>,
-    'role' | 'did' | 'lastUpdatedBy'
-  >): Promise<void> {
-    const now = new Date()
-    await this.db.db
-      .insertInto('member')
-      .values({
-        role,
-        did,
-        lastUpdatedBy,
-        disabled: false,
-        updatedAt: now,
-        createdAt: now,
-      })
-      .onConflict((oc) =>
-        oc.column('did').doUpdateSet({ role, updatedAt: now, lastUpdatedBy }),
-      )
-      .execute()
-  }
-
-  async update(
-    did: string,
-    updates: Partial<
-      Pick<
-        Selectable<Member>,
-        'role' | 'disabled' | 'lastUpdatedBy' | 'updatedAt'
-      >
-    >,
-  ): Promise<Selectable<Member>> {
-    const { role, disabled, lastUpdatedBy, updatedAt = new Date() } = updates
-    const updatedMember = await this.db.db
-      .updateTable('member')
-      .where('did', '=', did)
-      .set({
-        role,
-        disabled,
-        lastUpdatedBy,
-        updatedAt,
-      })
-      .returningAll()
-      .executeTakeFirstOrThrow()
-
-    return updatedMember
-  }
-
-  async delete(did: string): Promise<void> {
-    await this.db.db.deleteFrom('member').where('did', '=', did).execute()
-  }
-
-  async assertCanDelete(did: string): Promise<void> {
-    const memberExists = await this.doesMemberExist(did)
-
-    if (!memberExists) {
-      throw new InvalidRequestError('member not found', 'MemberNotFound')
-    }
-  }
-
-  async doesMemberExist(did: string): Promise<boolean> {
-    const member = await this.db.db
-      .selectFrom('member')
-      .select('did')
-      .where('did', '=', did)
-      .executeTakeFirst()
-
-    return !!member
-  }
-
-  async getMember(did: string): Promise<Selectable<Member> | undefined> {
-    const member = await this.db.db
-      .selectFrom('member')
-      .selectAll()
-      .where('did', '=', did)
-      .executeTakeFirst()
-
-    return member
-  }
-
-  getMemberRole(member?: Selectable<Member>) {
-    const isAdmin = member?.role === 'tools.ozone.team.defs#roleAdmin'
-    const isModerator =
-      isAdmin || member?.role === 'tools.ozone.team.defs#roleModerator'
-    const isTriage =
-      isModerator || member?.role === 'tools.ozone.team.defs#roleTriage'
-    const isVerifier =
-      isAdmin || member?.role === 'tools.ozone.team.defs#roleVerifier'
-
-    return {
-      isModerator,
-      isAdmin,
-      isTriage,
-      isVerifier,
-    }
-  }
-
-  // getProfiles() only allows 25 DIDs at a time so we need to query in chunks
-  async getProfiles(dids: string[]): Promise<Map<string, ProfileViewDetailed>> {
-    const profiles = new Map<string, ProfileViewDetailed>()
-
-    try {
-      const headers = await this.createAuthHeaders(
-        this.appviewDid,
-        ids.AppBskyActorGetProfiles,
-      )
-
-      for (const actors of chunkArray(dids, 25)) {
-        const { data } = await this.appviewAgent.getProfiles(
-          { actors },
-          headers,
-        )
-
-        data.profiles.forEach((profile) => {
-          profiles.set(profile.did, profile)
-        })
-      }
-    } catch (err) {
-      httpLogger.error({ err, dids }, 'Failed to get profiles for team members')
-    }
-
-    return profiles
-  }
-
-  async syncMemberProfiles(): Promise<void> {
-    let lastDid = ''
-    // Max 25 profiles can be fetched at a time so let's pull 25 members at a time from the db and update their profile details
-    do {
-      const members = await this.db.db
-        .selectFrom('member')
-        .select(['did'])
-        .limit(25)
-        .$if(!!lastDid, (q) => q.where('did', '>', lastDid))
-        .orderBy('did', 'asc')
-        .execute()
-
-      const dids = members.map((member) => member.did)
-      const profiles = await this.getProfiles(dids)
-
-      for (const profile of profiles.values()) {
-        await this.db.db
-          .updateTable('member')
-          .where('did', '=', profile.did)
-          .set({
-            handle: profile.handle,
-            displayName: profile.displayName || null,
-          })
-          .execute()
-      }
-
-      lastDid = dids.at(-1) || ''
-    } while (lastDid)
-  }
-
-  async viewByDids(dids: string[]): Promise<Map<string, TeamMember>> {
-    if (!dids.length) return new Map()
-    const members = await this.db.db
-      .selectFrom('member')
-      .selectAll()
-      .where('did', 'in', dids)
-      .execute()
-    const memberViews = await this.view(members)
-    return new Map(memberViews.map((m) => [m.did, m]))
-  }
-
-  async view(members: Selectable<Member>[]): Promise<TeamMember[]> {
-    const profiles = await this.getProfiles(members.map(({ did }) => did))
-    return members.map((member) => {
-      return {
-        did: member.did,
-        role: member.role,
-        disabled: member.disabled,
-        profile: profiles.get(member.did),
-        createdAt: member.createdAt.toISOString(),
-        updatedAt: member.updatedAt.toISOString(),
-        lastUpdatedBy: member.lastUpdatedBy,
-      }
-    })
-  }
-}

package/src/util.ts

@@ -1,230 +0,0 @@
-import assert from 'node:assert'
-import { parseList } from 'structured-headers'
-import { createRetryable } from '@atproto/common'
-import { ResponseType, XRPCError } from '@atproto/xrpc'
-import { Database } from './db/index.js'
-
-export const getSigningKeyId = async (
-  db: Database,
-  signingKey: string,
-): Promise<number> => {
-  const selectRes = await db.db
-    .selectFrom('signing_key')
-    .selectAll()
-    .where('key', '=', signingKey)
-    .executeTakeFirst()
-  if (selectRes) {
-    return selectRes.id
-  }
-  const insertRes = await db.db
-    .insertInto('signing_key')
-    .values({ key: signingKey })
-    .returningAll()
-    .executeTakeFirstOrThrow()
-  return insertRes.id
-}
-
-export const RETRYABLE_HTTP_STATUS_CODES = new Set([
-  408, 425, 429, 500, 502, 503, 504, 522, 524,
-])
-
-export const retryHttp = createRetryable((err: unknown) => {
-  if (err instanceof XRPCError) {
-    if (err.status === ResponseType.Unknown) return true
-    return RETRYABLE_HTTP_STATUS_CODES.has(err.status)
-  }
-  return false
-})
-
-export type ParsedLabelers = {
-  dids: string[]
-  redact: Set<string>
-}
-
-export const LABELER_HEADER_NAME = 'atproto-accept-labelers'
-
-export const parseLabelerHeader = (
-  header: string | undefined,
-  ignoreDid?: string,
-): ParsedLabelers | null => {
-  if (!header) return null
-  const labelerDids = new Set<string>()
-  const redactDids = new Set<string>()
-  const parsed = parseList(header)
-  for (const item of parsed) {
-    const did = item[0].toString()
-    if (!did) {
-      return null
-    }
-    if (did === ignoreDid) {
-      continue
-    }
-    labelerDids.add(did)
-    const redact = item[1].get('redact')?.valueOf()
-    if (redact === true) {
-      redactDids.add(did)
-    }
-  }
-  return {
-    dids: [...labelerDids],
-    redact: redactDids,
-  }
-}
-
-export const defaultLabelerHeader = (dids: string[]): ParsedLabelers => {
-  return {
-    dids,
-    redact: new Set(dids),
-  }
-}
-
-export const formatLabelerHeader = (parsed: ParsedLabelers): string => {
-  const parts = parsed.dids.map((did) =>
-    parsed.redact.has(did) ? `${did};redact` : did,
-  )
-  return parts.join(',')
-}
-
-/**
- * Utility function similar to `setInterval()`. The main difference is that the
- * execution is controlled through a signal and that the function will wait for
- * `interval` milliseconds *between* the end of the previous execution and the
- * start of the next one (instead of starting the execution every `interval`
- * milliseconds), ensuring that the function is not running concurrently.
- *
- * @param fn The function to execute. That function must not throw any error
- * other than {@link signal}'s {@link AbortSignal.reason} or an {@link Error}
- * that has the {@link signal}'s {@link AbortSignal.reason} as its
- * {@link Error.cause}.
- *
- * @returns A promise that resolves when the signal is aborted, and the last
- * execution is done.
- *
- * @throws {AbortSignal['reason']} if the {@link signal} is already aborted.
- * @throws {TypeError} if {@link fn} throws an unexpected error (with the
- * unexpected error as the {@link Error.cause}).
- */
-export async function startInterval(
-  fn: (signal: AbortSignal) => void | Promise<void>,
-  interval: number,
-  signal: AbortSignal,
-  runImmediately = false,
-) {
-  signal.throwIfAborted()
-
-  // Renaming for clarity
-  const inputSignal = signal
-
-  const intervalController = new AbortController()
-  const intervalSignal = intervalController.signal
-
-  return new Promise<void>((resolve, reject) => {
-    let timer: NodeJS.Timeout | undefined
-
-    const run = async () => {
-      // Cloning the signal for this particular run to prevent memory leaks
-      const runController = boundAbortController(intervalSignal)
-      const runSignal = runController.signal
-
-      try {
-        await fn(runSignal)
-      } catch (err) {
-        if (err != null && isCausedBySignal(err, runSignal)) {
-          // Silently ignore the error if it is caused by the signal. At this
-          // point, the interval controller was aborted, which will cause the
-          // promise to resolve in the "finally" block bellow.
-        } else {
-          // Invalid behavior: stop the interval and reject the promise.
-          const error = new TypeError('Unexpected error', { cause: err })
-
-          // Rejecting here will make `resolve()` in the "finally" block to be a
-          // no-op. Rejecting before aborting the controller to ensure the
-          // promise does not get resolved by the `abort` event listeners.
-          reject(error)
-
-          // Using `error` as abort reason to avoid creating an AbortError.
-          intervalController.abort(error)
-        }
-      } finally {
-        // Cleanup the listeners added by `boundAbortController`
-        runController.abort()
-
-        if (intervalSignal.aborted) resolve()
-        else schedule()
-      }
-    }
-
-    const schedule = () => {
-      assert(timer === undefined, 'unexpected state')
-      timer = setTimeout(() => {
-        timer = undefined // "running" state
-        void run()
-      }, interval)
-    }
-
-    inputSignal.addEventListener(
-      'abort',
-      // This function will only be called if the `inputSignal` is aborted
-      // before the interval controller is aborted.
-      () => {
-        // Stop the interval, using the input signal's reason
-        intervalController.abort(inputSignal.reason)
-
-        if (timer === undefined) {
-          // `fn` is currently running; `run`'s finally block will resolve the
-          // promise.
-        } else {
-          // The execution was scheduled but not started yet. Clear the timer
-          // and resolve the promise.
-          clearTimeout(timer)
-          resolve()
-        }
-      },
-      // Remove the listener whenever the interval is aborted.
-      { signal: intervalSignal },
-    )
-
-    if (runImmediately) void run()
-    else schedule()
-  })
-}
-
-/**
- * Determines whether the cause of an error is a signal's reason
- */
-export function isCausedBySignal(err: unknown, signal: AbortSignal) {
-  if (!signal.aborted) return false
-  if (signal.reason == null) return false // Ignore nullish reasons
-  return (
-    err === signal.reason ||
-    (err instanceof Error && err.cause === signal.reason)
-  )
-}
-
-/**
- * Creates an AbortController that will be aborted when any of the given signals
- * is aborted.
- *
- * @note Make sure to call `abortController.abort()` when you are done with
- * the controller to avoid memory leaks.
- *
- * @throws if any of the input signals is already aborted.
- */
-export function boundAbortController(
-  ...signals: readonly (AbortSignal | undefined | null)[]
-): AbortController {
-  for (const signal of signals) {
-    signal?.throwIfAborted()
-  }
-
-  const abortController = new AbortController()
-  const abort = function (event: Event) {
-    abortController.abort((event.target as AbortSignal)?.reason)
-  }
-
-  for (const signal of signals) {
-    signal?.addEventListener('abort', abort, { signal: abortController.signal })
-  }
-
-  return abortController
-}