@sanity/client 7.1.0-views.0 → 7.1.0-views.2

package/src/releases/createRelease.ts

@@ -0,0 +1,53 @@
+import type {BaseActionOptions, CreateReleaseAction, ReleaseDocument} from '@sanity/client'
+
+import {generateReleaseId} from '../util/createVersionId'
+
+interface ReleaseOrOptions extends BaseActionOptions {
+  releaseId?: string
+  metadata?: Partial<ReleaseDocument['metadata']>
+}
+
+interface CompleteCreateReleaseAction extends CreateReleaseAction {
+  metadata: ReleaseDocument['metadata']
+}
+
+const getArgs = (
+  releaseOrOptions?: ReleaseOrOptions,
+  maybeOptions?: BaseActionOptions,
+): [string, Partial<ReleaseDocument['metadata']>, BaseActionOptions | undefined] => {
+  const isReleaseInput =
+    typeof releaseOrOptions === 'object' &&
+    releaseOrOptions !== null &&
+    ('releaseId' in releaseOrOptions || 'metadata' in releaseOrOptions)
+
+  if (isReleaseInput) {
+    const {releaseId = generateReleaseId(), metadata = {}} = releaseOrOptions
+    return [releaseId, metadata, maybeOptions]
+  }
+
+  return [generateReleaseId(), {}, releaseOrOptions as BaseActionOptions]
+}
+
+/** @internal */
+export const createRelease = (
+  releaseOrOptions?: ReleaseOrOptions,
+  maybeOptions?: BaseActionOptions,
+): {
+  action: CompleteCreateReleaseAction
+  options?: BaseActionOptions
+} => {
+  const [releaseId, metadata, options] = getArgs(releaseOrOptions, maybeOptions)
+
+  const finalMetadata: ReleaseDocument['metadata'] = {
+    ...metadata,
+    releaseType: metadata.releaseType || 'undecided',
+  }
+
+  const createAction: CompleteCreateReleaseAction = {
+    actionType: 'sanity.action.release.create',
+    releaseId,
+    metadata: finalMetadata,
+  }
+
+  return {action: createAction, options}
+}

package/src/types.ts

@@ -73,6 +73,7 @@ type ClientConfigResource =
   | {
       type: 'view'
       id: string
+      useEmulate?: boolean
     }
 
 /** @public */
