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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/client",
-  "version": "3.4.0-beta.esm.1",
+  "version": "3.4.0-beta.esm.2",
   "description": "Client for retrieving, creating and patching data from Sanity.io",
   "main": "lib/sanityClient.js",
   "umd": "umd/sanityClient.min.js",
@@ -17,7 +17,6 @@
   "files": [
     "dist",
     "lib",
-    "src",
     "umd",
     "sanityClient.d.ts"
   ],

package/src/assets/assetsClient.js

@@ -1,135 +0,0 @@
-const assign = require('object-assign')
-const {map, filter} = require('../util/observable')
-const queryString = require('../http/queryString')
-const validators = require('../validators')
-
-function AssetsClient(client) {
-  this.client = client
-}
-
-function optionsFromFile(opts, file) {
-  if (typeof window === 'undefined' || !(file instanceof window.File)) {
-    return opts
-  }
-
-  return assign(
-    {
-      filename: opts.preserveFilename === false ? undefined : file.name,
-      contentType: file.type,
-    },
-    opts
-  )
-}
-
-assign(AssetsClient.prototype, {
-  /**
-   * 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}`
-  },
-})
-
-module.exports = AssetsClient

package/src/auth/authClient.js

@@ -1,17 +0,0 @@
-const assign = require('object-assign')
-
-function AuthClient(client) {
-  this.client = client
-}
-
-assign(AuthClient.prototype, {
-  getLoginProviders() {
-    return this.client.request({uri: '/auth/providers'})
-  },
-
-  logout() {
-    return this.client.request({uri: '/auth/logout', method: 'POST'})
-  },
-})
-
-module.exports = AuthClient

package/src/config.js

@@ -1,96 +0,0 @@
-const generateHelpUrl = require('@sanity/generate-help-url').generateHelpUrl
-const assign = require('object-assign')
-const validate = require('./validators')
-const warnings = require('./warnings')
-
-const defaultCdnHost = 'apicdn.sanity.io'
-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
-
-exports.defaultConfig = defaultConfig
-
-// eslint-disable-next-line complexity
-exports.initConfig = (config, prevConfig) => {
-  const specifiedConfig = assign({}, prevConfig, config)
-  if (!specifiedConfig.apiVersion) {
-    warnings.printNoApiVersionSpecifiedWarning()
-  }
-
-  const newConfig = 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
-
-  exports.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
-}
-
-exports.validateApiVersion = 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

@@ -1,183 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,160 +0,0 @@
-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)
-}