@atproto/ozone 0.2.9 → 0.2.11

package/src/verification/issuer.ts

@@ -1,146 +0,0 @@
-import { Selectable } from 'kysely'
-import { Agent, AtUri, CredentialSession } from '@atproto/api'
-import { VerifierConfig } from '../config/index.js'
-import { Verification } from '../db/schema/verification.js'
-
-export type VerificationInput = {
-  displayName: string
-  handle: string
-  subject: string
-  createdAt?: string
-}
-
-export type VerificationIssuerCreator = (
-  verifierConfig: VerifierConfig,
-) => VerificationIssuer
-
-const HANDLE_INVALID = 'handle.invalid'
-
-export class VerificationIssuer {
-  private session = new CredentialSession(new URL(this.verifierConfig.url))
-  private agent = new Agent(this.session)
-  constructor(private verifierConfig: VerifierConfig) {}
-
-  static creator() {
-    return (verifierConfig: VerifierConfig) =>
-      new VerificationIssuer(verifierConfig)
-  }
-
-  async getAgent() {
-    if (!this.session.hasSession) {
-      await this.session.login({
-        identifier: this.verifierConfig.did,
-        password: this.verifierConfig.password,
-      })
-    }
-
-    // Trigger a test request to check if the session is still valid, if not, we will login again
-    try {
-      await this.agent.com.atproto.server.getSession()
-    } catch (err) {
-      if ((err as any).status === 401) {
-        await this.session.login({
-          identifier: this.verifierConfig.did,
-          password: this.verifierConfig.password,
-        })
-      }
-    }
-
-    return this.agent
-  }
-
-  async verify(verifications: VerificationInput[]) {
-    const grantedVerifications: Selectable<Verification>[] = []
-    const failedVerifications: {
-      $type: 'tools.ozone.verification.grantVerifications#grantError'
-      subject: string
-      error: string
-    }[] = []
-    const now = new Date().toISOString()
-    const agent = await this.getAgent()
-    await Promise.allSettled(
-      verifications.map(async ({ displayName, handle, subject, createdAt }) => {
-        if (handle.toLowerCase() === HANDLE_INVALID) {
-          failedVerifications.push({
-            $type: 'tools.ozone.verification.grantVerifications#grantError',
-            error: 'Cannot verify with invalid handle',
-            subject,
-          })
-          return
-        }
-
-        try {
-          const verificationRecord = {
-            createdAt: createdAt || now,
-            issuer: this.verifierConfig.did,
-            displayName,
-            handle,
-            subject,
-          }
-          const {
-            data: { uri, cid },
-          } = await agent.com.atproto.repo.createRecord({
-            repo: this.verifierConfig.did,
-            record: verificationRecord,
-            collection: 'app.bsky.graph.verification',
-          })
-          grantedVerifications.push({
-            ...verificationRecord,
-            uri,
-            cid,
-            revokedAt: null,
-            updatedAt: now,
-            revokedBy: null,
-            revokeReason: null,
-          })
-        } catch (err) {
-          failedVerifications.push({
-            $type: 'tools.ozone.verification.grantVerifications#grantError',
-            error: (err as Error).message,
-            subject,
-          })
-          return
-        }
-      }),
-    )
-
-    return { grantedVerifications, failedVerifications }
-  }
-
-  async revoke({ uris }: { uris: string[] }) {
-    const revokedVerifications: string[] = []
-    const failedRevocations: Array<{ uri: string; error: string }> = []
-
-    const agent = await this.getAgent()
-
-    await Promise.allSettled(
-      uris.map(async (uri) => {
-        try {
-          const atUri = new AtUri(uri)
-
-          if (atUri.collection !== 'app.bsky.graph.verification') {
-            throw new Error(`Only verification records can be revoked`)
-          }
-
-          if (atUri.host !== this.verifierConfig.did) {
-            throw new Error(
-              `Cannot revoke verification record ${uri} not issued by ${this.verifierConfig.did}`,
-            )
-          }
-
-          await agent.com.atproto.repo.deleteRecord({
-            collection: atUri.collection,
-            repo: this.verifierConfig.did,
-            rkey: atUri.rkey,
-          })
-          revokedVerifications.push(uri)
-        } catch (err) {
-          failedRevocations.push({ uri, error: (err as Error).message })
-          return
-        }
-      }),
-    )
-
-    return { revokedVerifications, failedRevocations }
-  }
-}

package/src/verification/service.ts

