@atproto/bsky 0.0.15 → 0.0.17

package/tests/views/timeline.test.ts

@@ -1,7 +1,6 @@
 import assert from 'assert'
 import AtpAgent from '@atproto/api'
 import { TestNetwork, SeedClient } from '@atproto/dev-env'
-import { TAKEDOWN } from '@atproto/api/src/client/types/com/atproto/admin/defs'
 import { forSnapshot, getOriginator, paginateAll } from '../_util'
 import basicSeed from '../seeds/basic'
 import { FeedAlgorithm } from '../../src/api/app/bsky/util/feed'
@@ -182,11 +181,11 @@ describe('timeline views', () => {
   })
 
   it('blocks posts, reposts, replies by actor takedown', async () => {
-    const actionResults = await Promise.all(
+    await Promise.all(
       [bob, carol].map((did) =>
-        agent.api.com.atproto.admin.takeModerationAction(
+        agent.api.com.atproto.admin.emitModerationEvent(
           {
-            action: TAKEDOWN,
+            event: { $type: 'com.atproto.admin.defs#modEventTakedown' },
             subject: {
               $type: 'com.atproto.admin.defs#repoRef',
               did,
@@ -211,10 +210,14 @@ describe('timeline views', () => {
 
     // Cleanup
     await Promise.all(
-      actionResults.map((result) =>
-        agent.api.com.atproto.admin.reverseModerationAction(
+      [bob, carol].map((did) =>
+        agent.api.com.atproto.admin.emitModerationEvent(
           {
-            id: result.data.id,
+            event: { $type: 'com.atproto.admin.defs#modEventReverseTakedown' },
+            subject: {
+              $type: 'com.atproto.admin.defs#repoRef',
+              did,
+            },
             createdBy: 'did:example:admin',
             reason: 'Y',
           },
@@ -230,11 +233,11 @@ describe('timeline views', () => {
   it('blocks posts, reposts, replies by record takedown.', async () => {
     const postRef1 = sc.posts[dan][1].ref // Repost
     const postRef2 = sc.replies[bob][0].ref // Post and reply parent
-    const actionResults = await Promise.all(
+    await Promise.all(
       [postRef1, postRef2].map((postRef) =>
-        agent.api.com.atproto.admin.takeModerationAction(
+        agent.api.com.atproto.admin.emitModerationEvent(
           {
-            action: TAKEDOWN,
+            event: { $type: 'com.atproto.admin.defs#modEventTakedown' },
             subject: {
               $type: 'com.atproto.repo.strongRef',
               uri: postRef.uriStr,
@@ -260,10 +263,15 @@ describe('timeline views', () => {
 
     // Cleanup
     await Promise.all(
-      actionResults.map((result) =>
-        agent.api.com.atproto.admin.reverseModerationAction(
+      [postRef1, postRef2].map((postRef) =>
+        agent.api.com.atproto.admin.emitModerationEvent(
           {
-            id: result.data.id,
+            event: { $type: 'com.atproto.admin.defs#modEventReverseTakedown' },
+            subject: {
+              $type: 'com.atproto.repo.strongRef',
+              uri: postRef.uriStr,
+              cid: postRef.cidStr,
+            },
             createdBy: 'did:example:admin',
             reason: 'Y',
           },

package/dist/api/com/atproto/admin/resolveModerationReports.d.ts

@@ -1,3 +0,0 @@
-import { Server } from '../../../../lexicon';
-import AppContext from '../../../../context';
-export default function (server: Server, ctx: AppContext): void;

package/dist/api/com/atproto/admin/reverseModerationAction.d.ts

@@ -1,3 +0,0 @@
-import { Server } from '../../../../lexicon';
-import AppContext from '../../../../context';
-export default function (server: Server, ctx: AppContext): void;

package/dist/api/com/atproto/admin/takeModerationAction.d.ts

@@ -1,3 +0,0 @@
-import { Server } from '../../../../lexicon';
-import AppContext from '../../../../context';
-export default function (server: Server, ctx: AppContext): void;

package/dist/db/tables/did-cache.d.ts

@@ -1,10 +0,0 @@
-import { DidDocument } from '@atproto/identity';
-export interface DidCache {
-    did: string;
-    doc: DidDocument;
-    updatedAt: number;
-}
-export declare const tableName = "did_cache";
-export declare type PartialDB = {
-    [tableName]: DidCache;
-};

package/dist/feed-gen/best-of-follows.d.ts

@@ -1,29 +0,0 @@
-import { AlgoHandler } from './types';
-import { GenericKeyset } from '../db/pagination';
-declare const handler: AlgoHandler;
-export default handler;
-declare type Result = {
-    score: number;
-    cid: string;
-};
-declare type LabeledResult = {
-    primary: number;
-    secondary: string;
-};
-export declare class ScoreKeyset extends GenericKeyset<Result, LabeledResult> {
-    labelResult(result: Result): {
-        primary: number;
-        secondary: string;
-    };
-    labeledResultToCursor(labeled: LabeledResult): {
-        primary: string;
-        secondary: string;
-    };
-    cursorToLabeledResult(cursor: {
-        primary: string;
-        secondary: string;
-    }): {
-        primary: number;
-        secondary: string;
-    };
-}

package/dist/feed-gen/whats-hot.d.ts

@@ -1,29 +0,0 @@
-import { AlgoHandler } from './types';
-import { GenericKeyset } from '../db/pagination';
-declare const handler: AlgoHandler;
-export default handler;
-declare type Result = {
-    score: number;
-    cid: string;
-};
-declare type LabeledResult = {
-    primary: number;
-    secondary: string;
-};
-export declare class ScoreKeyset extends GenericKeyset<Result, LabeledResult> {
-    labelResult(result: Result): {
-        primary: number;
-        secondary: string;
-    };
-    labeledResultToCursor(labeled: LabeledResult): {
-        primary: string;
-        secondary: string;
-    };
-    cursorToLabeledResult(cursor: {
-        primary: string;
-        secondary: string;
-    }): {
-        primary: number;
-        secondary: string;
-    };
-}

package/dist/feed-gen/with-friends.d.ts

@@ -1,3 +0,0 @@
-import { AlgoHandler } from './types';
-declare const handler: AlgoHandler;
-export default handler;

package/dist/label-cache.d.ts

@@ -1,19 +0,0 @@
-import { PrimaryDatabase } from './db';
-import { Label } from './db/tables/label';
-export declare class LabelCache {
-    db: PrimaryDatabase;
-    bySubject: Record<string, Label[]>;
-    latestLabel: string;
-    refreshes: number;
-    destroyed: boolean;
-    constructor(db: PrimaryDatabase);
-    start(): void;
-    fullRefresh(): Promise<void>;
-    partialRefresh(): Promise<void>;
-    poll(): Promise<void>;
-    processLabels(labels: Label[]): void;
-    wipeCache(): void;
-    stop(): void;
-    forSubject(subject: string, includeNeg?: boolean): Label[];
-    forSubjects(subjects: string[], includeNeg?: boolean): Label[];
-}

package/src/api/com/atproto/admin/getModerationAction.ts

@@ -1,44 +0,0 @@
-import { Server } from '../../../../lexicon'
-import AppContext from '../../../../context'
-import { addAccountInfoToRepoView, getPdsAccountInfo } from './util'
-import {
-  isRecordView,
-  isRepoView,
-} from '../../../../lexicon/types/com/atproto/admin/defs'
-
-export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.admin.getModerationAction({
-    auth: ctx.roleVerifier,
-    handler: async ({ params, auth }) => {
-      const { id } = params
-      const db = ctx.db.getPrimary()
-      const moderationService = ctx.services.moderation(db)
-      const result = await moderationService.getActionOrThrow(id)
-
-      const [action, accountInfo] = await Promise.all([
-        moderationService.views.actionDetail(result),
-        getPdsAccountInfo(ctx, result.subjectDid),
-      ])
-
-      // add in pds account info if available
-      if (isRepoView(action.subject)) {
-        action.subject = addAccountInfoToRepoView(
-          action.subject,
-          accountInfo,
-          auth.credentials.moderator,
-        )
-      } else if (isRecordView(action.subject)) {
-        action.subject.repo = addAccountInfoToRepoView(
-          action.subject.repo,
-          accountInfo,
-          auth.credentials.moderator,
-        )
-      }
-
-      return {
-        encoding: 'application/json',
-        body: action,
-      }
-    },
-  })
-}

package/src/api/com/atproto/admin/getModerationReport.ts

@@ -1,43 +0,0 @@
-import { Server } from '../../../../lexicon'
-import AppContext from '../../../../context'
-import {
-  isRecordView,
-  isRepoView,
-} from '../../../../lexicon/types/com/atproto/admin/defs'
-import { addAccountInfoToRepoView, getPdsAccountInfo } from './util'
-
-export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.admin.getModerationReport({
-    auth: ctx.roleVerifier,
-    handler: async ({ params, auth }) => {
-      const { id } = params
-      const db = ctx.db.getPrimary()
-      const moderationService = ctx.services.moderation(db)
-      const result = await moderationService.getReportOrThrow(id)
-      const [report, accountInfo] = await Promise.all([
-        moderationService.views.reportDetail(result),
-        getPdsAccountInfo(ctx, result.subjectDid),
-      ])
-
-      // add in pds account info if available
-      if (isRepoView(report.subject)) {
-        report.subject = addAccountInfoToRepoView(
-          report.subject,
-          accountInfo,
-          auth.credentials.moderator,
-        )
-      } else if (isRecordView(report.subject)) {
-        report.subject.repo = addAccountInfoToRepoView(
-          report.subject.repo,
-          accountInfo,
-          auth.credentials.moderator,
-        )
-      }
-
-      return {
-        encoding: 'application/json',
-        body: report,
-      }
-    },
-  })
-}

package/src/api/com/atproto/admin/resolveModerationReports.ts

@@ -1,24 +0,0 @@
-import { Server } from '../../../../lexicon'
-import AppContext from '../../../../context'
-
-export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.admin.resolveModerationReports({
-    auth: ctx.roleVerifier,
-    handler: async ({ input }) => {
-      const db = ctx.db.getPrimary()
-      const moderationService = ctx.services.moderation(db)
-      const { actionId, reportIds, createdBy } = input.body
-
-      const moderationAction = await db.transaction(async (dbTxn) => {
-        const moderationTxn = ctx.services.moderation(dbTxn)
-        await moderationTxn.resolveReports({ reportIds, actionId, createdBy })
-        return await moderationTxn.getActionOrThrow(actionId)
-      })
-
-      return {
-        encoding: 'application/json',
-        body: await moderationService.views.action(moderationAction),
-      }
-    },
-  })
-}

package/src/api/com/atproto/admin/reverseModerationAction.ts

@@ -1,115 +0,0 @@
-import {
-  AuthRequiredError,
-  InvalidRequestError,
-  UpstreamFailureError,
-} from '@atproto/xrpc-server'
-import {
-  ACKNOWLEDGE,
-  ESCALATE,
-  TAKEDOWN,
-} from '../../../../lexicon/types/com/atproto/admin/defs'
-import { Server } from '../../../../lexicon'
-import AppContext from '../../../../context'
-import { retryHttp } from '../../../../util/retry'
-
-export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.admin.reverseModerationAction({
-    auth: ctx.roleVerifier,
-    handler: async ({ input, auth }) => {
-      const access = auth.credentials
-      const db = ctx.db.getPrimary()
-      const moderationService = ctx.services.moderation(db)
-      const { id, createdBy, reason } = input.body
-
-      const { result, restored } = await db.transaction(async (dbTxn) => {
-        const moderationTxn = ctx.services.moderation(dbTxn)
-        const labelTxn = ctx.services.label(dbTxn)
-        const now = new Date()
-
-        const existing = await moderationTxn.getAction(id)
-        if (!existing) {
-          throw new InvalidRequestError('Moderation action does not exist')
-        }
-        if (existing.reversedAt !== null) {
-          throw new InvalidRequestError(
-            'Moderation action has already been reversed',
-          )
-        }
-
-        // apply access rules
-
-        // if less than moderator access then can only reverse ack and escalation actions
-        if (
-          !access.moderator &&
-          ![ACKNOWLEDGE, ESCALATE].includes(existing.action)
-        ) {
-          throw new AuthRequiredError(
-            'Must be a full moderator to reverse this type of action',
-          )
-        }
-        // if less than moderator access then cannot reverse takedown on an account
-        if (
-          !access.moderator &&
-          existing.action === TAKEDOWN &&
-          existing.subjectType === 'com.atproto.admin.defs#repoRef'
-        ) {
-          throw new AuthRequiredError(
-            'Must be a full moderator to reverse an account takedown',
-          )
-        }
-
-        const { result, restored } = await moderationTxn.revertAction({
-          id,
-          createdAt: now,
-          createdBy,
-          reason,
-        })
-
-        // invert creates & negates
-        const { createLabelVals, negateLabelVals } = result
-        const negate =
-          createLabelVals && createLabelVals.length > 0
-            ? createLabelVals.split(' ')
-            : undefined
-        const create =
-          negateLabelVals && negateLabelVals.length > 0
-            ? negateLabelVals.split(' ')
-            : undefined
-        await labelTxn.formatAndCreate(
-          ctx.cfg.labelerDid,
-          result.subjectUri ?? result.subjectDid,
-          result.subjectCid,
-          { create, negate },
-        )
-
-        return { result, restored }
-      })
-
-      if (restored && ctx.moderationPushAgent) {
-        const agent = ctx.moderationPushAgent
-        const { subjects } = restored
-        const results = await Promise.allSettled(
-          subjects.map((subject) =>
-            retryHttp(() =>
-              agent.api.com.atproto.admin.updateSubjectStatus({
-                subject,
-                takedown: {
-                  applied: false,
-                },
-              }),
-            ),
-          ),
-        )
-        const hadFailure = results.some((r) => r.status === 'rejected')
-        if (hadFailure) {
-          throw new UpstreamFailureError('failed to revert action on PDS')
-        }
-      }
-
-      return {
-        encoding: 'application/json',
-        body: await moderationService.views.action(result),
-      }
-    },
-  })
-}

package/src/api/com/atproto/admin/takeModerationAction.ts

@@ -1,156 +0,0 @@
-import { CID } from 'multiformats/cid'
-import { AtUri } from '@atproto/syntax'
-import {
-  AuthRequiredError,
-  InvalidRequestError,
-  UpstreamFailureError,
-} from '@atproto/xrpc-server'
-import { Server } from '../../../../lexicon'
-import AppContext from '../../../../context'
-import {
-  ACKNOWLEDGE,
-  ESCALATE,
-  TAKEDOWN,
-} from '../../../../lexicon/types/com/atproto/admin/defs'
-import { getSubject, getAction } from '../moderation/util'
-import { TakedownSubjects } from '../../../../services/moderation'
-import { retryHttp } from '../../../../util/retry'
-
-export default function (server: Server, ctx: AppContext) {
-  server.com.atproto.admin.takeModerationAction({
-    auth: ctx.roleVerifier,
-    handler: async ({ input, auth }) => {
-      const access = auth.credentials
-      const db = ctx.db.getPrimary()
-      const moderationService = ctx.services.moderation(db)
-      const {
-        action,
-        subject,
-        reason,
-        createdBy,
-        createLabelVals,
-        negateLabelVals,
-        subjectBlobCids,
-        durationInHours,
-      } = input.body
-
-      // apply access rules
-
-      // if less than admin access then can not takedown an account
-      if (!access.moderator && action === TAKEDOWN && 'did' in subject) {
-        throw new AuthRequiredError(
-          'Must be a full moderator to perform an account takedown',
-        )
-      }
-      // if less than moderator access then can only take ack and escalation actions
-      if (!access.moderator && ![ACKNOWLEDGE, ESCALATE].includes(action)) {
-        throw new AuthRequiredError(
-          'Must be a full moderator to take this type of action',
-        )
-      }
-      // if less than moderator access then can not apply labels
-      if (
-        !access.moderator &&
-        (createLabelVals?.length || negateLabelVals?.length)
-      ) {
-        throw new AuthRequiredError('Must be a full moderator to label content')
-      }
-
-      validateLabels([...(createLabelVals ?? []), ...(negateLabelVals ?? [])])
-
-      const { result, takenDown } = await db.transaction(async (dbTxn) => {
-        const moderationTxn = ctx.services.moderation(dbTxn)
-        const labelTxn = ctx.services.label(dbTxn)
-
-        const result = await moderationTxn.logAction({
-          action: getAction(action),
-          subject: getSubject(subject),
-          subjectBlobCids: subjectBlobCids?.map((cid) => CID.parse(cid)) ?? [],
-          createLabelVals,
-          negateLabelVals,
-          createdBy,
-          reason,
-          durationInHours,
-        })
-
-        let takenDown: TakedownSubjects | undefined
-
-        if (
-          result.action === TAKEDOWN &&
-          result.subjectType === 'com.atproto.admin.defs#repoRef' &&
-          result.subjectDid
-        ) {
-          // No credentials to revoke on appview
-          takenDown = await moderationTxn.takedownRepo({
-            takedownId: result.id,
-            did: result.subjectDid,
-          })
-        }
-
-        if (
-          result.action === TAKEDOWN &&
-          result.subjectType === 'com.atproto.repo.strongRef' &&
-          result.subjectUri &&
-          result.subjectCid
-        ) {
-          takenDown = await moderationTxn.takedownRecord({
-            takedownId: result.id,
-            uri: new AtUri(result.subjectUri),
-            cid: CID.parse(result.subjectCid),
-            blobCids: subjectBlobCids?.map((cid) => CID.parse(cid)) ?? [],
-          })
-        }
-
-        await labelTxn.formatAndCreate(
-          ctx.cfg.labelerDid,
-          result.subjectUri ?? result.subjectDid,
-          result.subjectCid,
-          { create: createLabelVals, negate: negateLabelVals },
-        )
-
-        return { result, takenDown }
-      })
-
-      if (takenDown && ctx.moderationPushAgent) {
-        const agent = ctx.moderationPushAgent
-        const { did, subjects } = takenDown
-        if (did && subjects.length > 0) {
-          const results = await Promise.allSettled(
-            subjects.map((subject) =>
-              retryHttp(() =>
-                agent.api.com.atproto.admin.updateSubjectStatus({
-                  subject,
-                  takedown: {
-                    applied: true,
-                    ref: result.id.toString(),
-                  },
-                }),
-              ),
-            ),
-          )
-          const hadFailure = results.some((r) => r.status === 'rejected')
-          if (hadFailure) {
-            throw new UpstreamFailureError('failed to apply action on PDS')
-          }
-        }
-      }
-
-      return {
-        encoding: 'application/json',
-        body: await moderationService.views.action(result),
-      }
-    },
-  })
-}
-
-const validateLabels = (labels: string[]) => {
-  for (const label of labels) {
-    for (const char of badChars) {
-      if (label.includes(char)) {
-        throw new InvalidRequestError(`Invalid label: ${label}`)
-      }
-    }
-  }
-}
-
-const badChars = [' ', ',', ';', `'`, `"`]

package/src/db/tables/did-cache.ts

@@ -1,13 +0,0 @@
-import { DidDocument } from '@atproto/identity'
-
-export interface DidCache {
-  did: string
-  doc: DidDocument
-  updatedAt: number
-}
-
-export const tableName = 'did_cache'
-
-export type PartialDB = {
-  [tableName]: DidCache
-}

package/src/feed-gen/best-of-follows.ts

@@ -1,74 +0,0 @@
-import { InvalidRequestError } from '@atproto/xrpc-server'
-import { QueryParams as SkeletonParams } from '../lexicon/types/app/bsky/feed/getFeedSkeleton'
-import { AlgoHandler, AlgoResponse } from './types'
-import { GenericKeyset, paginate } from '../db/pagination'
-import AppContext from '../context'
-
-const handler: AlgoHandler = async (
-  ctx: AppContext,
-  params: SkeletonParams,
-  viewer: string,
-): Promise<AlgoResponse> => {
-  const { limit, cursor } = params
-  const db = ctx.db.getReplica('feed')
-  const feedService = ctx.services.feed(db)
-
-  const { ref } = db.db.dynamic
-
-  // candidates are ranked within a materialized view by like count, depreciated over time.
-
-  let builder = feedService
-    .selectPostQb()
-    .innerJoin('algo_whats_hot_view as candidate', 'candidate.uri', 'post.uri')
-    .where((qb) =>
-      qb
-        .where('post.creator', '=', viewer)
-        .orWhereExists((inner) =>
-          inner
-            .selectFrom('follow')
-            .where('follow.creator', '=', viewer)
-            .whereRef('follow.subjectDid', '=', 'post.creator'),
-        ),
-    )
-    .select('candidate.score')
-    .select('candidate.cid')
-
-  const keyset = new ScoreKeyset(ref('candidate.score'), ref('candidate.cid'))
-  builder = paginate(builder, { limit, cursor, keyset })
-
-  const feedItems = await builder.execute()
-
-  return {
-    feedItems,
-    cursor: keyset.packFromResult(feedItems),
-  }
-}
-
-export default handler
-
-type Result = { score: number; cid: string }
-type LabeledResult = { primary: number; secondary: string }
-export class ScoreKeyset extends GenericKeyset<Result, LabeledResult> {
-  labelResult(result: Result) {
-    return {
-      primary: result.score,
-      secondary: result.cid,
-    }
-  }
-  labeledResultToCursor(labeled: LabeledResult) {
-    return {
-      primary: Math.round(labeled.primary).toString(),
-      secondary: labeled.secondary,
-    }
-  }
-  cursorToLabeledResult(cursor: { primary: string; secondary: string }) {
-    const score = parseInt(cursor.primary, 10)
-    if (isNaN(score)) {
-      throw new InvalidRequestError('Malformed cursor')
-    }
-    return {
-      primary: score,
-      secondary: cursor.secondary,
-    }
-  }
-}