@atproto/bsky 0.0.8 → 0.0.10

package/src/lexicon/index.ts

@@ -89,6 +89,7 @@ import * as AppBskyFeedGetPosts from './types/app/bsky/feed/getPosts'
 import * as AppBskyFeedGetRepostedBy from './types/app/bsky/feed/getRepostedBy'
 import * as AppBskyFeedGetSuggestedFeeds from './types/app/bsky/feed/getSuggestedFeeds'
 import * as AppBskyFeedGetTimeline from './types/app/bsky/feed/getTimeline'
+import * as AppBskyFeedSearchPosts from './types/app/bsky/feed/searchPosts'
 import * as AppBskyGraphGetBlocks from './types/app/bsky/graph/getBlocks'
 import * as AppBskyGraphGetFollowers from './types/app/bsky/graph/getFollowers'
 import * as AppBskyGraphGetFollows from './types/app/bsky/graph/getFollows'
@@ -106,10 +107,11 @@ import * as AppBskyNotificationGetUnreadCount from './types/app/bsky/notificatio
 import * as AppBskyNotificationListNotifications from './types/app/bsky/notification/listNotifications'
 import * as AppBskyNotificationRegisterPush from './types/app/bsky/notification/registerPush'
 import * as AppBskyNotificationUpdateSeen from './types/app/bsky/notification/updateSeen'
-import * as AppBskyUnspeccedApplyLabels from './types/app/bsky/unspecced/applyLabels'
 import * as AppBskyUnspeccedGetPopular from './types/app/bsky/unspecced/getPopular'
 import * as AppBskyUnspeccedGetPopularFeedGenerators from './types/app/bsky/unspecced/getPopularFeedGenerators'
 import * as AppBskyUnspeccedGetTimelineSkeleton from './types/app/bsky/unspecced/getTimelineSkeleton'
