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

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

package/src/sanityClient.js

@@ -0,0 +1,119 @@
+const assign = require('object-assign')
+const {Observable, map, filter} = require('./util/observable')
+const Patch = require('./data/patch')
+const Transaction = require('./data/transaction')
+const dataMethods = require('./data/dataMethods')
+const DatasetsClient = require('./datasets/datasetsClient')
+const ProjectsClient = require('./projects/projectsClient')
+const AssetsClient = require('./assets/assetsClient')
+const UsersClient = require('./users/usersClient')
+const AuthClient = require('./auth/authClient')
+const httpRequest = require('./http/request')
+const getRequestOptions = require('./http/requestOptions')
+const {defaultConfig, initConfig} = require('./config')
+const validate = require('./validators')
+
+const toPromise = (observable) => observable.toPromise()
+
+function SanityClient(config = defaultConfig) {
+  if (!(this instanceof SanityClient)) {
+    return new SanityClient(config)
+  }
+
+  this.config(config)
+
+  this.assets = new AssetsClient(this)
+  this.datasets = new DatasetsClient(this)
+  this.projects = new ProjectsClient(this)
+  this.users = new UsersClient(this)
+  this.auth = new AuthClient(this)
+
+  if (this.clientConfig.isPromiseAPI) {
+    const observableConfig = assign({}, this.clientConfig, {isPromiseAPI: false})
+    this.observable = new SanityClient(observableConfig)
+  }
+}
+
+assign(SanityClient.prototype, dataMethods)
+assign(SanityClient.prototype, {
+  clone() {
+    return new SanityClient(this.config())
+  },
+
+  config(newConfig) {
+    if (typeof newConfig === 'undefined') {
+      return assign({}, this.clientConfig)
+    }
+
+    if (this.observable) {
+      const observableConfig = assign({}, newConfig, {isPromiseAPI: false})
+      this.observable.config(observableConfig)
+    }
+
+    this.clientConfig = initConfig(newConfig, this.clientConfig || {})
+    return this
+  },
+
+  withConfig(newConfig) {
+    return this.clone().config(newConfig)
+  },
+
+  getUrl(uri, useCdn = false) {
+    const base = useCdn ? this.clientConfig.cdnUrl : this.clientConfig.url
+    return `${base}/${uri.replace(/^\//, '')}`
+  },
+
+  isPromiseAPI() {
+    return this.clientConfig.isPromiseAPI
+  },
+
+  _requestObservable(options) {
+    const uri = options.url || options.uri
+
+    // 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 = this.clientConfig.useCdn && canUseCdn
+
+    const tag =
+      options.tag && this.clientConfig.requestTagPrefix
+        ? [this.clientConfig.requestTagPrefix, options.tag].join('.')
+        : options.tag || this.clientConfig.requestTagPrefix
+
+    if (tag) {
+      options.query = {tag: validate.requestTag(tag), ...options.query}
+    }
+
+    const reqOptions = getRequestOptions(
+      this.clientConfig,
+      assign({}, options, {
+        url: this.getUrl(uri, useCdn),
+      })
+    )
+
+    return new Observable((subscriber) =>
+      httpRequest(reqOptions, this.clientConfig.requester).subscribe(subscriber)
+    )
+  },
+
+  request(options) {
+    const observable = this._requestObservable(options).pipe(
+      filter((event) => event.type === 'response'),
+      map((event) => event.body)
+    )
+
+    return this.isPromiseAPI() ? toPromise(observable) : observable
+  },
+})
+
+SanityClient.Patch = Patch
+SanityClient.Transaction = Transaction
+SanityClient.ClientError = httpRequest.ClientError
+SanityClient.ServerError = httpRequest.ServerError
+SanityClient.requester = httpRequest.defaultRequester
+
+module.exports = SanityClient

package/src/users/usersClient.js

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

package/src/util/defaults.js

@@ -0,0 +1,8 @@
+module.exports = (obj, defaults) =>
+  Object.keys(defaults)
+    .concat(Object.keys(obj))
+    .reduce((target, prop) => {
+      target[prop] = typeof obj[prop] === 'undefined' ? defaults[prop] : obj[prop]
+
+      return target
+    }, {})

package/src/util/getSelection.js

@@ -0,0 +1,17 @@
+module.exports = function getSelection(sel) {
+  if (typeof sel === 'string' || Array.isArray(sel)) {
+    return {id: sel}
+  }
+
+  if (sel && sel.query) {
+    return 'params' in sel ? {query: sel.query, params: sel.params} : {query: sel.query}
+  }
+
+  const selectionOpts = [
+    '* Document ID (<docId>)',
+    '* Array of document IDs',
+    '* Object containing `query`',
+  ].join('\n')
+
+  throw new Error(`Unknown selection - must be one of:\n\n${selectionOpts}`)
+}

package/src/util/observable.js

