@atproto/bsky 0.0.10 → 0.0.12

package/src/lexicon/types/com/atproto/admin/getSubjectStatus.ts

@@ -0,0 +1,54 @@
+/**
+ * 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 } from '@atproto/xrpc-server'
+import * as ComAtprotoAdminDefs from './defs'
+import * as ComAtprotoRepoStrongRef from '../repo/strongRef'
+
+export interface QueryParams {
+  did?: string
+  uri?: string
+  blob?: string
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  subject:
+    | ComAtprotoAdminDefs.RepoRef
+    | ComAtprotoRepoStrongRef.Main
+    | ComAtprotoAdminDefs.RepoBlobRef
+    | { $type: string; [k: string]: unknown }
+  takedown?: ComAtprotoAdminDefs.StatusAttr
+  [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
+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/com/atproto/admin/searchRepos.ts

@@ -13,7 +13,6 @@ export interface QueryParams {
   /** DEPRECATED: use 'q' instead */
   term?: string
   q?: string
-  invitedBy?: string
   limit: number
   cursor?: string
 }

package/src/lexicon/types/com/atproto/admin/updateSubjectStatus.ts

@@ -0,0 +1,61 @@
+/**
+ * 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 } from '@atproto/xrpc-server'
+import * as ComAtprotoAdminDefs from './defs'
+import * as ComAtprotoRepoStrongRef from '../repo/strongRef'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  subject:
+    | ComAtprotoAdminDefs.RepoRef
+    | ComAtprotoRepoStrongRef.Main
+    | ComAtprotoAdminDefs.RepoBlobRef
+    | { $type: string; [k: string]: unknown }
+  takedown?: ComAtprotoAdminDefs.StatusAttr
+  [k: string]: unknown
+}
+
+export interface OutputSchema {
+  subject:
+    | ComAtprotoAdminDefs.RepoRef
+    | ComAtprotoRepoStrongRef.Main
+    | ComAtprotoAdminDefs.RepoBlobRef
+    | { $type: string; [k: string]: unknown }
+  takedown?: ComAtprotoAdminDefs.StatusAttr
+  [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 type HandlerOutput = HandlerError | HandlerSuccess
+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/com/atproto/server/confirmEmail.ts

@@ -0,0 +1,40 @@
+/**
+ * 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 } from '@atproto/xrpc-server'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  email: string
+  token: string
+  [k: string]: unknown
+}
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+  error?: 'AccountNotFound' | 'ExpiredToken' | 'InvalidToken' | 'InvalidEmail'
+}
+
+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/com/atproto/server/createAccount.ts

@@ -17,6 +17,7 @@ export interface InputSchema {
   inviteCode?: string
   password: string
   recoveryKey?: string
+  plcOp?: Uint8Array
   [k: string]: unknown
 }
 
@@ -25,6 +26,7 @@ export interface OutputSchema {
   refreshJwt: string
   handle: string
   did: string
+  didDoc?: {}
   [k: string]: unknown
 }
 

package/src/lexicon/types/com/atproto/server/createSession.ts

@@ -22,7 +22,9 @@ export interface OutputSchema {
   refreshJwt: string
   handle: string
   did: string
+  didDoc?: {}
   email?: string
+  emailConfirmed?: boolean
   [k: string]: unknown
 }
 

package/src/lexicon/types/com/atproto/server/getSession.ts

@@ -16,6 +16,7 @@ export interface OutputSchema {
   handle: string
   did: string
   email?: string
+  emailConfirmed?: boolean
   [k: string]: unknown
 }
 

package/src/lexicon/types/com/atproto/server/refreshSession.ts

@@ -17,6 +17,7 @@ export interface OutputSchema {
   refreshJwt: string
   handle: string
   did: string
+  didDoc?: {}
   [k: string]: unknown
 }
 

package/src/lexicon/types/com/atproto/server/requestEmailConfirmation.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 } from '@atproto/xrpc-server'
+
+export interface QueryParams {}
+
+export type InputSchema = undefined
+export type HandlerInput = undefined
+
+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/com/atproto/server/requestEmailUpdate.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 } from '@atproto/xrpc-server'
+
+export interface QueryParams {}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  tokenRequired: boolean
+  [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
+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/com/atproto/server/reserveSigningKey.ts

@@ -0,0 +1,44 @@
+/**
+ * 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 } from '@atproto/xrpc-server'
+
+export interface QueryParams {}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  /** Public signing key in the form of a did:key. */
+  signingKey: 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
+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/com/atproto/server/updateEmail.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 } from '@atproto/xrpc-server'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  email: string
+  /** Requires a token from com.atproto.sever.requestEmailUpdate if the account's email has been confirmed. */
+  token?: string
+  [k: string]: unknown
+}
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+  error?: 'ExpiredToken' | 'InvalidToken' | 'TokenRequired'
+}
+
+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/com/atproto/sync/listRepos.ts

