@sanity/client 3.3.2 → 3.4.0-beta.esm.1

package/src/data/encodeQueryString.js

@@ -0,0 +1,18 @@
+const enc = encodeURIComponent
+
+module.exports = ({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,160 @@
+const assign = require('object-assign')
+const {Observable} = require('../util/observable')
+const polyfilledEventSource = require('@sanity/eventsource')
+const pick = require('../util/pick')
+const defaults = require('../util/defaults')
+const encodeQueryString = require('./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,
+}
+
+module.exports = 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 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)
+}

package/src/data/patch.js

@@ -0,0 +1,124 @@
+const assign = require('object-assign')
+const getSelection = require('../util/getSelection')
+const validate = require('../validators')
+const validateObject = validate.validateObject
+const validateInsert = validate.validateInsert
+
+function Patch(selection, operations = {}, client = null) {
+  this.selection = selection
+  this.operations = assign({}, operations)
+  this.client = client
+}
+
+assign(Patch.prototype, {
+  clone() {
+    return new Patch(this.selection, assign({}, this.operations), this.client)
+  },
+
+  set(props) {
+    return this._assign('set', props)
+  },
+
+  diffMatchPatch(props) {
+    validateObject('diffMatchPatch', props)
+    return this._assign('diffMatchPatch', props)
+  },
+
+  unset(attrs) {
+    if (!Array.isArray(attrs)) {
+      throw new Error('unset(attrs) takes an array of attributes to unset, non-array given')
+    }
+
+    this.operations = assign({}, this.operations, {unset: attrs})
+    return this
+  },
+
+  setIfMissing(props) {
+    return this._assign('setIfMissing', props)
+  },
+
+  replace(props) {
+    validateObject('replace', props)
+    return this._set('set', {$: props}) // eslint-disable-line id-length
+  },
+
+  inc(props) {
+    return this._assign('inc', props)
+  },
+
+  dec(props) {
+    return this._assign('dec', props)
+  },
+
+  insert(at, selector, items) {
+    validateInsert(at, selector, items)
+    return this._assign('insert', {[at]: selector, items})
+  },
+
+  append(selector, items) {
+    return this.insert('after', `${selector}[-1]`, items)
+  },
+
+  prepend(selector, items) {
+    return this.insert('before', `${selector}[0]`, items)
+  },
+
+  splice(selector, start, deleteCount, items) {
+    // Negative indexes doesn't mean the same in Sanity as they do in JS;
+    // -1 means "actually at the end of the array", which allows inserting
+    // at the end of the array without knowing its length. We therefore have
+    // to substract negative indexes by one to match JS. If you want Sanity-
+    // behaviour, just use `insert('replace', selector, items)` directly
+    const delAll = typeof deleteCount === 'undefined' || deleteCount === -1
+    const startIndex = start < 0 ? start - 1 : start
+    const delCount = delAll ? -1 : Math.max(0, start + deleteCount)
+    const delRange = startIndex < 0 && delCount >= 0 ? '' : delCount
+    const rangeSelector = `${selector}[${startIndex}:${delRange}]`
+    return this.insert('replace', rangeSelector, items || [])
+  },
+
+  ifRevisionId(rev) {
+    this.operations.ifRevisionID = rev
+    return this
+  },
+
+  serialize() {
+    return assign(getSelection(this.selection), this.operations)
+  },
+
+  toJSON() {
+    return this.serialize()
+  },
+
+  commit(options = {}) {
+    if (!this.client) {
+      throw new Error(
+        'No `client` passed to patch, either provide one or pass the ' +
+          'patch to a clients `mutate()` method'
+      )
+    }
+
+    const returnFirst = typeof this.selection === 'string'
+    const opts = assign({returnFirst, returnDocuments: true}, options)
+    return this.client.mutate({patch: this.serialize()}, opts)
+  },
+
+  reset() {
+    this.operations = {}
+    return this
+  },
+
+  _set(op, props) {
+    return this._assign(op, props, false)
+  },
+
+  _assign(op, props, merge = true) {
+    validateObject(op, props)
+    this.operations = assign({}, this.operations, {
+      [op]: assign({}, (merge && this.operations[op]) || {}, props),
+    })
+    return this
+  },
+})
+
+module.exports = Patch

package/src/data/transaction.js

