feat: add searchActors api

__generated__/index.ts

···
 import * as SocialGrainGalleryGetGallery from './types/social/grain/gallery/getGallery.ts'
 import * as SocialGrainFeedGetTimeline from './types/social/grain/feed/getTimeline.ts'
 import * as SocialGrainActorGetProfile from './types/social/grain/actor/getProfile.ts'
+import * as SocialGrainActorSearchActors from './types/social/grain/actor/searchActors.ts'
 
 export const APP_BSKY_GRAPH = {
   DefsModlist: 'app.bsky.graph.defs#modlist',
···
     >,
   ) {
     const nsid = 'social.grain.actor.getProfile' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  searchActors<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainActorSearchActors.Handler<ExtractAuth<AV>>,
+      SocialGrainActorSearchActors.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.actor.searchActors' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 }

__generated__/lexicons.ts

···
       },
     },
   },
+  SocialGrainActorSearchActors: {
+    lexicon: 1,
+    id: 'social.grain.actor.searchActors',
+    defs: {
+      main: {
+        type: 'query',
+        description:
+          'Find actors (profiles) matching search criteria. Does not require auth.',
+        parameters: {
+          type: 'params',
+          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',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['actors'],
+            properties: {
+              cursor: {
+                type: 'string',
+              },
+              actors: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:social.grain.actor.defs#profileView',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   SocialGrainActorProfile: {
     lexicon: 1,
     id: 'social.grain.actor.profile',
···
   SocialGrainFavorite: 'social.grain.favorite',
   SocialGrainActorDefs: 'social.grain.actor.defs',
   SocialGrainActorGetProfile: 'social.grain.actor.getProfile',
+  SocialGrainActorSearchActors: 'social.grain.actor.searchActors',
   SocialGrainActorProfile: 'social.grain.actor.profile',
   SocialGrainPhotoDefs: 'social.grain.photo.defs',
   SocialGrainPhotoExif: 'social.grain.photo.exif',

__generated__/types/social/grain/actor/searchActors.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from "npm:@atproto/xrpc-server";
+import express from "npm:express";
+import { validate as _validate } from "../../../../lexicons.ts";
+import { is$typed as _is$typed } from "../../../../util.ts";
+import type * as SocialGrainActorDefs from "./defs.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.actor.searchActors";
+
+export interface QueryParams {
+  /** Search query string. Syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. */
+  q?: string;
+  limit: number;
+  cursor?: string;
+}
+
+export type InputSchema = undefined;
+
+export interface OutputSchema {
+  cursor?: string;
+  actors: SocialGrainActorDefs.ProfileView[];
+}
+
+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;

lexicons/social/grain/actor/searchActors.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.actor.searchActors",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Find actors (profiles) matching search criteria. Does not require auth.",
+      "parameters": {
+        "type": "params",
+        "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" }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["actors"],
+          "properties": {
+            "cursor": { "type": "string" },
+            "actors": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "social.grain.actor.defs#profileView"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

src/api/mod.ts

···
+import { ProfileView } from "$lexicon/types/social/grain/actor/defs.ts";
 import {
   OutputSchema as GetProfileOutputSchema,
   QueryParams as GetProfileQueryParams,
 } from "$lexicon/types/social/grain/actor/getProfile.ts";
+import {
+  OutputSchema as SearchActorsOutputSchema,
+  QueryParams as SearchActorsQueryParams,
+} from "$lexicon/types/social/grain/actor/searchActors.ts";
 import {
   OutputSchema as GetTimelineOutputSchema,
 } from "$lexicon/types/social/grain/feed/getTimeline.ts";
···
 } from "$lexicon/types/social/grain/notification/getNotifications.ts";
 import { AtUri } from "@atproto/syntax";
 import { BffMiddleware, OAUTH_ROUTES, route } from "@bigmoves/bff";
-import { getActorGalleries, getActorProfileDetailed } from "../lib/actor.ts";
+import {
+  getActorGalleries,
+  getActorProfileDetailed,
+  searchActors,
+} from "../lib/actor.ts";
 import { BadRequestError } from "../lib/errors.ts";
 import { getGallery } from "../lib/gallery.ts";
 import { getNotifications } from "../lib/notifications.ts";
···
       );
     },
   ),
+  route(
+    "/xrpc/social.grain.actor.searchActors",
+    (req, _params, ctx) => {
+      const url = new URL(req.url);
+      const { q } = searchActorsQueryParams(url);
+      let results: ProfileView[] = [];
+      if (!q) {
+        results = [];
+      } else {
+        results = searchActors(
+          q,
+          ctx,
+        );
+      }
+      return ctx.json(
+        { actors: results } as SearchActorsOutputSchema,
+      );
+    },
+  ),
 ];
 
 function getProfileQueryParams(url: URL): GetProfileQueryParams {
···
   const uri = url.searchParams.get("uri");
   if (!uri) throw new BadRequestError("Missing uri parameter");
   return { uri };
+}
+
+function searchActorsQueryParams(url: URL): SearchActorsQueryParams {
+  const q = url.searchParams.get("q");
+  if (!q) throw new BadRequestError("Missing q parameter");
+  const limit = parseInt(url.searchParams.get("limit") ?? "50", 10);
+  if (isNaN(limit) || limit <= 0) {
+    throw new BadRequestError("Invalid limit parameter");
+  }
+  const cursor = url.searchParams.get("cursor") ?? undefined;
+  return { q, limit, cursor };
 }
 
 // function getNotificationsQueryParams(url: URL): GetNotificationsQueryParams {

src/lib/actor.ts

···
     return profileToView(profile, handle);
   });
 }