+import * as AppBskyUnspeccedSearchActorsSkeleton from './types/app/bsky/unspecced/searchActorsSkeleton'
+import * as AppBskyUnspeccedSearchPostsSkeleton from './types/app/bsky/unspecced/searchPostsSkeleton'
 
 export const COM_ATPROTO_ADMIN = {
   DefsTakedown: 'com.atproto.admin.defs#takedown',
@@ -1168,6 +1170,17 @@ export class FeedNS {
     const nsid = 'app.bsky.feed.getTimeline' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
+
+  searchPosts<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppBskyFeedSearchPosts.Handler<ExtractAuth<AV>>,
+      AppBskyFeedSearchPosts.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.bsky.feed.searchPosts' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
 }
 
 export class GraphNS {
@@ -1388,17 +1401,6 @@ export class UnspeccedNS {
     this._server = server
   }
 
-  applyLabels<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyUnspeccedApplyLabels.Handler<ExtractAuth<AV>>,
-      AppBskyUnspeccedApplyLabels.HandlerReqCtx<ExtractAuth<AV>>
-    >,
-  ) {
-    const nsid = 'app.bsky.unspecced.applyLabels' // @ts-ignore
-    return this._server.xrpc.method(nsid, cfg)
-  }
-
   getPopular<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,
@@ -1431,6 +1433,28 @@ export class UnspeccedNS {
     const nsid = 'app.bsky.unspecced.getTimelineSkeleton' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
+
+  searchActorsSkeleton<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppBskyUnspeccedSearchActorsSkeleton.Handler<ExtractAuth<AV>>,
+      AppBskyUnspeccedSearchActorsSkeleton.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.bsky.unspecced.searchActorsSkeleton' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  searchPostsSkeleton<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppBskyUnspeccedSearchPostsSkeleton.Handler<ExtractAuth<AV>>,
+      AppBskyUnspeccedSearchPostsSkeleton.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.bsky.unspecced.searchPostsSkeleton' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
 }
 
 type SharedRateLimitOpts<T> = {

package/src/lexicon/lexicons.ts

@@ -1113,6 +1113,10 @@ export const schemaDict = {
           properties: {
             term: {
               type: 'string',
+              description: "DEPRECATED: use 'q' instead",
+            },
+            q: {
+              type: 'string',
             },
             invitedBy: {
               type: 'string',
@@ -3998,18 +4002,24 @@ export const schemaDict = {
     defs: {
       main: {
         type: 'query',
-        description: 'Find actors matching search criteria.',
+        description: 'Find actors (profiles) matching search criteria.',
         parameters: {
           type: 'params',
           properties: {
             term: {
               type: 'string',
+              description: "DEPRECATED: use 'q' instead",
+            },
+            q: {
+              type: 'string',
+              description:
+                'search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended',
             },
             limit: {
               type: 'integer',
               minimum: 1,
               maximum: 100,
-              default: 50,
+              default: 25,
             },
             cursor: {
               type: 'string',
@@ -4050,12 +4060,17 @@ export const schemaDict = {
           properties: {
             term: {
               type: 'string',
+              description: "DEPRECATED: use 'q' instead",
+            },
+            q: {
+              type: 'string',
+              description: 'search query prefix; not a full query string',
             },
             limit: {
               type: 'integer',
               minimum: 1,
               maximum: 100,
-              default: 50,
+              default: 10,
             },
           },
         },
@@ -5713,6 +5728,67 @@ export const schemaDict = {
       },
     },
   },
+  AppBskyFeedSearchPosts: {
+    lexicon: 1,
+    id: 'app.bsky.feed.searchPosts',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Find posts matching search criteria',
+        parameters: {
+          type: 'params',
+          required: ['q'],
+          properties: {
+            q: {
+              type: 'string',
+              description:
+                'search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended',
+            },
+            limit: {
+              type: 'integer',
+              minimum: 1,
+              maximum: 100,
+              default: 25,
+            },
+            cursor: {
+              type: 'string',
+              description:
+                'optional pagination mechanism; may not necessarily allow scrolling through entire result set',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['posts'],
+            properties: {
+              cursor: {
+                type: 'string',
+              },
+              hitsTotal: {
+                type: 'integer',
+                description:
+                  'count of search hits. optional, may be rounded/truncated, and may not be possible to paginate through all hits',
+              },
+              posts: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.bsky.feed.defs#postView',
+                },
+              },
+            },
+          },
+        },
+        errors: [
+          {
+            name: 'BadQueryString',
+          },
+        ],
+      },
+    },
+  },
   AppBskyFeedThreadgate: {
     lexicon: 1,
     id: 'app.bsky.feed.threadgate',
@@ -6829,27 +6905,27 @@ export const schemaDict = {
       },
     },
   },
-  AppBskyUnspeccedApplyLabels: {
+  AppBskyUnspeccedDefs: {
     lexicon: 1,
-    id: 'app.bsky.unspecced.applyLabels',
+    id: 'app.bsky.unspecced.defs',
     defs: {
-      main: {
-        type: 'procedure',
-        description: 'Allow a labeler to apply labels directly.',
-        input: {
-          encoding: 'application/json',
-          schema: {
-            type: 'object',
-            required: ['labels'],
-            properties: {
-              labels: {
-                type: 'array',
-                items: {
-                  type: 'ref',
-                  ref: 'lex:com.atproto.label.defs#label',
-                },
-              },
-            },
+      skeletonSearchPost: {
+        type: 'object',
+        required: ['uri'],
+        properties: {
+          uri: {
+            type: 'string',
+            format: 'at-uri',
+          },
+        },
+      },
+      skeletonSearchActor: {
+        type: 'object',
+        required: ['did'],
+        properties: {
+          did: {
+            type: 'string',
+            format: 'did',
           },
         },
       },
@@ -6997,6 +7073,132 @@ export const schemaDict = {
       },
     },
   },
+  AppBskyUnspeccedSearchActorsSkeleton: {
+    lexicon: 1,
+    id: 'app.bsky.unspecced.searchActorsSkeleton',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Backend Actors (profile) search, returning only skeleton',
+        parameters: {
+          type: 'params',
+          required: ['q'],
+          properties: {
+            q: {
+              type: 'string',
+              description:
+                'search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. For typeahead search, only simple term match is supported, not full syntax',
+            },
+            typeahead: {
+              type: 'boolean',
+              description: "if true, acts as fast/simple 'typeahead' query",
+            },
+            limit: {
+              type: 'integer',
+              minimum: 1,
+              maximum: 100,
+              default: 25,
+            },
+            cursor: {
+              type: 'string',
+              description:
+                'optional pagination mechanism; may not necessarily allow scrolling through entire result set',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['actors'],
+            properties: {
+              cursor: {
+                type: 'string',
+              },
+              hitsTotal: {
+                type: 'integer',
+                description:
+                  'count of search hits. optional, may be rounded/truncated, and may not be possible to paginate through all hits',
+              },
+              actors: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.bsky.unspecced.defs#skeletonSearchActor',
+                },
+              },
+            },
+          },
+        },
+        errors: [
+          {
+            name: 'BadQueryString',
+          },
+        ],
+      },
+    },
+  },
+  AppBskyUnspeccedSearchPostsSkeleton: {
+    lexicon: 1,
+    id: 'app.bsky.unspecced.searchPostsSkeleton',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Backend Posts search, returning only skeleton',
+        parameters: {
+          type: 'params',
+          required: ['q'],
+          properties: {
+            q: {
+              type: 'string',
+              description:
+                'search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended',
+            },
+            limit: {
+              type: 'integer',
+              minimum: 1,
+              maximum: 100,
+              default: 25,
+            },
+            cursor: {
+              type: 'string',
+              description:
+                'optional pagination mechanism; may not necessarily allow scrolling through entire result set',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['posts'],
+            properties: {
+              cursor: {
+                type: 'string',
+              },
+              hitsTotal: {
+                type: 'integer',
+                description:
+                  'count of search hits. optional, may be rounded/truncated, and may not be possible to paginate through all hits',
+              },
+              posts: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.bsky.unspecced.defs#skeletonSearchPost',
+                },
+              },
+            },
+          },
+        },
+        errors: [
+          {
+            name: 'BadQueryString',
+          },
+        ],
+      },
+    },
+  },
 }
 export const schemas: LexiconDoc[] = Object.values(schemaDict) as LexiconDoc[]
 export const lexicons: Lexicons = new Lexicons(schemas)
@@ -7103,6 +7305,7 @@ export const ids = {
   AppBskyFeedLike: 'app.bsky.feed.like',
   AppBskyFeedPost: 'app.bsky.feed.post',
   AppBskyFeedRepost: 'app.bsky.feed.repost',
+  AppBskyFeedSearchPosts: 'app.bsky.feed.searchPosts',
   AppBskyFeedThreadgate: 'app.bsky.feed.threadgate',
   AppBskyGraphBlock: 'app.bsky.graph.block',
   AppBskyGraphDefs: 'app.bsky.graph.defs',
@@ -7130,9 +7333,12 @@ export const ids = {
   AppBskyNotificationRegisterPush: 'app.bsky.notification.registerPush',
   AppBskyNotificationUpdateSeen: 'app.bsky.notification.updateSeen',
   AppBskyRichtextFacet: 'app.bsky.richtext.facet',
-  AppBskyUnspeccedApplyLabels: 'app.bsky.unspecced.applyLabels',
+  AppBskyUnspeccedDefs: 'app.bsky.unspecced.defs',
   AppBskyUnspeccedGetPopular: 'app.bsky.unspecced.getPopular',
   AppBskyUnspeccedGetPopularFeedGenerators:
     'app.bsky.unspecced.getPopularFeedGenerators',
   AppBskyUnspeccedGetTimelineSkeleton: 'app.bsky.unspecced.getTimelineSkeleton',
+  AppBskyUnspeccedSearchActorsSkeleton:
+    'app.bsky.unspecced.searchActorsSkeleton',
+  AppBskyUnspeccedSearchPostsSkeleton: 'app.bsky.unspecced.searchPostsSkeleton',
 }

package/src/lexicon/types/app/bsky/actor/searchActors.ts

@@ -10,7 +10,10 @@ import { HandlerAuth } from '@atproto/xrpc-server'
 import * as AppBskyActorDefs from './defs'
 
 export interface QueryParams {
+  /** DEPRECATED: use 'q' instead */
   term?: string
+  /** search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended */
+  q?: string
   limit: number
   cursor?: string
 }

package/src/lexicon/types/app/bsky/actor/searchActorsTypeahead.ts

@@ -10,7 +10,10 @@ import { HandlerAuth } from '@atproto/xrpc-server'
 import * as AppBskyActorDefs from './defs'
 
 export interface QueryParams {
+  /** DEPRECATED: use 'q' instead */
   term?: string
+  /** search query prefix; not a full query string */
+  q?: string
   limit: number
 }
 

package/src/lexicon/types/app/bsky/feed/searchPosts.ts

@@ -0,0 +1,54 @@
+/**
+ * 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'
+import * as AppBskyFeedDefs from './defs'
+
+export interface QueryParams {
+  /** search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended */
+  q: string
+  limit: number
+  /** optional pagination mechanism; may not necessarily allow scrolling through entire result set */
+  cursor?: string
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  cursor?: string
+  /** count of search hits. optional, may be rounded/truncated, and may not be possible to paginate through all hits */
+  hitsTotal?: number
+  posts: AppBskyFeedDefs.PostView[]
+  [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
+  error?: 'BadQueryString'
+}
+
+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/app/bsky/unspecced/defs.ts

@@ -0,0 +1,41 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+
+export interface SkeletonSearchPost {
+  uri: string
+  [k: string]: unknown
+}
+
+export function isSkeletonSearchPost(v: unknown): v is SkeletonSearchPost {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.unspecced.defs#skeletonSearchPost'
+  )
+}
+
+export function validateSkeletonSearchPost(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.unspecced.defs#skeletonSearchPost', v)
+}
+
+export interface SkeletonSearchActor {
+  did: string
+  [k: string]: unknown
+}
+
+export function isSkeletonSearchActor(v: unknown): v is SkeletonSearchActor {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.unspecced.defs#skeletonSearchActor'
+  )
+}
+
+export function validateSkeletonSearchActor(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.unspecced.defs#skeletonSearchActor', v)
+}

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

@@ -0,0 +1,56 @@
+/**
+ * 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'
+import * as AppBskyUnspeccedDefs from './defs'
+
+export interface QueryParams {
+  /** search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. For typeahead search, only simple term match is supported, not full syntax */
+  q: string
+  /** if true, acts as fast/simple 'typeahead' query */
+  typeahead?: boolean
+  limit: number
+  /** optional pagination mechanism; may not necessarily allow scrolling through entire result set */
+  cursor?: string
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  cursor?: string
+  /** count of search hits. optional, may be rounded/truncated, and may not be possible to paginate through all hits */
+  hitsTotal?: number
+  actors: AppBskyUnspeccedDefs.SkeletonSearchActor[]
+  [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
+  error?: 'BadQueryString'
+}
+
+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/app/bsky/unspecced/searchPostsSkeleton.ts

@@ -0,0 +1,54 @@
+/**
+ * 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'
+import * as AppBskyUnspeccedDefs from './defs'
+
+export interface QueryParams {
+  /** search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended */
+  q: string
+  limit: number
+  /** optional pagination mechanism; may not necessarily allow scrolling through entire result set */
+  cursor?: string
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  cursor?: string
+  /** count of search hits. optional, may be rounded/truncated, and may not be possible to paginate through all hits */
+  hitsTotal?: number
+  posts: AppBskyUnspeccedDefs.SkeletonSearchPost[]
+  [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
+  error?: 'BadQueryString'
+}
+
+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/admin/searchRepos.ts

@@ -10,7 +10,9 @@ import { HandlerAuth } from '@atproto/xrpc-server'
 import * as ComAtprotoAdminDefs from './defs'
 
 export interface QueryParams {
+  /** DEPRECATED: use 'q' instead */
   term?: string
+  q?: string
   invitedBy?: string
   limit: number
   cursor?: string

package/src/services/indexing/plugins/block.ts

@@ -1,11 +1,11 @@
 import { Selectable } from 'kysely'
 import { AtUri } from '@atproto/syntax'
+import { toSimplifiedISOSafe } from '@atproto/common'
 import { CID } from 'multiformats/cid'
 import * as Block from '../../../lexicon/types/app/bsky/graph/block'
 import * as lex from '../../../lexicon/lexicons'
 import { DatabaseSchema, DatabaseSchemaType } from '../../../db/database-schema'
 import RecordProcessor from '../processor'
-import { toSimplifiedISOSafe } from '../util'
 import { PrimaryDatabase } from '../../../db'
 import { BackgroundQueue } from '../../../background'
 import { NotificationServer } from '../../../notifications'

package/src/services/indexing/plugins/feed-generator.ts

@@ -1,5 +1,6 @@
 import { Selectable } from 'kysely'
 import { AtUri } from '@atproto/syntax'
+import { toSimplifiedISOSafe } from '@atproto/common'
 import { CID } from 'multiformats/cid'
 import * as FeedGenerator from '../../../lexicon/types/app/bsky/feed/generator'
 import * as lex from '../../../lexicon/lexicons'
@@ -7,7 +8,6 @@ import { PrimaryDatabase } from '../../../db'
 import { DatabaseSchema, DatabaseSchemaType } from '../../../db/database-schema'
 import { BackgroundQueue } from '../../../background'
 import RecordProcessor from '../processor'
-import { toSimplifiedISOSafe } from '../util'
 import { NotificationServer } from '../../../notifications'
 
 const lexId = lex.ids.AppBskyFeedGenerator