@atproto/bsky 0.0.11 → 0.0.13

package/dist/lexicon/types/com/atproto/server/reserveSigningKey.d.ts

@@ -0,0 +1,36 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+export interface QueryParams {
+}
+export interface InputSchema {
+    did?: string;
+    [k: string]: unknown;
+}
+export interface OutputSchema {
+    signingKey: string;
+    [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;
+}
+export declare type HandlerOutput = HandlerError | HandlerSuccess;
+export declare type HandlerReqCtx<HA extends HandlerAuth = never> = {
+    auth: HA;
+    params: QueryParams;
+    input: HandlerInput;
+    req: express.Request;
+    res: express.Response;
+};
+export declare type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => Promise<HandlerOutput> | HandlerOutput;

package/dist/lexicon/types/com/atproto/sync/listRepos.d.ts

@@ -35,6 +35,7 @@ export declare type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCt
 export interface Repo {
     did: string;
     head: string;
+    rev: string;
     [k: string]: unknown;
 }
 export declare function isRepo(v: unknown): v is Repo;

package/dist/services/actor/types.d.ts

@@ -15,6 +15,7 @@ export declare type ActorInfo = {
         mutedByList?: ListViewBasic;
         blockedBy?: boolean;
         blocking?: string;
+        blockingByList?: ListViewBasic;
         following?: string;
         followedBy?: string;
     };

package/dist/services/graph/index.d.ts

@@ -85,6 +85,7 @@ export declare type RelationshipPair = [didA: string, didB: string];
 export declare class BlockAndMuteState {
     hasIdx: Map<string, Set<string>>;
     blockIdx: Map<string, Map<string, string>>;
+    blockListIdx: Map<string, Map<string, string>>;
     muteIdx: Map<string, Set<string>>;
     muteListIdx: Map<string, Map<string, string>>;
     constructor(items?: BlockAndMuteInfo[]);
@@ -93,6 +94,7 @@ export declare class BlockAndMuteState {
     blocking(pair: RelationshipPair): string | null;
     blockedBy(pair: RelationshipPair): string | null;
     mute(pair: RelationshipPair): boolean;
+    blockList(pair: RelationshipPair): string | null;
     muteList(pair: RelationshipPair): string | null;
     has(pair: RelationshipPair): boolean;
 }

package/dist/services/moderation/index.d.ts

@@ -6,6 +6,8 @@ import { ModerationAction, ModerationReport } from '../../db/tables/moderation';
 import { ModerationViews } from './views';
 import { ImageUriBuilder } from '../../image/uri';
 import { ImageInvalidator } from '../../image/invalidator';
+import { RepoRef, RepoBlobRef } from '../../lexicon/types/com/atproto/admin/defs';
+import { Main as StrongRef } from '../../lexicon/types/com/atproto/repo/strongRef';
 export declare class ModerationService {
     db: PrimaryDatabase;
     imgUriBuilder: ImageUriBuilder;
@@ -74,20 +76,24 @@ export declare class ModerationService {
         durationInHours?: number;
     }): Promise<ModerationActionRow>;
     getActionsDueForReversal(): Promise<ModerationActionRow[]>;
-    revertAction({ id, createdBy, createdAt, reason, }: ReversibleModerationAction): Promise<ModerationActionRow>;
+    revertAction({ id, createdBy, createdAt, reason, }: ReversibleModerationAction): Promise<{
+        result: ModerationActionRow;
+        restored?: TakedownSubjects;
+    }>;
     logReverseAction(info: ReversibleModerationAction): Promise<ModerationActionRow>;
     takedownRepo(info: {
         takedownId: number;
         did: string;
-    }): Promise<void>;
+    }): Promise<TakedownSubjects>;
     reverseTakedownRepo(info: {
         did: string;
     }): Promise<void>;
     takedownRecord(info: {
         takedownId: number;
         uri: AtUri;
+        cid: CID;
         blobCids?: CID[];
-    }): Promise<void>;
+    }): Promise<TakedownSubjects>;
     reverseTakedownRecord(info: {
         uri: AtUri;
     }): Promise<void>;
@@ -110,6 +116,10 @@ export declare class ModerationService {
         createdAt?: Date;
     }): Promise<ModerationReportRow>;
 }
