opencode-discord-bot 0.1.0 → 0.2.0

package/src/Discord/DiscordSearchRest.ts

@@ -0,0 +1,232 @@
+import type { DiscordAttachment, DiscordMessage, DiscordScope, DiscordSearchQuery, DiscordSearchResult } from "../Schema.ts"
+import { DiscordError } from "./DiscordPort.ts"
+import { type RawDiscordOptions, rawDiscordRequest, rawDiscordSearchRequest } from "./DiscordRest.ts"
+
+type NicknameResolver = (scope: DiscordScope, userId: string) => Promise<string | undefined>
+
+const isRecord = (value: unknown): value is Readonly<Record<string, unknown>> =>
+  typeof value === "object" && value !== null && !Array.isArray(value)
+
+const stringField = (value: unknown, key: string): string | undefined => {
+  if (!isRecord(value)) return undefined
+  const field = value[key]
+  return typeof field === "string" && field.length > 0 ? field : undefined
+}
+
+const userIdFromMemberSearch = (data: unknown): string | undefined => {
+  if (!Array.isArray(data)) return undefined
+  const first = data[0]
+  if (!isRecord(first)) return undefined
+  return stringField(first.user, "id")
+}
+
+const channelIdFromGuildChannels = (data: unknown, name: string): string | undefined => {
+  if (!Array.isArray(data)) return undefined
+  const normalized = name.toLowerCase().replace(/^#/, "")
+  for (const channel of data) {
+    if (!isRecord(channel)) continue
+    const channelName = stringField(channel, "name")
+    if (channelName?.toLowerCase() === normalized) return stringField(channel, "id")
+  }
+  return undefined
+}
+
+const resolveUserName = async (raw: RawDiscordOptions | undefined, scope: DiscordScope, name: string): Promise<string> => {
+  const params = new URLSearchParams({ query: name, limit: "1" })
+  const result = await rawDiscordRequest(raw, `/guilds/${scope.guildId}/members/search?${params}`, { method: "GET" })
+  const id = userIdFromMemberSearch(result)
+  if (id === undefined) throw new DiscordError({ message: `Unable to resolve Discord user ${name}; use an ID or mention` })
+  return id
+}
+
+const resolveChannelName = async (raw: RawDiscordOptions | undefined, scope: DiscordScope, name: string): Promise<string> => {
+  const result = await rawDiscordRequest(raw, `/guilds/${scope.guildId}/channels`, { method: "GET" })
+  const id = channelIdFromGuildChannels(result, name)
+  if (id === undefined) throw new DiscordError({ message: `Unable to resolve Discord channel ${name}; use an ID or channel mention` })
+  return id
+}
+
+const resolveSearchQuery = async (
+  raw: RawDiscordOptions | undefined,
+  scope: DiscordScope,
+  query: DiscordSearchQuery
+): Promise<DiscordSearchQuery> => {
+  const [authors, channels, mentions, repliedToUsers] = await Promise.all([
+    Promise.all(query.authorNames.map((name) => resolveUserName(raw, scope, name))),
+    Promise.all(query.channelNames.map((name) => resolveChannelName(raw, scope, name))),
+    Promise.all(query.mentionNames.map((name) => resolveUserName(raw, scope, name))),
+    Promise.all(query.repliedToUserNames.map((name) => resolveUserName(raw, scope, name)))
+  ])
+  return {
+    ...query,
+    authors: [...query.authors, ...authors],
+    authorNames: [],
+    channels: [...query.channels, ...channels],
+    channelNames: [],
+    mentions: [...query.mentions, ...mentions],
+    mentionNames: [],
+    repliedToUsers: [...query.repliedToUsers, ...repliedToUsers],
+    repliedToUserNames: []
+  }
+}
+
+const rawAttachment = (item: unknown): DiscordAttachment | undefined => {
+  if (!isRecord(item)) return undefined
+  const id = stringField(item, "id")
+  const filename = stringField(item, "filename")
+  const url = stringField(item, "url") ?? ""
+  const size = typeof item.size === "number" && Number.isFinite(item.size) && item.size >= 0 ? item.size : 0
+  const contentType = stringField(item, "content_type")
+  if (id === undefined || filename === undefined) return undefined
+  return { id, filename, ...(contentType === undefined ? {} : { contentType }), size, url }
+}
+
+const rawUserIds = (items: unknown): ReadonlyArray<string> =>
+  Array.isArray(items)
+    ? items.flatMap((item) => {
+        const id = stringField(item, "id")
+        return id === undefined ? [] : [id]
+      })
+    : []
+
+const rawStringArray = (items: unknown): ReadonlyArray<string> =>
+  Array.isArray(items) ? items.flatMap((item) => (typeof item === "string" ? [item] : [])) : []
+
+const threadParents = (items: unknown): ReadonlyMap<string, string> => {
+  const result = new Map<string, string>()
+  if (!Array.isArray(items)) return result
+  for (const thread of items) {
+    const id = stringField(thread, "id")
+    const parentId = stringField(thread, "parent_id")
+    if (id !== undefined && parentId !== undefined) result.set(id, parentId)
+  }
+  return result
+}
+
+const fromRawDiscordMessage = (
+  scope: DiscordScope,
+  data: unknown,
+  threadParentById: ReadonlyMap<string, string>
+): DiscordMessage | undefined => {
+  if (!isRecord(data)) return undefined
+  const id = stringField(data, "id")
+  const channelId = stringField(data, "channel_id")
+  const timestamp = stringField(data, "timestamp")
+  const author = data.author
+  const authorId = stringField(author, "id")
+  if (id === undefined || channelId === undefined || timestamp === undefined || authorId === undefined) return undefined
+  const parentId = threadParentById.get(channelId)
+  const content = typeof data.content === "string" ? data.content : ""
+  const attachments = Array.isArray(data.attachments) ? data.attachments : []
+  return {
+    id,
+    guildId: scope.guildId,
+    channelId: parentId ?? channelId,
+    ...(parentId === undefined ? {} : { threadId: channelId }),
+    author: {
+      id: authorId,
+      displayName: stringField(author, "global_name") ?? stringField(author, "username") ?? authorId,
+      isBot: isRecord(author) && author.bot === true
+    },
+    content,
+    timestamp,
+    mentions: rawUserIds(data.mentions),
+    roleMentions: rawStringArray(data.mention_roles),
+    everyoneMention: data.mention_everyone === true,
+    hereMention: content.includes("@here"),
+    attachments: attachments.flatMap((item) => {
+      const attachment = rawAttachment(item)
+      return attachment === undefined ? [] : [attachment]
+    }),
+    reactions: [],
+    channelType: "guild",
+    ...(typeof data.type === "number" && data.type !== 0 ? { isSystem: true } : {})
+  }
+}
+
+const flatSearchMessages = (data: unknown): ReadonlyArray<unknown> => {
+  if (!isRecord(data) || !Array.isArray(data.messages)) return []
+  return data.messages.flatMap((group) => (Array.isArray(group) ? group : []))
+}
+
+const searchTotalResults = (data: unknown): number =>
+  isRecord(data) && typeof data.total_results === "number" && Number.isFinite(data.total_results) && data.total_results >= 0
+    ? data.total_results
+    : 0
+
+const appendAll = (params: URLSearchParams, key: string, values: ReadonlyArray<string>): void => {
+  for (const value of values) params.append(key, value)
+}
+
+const searchParams = (query: DiscordSearchQuery, limit: number, offset: number): URLSearchParams => {
+  const params = new URLSearchParams()
+  params.set("limit", String(Math.max(1, Math.min(25, limit))))
+  params.set("offset", String(Math.max(0, Math.min(9975, offset))))
+  if (query.content !== undefined) params.set("content", query.content)
+  if (query.maxId !== undefined) params.set("max_id", query.maxId)
+  if (query.minId !== undefined) params.set("min_id", query.minId)
+  if (query.slop !== undefined) params.set("slop", String(query.slop))
+  if (query.pinned !== undefined) params.set("pinned", String(query.pinned))
+  if (query.mentionEveryone !== undefined) params.set("mention_everyone", String(query.mentionEveryone))
+  if (query.sortBy !== undefined) params.set("sort_by", query.sortBy)
+  if (query.sortOrder !== undefined) params.set("sort_order", query.sortOrder)
+  if (query.includeNsfw !== undefined) params.set("include_nsfw", String(query.includeNsfw))
+  appendAll(params, "channel_id", query.channels)
+  appendAll(params, "author_id", query.authors)
+  appendAll(params, "author_type", query.authorTypes)
+  appendAll(params, "mentions", query.mentions)
+  appendAll(params, "mentions_role_id", query.roleMentions)
+  appendAll(params, "replied_to_user_id", query.repliedToUsers)
+  appendAll(params, "replied_to_message_id", query.repliedToMessages)
+  appendAll(params, "has", query.has)
+  appendAll(params, "embed_type", query.embedTypes)
+  appendAll(params, "embed_provider", query.embedProviders)
+  appendAll(params, "link_hostname", query.linkHostnames)
+  appendAll(params, "attachment_filename", query.attachmentFilenames)
+  appendAll(params, "attachment_extension", query.attachmentExtensions)
+  return params
+}
+
+const enrichNicknames = async (
+  scope: DiscordScope,
+  messages: ReadonlyArray<DiscordMessage>,
+  resolveNickname: NicknameResolver
+): Promise<ReadonlyArray<DiscordMessage>> => {
+  const nicknames = new Map<string, string | undefined>()
+  for (const userId of [...new Set(messages.map((message) => message.author.id))]) {
+    nicknames.set(userId, await resolveNickname(scope, userId))
+  }
+  return messages.map((message) => {
+    const nickname = nicknames.get(message.author.id)
+    return nickname === undefined ? message : { ...message, author: { ...message.author, nickname } }
+  })
+}
+
+const collectMessages = (scope: DiscordScope, data: unknown): ReadonlyArray<DiscordMessage> => {
+  const parents = isRecord(data) ? threadParents(data.threads) : new Map<string, string>()
+  const seen = new Set<string>()
+  const messages: Array<DiscordMessage> = []
+  for (const rawMessage of flatSearchMessages(data)) {
+    const message = fromRawDiscordMessage(scope, rawMessage, parents)
+    if (message === undefined || seen.has(message.id)) continue
+    seen.add(message.id)
+    messages.push(message)
+  }
+  return messages
+}
+
+export const searchDiscordMessages = async (
+  raw: RawDiscordOptions | undefined,
+  scope: DiscordScope,
+  query: DiscordSearchQuery,
+  paging: { readonly limit: number; readonly offset: number },
+  resolveNickname: NicknameResolver
+): Promise<DiscordSearchResult> => {
+  const resolvedQuery = await resolveSearchQuery(raw, scope, query)
+  const params = searchParams(resolvedQuery, paging.limit, paging.offset)
+  const data = await rawDiscordSearchRequest(raw, `/guilds/${scope.guildId}/messages/search?${params}`)
+  const messages = await enrichNicknames(scope, collectMessages(scope, data), resolveNickname)
+  const totalResults = searchTotalResults(data)
+  const offset = Math.max(0, Math.min(9975, paging.offset))
+  return { totalResults, offset, hasMore: offset + messages.length < totalResults, messages }
+}

package/src/Discord/MemoryDiscord.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test"
 import { Effect } from "effect"
 import type { DiscordMessage, DiscordScope } from "../Schema.ts"
 import { makeMemoryDiscord } from "./MemoryDiscord.ts"
+import { parseDiscordSearchQuery } from "./SearchQuery.ts"
 
 const scope: DiscordScope = { guildId: "g1", channelId: "c1" }
 
@@ -26,14 +27,17 @@ describe("makeMemoryDiscord", () => {
     const discord = makeMemoryDiscord({ context: [message("1"), message("2")] })
 
     const context = await Effect.runPromise(discord.fetchContext(scope, 1))
-    const history = await Effect.runPromise(discord.fetchHistory(scope, 2))
+    const query = parseDiscordSearchQuery("content:2 from:Alice")
+    if (!query.ok) throw new Error(query.error)
+    const search = await Effect.runPromise(discord.searchMessages(scope, query.query, { limit: 2, offset: 0 }))
     const posted = await Effect.runPromise(discord.postMessage(scope, "hello"))
     await Effect.runPromise(discord.editMessage(scope, posted.id, "updated"))
     await Effect.runPromise(discord.addReaction(scope, "m1", "rocket"))
     const attached = await Effect.runPromise(discord.attachFile(scope, "/repo/out.txt"))
 
     expect(context.map((item) => item.id)).toEqual(["2"])
-    expect(history.map((item) => item.id)).toEqual(["1", "2"])
+    expect(search.messages.map((item) => item.id)).toEqual(["2"])
+    expect(search.totalResults).toBe(1)
     expect(posted).toEqual({ id: "posted-1" })
     expect(discord.messages).toEqual([{ scope, content: "hello" }])
     expect(discord.edits).toEqual([{ scope, messageId: "posted-1", content: "updated" }])

package/src/Discord/MemoryDiscord.ts

@@ -1,11 +1,48 @@
 import { Effect } from "effect"
-import type { DiscordMessage, DiscordScope } from "../Schema.ts"
+import type { DiscordMessage, DiscordScope, DiscordSearchQuery, DiscordSearchResult } from "../Schema.ts"
 import type { DiscordPostedMessage, DiscordService } from "./DiscordPort.ts"
 
 type MemoryOptions = {
   readonly context?: ReadonlyArray<DiscordMessage>
 }
 
+const lowerIncludes = (value: string, expected: string): boolean => value.toLowerCase().includes(expected.toLowerCase())
+
+const matchesContent = (message: DiscordMessage, query: DiscordSearchQuery): boolean =>
+  query.content === undefined || lowerIncludes(message.content, query.content)
+
+const matchesAuthor = (message: DiscordMessage, query: DiscordSearchQuery): boolean =>
+  (query.authors.length === 0 || query.authors.includes(message.author.id)) &&
+  (query.authorNames.length === 0 || query.authorNames.some((name) => lowerIncludes(message.author.displayName, name)))
+
+const matchesChannel = (message: DiscordMessage, query: DiscordSearchQuery): boolean =>
+  query.channels.length === 0 || query.channels.some((id) => id === message.channelId || id === message.threadId)
+
+const matchesMentions = (message: DiscordMessage, query: DiscordSearchQuery): boolean =>
+  (query.mentions.length === 0 || query.mentions.every((id) => message.mentions.includes(id))) &&
+  (query.roleMentions.length === 0 || query.roleMentions.every((id) => message.roleMentions.includes(id))) &&
+  (query.mentionEveryone === undefined || message.everyoneMention === query.mentionEveryone)
+
+const matchesHas = (message: DiscordMessage, query: DiscordSearchQuery): boolean =>
+  (!query.has.includes("file") || message.attachments.length > 0) && (!query.has.includes("link") || /https?:\/\//i.test(message.content))
+
+const matchesSearch = (message: DiscordMessage, scope: DiscordScope, query: DiscordSearchQuery): boolean => {
+  if (message.guildId !== scope.guildId) return false
+  return [matchesContent, matchesAuthor, matchesChannel, matchesMentions, matchesHas].every((matches) => matches(message, query))
+}
+
+const memorySearch = (
+  context: ReadonlyArray<DiscordMessage>,
+  scope: DiscordScope,
+  query: DiscordSearchQuery,
+  limit: number,
+  offset: number
+): DiscordSearchResult => {
+  const matching = context.filter((message) => matchesSearch(message, scope, query))
+  const messages = matching.slice(offset, offset + limit)
+  return { totalResults: matching.length, offset, hasMore: offset + messages.length < matching.length, messages }
+}
+
 export type MemoryDiscord = DiscordService & {
   readonly context: Array<DiscordMessage>
   readonly typingScopes: Array<DiscordScope>
@@ -52,7 +89,7 @@ export const makeMemoryDiscord = (options: MemoryOptions = {}): MemoryDiscord =>
       }),
     editMessage: (scope, messageId, content) => Effect.sync(() => edits.push({ scope, messageId, content })).pipe(Effect.asVoid),
     addReaction: (scope, messageId, emoji) => Effect.sync(() => reactions.push({ scope, messageId, emoji, op: "add" })).pipe(Effect.asVoid),
-    fetchHistory: (_scope, limit) => Effect.succeed(context.slice(Math.max(0, context.length - limit))),
+    searchMessages: (scope, query, paging) => Effect.succeed(memorySearch(context, scope, query, paging.limit, paging.offset)),
     attachFile: (scope, path) =>
       Effect.sync(() => {
         attachments.push({ scope, path })

package/src/Discord/SearchQuery.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, test } from "bun:test"
+import { parseDiscordSearchQuery, timestampMsToDiscordSnowflake } from "./SearchQuery.ts"
+
+describe("parseDiscordSearchQuery", () => {
+  test("parses Discord-style search operators", () => {
+    const result = parseDiscordSearchQuery(
+      '"release notes" from:<@123> mentions:<@!456> in:<#789> has:link pinned:true sort:relevance order:asc'
+    )
+    if (!result.ok) throw new Error(result.error)
+
+    expect(result.query).toMatchObject({
+      content: "release notes",
+      authors: ["123"],
+      mentions: ["456"],
+      channels: ["789"],
+      has: ["link"],
+      pinned: true,
+      sortBy: "relevance",
+      sortOrder: "asc"
+    })
+  })
+
+  test("supports name references and raw API filter aliases", () => {
+    const result = parseDiscordSearchQuery(
+      "from:Alice in:#general author_type:bot attachment_extension:ts link_hostname:example.com embed_type:image mention_everyone:false"
+    )
+    if (!result.ok) throw new Error(result.error)
+
+    expect(result.query.authorNames).toEqual(["Alice"])
+    expect(result.query.channelNames).toEqual(["general"])
+    expect(result.query.authorTypes).toEqual(["bot"])
+    expect(result.query.attachmentExtensions).toEqual(["ts"])
+    expect(result.query.linkHostnames).toEqual(["example.com"])
+    expect(result.query.embedTypes).toEqual(["image"])
+    expect(result.query.mentionEveryone).toBe(false)
+  })
+
+  test("converts date filters to Discord snowflake IDs", () => {
+    const result = parseDiscordSearchQuery("after:2026-06-05 during:2026-06-06")
+    if (!result.ok) throw new Error(result.error)
+
+    expect(result.query.minId).toBe(timestampMsToDiscordSnowflake(Date.UTC(2026, 5, 6)))
+    expect(result.query.maxId).toBe(timestampMsToDiscordSnowflake(Date.UTC(2026, 5, 7)))
+  })
+
+  test("rejects invalid operators", () => {
+    expect(parseDiscordSearchQuery("pinned:maybe")).toEqual({ ok: false, error: "Invalid pinned: value maybe" })
+    expect(parseDiscordSearchQuery("role:moderators")).toEqual({
+      ok: false,
+      error: "Role search requires a role ID or role mention: moderators"
+    })
+  })
+})

package/src/Discord/SearchQuery.ts

@@ -0,0 +1,268 @@
+import type { DiscordSearchQuery } from "../Schema.ts"
+import { type DiscordSearchDateKey, discordSearchDateFilter, timestampMsToDiscordSnowflake } from "./SearchQueryDates.ts"
+import { splitKeyValue, splitValues, tokenizeDiscordSearch, unique } from "./SearchQueryTokens.ts"
+
+export { hasDiscordSearchCriteria } from "./SearchQueryCriteria.ts"
+export { timestampMsToDiscordSnowflake }
+
+export type DiscordSearchParseResult =
+  | { readonly ok: true; readonly query: DiscordSearchQuery }
+  | { readonly ok: false; readonly error: string }
+
+type MutableSearchQueryFields = { -readonly [K in keyof DiscordSearchQuery]?: DiscordSearchQuery[K] }
+
+type SearchState = {
+  readonly content: Array<string>
+  readonly authors: Array<string>
+  readonly authorNames: Array<string>
+  readonly authorTypes: Array<string>
+  readonly channels: Array<string>
+  readonly channelNames: Array<string>
+  readonly mentions: Array<string>
+  readonly mentionNames: Array<string>
+  readonly roleMentions: Array<string>
+  readonly repliedToUsers: Array<string>
+  readonly repliedToUserNames: Array<string>
+  readonly repliedToMessages: Array<string>
+  readonly has: Array<string>
+  readonly embedTypes: Array<string>
+  readonly embedProviders: Array<string>
+  readonly linkHostnames: Array<string>
+  readonly attachmentFilenames: Array<string>
+  readonly attachmentExtensions: Array<string>
+  readonly next: MutableSearchQueryFields
+}
+
+type SearchHandler = (state: SearchState, value: string, key: string) => DiscordSearchParseResult | undefined
+
+const snowflakePattern = /^\d{5,32}$/
+
+export const emptyDiscordSearchQuery = (): DiscordSearchQuery => ({
+  authors: [],
+  authorNames: [],
+  authorTypes: [],
+  channels: [],
+  channelNames: [],
+  mentions: [],
+  mentionNames: [],
+  roleMentions: [],
+  repliedToUsers: [],
+  repliedToUserNames: [],
+  repliedToMessages: [],
+  has: [],
+  embedTypes: [],
+  embedProviders: [],
+  linkHostnames: [],
+  attachmentFilenames: [],
+  attachmentExtensions: []
+})
+
+const createState = (): SearchState => ({
+  content: [],
+  authors: [],
+  authorNames: [],
+  authorTypes: [],
+  channels: [],
+  channelNames: [],
+  mentions: [],
+  mentionNames: [],
+  roleMentions: [],
+  repliedToUsers: [],
+  repliedToUserNames: [],
+  repliedToMessages: [],
+  has: [],
+  embedTypes: [],
+  embedProviders: [],
+  linkHostnames: [],
+  attachmentFilenames: [],
+  attachmentExtensions: [],
+  next: {}
+})
+
+const extractId = (input: string, pattern: RegExp): string | undefined => pattern.exec(input.trim())?.[1]
+const isSnowflake = (input: string): boolean => snowflakePattern.test(input.trim())
+const lower = (items: ReadonlyArray<string>): ReadonlyArray<string> => items.map((item) => item.toLowerCase())
+
+const pushUserReference = (input: string, ids: Array<string>, names: Array<string>): void => {
+  const id = extractId(input, /^<@!?(\d+)>$/)
+  if (id !== undefined || isSnowflake(input)) ids.push(id ?? input.trim())
+  else names.push(input.trim().replace(/^@/, ""))
+}
+
+const pushChannelReference = (input: string, ids: Array<string>, names: Array<string>): void => {
+  const id = extractId(input, /^<#(\d+)>$/)
+  if (id !== undefined || isSnowflake(input)) ids.push(id ?? input.trim())
+  else names.push(input.trim().replace(/^#/, ""))
+}
+
+const pushRoleReference = (input: string, ids: Array<string>): DiscordSearchParseResult | undefined => {
+  const id = extractId(input, /^<@&(\d+)>$/)
+  if (id !== undefined || isSnowflake(input)) {
+    ids.push(id ?? input.trim())
+    return undefined
+  }
+  return { ok: false, error: `Role search requires a role ID or role mention: ${input}` }
+}
+
+const parseBoolean = (input: string): boolean | undefined => {
+  switch (input.trim().toLowerCase()) {
+    case "true":
+    case "yes":
+    case "1":
+      return true
+    case "false":
+    case "no":
+    case "0":
+      return false
+    default:
+      return undefined
+  }
+}
+
+const contentHandler: SearchHandler = (state, value) => {
+  state.content.push(value)
+}
+
+const authorHandler: SearchHandler = (state, value) => {
+  for (const item of splitValues(value)) pushUserReference(item, state.authors, state.authorNames)
+}
+
+const channelHandler: SearchHandler = (state, value) => {
+  for (const item of splitValues(value)) pushChannelReference(item, state.channels, state.channelNames)
+}
+
+const mentionHandler: SearchHandler = (state, value) => {
+  for (const item of splitValues(value)) pushUserReference(item, state.mentions, state.mentionNames)
+}
+
+const roleHandler: SearchHandler = (state, value) => {
+  for (const item of splitValues(value)) {
+    const failed = pushRoleReference(item, state.roleMentions)
+    if (failed !== undefined) return failed
+  }
+}
+
+const repliedUserHandler: SearchHandler = (state, value) => {
+  for (const item of splitValues(value)) pushUserReference(item, state.repliedToUsers, state.repliedToUserNames)
+}
+
+const dateHandler: SearchHandler = (state, value, key) => {
+  const result = discordSearchDateFilter(key as DiscordSearchDateKey, value)
+  if (!result.ok) return result
+  if (result.minId !== undefined) state.next.minId = result.minId
+  if (result.maxId !== undefined) state.next.maxId = result.maxId
+}
+
+const slopHandler: SearchHandler = (state, value) => {
+  const slop = Number(value)
+  if (!Number.isInteger(slop) || slop < 0 || slop > 100) return { ok: false, error: `Invalid slop: ${value}` }
+  state.next.slop = slop
+}
+
+const booleanHandler =
+  (field: "pinned" | "mentionEveryone" | "includeNsfw", label: string): SearchHandler =>
+  (state, value) => {
+    const parsed = parseBoolean(value)
+    if (parsed === undefined) return { ok: false, error: `Invalid ${label}: value ${value}` }
+    state.next[field] = parsed
+  }
+
+const sortHandler: SearchHandler = (state, value) => {
+  const sortBy = value.toLowerCase()
+  if (sortBy !== "timestamp" && sortBy !== "relevance") return { ok: false, error: `Invalid sort: value ${value}` }
+  state.next.sortBy = sortBy
+}
+
+const orderHandler: SearchHandler = (state, value) => {
+  const sortOrder = value.toLowerCase()
+  if (sortOrder !== "asc" && sortOrder !== "desc") return { ok: false, error: `Invalid order: value ${value}` }
+  state.next.sortOrder = sortOrder
+}
+
+const handlerByKey: Record<string, SearchHandler> = {}
+const register = (aliases: ReadonlyArray<string>, handler: SearchHandler): void => {
+  for (const alias of aliases) handlerByKey[alias] = handler
+}
+
+register(["content"], contentHandler)
+register(["from", "author", "author_id"], authorHandler)
+register(["author_type"], (state, value) => {
+  state.authorTypes.push(...lower(splitValues(value)))
+})
+register(["in", "channel", "channel_id"], channelHandler)
+register(["mentions", "mention", "mentions_user_id"], mentionHandler)
+register(["mentions_role", "mentions_role_id", "mention_role", "role"], roleHandler)
+register(["replied_to_user", "replied_to_user_id", "reply_to_user", "reply_to"], repliedUserHandler)
+register(["replied_to_message", "replied_to_message_id", "reply_to_message"], (state, value) => {
+  state.repliedToMessages.push(...splitValues(value))
+})
+register(["has"], (state, value) => {
+  state.has.push(...lower(splitValues(value)))
+})
+register(["embed", "embed_type"], (state, value) => {
+  state.embedTypes.push(...lower(splitValues(value)))
+})
+register(["embed_provider"], (state, value) => {
+  state.embedProviders.push(...splitValues(value))
+})
+register(["link_hostname", "hostname", "domain"], (state, value) => {
+  state.linkHostnames.push(...lower(splitValues(value)))
+})
+register(["attachment_filename", "filename"], (state, value) => {
+  state.attachmentFilenames.push(...splitValues(value))
+})
+register(["attachment_extension", "extension", "ext"], (state, value) => {
+  state.attachmentExtensions.push(...lower(splitValues(value).map((item) => item.replace(/^\./, ""))))
+})
+register(["before", "after", "during"], dateHandler)
+register(["max_id"], (state, value) => {
+  state.next.maxId = value
+})
+register(["min_id"], (state, value) => {
+  state.next.minId = value
+})
+register(["slop"], slopHandler)
+register(["pinned"], booleanHandler("pinned", "pinned"))
+register(["mention_everyone", "everyone"], booleanHandler("mentionEveryone", "mention_everyone"))
+register(["include_nsfw", "nsfw"], booleanHandler("includeNsfw", "include_nsfw"))
+register(["sort", "sort_by"], sortHandler)
+register(["order", "sort_order"], orderHandler)
+
+const buildQuery = (state: SearchState): DiscordSearchQuery => {
+  const content = state.content.join(" ").trim()
+  return {
+    ...(content.length === 0 ? {} : { content }),
+    authors: unique(state.authors),
+    authorNames: unique(state.authorNames),
+    authorTypes: unique(state.authorTypes),
+    channels: unique(state.channels),
+    channelNames: unique(state.channelNames),
+    mentions: unique(state.mentions),
+    mentionNames: unique(state.mentionNames),
+    roleMentions: unique(state.roleMentions),
+    repliedToUsers: unique(state.repliedToUsers),
+    repliedToUserNames: unique(state.repliedToUserNames),
+    repliedToMessages: unique(state.repliedToMessages),
+    has: unique(state.has),
+    embedTypes: unique(state.embedTypes),
+    embedProviders: unique(state.embedProviders),
+    linkHostnames: unique(state.linkHostnames),
+    attachmentFilenames: unique(state.attachmentFilenames),
+    attachmentExtensions: unique(state.attachmentExtensions),
+    ...state.next
+  }
+}
+
+export const parseDiscordSearchQuery = (input: string): DiscordSearchParseResult => {
+  const state = createState()
+  for (const token of tokenizeDiscordSearch(input)) {
+    const pair = splitKeyValue(token)
+    const handler = pair === undefined ? undefined : handlerByKey[pair[0]]
+    if (pair === undefined || handler === undefined) state.content.push(token)
+    else {
+      const failed = handler(state, pair[1], pair[0])
+      if (failed !== undefined) return failed
+    }
+  }
+  return { ok: true, query: buildQuery(state) }
+}

package/src/Discord/SearchQueryCriteria.ts

@@ -0,0 +1,35 @@
+import type { DiscordSearchQuery } from "../Schema.ts"
+
+export const hasDiscordSearchCriteria = (query: DiscordSearchQuery): boolean => {
+  const arrays = [
+    query.authors,
+    query.authorNames,
+    query.authorTypes,
+    query.channels,
+    query.channelNames,
+    query.mentions,
+    query.mentionNames,
+    query.roleMentions,
+    query.repliedToUsers,
+    query.repliedToUserNames,
+    query.repliedToMessages,
+    query.has,
+    query.embedTypes,
+    query.embedProviders,
+    query.linkHostnames,
+    query.attachmentFilenames,
+    query.attachmentExtensions
+  ]
+  const scalars = [
+    query.content,
+    query.maxId,
+    query.minId,
+    query.slop,
+    query.pinned,
+    query.mentionEveryone,
+    query.includeNsfw,
+    query.sortBy,
+    query.sortOrder
+  ]
+  return arrays.some((items) => items.length > 0) || scalars.some((value) => value !== undefined)
+}