@@ -1,208 +0,0 @@
-import { Selectable } from 'kysely'
-import {
-  $Typed,
-  AppBskyActorDefs,
-  AtUri,
-  ToolsOzoneModerationDefs,
-  ToolsOzoneVerificationDefs,
-} from '@atproto/api'
-import { Database } from '../db/index.js'
-import { CreatedAtUriKeyset, paginate } from '../db/pagination.js'
-import { Verification } from '../db/schema/verification.js'
-
-export type VerificationServiceCreator = (db: Database) => VerificationService
-
-export class VerificationService {
-  constructor(public db: Database) {}
-
-  static creator() {
-    return (db: Database) => new VerificationService(db)
-  }
-
-  async create(
-    verifications: Pick<
-      Verification,
-      | 'uri'
-      | 'issuer'
-      | 'subject'
-      | 'handle'
-      | 'displayName'
-      | 'createdAt'
-      | 'cid'
-    >[],
-  ) {
-    return this.db.transaction(async (tx) => {
-      return tx.db
-        .insertInto('verification')
-        .values(verifications)
-        .onConflict((oc) => oc.doNothing())
-        .returningAll()
-        .execute()
-    })
-  }
-
-  async markRevoked({
-    uris,
-    revokedBy,
-    revokedAt,
-    revokeReason,
-  }: {
-    uris: string[]
-    revokedBy?: string
-    revokedAt?: string
-    revokeReason?: string
-  }) {
-    const now = new Date().toISOString()
-    return this.db.transaction(async (tx) => {
-      for (const uri of uris) {
-        return tx.db
-          .updateTable('verification')
-          .set({
-            revokeReason,
-            updatedAt: now,
-            revokedAt: revokedAt || now,
-            // Allow setting revokedBy to a moderator/verifier DID and if it isn't set, default to the author of the verification record
-            revokedBy: revokedBy || new AtUri(uri).host,
-          })
-          .where('uri', '=', uri)
-          .where('revokedAt', 'is', null)
-          .execute()
-      }
-    })
-  }
-
-  async list({
-    sortDirection,
-    cursor,
-    createdAfter,
-    createdBefore,
-    issuers = [],
-    subjects = [],
-    isRevoked,
-    limit = 100,
-  }: {
-    sortDirection?: 'asc' | 'desc'
-    cursor?: string
-    createdAfter?: string
-    createdBefore?: string
-    issuers?: string[]
-    subjects?: string[]
-    isRevoked?: boolean
-    limit?: number
-  }) {
-    const { ref } = this.db.db.dynamic
-
-    let qb = this.db.db.selectFrom('verification').selectAll()
-
-    if (issuers.length) {
-      qb = qb.where('issuer', 'in', issuers)
-    }
-
-    if (isRevoked !== undefined) {
-      qb = qb.where('revokedAt', isRevoked ? 'is not' : 'is', null)
-    }
-
-    if (subjects.length) {
-      qb = qb.where('subject', 'in', subjects)
-    }
-
-    if (createdAfter) {
-      qb = qb.where('createdAt', '>=', createdAfter)
-    }
-
-    if (createdBefore) {
-      qb = qb.where('createdAt', '<=', createdBefore)
-    }
-
-    const keyset = new CreatedAtUriKeyset(ref(`createdAt`), ref('uri'))
-    const paginatedBuilder = paginate(qb, {
-      limit,
-      cursor,
-      keyset,
-      tryIndex: true,
-      direction: sortDirection === 'desc' ? 'desc' : 'asc',
-    })
-
-    const result = await paginatedBuilder.execute()
-    return { verifications: result, cursor: keyset.packFromResult(result) }
-  }
-
-  view(
-    verifications: Selectable<Verification>[],
-    repos: Map<
-      string,
-      | $Typed<ToolsOzoneModerationDefs.RepoViewDetail>
-      | $Typed<ToolsOzoneModerationDefs.RepoViewNotFound>
-    >,
-    profiles: Map<string, AppBskyActorDefs.ProfileViewDetailed>,
-  ): $Typed<ToolsOzoneVerificationDefs.VerificationView>[] {
-    return verifications.map((verification) => {
-      const issuerRepo = repos.get(verification.issuer)
-      const subjectRepo = repos.get(verification.subject)
-      const subjectProfile = profiles.get(verification.subject)
-      const issuerProfile = profiles.get(verification.issuer)
-      return {
-        $type: 'tools.ozone.verification.defs#verificationView',
-        uri: verification.uri,
-        issuer: verification.issuer,
-        subject: verification.subject,
-        createdAt: verification.createdAt,
-        displayName: verification.displayName,
-        handle: verification.handle,
-        updatedAt: verification.updatedAt || undefined,
-        revokedAt: verification.revokedAt || undefined,
-        revokedBy: verification.revokedBy || undefined,
-        revokeReason: verification.revokeReason || undefined,
-        issuerRepo,
-        subjectRepo,
-        subjectProfile: subjectProfile
-          ? {
-              $type: 'app.bsky.actor.defs#profileViewDetailed',
-              ...subjectProfile,
-            }
-          : undefined,
-        issuerProfile: issuerProfile
-          ? {
-              $type: 'app.bsky.actor.defs#profileViewDetailed',
-              ...issuerProfile,
-            }
-          : undefined,
-      }
-    })
-  }
-
-  async getFirehoseCursor() {
-    const entry = await this.db.db
-      .selectFrom('firehose_cursor')
-      .select('cursor')
-      .where('service', '=', 'verification')
-      .executeTakeFirst()
-
-    return entry?.cursor || null
-  }
-
-  createFirehoseCursor() {
-    return this.db.db
-      .insertInto('firehose_cursor')
-      .values({
-        service: 'verification',
-        cursor: null,
-      })
-      .onConflict((oc) => oc.doNothing())
-      .execute()
-  }
-
-  async updateFirehoseCursor(cursor: number) {
-    const updated = await this.db.db
-      .updateTable('firehose_cursor')
-      .set({ cursor })
-      .where('service', '=', 'verification')
-      .where((eb) =>
-        eb.or([eb('cursor', '<', cursor), eb('cursor', 'is', null)]),
-      )
-      .returningAll()
-      .executeTakeFirst()
-
-    return updated?.cursor
-  }
-}