+export declare type TakedownSubjects = {
+    did: string;
+    subjects: (RepoRef | RepoBlobRef | StrongRef)[];
+};
 export declare type ModerationActionRow = Selectable<ModerationAction>;
 export declare type ReversibleModerationAction = Pick<ModerationActionRow, 'id' | 'createdBy' | 'reason'> & {
     createdAt?: Date;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/bsky",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "license": "MIT",
   "description": "Reference implementation of app.bsky App View (Bluesky API)",
   "keywords": [
@@ -20,7 +20,6 @@
     "@isaacs/ttlcache": "^1.4.1",
     "compression": "^1.7.4",
     "cors": "^2.8.5",
-    "dotenv": "^16.0.0",
     "express": "^4.17.2",
     "express-async-errors": "^3.1.1",
     "form-data": "^4.0.0",
@@ -36,14 +35,14 @@
     "sharp": "^0.31.2",
     "typed-emitter": "^2.1.0",
     "uint8arrays": "3.0.0",
-    "@atproto/api": "^0.6.20",
-    "@atproto/common": "^0.3.1",
-    "@atproto/crypto": "^0.2.2",
-    "@atproto/syntax": "^0.1.2",
-    "@atproto/identity": "^0.2.1",
-    "@atproto/lexicon": "^0.2.2",
-    "@atproto/repo": "^0.3.2",
-    "@atproto/xrpc-server": "^0.3.2"
+    "@atproto/api": "^0.6.22",
+    "@atproto/common": "^0.3.3",
+    "@atproto/crypto": "^0.2.3",
+    "@atproto/syntax": "^0.1.4",
+    "@atproto/identity": "^0.3.1",
+    "@atproto/lexicon": "^0.3.0",
+    "@atproto/repo": "^0.3.4",
+    "@atproto/xrpc-server": "^0.4.0"
   },
   "devDependencies": {
     "@did-plc/server": "^0.0.1",
@@ -54,11 +53,11 @@
     "@types/qs": "^6.9.7",
     "@types/sharp": "^0.31.0",
     "axios": "^0.27.2",
-    "@atproto/api": "^0.6.20",
-    "@atproto/dev-env": "^0.2.11",
-    "@atproto/lex-cli": "^0.2.2",
-    "@atproto/pds": "^0.1.20",
-    "@atproto/xrpc": "^0.3.2"
+    "@atproto/api": "^0.6.22",
+    "@atproto/dev-env": "^0.2.13",
+    "@atproto/lex-cli": "^0.2.4",
+    "@atproto/pds": "^0.3.1",
+    "@atproto/xrpc": "^0.4.0"
   },
   "scripts": {
     "codegen": "lex gen-server ./src/lexicon ../../lexicons/com/atproto/*/* ../../lexicons/app/bsky/*/*",

package/src/api/app/bsky/feed/getAuthorFeed.ts

@@ -89,8 +89,8 @@ export const skeleton = async (
 
   if (filter === 'posts_with_media') {
     feedItemsQb = feedItemsQb
-      // and only your own posts/reposts
-      .where('post.creator', '=', actorDid)
+      // only your own posts
+      .where('type', '=', 'post')
       // only posts with media
       .whereExists((qb) =>
         qb

package/src/api/app/bsky/feed/getPostThread.ts

@@ -37,9 +37,9 @@ export default function (server: Server, ctx: AppContext) {
     presentation,
   )
   server.app.bsky.feed.getPostThread({
-    auth: ctx.authOptionalVerifier,
+    auth: ctx.authOptionalAccessOrRoleVerifier,
     handler: async ({ params, auth, res }) => {
-      const viewer = auth.credentials.did
+      const viewer = 'did' in auth.credentials ? auth.credentials.did : null
       const db = ctx.db.getReplica('thread')
       const feedService = ctx.services.feed(db)
       const actorService = ctx.services.actor(db)

package/src/api/app/bsky/notification/listNotifications.ts

@@ -53,10 +53,6 @@ const skeleton = async (
   }
   let notifBuilder = db.db
     .selectFrom('notification as notif')
-    .innerJoin('record', 'record.uri', 'notif.recordUri')
-    .innerJoin('actor as author', 'author.did', 'notif.author')
-    .where(notSoftDeletedClause(ref('record')))
-    .where(notSoftDeletedClause(ref('author')))
     .where('notif.did', '=', viewer)
     .where((clause) =>
       clause
@@ -69,16 +65,12 @@ const skeleton = async (
         ),
     )
     .select([
+      'notif.author as authorDid',
       'notif.recordUri as uri',
       'notif.recordCid as cid',
-      'author.did as authorDid',
-      'author.handle as authorHandle',
-      'author.indexedAt as authorIndexedAt',
-      'author.takedownId as authorTakedownId',
       'notif.reason as reason',
       'notif.reasonSubject as reasonSubject',
       'notif.sortAt as indexedAt',
-      'record.json as recordJson',
     ])
 
   const keyset = new NotifsKeyset(ref('notif.sortAt'), ref('notif.recordCid'))
@@ -86,6 +78,7 @@ const skeleton = async (
     cursor,
     limit,
     keyset,
+    tryIndex: true,
   })
 
   const actorStateQuery = db.db
@@ -107,17 +100,18 @@ const skeleton = async (
 }
 
 const hydration = async (state: SkeletonState, ctx: Context) => {
-  const { graphService, actorService, labelService } = ctx
+  const { graphService, actorService, labelService, db } = ctx
   const { params, notifs } = state
   const { viewer } = params
   const dids = notifs.map((notif) => notif.authorDid)
   const uris = notifs.map((notif) => notif.uri)
-  const [actors, labels, bam] = await Promise.all([
+  const [actors, records, labels, bam] = await Promise.all([
     actorService.views.profiles(dids, viewer),
+    getRecordMap(db, uris),
     labelService.getLabelsForUris(uris),
     graphService.getBlockAndMuteState(dids.map((did) => [viewer, did])),
   ])
-  return { ...state, actors, labels, bam }
+  return { ...state, actors, records, labels, bam }
 }
 
 const noBlockOrMutes = (state: HydrationState) => {
@@ -131,11 +125,11 @@ const noBlockOrMutes = (state: HydrationState) => {
 }
 
 const presentation = (state: HydrationState) => {
-  const { notifs, cursor, actors, labels, lastSeenNotifs } = state
+  const { notifs, cursor, actors, records, labels, lastSeenNotifs } = state
   const notifications = mapDefined(notifs, (notif) => {
     const author = actors[notif.authorDid]
-    if (!author) return undefined
-    const record = jsonStringToLex(notif.recordJson) as Record<string, unknown>
+    const record = records[notif.uri]
+    if (!author || !record) return undefined
     const recordLabels = labels[notif.uri] ?? []
     const recordSelfLabels = getSelfLabels({
       uri: notif.uri,
@@ -157,6 +151,24 @@ const presentation = (state: HydrationState) => {
   return { notifications, cursor }
 }
 
+const getRecordMap = async (
+  db: Database,
+  uris: string[],
+): Promise<RecordMap> => {
+  if (!uris.length) return {}
+  const { ref } = db.db.dynamic
+  const recordRows = await db.db
+    .selectFrom('record')
+    .select(['uri', 'json'])
+    .where('uri', 'in', uris)
+    .where(notSoftDeletedClause(ref('record')))
+    .execute()
+  return recordRows.reduce((acc, { uri, json }) => {
+    acc[uri] = jsonStringToLex(json) as Record<string, unknown>
+    return acc
+  }, {} as RecordMap)
+}
+
 type Context = {
   db: Database
   actorService: ActorService
@@ -178,20 +190,19 @@ type SkeletonState = {
 type HydrationState = SkeletonState & {
   bam: BlockAndMuteState
   actors: ActorInfoMap
+  records: RecordMap
   labels: Labels
 }
 
+type RecordMap = { [uri: string]: Record<string, unknown> }
+
 type NotifRow = {
-  indexedAt: string
-  cid: string
-  uri: string
   authorDid: string
-  authorHandle: string | null
-  authorIndexedAt: string
-  authorTakedownId: number | null
+  uri: string
+  cid: string
   reason: string
   reasonSubject: string | null
-  recordJson: string
+  indexedAt: string
 }
 
 class NotifsKeyset extends TimeCidKeyset<NotifRow> {

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

@@ -1,17 +1,43 @@
 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 }) => {
+    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: await moderationService.views.actionDetail(result),
+        body: action,
       }
     },
   })

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

@@ -1,17 +1,42 @@
 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 }) => {
+    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: await moderationService.views.reportDetail(result),
+        body: report,
       }
     },
   })

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

@@ -1,11 +1,12 @@
 import { InvalidRequestError } from '@atproto/xrpc-server'
 import { Server } from '../../../../lexicon'
 import AppContext from '../../../../context'
+import { addAccountInfoToRepoView, getPdsAccountInfo } from './util'
 
 export default function (server: Server, ctx: AppContext) {
   server.com.atproto.admin.getRecord({
     auth: ctx.roleVerifier,
-    handler: async ({ params }) => {
+    handler: async ({ params, auth }) => {
       const { uri, cid } = params
       const db = ctx.db.getPrimary()
       const result = await db.db
@@ -17,9 +18,20 @@ export default function (server: Server, ctx: AppContext) {
       if (!result) {
         throw new InvalidRequestError('Record not found', 'RecordNotFound')
       }
+      const [record, accountInfo] = await Promise.all([
+        ctx.services.moderation(db).views.recordDetail(result),
+        getPdsAccountInfo(ctx, result.did),
+      ])
+
+      record.repo = addAccountInfoToRepoView(
+        record.repo,
+        accountInfo,
+        auth.credentials.moderator,
+      )
+
       return {
         encoding: 'application/json',
-        body: await ctx.services.moderation(db).views.recordDetail(result),
+        body: record,
       }
     },
   })

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

@@ -1,20 +1,31 @@
 import { InvalidRequestError } from '@atproto/xrpc-server'
 import { Server } from '../../../../lexicon'
 import AppContext from '../../../../context'
+import { addAccountInfoToRepoViewDetail, getPdsAccountInfo } from './util'
 
 export default function (server: Server, ctx: AppContext) {
   server.com.atproto.admin.getRepo({
     auth: ctx.roleVerifier,
-    handler: async ({ params }) => {
+    handler: async ({ params, auth }) => {
       const { did } = params
       const db = ctx.db.getPrimary()
       const result = await ctx.services.actor(db).getActor(did, true)
       if (!result) {
         throw new InvalidRequestError('Repo not found', 'RepoNotFound')
       }
+      const [partialRepo, accountInfo] = await Promise.all([
+        ctx.services.moderation(db).views.repoDetail(result),
+        getPdsAccountInfo(ctx, result.did),
+      ])
+
+      const repo = addAccountInfoToRepoViewDetail(
+        partialRepo,
+        accountInfo,
+        auth.credentials.moderator,
+      )
       return {
         encoding: 'application/json',
-        body: await ctx.services.moderation(db).views.repoDetail(result),
+        body: repo,
       }
     },
   })

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

@@ -1,4 +1,8 @@
-import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
+import {
+  AuthRequiredError,
+  InvalidRequestError,
+  UpstreamFailureError,
+} from '@atproto/xrpc-server'
 import {
   ACKNOWLEDGE,
   ESCALATE,
@@ -6,6 +10,7 @@ import {
 } 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({
@@ -16,7 +21,7 @@ export default function (server: Server, ctx: AppContext) {
       const moderationService = ctx.services.moderation(db)
       const { id, createdBy, reason } = input.body
 
-      const moderationAction = await db.transaction(async (dbTxn) => {
+      const { result, restored } = await db.transaction(async (dbTxn) => {
         const moderationTxn = ctx.services.moderation(dbTxn)
         const labelTxn = ctx.services.label(dbTxn)
         const now = new Date()
@@ -53,7 +58,7 @@ export default function (server: Server, ctx: AppContext) {
           )
         }
 
-        const result = await moderationTxn.revertAction({
+        const { result, restored } = await moderationTxn.revertAction({
           id,
           createdAt: now,
           createdBy,
@@ -77,12 +82,33 @@ export default function (server: Server, ctx: AppContext) {
           { create, negate },
         )
 
-        return result
+        return { result, restored }
       })
 
+      if (restored) {
+        const { did, subjects } = restored
+        const agent = await ctx.pdsAdminAgent(did)
+        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(moderationAction),
+        body: await moderationService.views.action(result),
       }
     },
   })

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

@@ -1,4 +1,3 @@
-import { InvalidRequestError } from '@atproto/xrpc-server'
 import { Server } from '../../../../lexicon'
 import AppContext from '../../../../context'
 
@@ -8,16 +7,14 @@ export default function (server: Server, ctx: AppContext) {
     handler: async ({ params }) => {
       const db = ctx.db.getPrimary()
       const moderationService = ctx.services.moderation(db)
-      const { invitedBy, limit, cursor } = params
-      if (invitedBy) {
-        throw new InvalidRequestError('The invitedBy parameter is unsupported')
-      }
+      const { limit, cursor } = params
       // prefer new 'q' query param over deprecated 'term'
       const query = params.q ?? params.term
 
       const { results, cursor: resCursor } = await ctx.services
         .actor(db)
         .getSearchResults({ query, limit, cursor, includeSoftDeleted: true })
+
       return {
         encoding: 'application/json',
         body: {