@sanity/client 4.0.1 → 5.0.0-esm.0

package/src/assets/AssetsClient.ts

@@ -0,0 +1,164 @@
+import {type Observable, lastValueFrom} from 'rxjs'
+import {filter, map} from 'rxjs/operators'
+
+import {_requestObservable} from '../data/dataMethods'
+import type {ObservableSanityClient, SanityClient} from '../SanityClient'
+import type {
+  HttpRequest,
+  HttpRequestEvent,
+  ResponseEvent,
+  SanityAssetDocument,
+  SanityImageAssetDocument,
+  UploadClientConfig,
+} from '../types'
+import * as validators from '../validators'
+
+export class ObservableAssetsClient {
+  #client: ObservableSanityClient
+  #httpRequest: HttpRequest
+  constructor(client: ObservableSanityClient, httpRequest: HttpRequest) {
+    this.#client = client
+    this.#httpRequest = httpRequest
+  }
+
+  /**
+   * Uploads a file asset to the configured dataset
+   *
+   * @param assetType Asset type (file/image)
+   * @param body Asset content - can be a browser File instance, a Blob, a Node.js Buffer instance or a Node.js ReadableStream.
+   * @param options Options to use for the upload
+   */
+  upload(
+    assetType: 'file',
+    body: File | Blob | Buffer | NodeJS.ReadableStream,
+    options?: UploadClientConfig
+  ): Observable<HttpRequestEvent<{document: SanityAssetDocument}>>
+
+  /**
+   * Uploads an image asset to the configured dataset
+   *
+   * @param assetType Asset type (file/image)
+   * @param body Asset content - can be a browser File instance, a Blob, a Node.js Buffer instance or a Node.js ReadableStream.
+   * @param options Options to use for the upload
+   */
+  upload(
+    assetType: 'image',
+    body: File | Blob | Buffer | NodeJS.ReadableStream,
+    options?: UploadClientConfig
+  ): Observable<HttpRequestEvent<{document: SanityImageAssetDocument}>>
+  upload(
+    assetType: 'file' | 'image',
+    body: File | Blob | Buffer | NodeJS.ReadableStream,
+    options?: UploadClientConfig
+  ): Observable<HttpRequestEvent<{document: SanityAssetDocument | SanityImageAssetDocument}>> {
+    return _upload(this.#client, this.#httpRequest, assetType, body, options)
+  }
+}
+
+export class AssetsClient {
+  #client: SanityClient
+  #httpRequest: HttpRequest
+  constructor(client: SanityClient, httpRequest: HttpRequest) {
+    this.#client = client
+    this.#httpRequest = httpRequest
+  }
+
+  /**
+   * Uploads a file asset to the configured dataset
+   *
+   * @param assetType Asset type (file/image)
+   * @param body Asset content - can be a browser File instance, a Blob, a Node.js Buffer instance or a Node.js ReadableStream.
+   * @param options Options to use for the upload
+   */
+  upload(
+    assetType: 'file',
+    body: File | Blob | Buffer | NodeJS.ReadableStream,
+    options?: UploadClientConfig
+  ): Promise<SanityAssetDocument>
+  /**
+   * Uploads an image asset to the configured dataset
+   *
+   * @param assetType Asset type (file/image)
+   * @param body Asset content - can be a browser File instance, a Blob, a Node.js Buffer instance or a Node.js ReadableStream.
+   * @param options Options to use for the upload
+   */
+  upload(
+    assetType: 'image',
+    body: File | Blob | Buffer | NodeJS.ReadableStream,
+    options?: UploadClientConfig
+  ): Promise<SanityImageAssetDocument>
+  upload(
+    assetType: 'file' | 'image',
+    body: File | Blob | Buffer | NodeJS.ReadableStream,
+    options?: UploadClientConfig
+  ): Promise<SanityAssetDocument | SanityImageAssetDocument> {
+    const observable = _upload(this.#client, this.#httpRequest, assetType, body, options)
+    return lastValueFrom(
+      observable.pipe(
+        filter((event: any) => event.type === 'response'),
+        map(
+          (event) =>
+            (event as ResponseEvent<{document: SanityAssetDocument | SanityImageAssetDocument}>)
+              .body.document
+        )
+      )
+    )
+  }
+}
+
+function _upload(
+  client: SanityClient | ObservableSanityClient,
+  httpRequest: HttpRequest,
+  assetType: 'image' | 'file',
+  body: File | Blob | Buffer | NodeJS.ReadableStream,
+  opts: UploadClientConfig = {}
+): Observable<HttpRequestEvent<{document: SanityAssetDocument | SanityImageAssetDocument}>> {
+  validators.validateAssetType(assetType)
+
+  // If an empty array is given, explicitly set `none` to override API defaults
+  let meta = opts.extract || undefined
+  if (meta && !meta.length) {
+    meta = ['none']
+  }
+
+  const dataset = validators.hasDataset(client.config())
+  const assetEndpoint = assetType === 'image' ? 'images' : 'files'
+  const options = optionsFromFile(opts, body)
+  const {tag, label, title, description, creditLine, filename, source} = options
+  const query: any = {
+    label,
+    title,
+    description,
+    filename,
+    meta,
+    creditLine,
+  }
+  if (source) {
+    query.sourceId = source.id
+    query.sourceName = source.name
+    query.sourceUrl = source.url
+  }
+  return _requestObservable(client, httpRequest, {
+    tag,
+    method: 'POST',
+    timeout: options.timeout || 0,
+    uri: `/assets/${assetEndpoint}/${dataset}`,
+    headers: options.contentType ? {'Content-Type': options.contentType} : {},
+    query,
+    body,
+  })
+}
+
+function optionsFromFile(opts: Record<string, any>, file: any) {
+  if (typeof window === 'undefined' || !(file instanceof window.File)) {
+    return opts
+  }
+
+  return Object.assign(
+    {
+      filename: opts.preserveFilename === false ? undefined : file.name,
+      contentType: file.type,
+    },
+    opts
+  )
+}

package/src/auth/AuthClient.ts

@@ -0,0 +1,43 @@
+import {type Observable} from 'rxjs'
+
+import type {ObservableSanityClient, SanityClient} from '../SanityClient'
+import type {AuthProviderResponse} from '../types'
+
+export class BaseAuthClient {
+  client: SanityClient | ObservableSanityClient
+
+  /**
+   * Fetch available login providers
+   */
+  getLoginProviders(this: AuthClient): Promise<AuthProviderResponse>
+  getLoginProviders(this: ObservableAuthClient): Observable<AuthProviderResponse>
+  getLoginProviders(): Promise<AuthProviderResponse> | Observable<AuthProviderResponse> {
+    return this.client.request({uri: '/auth/providers'})
+  }
+
+  /**
+   * Revoke the configured session/token
+   */
+  logout(this: AuthClient): Promise<any>
+  logout(this: ObservableAuthClient): Observable<any>
+  logout(): Promise<any> | Observable<any> {
+    return this.client.request({uri: '/auth/logout', method: 'POST'})
+  }
+}
+
+export class ObservableAuthClient extends BaseAuthClient {
+  client: ObservableSanityClient
+
+  constructor(client: ObservableSanityClient) {
+    super()
+    this.client = client
+  }
+}
+
+export class AuthClient extends BaseAuthClient {
+  client: SanityClient
+  constructor(client: SanityClient) {
+    super()
+    this.client = client
+  }
+}

package/src/config.ts

@@ -0,0 +1,95 @@
+import generateHelpUrl from './generateHelpUrl'
+import type {ClientConfig, InitializedClientConfig} from './types'
+import * as validate from './validators'
+import * as warnings from './warnings'
+
+const defaultCdnHost = 'apicdn.sanity.io'
+const defaultConfig = {
+  apiHost: 'https://api.sanity.io',
+  apiVersion: '1',
+  useProjectHostname: true,
+} satisfies ClientConfig
+
+const LOCALHOSTS = ['localhost', '127.0.0.1', '0.0.0.0']
+const isLocal = (host: string) => LOCALHOSTS.indexOf(host) !== -1
+
+export const validateApiVersion = function validateApiVersion(apiVersion: string) {
+  if (apiVersion === '1' || apiVersion === 'X') {
+    return
+  }
+
+  const apiDate = new Date(apiVersion)
+  const apiVersionValid =
+    /^\d{4}-\d{2}-\d{2}$/.test(apiVersion) && apiDate instanceof Date && apiDate.getTime() > 0
+
+  if (!apiVersionValid) {
+    throw new Error('Invalid API version string, expected `1` or date in format `YYYY-MM-DD`')
+  }
+}
+
+export const initConfig = (
+  config: Partial<ClientConfig>,
+  prevConfig: Partial<ClientConfig>
+): InitializedClientConfig => {
+  const specifiedConfig = Object.assign({}, prevConfig, config)
+  if (!specifiedConfig.apiVersion) {
+    warnings.printNoApiVersionSpecifiedWarning()
+  }
+
+  const newConfig = Object.assign({} as InitializedClientConfig, defaultConfig, specifiedConfig)
+  const projectBased = newConfig.useProjectHostname
+
+  if (typeof Promise === 'undefined') {
+    const helpUrl = generateHelpUrl('js-client-promise-polyfill')
+    throw new Error(`No native Promise-implementation found, polyfill needed - see ${helpUrl}`)
+  }
+
+  if (projectBased && !newConfig.projectId) {
+    throw new Error('Configuration must contain `projectId`')
+  }
+
+  const isBrowser = typeof window !== 'undefined' && window.location && window.location.hostname
+  const isLocalhost = isBrowser && isLocal(window.location.hostname)
+
+  if (isBrowser && isLocalhost && newConfig.token && newConfig.ignoreBrowserTokenWarning !== true) {
+    warnings.printBrowserTokenWarning()
+  } else if (typeof newConfig.useCdn === 'undefined') {
+    warnings.printCdnWarning()
+  }
+
+  if (projectBased) {
+    validate.projectId(newConfig.projectId)
+  }
+
+  if (newConfig.dataset) {
+    validate.dataset(newConfig.dataset)
+  }
+
+  if ('requestTagPrefix' in newConfig) {
+    // Allow setting and unsetting request tag prefix
+    newConfig.requestTagPrefix = newConfig.requestTagPrefix
+      ? validate.requestTag(newConfig.requestTagPrefix).replace(/\.+$/, '')
+      : undefined
+  }
+
+  newConfig.apiVersion = `${newConfig.apiVersion}`.replace(/^v/, '')
+  newConfig.isDefaultApi = newConfig.apiHost === defaultConfig.apiHost
+  newConfig.useCdn = Boolean(newConfig.useCdn) && !newConfig.withCredentials
+
+  validateApiVersion(newConfig.apiVersion)
+
+  const hostParts = newConfig.apiHost.split('://', 2)
+  const protocol = hostParts[0]
+  const host = hostParts[1]
+  const cdnHost = newConfig.isDefaultApi ? defaultCdnHost : host
+
+  if (newConfig.useProjectHostname) {
+    newConfig.url = `${protocol}://${newConfig.projectId}.${host}/v${newConfig.apiVersion}`
+    newConfig.cdnUrl = `${protocol}://${newConfig.projectId}.${cdnHost}/v${newConfig.apiVersion}`
+  } else {
+    newConfig.url = `${newConfig.apiHost}/v${newConfig.apiVersion}`
+    newConfig.cdnUrl = newConfig.url
+  }
+
+  return newConfig
+}

package/src/data/dataMethods.ts

@@ -0,0 +1,328 @@
+import {Observable} from 'rxjs'
+import {filter, map} from 'rxjs/operators'
+
+import getRequestOptions from '../http/requestOptions'
+import type {ObservableSanityClient, SanityClient} from '../SanityClient'
+import type {
+  AllDocumentIdsMutationOptions,
+  AllDocumentsMutationOptions,
+  BaseMutationOptions,
+  FilteredResponseQueryOptions,
+  FirstDocumentIdMutationOptions,
+  FirstDocumentMutationOptions,
+  HttpRequest,
+  HttpRequestEvent,
+  IdentifiedSanityDocumentStub,
+  MultipleMutationResult,
+  Mutation,
+  MutationSelection,
+  QueryParams,
+  RawQueryResponse,
+  RequestObservableOptions,
+  RequestOptions,
+  SanityDocument,
+  SingleMutationResult,
+  UnfilteredResponseQueryOptions,
+} from '../types'
+import getSelection from '../util/getSelection'
+import * as validate from '../validators'
+import * as validators from '../validators'
+import encodeQueryString from './encodeQueryString'
+import {ObservablePatch, Patch} from './patch'
+import {ObservableTransaction, Transaction} from './transaction'
+
+const excludeFalsey = (param: any, defValue: any) => {
+  const value = typeof param === 'undefined' ? defValue : param
+  return param === false ? undefined : value
+}
+
+const getMutationQuery = (options: BaseMutationOptions = {}) => {
+  return {
+    dryRun: options.dryRun,
+    returnIds: true,
+    returnDocuments: excludeFalsey(options.returnDocuments, true),
+    visibility: options.visibility || 'sync',
+    autoGenerateArrayKeys: options.autoGenerateArrayKeys,
+    skipCrossDatasetReferenceValidation: options.skipCrossDatasetReferenceValidation,
+  }
+}
+
+const isResponse = (event: any) => event.type === 'response'
+const getBody = (event: any) => event.body
+
+const indexBy = (docs: any[], attr: any) =>
+  docs.reduce((indexed, doc) => {
+    indexed[attr(doc)] = doc
+    return indexed
+  }, Object.create(null))
+
+const getQuerySizeLimit = 11264
+
+/** @internal */
+export function _fetch<R>(
+  client: ObservableSanityClient | SanityClient,
+  httpRequest: HttpRequest,
+  query: string,
+  params?: QueryParams,
+  options: FilteredResponseQueryOptions | UnfilteredResponseQueryOptions = {}
+): Observable<RawQueryResponse<R> | R> {
+  const mapResponse =
+    options.filterResponse === false ? (res: any) => res : (res: any) => res.result
+
+  return _dataRequest(client, httpRequest, 'query', {query, params}, options).pipe(map(mapResponse))
+}
+
+/** @internal */
+export function _getDocument<R extends Record<string, any>>(
+  client: ObservableSanityClient | SanityClient,
+  httpRequest: HttpRequest,
+  id: string,
+  opts: {tag?: string} = {}
+): Observable<SanityDocument<R> | undefined> {
+  const options = {uri: client.getDataUrl('doc', id), json: true, tag: opts.tag}
+  return _requestObservable<SanityDocument<R> | undefined>(client, httpRequest, options).pipe(
+    filter(isResponse),
+    map((event) => event.body.documents && event.body.documents[0])
+  )
+}
+
+/** @internal */
+export function _getDocuments<R extends Record<string, any>>(
+  client: ObservableSanityClient | SanityClient,
+  httpRequest: HttpRequest,
+  ids: string[],
+  opts: {tag?: string} = {}
+): Observable<(SanityDocument<R> | null)[]> {
+  const options = {uri: client.getDataUrl('doc', ids.join(',')), json: true, tag: opts.tag}
+  return _requestObservable<(SanityDocument<R> | null)[]>(client, httpRequest, options).pipe(
+    filter(isResponse),
+    map((event: any) => {
+      const indexed = indexBy(event.body.documents || [], (doc: any) => doc._id)
+      return ids.map((id) => indexed[id] || null)
+    })
+  )
+}
+
+/** @internal */
+export function _createIfNotExists<R extends Record<string, any>>(
+  client: ObservableSanityClient | SanityClient,
+  httpRequest: HttpRequest,
+  doc: IdentifiedSanityDocumentStub<R>,
+  options?:
+    | AllDocumentIdsMutationOptions
+    | AllDocumentsMutationOptions
+    | BaseMutationOptions
+    | FirstDocumentIdMutationOptions
+    | FirstDocumentMutationOptions
+): Observable<
+  SanityDocument<R> | SanityDocument<R>[] | SingleMutationResult | MultipleMutationResult
+> {
+  validators.requireDocumentId('createIfNotExists', doc)
+  return _create<R>(client, httpRequest, doc, 'createIfNotExists', options)
+}
+
+/** @internal */
+export function _createOrReplace<R extends Record<string, any>>(
+  client: ObservableSanityClient | SanityClient,
+  httpRequest: HttpRequest,
+  doc: IdentifiedSanityDocumentStub<R>,
+  options?:
+    | AllDocumentIdsMutationOptions
+    | AllDocumentsMutationOptions
+    | BaseMutationOptions
+    | FirstDocumentIdMutationOptions
+    | FirstDocumentMutationOptions
+): Observable<
+  SanityDocument<R> | SanityDocument<R>[] | SingleMutationResult | MultipleMutationResult
+> {
+  validators.requireDocumentId('createOrReplace', doc)
+  return _create<R>(client, httpRequest, doc, 'createOrReplace', options)
+}
+
+/** @internal */
+export function _delete<R extends Record<string, any>>(
+  client: ObservableSanityClient | SanityClient,
+  httpRequest: HttpRequest,
+  selection: string | MutationSelection,
+  options?:
+    | AllDocumentIdsMutationOptions
+    | AllDocumentsMutationOptions
+    | BaseMutationOptions
+    | FirstDocumentIdMutationOptions
+    | FirstDocumentMutationOptions
+): Observable<
+  SanityDocument<R> | SanityDocument<R>[] | SingleMutationResult | MultipleMutationResult
+> {
+  return _dataRequest(
+    client,
+    httpRequest,
+    'mutate',
+    {mutations: [{delete: getSelection(selection)}]},
+    options
+  )
+}
+
+/** @internal */
+export function _mutate<R extends Record<string, any>>(
+  client: SanityClient | ObservableSanityClient,
+  httpRequest: HttpRequest,
+  mutations: Mutation<R>[] | Patch | ObservablePatch | Transaction | ObservableTransaction,
+  options?:
+    | AllDocumentIdsMutationOptions
+    | AllDocumentsMutationOptions
+    | BaseMutationOptions
+    | FirstDocumentIdMutationOptions
+    | FirstDocumentMutationOptions
+): Observable<
+  SanityDocument<R> | SanityDocument<R>[] | SingleMutationResult | MultipleMutationResult
+> {
+  const mut =
+    mutations instanceof Patch ||
+    mutations instanceof ObservablePatch ||
+    mutations instanceof Transaction ||
+    mutations instanceof ObservableTransaction
+      ? mutations.serialize()
+      : mutations
+
+  const muts = Array.isArray(mut) ? mut : [mut]
+  const transactionId = options && (options as any).transactionId
+  return _dataRequest(client, httpRequest, 'mutate', {mutations: muts, transactionId}, options)
+}
+
+/**
+ * @internal
+ */
+export function _dataRequest(
+  client: SanityClient | ObservableSanityClient,
+  httpRequest: HttpRequest,
+  endpoint: string,
+  body: any,
+  options: any = {}
+): any {
+  const isMutation = endpoint === 'mutate'
+  const isQuery = endpoint === 'query'
+
+  // Check if the query string is within a configured threshold,
+  // in which case we can use GET. Otherwise, use POST.
+  const strQuery = isMutation ? '' : encodeQueryString(body)
+  const useGet = !isMutation && strQuery.length < getQuerySizeLimit
+  const stringQuery = useGet ? strQuery : ''
+  const returnFirst = options.returnFirst
+  const {timeout, token, tag, headers} = options
+
+  const uri = client.getDataUrl(endpoint, stringQuery)
+
+  const reqOptions = {
+    method: useGet ? 'GET' : 'POST',
+    uri: uri,
+    json: true,
+    body: useGet ? undefined : body,
+    query: isMutation && getMutationQuery(options),
+    timeout,
+    headers,
+    token,
+    tag,
+    canUseCdn: isQuery,
+  }
+
+  return _requestObservable(client, httpRequest, reqOptions).pipe(
+    filter(isResponse),
+    map(getBody),
+    map((res) => {
+      if (!isMutation) {
+        return res
+      }
+
+      // Should we return documents?
+      const results = res.results || []
+      if (options.returnDocuments) {
+        return returnFirst
+          ? results[0] && results[0].document
+          : results.map((mut: any) => mut.document)
+      }
+
+      // Return a reduced subset
+      const key = returnFirst ? 'documentId' : 'documentIds'
+      const ids = returnFirst ? results[0] && results[0].id : results.map((mut: any) => mut.id)
+      return {
+        transactionId: res.transactionId,
+        results: results,
+        [key]: ids,
+      }
+    })
+  )
+}
+
+/**
+ * @internal
+ */
+export function _create<R extends Record<string, any>>(
+  client: SanityClient | ObservableSanityClient,
+  httpRequest: HttpRequest,
+  doc: any,
+  op: any,
+  options: any = {}
+): Observable<
+  SanityDocument<R> | SanityDocument<R>[] | SingleMutationResult | MultipleMutationResult
+> {
+  const mutation = {[op]: doc}
+  const opts = Object.assign({returnFirst: true, returnDocuments: true}, options)
+  return _dataRequest(client, httpRequest, 'mutate', {mutations: [mutation]}, opts)
+}
+
+/**
+ * @internal
+ */
+export function _requestObservable<R>(
+  client: SanityClient | ObservableSanityClient,
+  httpRequest: HttpRequest,
+  options: RequestObservableOptions
+): Observable<HttpRequestEvent<R>> {
+  const uri = options.url || (options.uri as string)
+  const config = client.config()
+
+  // If the `canUseCdn`-option is not set we detect it automatically based on the method + URL.
+  // Only the /data endpoint is currently available through API-CDN.
+  const canUseCdn =
+    typeof options.canUseCdn === 'undefined'
+      ? ['GET', 'HEAD'].indexOf(options.method || 'GET') >= 0 && uri.indexOf('/data/') === 0
+      : options.canUseCdn
+
+  const useCdn = config.useCdn && canUseCdn
+
+  const tag =
+    options.tag && config.requestTagPrefix
+      ? [config.requestTagPrefix, options.tag].join('.')
+      : options.tag || config.requestTagPrefix
+
+  if (tag) {
+    options.query = {tag: validate.requestTag(tag), ...options.query}
+  }
+
+  const reqOptions = getRequestOptions(
+    config,
+    Object.assign({}, options, {
+      url: client.getUrl(uri, useCdn),
+    })
+  ) as RequestOptions
+
+  return new Observable<HttpRequestEvent<R>>((subscriber) =>
+    httpRequest(reqOptions, config.requester!).subscribe(subscriber)
+  )
+}
+
+/**
+ * @internal
+ */
+export function _request<R>(
+  client: SanityClient | ObservableSanityClient,
+  httpRequest: HttpRequest,
+  options: any
+): Observable<R> {
+  const observable = _requestObservable<R>(client, httpRequest, options).pipe(
+    filter((event: any) => event.type === 'response'),
+    map((event: any) => event.body)
+  )
+
+  return observable
+}

package/src/data/encodeQueryString.ts

@@ -0,0 +1,28 @@
+import type {QueryParams} from '../types'
+
+const enc = encodeURIComponent
+
+export default ({
+  query,
+  params = {} as any,
+  options = {} as any,
+}: {
+  query: string
+  params?: QueryParams
+  options?: any
+}) => {
+  // We generally want tag at the start of the query string
+  const {tag, ...opts} = options
+  const q = `query=${enc(query)}`
+  const base = tag ? `?tag=${enc(tag)}&${q}` : `?${q}`
+
+  const qString = Object.keys(params).reduce(
+    (qs, param) => `${qs}&${enc(`$${param}`)}=${enc(JSON.stringify(params[param]))}`,
+    base
+  )
+
+  return Object.keys(opts).reduce((qs, option) => {
+    // Only include the option if it is truthy
+    return options[option] ? `${qs}&${enc(option)}=${enc(options[option])}` : qs
+  }, qString)
+}