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

package/src/data/dataMethods.js

@@ -0,0 +1,183 @@
+const assign = require('object-assign')
+const {map, filter} = require('../util/observable')
+const validators = require('../validators')
+const getSelection = require('../util/getSelection')
+const encodeQueryString = require('./encodeQueryString')
+const Transaction = require('./transaction')
+const Patch = require('./patch')
+const listen = require('./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
+
+module.exports = {
+  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 = 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
+
+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