@atproto/bsky 0.0.214 → 0.0.215

package/src/lexicon/lexicons.ts

@@ -2392,9 +2392,10 @@ export const schemaDict = {
         properties: {
           text: {
             type: 'string',
-            maxLength: 3000,
-            maxGraphemes: 300,
-            description: 'The primary post content.',
+            maxLength: 10000,
+            maxGraphemes: 1000,
+            description:
+              'The primary post content. It has a higher limit than post contents to allow storing a larger text that can later be refined into smaller posts.',
           },
           labels: {
             type: 'union',
@@ -8343,6 +8344,105 @@ export const schemaDict = {
       },
     },
   },
+  AppBskyUnspeccedGetSuggestedOnboardingUsers: {
+    lexicon: 1,
+    id: 'app.bsky.unspecced.getSuggestedOnboardingUsers',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get a list of suggested users for onboarding',
+        parameters: {
+          type: 'params',
+          properties: {
+            category: {
+              type: 'string',
+              description: 'Category of users to get suggestions for.',
+            },
+            limit: {
+              type: 'integer',
+              minimum: 1,
+              maximum: 50,
+              default: 25,
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['actors'],
+            properties: {
+              actors: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.bsky.actor.defs#profileView',
+                },
+              },
+              recId: {
+                type: 'string',
+                description:
+                  'Snowflake for this recommendation, use when submitting recommendation events.',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  AppBskyUnspeccedGetSuggestedOnboardingUsersSkeleton: {
+    lexicon: 1,
+    id: 'app.bsky.unspecced.getSuggestedOnboardingUsersSkeleton',
+    defs: {
+      main: {
+        type: 'query',
+        description:
+          'Get a skeleton of suggested users for onboarding. Intended to be called and hydrated by app.bsky.unspecced.getSuggestedOnboardingUsers',
+        parameters: {
+          type: 'params',
+          properties: {
+            viewer: {
+              type: 'string',
+              format: 'did',
+              description:
+                'DID of the account making the request (not included for public/unauthenticated queries).',
+            },
+            category: {
+              type: 'string',
+              description: 'Category of users to get suggestions for.',
+            },
+            limit: {
+              type: 'integer',
+              minimum: 1,
+              maximum: 50,
+              default: 25,
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['dids'],
+            properties: {
+              dids: {
+                type: 'array',
+                items: {
+                  type: 'string',
+                  format: 'did',
+                },
+              },
+              recId: {
+                type: 'string',
+                description:
+                  'Snowflake for this recommendation, use when submitting recommendation events.',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   AppBskyUnspeccedGetSuggestedStarterPacks: {
     lexicon: 1,
     id: 'app.bsky.unspecced.getSuggestedStarterPacks',
@@ -15346,7 +15446,7 @@ export const schemaDict = {
     defs: {
       main: {
         type: 'record',
-        description: 'A delegate messaging id',
+        description: 'A declaration of a Germ Network account',
         key: 'literal:self',
         record: {
           type: 'object',
@@ -15354,22 +15454,33 @@ export const schemaDict = {
           properties: {
             version: {
               type: 'string',
+              description:
+                'Semver version number, without pre-release or build information, for the format of opaque content',
+              minLength: 5,
+              maxLength: 14,
             },
             currentKey: {
               type: 'bytes',
+              description:
+                'Opaque value, an ed25519 public key prefixed with a byte enum',
             },
             messageMe: {
               type: 'ref',
+              description: 'Controls who can message this account',
               ref: 'lex:com.germnetwork.declaration#messageMe',
             },
             keyPackage: {
               type: 'bytes',
+              description:
+                'Opaque value, contains MLS KeyPackage(s), and other signature data, and is signed by the currentKey',
             },
             continuityProofs: {
               type: 'array',
+              description: 'Array of opaque values to allow for key rolling',
               items: {
                 type: 'bytes',
               },
+              maxLength: 1000,
             },
           },
         },
@@ -15380,11 +15491,19 @@ export const schemaDict = {
         properties: {
           messageMeUrl: {
             type: 'string',
+            description:
+              'A URL to present to an account that does not have its own com.germnetwork.declaration record, must have an empty fragment component, where the app should fill in the fragment component with the DIDs of the two accounts who wish to message each other',
             format: 'uri',
+            minLength: 1,
+            maxLength: 2047,
           },
           showButtonTo: {
             type: 'string',
-            knownValues: ['usersIFollow', 'everyone'],
+            knownValues: ['none', 'usersIFollow', 'everyone'],
+            description:
+              "The policy of who can message the account, this value is included in the keyPackage, but is duplicated here to allow applications to decide if they should show a 'Message on Germ' button to the viewer.",
+            minLength: 1,
+            maxLength: 100,
           },
         },
       },
@@ -15555,6 +15674,10 @@ export const ids = {
   AppBskyUnspeccedGetSuggestedFeeds: 'app.bsky.unspecced.getSuggestedFeeds',
   AppBskyUnspeccedGetSuggestedFeedsSkeleton:
     'app.bsky.unspecced.getSuggestedFeedsSkeleton',
+  AppBskyUnspeccedGetSuggestedOnboardingUsers:
+    'app.bsky.unspecced.getSuggestedOnboardingUsers',
+  AppBskyUnspeccedGetSuggestedOnboardingUsersSkeleton:
+    'app.bsky.unspecced.getSuggestedOnboardingUsersSkeleton',
   AppBskyUnspeccedGetSuggestedStarterPacks:
     'app.bsky.unspecced.getSuggestedStarterPacks',
   AppBskyUnspeccedGetSuggestedStarterPacksSkeleton:

package/src/lexicon/types/app/bsky/draft/defs.ts

@@ -75,7 +75,7 @@ export function validateDraft<V>(v: V) {
 /** One of the posts that compose a draft. */
 export interface DraftPost {
   $type?: 'app.bsky.draft.defs#draftPost'
-  /** The primary post content. */
+  /** The primary post content. It has a higher limit than post contents to allow storing a larger text that can later be refined into smaller posts. */
   text: string
   labels?: $Typed<ComAtprotoLabelDefs.SelfLabels> | { $type: string }
   embedImages?: DraftEmbedImage[]

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

@@ -0,0 +1,44 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+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 type * as AppBskyActorDefs from '../actor/defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.bsky.unspecced.getSuggestedOnboardingUsers'
+
+export type QueryParams = {
+  /** Category of users to get suggestions for. */
+  category?: string
+  limit: number
+}
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  actors: AppBskyActorDefs.ProfileView[]
+  /** Snowflake for this recommendation, use when submitting recommendation events. */
+  recId?: string
+}
+
+export type HandlerInput = void
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess

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

@@ -0,0 +1,45 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+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'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.bsky.unspecced.getSuggestedOnboardingUsersSkeleton'
+
+export type QueryParams = {
+  /** DID of the account making the request (not included for public/unauthenticated queries). */
+  viewer?: string
+  /** Category of users to get suggestions for. */
+  category?: string
+  limit: number
+}
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  dids: string[]
+  /** Snowflake for this recommendation, use when submitting recommendation events. */
+  recId?: string
+}
+
+export type HandlerInput = void
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess

package/src/lexicon/types/com/germnetwork/declaration.ts

@@ -12,10 +12,14 @@ const id = 'com.germnetwork.declaration'
 
 export interface Main {
   $type: 'com.germnetwork.declaration'
+  /** Semver version number, without pre-release or build information, for the format of opaque content */
   version: string
+  /** Opaque value, an ed25519 public key prefixed with a byte enum */
   currentKey: Uint8Array
   messageMe?: MessageMe
+  /** Opaque value, contains MLS KeyPackage(s), and other signature data, and is signed by the currentKey */
   keyPackage?: Uint8Array
+  /** Array of opaque values to allow for key rolling */
   continuityProofs?: Uint8Array[]
   [k: string]: unknown
 }
@@ -38,8 +42,10 @@ export {
 
 export interface MessageMe {
   $type?: 'com.germnetwork.declaration#messageMe'
+  /** A URL to present to an account that does not have its own com.germnetwork.declaration record, must have an empty fragment component, where the app should fill in the fragment component with the DIDs of the two accounts who wish to message each other */
   messageMeUrl: string
-  showButtonTo: 'usersIFollow' | 'everyone' | (string & {})
+  /** The policy of who can message the account, this value is included in the keyPackage, but is duplicated here to allow applications to decide if they should show a 'Message on Germ' button to the viewer. */
+  showButtonTo: 'none' | 'usersIFollow' | 'everyone' | (string & {})
 }
 
 const hashMessageMe = 'messageMe'

package/tests/views/get-suggested-onboarding-users.test.ts

@@ -0,0 +1,186 @@
+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/getSuggestedOnboardingUsersSkeleton'
+
+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}`,
+    selfLabels: undefined,
+  }
+}
+
+const users = {
+  suggestedUser: createUser('suggested-user'),
+  viewer: createUser('viewer'),
+  viewerBlocker: createUser('viewer-blocker'),
+  followedUser: createUser('followed-user'),
+}
+
+type Users = typeof users
+
+async function seed(sc: SeedClient) {
+  const u = structuredClone(users)
+
+  for (const [key, user] of Object.entries(u)) {
+    await sc.createAccount(key, user)
+    u[key].did = sc.dids[key]
+  }
+
+  await sc.block(u.viewerBlocker.did, u.suggestedUser.did)
+  await sc.follow(u.viewer.did, u.followedUser.did)
+
+  await sc.network.processAll()
+
+  return { users: u }
+}
+
+describe('getSuggestedOnboardingUsers', () => {
+  let network: TestNetwork
+  let agent: AtpAgent
+  let sc: SeedClient
+  let seededUsers: Users
+  let mockServer: MockServer
+
+  beforeAll(async () => {
+    mockServer = new MockServer()
+    await mockServer.listen()
+
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'bsky_tests_get_suggested_onboarding_users',
+      bsky: {
+        topicsUrl: mockServer.url,
+        topicsApiKey: 'test',
+      },
+    })
+    agent = network.bsky.getClient()
+    sc = network.getSeedClient()
+
+    const result = await seed(sc)
+    seededUsers = result.users
+
+    await network.processAll()
+  })
+
+  afterAll(async () => {
+    await network.close()
+    await mockServer.stop()
+  })
+
+  describe(`basic handling`, () => {
+    beforeAll(() => {
+      mockServer.mockedDids.set('suggestedUser', seededUsers.suggestedUser.did)
+    })
+
+    afterAll(() => {
+      mockServer.mockedDids.delete('suggestedUser')
+    })
+
+    it(`returns users for non-blocking viewer`, async () => {
+      const { data } =
+        await agent.app.bsky.unspecced.getSuggestedOnboardingUsers(undefined, {
+          headers: await network.serviceHeaders(
+            seededUsers.viewer.did,
+            ids.AppBskyUnspeccedGetSuggestedOnboardingUsers,
+          ),
+        })
+      const actor = data.actors.find(
+        (a) => a.did === seededUsers.suggestedUser.did,
+      )
+      expect(actor).toBeDefined()
+    })
+
+    it(`does not return user if blocked by viewer`, async () => {
+      const { data } =
+        await agent.app.bsky.unspecced.getSuggestedOnboardingUsers(undefined, {
+          headers: await network.serviceHeaders(
+            seededUsers.viewerBlocker.did,
+            ids.AppBskyUnspeccedGetSuggestedOnboardingUsers,
+          ),
+        })
+      const actor = data.actors.find(
+        (a) => a.did === seededUsers.suggestedUser.did,
+      )
+      expect(actor).not.toBeDefined()
+    })
+
+    it(`does not return users that viewer already follows`, async () => {
+      mockServer.mockedDids.set('followedUser', seededUsers.followedUser.did)
+      const { data } =
+        await agent.app.bsky.unspecced.getSuggestedOnboardingUsers(undefined, {
+          headers: await network.serviceHeaders(
+            seededUsers.viewer.did,
+            ids.AppBskyUnspeccedGetSuggestedOnboardingUsers,
+          ),
+        })
+      const actor = data.actors.find(
+        (a) => a.did === seededUsers.followedUser.did,
+      )
+      expect(actor).not.toBeDefined()
+      mockServer.mockedDids.delete('followedUser')
+    })
+  })
+})
+
+class MockServer {
+  app: Application
+  server: Server
+
+  mockedDids = new Map<string, string>()
+
+  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.getSuggestedUsersSkeleton',
+      (req, res) => {
+        const skeleton: OutputSchema = {
+          dids: Array.from(this.mockedDids.values()),
+        }
+        return res.json(skeleton)
+      },
+    )
+    return app
+  }
+}