@@ -0,0 +1,106 @@
+const assign = require('object-assign')
+const validators = require('../validators')
+const Patch = require('./patch')
+
+const defaultMutateOptions = {returnDocuments: false}
+
+function Transaction(operations = [], client, transactionId) {
+  this.trxId = transactionId
+  this.operations = operations
+  this.client = client
+}
+
+assign(Transaction.prototype, {
+  clone() {
+    return new Transaction(this.operations.slice(0), this.client, this.trxId)
+  },
+
+  create(doc) {
+    validators.validateObject('create', doc)
+    return this._add({create: doc})
+  },
+
+  createIfNotExists(doc) {
+    const op = 'createIfNotExists'
+    validators.validateObject(op, doc)
+    validators.requireDocumentId(op, doc)
+    return this._add({[op]: doc})
+  },
+
+  createOrReplace(doc) {
+    const op = 'createOrReplace'
+    validators.validateObject(op, doc)
+    validators.requireDocumentId(op, doc)
+    return this._add({[op]: doc})
+  },
+
+  delete(documentId) {
+    validators.validateDocumentId('delete', documentId)
+    return this._add({delete: {id: documentId}})
+  },
+
+  patch(documentId, patchOps) {
+    const isBuilder = typeof patchOps === 'function'
+    const isPatch = documentId instanceof Patch
+
+    // transaction.patch(client.patch('documentId').inc({visits: 1}))
+    if (isPatch) {
+      return this._add({patch: documentId.serialize()})
+    }
+
+    // patch => patch.inc({visits: 1}).set({foo: 'bar'})
+    if (isBuilder) {
+      const patch = patchOps(new Patch(documentId, {}, this.client))
+      if (!(patch instanceof Patch)) {
+        throw new Error('function passed to `patch()` must return the patch')
+      }
+
+      return this._add({patch: patch.serialize()})
+    }
+
+    return this._add({patch: assign({id: documentId}, patchOps)})
+  },
+
+  transactionId(id) {
+    if (!id) {
+      return this.trxId
+    }
+
+    this.trxId = id
+    return this
+  },
+
+  serialize() {
+    return this.operations.slice()
+  },
+
+  toJSON() {
+    return this.serialize()
+  },
+
+  commit(options) {
+    if (!this.client) {
+      throw new Error(
+        'No `client` passed to transaction, either provide one or pass the ' +
+          'transaction to a clients `mutate()` method'
+      )
+    }
+
+    return this.client.mutate(
+      this.serialize(),
+      assign({transactionId: this.trxId}, defaultMutateOptions, options || {})
+    )
+  },
+
+  reset() {
+    this.operations = []
+    return this
+  },
+
+  _add(mut) {
+    this.operations.push(mut)
+    return this
+  },
+})
+
+module.exports = Transaction

package/src/datasets/datasetsClient.js

@@ -0,0 +1,31 @@
+const assign = require('object-assign')
+const validate = require('../validators')
+
+function DatasetsClient(client) {
+  this.request = client.request.bind(client)
+}
+
+assign(DatasetsClient.prototype, {
+  create(name, options) {
+    return this._modify('PUT', name, options)
+  },
+
+  edit(name, options) {
+    return this._modify('PATCH', name, options)
+  },
+
+  delete(name) {
+    return this._modify('DELETE', name)
+  },
+
+  list() {
+    return this.request({uri: '/datasets'})
+  },
+
+  _modify(method, name, body) {
+    validate.dataset(name)
+    return this.request({method, uri: `/datasets/${name}`, body})
+  },
+})
+
+module.exports = DatasetsClient

package/src/http/browserMiddleware.js

@@ -0,0 +1 @@
+module.exports = []

package/src/http/errors.js

@@ -0,0 +1,57 @@
+const makeError = require('make-error')
+const assign = require('object-assign')
+
+function ClientError(res) {
+  const props = extractErrorProps(res)
+  ClientError.super.call(this, props.message)
+  assign(this, props)
+}
+
+function ServerError(res) {
+  const props = extractErrorProps(res)
+  ServerError.super.call(this, props.message)
+  assign(this, props)
+}
+
+function extractErrorProps(res) {
+  const body = res.body
+  const props = {
+    response: res,
+    statusCode: res.statusCode,
+    responseBody: stringifyBody(body, res),
+  }
+
+  // API/Boom style errors ({statusCode, error, message})
+  if (body.error && body.message) {
+    props.message = `${body.error} - ${body.message}`
+    return props
+  }
+
+  // Query/database errors ({error: {description, other, arb, props}})
+  if (body.error && body.error.description) {
+    props.message = body.error.description
+    props.details = body.error
+    return props
+  }
+
+  // Other, more arbitrary errors
+  props.message = body.error || body.message || httpErrorMessage(res)
+  return props
+}
+
+function httpErrorMessage(res) {
+  const statusMessage = res.statusMessage ? ` ${res.statusMessage}` : ''
+  return `${res.method}-request to ${res.url} resulted in HTTP ${res.statusCode}${statusMessage}`
+}
+
+function stringifyBody(body, res) {
+  const contentType = (res.headers['content-type'] || '').toLowerCase()
+  const isJson = contentType.indexOf('application/json') !== -1
+  return isJson ? JSON.stringify(body, null, 2) : body
+}
+
+makeError(ClientError)
+makeError(ServerError)
+
+exports.ClientError = ClientError
+exports.ServerError = ServerError

