@atproto/bsky 0.0.10 → 0.0.11

package/src/index.ts

@@ -25,6 +25,7 @@ import { BackgroundQueue } from './background'
 import { MountedAlgos } from './feed-gen/types'
 import { LabelCache } from './label-cache'
 import { NotificationServer } from './notifications'
+import { AtpAgent } from '@atproto/api'
 
 export type { ServerConfigValues } from './config'
 export type { MountedAlgos } from './feed-gen/types'
@@ -100,6 +101,9 @@ export class BskyAppView {
     const backgroundQueue = new BackgroundQueue(db.getPrimary())
     const labelCache = new LabelCache(db.getPrimary())
     const notifServer = new NotificationServer(db.getPrimary())
+    const searchAgent = config.searchEndpoint
+      ? new AtpAgent({ service: config.searchEndpoint })
+      : undefined
 
     const services = createServices({
       imgUriBuilder,
@@ -116,6 +120,7 @@ export class BskyAppView {
       didCache,
       labelCache,
       backgroundQueue,
+      searchAgent,
       algos,
       notifServer,
     })

package/src/lexicon/index.ts

@@ -39,6 +39,7 @@ import * as ComAtprotoRepoGetRecord from './types/com/atproto/repo/getRecord'
 import * as ComAtprotoRepoListRecords from './types/com/atproto/repo/listRecords'
 import * as ComAtprotoRepoPutRecord from './types/com/atproto/repo/putRecord'
 import * as ComAtprotoRepoUploadBlob from './types/com/atproto/repo/uploadBlob'
+import * as ComAtprotoServerConfirmEmail from './types/com/atproto/server/confirmEmail'
 import * as ComAtprotoServerCreateAccount from './types/com/atproto/server/createAccount'
 import * as ComAtprotoServerCreateAppPassword from './types/com/atproto/server/createAppPassword'
 import * as ComAtprotoServerCreateInviteCode from './types/com/atproto/server/createInviteCode'
@@ -52,9 +53,12 @@ import * as ComAtprotoServerGetSession from './types/com/atproto/server/getSessi
 import * as ComAtprotoServerListAppPasswords from './types/com/atproto/server/listAppPasswords'
 import * as ComAtprotoServerRefreshSession from './types/com/atproto/server/refreshSession'
 import * as ComAtprotoServerRequestAccountDelete from './types/com/atproto/server/requestAccountDelete'
+import * as ComAtprotoServerRequestEmailConfirmation from './types/com/atproto/server/requestEmailConfirmation'
+import * as ComAtprotoServerRequestEmailUpdate from './types/com/atproto/server/requestEmailUpdate'
 import * as ComAtprotoServerRequestPasswordReset from './types/com/atproto/server/requestPasswordReset'
 import * as ComAtprotoServerResetPassword from './types/com/atproto/server/resetPassword'
 import * as ComAtprotoServerRevokeAppPassword from './types/com/atproto/server/revokeAppPassword'
+import * as ComAtprotoServerUpdateEmail from './types/com/atproto/server/updateEmail'
 import * as ComAtprotoSyncGetBlob from './types/com/atproto/sync/getBlob'
 import * as ComAtprotoSyncGetBlocks from './types/com/atproto/sync/getBlocks'
 import * as ComAtprotoSyncGetCheckout from './types/com/atproto/sync/getCheckout'
@@ -557,6 +561,17 @@ export class ServerNS {
     this._server = server
   }
 
+  confirmEmail<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ComAtprotoServerConfirmEmail.Handler<ExtractAuth<AV>>,
+      ComAtprotoServerConfirmEmail.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'com.atproto.server.confirmEmail' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
   createAccount<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,
@@ -700,6 +715,28 @@ export class ServerNS {
     return this._server.xrpc.method(nsid, cfg)
   }
 
+  requestEmailConfirmation<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ComAtprotoServerRequestEmailConfirmation.Handler<ExtractAuth<AV>>,
+      ComAtprotoServerRequestEmailConfirmation.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'com.atproto.server.requestEmailConfirmation' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  requestEmailUpdate<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ComAtprotoServerRequestEmailUpdate.Handler<ExtractAuth<AV>>,
+      ComAtprotoServerRequestEmailUpdate.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'com.atproto.server.requestEmailUpdate' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
   requestPasswordReset<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,
@@ -732,6 +769,17 @@ export class ServerNS {
     const nsid = 'com.atproto.server.revokeAppPassword' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
+
+  updateEmail<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ComAtprotoServerUpdateEmail.Handler<ExtractAuth<AV>>,
+      ComAtprotoServerUpdateEmail.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'com.atproto.server.updateEmail' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
 }
 
 export class SyncNS {

package/src/lexicon/lexicons.ts

@@ -2242,6 +2242,46 @@ export const schemaDict = {
       },
     },
   },
+  ComAtprotoServerConfirmEmail: {
+    lexicon: 1,
+    id: 'com.atproto.server.confirmEmail',
+    defs: {
+      main: {
+        type: 'procedure',
+        description:
+          'Confirm an email using a token from com.atproto.server.requestEmailConfirmation.',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['email', 'token'],
+            properties: {
+              email: {
+                type: 'string',
+              },
+              token: {
+                type: 'string',
+              },
+            },
+          },
+        },
+        errors: [
+          {
+            name: 'AccountNotFound',
+          },
+          {
+            name: 'ExpiredToken',
+          },
+          {
+            name: 'InvalidToken',
+          },
+          {
+            name: 'InvalidEmail',
+          },
+        ],
+      },
+    },
+  },
   ComAtprotoServerCreateAccount: {
     lexicon: 1,
     id: 'com.atproto.server.createAccount',
@@ -2526,6 +2566,9 @@ export const schemaDict = {
               email: {
                 type: 'string',
               },
+              emailConfirmed: {
+                type: 'boolean',
+              },
             },
           },
         },
