@sanity/client 4.0.0-alpha.esm.1 → 4.0.0-alpha.esm.2

package/dist/node/sanityClient.js

@@ -721,7 +721,7 @@ import headers from "get-it/lib-node/middleware/headers";
 
 // package.json
 var name = "@sanity/client";
-var version = "4.0.0-alpha.esm.1";
+var version = "4.0.0-alpha.esm.2";
 
 // src/http/nodeMiddleware.js
 var middleware = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/client",
-  "version": "4.0.0-alpha.esm.1",
+  "version": "4.0.0-alpha.esm.2",
   "description": "Client for retrieving, creating and patching data from Sanity.io",
   "main": "lib/sanityClient.js",
   "umd": "umd/sanityClient.min.js",
@@ -9,6 +9,7 @@
   "module": "./dist/sanityClient.js",
   "exports": {
     ".": {
+      "source": "./src/sanityClient.js",
       "browser": "./dist/browser/sanityClient.js",
       "default": "./dist/node/sanityClient.js"
     },

package/src/assets/assetsClient.js

@@ -0,0 +1,132 @@
+import {map, filter} from '../util/observable'
+import {queryString} from '../http/queryString'
+import * as validators from '../validators'
+
+export class AssetsClient {
+  constructor(client) {
+    this.client = client
+  }
+
+  /**
+   * Upload an asset
+   *
+   * @param  {String} assetType `image` or `file`
+   * @param  {File|Blob|Buffer|ReadableStream} body File to upload
+   * @param  {Object}  opts Options for the upload
+   * @param  {Boolean} opts.preserveFilename Whether or not to preserve the original filename (default: true)
+   * @param  {String}  opts.filename Filename for this file (optional)
+   * @param  {Number}  opts.timeout  Milliseconds to wait before timing the request out (default: 0)
+   * @param  {String}  opts.contentType Mime type of the file
+   * @param  {Array}   opts.extract Array of metadata parts to extract from image.
+   *                                 Possible values: `location`, `exif`, `image`, `palette`
+   * @param  {String}  opts.label Label
+   * @param  {String}  opts.title Title
+   * @param  {String}  opts.description Description
+   * @param  {String}  opts.creditLine The credit to person(s) and/or organization(s) required by the supplier of the image to be used when published
+   * @param  {Object}  opts.source Source data (when the asset is from an external service)
+   * @param  {String}  opts.source.id The (u)id of the asset within the source, i.e. 'i-f323r1E'
+   *                                  Required if source is defined
+   * @param  {String}  opts.source.name The name of the source, i.e. 'unsplash'
+   *                                  Required if source is defined
+   * @param  {String}  opts.source.url A url to where to find the asset, or get more info about it in the source
+   *                                  Optional
+   * @return {Promise} Resolves with the created asset document
+   */
+  upload(assetType, body, opts = {}) {
+    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(this.client.clientConfig)
+    const assetEndpoint = assetType === 'image' ? 'images' : 'files'
+    const options = optionsFromFile(opts, body)
+    const {tag, label, title, description, creditLine, filename, source} = options
+    const query = {
+      label,
+      title,
+      description,
+      filename,
+      meta,
+      creditLine,
+    }
+    if (source) {
+      query.sourceId = source.id
+      query.sourceName = source.name
+      query.sourceUrl = source.url
+    }
+    const observable = this.client._requestObservable({
+      tag,
+      method: 'POST',
+      timeout: options.timeout || 0,
+      uri: `/assets/${assetEndpoint}/${dataset}`,
+      headers: options.contentType ? {'Content-Type': options.contentType} : {},
+      query,
+      body,
+    })
+
+    return this.client.isPromiseAPI()
+      ? observable
+          .pipe(
+            filter((event) => event.type === 'response'),
+            map((event) => event.body.document)
+          )
+          .toPromise()
+      : observable
+  }
+
+  delete(type, id) {
+    // eslint-disable-next-line no-console
+    console.warn('client.assets.delete() is deprecated, please use client.delete(<document-id>)')
+
+    let docId = id || ''
+    if (!/^(image|file)-/.test(docId)) {
+      docId = `${type}-${docId}`
+    } else if (type._id) {
+      // We could be passing an entire asset document instead of an ID
+      docId = type._id
+    }
+
+    validators.hasDataset(this.client.clientConfig)
+    return this.client.delete(docId)
+  }
+
+  getImageUrl(ref, query) {
+    const id = ref._ref || ref
+    if (typeof id !== 'string') {
+      throw new Error(
+        'getImageUrl() needs either an object with a _ref, or a string with an asset document ID'
+      )
+    }
+
+    if (!/^image-[A-Za-z0-9_]+-\d+x\d+-[a-z]{1,5}$/.test(id)) {
+      throw new Error(
+        `Unsupported asset ID "${id}". URL generation only works for auto-generated IDs.`
+      )
+    }
+
+    const [, assetId, size, format] = id.split('-')
+
+    validators.hasDataset(this.client.clientConfig)
+    const {projectId, dataset} = this.client.clientConfig
+    const qs = query ? queryString(query) : ''
+    return `https://cdn.sanity.io/images/${projectId}/${dataset}/${assetId}-${size}.${format}${qs}`
+  }
+}
+
+function optionsFromFile(opts, file) {
+  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.js

@@ -0,0 +1,13 @@
+export class AuthClient {
+  constructor(client) {
+    this.client = client
+  }
+
+  getLoginProviders() {
+    return this.client.request({uri: '/auth/providers'})
+  }
+
+  logout() {
+    return this.client.request({uri: '/auth/logout', method: 'POST'})
+  }
+}

package/src/config.js

@@ -0,0 +1,93 @@
+import {generateHelpUrl} from '@sanity/generate-help-url'
+import * as validate from './validators'
+import * as warnings from './warnings'
+
+const defaultCdnHost = 'apicdn.sanity.io'
+export const defaultConfig = {
+  apiHost: 'https://api.sanity.io',
+  apiVersion: '1',
+  useProjectHostname: true,
+  isPromiseAPI: true,
+}
+
+const LOCALHOSTS = ['localhost', '127.0.0.1', '0.0.0.0']
+const isLocal = (host) => LOCALHOSTS.indexOf(host) !== -1
+
+// eslint-disable-next-line complexity
+export const initConfig = (config, prevConfig) => {
+  const specifiedConfig = Object.assign({}, prevConfig, config)
+  if (!specifiedConfig.apiVersion) {
+    warnings.printNoApiVersionSpecifiedWarning()
+  }
+
+  const newConfig = Object.assign({}, 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
+}
+
+export function validateApiVersion(apiVersion) {
+  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`')
+  }
+}

package/src/data/dataMethods.js

@@ -0,0 +1,182 @@
+import {map, filter} from '../util/observable'
+import * as validators from '../validators'
+import {getSelection} from '../util/getSelection'
+import {encodeQueryString} from './encodeQueryString'
+import {Transaction} from './transaction'
+import {Patch} from './patch'
+import {listen} from './listen'
+
+const excludeFalsey = (param, defValue) => {
+  const value = typeof param === 'undefined' ? defValue : param
+  return param === false ? undefined : value
+}
+
+const getMutationQuery = (options = {}) => {
+  return {
+    dryRun: options.dryRun,
+    returnIds: true,
+    returnDocuments: excludeFalsey(options.returnDocuments, true),
+    visibility: options.visibility || 'sync',
+    autoGenerateArrayKeys: options.autoGenerateArrayKeys,
+    skipCrossDatasetReferenceValidation: options.skipCrossDatasetReferenceValidation,
+  }
+}
+
+const isResponse = (event) => event.type === 'response'
+const getBody = (event) => event.body
+
+const indexBy = (docs, attr) =>
+  docs.reduce((indexed, doc) => {
+    indexed[attr(doc)] = doc
+    return indexed
+  }, Object.create(null))
+
+const toPromise = (observable) => observable.toPromise()
+
+const getQuerySizeLimit = 11264
+
+export const dataMethods = {
+  listen: listen,
+
+  getDataUrl(operation, path) {
+    const config = this.clientConfig
+    const catalog = validators.hasDataset(config)
+    const baseUri = `/${operation}/${catalog}`
+    const uri = path ? `${baseUri}/${path}` : baseUri
+    return `/data${uri}`.replace(/\/($|\?)/, '$1')
+  },
+
+  fetch(query, params, options = {}) {
+    const mapResponse = options.filterResponse === false ? (res) => res : (res) => res.result
+
+    const observable = this._dataRequest('query', {query, params}, options).pipe(map(mapResponse))
+    return this.isPromiseAPI() ? toPromise(observable) : observable
+  },
+
+  getDocument(id, opts = {}) {
+    const options = {uri: this.getDataUrl('doc', id), json: true, tag: opts.tag}
+    const observable = this._requestObservable(options).pipe(
+      filter(isResponse),
+      map((event) => event.body.documents && event.body.documents[0])
+    )
+
+    return this.isPromiseAPI() ? toPromise(observable) : observable
+  },
+
+  getDocuments(ids, opts = {}) {
+    const options = {uri: this.getDataUrl('doc', ids.join(',')), json: true, tag: opts.tag}
+    const observable = this._requestObservable(options).pipe(
+      filter(isResponse),
+      map((event) => {
+        const indexed = indexBy(event.body.documents || [], (doc) => doc._id)
+        return ids.map((id) => indexed[id] || null)
+      })
+    )
+
+    return this.isPromiseAPI() ? toPromise(observable) : observable
+  },
+
+  create(doc, options) {
+    return this._create(doc, 'create', options)
+  },
+
+  createIfNotExists(doc, options) {
+    validators.requireDocumentId('createIfNotExists', doc)
+    return this._create(doc, 'createIfNotExists', options)
+  },
+
+  createOrReplace(doc, options) {
+    validators.requireDocumentId('createOrReplace', doc)
+    return this._create(doc, 'createOrReplace', options)
+  },
+
+  patch(selector, operations) {
+    return new Patch(selector, operations, this)
+  },
+
+  delete(selection, options) {
+    return this.dataRequest('mutate', {mutations: [{delete: getSelection(selection)}]}, options)
+  },
+
+  mutate(mutations, options) {
+    const mut =
+      mutations instanceof Patch || mutations instanceof Transaction
+        ? mutations.serialize()
+        : mutations
+
+    const muts = Array.isArray(mut) ? mut : [mut]
+    const transactionId = options && options.transactionId
+    return this.dataRequest('mutate', {mutations: muts, transactionId}, options)
+  },
+
+  transaction(operations) {
+    return new Transaction(operations, this)
+  },
+
+  dataRequest(endpoint, body, options = {}) {
+    const request = this._dataRequest(endpoint, body, options)
+
+    return this.isPromiseAPI() ? toPromise(request) : request
+  },
+
+  _dataRequest(endpoint, body, options = {}) {
+    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 = this.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 this._requestObservable(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) => mut.document)
+        }
+
+        // Return a reduced subset
+        const key = returnFirst ? 'documentId' : 'documentIds'
+        const ids = returnFirst ? results[0] && results[0].id : results.map((mut) => mut.id)
+        return {
+          transactionId: res.transactionId,
+          results: results,
+          [key]: ids,
+        }
+      })
+    )
+  },
+
+  _create(doc, op, options = {}) {
+    const mutation = {[op]: doc}
+    const opts = Object.assign({returnFirst: true, returnDocuments: true}, options)
+    return this.dataRequest('mutate', {mutations: [mutation]}, opts)
+  },
+}

package/src/data/encodeQueryString.js

@@ -0,0 +1,18 @@
+const enc = encodeURIComponent
+
+export const encodeQueryString = ({query, params = {}, options = {}}) => {
+  // 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)
+}

package/src/data/listen.js

@@ -0,0 +1,159 @@
+import {Observable} from '../util/observable'
+import polyfilledEventSource from '@sanity/eventsource'
+import {pick} from '../util/pick'
+import {defaults} from '../util/defaults'
+import {encodeQueryString} from './encodeQueryString'
+
+// Limit is 16K for a _request_, eg including headers. Have to account for an
+// unknown range of headers, but an average EventSource request from Chrome seems
+// to have around 700 bytes of cruft, so let us account for 1.2K to be "safe"
+const MAX_URL_LENGTH = 16000 - 1200
+const EventSource = polyfilledEventSource
+
+const possibleOptions = [
+  'includePreviousRevision',
+  'includeResult',
+  'visibility',
+  'effectFormat',
+  'tag',
+]
+
+const defaultOptions = {
+  includeResult: true,
+}
+
+export function listen(query, params, opts = {}) {
+  const {url, token, withCredentials, requestTagPrefix} = this.clientConfig
+  const tag = opts.tag && requestTagPrefix ? [requestTagPrefix, opts.tag].join('.') : opts.tag
+  const options = {...defaults(opts, defaultOptions), tag}
+  const listenOpts = pick(options, possibleOptions)
+  const qs = encodeQueryString({query, params, options: listenOpts, tag})
+
+  const uri = `${url}${this.getDataUrl('listen', qs)}`
+  if (uri.length > MAX_URL_LENGTH) {
+    return new Observable((observer) => observer.error(new Error('Query too large for listener')))
+  }
+
+  const listenFor = options.events ? options.events : ['mutation']
+  const shouldEmitReconnect = listenFor.indexOf('reconnect') !== -1
+
+  const esOptions = {}
+  if (token || withCredentials) {
+    esOptions.withCredentials = true
+  }
+
+  if (token) {
+    esOptions.headers = {
+      Authorization: `Bearer ${token}`,
+    }
+  }
+
+  return new Observable((observer) => {
+    let es = getEventSource()
+    let reconnectTimer
+    let stopped = false
+
+    function onError() {
+      if (stopped) {
+        return
+      }
+
+      emitReconnect()
+
+      // Allow event handlers of `emitReconnect` to cancel/close the reconnect attempt
+      if (stopped) {
+        return
+      }
+
+      // Unless we've explicitly stopped the ES (in which case `stopped` should be true),
+      // we should never be in a disconnected state. By default, EventSource will reconnect
+      // automatically, in which case it sets readyState to `CONNECTING`, but in some cases
+      // (like when a laptop lid is closed), it closes the connection. In these cases we need
+      // to explicitly reconnect.
+      if (es.readyState === EventSource.CLOSED) {
+        unsubscribe()
+        clearTimeout(reconnectTimer)
+        reconnectTimer = setTimeout(open, 100)
+      }
+    }
+
+    function onChannelError(err) {
+      observer.error(cooerceError(err))
+    }
+
+    function onMessage(evt) {
+      const event = parseEvent(evt)
+      return event instanceof Error ? observer.error(event) : observer.next(event)
+    }
+
+    function onDisconnect(evt) {
+      stopped = true
+      unsubscribe()
+      observer.complete()
+    }
+
+    function unsubscribe() {
+      es.removeEventListener('error', onError, false)
+      es.removeEventListener('channelError', onChannelError, false)
+      es.removeEventListener('disconnect', onDisconnect, false)
+      listenFor.forEach((type) => es.removeEventListener(type, onMessage, false))
+      es.close()
+    }
+
+    function emitReconnect() {
+      if (shouldEmitReconnect) {
+        observer.next({type: 'reconnect'})
+      }
+    }
+
+    function getEventSource() {
+      const evs = new EventSource(uri, esOptions)
+      evs.addEventListener('error', onError, false)
+      evs.addEventListener('channelError', onChannelError, false)
+      evs.addEventListener('disconnect', onDisconnect, false)
+      listenFor.forEach((type) => evs.addEventListener(type, onMessage, false))
+      return evs
+    }
+
+    function open() {
+      es = getEventSource()
+    }
+
+    function stop() {
+      stopped = true
+      unsubscribe()
+    }
+
+    return stop
+  })
+}
+
+function parseEvent(event) {
+  try {
+    const data = (event.data && JSON.parse(event.data)) || {}
+    return Object.assign({type: event.type}, data)
+  } catch (err) {
+    return err
+  }
+}
+
+function cooerceError(err) {
+  if (err instanceof Error) {
+    return err
+  }
+
+  const evt = parseEvent(err)
+  return evt instanceof Error ? evt : new Error(extractErrorMessage(evt))
+}
+
+function extractErrorMessage(err) {
+  if (!err.error) {
+    return err.message || 'Unknown listener error'
+  }
+
+  if (err.error.description) {
+    return err.error.description
+  }
+
+  return typeof err.error === 'string' ? err.error : JSON.stringify(err.error, null, 2)
+}