@sanity/client 3.3.0 → 4.0.0-alpha.esm.3

package/src/data/patch.js

@@ -0,0 +1,119 @@
+import {getSelection} from '../util/getSelection'
+import {validateObject, validateInsert} from '../validators'
+
+export class Patch {
+  constructor(selection, operations = {}, client = null) {
+    this.selection = selection
+    this.operations = Object.assign({}, operations)
+    this.client = client
+  }
+
+  clone() {
+    return new Patch(this.selection, Object.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 = Object.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 Object.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 = Object.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 = Object.assign({}, this.operations, {
+      [op]: Object.assign({}, (merge && this.operations[op]) || {}, props),
+    })
+    return this
+  }
+}

package/src/data/transaction.js

@@ -0,0 +1,103 @@
+import * as validators from '../validators'
+import {Patch} from './patch'
+
+const defaultMutateOptions = {returnDocuments: false}
+
+export class Transaction {
+  constructor(operations = [], client, transactionId) {
+    this.trxId = transactionId
+    this.operations = operations
+    this.client = client
+  }
+
+  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: Object.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(),
+      Object.assign({transactionId: this.trxId}, defaultMutateOptions, options || {})
+    )
+  }
+
+  reset() {
+    this.operations = []
+    return this
+  }
+
+  _add(mut) {
+    this.operations.push(mut)
+    return this
+  }
+}

package/src/datasets/datasetsClient.js

@@ -0,0 +1,28 @@
+import * as validate from '../validators'
+
+export class DatasetsClient {
+  constructor(client) {
+    this.request = client.request.bind(client)
+  }
+
+  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})
+  }
+}

package/src/http/browserMiddleware.js

@@ -0,0 +1 @@
+export const middleware = []

package/src/http/errors.js

@@ -0,0 +1,53 @@
+import makeError from 'make-error'
+
+export function ClientError(res) {
+  const props = extractErrorProps(res)
+  ClientError.super.call(this, props.message)
+  Object.assign(this, props)
+}
+
+export function ServerError(res) {
+  const props = extractErrorProps(res)
+  ServerError.super.call(this, props.message)
+  Object.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)

package/src/http/nodeMiddleware.js

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

package/src/http/queryString.js

@@ -0,0 +1,10 @@
+export const queryString = (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,50 @@
+/* eslint-disable no-empty-function, no-process-env */
+import getIt from 'get-it'
+import observable from 'get-it/lib/middleware/observable'
+import jsonRequest from 'get-it/lib/middleware/jsonRequest'
+import jsonResponse from 'get-it/lib/middleware/jsonResponse'
+import progress from 'get-it/lib/middleware/progress'
+import {Observable} from '../util/observable'
+import {ClientError, ServerError} from './errors'
+// Environment-specific middleware.
+import {middleware as envSpecific} from './nodeMiddleware'
+
+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
+  },
+}
+
+const middleware = envSpecific.concat([
+  printWarnings,
+  jsonRequest(),
+  jsonResponse(),
+  progress(),
+  httpError,
+  observable({implementation: Observable}),
+])
+
+const request = getIt(middleware)
+
+export function httpRequest(options, requester = request) {
+  return requester(Object.assign({maxRedirects: 0}, options))
+}
+
+httpRequest.defaultRequester = request
+httpRequest.ClientError = ClientError
+httpRequest.ServerError = ServerError

package/src/http/requestOptions.js

@@ -0,0 +1,29 @@
+const projectHeader = 'X-Sanity-Project-ID'
+
+export const requestOptions = (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 Object.assign({}, overrides, {
+    headers: Object.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,13 @@
+export class ProjectsClient {
+  constructor(client) {
+    this.client = client
+  }
+
+  list() {
+    return this.client.request({uri: '/projects'})
+  }
+
+  getById(id) {
+    return this.client.request({uri: `/projects/${id}`})
+  }
+}

package/src/sanityClient.js

@@ -0,0 +1,124 @@
+import {Observable, map, filter} from './util/observable'
+import {Patch} from './data/patch'
+import {Transaction} from './data/transaction'
+import {dataMethods} from './data/dataMethods'
+import {DatasetsClient} from './datasets/datasetsClient'
+import {ProjectsClient} from './projects/projectsClient'
+import {AssetsClient} from './assets/assetsClient'
+import {UsersClient} from './users/usersClient'
+import {AuthClient} from './auth/authClient'
+import {httpRequest} from './http/request'
+import {requestOptions} from './http/requestOptions'
+import {defaultConfig, initConfig} from './config'
+import * as validate from './validators'
+
+const toPromise = (observable) => observable.toPromise()
+
+export class SanityClient {
+  constructor(config = defaultConfig) {
+    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 = Object.assign({}, this.clientConfig, {isPromiseAPI: false})
+      this.observable = new SanityClient(observableConfig)
+    }
+  }
+
+  clone() {
+    return new SanityClient(this.config())
+  }
+
+  config(newConfig) {
+    if (typeof newConfig === 'undefined') {
+      return Object.assign({}, this.clientConfig)
+    }
+
+    if (this.observable) {
+      const observableConfig = Object.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 = requestOptions(
+      this.clientConfig,
+      Object.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
+  }
+}
+
+Object.assign(SanityClient.prototype, dataMethods)
+
+SanityClient.Patch = Patch
+SanityClient.Transaction = Transaction
+SanityClient.ClientError = httpRequest.ClientError
+SanityClient.ServerError = httpRequest.ServerError
+SanityClient.requester = httpRequest.defaultRequester
+
+// Not using default exports is intentional, as it permits importing from both ESM and CJS node envs with less hazards
+// https://nodejs.org/docs/latest/api/packages.html#writing-dual-packages-while-avoiding-or-minimizing-hazards
+export function createClient(config) {
+  return new SanityClient(config)
+}
+createClient.Patch = Patch
+createClient.Transaction = Transaction
+createClient.ClientError = httpRequest.ClientError
+createClient.ServerError = httpRequest.ServerError
+createClient.requester = httpRequest.defaultRequester

package/src/users/usersClient.js

@@ -0,0 +1,9 @@
+export class UsersClient {
+  constructor(client) {
+    this.client = client
+  }
+
+  getById(id) {
+    return this.client.request({uri: `/users/${id}`})
+  }
+}

package/src/util/defaults.js

@@ -0,0 +1,9 @@
+// eslint-disable-next-line no-shadow
+export const defaults = (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 @@
+export 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,6 @@
+//  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
+
+export {Observable} from 'rxjs/internal/Observable'
+export {filter} from 'rxjs/internal/operators/filter'
+export {map} from 'rxjs/internal/operators/map'

package/src/util/once.js

@@ -0,0 +1,12 @@
+export const once = (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 @@
+export const pick = (obj, props) =>
+  props.reduce((selection, prop) => {
+    if (typeof obj[prop] === 'undefined') {
+      return selection
+    }
+
+    selection[prop] = obj[prop]
+    return selection
+  }, {})