@atproto/bsky 0.0.133 → 0.0.134

package/src/lexicon/types/app/bsky/unspecced/getSuggestedStarterPacksSkeleton.ts

@@ -0,0 +1,55 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.bsky.unspecced.getSuggestedStarterPacksSkeleton'
+
+export interface QueryParams {
+  /** DID of the account making the request (not included for public/unauthenticated queries). */
+  viewer?: string
+  limit: number
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  starterPacks: string[]
+}
+
+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 | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

package/src/lexicon/types/app/bsky/unspecced/getTrends.ts

@@ -0,0 +1,54 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppBskyUnspeccedDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.bsky.unspecced.getTrends'
+
+export interface QueryParams {
+  limit: number
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  trends: AppBskyUnspeccedDefs.TrendView[]
+}
+
+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 | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

package/src/lexicon/types/app/bsky/unspecced/getTrendsSkeleton.ts

@@ -0,0 +1,56 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppBskyUnspeccedDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.bsky.unspecced.getTrendsSkeleton'
+
+export interface QueryParams {
+  /** DID of the account making the request (not included for public/unauthenticated queries). */
+  viewer?: string
+  limit: number
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  trends: AppBskyUnspeccedDefs.SkeletonTrend[]
+}
+
+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 | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

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

@@ -0,0 +1,48 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.admin.updateAccountSigningKey'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  did: string
+  /** Did-key formatted public key */
+  signingKey: string
+}
+
+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
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

package/tests/seed/get-suggested-starter-packs.ts

@@ -0,0 +1,63 @@
+import { SeedClient, TestNetwork, TestNetworkNoAppView } from '@atproto/dev-env'
+
+export type User = {
+  id: string
+  did: string
+  email: string
+  handle: string
+  password: string
+  displayName: string
+  description: string
+  selfLabels: undefined
+}
+
+function createUser(name: string): User {
+  return {
+    id: name,
+    // @ts-ignore overwritten below
+    did: undefined,
+    email: `${name}@test.com`,
+    handle: `${name}.test`,
+    password: `${name}-pass`,
+    displayName: name,
+    description: `hi im ${name} label_me`,
+    selfLabels: undefined,
+  }
+}
+
+const users = {
+  creator: createUser('creator'),
+  poster: createUser('poster'),
+
+  viewer: createUser('viewer'),
+  viewerBlocker: createUser('viewerBlocker'),
+}
+
+export type Users = typeof users
+export type StarterPacks = SeedClient['starterpacks']
+
+export async function trendsSeed(
+  sc: SeedClient<TestNetwork | TestNetworkNoAppView>,
+) {
+  const u = structuredClone(users)
+
+  await sc.createAccount('creator', u.creator)
+  await sc.createAccount('poster', u.poster)
+  await sc.createAccount('viewer', u.viewer)
+  await sc.createAccount('viewerBlocker', u.viewerBlocker)
+
+  Object.values(u).forEach((user) => {
+    u[user.id].did = sc.dids[user.id]
+  })
+
+  await sc.createStarterPack(u.creator.did, 'test', [u.poster.did])
+  await sc.block(u.viewerBlocker.did, u.creator.did)
+
+  await sc.network.processAll()
+
+  return {
+    users: u,
+    starterpacks: sc.starterpacks,
+    seedClient: sc,
+  }
+}

package/tests/seed/get-trends.ts

@@ -0,0 +1,70 @@
+import { SeedClient, TestNetwork, TestNetworkNoAppView } from '@atproto/dev-env'
+
+export type User = {
+  id: string
+  did: string
+  email: string
+  handle: string
+  password: string
+  displayName: string
+  description: string
+  selfLabels: undefined
+}
+
+function createUser(name: string): User {
+  return {
+    id: name,
+    // @ts-ignore overwritten below
+    did: undefined,
+    email: `${name}@test.com`,
+    handle: `${name}.test`,
+    password: `${name}-pass`,
+    displayName: name,
+    description: `hi im ${name} label_me`,
+    selfLabels: undefined,
+  }
+}
+
+const users = {
+  trender: createUser('trender'),
+
+  posterA: createUser('posterA'),
+  posterB: createUser('posterB'),
+  posterC: createUser('posterC'),
+  posterD: createUser('posterD'),
+
+  viewer: createUser('viewer'),
+  viewerBlocker: createUser('viewerBlocker'),
+}
+
+export type Users = typeof users
+export type Feeds = SeedClient['feedgens']
+
+export async function trendsSeed(
+  sc: SeedClient<TestNetwork | TestNetworkNoAppView>,
+) {
+  const u = structuredClone(users)
+
+  await sc.createAccount('trender', u.trender)
+  await sc.createAccount('posterA', u.posterA)
+  await sc.createAccount('posterB', u.posterB)
+  await sc.createAccount('posterC', u.posterC)
+  await sc.createAccount('posterD', u.posterD)
+  await sc.createAccount('viewer', u.viewer)
+  await sc.createAccount('viewerBlocker', u.viewerBlocker)
+
+  Object.values(u).forEach((user) => {
+    u[user.id].did = sc.dids[user.id]
+  })
+
+  await sc.createFeedGen(u.trender.did, 'did:web:example.com', 'trendA')
+  await sc.block(u.viewerBlocker.did, u.posterC.did)
+
+  await sc.network.processAll()
+
+  return {
+    users: u,
+    feeds: sc.feedgens,
+    seedClient: sc,
+  }
+}

