@sanity/client 8.3.0 → 8.4.0

package/src/context/reads.ts

@@ -0,0 +1,206 @@
+import {lastValueFrom} from 'rxjs'
+
+import type {ObservableSanityClient, SanityClient} from '../SanityClient'
+import type {HttpRequest, QueryParams} from '../types'
+import {_fetch, _organizationId} from './store'
+import type {
+  ContextRequestOptions,
+  ConversationDoc,
+  Entry,
+  EntryDoc,
+  InstructionDoc,
+  IssueDoc,
+  McpDoc,
+} from './types'
+
+type Client = SanityClient | ObservableSanityClient
+
+const ENTRY_TYPE = 'sanity.context.entry'
+const ISSUE_TYPE = 'sanity.context.issue'
+const INSTRUCTION_TYPE = 'sanity.context.instruction'
+const MCP_TYPE = 'sanity.context.mcp'
+const CONVERSATION_TYPE = 'sanity.context.conversation'
+
+/** Documents per page while a list read drains the store to completion. */
+const PAGE_SIZE = 200
+
+/** MCP endpoint configurations are few; one capped page covers them all. */
+const MCP_LIST_LIMIT = 500
+
+/** Keyset cursor over the `| order(_createdAt asc, _id asc)` total order. */
+const CREATED_AT_KEYSET = '(_createdAt > $c || (_createdAt == $c && _id > $i))'
+
+function _one<R>(
+  client: Client,
+  httpRequest: HttpRequest,
+  query: string,
+  params: QueryParams,
+  options?: ContextRequestOptions,
+): Promise<R | null> {
+  return lastValueFrom(_fetch<R | null>(client, httpRequest, query, params, options))
+}
+
+/**
+ * Drain every page of a `(_createdAt, _id)`-keyset read. Termination keys on
+ * the raw page length before anything looks at the rows: a short page means
+ * the store had nothing more to give, and filtering must never shorten a
+ * full page into a false stop.
+ */
+async function _drainByCreatedAt<T extends {_createdAt: string; _id: string}>(
+  client: Client,
+  httpRequest: HttpRequest,
+  filter: string,
+  params: QueryParams,
+  options?: ContextRequestOptions,
+): Promise<T[]> {
+  const all: T[] = []
+  let cursor: {c: string; i: string} | undefined
+  for (;;) {
+    const pagedFilter = cursor ? `${filter} && ${CREATED_AT_KEYSET}` : filter
+    const query = `*[${pagedFilter}] | order(_createdAt asc, _id asc) [0...${PAGE_SIZE}]`
+    const page = await lastValueFrom(
+      _fetch<T[]>(client, httpRequest, query, cursor ? {...params, ...cursor} : params, options),
+    )
+    all.push(...page)
+    if (page.length < PAGE_SIZE) return all
+    const last = page[page.length - 1]
+    cursor = {c: last._createdAt, i: last._id}
+  }
+}
+
+/** @internal */
+export function _readEntry(
+  client: Client,
+  httpRequest: HttpRequest,
+  knowledgeBaseId: string,
+  path: string,
+  options?: ContextRequestOptions,
+): Promise<EntryDoc | null> {
+  return _one<EntryDoc>(
+    client,
+    httpRequest,
+    `*[_type == "${ENTRY_TYPE}" && knowledgeBaseId == $kb && path == $path][0]`,
+    {kb: knowledgeBaseId, path},
+    options,
+  )
+}
+
+/** @internal */
+export async function _listEntries(
+  client: Client,
+  httpRequest: HttpRequest,
+  knowledgeBaseId: string,
+  options?: ContextRequestOptions,
+): Promise<Entry[]> {
+  const all: Entry[] = []
+  let after = ''
+  for (;;) {
+    const query = `*[_type == "${ENTRY_TYPE}" && knowledgeBaseId == $kb && path > $after] | order(path asc) [0...${PAGE_SIZE}] {_id, path, title, tldr, status}`
+    const page = await lastValueFrom(
+      _fetch<Entry[]>(client, httpRequest, query, {kb: knowledgeBaseId, after}, options),
+    )
+    all.push(...page)
+    if (page.length < PAGE_SIZE) return all
+    after = page[page.length - 1].path
+  }
+}
+
+/** @internal */
+export function _listIssues(
+  client: Client,
+  httpRequest: HttpRequest,
+  knowledgeBaseId: string,
+  status: 'open' | 'accepted' | 'rejected' | undefined,
+  options?: ContextRequestOptions,
+): Promise<IssueDoc[]> {
+  const statusFilter = status === undefined ? '' : ' && status == $status'
+  return _drainByCreatedAt<IssueDoc>(
+    client,
+    httpRequest,
+    `_type == "${ISSUE_TYPE}" && knowledgeBaseId == $kb${statusFilter}`,
+    status === undefined ? {kb: knowledgeBaseId} : {kb: knowledgeBaseId, status},
+    options,
+  )
+}
+
+/** @internal */
+export function _readIssue(
+  client: Client,
+  httpRequest: HttpRequest,
+  knowledgeBaseId: string,
+  issueId: string,
+  options?: ContextRequestOptions,
+): Promise<IssueDoc | null> {
+  return _one<IssueDoc>(
+    client,
+    httpRequest,
+    `*[_type == "${ISSUE_TYPE}" && knowledgeBaseId == $kb && _id == $id][0]`,
+    {kb: knowledgeBaseId, id: issueId},
+    options,
+  )
+}
+
+/** @internal */
+export function _listInstructions(
+  client: Client,
+  httpRequest: HttpRequest,
+  knowledgeBaseId: string,
+  options?: ContextRequestOptions,
+): Promise<InstructionDoc[]> {
+  return _drainByCreatedAt<InstructionDoc>(
+    client,
+    httpRequest,
+    `_type == "${INSTRUCTION_TYPE}" && knowledgeBaseId == $kb && schemaVersion == 1`,
+    {kb: knowledgeBaseId},
+    options,
+  )
+}
+
+/** @internal */
+export function _listMcpEndpoints(
+  client: Client,
+  httpRequest: HttpRequest,
+  options?: ContextRequestOptions,
+): Promise<McpDoc[]> {
+  return lastValueFrom(
+    _fetch<McpDoc[]>(
+      client,
+      httpRequest,
+      `*[_type == "${MCP_TYPE}" && organizationId == $org] | order(_createdAt asc, _id asc) [0...${MCP_LIST_LIMIT}]`,
+      {org: _organizationId(client)},
+      options,
+    ),
+  )
+}
+
+/** @internal */
+export function _readMcpEndpoint(
+  client: Client,
+  httpRequest: HttpRequest,
+  name: string,
+  options?: ContextRequestOptions,
+): Promise<McpDoc | null> {
+  return _one<McpDoc>(
+    client,
+    httpRequest,
+    `*[_type == "${MCP_TYPE}" && organizationId == $org && name == $name][0]`,
+    {org: _organizationId(client), name},
+    options,
+  )
+}
+
+/** @internal */
+export function _readConversation(
+  client: Client,
+  httpRequest: HttpRequest,
+  threadId: string,
+  options?: ContextRequestOptions,
+): Promise<ConversationDoc | null> {
+  return _one<ConversationDoc>(
+    client,
+    httpRequest,
+    `*[_type == "${CONVERSATION_TYPE}" && organizationId == $org && threadId == $threadId][0]`,
+    {org: _organizationId(client), threadId},
+    options,
+  )
+}