@@ -2756,6 +2799,9 @@ export const schemaDict = {
               email: {
                 type: 'string',
               },
+              emailConfirmed: {
+                type: 'boolean',
+              },
             },
           },
         },
@@ -2854,6 +2900,39 @@ export const schemaDict = {
       },
     },
   },
+  ComAtprotoServerRequestEmailConfirmation: {
+    lexicon: 1,
+    id: 'com.atproto.server.requestEmailConfirmation',
+    defs: {
+      main: {
+        type: 'procedure',
+        description:
+          'Request an email with a code to confirm ownership of email',
+      },
+    },
+  },
+  ComAtprotoServerRequestEmailUpdate: {
+    lexicon: 1,
+    id: 'com.atproto.server.requestEmailUpdate',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Request a token in order to update email.',
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['tokenRequired'],
+            properties: {
+              tokenRequired: {
+                type: 'boolean',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   ComAtprotoServerRequestPasswordReset: {
     lexicon: 1,
     id: 'com.atproto.server.requestPasswordReset',
@@ -2931,6 +3010,44 @@ export const schemaDict = {
       },
     },
   },
+  ComAtprotoServerUpdateEmail: {
+    lexicon: 1,
+    id: 'com.atproto.server.updateEmail',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: "Update an account's email.",
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['email'],
+            properties: {
+              email: {
+                type: 'string',
+              },
+              token: {
+                type: 'string',
+                description:
+                  "Requires a token from com.atproto.sever.requestEmailUpdate if the account's email has been confirmed.",
+              },
+            },
+          },
+        },
+        errors: [
+          {
+            name: 'ExpiredToken',
+          },
+          {
+            name: 'InvalidToken',
+          },
+          {
+            name: 'TokenRequired',
+          },
+        ],
+      },
+    },
+  },
   ComAtprotoSyncGetBlob: {
     lexicon: 1,
     id: 'com.atproto.sync.getBlob',
@@ -7240,6 +7357,7 @@ export const ids = {
   ComAtprotoRepoPutRecord: 'com.atproto.repo.putRecord',
   ComAtprotoRepoStrongRef: 'com.atproto.repo.strongRef',
   ComAtprotoRepoUploadBlob: 'com.atproto.repo.uploadBlob',
+  ComAtprotoServerConfirmEmail: 'com.atproto.server.confirmEmail',
   ComAtprotoServerCreateAccount: 'com.atproto.server.createAccount',
   ComAtprotoServerCreateAppPassword: 'com.atproto.server.createAppPassword',
   ComAtprotoServerCreateInviteCode: 'com.atproto.server.createInviteCode',
@@ -7256,10 +7374,14 @@ export const ids = {
   ComAtprotoServerRefreshSession: 'com.atproto.server.refreshSession',
   ComAtprotoServerRequestAccountDelete:
     'com.atproto.server.requestAccountDelete',
+  ComAtprotoServerRequestEmailConfirmation:
+    'com.atproto.server.requestEmailConfirmation',
+  ComAtprotoServerRequestEmailUpdate: 'com.atproto.server.requestEmailUpdate',
   ComAtprotoServerRequestPasswordReset:
     'com.atproto.server.requestPasswordReset',
   ComAtprotoServerResetPassword: 'com.atproto.server.resetPassword',
   ComAtprotoServerRevokeAppPassword: 'com.atproto.server.revokeAppPassword',
+  ComAtprotoServerUpdateEmail: 'com.atproto.server.updateEmail',
   ComAtprotoSyncGetBlob: 'com.atproto.sync.getBlob',
   ComAtprotoSyncGetBlocks: 'com.atproto.sync.getBlocks',
   ComAtprotoSyncGetCheckout: 'com.atproto.sync.getCheckout',

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/createSession.ts

@@ -23,6 +23,7 @@ export interface OutputSchema {
   handle: string
   did: string
   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/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/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/services/actor/index.ts

@@ -83,15 +83,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 +101,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 +114,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/util/search.ts

@@ -7,17 +7,17 @@ import { GenericKeyset, paginate } from '../../db/pagination'
 export const getUserSearchQuery = (
   db: Database,
   opts: {
-    term: string
+    query: string
     limit: number
     cursor?: string
     includeSoftDeleted?: boolean
   },
 ) => {
   const { ref } = db.db.dynamic
-  const { term, limit, cursor, includeSoftDeleted } = opts
+  const { query, limit, cursor, includeSoftDeleted } = opts
   // Matching user accounts based on handle
-  const distanceAccount = distance(term, ref('handle'))
-  let accountsQb = getMatchingAccountsQb(db, { term, includeSoftDeleted })
+  const distanceAccount = distance(query, ref('handle'))
+  let accountsQb = getMatchingAccountsQb(db, { query, includeSoftDeleted })
   accountsQb = paginate(accountsQb, {
     limit,
     cursor,
@@ -25,8 +25,8 @@ export const getUserSearchQuery = (
     keyset: new SearchKeyset(distanceAccount, ref('actor.did')),
   })
   // Matching profiles based on display name
-  const distanceProfile = distance(term, ref('displayName'))
-  let profilesQb = getMatchingProfilesQb(db, { term, includeSoftDeleted })
+  const distanceProfile = distance(query, ref('displayName'))
+  let profilesQb = getMatchingProfilesQb(db, { query, includeSoftDeleted })
   profilesQb = paginate(profilesQb, {
     limit,
     cursor,
@@ -46,18 +46,18 @@ export const getUserSearchQuery = (
 export const getUserSearchQuerySimple = (
   db: Database,
   opts: {
-    term: string
+    query: string
     limit: number
   },
 ) => {
   const { ref } = db.db.dynamic
-  const { term, limit } = opts
+  const { query, limit } = opts
   // Matching user accounts based on handle
-  const accountsQb = getMatchingAccountsQb(db, { term })
+  const accountsQb = getMatchingAccountsQb(db, { query })
     .orderBy('distance', 'asc')
     .limit(limit)
   // Matching profiles based on display name
-  const profilesQb = getMatchingProfilesQb(db, { term })
+  const profilesQb = getMatchingProfilesQb(db, { query })
     .orderBy('distance', 'asc')
     .limit(limit)
   // Combine and paginate result set
@@ -71,29 +71,29 @@ export const getUserSearchQuerySimple = (
 // Matching user accounts based on handle
 const getMatchingAccountsQb = (
   db: Database,
-  opts: { term: string; includeSoftDeleted?: boolean },
+  opts: { query: string; includeSoftDeleted?: boolean },
 ) => {
   const { ref } = db.db.dynamic
-  const { term, includeSoftDeleted } = opts
-  const distanceAccount = distance(term, ref('handle'))
+  const { query, includeSoftDeleted } = opts
+  const distanceAccount = distance(query, ref('handle'))
   return db.db
     .selectFrom('actor')
     .if(!includeSoftDeleted, (qb) =>
       qb.where(notSoftDeletedClause(ref('actor'))),
     )
     .where('actor.handle', 'is not', null)
-    .where(similar(term, ref('handle'))) // Coarse filter engaging trigram index
+    .where(similar(query, ref('handle'))) // Coarse filter engaging trigram index
     .select(['actor.did as did', distanceAccount.as('distance')])
 }
 
 // Matching profiles based on display name
 const getMatchingProfilesQb = (
   db: Database,
-  opts: { term: string; includeSoftDeleted?: boolean },
+  opts: { query: string; includeSoftDeleted?: boolean },
 ) => {
   const { ref } = db.db.dynamic
-  const { term, includeSoftDeleted } = opts
-  const distanceProfile = distance(term, ref('displayName'))
+  const { query, includeSoftDeleted } = opts
+  const distanceProfile = distance(query, ref('displayName'))
   return db.db
     .selectFrom('profile')
     .innerJoin('actor', 'actor.did', 'profile.creator')
@@ -101,7 +101,7 @@ const getMatchingProfilesQb = (
       qb.where(notSoftDeletedClause(ref('actor'))),
     )
     .where('actor.handle', 'is not', null)
-    .where(similar(term, ref('displayName'))) // Coarse filter engaging trigram index
+    .where(similar(query, ref('displayName'))) // Coarse filter engaging trigram index
     .select(['profile.creator as did', distanceProfile.as('distance')])
 }
 
@@ -133,15 +133,16 @@ const combineAccountsAndProfilesQb = (
 }
 
 // Remove leading @ in case a handle is input that way
-export const cleanTerm = (term: string) => term.trim().replace(/^@/g, '')
+export const cleanQuery = (query: string) => query.trim().replace(/^@/g, '')
 
-// Uses pg_trgm strict word similarity to check similarity between a search term and a stored value
-const distance = (term: string, ref: DbRef) =>
-  sql<number>`(${term} <<-> ${ref})`
+// Uses pg_trgm strict word similarity to check similarity between a search query and a stored value
+const distance = (query: string, ref: DbRef) =>
+  sql<number>`(${query} <<-> ${ref})`
 
 // Can utilize trigram index to match on strict word similarity.
 // The word_similarity_threshold is set to .4 (i.e. distance < .6) in db/index.ts.
-const similar = (term: string, ref: DbRef) => sql<boolean>`(${term} <% ${ref})`
+const similar = (query: string, ref: DbRef) =>
+  sql<boolean>`(${query} <% ${ref})`
 
 type Result = { distance: number; did: string }
 type LabeledResult = { primary: number; secondary: string }