@@ -0,0 +1,11 @@
+//  Since `@sanity/client` doesn't offer ESM exports (yet) const {filter} = require('rxjs/operators') will cause the the whole of rxjs to be included in the bundle.
+//  The internal import paths here is a stop-gap measure and will become less of a problem when @sanity/client export tree-shakeable esm bundles
+const {Observable} = require('rxjs/internal/Observable')
+const {filter} = require('rxjs/internal/operators/filter')
+const {map} = require('rxjs/internal/operators/map')
+
+module.exports = {
+  Observable,
+  filter,
+  map,
+}

package/src/util/once.js

@@ -0,0 +1,12 @@
+module.exports = (fn) => {
+  let didCall = false
+  let returnValue
+  return (...args) => {
+    if (didCall) {
+      return returnValue
+    }
+    returnValue = fn(...args)
+    didCall = true
+    return returnValue
+  }
+}

package/src/util/pick.js

@@ -0,0 +1,9 @@
+module.exports = (obj, props) =>
+  props.reduce((selection, prop) => {
+    if (typeof obj[prop] === 'undefined') {
+      return selection
+    }
+
+    selection[prop] = obj[prop]
+    return selection
+  }, {})

package/src/validators.js

@@ -0,0 +1,76 @@
+const VALID_ASSET_TYPES = ['image', 'file']
+const VALID_INSERT_LOCATIONS = ['before', 'after', 'replace']
+
+exports.dataset = (name) => {
+  if (!/^(~[a-z0-9]{1}[-\w]{0,63}|[a-z0-9]{1}[-\w]{0,63})$/.test(name)) {
+    throw new Error(
+      'Datasets can only contain lowercase characters, numbers, underscores and dashes, and start with tilde, and be maximum 64 characters'
+    )
+  }
+}
+
+exports.projectId = (id) => {
+  if (!/^[-a-z0-9]+$/i.test(id)) {
+    throw new Error('`projectId` can only contain only a-z, 0-9 and dashes')
+  }
+}
+
+exports.validateAssetType = (type) => {
+  if (VALID_ASSET_TYPES.indexOf(type) === -1) {
+    throw new Error(`Invalid asset type: ${type}. Must be one of ${VALID_ASSET_TYPES.join(', ')}`)
+  }
+}
+
+exports.validateObject = (op, val) => {
+  if (val === null || typeof val !== 'object' || Array.isArray(val)) {
+    throw new Error(`${op}() takes an object of properties`)
+  }
+}
+
+exports.requireDocumentId = (op, doc) => {
+  if (!doc._id) {
+    throw new Error(`${op}() requires that the document contains an ID ("_id" property)`)
+  }
+
+  exports.validateDocumentId(op, doc._id)
+}
+
+exports.validateDocumentId = (op, id) => {
+  if (typeof id !== 'string' || !/^[a-z0-9_.-]+$/i.test(id)) {
+    throw new Error(`${op}(): "${id}" is not a valid document ID`)
+  }
+}
+
+exports.validateInsert = (at, selector, items) => {
+  const signature = 'insert(at, selector, items)'
+  if (VALID_INSERT_LOCATIONS.indexOf(at) === -1) {
+    const valid = VALID_INSERT_LOCATIONS.map((loc) => `"${loc}"`).join(', ')
+    throw new Error(`${signature} takes an "at"-argument which is one of: ${valid}`)
+  }
+
+  if (typeof selector !== 'string') {
+    throw new Error(`${signature} takes a "selector"-argument which must be a string`)
+  }
+
+  if (!Array.isArray(items)) {
+    throw new Error(`${signature} takes an "items"-argument which must be an array`)
+  }
+}
+
+exports.hasDataset = (config) => {
+  if (!config.dataset) {
+    throw new Error('`dataset` must be provided to perform queries')
+  }
+
+  return config.dataset || ''
+}
+
+exports.requestTag = (tag) => {
+  if (typeof tag !== 'string' || !/^[a-z0-9._-]{1,75}$/i.test(tag)) {
+    throw new Error(
+      `Tag can only contain alphanumeric characters, underscores, dashes and dots, and be between one and 75 characters long.`
+    )
+  }
+
+  return tag
+}

package/src/warnings.js

@@ -0,0 +1,25 @@
+const generateHelpUrl = require('@sanity/generate-help-url').generateHelpUrl
+const once = require('./util/once')
+
+const createWarningPrinter = (message) =>
+  // eslint-disable-next-line no-console
+  once((...args) => console.warn(message.join(' '), ...args))
+
+exports.printCdnWarning = createWarningPrinter([
+  'You are not using the Sanity CDN. That means your data is always fresh, but the CDN is faster and',
+  `cheaper. Think about it! For more info, see ${generateHelpUrl('js-client-cdn-configuration')}.`,
+  'To hide this warning, please set the `useCdn` option to either `true` or `false` when creating',
+  'the client.',
+])
+
+exports.printBrowserTokenWarning = createWarningPrinter([
+  'You have configured Sanity client to use a token in the browser. This may cause unintentional security issues.',
+  `See ${generateHelpUrl(
+    'js-client-browser-token'
+  )} for more information and how to hide this warning.`,
+])
+
+exports.printNoApiVersionSpecifiedWarning = createWarningPrinter([
+  'Using the Sanity client without specifying an API version is deprecated.',
+  `See ${generateHelpUrl('js-client-api-version')}`,
+])