@@ -49,6 +49,7 @@ export type Handler<HA extends HandlerAuth = never> = (
 export interface Repo {
   did: string
   head: string
+  rev: string
   [k: string]: unknown
 }
 

package/src/logger.ts

@@ -12,4 +12,12 @@ export const httpLogger: ReturnType<typeof subsystemLogger> =
 
 export const loggerMiddleware = pinoHttp({
   logger: httpLogger,
+  serializers: {
+    err: (err) => {
+      return {
+        code: err?.code,
+        message: err?.message,
+      }
+    },
+  },
 })

package/src/services/actor/index.ts

@@ -66,7 +66,13 @@ export class ActorService {
           qb = qb.orWhere('actor.did', 'in', dids)
         }
         if (handles.length) {
-          qb = qb.orWhere('actor.handle', 'in', handles)
+          qb = qb.orWhere(
+            'actor.handle',
+            'in',
+            handles.length === 1
+              ? [handles[0], handles[0]] // a silly (but worthwhile) optimization to avoid usage of actor_handle_tgrm_idx
+              : handles,
+          )
         }
         return qb
       })
@@ -83,15 +89,15 @@ export class ActorService {
   async getSearchResults({
     cursor,
     limit = 25,
-    term = '',
+    query = '',
     includeSoftDeleted,
   }: {
     cursor?: string
     limit?: number
-    term?: string
+    query?: string
     includeSoftDeleted?: boolean
   }) {
-    const searchField = term.startsWith('did:') ? 'did' : 'handle'
+    const searchField = query.startsWith('did:') ? 'did' : 'handle'
     let paginatedBuilder
     const { ref } = this.db.db.dynamic
     const paginationOptions = {
@@ -101,10 +107,10 @@ export class ActorService {
     }
     let keyset
 
-    if (term && searchField === 'handle') {
+    if (query && searchField === 'handle') {
       keyset = new SearchKeyset(sql``, sql``)
       paginatedBuilder = getUserSearchQuery(this.db, {
-        term,
+        query,
         includeSoftDeleted,
         ...paginationOptions,
       }).select('distance')
@@ -114,10 +120,10 @@ export class ActorService {
         .select([sql<number>`0`.as('distance')])
       keyset = new ListKeyset(ref('indexedAt'), ref('did'))
 
-      // When searchField === 'did', the term will always be a valid string because
-      // searchField is set to 'did' after checking that the term is a valid did
-      if (term && searchField === 'did') {
-        paginatedBuilder = paginatedBuilder.where('actor.did', '=', term)
+      // When searchField === 'did', the query will always be a valid string because
+      // searchField is set to 'did' after checking that the query is a valid did
+      if (query && searchField === 'did') {
+        paginatedBuilder = paginatedBuilder.where('actor.did', '=', query)
       }
       paginatedBuilder = paginate(paginatedBuilder, {
         keyset,

package/src/services/actor/types.ts

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

package/src/services/actor/views.ts

@@ -137,10 +137,13 @@ export class ActorViews {
       ),
     ])
     const listUris = mapDefined(profiles, ({ did }) => {
-      const list = viewer && bam.muteList([viewer, did])
-      if (!list) return
-      return list
-    })
+      const muteList = viewer && bam.muteList([viewer, did])
+      const blockList = viewer && bam.blockList([viewer, did])
+      const lists: string[] = []
+      if (muteList) lists.push(muteList)
+      if (blockList) lists.push(blockList)
+      return lists
+    }).flat()
     const lists = await this.services.graph.getListViews(listUris, viewer)
     return { profilesDetailed: toMapByDid(profiles), labels, bam, lists }
   }
@@ -168,6 +171,11 @@ export class ActorViews {
         mutedByListUri && lists[mutedByListUri]
           ? this.services.graph.formatListViewBasic(lists[mutedByListUri])
           : undefined
+      const blockingByListUri = viewer && bam.blockList([viewer, did])
+      const blockingByList =
+        blockingByListUri && lists[blockingByListUri]
+          ? this.services.graph.formatListViewBasic(lists[blockingByListUri])
+          : undefined
       const actorLabels = labels[did] ?? []
       const selfLabels = getSelfLabels({
         uri: prof.profileUri,
@@ -194,6 +202,7 @@ export class ActorViews {
               mutedByList,
               blockedBy: !!bam.blockedBy([viewer, did]),
               blocking: bam.blocking([viewer, did]) ?? undefined,
+              blockingByList,
               following:
                 prof?.viewerFollowing && !bam.block([viewer, did])
                   ? prof.viewerFollowing
@@ -265,10 +274,13 @@ export class ActorViews {
       ),
     ])
     const listUris = mapDefined(profiles, ({ did }) => {
-      const list = viewer && bam.muteList([viewer, did])
-      if (!list) return
-      return list
-    })
+      const muteList = viewer && bam.muteList([viewer, did])
+      const blockList = viewer && bam.blockList([viewer, did])
+      const lists: string[] = []
+      if (muteList) lists.push(muteList)
+      if (blockList) lists.push(blockList)
+      return lists
+    }).flat()
     const lists = await this.services.graph.getListViews(listUris, viewer)
     return { profiles: toMapByDid(profiles), labels, bam, lists }
   }
@@ -298,6 +310,11 @@ export class ActorViews {
         mutedByListUri && lists[mutedByListUri]
           ? this.services.graph.formatListViewBasic(lists[mutedByListUri])
           : undefined
+      const blockingByListUri = viewer && bam.blockList([viewer, did])
+      const blockingByList =
+        blockingByListUri && lists[blockingByListUri]
+          ? this.services.graph.formatListViewBasic(lists[blockingByListUri])
+          : undefined
       const actorLabels = labels[did] ?? []
       const selfLabels = getSelfLabels({
         uri: prof.profileUri,
@@ -320,6 +337,7 @@ export class ActorViews {
               mutedByList,
               blockedBy: !!bam.blockedBy([viewer, did]),
               blocking: bam.blocking([viewer, did]) ?? undefined,
+              blockingByList,
               following:
                 prof?.viewerFollowing && !bam.block([viewer, did])
                   ? prof.viewerFollowing

package/src/services/graph/index.ts

@@ -267,28 +267,44 @@ export type RelationshipPair = [didA: string, didB: string]
 export class BlockAndMuteState {
   hasIdx = new Map<string, Set<string>>() // did -> did
   blockIdx = new Map<string, Map<string, string>>() // did -> did -> block uri
+  blockListIdx = new Map<string, Map<string, string>>() // did -> did -> list uri
   muteIdx = new Map<string, Set<string>>() // did -> did
   muteListIdx = new Map<string, Map<string, string>>() // did -> did -> list uri
   constructor(items: BlockAndMuteInfo[] = []) {
     items.forEach((item) => this.add(item))
   }
   add(item: BlockAndMuteInfo) {
-    const blocking = item.blocking || item.blockingViaList // block or list uri
-    if (blocking) {
+    if (item.source === item.target) {
+      return // we do not respect self-blocks or self-mutes
+    }
+    if (item.blocking) {
       const map = this.blockIdx.get(item.source) ?? new Map()
-      map.set(item.target, blocking)
+      map.set(item.target, item.blocking)
       if (!this.blockIdx.has(item.source)) {
         this.blockIdx.set(item.source, map)
       }
     }
-    const blockedBy = item.blockedBy || item.blockedByViaList // block or list uri
-    if (blockedBy) {
+    if (item.blockingViaList) {
+      const map = this.blockListIdx.get(item.source) ?? new Map()
+      map.set(item.target, item.blockingViaList)
+      if (!this.blockListIdx.has(item.source)) {
+        this.blockListIdx.set(item.source, map)
+      }
+    }
+    if (item.blockedBy) {
       const map = this.blockIdx.get(item.target) ?? new Map()
-      map.set(item.source, blockedBy)
+      map.set(item.source, item.blockedBy)
       if (!this.blockIdx.has(item.target)) {
         this.blockIdx.set(item.target, map)
       }
     }
+    if (item.blockedByViaList) {
+      const map = this.blockListIdx.get(item.target) ?? new Map()
+      map.set(item.source, item.blockedByViaList)
+      if (!this.blockListIdx.has(item.target)) {
+        this.blockListIdx.set(item.target, map)
+      }
+    }
     if (item.muting) {
       const set = this.muteIdx.get(item.source) ?? new Set()
       set.add(item.target)
@@ -314,7 +330,7 @@ export class BlockAndMuteState {
   }
   // block or list uri
   blocking(pair: RelationshipPair): string | null {
-    return this.blockIdx.get(pair[0])?.get(pair[1]) ?? null
+    return this.blockIdx.get(pair[0])?.get(pair[1]) ?? this.blockList(pair)
   }
   // block or list uri
   blockedBy(pair: RelationshipPair): string | null {
@@ -324,6 +340,9 @@ export class BlockAndMuteState {
     return !!this.muteIdx.get(pair[0])?.has(pair[1]) || !!this.muteList(pair)
   }
   // list uri
+  blockList(pair: RelationshipPair): string | null {
+    return this.blockListIdx.get(pair[0])?.get(pair[1]) ?? null
+  }
   muteList(pair: RelationshipPair): string | null {
     return this.muteListIdx.get(pair[0])?.get(pair[1]) ?? null
   }

package/src/services/indexing/index.ts

@@ -144,24 +144,22 @@ export class IndexingService {
     const handle: string | null =
       did === handleToDid ? atpData.handle.toLowerCase() : null
 
-    if (actor && actor.handle !== handle) {
-      const actorWithHandle =
-        handle !== null
-          ? await this.db.db
-              .selectFrom('actor')
-              .where('handle', '=', handle)
-              .selectAll()
-              .executeTakeFirst()
-          : null
+    const actorWithHandle =
+      handle !== null
+        ? await this.db.db
+            .selectFrom('actor')
+            .where('handle', '=', handle)
+            .selectAll()
+            .executeTakeFirst()
+        : null
 
-      // handle contention
-      if (handle && actorWithHandle && did !== actorWithHandle.did) {
-        await this.db.db
-          .updateTable('actor')
-          .where('actor.did', '=', actorWithHandle.did)
-          .set({ handle: null })
-          .execute()
-      }
+    // handle contention
+    if (handle && actorWithHandle && did !== actorWithHandle.did) {
+      await this.db.db
+        .updateTable('actor')
+        .where('actor.did', '=', actorWithHandle.did)
+        .set({ handle: null })
+        .execute()
     }
 
     const actorInfo = { handle, indexedAt: timestamp }