package/tests/views/get-suggested-starter-packs.test.ts

@@ -0,0 +1,128 @@
+import { once } from 'node:events'
+import { Server, createServer } from 'node:http'
+import { AddressInfo } from 'node:net'
+import express, { Application } from 'express'
+import AtpAgent from '@atproto/api'
+import { SeedClient, TestNetwork } from '@atproto/dev-env'
+import { ids } from '../../src/lexicon/lexicons'
+import { OutputSchema } from '../../src/lexicon/types/app/bsky/unspecced/getSuggestedStarterPacksSkeleton'
+import {
+  StarterPacks,
+  Users,
+  trendsSeed,
+} from '../seed/get-suggested-starter-packs'
+
+describe('getSuggestedStarterPacks', () => {
+  let network: TestNetwork
+  let agent: AtpAgent
+  let sc: SeedClient
+  let users: Users
+  let mockServer: MockServer
+  let starterpacks: StarterPacks
+
+  beforeAll(async () => {
+    mockServer = new MockServer()
+    await mockServer.listen()
+
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'bsky_tests_get_suggested_starter_packs',
+      bsky: {
+        topicsUrl: mockServer.url,
+        topicsApiKey: 'test',
+      },
+    })
+    agent = network.bsky.getClient()
+    sc = network.getSeedClient()
+
+    const result = await trendsSeed(sc)
+    users = result.users
+    starterpacks = result.starterpacks
+
+    await network.processAll()
+  })
+
+  afterAll(async () => {
+    await network.close()
+    await mockServer.stop()
+  })
+
+  describe(`basic handling`, () => {
+    beforeAll(() => {
+      const pack = Object.values(starterpacks[users.creator.did])[0]
+      mockServer.mockedStarterPackUris.set('a', pack.ref.uriStr)
+    })
+
+    afterAll(() => {
+      mockServer.mockedStarterPackUris.delete('a')
+    })
+
+    it(`returns pack for non-blocking user`, async () => {
+      const { data } = await agent.app.bsky.unspecced.getSuggestedStarterPacks(
+        undefined,
+        {
+          headers: await network.serviceHeaders(
+            users.viewer.did,
+            ids.AppBskyUnspeccedGetSuggestedStarterPacks,
+          ),
+        },
+      )
+      const sp = data.starterPacks[0]
+      expect(sp).toBeDefined()
+    })
+
+    it(`does not return pack if creator blocked by viewer`, async () => {
+      const { data } = await agent.app.bsky.unspecced.getSuggestedStarterPacks(
+        undefined,
+        {
+          headers: await network.serviceHeaders(
+            users.viewerBlocker.did,
+            ids.AppBskyUnspeccedGetSuggestedStarterPacks,
+          ),
+        },
+      )
+      const sp = data.starterPacks[0]
+      expect(sp).not.toBeDefined()
+    })
+  })
+})
+
+class MockServer {
+  app: Application
+  server: Server
+
+  mockedStarterPackUris = new Map<string, OutputSchema['starterPacks'][0]>()
+
+  constructor() {
+    this.app = this.createApp()
+    this.server = createServer(this.app)
+  }
+
+  async listen(port?: number) {
+    this.server.listen(port)
+    await once(this.server, 'listening')
+  }
+
+  async stop() {
+    this.server.close()
+    await once(this.server, 'close')
+  }
+
+  get url() {
+    const address = this.server.address() as AddressInfo
+    return `http://localhost:${address.port}`
+  }
+
+  private createApp() {
+    const app = express()
+    app.get(
+      '/xrpc/app.bsky.unspecced.getSuggestedStarterPacksSkeleton',
+      (req, res) => {
+        const skeleton: OutputSchema = {
+          starterPacks: Array.from(this.mockedStarterPackUris.values()),
+        }
+        return res.json(skeleton)
+      },
+    )
+    return app
+  }
+}