package/src/http/nodeMiddleware.js

@@ -0,0 +1,13 @@
+const retry = require('get-it/lib-node/middleware/retry')
+const debug = require('get-it/lib-node/middleware/debug')
+const headers = require('get-it/lib-node/middleware/headers')
+
+const pkg = require('../../package.json')
+
+const middleware = [
+  debug({verbose: true, namespace: 'sanity:client'}),
+  headers({'User-Agent': `${pkg.name} ${pkg.version}`}),
+  retry({maxRetries: 3}),
+]
+
+module.exports = middleware

package/src/http/queryString.js

@@ -0,0 +1,10 @@
+module.exports = (params) => {
+  const qs = []
+  for (const key in params) {
+    if (params.hasOwnProperty(key)) {
+      qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`)
+    }
+  }
+
+  return qs.length > 0 ? `?${qs.join('&')}` : ''
+}

package/src/http/request.js

@@ -0,0 +1,54 @@
+/* eslint-disable no-empty-function, no-process-env */
+const getIt = require('get-it')
+const assign = require('object-assign')
+const observable = require('get-it/lib/middleware/observable')
+const jsonRequest = require('get-it/lib/middleware/jsonRequest')
+const jsonResponse = require('get-it/lib/middleware/jsonResponse')
+const progress = require('get-it/lib/middleware/progress')
+const {Observable} = require('../util/observable')
+const {ClientError, ServerError} = require('./errors')
+
+const httpError = {
+  onResponse: (res) => {
+    if (res.statusCode >= 500) {
+      throw new ServerError(res)
+    } else if (res.statusCode >= 400) {
+      throw new ClientError(res)
+    }
+
+    return res
+  },
+}
+
+const printWarnings = {
+  onResponse: (res) => {
+    const warn = res.headers['x-sanity-warning']
+    const warnings = Array.isArray(warn) ? warn : [warn]
+    warnings.filter(Boolean).forEach((msg) => console.warn(msg)) // eslint-disable-line no-console
+    return res
+  },
+}
+
+// Environment-specific middleware.
+const envSpecific = require('./nodeMiddleware')
+
+const middleware = envSpecific.concat([
+  printWarnings,
+  jsonRequest(),
+  jsonResponse(),
+  progress(),
+  httpError,
+  observable({implementation: Observable}),
+])
+
+const request = getIt(middleware)
+
+function httpRequest(options, requester = request) {
+  return requester(assign({maxRedirects: 0}, options))
+}
+
+httpRequest.defaultRequester = request
+httpRequest.ClientError = ClientError
+httpRequest.ServerError = ServerError
+
+module.exports = httpRequest

package/src/http/requestOptions.js

@@ -0,0 +1,31 @@
+const assign = require('object-assign')
+
+const projectHeader = 'X-Sanity-Project-ID'
+
+module.exports = (config, overrides = {}) => {
+  const headers = {}
+
+  const token = overrides.token || config.token
+  if (token) {
+    headers.Authorization = `Bearer ${token}`
+  }
+
+  if (!overrides.useGlobalApi && !config.useProjectHostname && config.projectId) {
+    headers[projectHeader] = config.projectId
+  }
+
+  const withCredentials = Boolean(
+    typeof overrides.withCredentials === 'undefined'
+      ? config.token || config.withCredentials
+      : overrides.withCredentials
+  )
+
+  const timeout = typeof overrides.timeout === 'undefined' ? config.timeout : overrides.timeout
+  return assign({}, overrides, {
+    headers: assign({}, headers, overrides.headers || {}),
+    timeout: typeof timeout === 'undefined' ? 5 * 60 * 1000 : timeout,
+    proxy: overrides.proxy || config.proxy,
+    json: true,
+    withCredentials,
+  })
+}

package/src/projects/projectsClient.js

@@ -0,0 +1,17 @@
+const assign = require('object-assign')
+
+function ProjectsClient(client) {
+  this.client = client
+}
+
+assign(ProjectsClient.prototype, {
+  list() {
+    return this.client.request({uri: '/projects'})
+  },
+
+  getById(id) {
+    return this.client.request({uri: `/projects/${id}`})
+  },
+})
+
+module.exports = ProjectsClient