package/src/verification/util.ts

@@ -1,53 +0,0 @@
-import { $Typed, ToolsOzoneModerationDefs } from '@atproto/api'
-import {
-  addAccountInfoToRepoViewDetail,
-  getPdsAccountInfos,
-} from '../api/util.js'
-import { AppContext } from '../context.js'
-import { ModerationService } from '../mod-service/index.js'
-import { ParsedLabelers } from '../util.js'
-
-export const getReposForVerifications = async (
-  ctx: AppContext,
-  labelers: ParsedLabelers,
-  modService: ModerationService,
-  dids: string[],
-  isModerator: boolean,
-) => {
-  const [partialRepos, accountInfo] = await Promise.all([
-    modService.views.repoDetails(dids, labelers),
-    getPdsAccountInfos(ctx, dids),
-  ])
-
-  const repos = new Map<
-    string,
-    | $Typed<ToolsOzoneModerationDefs.RepoViewDetail>
-    | $Typed<ToolsOzoneModerationDefs.RepoViewNotFound>
-  >(
-    dids.map((did) => {
-      const partialRepo = partialRepos.get(did)
-      if (!partialRepo) {
-        return [
-          did,
-          {
-            did,
-            $type: 'tools.ozone.moderation.defs#repoViewNotFound',
-          },
-        ]
-      }
-      return [
-        did,
-        {
-          ...addAccountInfoToRepoViewDetail(
-            partialRepo,
-            accountInfo.get(did) || null,
-            isModerator,
-          ),
-          $type: 'tools.ozone.moderation.defs#repoViewDetail',
-        },
-      ]
-    }),
-  )
-
-  return repos
-}

package/test.env

@@ -1,2 +0,0 @@
-LOG_ENABLED=true
-LOG_DESTINATION=test.log

package/tests/3p-labeler.test.ts