package/tests/views/get-trends.test.ts

@@ -0,0 +1,133 @@
+import assert from 'node:assert'
+import { once } from 'node:events'
+import { Server, createServer } from 'node:http'
+import { AddressInfo } from 'node:net'
+import express, { Application } from 'express'
+import AtpAgent from '@atproto/api'
+import { SeedClient, TestNetwork } from '@atproto/dev-env'
+import { ids } from '../../src/lexicon/lexicons'
+import { OutputSchema } from '../../src/lexicon/types/app/bsky/unspecced/getTrendsSkeleton'
+import { Users, trendsSeed } from '../seed/get-trends'
+
+describe('getTrends', () => {
+  let network: TestNetwork
+  let agent: AtpAgent
+  let sc: SeedClient
+  let users: Users
+  let mockTrendServer: MockTrendsServer
+
+  beforeAll(async () => {
+    mockTrendServer = new MockTrendsServer()
+    await mockTrendServer.listen()
+
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'bsky_tests_get_trends_test_b',
+      bsky: {
+        topicsUrl: mockTrendServer.url,
+        topicsApiKey: 'test',
+      },
+    })
+    agent = network.bsky.getClient()
+    sc = network.getSeedClient()
+
+    const result = await trendsSeed(sc)
+    users = result.users
+
+    await network.processAll()
+  })
+
+  afterAll(async () => {
+    await network.close()
+    await mockTrendServer.stop()
+  })
+
+  describe(`basic handling`, () => {
+    beforeAll(() => {
+      mockTrendServer.mockedTrendSkeletons.set('a', {
+        topic: 'a',
+        displayName: 'A',
+        link: '/test',
+        startedAt: new Date().toISOString(),
+        postCount: 3,
+        dids: [users.posterA.did, users.posterB.did, users.posterC.did],
+      })
+    })
+
+    afterAll(() => {
+      mockTrendServer.mockedTrendSkeletons.delete('a')
+    })
+
+    it(`returns all users for non-blocked user`, async () => {
+      const { data } = await agent.app.bsky.unspecced.getTrends(undefined, {
+        headers: await network.serviceHeaders(
+          users.viewer.did,
+          ids.AppBskyUnspeccedGetTrends,
+        ),
+      })
+      const trendA = data.trends.find((t) => t.topic === 'a')
+
+      assert(trendA)
+
+      expect(trendA.actors.map((a) => a.did)).toEqual([
+        users.posterA.did,
+        users.posterB.did,
+        users.posterC.did,
+      ])
+    })
+
+    it(`does not return user blocked by viewer`, async () => {
+      const { data } = await agent.app.bsky.unspecced.getTrends(undefined, {
+        headers: await network.serviceHeaders(
+          users.viewerBlocker.did,
+          ids.AppBskyUnspeccedGetTrends,
+        ),
+      })
+      const trendA = data.trends.find((t) => t.topic === 'a')
+
+      assert(trendA)
+
+      expect(trendA.actors.map((a) => a.did)).toEqual([
+        users.posterA.did,
+        users.posterB.did,
+      ])
+    })
+  })
+})
+
+class MockTrendsServer {
+  app: Application
+  server: Server
+
+  mockedTrendSkeletons = new Map<string, OutputSchema['trends'][0]>()
+
+  constructor() {
+    this.app = this.createApp()
+    this.server = createServer(this.app)
+  }
+
+  async listen(port?: number) {
+    this.server.listen(port)
+    await once(this.server, 'listening')
+  }
+
+  async stop() {
+    this.server.close()
+    await once(this.server, 'close')
+  }
+
+  get url() {
+    const address = this.server.address() as AddressInfo
+    return `http://localhost:${address.port}`
+  }
+
+  private createApp() {
+    const app = express()
+    app.get('/xrpc/app.bsky.unspecced.getTrendsSkeleton', (req, res) => {
+      const skeleton: OutputSchema = {
+        trends: Array.from(this.mockedTrendSkeletons.values()),
+      }
+      return res.json(skeleton)
+    })
+    return app
+  }
+}