@atproto/pds 0.4.90 → 0.4.92

package/src/account-manager/db/schema/authorization-request.ts

@@ -1,10 +1,10 @@
+import { Selectable } from 'kysely'
 import {
   Code,
   DeviceId,
   OAuthClientId,
   RequestId,
 } from '@atproto/oauth-provider'
-import { Selectable } from 'kysely'
 import { DateISO, JsonObject } from '../../../db'
 
 export interface AuthorizationRequest {

package/src/account-manager/db/schema/device.ts

@@ -1,5 +1,5 @@
-import { DeviceId, SessionId } from '@atproto/oauth-provider'
 import { Selectable } from 'kysely'
+import { DeviceId, SessionId } from '@atproto/oauth-provider'
 import { DateISO } from '../../../db'
 
 export interface Device {

package/src/account-manager/db/schema/index.ts

@@ -1,15 +1,15 @@
-import * as actor from './actor'
 import * as account from './account'
+import * as actor from './actor'
+import * as appPassword from './app-password'
+import * as oauthRequest from './authorization-request'
 import * as device from './device'
 import * as deviceAccount from './device-account'
-import * as oauthRequest from './authorization-request'
+import * as emailToken from './email-token'
+import * as inviteCode from './invite-code'
+import * as refreshToken from './refresh-token'
+import * as repoRoot from './repo-root'
 import * as token from './token'
 import * as usedRefreshToken from './used-refresh-token'
-import * as repoRoot from './repo-root'
-import * as refreshToken from './refresh-token'
-import * as appPassword from './app-password'
-import * as inviteCode from './invite-code'
-import * as emailToken from './email-token'
 
 export type DatabaseSchema = actor.PartialDB &
   account.PartialDB &

package/src/account-manager/db/schema/token.ts

@@ -1,3 +1,4 @@
+import { Generated, Selectable } from 'kysely'
 import {
   Code,
   DeviceId,
@@ -6,8 +7,6 @@ import {
   Sub,
   TokenId,
 } from '@atproto/oauth-provider'
-import { Generated, Selectable } from 'kysely'
-
 import { DateISO, JsonArray, JsonObject } from '../../../db/cast'
 
 export interface Token {

package/src/account-manager/db/schema/used-refresh-token.ts

@@ -1,5 +1,5 @@
-import { RefreshToken } from '@atproto/oauth-provider'
 import { Selectable } from 'kysely'
+import { RefreshToken } from '@atproto/oauth-provider'
 
 export interface UsedRefreshToken {
   tokenId: number

package/src/account-manager/helpers/account.ts

@@ -1,7 +1,7 @@
+import { DAY } from '@atproto/common'
 import { isErrUniqueViolation, notSoftDeletedClause } from '../../db'
-import { AccountDb, ActorEntry } from '../db'
 import { StatusAttr } from '../../lexicon/types/com/atproto/admin/defs'
-import { DAY } from '@atproto/common'
+import { AccountDb, ActorEntry } from '../db'
 
 export class UserAlreadyExistsError extends Error {}
 

package/src/account-manager/helpers/authorization-request.ts

@@ -1,3 +1,4 @@
+import { Insertable, Selectable } from 'kysely'
 import {
   Code,
   FoundRequestResult,
@@ -5,9 +6,8 @@ import {
   RequestId,
   UpdateRequestData,
 } from '@atproto/oauth-provider'
-import { AccountDb, AuthorizationRequest } from '../db'
 import { fromDateISO, fromJsonObject, toDateISO, toJsonObject } from '../../db'
-import { Insertable, Selectable } from 'kysely'
+import { AccountDb, AuthorizationRequest } from '../db'
 
 export const rowToRequestData = (
   row: Selectable<AuthorizationRequest>,

package/src/account-manager/helpers/device-account.ts

@@ -1,11 +1,10 @@
+import { Insertable, Selectable } from 'kysely'
 import {
   Account,
   DeviceAccountInfo,
   DeviceId,
   OAuthClientId,
 } from '@atproto/oauth-provider'
-import { Insertable, Selectable } from 'kysely'
-
 import { fromDateISO, fromJsonArray, toDateISO, toJsonArray } from '../../db'
 import { AccountDb } from '../db'
 import { DeviceAccount } from '../db/schema/device-account'

package/src/account-manager/helpers/device.ts

@@ -1,7 +1,7 @@
-import { DeviceId, DeviceData } from '@atproto/oauth-provider'
-import { AccountDb, Device } from '../db'
-import { fromDateISO, toDateISO } from '../../db'
 import { Selectable } from 'kysely'
+import { DeviceData, DeviceId } from '@atproto/oauth-provider'
+import { fromDateISO, toDateISO } from '../../db'
+import { AccountDb, Device } from '../db'
 
 export const rowToDeviceData = (row: Selectable<Device>): DeviceData => ({
   sessionId: row.sessionId,

package/src/account-manager/helpers/email-token.ts

@@ -1,5 +1,5 @@
-import { InvalidRequestError } from '@atproto/xrpc-server'
 import { MINUTE, lessThanAgoMs } from '@atproto/common'
+import { InvalidRequestError } from '@atproto/xrpc-server'
 import { getRandomToken } from '../../api/com/atproto/server/util'
 import { AccountDb, EmailTokenPurpose } from '../db'
 

package/src/account-manager/helpers/invite.ts

@@ -1,7 +1,7 @@
 import { chunkArray } from '@atproto/common'
 import { InvalidRequestError } from '@atproto/xrpc-server'
-import { AccountDb, InviteCode } from '../db'
 import { countAll } from '../../db'
+import { AccountDb, InviteCode } from '../db'
 
 export const createInviteCodes = async (
   db: AccountDb,

package/src/account-manager/helpers/password.ts

@@ -1,8 +1,8 @@
 import { randomStr } from '@atproto/crypto'
 import { InvalidRequestError } from '@atproto/xrpc-server'
-import * as scrypt from './scrypt'
-import { AccountDb } from '../db'
 import { AppPassword } from '../../lexicon/types/com/atproto/server/createAppPassword'
+import { AccountDb } from '../db'
+import * as scrypt from './scrypt'
 
 export type AppPassDescript = {
   name: string

package/src/account-manager/helpers/scrypt.ts

@@ -1,6 +1,6 @@
-import crypto from 'crypto'
-import { sha256 } from '@atproto/crypto'
+import crypto from 'node:crypto'
 import * as ui8 from 'uint8arrays'
+import { sha256 } from '@atproto/crypto'
 
 export const genSaltAndHash = (password: string): Promise<string> => {
   const salt = crypto.randomBytes(16).toString('hex')

package/src/account-manager/helpers/token.ts

@@ -1,3 +1,4 @@
+import { Selectable } from 'kysely'
 import {
   Code,
   NewTokenData,
@@ -7,7 +8,6 @@ import {
   TokenId,
   TokenInfo,
 } from '@atproto/oauth-provider'
-import { Selectable } from 'kysely'
 import {
   fromDateISO,
   fromJsonArray,

package/src/account-manager/index.ts

@@ -1,5 +1,9 @@
+import { KeyObject } from 'node:crypto'
+import { Selectable } from 'kysely'
+import { CID } from 'multiformats/cid'
 import { HOUR, wait } from '@atproto/common'
 import {
+  Account,
   AccountInfo,
   AccountStore,
   Code,
@@ -20,12 +24,11 @@ import {
   UpdateRequestData,
 } from '@atproto/oauth-provider'
 import { AuthRequiredError } from '@atproto/xrpc-server'
-import { CID } from 'multiformats/cid'
-import { KeyObject } from 'node:crypto'
-
+import { ActorStore } from '../actor-store/actor-store'
 import { AuthScope } from '../auth-verifier'
 import { BackgroundQueue } from '../background'
 import { softDeleted } from '../db'
+import { ImageUrlBuilder } from '../image/image-url-builder'
 import { StatusAttr } from '../lexicon/types/com/atproto/admin/defs'
 import { AccountDb, EmailTokenPurpose, getDb, getMigrator } from './db'
 import * as account from './helpers/account'
@@ -50,6 +53,8 @@ export class AccountManager
   db: AccountDb
 
   constructor(
+    private actorStore: ActorStore,
+    private imageUrlBuilder: ImageUrlBuilder,
     private backgroundQueue: BackgroundQueue,
     dbLocation: string,
     private jwtKey: KeyObject,
@@ -500,6 +505,29 @@ export class AccountManager
 
   // AccountStore
 
+  private async buildAccount(row: Selectable<ActorAccount>): Promise<Account> {
+    const account = deviceAccount.toAccount(row, this.serviceDid)
+
+    if (!account.name || !account.picture) {
+      const did = account.sub
+
+      const profile = await this.actorStore.read(did, async (store) => {
+        return store.record.getProfileRecord()
+      })
+
+      if (profile) {
+        const { avatar, displayName } = profile
+
+        account.name ||= displayName
+        account.picture ||= avatar
+          ? this.imageUrlBuilder.build('avatar', did, avatar.ref.toString())
+          : undefined
+      }
+    }
+
+    return account
+  }
+
   async authenticateAccount(
     { username: identifier, password, remember = false }: SignInCredentials,
     deviceId: DeviceId,
@@ -554,7 +582,7 @@ export class AccountManager
     if (!row) return null
 
     return {
-      account: deviceAccount.toAccount(row, this.serviceDid),
+      account: await this.buildAccount(row),
       info: deviceAccount.toDeviceAccountInfo(row),
     }
   }
@@ -564,10 +592,12 @@ export class AccountManager
       .listRememberedQB(this.db, deviceId)
       .execute()
 
-    return rows.map((row) => ({
-      account: deviceAccount.toAccount(row, this.serviceDid),
-      info: deviceAccount.toDeviceAccountInfo(row),
-    }))
+    return Promise.all(
+      rows.map(async (row) => ({
+        account: await this.buildAccount(row),
+        info: deviceAccount.toDeviceAccountInfo(row),
+      })),
+    )
   }
 
   async removeDeviceAccount(deviceId: DeviceId, sub: string): Promise<void> {

package/src/actor-store/actor-store-reader.ts

@@ -0,0 +1,45 @@
+import { Keypair } from '@atproto/crypto'
+import { ActorStoreResources } from './actor-store-resources'
+import { ActorStoreTransactor } from './actor-store-transactor'
+import { ActorDb } from './db'
+import { PreferenceReader } from './preference/reader'
+import { RecordReader } from './record/reader'
+import { RepoReader } from './repo/reader'
+
+export class ActorStoreReader {
+  public readonly repo: RepoReader
+  public readonly record: RecordReader
+  public readonly pref: PreferenceReader
+
+  constructor(
+    public readonly did: string,
+    protected readonly db: ActorDb,
+    protected readonly resources: ActorStoreResources,
+    public readonly keypair: () => Promise<Keypair>,
+  ) {
+    const blobstore = resources.blobstore(did)
+
+    this.repo = new RepoReader(db, blobstore)
+    this.record = new RecordReader(db)
+    this.pref = new PreferenceReader(db)
+
+    // Invoke "keypair" once. Also avoids leaking "this" as keypair context.
+    let keypairPromise: Promise<Keypair>
+    this.keypair = () => (keypairPromise ??= Promise.resolve().then(keypair))
+  }
+
+  async transact<T>(
+    fn: (fn: ActorStoreTransactor) => T | PromiseLike<T>,
+  ): Promise<T> {
+    const keypair = await this.keypair()
+    return this.db.transaction((dbTxn) => {
+      const store = new ActorStoreTransactor(
+        this.did,
+        dbTxn,
+        keypair,
+        this.resources,
+      )
+      return fn(store)
+    })
+  }
+}

package/src/actor-store/actor-store-resources.ts

@@ -0,0 +1,8 @@
+import { BlobStore } from '@atproto/repo'
+import { BackgroundQueue } from '../background'
+
+export type ActorStoreResources = {
+  blobstore: (did: string) => BlobStore
+  backgroundQueue: BackgroundQueue
+  reservedKeyDir?: string
+}

package/src/actor-store/actor-store-transactor.ts

@@ -0,0 +1,31 @@
+import { Keypair } from '@atproto/crypto'
+import { ActorStoreResources } from './actor-store-resources'
+import { ActorDb } from './db'
+import { PreferenceTransactor } from './preference/transactor'
+import { RecordTransactor } from './record/transactor'
+import { RepoTransactor } from './repo/transactor'
+
+export class ActorStoreTransactor {
+  public readonly record: RecordTransactor
+  public readonly repo: RepoTransactor
+  public readonly pref: PreferenceTransactor
+
+  constructor(
+    public readonly did: string,
+    protected readonly db: ActorDb,
+    protected readonly keypair: Keypair,
+    protected readonly resources: ActorStoreResources,
+  ) {
+    const blobstore = resources.blobstore(did)
+
+    this.record = new RecordTransactor(db, blobstore)
+    this.pref = new PreferenceTransactor(db)
+    this.repo = new RepoTransactor(
+      db,
+      blobstore,
+      did,
+      keypair,
+      resources.backgroundQueue,
+    )
+  }
+}

package/src/actor-store/actor-store-writer.ts

@@ -0,0 +1,17 @@
+import { ActorStoreTransactor } from './actor-store-transactor'
+
+export class ActorStoreWriter extends ActorStoreTransactor {
+  async transact<T>(
+    fn: (fn: ActorStoreTransactor) => T | PromiseLike<T>,
+  ): Promise<T> {
+    return this.db.transaction((dbTxn) => {
+      const transactor = new ActorStoreTransactor(
+        this.did,
+        dbTxn,
+        this.keypair,
+        this.resources,
+      )
+      return fn(transactor)
+    })
+  }
+}

package/src/actor-store/{index.ts → actor-store.ts}

@@ -1,35 +1,23 @@
-import path from 'path'
-import assert from 'assert'
-import fs from 'fs/promises'
-import * as crypto from '@atproto/crypto'
-import { Keypair, ExportableKeypair } from '@atproto/crypto'
-import { BlobStore } from '@atproto/repo'
+import assert from 'node:assert'
+import fs, { mkdir } from 'node:fs/promises'
+import path from 'node:path'
 import {
   chunkArray,
   fileExists,
   readIfExists,
   rmIfExists,
 } from '@atproto/common'
-import { ActorDb, getDb, getMigrator } from './db'
-import { BackgroundQueue } from '../background'
-import { RecordReader } from './record/reader'
-import { PreferenceReader } from './preference/reader'
-import { RepoReader } from './repo/reader'
-import { RepoTransactor } from './repo/transactor'
-import { PreferenceTransactor } from './preference/transactor'
+import * as crypto from '@atproto/crypto'
+import { ExportableKeypair, Keypair } from '@atproto/crypto'
 import { InvalidRequestError } from '@atproto/xrpc-server'
-import { RecordTransactor } from './record/transactor'
-import { CID } from 'multiformats/cid'
-import DiskBlobStore from '../disk-blobstore'
-import { mkdir } from 'fs/promises'
 import { ActorStoreConfig } from '../config'
 import { retrySqlite } from '../db'
-
-type ActorStoreResources = {
-  blobstore: (did: string) => BlobStore
-  backgroundQueue: BackgroundQueue
-  reservedKeyDir?: string
-}
+import { DiskBlobStore } from '../disk-blobstore'
+import { ActorStoreReader } from './actor-store-reader'
+import { ActorStoreResources } from './actor-store-resources'
+import { ActorStoreTransactor } from './actor-store-transactor'
+import { ActorStoreWriter } from './actor-store-writer'
+import { ActorDb, getDb, getMigrator } from './db'
 
 export class ActorStore {
   reservedKeyDir: string
@@ -82,50 +70,39 @@ export class ActorStore {
     return db
   }
 
-  async read<T>(did: string, fn: ActorStoreReadFn<T>) {
+  async read<T>(did: string, fn: (fn: ActorStoreReader) => T | PromiseLike<T>) {
     const db = await this.openDb(did)
     try {
-      const reader = createActorReader(did, db, this.resources, () =>
-        this.keypair(did),
-      )
-      return await fn(reader)
+      const getKeypair = () => this.keypair(did)
+      return await fn(new ActorStoreReader(did, db, this.resources, getKeypair))
     } finally {
       db.close()
     }
   }
 
-  async transact<T>(did: string, fn: ActorStoreTransactFn<T>) {
+  async transact<T>(
+    did: string,
+    fn: (fn: ActorStoreTransactor) => T | PromiseLike<T>,
+  ) {
     const keypair = await this.keypair(did)
     const db = await this.openDb(did)
     try {
       return await db.transaction((dbTxn) => {
-        const store = createActorTransactor(did, dbTxn, keypair, this.resources)
-        return fn(store)
+        return fn(new ActorStoreTransactor(did, dbTxn, keypair, this.resources))
       })
     } finally {
       db.close()
     }
   }
 
-  async writeNoTransaction<T>(did: string, fn: ActorStoreWriterFn<T>) {
+  async writeNoTransaction<T>(
+    did: string,
+    fn: (fn: ActorStoreWriter) => T | PromiseLike<T>,
+  ) {
     const keypair = await this.keypair(did)
     const db = await this.openDb(did)
     try {
-      const writer = createActorTransactor(did, db, keypair, this.resources)
-      return await fn({
-        ...writer,
-        transact: async <T>(fn: ActorStoreTransactFn<T>): Promise<T> => {
-          return db.transaction((dbTxn) => {
-            const transactor = createActorTransactor(
-              did,
-              dbTxn,
-              keypair,
-              this.resources,
-            )
-            return fn(transactor)
-          })
-        },
-      })
+      return await fn(new ActorStoreWriter(did, db, keypair, this.resources))
     } finally {
       db.close()
     }
@@ -157,10 +134,9 @@ export class ActorStore {
     if (blobstore instanceof DiskBlobStore) {
       await blobstore.deleteAll()
     } else {
-      const blobRows = await this.read(did, (store) =>
-        store.db.db.selectFrom('blob').select('cid').execute(),
+      const cids = await this.read(did, async (store) =>
+        store.repo.blob.getBlobCids(),
       )
-      const cids = blobRows.map((row) => CID.parse(row.cid))
       await Promise.allSettled(
         chunkArray(cids, 500).map((chunk) => blobstore.deleteMany(chunk)),
       )
@@ -226,73 +202,6 @@ const loadKey = async (loc: string): Promise<ExportableKeypair | undefined> => {
   return crypto.Secp256k1Keypair.import(privKey, { exportable: true })
 }
 
-const createActorTransactor = (
-  did: string,
-  db: ActorDb,
-  keypair: Keypair,
-  resources: ActorStoreResources,
-): ActorStoreTransactor => {
-  const { blobstore, backgroundQueue } = resources
-  const userBlobstore = blobstore(did)
-  return {
-    did,
-    db,
-    repo: new RepoTransactor(db, did, keypair, userBlobstore, backgroundQueue),
-    record: new RecordTransactor(db, userBlobstore),
-    pref: new PreferenceTransactor(db),
-  }
-}
-
-const createActorReader = (
-  did: string,
-  db: ActorDb,
-  resources: ActorStoreResources,
-  getKeypair: () => Promise<Keypair>,
-): ActorStoreReader => {
-  const { blobstore } = resources
-  return {
-    did,
-    db,
-    repo: new RepoReader(db, blobstore(did)),
-    record: new RecordReader(db),
-    pref: new PreferenceReader(db),
-    keypair: getKeypair,
-    transact: async <T>(fn: ActorStoreTransactFn<T>): Promise<T> => {
-      const keypair = await getKeypair()
-      return db.transaction((dbTxn) => {
-        const store = createActorTransactor(did, dbTxn, keypair, resources)
-        return fn(store)
-      })
-    },
-  }
-}
-
-export type ActorStoreReadFn<T> = (fn: ActorStoreReader) => Promise<T>
-export type ActorStoreTransactFn<T> = (fn: ActorStoreTransactor) => Promise<T>
-export type ActorStoreWriterFn<T> = (fn: ActorStoreWriter) => Promise<T>
-
-export type ActorStoreReader = {
-  did: string
-  db: ActorDb
-  repo: RepoReader
-  record: RecordReader
-  pref: PreferenceReader
-  keypair: () => Promise<Keypair>
-  transact: <T>(fn: ActorStoreTransactFn<T>) => Promise<T>
-}
-
-export type ActorStoreTransactor = {
-  did: string
-  db: ActorDb
-  repo: RepoTransactor
-  record: RecordTransactor
-  pref: PreferenceTransactor
-}
-
-export type ActorStoreWriter = ActorStoreTransactor & {
-  transact: <T>(fn: ActorStoreTransactFn<T>) => Promise<T>
-}
-
 function assertSafePathPart(part: string) {
   const normalized = path.normalize(part)
   assert(

package/src/actor-store/blob/reader.ts

@@ -1,10 +1,10 @@
-import stream from 'stream'
+import stream from 'node:stream'
 import { CID } from 'multiformats/cid'
 import { BlobNotFoundError, BlobStore } from '@atproto/repo'
 import { InvalidRequestError } from '@atproto/xrpc-server'
-import { ActorDb } from '../db'
 import { countAll, countDistinct, notSoftDeletedClause } from '../../db/util'
 import { StatusAttr } from '../../lexicon/types/com/atproto/admin/defs'
+import { ActorDb } from '../db'
 
 export class BlobReader {
   constructor(
@@ -95,6 +95,16 @@ export class BlobReader {
     return res.map((row) => row.recordUri)
   }
 
+  async getBlobsForRecord(recordUri: string): Promise<string[]> {
+    const res = await this.db.db
+      .selectFrom('blob')
+      .innerJoin('record_blob', 'record_blob.blobCid', 'blob.cid')
+      .where('recordUri', '=', recordUri)
+      .select('blob.cid')
+      .execute()
+    return res.map((row) => row.cid)
+  }
+
   async blobCount(): Promise<number> {
     const res = await this.db.db
       .selectFrom('blob')
@@ -138,4 +148,9 @@ export class BlobReader {
       recordUri: row.recordUri,
     }))
   }
+
+  async getBlobCids() {
+    const blobRows = await this.db.db.selectFrom('blob').select('cid').execute()
+    return blobRows.map((row) => CID.parse(row.cid))
+  }
 }

package/src/actor-store/blob/transactor.ts

@@ -1,24 +1,24 @@
-import stream from 'stream'
-import crypto from 'crypto'
-import { CID } from 'multiformats/cid'
+import crypto from 'node:crypto'
+import stream from 'node:stream'
 import bytes from 'bytes'
 import { fromStream as fileTypeFromStream } from 'file-type'
+import { CID } from 'multiformats/cid'
+import { cloneStream, sha256RawToCid, streamSize } from '@atproto/common'
+import { BlobRef } from '@atproto/lexicon'
 import { BlobNotFoundError, BlobStore, WriteOpAction } from '@atproto/repo'
 import { AtUri } from '@atproto/syntax'
-import { cloneStream, sha256RawToCid, streamSize } from '@atproto/common'
 import { InvalidRequestError } from '@atproto/xrpc-server'
-import { BlobRef } from '@atproto/lexicon'
-import { ActorDb, Blob as BlobTable } from '../db'
+import { BackgroundQueue } from '../../background'
+import * as img from '../../image'
+import { StatusAttr } from '../../lexicon/types/com/atproto/admin/defs'
 import {
   PreparedBlobRef,
-  PreparedWrite,
   PreparedDelete,
   PreparedUpdate,
+  PreparedWrite,
 } from '../../repo/types'
-import * as img from '../../image'
-import { BackgroundQueue } from '../../background'
+import { ActorDb, Blob as BlobTable } from '../db'
 import { BlobReader } from './reader'
-import { StatusAttr } from '../../lexicon/types/com/atproto/admin/defs'
 
 export type BlobMetadata = {
   tempKey: string
@@ -38,6 +38,21 @@ export class BlobTransactor extends BlobReader {
     super(db, blobstore)
   }
 
+  async insertBlobs(recordUri: string, blobs: Iterable<BlobRef>) {
+    const values = Array.from(blobs, (cid) => ({
+      recordUri,
+      blobCid: cid.ref.toString(),
+    }))
+
+    if (values.length) {
+      await this.db.db
+        .insertInto('record_blob')
+        .values(values)
+        .onConflict((oc) => oc.doNothing())
+        .execute()
+    }
+  }
+
   async uploadBlobAndGetMetadata(
     userSuggestedMime: string,
     blobStream: stream.Readable,

package/src/actor-store/db/index.ts

@@ -1,6 +1,6 @@
-import { DatabaseSchema } from './schema'
 import { Database, Migrator } from '../../db'
 import migrations from './migrations'
+import { DatabaseSchema } from './schema'
 export * from './schema'
 
 export type ActorDb = Database<DatabaseSchema>