@@ -107,6 +108,14 @@ export interface ClientConfig {
    * Optional request tag prefix for all request tags
    */
   requestTagPrefix?: string
+
+  /**
+   * Optional default headers to include with all requests
+   *
+   * @remarks request-specific headers will override any default headers with the same name.
+   */
+  headers?: Record<string, string>
+
   ignoreBrowserTokenWarning?: boolean
   withCredentials?: boolean
   allowReconfigure?: boolean
@@ -178,6 +187,12 @@ export interface InitializedClientConfig extends ClientConfig {
    * The fully initialized stega config, can be used to check if stega is enabled
    */
   stega: InitializedStegaConfig
+  /**
+   * Default headers to include with all requests
+   *
+   * @remarks request-specific headers will override any default headers with the same name.
+   */
+  headers?: Record<string, string>
 }
 
 /** @public */
@@ -578,6 +593,24 @@ export type Mutation<R extends Record<string, Any> = Record<string, Any>> =
   | {delete: MutationSelection}
   | {patch: PatchMutationOperation}
 
+/** @public */
+export type ReleaseAction =
+  | CreateReleaseAction
+  | EditReleaseAction
+  | PublishReleaseAction
+  | ArchiveReleaseAction
+  | UnarchiveReleaseAction
+  | ScheduleReleaseAction
+  | UnscheduleReleaseAction
+  | DeleteReleaseAction
+
+/** @public */
+export type VersionAction =
+  | CreateVersionAction
+  | DiscardVersionAction
+  | ReplaceVersionAction
+  | UnpublishVersionAction
+
 /** @public */
 export type Action =
   | CreateAction
@@ -587,6 +620,136 @@ export type Action =
   | DiscardAction
   | PublishAction
   | UnpublishAction
+  | VersionAction
+  | ReleaseAction
+
+/**
+ * Creates a new release under the given id, with metadata.
+ *
+ * @public
+ */
+export interface CreateReleaseAction {
+  actionType: 'sanity.action.release.create'
+  releaseId: string
+  metadata?: Partial<ReleaseDocument['metadata']>
+}
+
+/**
+ * Edits an existing release, updating the metadata.
+ *
+ * @public
+ */
+export interface EditReleaseAction {
+  actionType: 'sanity.action.release.edit'
+  releaseId: string
+  patch: PatchOperations
+}
+
+/**
+ * Publishes all documents in a release at once.
+ *
+ * @public
+ */
+export interface PublishReleaseAction {
+  actionType: 'sanity.action.release.publish'
+  releaseId: string
+}
+
+/**
+ * Archives an `active` release, and deletes all the release documents.
+ *
+ * @public
+ */
+export interface ArchiveReleaseAction {
+  actionType: 'sanity.action.release.archive'
+  releaseId: string
+}
+
+/**
+ * Unarchived an `archived` release, and restores all the release documents.
+ *
+ * @public
+ */
+export interface UnarchiveReleaseAction {
+  actionType: 'sanity.action.release.unarchive'
+  releaseId: string
+}
+
+/**
+ * Queues release for publishing at the given future time.
+ *
+ * @public
+ */
+export interface ScheduleReleaseAction {
+  actionType: 'sanity.action.release.schedule'
+  releaseId: string
+  publishAt: string
+}
+
+/**
+ * Unschedules a `scheduled` release, stopping it from being published.
+ *
+ * @public
+ */
+export interface UnscheduleReleaseAction {
+  actionType: 'sanity.action.release.unschedule'
+  releaseId: string
+}
+
+/**
+ * Deletes a `archived` or `published` release, and all the release documents versions.
+ *
+ * @public
+ */
+export interface DeleteReleaseAction {
+  actionType: 'sanity.action.release.delete'
+  releaseId: string
+}
+
+/**
+ * Creates a new version of an existing document, attached to the release as given
+ * by `document._id`
+ *
+ * @public
+ */
+export interface CreateVersionAction {
+  actionType: 'sanity.action.document.version.create'
+  publishedId: string
+  document: IdentifiedSanityDocumentStub
+}
+
+/**
+ * Delete a version of a document.
+ *
+ * @public
+ */
+export interface DiscardVersionAction {
+  actionType: 'sanity.action.document.version.discard'
+  versionId: string
+  purge?: boolean
+}
+
+/**
+ * Replace an existing version of a document.
+ *
+ * @public
+ */
+export interface ReplaceVersionAction {
+  actionType: 'sanity.action.document.version.replace'
+  document: IdentifiedSanityDocumentStub
+}
+
+/**
+ * Identify that a version of a document should be unpublished when
+ * the release that version is contained within is published.
+ *
+ * @public
+ */
+export interface UnpublishVersionAction {
+  actionType: 'sanity.action.document.version.unpublish'
+  versionId: string
+  publishedId: string
+}
 
 /**
  * Creates a new draft document. The published version of the document must not already exist.
@@ -619,6 +782,7 @@ export type CreateAction = {
  * At least one of the draft or published versions of the document must exist.
  *
  * @public
+ * @deprecated Use {@link ReplaceVersionAction} instead
  */
 export type ReplaceDraftAction = {
   actionType: 'sanity.action.document.replaceDraft'
@@ -691,6 +855,7 @@ export type DeleteAction = {
  * It is an error if it does not exist. If the purge flag is set, the document history is also deleted.
  *
  * @public
+ * @deprecated Use {@link DiscardVersionAction} instead
  */
 export type DiscardAction = {
   actionType: 'sanity.action.document.discard'
@@ -1064,11 +1229,47 @@ export interface UnfilteredResponseWithoutQuery extends ResponseQueryOptions {
   returnQuery: false
 }
 
+/** @public */
+export enum ViewResourceType {
+  Dataset = 'dataset',
+  View = 'view',
+}
+
+/** @public */
+export type ViewOverride = {
+  resourceType: ViewResourceType.View
+  resourceId: string
+  connections: ViewConnectionOverride[]
+}
+
+/** @public */
+export type ViewConnectionOverride = {
+  query: string
+  resourceType: ViewResourceType
+  resourceId: string
+}
+
+/** @public */
+export interface EmulatedResponseQueryOptions extends ResponseQueryOptions {
+  useEmulate: boolean
+  connections?: ViewConnectionOverride[] | undefined
+
+  filterResponse?: false
+  returnQuery?: false
+}
+
 /** @public */
 export type QueryOptions =
   | FilteredResponseQueryOptions
   | UnfilteredResponseQueryOptions
   | UnfilteredResponseWithoutQuery
+  | EmulatedResponseQueryOptions
+
+/** @public */
+export type ViewQueryOptions = Pick<
+  EmulatedResponseQueryOptions,
+  'perspective' | 'resultSourceMap' | 'filterResponse'
+>
 
 /** @public */
 export interface RawQueryResponse<R> {
@@ -1214,11 +1415,26 @@ export interface ApiError {
 
 /** @internal */
 export interface MutationError {
-  error: {
-    type: 'mutationError'
-    description: string
-    items?: MutationErrorItem[]
-  }
+  type: 'mutationError'
+  description: string
+  items?: MutationErrorItem[]
+}
+
+/**
+ * Returned from the Content Lake API when a query is malformed, usually with a start
+ * and end column to indicate where the error occurred, but not always. Can we used to
+ * provide a more structured error message to the user.
+ *
+ * This will be located under the response `error` property.
+ *
+ * @public
+ */
+export interface QueryParseError {
+  type: 'queryParseError'
+  description: string
+  start?: number
+  end?: number
+  query?: string
 }
 
 /** @internal */
@@ -1232,11 +1448,9 @@ export interface MutationErrorItem {
 
 /** @internal */
 export interface ActionError {
-  error: {
-    type: 'actionError'
-    description: string
-    items?: ActionErrorItem[]
-  }
+  type: 'actionError'
+  description: string
+  items?: ActionErrorItem[]
 }
 
 /** @internal */
@@ -1249,6 +1463,71 @@ export interface ActionErrorItem {
   index: number
 }
 
+/** @internal */
+export type PartialExcept<T, K extends keyof T> = Pick<T, K> & Partial<Omit<T, K>>
+
+/** @beta */
+export type ReleaseState =
+  | 'active'
+  | 'archiving'
+  | 'unarchiving'
+  | 'archived'
+  | 'published'
+  | 'publishing'
+  | 'scheduled'
+  | 'scheduling'
+
+/** @internal */
+export type ReleaseType = 'asap' | 'scheduled' | 'undecided'
+
+/** @internal */
+export interface ReleaseDocument extends SanityDocument {
+  /**
+   * typically
+   * `_.releases.<name>`
+   */
+  _id: string
+  /**
+   * where a release has _id `_.releases.foo`, the name is `foo`
+   */
+  name: string
+  _type: 'system.release'
+  _createdAt: string
+  _updatedAt: string
+  _rev: string
+  state: ReleaseState
+  error?: {
+    message: string
+  }
+  finalDocumentStates?: {
+    /** Document ID */
+    id: string
+  }[]
+  /**
+   * If defined, it takes precedence over the intendedPublishAt, the state should be 'scheduled'
+   */
+  publishAt?: string
+  /**
+   * If defined, it provides the time the release was actually published
+   */
+  publishedAt?: string
+  metadata: {
+    title?: string
+    description?: string
+    intendedPublishAt?: string
+    releaseType: ReleaseType
+  }
+}
+
+/** @internal */
+export type EditableReleaseDocument = Omit<
+  PartialExcept<ReleaseDocument, '_id'>,
+  'metadata' | '_type'
+> & {
+  _id: string
+  metadata: Partial<ReleaseDocument['metadata']>
+}
+
 /**
  * DocumentValueSource is a path to a value within a document
  * @public
@@ -1395,8 +1674,12 @@ export type {
   GenerateTargetDocument,
   GenerateTargetInclude,
 } from './agent/actions/generate'
+export type {PatchDocument, PatchOperation, PatchTarget} from './agent/actions/patch'
+export type {PromptRequest} from './agent/actions/prompt'
 export type {
+  ImageDescriptionOperation,
   TransformDocument,
+  TransformOperation,
   TransformTarget,
   TransformTargetDocument,
   TransformTargetInclude,

package/src/users/UsersClient.ts

@@ -47,9 +47,13 @@ export class UsersClient {
     id: T,
   ): Promise<T extends 'me' ? CurrentSanityUser : SanityUser> {
     return lastValueFrom(
-      _request<T extends 'me' ? CurrentSanityUser : SanityUser>(this.#client.config(), this.#httpRequest, {
-        uri: `/users/${id}`,
-      }),
+      _request<T extends 'me' ? CurrentSanityUser : SanityUser>(
+        this.#client.config(),
+        this.#httpRequest,
+        {
+          uri: `/users/${id}`,
+        },
+      ),
     )
   }
 }

package/src/util/codeFrame.ts

@@ -0,0 +1,174 @@
+/**
+ * Inlined, modified version of the `codeFrameColumns` function from `@babel/code-frame`.
+ * MIT-licensed - https://github.com/babel/babel/blob/main/LICENSE
+ * Copyright (c) 2014-present Sebastian McKenzie and other contributors.
+ */
+type Location = {
+  column: number
+  line: number
+}
+
+type NodeLocation = {
+  start: Location
+  end?: Location
+}
+
+type GroqLocation = {
+  start: number
+  end?: number
+}
+
+/**
+ * RegExp to test for newlines.
+ */
+
+const NEWLINE = /\r\n|[\n\r\u2028\u2029]/
+
+/**
+ * Extract what lines should be marked and highlighted.
+ */
+
+type MarkerLines = Record<number, true | [number, number]>
+
+/**
+ * Highlight a code frame with the given location and message.
+ *
+ * @param query - The query to be highlighted.
+ * @param location - The location of the error in the code/query.
+ * @param message - Message to be displayed inline (if possible) next to the highlighted
+ * location in the code. If it can't be positioned inline, it will be placed above the
+ * code frame.
+ * @returns The highlighted code frame.
+ */
+export function codeFrame(query: string, location: GroqLocation, message?: string): string {
+  const lines = query.split(NEWLINE)
+  const loc = {
+    start: columnToLine(location.start, lines),
+    end: location.end ? columnToLine(location.end, lines) : undefined,
+  }
+
+  const {start, end, markerLines} = getMarkerLines(loc, lines)
+
+  const numberMaxWidth = `${end}`.length
+
+  return query
+    .split(NEWLINE, end)
+    .slice(start, end)
+    .map((line, index) => {
+      const number = start + 1 + index
+      const paddedNumber = ` ${number}`.slice(-numberMaxWidth)
+      const gutter = ` ${paddedNumber} |`
+      const hasMarker = markerLines[number]
+      const lastMarkerLine = !markerLines[number + 1]
+      if (!hasMarker) {
+        return ` ${gutter}${line.length > 0 ? ` ${line}` : ''}`
+      }
+
+      let markerLine = ''
+      if (Array.isArray(hasMarker)) {
+        const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, ' ')
+        const numberOfMarkers = hasMarker[1] || 1
+
+        markerLine = [
+          '\n ',
+          gutter.replace(/\d/g, ' '),
+          ' ',
+          markerSpacing,
+          '^'.repeat(numberOfMarkers),
+        ].join('')
+
+        if (lastMarkerLine && message) {
+          markerLine += ' ' + message
+        }
+      }
+      return ['>', gutter, line.length > 0 ? ` ${line}` : '', markerLine].join('')
+    })
+    .join('\n')
+}
+
+function getMarkerLines(
+  loc: NodeLocation,
+  source: Array<string>,
+): {
+  start: number
+  end: number
+  markerLines: MarkerLines
+} {
+  const startLoc: Location = {...loc.start}
+  const endLoc: Location = {...startLoc, ...loc.end}
+  const linesAbove = 2
+  const linesBelow = 3
+  const startLine = startLoc.line ?? -1
+  const startColumn = startLoc.column ?? 0
+  const endLine = endLoc.line
+  const endColumn = endLoc.column
+
+  let start = Math.max(startLine - (linesAbove + 1), 0)
+  let end = Math.min(source.length, endLine + linesBelow)
+
+  if (startLine === -1) {
+    start = 0
+  }
+
+  if (endLine === -1) {
+    end = source.length
+  }
+
+  const lineDiff = endLine - startLine
+  const markerLines: MarkerLines = {}
+
+  if (lineDiff) {
+    for (let i = 0; i <= lineDiff; i++) {
+      const lineNumber = i + startLine
+
+      if (!startColumn) {
+        markerLines[lineNumber] = true
+      } else if (i === 0) {
+        const sourceLength = source[lineNumber - 1].length
+
+        markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1]
+      } else if (i === lineDiff) {
+        markerLines[lineNumber] = [0, endColumn]
+      } else {
+        const sourceLength = source[lineNumber - i].length
+
+        markerLines[lineNumber] = [0, sourceLength]
+      }
+    }
+  } else {
+    if (startColumn === endColumn) {
+      if (startColumn) {
+        markerLines[startLine] = [startColumn, 0]
+      } else {
+        markerLines[startLine] = true
+      }
+    } else {
+      markerLines[startLine] = [startColumn, endColumn - startColumn]
+    }
+  }
+
+  return {start, end, markerLines}
+}
+
+function columnToLine(column: number, lines: string[]): Location {
+  let offset = 0
+
+  for (let i = 0; i < lines.length; i++) {
+    const lineLength = lines[i].length + 1 // assume '\n' after each line
+
+    if (offset + lineLength > column) {
+      return {
+        line: i + 1, // 1-based line
+        column: column - offset, // 0-based column
+      }
+    }
+
+    offset += lineLength
+  }
+
+  // Fallback: beyond last line
+  return {
+    line: lines.length,
+    column: lines[lines.length - 1]?.length ?? 0,
+  }
+}

package/src/util/createVersionId.ts

@@ -0,0 +1,79 @@
+import {
+  getDraftId,
+  getVersionFromId,
+  getVersionId,
+  isDraftId,
+  isVersionId,
+} from '@sanity/client/csm'
+import {customAlphabet} from 'nanoid'
+
+import type {IdentifiedSanityDocumentStub, SanityDocumentStub} from '../types'
+import {validateVersionIdMatch} from '../validators'
+
+/**
+ * @internal
+ *
+ * ~24 years (or 7.54e+8 seconds) needed, in order to have a 1% probability of at least one collision if 10 ID's are generated every hour.
+ */
+export const generateReleaseId = customAlphabet(
+  'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789',
+  8,
+)
+
+/** @internal */
+export const getDocumentVersionId = (publishedId: string, releaseId?: string) =>
+  releaseId ? getVersionId(publishedId, releaseId) : getDraftId(publishedId)
+
+/** @internal */
+export function deriveDocumentVersionId(
+  op: string,
+  {
+    releaseId,
+    publishedId,
+    document,
+  }: {
+    releaseId?: string
+    publishedId?: string
+    document: SanityDocumentStub | IdentifiedSanityDocumentStub
+  },
+): string {
+  if (publishedId && document._id) {
+    const versionId = getDocumentVersionId(publishedId, releaseId)
+    validateVersionIdMatch(versionId, document)
+    return versionId
+  }
+
+  if (document._id) {
+    const isDraft = isDraftId(document._id)
+    const isVersion = isVersionId(document._id)
+
+    if (!isDraft && !isVersion) {
+      throw new Error(
+        `\`${op}()\` requires a document with an \`_id\` that is a version or draft ID`,
+      )
+    }
+
+    if (releaseId) {
+      if (isDraft) {
+        throw new Error(
+          `\`${op}()\` was called with a document ID (\`${document._id}\`) that is a draft ID, but a release ID (\`${releaseId}\`) was also provided.`,
+        )
+      }
+
+      const builtVersionId = getVersionFromId(document._id)
+      if (builtVersionId !== releaseId) {
+        throw new Error(
+          `\`${op}()\` was called with a document ID (\`${document._id}\`) that is a version ID, but the release ID (\`${releaseId}\`) does not match the document's version ID (\`${builtVersionId}\`).`,
+        )
+      }
+    }
+
+    return document._id
+  }
+
+  if (publishedId) {
+    return getDocumentVersionId(publishedId, releaseId)
+  }
+
+  throw new Error(`\`${op}()\` requires either a publishedId or a document with an \`_id\``)
+}