@@ -1,288 +0,0 @@
-import { AtpAgent } from '@atproto/api'
-import { Secp256k1Keypair } from '@atproto/crypto'
-import {
-  ModeratorClient,
-  SeedClient,
-  TestNetwork,
-  TestOzone,
-  basicSeed,
-  createOzoneDid,
-} from '@atproto/dev-env'
-import { ids } from '../src/lexicon/lexicons.js'
-import { LABELER_HEADER_NAME } from '../src/util.js'
-
-describe('labels from 3p labelers', () => {
-  let network: TestNetwork
-  let ozone: TestOzone
-  let thirdPartyLabeler: TestOzone
-  let agent: AtpAgent
-  let thirdPartyAgent: AtpAgent
-  let sc: SeedClient
-  let modClient: ModeratorClient
-  let thirdPartyModClient: ModeratorClient
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'ozone_admin_third_party_labeler_main',
-    })
-    ozone = network.ozone
-
-    const ozoneKey = await Secp256k1Keypair.create({ exportable: true })
-    const ozoneDid = await createOzoneDid(network.plc.url, ozoneKey)
-    thirdPartyLabeler = await TestOzone.create({
-      port: ozone.port + 10,
-      plcUrl: network.plc.url,
-      signingKey: ozoneKey,
-      serverDid: ozoneDid,
-      dbPostgresSchema: `ozone_admin_third_party_labeler_third_party`,
-      dbPostgresUrl: ozone.ctx.cfg.db.postgresUrl,
-      appviewUrl: network.bsky.url,
-      appviewDid: network.bsky.ctx.cfg.serverDid,
-      appviewPushEvents: true,
-      pdsUrl: network.pds.url,
-      pdsDid: network.pds.ctx.cfg.service.did,
-    })
-
-    thirdPartyAgent = thirdPartyLabeler.getAgent()
-    agent = ozone.getAgent()
-    sc = network.getSeedClient()
-    modClient = ozone.getModClient()
-    thirdPartyModClient = thirdPartyLabeler.getModClient()
-    await basicSeed(sc)
-    await network.processAll()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-    await thirdPartyLabeler?.close()
-  })
-
-  const getPostSubject = () => ({
-    $type: 'com.atproto.repo.strongRef',
-    uri: sc.posts[sc.dids.alice][0].ref.uriStr,
-    cid: sc.posts[sc.dids.alice][0].ref.cidStr,
-  })
-
-  const adjustLabels = async ({
-    uri,
-    cid,
-    src,
-    createLabelVals = [],
-    negateLabelVals = [],
-  }: {
-    uri: string
-    src: string
-    cid?: string
-    createLabelVals?: string[]
-    negateLabelVals?: string[]
-  }) => {
-    const labelEntries = createLabelVals.map((val) => ({
-      uri,
-      cid: cid || '',
-      val,
-      cts: new Date().toISOString(),
-      neg: false,
-      src,
-    }))
-
-    negateLabelVals.forEach((val) => {
-      labelEntries.push({
-        uri,
-        cid: cid || '',
-        val,
-        cts: new Date().toISOString(),
-        neg: true,
-        src,
-      })
-    })
-    await network.bsky.db.db.insertInto('label').values(labelEntries).execute()
-  }
-
-  const labelAccount = async (
-    client: ModeratorClient,
-    {
-      createLabelVals = [],
-      negateLabelVals = [],
-    }: { createLabelVals?: string[]; negateLabelVals?: string[] },
-  ) => {
-    const subject = {
-      $type: 'com.atproto.admin.defs#repoRef',
-      did: sc.dids.alice,
-    }
-    await client.emitEvent(
-      {
-        subject,
-        event: {
-          $type: 'tools.ozone.moderation.defs#modEventLabel',
-          createLabelVals,
-          negateLabelVals,
-        },
-        createdBy: sc.dids.carol,
-      },
-      'moderator',
-    )
-    await adjustLabels({
-      createLabelVals,
-      negateLabelVals,
-      uri: sc.dids.alice,
-      src: client.ozone.ctx.cfg.service.did,
-    })
-  }
-
-  const labelPost = async (
-    client: ModeratorClient,
-    {
-      createLabelVals = [],
-      negateLabelVals = [],
-    }: { createLabelVals?: string[]; negateLabelVals?: string[] },
-  ) => {
-    const subject = getPostSubject()
-    await client.emitEvent(
-      {
-        subject,
-        event: {
-          $type: 'tools.ozone.moderation.defs#modEventLabel',
-          createLabelVals,
-          negateLabelVals,
-        },
-        createdBy: sc.dids.carol,
-      },
-      'moderator',
-    )
-    await adjustLabels({
-      createLabelVals,
-      negateLabelVals,
-      uri: subject.uri,
-      cid: subject.cid,
-      src: client.ozone.ctx.cfg.service.did,
-    })
-  }
-
-  describe('record labels', () => {
-    it('includes only labels from current authority by default', async () => {
-      await Promise.all([
-        labelPost(modClient, { createLabelVals: ['spam'] }),
-        labelPost(thirdPartyModClient, { createLabelVals: ['weird'] }),
-      ])
-
-      const [
-        { data: recordFromCurrentAuthority },
-        { data: recordFromThirdParty },
-      ] = await Promise.all([
-        agent.api.tools.ozone.moderation.getRecord(
-          { uri: sc.posts[sc.dids.alice][0].ref.uriStr },
-          {
-            headers: await ozone.modHeaders(ids.ToolsOzoneModerationGetRecord),
-          },
-        ),
-        thirdPartyAgent.api.tools.ozone.moderation.getRecord(
-          { uri: sc.posts[sc.dids.alice][0].ref.uriStr },
-          {
-            headers: await thirdPartyLabeler.modHeaders(
-              ids.ToolsOzoneModerationGetRecord,
-            ),
-          },
-        ),
-      ])
-
-      const currentAuthorityLabels = recordFromCurrentAuthority.labels?.map(
-        (l) => l.val,
-      )
-      const thirdPartyLabels = recordFromThirdParty.labels?.map((l) => l.val)
-      expect(currentAuthorityLabels).toContain('spam')
-      expect(currentAuthorityLabels).not.toContain('weird')
-      expect(thirdPartyLabels).toContain('weird')
-      expect(thirdPartyLabels).not.toContain('spam')
-    })
-
-    it('includes labels from all authorities requested via header', async () => {
-      const authHeaders = await ozone.modHeaders(
-        ids.ToolsOzoneModerationGetRecord,
-      )
-      const { data: recordIncludingExternalLabels } =
-        await agent.api.tools.ozone.moderation.getRecord(
-          { uri: sc.posts[sc.dids.alice][0].ref.uriStr },
-          {
-            headers: {
-              ...authHeaders,
-              [LABELER_HEADER_NAME]: [
-                thirdPartyLabeler.ctx.cfg.service.did,
-                ozone.ctx.cfg.service.did,
-              ].join(','),
-            },
-          },
-        )
-      const labelVals = recordIncludingExternalLabels.labels?.map((l) => l.val)
-      const labelSources = recordIncludingExternalLabels.labels?.map(
-        (l) => l.src,
-      )
-      expect(labelVals).toContain('weird')
-      expect(labelVals).toContain('spam')
-      expect(labelSources).toContain(thirdPartyLabeler.ctx.cfg.service.did)
-      expect(labelSources).toContain(ozone.ctx.cfg.service.did)
-    })
-  })
-
-  describe('repo labels', () => {
-    it('includes only labels from current authority by default', async () => {
-      await Promise.all([
-        labelAccount(modClient, { createLabelVals: ['spam'] }),
-        labelAccount(thirdPartyModClient, { createLabelVals: ['weird'] }),
-      ])
-
-      const [{ data: repoFromCurrentAuthority }, { data: repoFromThirdParty }] =
-        await Promise.all([
-          agent.api.tools.ozone.moderation.getRepo(
-            { did: sc.dids.alice },
-            {
-              headers: await ozone.modHeaders(ids.ToolsOzoneModerationGetRepo),
-            },
-          ),
-          thirdPartyAgent.api.tools.ozone.moderation.getRepo(
-            { did: sc.dids.alice },
-            {
-              headers: await thirdPartyLabeler.modHeaders(
-                ids.ToolsOzoneModerationGetRepo,
-              ),
-            },
-          ),
-        ])
-
-      const currentAuthorityLabels = repoFromCurrentAuthority.labels?.map(
-        (l) => l.val,
-      )
-      const thirdPartyLabels = repoFromThirdParty.labels?.map((l) => l.val)
-      expect(currentAuthorityLabels).toContain('spam')
-      expect(currentAuthorityLabels).not.toContain('weird')
-      expect(thirdPartyLabels).toContain('weird')
-      expect(thirdPartyLabels).not.toContain('spam')
-    })
-
-    it('includes labels from all authorities requested via header', async () => {
-      const authHeaders = await ozone.modHeaders(
-        ids.ToolsOzoneModerationGetRepo,
-      )
-      const { data: recordIncludingExternalLabels } =
-        await agent.api.tools.ozone.moderation.getRepo(
-          { did: sc.dids.alice },
-          {
-            headers: {
-              ...authHeaders,
-              [LABELER_HEADER_NAME]: [
-                thirdPartyLabeler.ctx.cfg.service.did,
-                ozone.ctx.cfg.service.did,
-              ].join(','),
-            },
-          },
-        )
-      const labelVals = recordIncludingExternalLabels.labels?.map((l) => l.val)
-      const labelSources = recordIncludingExternalLabels.labels?.map(
-        (l) => l.src,
-      )
-      expect(labelVals).toContain('weird')
-      expect(labelVals).toContain('spam')
-      expect(labelSources).toContain(thirdPartyLabeler.ctx.cfg.service.did)
-      expect(labelSources).toContain(ozone.ctx.cfg.service.did)
-    })
-  })
-})