@sanity/client 4.0.1-1 → 5.0.0-esm.0

package/src/data/transaction.ts

@@ -0,0 +1,352 @@
+import type {Observable} from 'rxjs'
+
+import type {ObservableSanityClient, SanityClient} from '../SanityClient'
+import type {
+  BaseMutationOptions,
+  IdentifiedSanityDocumentStub,
+  MultipleMutationResult,
+  Mutation,
+  PatchOperations,
+  SanityDocument,
+  SanityDocumentStub,
+  SingleMutationResult,
+  TransactionAllDocumentIdsMutationOptions,
+  TransactionAllDocumentsMutationOptions,
+  TransactionFirstDocumentIdMutationOptions,
+  TransactionFirstDocumentMutationOptions,
+} from '../types'
+import * as validators from '../validators'
+import {ObservablePatch, Patch} from './patch'
+
+export type PatchBuilder = (patch: Patch) => Patch
+export type ObservablePatchBuilder = (patch: ObservablePatch) => ObservablePatch
+
+const defaultMutateOptions = {returnDocuments: false}
+
+export class BaseTransaction {
+  protected operations: Mutation[]
+  protected trxId?: string
+  constructor(operations: Mutation[] = [], transactionId?: string) {
+    this.operations = operations
+    this.trxId = transactionId
+  }
+  /**
+   * Creates a new Sanity document. If `_id` is provided and already exists, the mutation will fail. If no `_id` is given, one will automatically be generated by the database.
+   * The operation is added to the current transaction, ready to be commited by `commit()`
+   *
+   * @param doc - Document to create. Requires a `_type` property.
+   */
+  create<R extends Record<string, any> = Record<string, any>>(doc: SanityDocumentStub<R>): this {
+    validators.validateObject('create', doc)
+    return this._add({create: doc})
+  }
+
+  /**
+   * Creates a new Sanity document. If a document with the same `_id` already exists, the create operation will be ignored.
+   * The operation is added to the current transaction, ready to be commited by `commit()`
+   *
+   * @param doc - Document to create if it does not already exist. Requires `_id` and `_type` properties.
+   */
+  createIfNotExists<R extends Record<string, any> = Record<string, any>>(
+    doc: IdentifiedSanityDocumentStub<R>
+  ): this {
+    const op = 'createIfNotExists'
+    validators.validateObject(op, doc)
+    validators.requireDocumentId(op, doc)
+    return this._add({[op]: doc})
+  }
+
+  /**
+   * Creates a new Sanity document, or replaces an existing one if the same `_id` is already used.
+   * The operation is added to the current transaction, ready to be commited by `commit()`
+   *
+   * @param doc - Document to create or replace. Requires `_id` and `_type` properties.
+   */
+  createOrReplace<R extends Record<string, any> = Record<string, any>>(
+    doc: IdentifiedSanityDocumentStub<R>
+  ): this {
+    const op = 'createOrReplace'
+    validators.validateObject(op, doc)
+    validators.requireDocumentId(op, doc)
+    return this._add({[op]: doc})
+  }
+
+  /**
+   * Deletes the document with the given document ID
+   * The operation is added to the current transaction, ready to be commited by `commit()`
+   *
+   * @param documentId - Document ID to delete
+   */
+  delete(documentId: string): this {
+    validators.validateDocumentId('delete', documentId)
+    return this._add({delete: {id: documentId}})
+  }
+
+  /**
+   * Gets the current transaction ID, if any
+   */
+  transactionId(): string | undefined
+  /**
+   * Set the ID of this transaction.
+   *
+   * @param id - Transaction ID
+   */
+  transactionId(id: string): this
+  transactionId(id?: string): this | string | undefined {
+    if (!id) {
+      return this.trxId
+    }
+
+    this.trxId = id
+    return this
+  }
+
+  /**
+   * Return a plain JSON representation of the transaction
+   */
+  serialize(): Mutation[] {
+    return [...this.operations]
+  }
+
+  /**
+   * Return a plain JSON representation of the transaction
+   */
+  toJSON(): Mutation[] {
+    return this.serialize()
+  }
+
+  /**
+   * Clears the transaction of all operations
+   */
+  reset(): this {
+    this.operations = []
+    return this
+  }
+
+  protected _add(mut: Mutation): this {
+    this.operations.push(mut)
+    return this
+  }
+}
+
+export class Transaction extends BaseTransaction {
+  #client?: SanityClient
+  constructor(operations?: Mutation[], client?: SanityClient, transactionId?: string) {
+    super(operations, transactionId)
+    this.#client = client
+  }
+
+  /**
+   * Clones the transaction
+   */
+  clone(): Transaction {
+    return new Transaction([...this.operations], this.#client, this.trxId)
+  }
+
+  /**
+   * Commit the transaction, returning a promise that resolves to the first mutated document
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit<R extends Record<string, any>>(
+    options: TransactionFirstDocumentMutationOptions
+  ): Promise<SanityDocument<R>>
+  /**
+   * Commit the transaction, returning a promise that resolves to an array of the mutated documents
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit<R extends Record<string, any>>(
+    options: TransactionAllDocumentsMutationOptions
+  ): Promise<SanityDocument<R>[]>
+  /**
+   * Commit the transaction, returning a promise that resolves to a mutation result object
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit(options: TransactionFirstDocumentIdMutationOptions): Promise<SingleMutationResult>
+  /**
+   * Commit the transaction, returning a promise that resolves to a mutation result object
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit(options: TransactionAllDocumentIdsMutationOptions): Promise<MultipleMutationResult>
+  /**
+   * Commit the transaction, returning a promise that resolves to a mutation result object
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit(options?: BaseMutationOptions): Promise<MultipleMutationResult>
+  commit<R extends Record<string, any> = Record<string, any>>(
+    options?:
+      | TransactionFirstDocumentMutationOptions
+      | TransactionAllDocumentsMutationOptions
+      | TransactionFirstDocumentIdMutationOptions
+      | TransactionAllDocumentIdsMutationOptions
+      | BaseMutationOptions
+  ): Promise<
+    SanityDocument<R> | SanityDocument<R>[] | SingleMutationResult | MultipleMutationResult
+  > {
+    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<R>(
+      this.serialize() as any,
+      Object.assign({transactionId: this.trxId}, defaultMutateOptions, options || {})
+    )
+  }
+
+  /**
+   * Performs a patch on the given document ID. Can either be a builder function or an object of patch operations.
+   * The operation is added to the current transaction, ready to be commited by `commit()`
+   *
+   * @param documentId - Document ID to perform the patch operation on
+   * @param patchOps - Operations to perform, or a builder function
+   */
+  patch(documentId: string, patchOps?: PatchBuilder | PatchOperations): this
+  /**
+   * Adds the given patch instance to the transaction.
+   * The operation is added to the current transaction, ready to be commited by `commit()`
+   *
+   * @param patch - Patch to execute
+   */
+  patch(patch: Patch): this
+  patch(patchOrDocumentId: Patch | string, patchOps?: PatchBuilder | PatchOperations): this {
+    const isBuilder = typeof patchOps === 'function'
+    const isPatch = typeof patchOrDocumentId !== 'string' && patchOrDocumentId instanceof Patch
+
+    // transaction.patch(client.patch('documentId').inc({visits: 1}))
+    if (isPatch) {
+      return this._add({patch: patchOrDocumentId.serialize()})
+    }
+
+    // patch => patch.inc({visits: 1}).set({foo: 'bar'})
+    if (isBuilder) {
+      const patch = patchOps(new Patch(patchOrDocumentId, {}, 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: {id: patchOrDocumentId, ...patchOps}})
+  }
+}
+
+export class ObservableTransaction extends BaseTransaction {
+  #client?: ObservableSanityClient
+  constructor(operations?: Mutation[], client?: ObservableSanityClient, transactionId?: string) {
+    super(operations, transactionId)
+    this.#client = client
+  }
+
+  /**
+   * Clones the transaction
+   */
+  clone(): ObservableTransaction {
+    return new ObservableTransaction([...this.operations], this.#client, this.trxId)
+  }
+
+  /**
+   * Commit the transaction, returning an observable that produces the first mutated document
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit<R extends Record<string, any>>(
+    options: TransactionFirstDocumentMutationOptions
+  ): Observable<SanityDocument<R>>
+  /**
+   * Commit the transaction, returning an observable that produces an array of the mutated documents
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit<R extends Record<string, any>>(
+    options: TransactionAllDocumentsMutationOptions
+  ): Observable<SanityDocument<R>[]>
+  /**
+   * Commit the transaction, returning an observable that produces a mutation result object
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit(options: TransactionFirstDocumentIdMutationOptions): Observable<SingleMutationResult>
+  /**
+   * Commit the transaction, returning an observable that produces a mutation result object
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit(options: TransactionAllDocumentIdsMutationOptions): Observable<MultipleMutationResult>
+  /**
+   * Commit the transaction, returning an observable that produces a mutation result object
+   *
+   * @param options - Options for the mutation operation
+   */
+  commit(options?: BaseMutationOptions): Observable<MultipleMutationResult>
+  commit<R extends Record<string, any> = Record<string, any>>(
+    options?:
+      | TransactionFirstDocumentMutationOptions
+      | TransactionAllDocumentsMutationOptions
+      | TransactionFirstDocumentIdMutationOptions
+      | TransactionAllDocumentIdsMutationOptions
+      | BaseMutationOptions
+  ): Observable<
+    SanityDocument<R> | SanityDocument<R>[] | SingleMutationResult | MultipleMutationResult
+  > {
+    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<R>(
+      this.serialize() as any,
+      Object.assign({transactionId: this.trxId}, defaultMutateOptions, options || {})
+    )
+  }
+
+  /**
+   * Performs a patch on the given document ID. Can either be a builder function or an object of patch operations.
+   * The operation is added to the current transaction, ready to be commited by `commit()`
+   *
+   * @param documentId - Document ID to perform the patch operation on
+   * @param patchOps - Operations to perform, or a builder function
+   */
+  patch(documentId: string, patchOps?: ObservablePatchBuilder | PatchOperations): this
+  /**
+   * Adds the given patch instance to the transaction.
+   * The operation is added to the current transaction, ready to be commited by `commit()`
+   *
+   * @param patch - ObservablePatch to execute
+   */
+  patch(patch: ObservablePatch): this
+  patch(
+    patchOrDocumentId: ObservablePatch | string,
+    patchOps?: ObservablePatchBuilder | PatchOperations
+  ): this {
+    const isBuilder = typeof patchOps === 'function'
+    const isPatch =
+      typeof patchOrDocumentId !== 'string' && patchOrDocumentId instanceof ObservablePatch
+
+    // transaction.patch(client.patch('documentId').inc({visits: 1}))
+    if (isPatch) {
+      return this._add({patch: patchOrDocumentId.serialize()})
+    }
+
+    // patch => patch.inc({visits: 1}).set({foo: 'bar'})
+    if (isBuilder) {
+      const patch = patchOps(new ObservablePatch(patchOrDocumentId, {}, this.#client))
+      if (!(patch instanceof ObservablePatch)) {
+        throw new Error('function passed to `patch()` must return the patch')
+      }
+
+      return this._add({patch: patch.serialize()})
+    }
+
+    return this._add({patch: {id: patchOrDocumentId, ...patchOps}})
+  }
+}

package/src/datasets/DatasetsClient.ts

@@ -0,0 +1,97 @@
+import {type Observable} from 'rxjs'
+
+import type {ObservableSanityClient, SanityClient} from '../SanityClient'
+import type {DatasetAclMode, DatasetResponse, DatasetsResponse} from '../types'
+import * as validate from '../validators'
+
+export class BaseDatasetsClient {
+  client: SanityClient | ObservableSanityClient
+
+  /**
+   * Create a new dataset with the given name
+   *
+   * @param name - Name of the dataset to create
+   * @param options - Options for the dataset
+   */
+  create(
+    this: DatasetsClient,
+    name: string,
+    options?: {aclMode?: DatasetAclMode}
+  ): Promise<DatasetResponse>
+  create(
+    this: ObservableDatasetsClient,
+    name: string,
+    options?: {aclMode?: DatasetAclMode}
+  ): Observable<DatasetResponse>
+  create(
+    name: string,
+    options?: {aclMode?: DatasetAclMode}
+  ): Promise<DatasetResponse> | Observable<DatasetResponse> {
+    return this.#_modify('PUT', name, options)
+  }
+
+  /**
+   * Edit a dataset with the given name
+   *
+   * @param name - Name of the dataset to edit
+   * @param options - New options for the dataset
+   */
+  edit(
+    this: DatasetsClient,
+    name: string,
+    options?: {aclMode?: DatasetAclMode}
+  ): Promise<DatasetResponse>
+  edit(
+    this: ObservableDatasetsClient,
+    name: string,
+    options?: {aclMode?: DatasetAclMode}
+  ): Observable<DatasetResponse>
+  edit(
+    name: string,
+    options?: {aclMode?: DatasetAclMode}
+  ): Promise<DatasetResponse> | Observable<DatasetResponse> {
+    return this.#_modify('PATCH', name, options)
+  }
+
+  /**
+   * Delete a dataset with the given name
+   *
+   * @param name - Name of the dataset to delete
+   */
+  delete(this: DatasetsClient, name: string): Promise<{deleted: true}>
+  delete(this: ObservableDatasetsClient, name: string): Observable<{deleted: true}>
+  delete(name: string): Promise<{deleted: true}> | Observable<{deleted: true}> {
+    return this.#_modify('DELETE', name)
+  }
+
+  /**
+   * Fetch a list of datasets for the configured project
+   */
+  list(this: DatasetsClient): Promise<DatasetsResponse>
+  list(this: ObservableDatasetsClient): Observable<DatasetsResponse>
+  list(): Promise<DatasetsResponse> | Observable<DatasetsResponse> {
+    return this.client.request({uri: '/datasets'})
+  }
+
+  #_modify(method: 'DELETE' | 'PATCH' | 'PUT', name: string, options?: {aclMode?: DatasetAclMode}) {
+    validate.dataset(name)
+    return this.client.request({method, uri: `/datasets/${name}`, body: options})
+  }
+}
+
+export class ObservableDatasetsClient extends BaseDatasetsClient {
+  client: ObservableSanityClient
+
+  constructor(client: ObservableSanityClient) {
+    super()
+    this.client = client
+  }
+}
+
+export class DatasetsClient extends BaseDatasetsClient {
+  client: SanityClient
+  constructor(client: SanityClient) {
+    super()
+    this.client = client
+  }
+}

package/src/generateHelpUrl.ts

@@ -0,0 +1,5 @@
+const BASE_URL = 'https://docs.sanity.io/help/'
+
+export default function generateHelpUrl(slug: string) {
+  return BASE_URL + slug
+}

package/src/http/browserMiddleware.ts

@@ -0,0 +1 @@
+export default []

package/src/http/errors.ts

@@ -0,0 +1,68 @@
+import {BaseError} from 'make-error'
+
+import {ErrorProps} from '../types'
+
+export class ClientError extends BaseError {
+  response: ErrorProps['response']
+  statusCode: ErrorProps['statusCode'] = 400
+  responseBody: ErrorProps['responseBody']
+  details: ErrorProps['details']
+
+  constructor(res: any) {
+    const props = extractErrorProps(res)
+    super(props.message)
+    Object.assign(this, props)
+  }
+}
+
+export class ServerError extends BaseError {
+  response: ErrorProps['response']
+  statusCode: ErrorProps['statusCode'] = 500
+  responseBody: ErrorProps['responseBody']
+  details: ErrorProps['details']
+
+  constructor(res: any) {
+    const props = extractErrorProps(res)
+    super(props.message)
+    Object.assign(this, props)
+  }
+}
+
+function extractErrorProps(res: any): ErrorProps {
+  const body = res.body
+  const props = {
+    response: res,
+    statusCode: res.statusCode,
+    responseBody: stringifyBody(body, res),
+    message: '',
+    details: undefined as any,
+  }
+
+  // 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: any) {
+  const statusMessage = res.statusMessage ? ` ${res.statusMessage}` : ''
+  return `${res.method}-request to ${res.url} resulted in HTTP ${res.statusCode}${statusMessage}`
+}
+
+function stringifyBody(body: any, res: any) {
+  const contentType = (res.headers['content-type'] || '').toLowerCase()
+  const isJson = contentType.indexOf('application/json') !== -1
+  return isJson ? JSON.stringify(body, null, 2) : body
+}

package/src/http/nodeMiddleware.ts

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

package/src/http/request.ts

@@ -0,0 +1,50 @@
+import {type Middlewares, getIt} from 'get-it'
+import {jsonRequest, jsonResponse, observable, progress} from 'get-it/middleware'
+import {Observable} from 'rxjs'
+
+import type {HttpRequest, RequestOptions} from '../types'
+import {ClientError, ServerError} from './errors'
+
+const httpError = {
+  onResponse: (res: any) => {
+    if (res.statusCode >= 500) {
+      throw new ServerError(res)
+    } else if (res.statusCode >= 400) {
+      throw new ClientError(res)
+    }
+
+    return res
+  },
+}
+
+const printWarnings = {
+  onResponse: (res: any) => {
+    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
+  },
+}
+
+/**
+ * @param envMiddleware Environment-specific middleware.
+ */
+export function defineHttpRequest(envMiddleware: Middlewares): HttpRequest {
+  const request = getIt([
+    ...envMiddleware,
+    printWarnings,
+    jsonRequest(),
+    jsonResponse(),
+    progress(),
+    httpError,
+    observable({implementation: Observable}),
+  ])
+
+  function httpRequest(options: RequestOptions, requester = request) {
+    return requester({maxRedirects: 0, ...options} as any)
+  }
+
+  httpRequest.defaultRequester = request
+
+  return httpRequest
+}

package/src/http/requestOptions.ts

@@ -0,0 +1,31 @@
+import type {RequestOptions} from 'get-it'
+
+const projectHeader = 'X-Sanity-Project-ID'
+
+export default (config: any, overrides: any = {}): Omit<RequestOptions, 'url'> => {
+  const headers: any = {}
+
+  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/index.browser.ts

@@ -0,0 +1,18 @@
+import envMiddleware from './http/browserMiddleware'
+import {defineHttpRequest} from './http/request'
+import {SanityClient} from './SanityClient'
+import type {ClientConfig} from './types'
+
+export * from './data/patch'
+export * from './data/transaction'
+export {ClientError, ServerError} from './http/errors'
+export * from './SanityClient'
+export * from './types'
+
+// Set the http client to use for requests, and its environment specific middleware
+const httpRequest = defineHttpRequest(envMiddleware)
+export const requester = httpRequest.defaultRequester
+
+export function createClient(config: ClientConfig) {
+  return new SanityClient(httpRequest, config)
+}

package/src/index.ts

@@ -0,0 +1,57 @@
+import envMiddleware from './http/nodeMiddleware'
+import {defineHttpRequest} from './http/request'
+import {SanityClient} from './SanityClient'
+import type {ClientConfig} from './types'
+
+export * from './data/patch'
+export * from './data/transaction'
+export {ClientError, ServerError} from './http/errors'
+export * from './SanityClient'
+export * from './types'
+
+// Set the http client to use for requests, and its environment specific middleware
+const httpRequest = defineHttpRequest(envMiddleware)
+export const requester = httpRequest.defaultRequester
+
+export function createClient(config: ClientConfig) {
+  return new SanityClient(httpRequest, config)
+}
+
+/*
+const client = createClient({})
+
+client.auth.getLoginProviders().then
+client.observable.auth.getLoginProviders().subscribe
+
+client.create({_id: 'id', _type: 'document'}, {}).then()
+client.observable.create({_id: 'id', _type: 'document'}, {}).subscribe()
+
+client.delete('id', {returnFirst: true}).then
+
+client.config({projectId: 'my-project-id'})
+// @ts-expect-error -- isPromiseAPI isn't allowed
+client.config({projectId: 'my-project-id', isPromiseAPI: false})
+client.fetch('', {}).then
+// @ts-expect-error -- observable is not allowed
+client.fetch('', {}).subscribe
+client.observable.fetch('', {}).subscribe
+// @ts-expect-error -- promise is not allowed
+client.observable.fetch('', {}).then
+
+client.assets.upload('image', Buffer.from('')).then
+client.observable.assets.upload('image', Buffer.from('')).subscribe
+// @ts-expect-error -- promise not allowed
+client.observable.assets.upload('image', Buffer.from('')).then
+// @ts-expect-error -- protected property
+client.assets.isPromiseAPI()
+
+const observableClient = new ObservableSanityClient(httpRequest, {})
+observableClient.config({projectId: 'my-project-id'})
+// eslint-disable-next-line no-console
+console.log(observableClient.isPromiseAPI() === false)
+observableClient.fetch('', {}).subscribe
+// @ts-expect-error -- promise is not allowed
+observableClient.fetch('', {}).then
+// @ts-expect-error -- observable is not allowed
+observableClient.observable.fetch
+// */