@atproto/bsky 0.0.16 → 0.0.17

package/src/lexicon/lexicons.ts

@@ -820,6 +820,29 @@ export const schemaDict = {
       },
     },
   },
+  ComAtprotoAdminDeleteAccount: {
+    lexicon: 1,
+    id: 'com.atproto.admin.deleteAccount',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Delete a user account as an administrator.',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['did'],
+            properties: {
+              did: {
+                type: 'string',
+                format: 'did',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   ComAtprotoAdminDisableAccountInvites: {
     lexicon: 1,
     id: 'com.atproto.admin.disableAccountInvites',
@@ -3979,6 +4002,135 @@ export const schemaDict = {
       },
     },
   },
+  ComAtprotoTempImportRepo: {
+    lexicon: 1,
+    id: 'com.atproto.temp.importRepo',
+    defs: {
+      main: {
+        type: 'procedure',
+        description:
+          "Gets the did's repo, optionally catching up from a specific revision.",
+        parameters: {
+          type: 'params',
+          required: ['did'],
+          properties: {
+            did: {
+              type: 'string',
+              format: 'did',
+              description: 'The DID of the repo.',
+            },
+          },
+        },
+        input: {
+          encoding: 'application/vnd.ipld.car',
+        },
+        output: {
+          encoding: 'text/plain',
+        },
+      },
+    },
+  },
+  ComAtprotoTempPushBlob: {
+    lexicon: 1,
+    id: 'com.atproto.temp.pushBlob',
+    defs: {
+      main: {
+        type: 'procedure',
+        description:
+          "Gets the did's repo, optionally catching up from a specific revision.",
+        parameters: {
+          type: 'params',
+          required: ['did'],
+          properties: {
+            did: {
+              type: 'string',
+              format: 'did',
+              description: 'The DID of the repo.',
+            },
+          },
+        },
+        input: {
+          encoding: '*/*',
+        },
+      },
+    },
+  },
+  ComAtprotoTempTransferAccount: {
+    lexicon: 1,
+    id: 'com.atproto.temp.transferAccount',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Transfer an account.',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['handle', 'did', 'plcOp'],
+            properties: {
+              handle: {
+                type: 'string',
+                format: 'handle',
+              },
+              did: {
+                type: 'string',
+                format: 'did',
+              },
+              plcOp: {
+                type: 'unknown',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['accessJwt', 'refreshJwt', 'handle', 'did'],
+            properties: {
+              accessJwt: {
+                type: 'string',
+              },
+              refreshJwt: {
+                type: 'string',
+              },
+              handle: {
+                type: 'string',
+                format: 'handle',
+              },
+              did: {
+                type: 'string',
+                format: 'did',
+              },
+            },
+          },
+        },
+        errors: [
+          {
+            name: 'InvalidHandle',
+          },
+          {
+            name: 'InvalidPassword',
+          },
+          {
+            name: 'InvalidInviteCode',
+          },
+          {
+            name: 'HandleNotAvailable',
+          },
+          {
+            name: 'UnsupportedDomain',
+          },
+          {
+            name: 'UnresolvableDid',
+          },
+          {
+            name: 'IncompatibleDidDoc',
+          },
+        ],
+      },
+    },
+  },
   AppBskyActorDefs: {
     lexicon: 1,
     id: 'app.bsky.actor.defs',
@@ -7671,6 +7823,7 @@ export const schemas: LexiconDoc[] = Object.values(schemaDict) as LexiconDoc[]
 export const lexicons: Lexicons = new Lexicons(schemas)
 export const ids = {
   ComAtprotoAdminDefs: 'com.atproto.admin.defs',
+  ComAtprotoAdminDeleteAccount: 'com.atproto.admin.deleteAccount',
   ComAtprotoAdminDisableAccountInvites:
     'com.atproto.admin.disableAccountInvites',
   ComAtprotoAdminDisableInviteCodes: 'com.atproto.admin.disableInviteCodes',
@@ -7746,6 +7899,9 @@ export const ids = {
   ComAtprotoSyncRequestCrawl: 'com.atproto.sync.requestCrawl',
   ComAtprotoSyncSubscribeRepos: 'com.atproto.sync.subscribeRepos',
   ComAtprotoTempFetchLabels: 'com.atproto.temp.fetchLabels',
+  ComAtprotoTempImportRepo: 'com.atproto.temp.importRepo',
+  ComAtprotoTempPushBlob: 'com.atproto.temp.pushBlob',
+  ComAtprotoTempTransferAccount: 'com.atproto.temp.transferAccount',
   AppBskyActorDefs: 'app.bsky.actor.defs',
   AppBskyActorGetPreferences: 'app.bsky.actor.getPreferences',
   AppBskyActorGetProfile: 'app.bsky.actor.getProfile',

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

@@ -0,0 +1,38 @@
+/**
+ * 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 {
+  did: string
+  [k: string]: unknown
+}
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+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/temp/importRepo.ts

@@ -0,0 +1,45 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import stream from 'stream'
+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 {
+  /** The DID of the repo. */
+  did: string
+}
+
+export type InputSchema = string | Uint8Array
+
+export interface HandlerInput {
+  encoding: 'application/vnd.ipld.car'
+  body: stream.Readable
+}
+
+export interface HandlerSuccess {
+  encoding: 'text/plain'
+  body: Uint8Array | stream.Readable
+  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/temp/pushBlob.ts

@@ -0,0 +1,39 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import stream from 'stream'
+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 {
+  /** The DID of the repo. */
+  did: string
+}
+
+export type InputSchema = string | Uint8Array
+
+export interface HandlerInput {
+  encoding: '*/*'
+  body: stream.Readable
+}
+
+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/temp/transferAccount.ts

@@ -0,0 +1,62 @@
+/**
+ * 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 {
+  handle: string
+  did: string
+  plcOp: {}
+  [k: string]: unknown
+}
+
+export interface OutputSchema {
+  accessJwt: string
+  refreshJwt: string
+  handle: string
+  did: 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
+  error?:
+    | 'InvalidHandle'
+    | 'InvalidPassword'
+    | 'InvalidInviteCode'
+    | 'HandleNotAvailable'
+    | 'UnsupportedDomain'
+    | 'UnresolvableDid'
+    | 'IncompatibleDidDoc'
+}
+
+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/logger.ts

@@ -3,6 +3,8 @@ import { subsystemLogger } from '@atproto/common'
 
 export const dbLogger: ReturnType<typeof subsystemLogger> =
   subsystemLogger('bsky:db')
+export const cacheLogger: ReturnType<typeof subsystemLogger> =
+  subsystemLogger('bsky:cache')
 export const subLogger: ReturnType<typeof subsystemLogger> =
   subsystemLogger('bsky:sub')
 export const labelerLogger: ReturnType<typeof subsystemLogger> =

package/src/redis.ts

@@ -11,12 +11,16 @@ export class Redis {
         name: opts.sentinel,
         sentinels: opts.hosts.map((h) => addressParts(h, 26379)),
         password: opts.password,
+        db: opts.db,
+        commandTimeout: opts.commandTimeout,
       })
     } else if ('host' in opts) {
       assert(opts.host)
       this.driver = new RedisDriver({
         ...addressParts(opts.host),
         password: opts.password,
+        db: opts.db,
+        commandTimeout: opts.commandTimeout,
       })
     } else {
       assert(opts.driver)
@@ -25,6 +29,10 @@ export class Redis {
     this.namespace = opts.namespace
   }
 
+  withNamespace(namespace: string): Redis {
+    return new Redis({ driver: this.driver, namespace })
+  }
+
   async readStreams(
     streams: StreamRef[],
     opts: { count: number; blockMs?: number },
@@ -97,8 +105,38 @@ export class Redis {
     return await this.driver.get(this.ns(key))
   }
 
-  async set(key: string, val: string | number) {
-    await this.driver.set(this.ns(key), val)
+  async set(key: string, val: string | number, ttlMs?: number) {
+    if (ttlMs !== undefined) {
+      await this.driver.set(this.ns(key), val, 'PX', ttlMs)
+    } else {
+      await this.driver.set(this.ns(key), val)
+    }
+  }
+
+  async getMulti(keys: string[]) {
+    const namespaced = keys.map((k) => this.ns(k))
+    const got = await this.driver.mget(...namespaced)
+    const results = {}
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i]
+      results[key] = got[i]
+    }
+    return results
+  }
+
+  async setMulti(vals: Record<string, string | number>, ttlMs?: number) {
+    if (Object.keys(vals).length === 0) {
+      return
+    }
+    let builder = this.driver.multi({ pipeline: true })
+    for (const key of Object.keys(vals)) {
+      if (ttlMs !== undefined) {
+        builder = builder.set(this.ns(key), vals[key], 'PX', ttlMs)
+      } else {
+        builder = builder.set(this.ns(key), vals[key])
+      }
+    }
+    await builder.exec()
   }
 
   async del(key: string) {
@@ -152,9 +190,11 @@ export type RedisOptions = (
 ) & {
   password?: string
   namespace?: string
+  db?: number
+  commandTimeout?: number
 }
 
-function addressParts(
+export function addressParts(
   addr: string,
   defaultPort = 6379,
 ): { host: string; port: number } {

package/src/services/actor/index.ts

@@ -1,27 +1,37 @@
 import { sql } from 'kysely'
+import { wait } from '@atproto/common'
 import { Database } from '../../db'
 import { notSoftDeletedClause } from '../../db/util'
 import { ActorViews } from './views'
 import { ImageUriBuilder } from '../../image/uri'
 import { Actor } from '../../db/tables/actor'
-import { LabelCache } from '../../label-cache'
 import { TimeCidKeyset, paginate } from '../../db/pagination'
 import { SearchKeyset, getUserSearchQuery } from '../util/search'
+import { FromDb } from '../types'
+import { GraphService } from '../graph'
+import { LabelService } from '../label'
 
 export * from './types'
 
 export class ActorService {
+  views: ActorViews
+
   constructor(
     public db: Database,
     public imgUriBuilder: ImageUriBuilder,
-    public labelCache: LabelCache,
-  ) {}
-
-  static creator(imgUriBuilder: ImageUriBuilder, labelCache: LabelCache) {
-    return (db: Database) => new ActorService(db, imgUriBuilder, labelCache)
+    private graph: FromDb<GraphService>,
+    private label: FromDb<LabelService>,
+  ) {
+    this.views = new ActorViews(this.db, this.imgUriBuilder, graph, label)
   }
 
-  views = new ActorViews(this.db, this.imgUriBuilder, this.labelCache)
+  static creator(
+    imgUriBuilder: ImageUriBuilder,
+    graph: FromDb<GraphService>,
+    label: FromDb<LabelService>,
+  ) {
+    return (db: Database) => new ActorService(db, imgUriBuilder, graph, label)
+  }
 
   async getActorDid(handleOrDid: string): Promise<string | null> {
     if (handleOrDid.startsWith('did:')) {
@@ -144,6 +154,44 @@ export class ActorService {
       .executeTakeFirst()
     return res?.repoRev ?? null
   }
+
+  async *all(
+    opts: {
+      batchSize?: number
+      forever?: boolean
+      cooldownMs?: number
+      startFromDid?: string
+    } = {},
+  ) {
+    const {
+      cooldownMs = 1000,
+      batchSize = 1000,
+      forever = false,
+      startFromDid,
+    } = opts
+    const baseQuery = this.db.db
+      .selectFrom('actor')
+      .selectAll()
+      .orderBy('did')
+      .limit(batchSize)
+    while (true) {
+      let cursor = startFromDid
+      do {
+        const actors = cursor
+          ? await baseQuery.where('did', '>', cursor).execute()
+          : await baseQuery.execute()
+        for (const actor of actors) {
+          yield actor
+        }
+        cursor = actors.at(-1)?.did
+      } while (cursor)
+      if (forever) {
+        await wait(cooldownMs)
+      } else {
+        return
+      }
+    }
+  }
 }
 
 type ActorResult = Actor

package/src/services/actor/views.ts

@@ -11,7 +11,6 @@ import { Actor } from '../../db/tables/actor'
 import { ImageUriBuilder } from '../../image/uri'
 import { LabelService, Labels, getSelfLabels } from '../label'
 import { BlockAndMuteState, GraphService } from '../graph'
-import { LabelCache } from '../../label-cache'
 import {
   ActorInfoMap,
   ProfileDetailHydrationState,
@@ -21,17 +20,24 @@ import {
   toMapByDid,
 } from './types'
 import { ListInfoMap } from '../graph/types'
+import { FromDb } from '../types'
 
 export class ActorViews {
+  services: {
+    label: LabelService
+    graph: GraphService
+  }
+
   constructor(
     private db: Database,
     private imgUriBuilder: ImageUriBuilder,
-    private labelCache: LabelCache,
-  ) {}
-
-  services = {
-    label: LabelService.creator(this.labelCache)(this.db),
-    graph: GraphService.creator(this.imgUriBuilder)(this.db),
+    private graph: FromDb<GraphService>,
+    private label: FromDb<LabelService>,
+  ) {
+    this.services = {
+      label: label(db),
+      graph: graph(db),
+    }
   }
 
   async profiles(

package/src/services/feed/index.ts

@@ -1,6 +1,7 @@
 import { sql } from 'kysely'
 import { AtUri } from '@atproto/syntax'
 import { jsonStringToLex } from '@atproto/lexicon'
+import { mapDefined } from '@atproto/common'
 import { Database } from '../../db'
 import { countAll, noMatch, notSoftDeletedClause } from '../../db/util'
 import { ImageUriBuilder } from '../../image/uri'
@@ -42,29 +43,42 @@ import {
   RelationshipPair,
 } from '../graph'
 import { FeedViews } from './views'
-import { LabelCache } from '../../label-cache'
 import { threadgateToPostUri, postToThreadgateUri } from './util'
-import { mapDefined } from '@atproto/common'
+import { FromDb } from '../types'
 
 export * from './types'
 
 export class FeedService {
+  views: FeedViews
+  services: {
+    label: LabelService
+    actor: ActorService
+    graph: GraphService
+  }
+
   constructor(
     public db: Database,
     public imgUriBuilder: ImageUriBuilder,
-    public labelCache: LabelCache,
-  ) {}
-
-  views = new FeedViews(this.db, this.imgUriBuilder, this.labelCache)
-
-  services = {
-    label: LabelService.creator(this.labelCache)(this.db),
-    actor: ActorService.creator(this.imgUriBuilder, this.labelCache)(this.db),
-    graph: GraphService.creator(this.imgUriBuilder)(this.db),
+    private actor: FromDb<ActorService>,
+    private label: FromDb<LabelService>,
+    private graph: FromDb<GraphService>,
+  ) {
+    this.views = new FeedViews(this.db, this.imgUriBuilder, actor, graph)
+    this.services = {
+      label: label(this.db),
+      actor: actor(this.db),
+      graph: graph(this.db),
+    }
   }
 
-  static creator(imgUriBuilder: ImageUriBuilder, labelCache: LabelCache) {
-    return (db: Database) => new FeedService(db, imgUriBuilder, labelCache)
+  static creator(
+    imgUriBuilder: ImageUriBuilder,
+    actor: FromDb<ActorService>,
+    label: FromDb<LabelService>,
+    graph: FromDb<GraphService>,
+  ) {
+    return (db: Database) =>
+      new FeedService(db, imgUriBuilder, actor, label, graph)
   }
 
   selectPostQb() {