package/src/context/store.ts

@@ -0,0 +1,100 @@
+import {type Observable, throwError} from 'rxjs'
+import {map} from 'rxjs/operators'
+
+import {_requestObservable, getQuerySizeLimit} from '../data/dataMethods'
+import {encodeQueryString} from '../data/encodeQueryString'
+import {
+  _connectListenEventSource,
+  defaultOptions as defaultListenOptions,
+  type ListenEventFromOptions,
+  MAX_URL_LENGTH,
+  possibleOptions as possibleListenOptions,
+} from '../data/listen'
+import type {ObservableSanityClient, SanityClient} from '../SanityClient'
+import type {HttpRequest, QueryParams, ResumableListenEventNames, SanityDocument} from '../types'
+import defaults from '../util/defaults'
+import {pick} from '../util/pick'
+import {
+  type ContextListenOptions,
+  type ContextRequestOptions,
+  possibleStoreRequestOptions,
+} from './types'
+
+type Client = SanityClient | ObservableSanityClient
+
+/** @internal */
+export function _organizationId(client: Client): string {
+  const organizationId = client.config().context?.organizationId
+
+  if (!organizationId) {
+    throw new Error('`context.organizationId` must be configured to query Context documents')
+  }
+
+  return organizationId
+}
+
+function storeUrl(client: Client, suffix: 'query' | 'listen'): string {
+  return `/context/organizations/${encodeURIComponent(_organizationId(client))}/${suffix}`
+}
+
+/** @internal */
+export function _fetch<R>(
+  client: Client,
+  httpRequest: HttpRequest,
+  query: string,
+  params?: QueryParams,
+  options?: ContextRequestOptions,
+): Observable<R> {
+  const url = storeUrl(client, 'query')
+
+  // Mirrors `client.fetch`: GET while the query fits in the URL, POST beyond that.
+  const useGet = encodeQueryString({query, params}).length < getQuerySizeLimit
+  const request = useGet
+    ? {
+        method: 'GET',
+        url: `${url}${encodeQueryString({query, params})}`,
+      }
+    : {
+        method: 'POST',
+        url,
+        body: {query, params: params ?? {}},
+      }
+
+  return _requestObservable<{result: R}>(client, httpRequest, {
+    ...request,
+    ...pick(options || {}, possibleStoreRequestOptions),
+  }).pipe(map((response) => response.result))
+}
+
+/** @internal */
+export function _listen<Opts extends ContextListenOptions | undefined = undefined>(
+  client: Client,
+  query: string,
+  params?: QueryParams,
+  options?: Opts,
+): Observable<ListenEventFromOptions<SanityDocument, Opts>> {
+  const opts: ContextListenOptions = options ?? {}
+
+  // Mirrors `_listen` in data/listen.ts, but against the Context store's listen endpoint
+  const {requestTagPrefix} = client.config()
+  const tag = opts.tag && requestTagPrefix ? [requestTagPrefix, opts.tag].join('.') : opts.tag
+  const listenOpts = pick({...defaults(opts, defaultListenOptions), tag}, possibleListenOptions)
+  const qs = encodeQueryString({
+    query,
+    params,
+    options: listenOpts,
+  })
+
+  const uri = `${client.getUrl(storeUrl(client, 'listen'))}${qs}`
+  if (uri.length > MAX_URL_LENGTH) {
+    return throwError(() => new Error('Query too large for listener'))
+  }
+
+  const events: ResumableListenEventNames[] = opts.events ? opts.events : ['mutation']
+
+  return _connectListenEventSource<ListenEventFromOptions<SanityDocument, Opts>>(
+    client,
+    uri,
+    events,
+  )
+}