+
+export function searchActors(query: string, ctx: BffContext) {
+  const actors = ctx.indexService.searchActors(query);
+
+  const { items } = ctx.indexService.getRecords<WithBffMeta<GrainProfile>>(
+    "social.grain.actor.profile",
+    {
+      where: {
+        OR: [
+          ...(actors.length > 0
+            ? [{
+              field: "did",
+              in: actors.map((actor) => actor.did),
+            }]
+            : []),
+          {
+            field: "displayName",
+            contains: query,
+          },
+          {
+            field: "did",
+            contains: query,
+          },
+        ],
+      },
+    },
+  );
+
+  const profileMap = new Map<string, WithBffMeta<GrainProfile>>();
+  for (const item of items) {
+    profileMap.set(item.did, item);
+  }
+
+  const actorMap = new Map();
+  actors.forEach((actor) => {
+    actorMap.set(actor.did, actor);
+  });
+
+  const profileViews = [];
+
+  for (const actor of actors) {
+    if (profileMap.has(actor.did)) {
+      const profile = profileMap.get(actor.did)!;
+      profileViews.push(profileToView(profile, actor.handle));
+    }
+  }
+
+  for (const profile of items) {
+    if (!actorMap.has(profile.did)) {
+      const handle = ctx.indexService.getActor(profile.did)?.handle;
+      if (!handle) continue;
+      profileViews.push(profileToView(profile, handle));
+    }
+  }
+
+  return profileViews;
+}

src/routes/explore.tsx

···
 import { ProfileView } from "$lexicon/types/social/grain/actor/defs.ts";
-import { Record as Profile } from "$lexicon/types/social/grain/actor/profile.ts";
 import { Un$Typed } from "$lexicon/util.ts";
-import { BffContext, RouteHandler, WithBffMeta } from "@bigmoves/bff";
+import { BffContext, RouteHandler } from "@bigmoves/bff";
 import { ComponentChildren } from "preact";
 import { ActorAvatar } from "../components/ActorAvatar.tsx";
 import { Input } from "../components/Input.tsx";
 import { LabelerAvatar } from "../components/LabelerAvatar.tsx";
-import { profileToView } from "../lib/actor.ts";
+import { searchActors } from "../lib/actor.ts";
 import { getPageMeta } from "../meta.ts";
 import type { State } from "../state.ts";
 
···
   const query = url.searchParams.get("q") ?? "";
   ctx.state.meta = [{ title: "Explore — Grain" }, ...getPageMeta("/explore")];
   if (query) {
-    const profileViews = doSearch(query, ctx);
+    const profileViews = searchActors(query, ctx);
     if (req.headers.get("hx-request")) {
       if (profileViews.length === 0) {
         return ctx.html(<p>No results for "{query}"</p>);
···
     </>
   );
 }
-
-function doSearch(query: string, ctx: BffContext<State>) {
-  const actors = ctx.indexService.searchActors(query);
-
-  const { items } = ctx.indexService.getRecords<WithBffMeta<Profile>>(
-    "social.grain.actor.profile",
-    {
-      where: {
-        OR: [
-          ...(actors.length > 0
-            ? [{
-              field: "did",
-              in: actors.map((actor) => actor.did),
-            }]
-            : []),
-          {
-            field: "displayName",
-            contains: query,
-          },
-          {
-            field: "did",
-            contains: query,
-          },
-        ],
-      },
-    },
-  );
-
-  const profileMap = new Map<string, WithBffMeta<Profile>>();
-  for (const item of items) {
-    profileMap.set(item.did, item);
-  }
-
-  const actorMap = new Map();
-  actors.forEach((actor) => {
-    actorMap.set(actor.did, actor);
-  });
-
-  const profileViews = [];
-
-  for (const actor of actors) {
-    if (profileMap.has(actor.did)) {
-      const profile = profileMap.get(actor.did)!;
-      profileViews.push(profileToView(profile, actor.handle));
-    }
-  }
-
-  for (const profile of items) {
-    if (!actorMap.has(profile.did)) {
-      const handle = ctx.indexService.getActor(profile.did)?.handle;
-      if (!handle) continue;
-      profileViews.push(profileToView(profile, handle));
-    }
-  }
-
-  return profileViews;
-}