@sanity/client 6.7.1-pink-lizard.4 → 6.7.1

package/src/stega/SanityStegaClient.ts

@@ -1,244 +0,0 @@
-import {Observable} from 'rxjs'
-import {map} from 'rxjs/operators'
-
-import {defaultConfig} from '../config'
-import {ObservableSanityClient, SanityClient} from '../SanityClient'
-import type {
-  Any,
-  ClientConfig,
-  FilteredResponseQueryOptions,
-  HttpRequest,
-  QueryParams,
-  RawQueryResponse,
-  UnfilteredResponseQueryOptions,
-} from '../types'
-import {defaultStegaConfig, initStegaConfig, splitConfig} from './config'
-import {stegaEncodeSourceMap} from './stegaEncodeSourceMap'
-import {ClientStegaConfig, InitializedClientStegaConfig, InitializedStegaConfig} from './types'
-
-/** @public */
-export class ObservableSanityStegaClient extends ObservableSanityClient {
-  /**
-   * Private properties
-   */
-  #httpRequest: HttpRequest
-  private stegaConfig: InitializedStegaConfig
-
-  constructor(httpRequest: HttpRequest, config: ClientStegaConfig = defaultConfig) {
-    const {clientConfig, stegaConfig} = splitConfig(config)
-    super(httpRequest, clientConfig)
-
-    this.#httpRequest = httpRequest
-    this.stegaConfig = initStegaConfig(stegaConfig, defaultStegaConfig)
-  }
-
-  /**
-   * Clone the client - returns a new instance
-   */
-  clone(): ObservableSanityStegaClient {
-    return new ObservableSanityStegaClient(this.#httpRequest, this.config())
-  }
-
-  /**
-   * Returns the current client configuration
-   */
-  config(): InitializedClientStegaConfig
-  /**
-   * Reconfigure the client. Note that this _mutates_ the current client.
-   */
-  config(newConfig?: Partial<ClientStegaConfig>): this
-  config(newConfig?: Partial<ClientStegaConfig>): ClientStegaConfig | this {
-    if (newConfig === undefined) {
-      return {...super.config(), stega: {...this.stegaConfig}}
-    }
-
-    super.config(newConfig)
-
-    const {stegaConfig} = splitConfig(newConfig)
-
-    this.stegaConfig = initStegaConfig(stegaConfig, this.stegaConfig || {})
-    return this
-  }
-
-  /**
-   * Clone the client with a new (partial) configuration.
-   *
-   * @param newConfig - New client configuration properties, shallowly merged with existing configuration
-   */
-  withConfig(newConfig?: Partial<ClientConfig>): ObservableSanityStegaClient {
-    return new ObservableSanityStegaClient(this.#httpRequest, {...this.config(), ...newConfig})
-  }
-
-  /**
-   * Perform a GROQ-query against the configured dataset.
-   *
-   * @param query - GROQ-query to perform
-   */
-  fetch<R = Any>(query: string): Observable<R>
-  /**
-   * Perform a GROQ-query against the configured dataset.
-   *
-   * @param query - GROQ-query to perform
-   * @param params - Query parameters
-   */
-  fetch<R = Any, Q = QueryParams>(query: string, params: Q): Observable<R>
-  /**
-   * Perform a GROQ-query against the configured dataset.
-   *
-   * @param query - GROQ-query to perform
-   * @param params - Query parameters
-   * @param options - Request options
-   */
-  fetch<R = Any, Q = QueryParams>(
-    query: string,
-    params: Q | undefined,
-    options: FilteredResponseQueryOptions,
-  ): Observable<R>
-  /**
-   * Perform a GROQ-query against the configured dataset.
-   *
-   * @param query - GROQ-query to perform
-   * @param params - Query parameters
-   * @param options - Request options
-   */
-  fetch<R = Any, Q = QueryParams>(
-    query: string,
-    params: Q | undefined,
-    options: UnfilteredResponseQueryOptions,
-  ): Observable<RawQueryResponse<R>>
-  fetch<R, Q extends QueryParams>(
-    query: string,
-    params?: Q,
-    options: FilteredResponseQueryOptions | UnfilteredResponseQueryOptions = {},
-  ): Observable<RawQueryResponse<R> | R> {
-    const {filterResponse: originalFilterResponse = true} = options
-    return super
-      .fetch<R, Q>(query, params, Object.assign({}, options as Any, {filterResponse: false}))
-      .pipe(
-        map((res: Any) => {
-          const {result: _result, resultSourceMap} = res as RawQueryResponse<R>
-          let result = _result
-          if (this.stegaConfig.enabled) {
-            result = stegaEncodeSourceMap(_result, resultSourceMap, this.stegaConfig)
-          }
-          return originalFilterResponse ? result : {...res, result}
-        }),
-      )
-  }
-}
-
-/** @public */
-export class SanityStegaClient extends SanityClient {
-  /**
-   * Observable version of the Sanity client, with the same configuration as the promise-based one
-   */
-  observable: ObservableSanityStegaClient
-
-  /**
-   * Private properties
-   */
-  #httpRequest: HttpRequest
-  private stegaConfig: InitializedStegaConfig
-
-  constructor(httpRequest: HttpRequest, config: ClientStegaConfig = defaultConfig) {
-    const {clientConfig, stegaConfig} = splitConfig(config)
-    super(httpRequest, clientConfig)
-
-    this.#httpRequest = httpRequest
-    this.stegaConfig = initStegaConfig(stegaConfig, defaultStegaConfig)
-
-    this.observable = new ObservableSanityStegaClient(httpRequest, config)
-  }
-
-  /**
-   * Clone the client - returns a new instance
-   */
-  clone(): SanityStegaClient {
-    return new SanityStegaClient(this.#httpRequest, this.config())
-  }
-
-  /**
-   * Returns the current client configuration
-   */
-  config(): InitializedClientStegaConfig
-  /**
-   * Reconfigure the client. Note that this _mutates_ the current client.
-   */
-  config(newConfig?: Partial<ClientStegaConfig>): this
-  config(newConfig?: Partial<ClientStegaConfig>): ClientStegaConfig | this {
-    if (newConfig === undefined) {
-      return {...super.config(), stega: {...this.stegaConfig}}
-    }
-
-    super.config(newConfig)
-
-    const {stegaConfig} = splitConfig(newConfig)
-
-    this.stegaConfig = initStegaConfig(stegaConfig, {...(this.stegaConfig || {})})
-    return this
-  }
-
-  /**
-   * Clone the client with a new (partial) configuration.
-   *
-   * @param newConfig - New client configuration properties, shallowly merged with existing configuration
-   */
-  withConfig(newConfig?: Partial<ClientStegaConfig>): SanityStegaClient {
-    return new SanityStegaClient(this.#httpRequest, {...this.config(), ...newConfig})
-  }
-
-  /**
-   * Perform a GROQ-query against the configured dataset.
-   *
-   * @param query - GROQ-query to perform
-   */
-  fetch<R = Any>(query: string): Promise<R>
-  /**
-   * Perform a GROQ-query against the configured dataset.
-   *
-   * @param query - GROQ-query to perform
-   * @param params - Optional query parameters
-   */
-  fetch<R = Any, Q = QueryParams>(query: string, params: Q): Promise<R>
-  /**
-   * Perform a GROQ-query against the configured dataset.
-   *
-   * @param query - GROQ-query to perform
-   * @param params - Optional query parameters
-   * @param options - Request options
-   */
-  fetch<R = Any, Q = QueryParams>(
-    query: string,
-    params: Q | undefined,
-    options: FilteredResponseQueryOptions,
-  ): Promise<R>
-  /**
-   * Perform a GROQ-query against the configured dataset.
-   *
-   * @param query - GROQ-query to perform
-   * @param params - Optional query parameters
-   * @param options - Request options
-   */
-  fetch<R = Any, Q = QueryParams>(
-    query: string,
-    params: Q | undefined,
-    options: UnfilteredResponseQueryOptions,
-  ): Promise<RawQueryResponse<R>>
-  fetch<R, Q extends QueryParams>(
-    query: string,
-    params?: Q,
-    options: FilteredResponseQueryOptions | UnfilteredResponseQueryOptions = {},
-  ): Promise<RawQueryResponse<R> | R> {
-    const {filterResponse: originalFilterResponse = true} = options
-    return super
-      .fetch<R, Q>(query, params, Object.assign({}, options as Any, {filterResponse: false}))
-      .then((res: Any) => {
-        const {result: _result, resultSourceMap} = res as RawQueryResponse<R>
-        let result = _result
-        if (this.stegaConfig.enabled) {
-          result = stegaEncodeSourceMap(_result, resultSourceMap, this.stegaConfig)
-        }
-        return originalFilterResponse ? result : {...res, result}
-      })
-  }
-}

package/src/stega/config.ts

@@ -1,56 +0,0 @@
-import type {ClientConfig} from '../types'
-import type {ClientStegaConfig, InitializedStegaConfig, StegaConfig} from './types'
-
-export const defaultStegaConfig: StegaConfig = {
-  enabled: false,
-  filter: (props) => props.filterDefault(props),
-  vercelStegaCombineSkip: 'auto',
-}
-
-export function splitConfig(config: ClientStegaConfig): {
-  clientConfig: ClientConfig
-  stegaConfig: StegaConfig
-} {
-  const {stega = {}, ...clientConfig} = config
-  return {clientConfig, stegaConfig: stega}
-}
-
-export const initStegaConfig = (
-  config: Partial<StegaConfig>,
-  prevConfig: Partial<StegaConfig>,
-): InitializedStegaConfig => {
-  const specifiedConfig = Object.assign({} as StegaConfig, prevConfig, config)
-  const newConfig = Object.assign({} as InitializedStegaConfig, defaultStegaConfig, specifiedConfig)
-
-  if ('encodeSourceMap' in newConfig) {
-    throw new Error(
-      `It looks like you're using options meant for '@sanity/preview-kit/client'. 'encodeSourceMap' is not supported in '@sanity/client/stega'. Did you mean 'enabled'?`,
-    )
-  }
-
-  if ('encodeSourceMapAtPath' in newConfig) {
-    throw new Error(
-      `It looks like you're using options meant for '@sanity/preview-kit/client'. 'encodeSourceMapAtPath' is not supported in '@sanity/client/stega'. Did you mean 'filter'?`,
-    )
-  }
-
-  if (typeof newConfig.enabled !== 'boolean') {
-    throw new Error(`config.enabled must be a boolean, received ${newConfig.enabled}`)
-  }
-
-  if (newConfig.enabled && newConfig.studioUrl === undefined) {
-    throw new Error(`config.studioUrl must be defined when config.enabled is true`)
-  }
-
-  if (
-    newConfig.enabled &&
-    typeof newConfig.studioUrl !== 'string' &&
-    typeof newConfig.studioUrl !== 'function'
-  ) {
-    throw new Error(
-      `config.studioUrl must be a string or a function, received ${newConfig.studioUrl}`,
-    )
-  }
-
-  return newConfig
-}

package/src/stega/encodeIntoResult.test.ts

@@ -1,268 +0,0 @@
-import {expect, test, vi} from 'vitest'
-
-import type {ContentSourceMap} from '../types'
-import {encodeIntoResult} from './encodeIntoResult'
-
-const encodeTestCases: {
-  name: string
-  queryResult: {
-    result: unknown
-    resultSourceMap: ContentSourceMap
-  }
-  options?: {
-    keyArraySelectors: boolean
-  }
-  expected: {
-    encoderCalls: number
-    encoderArgs: unknown[][]
-  }
-}[] = [
-  {
-    name: 'resolves exact mappings to source',
-    queryResult: {
-      result: [
-        {
-          _id: 'foo',
-          this: 'that',
-        },
-      ],
-      resultSourceMap: {
-        documents: [
-          {
-            _id: 'foo',
-            _type: 'bar',
-          },
-        ],
-        paths: ["$['this']"],
-        mappings: {
-          "$[0]['this']": {
-            source: {
-              document: 0,
-              path: 0,
-              type: 'documentValue',
-            },
-            type: 'value',
-          },
-        },
-      },
-    },
-    expected: {
-      encoderCalls: 1,
-      encoderArgs: [
-        [
-          {
-            sourcePath: ['this'],
-            sourceDocument: {
-              _id: 'foo',
-              _type: 'bar',
-            },
-            resultPath: [0, 'this'],
-            value: 'that',
-          },
-        ],
-      ],
-    },
-  },
-  {
-    name: 'resolves aggregated mappings to source',
-    queryResult: {
-      result: [
-        {
-          _id: 'foo',
-          nested: {
-            object: {
-              this: 'that',
-            },
-          },
-        },
-      ],
-      resultSourceMap: {
-        documents: [
-          {
-            _id: 'foo',
-            _type: 'bar',
-          },
-        ],
-        paths: ["$['something']['nested']"],
-        mappings: {
-          "$[0]['nested']": {
-            source: {
-              document: 0,
-              path: 0,
-              type: 'documentValue',
-            },
-            type: 'value',
-          },
-        },
-      },
-    },
-    expected: {
-      encoderCalls: 1,
-      encoderArgs: [
-        [
-          {
-            sourcePath: ['something', 'nested', 'object', 'this'],
-            sourceDocument: {
-              _id: 'foo',
-              _type: 'bar',
-            },
-            resultPath: [0, 'nested', 'object', 'this'],
-            value: 'that',
-          },
-        ],
-      ],
-    },
-  },
-  {
-    name: 'plucks out _key to use as path segment',
-    queryResult: {
-      result: [
-        {
-          _id: 'foo',
-          nested: {
-            arr: [
-              {
-                _key: 'im_a_key',
-                value: 'that',
-              },
-            ],
-          },
-        },
-      ],
-      resultSourceMap: {
-        documents: [
-          {
-            _id: 'foo',
-            _type: 'bar',
-          },
-        ],
-        paths: ["$['projected']['nested']"],
-        mappings: {
-          "$[0]['nested']": {
-            source: {
-              document: 0,
-              path: 0,
-              type: 'documentValue',
-            },
-            type: 'value',
-          },
-        },
-      },
-    },
-    options: {
-      keyArraySelectors: true,
-    },
-    expected: {
-      encoderCalls: 2,
-      encoderArgs: [
-        [
-          {
-            sourcePath: ['projected', 'nested', 'arr', {key: 'im_a_key', index: 0}, '_key'],
-            sourceDocument: {
-              _id: 'foo',
-              _type: 'bar',
-            },
-            resultPath: [0, 'nested', 'arr', {key: 'im_a_key', index: 0}, '_key'],
-            value: 'im_a_key',
-          },
-        ],
-        [
-          {
-            sourcePath: ['projected', 'nested', 'arr', {key: 'im_a_key', index: 0}, 'value'],
-            sourceDocument: {
-              _id: 'foo',
-              _type: 'bar',
-            },
-            resultPath: [0, 'nested', 'arr', {key: 'im_a_key', index: 0}, 'value'],
-            value: 'that',
-          },
-        ],
-      ],
-    },
-  },
-  {
-    name: 'handles _key array filter selectors in source paths',
-    queryResult: {
-      result: [
-        {
-          _id: 'foo',
-          arr: [
-            {
-              _key: 'im_a_key',
-              value: 'that',
-            },
-          ],
-        },
-      ],
-      resultSourceMap: {
-        documents: [
-          {
-            _id: 'foo',
-            _type: 'bar',
-          },
-        ],
-        paths: ["$['projected'][?(@._key=='fooKey')]"],
-        mappings: {
-          "$[0]['arr']": {
-            source: {
-              document: 0,
-              path: 0,
-              type: 'documentValue',
-            },
-            type: 'value',
-          },
-        },
-      },
-    },
-    options: {
-      keyArraySelectors: true,
-    },
-    expected: {
-      encoderCalls: 2,
-      encoderArgs: [
-        [
-          {
-            sourcePath: [
-              'projected',
-              {key: 'fooKey', index: -1},
-              {key: 'im_a_key', index: 0},
-              '_key',
-            ],
-            sourceDocument: {
-              _id: 'foo',
-              _type: 'bar',
-            },
-            resultPath: [0, 'arr', {key: 'im_a_key', index: 0}, '_key'],
-            value: 'im_a_key',
-          },
-        ],
-        [
-          {
-            sourcePath: [
-              'projected',
-              {key: 'fooKey', index: -1},
-              {key: 'im_a_key', index: 0},
-              'value',
-            ],
-            sourceDocument: {
-              _id: 'foo',
-              _type: 'bar',
-            },
-            resultPath: [0, 'arr', {key: 'im_a_key', index: 0}, 'value'],
-            value: 'that',
-          },
-        ],
-      ],
-    },
-  },
-]
-
-test.each(encodeTestCases)('encode $name', ({queryResult, options, expected}) => {
-  const mockTranscoder = vi.fn().mockImplementation((input: string) => input)
-  encodeIntoResult(queryResult.result, queryResult.resultSourceMap, mockTranscoder, options)
-
-  expect(mockTranscoder).toBeCalledTimes(expected.encoderCalls)
-  for (const args of expected.encoderArgs) {
-    expect(mockTranscoder).toBeCalledWith(...args)
-  }
-})

package/src/stega/encodeIntoResult.ts

@@ -1,59 +0,0 @@
-import {parseJsonPath} from '../csm/jsonpath'
-import {resolveMapping} from '../csm/resolveMapping'
-import type {ContentSourceMap} from '../csm/types'
-import {walkMap} from '../csm/walkMap'
-import type {Encoder} from './types'
-
-/**
- * @internal
- */
-export function encodeIntoResult<Result>(
-  result: Result,
-  csm: ContentSourceMap,
-  encoder: Encoder,
-  options?: {keyArraySelectors: boolean},
-): Result {
-  return walkMap(result, (value, path) => {
-    // Only map strings, we could extend this in the future to support other types like integers...
-    if (typeof value !== 'string') {
-      return value
-    }
-
-    const resolveMappingResult = resolveMapping(path, csm)
-    if (!resolveMappingResult) {
-      return value
-    }
-
-    const {mapping, matchedPath, pathSuffix} = resolveMappingResult
-    if (mapping.type !== 'value') {
-      return value
-    }
-
-    if (mapping.source.type !== 'documentValue') {
-      return value
-    }
-
-    const sourceDocument = csm.documents[mapping.source.document!]
-    const sourcePath = csm.paths[mapping.source.path]
-
-    if (options?.keyArraySelectors) {
-      const matchPathSegments = parseJsonPath(matchedPath)
-      const sourcePathSegments = parseJsonPath(sourcePath)
-      const fullSourceSegments = sourcePathSegments.concat(path.slice(matchPathSegments.length))
-
-      return encoder({
-        sourcePath: fullSourceSegments,
-        sourceDocument,
-        resultPath: path,
-        value,
-      })
-    }
-
-    return encoder({
-      sourcePath: parseJsonPath(sourcePath + pathSuffix),
-      sourceDocument,
-      resultPath: path,
-      value,
-    })
-  }) as Result
-}

package/src/stega/filterDefault.ts

@@ -1,49 +0,0 @@
-import type {FilterDefault} from './types'
-
-export const filterDefault: FilterDefault = ({sourcePath}) => {
-  const endPath = sourcePath.at(-1)
-  // Never encode slugs
-  if (sourcePath.at(-2) === 'slug' && endPath === 'current') {
-    return false
-  }
-
-  // Skip underscored keys, needs better heuristics but it works for now
-  if (typeof endPath === 'string' && endPath.startsWith('_')) {
-    return false
-  }
-
-  /**
-   * Best effort infer Portable Text paths that should not be encoded.
-   * Nothing is for certain, and the below implementation may cause paths that aren't Portable Text and otherwise be safe to encode to be skipped.
-   * However, that's ok as userland can always opt-in with the `encodeSourceMapAtPath` option and mark known safe paths as such, which will override this heuristic.
-   */
-  // If the path ends in [number].children[number].marks[number] it's likely a PortableTextSpan: https://github.com/portabletext/types/blob/e54eb24f136d8efd51a46c6a190e7c46e79b5380/src/portableText.ts#LL154C16-L154C16
-  if (
-    typeof endPath === 'number' &&
-    sourcePath.at(-2) === 'marks' &&
-    typeof sourcePath.at(-3) === 'number' &&
-    sourcePath.at(-4) === 'children' &&
-    typeof sourcePath.at(-5) === 'number'
-  ) {
-    return false
-  }
-  // Or if it's [number].markDefs[number].href it's likely a PortableTextLink: https://github.com/portabletext/types/blob/e54eb24f136d8efd51a46c6a190e7c46e79b5380/src/portableText.ts#L163
-  if (
-    endPath === 'href' &&
-    typeof sourcePath.at(-2) === 'number' &&
-    sourcePath.at(-3) === 'markDefs' &&
-    typeof sourcePath.at(-4) === 'number'
-  ) {
-    return false
-  }
-  // Otherwise we have to deal with special properties of PortableTextBlock, and we can't confidently know if it's actually a `_type: 'block'` array item or not.
-  // All we know is that if it is indeed a block, and we encode the strings on these keys it'll for sure break the PortableText rendering and thus we skip encoding.
-  if (typeof endPath === 'string' && typeof sourcePath.at(-2) === 'number') {
-    // https://github.com/portabletext/types/blob/e54eb24f136d8efd51a46c6a190e7c46e79b5380/src/portableText.ts#L48-L58
-    if (endPath === 'style' || endPath === 'listItem') {
-      return false
-    }
-  }
-
-  return true
-}

package/src/stega/index.browser.ts

@@ -1,19 +0,0 @@
-export * from '../defineCreateClient'
-
-import defineCreateClientExports from '../defineCreateClient'
-import envMiddleware from '../http/browserMiddleware'
-import {SanityStegaClient} from './SanityStegaClient'
-import type {ClientStegaConfig} from './types'
-
-const exp = defineCreateClientExports<SanityStegaClient, ClientStegaConfig>(
-  envMiddleware,
-  SanityStegaClient,
-)
-
-export * from './shared'
-
-/** @public */
-export const requester = exp.requester
-
-/** @public */
-export const createClient = exp.createClient