sanity 3.93.1-next.16.586a638358 → 3.93.1-next.17.e9296c12d1

package/src/core/store/key-value/serverKeyValueStore.ts

@@ -1,49 +0,0 @@
-import {type SanityClient} from '@sanity/client'
-import {isEqual} from 'lodash'
-import {concat, type Observable, Subject} from 'rxjs'
-import {distinctUntilChanged, filter, map} from 'rxjs/operators'
-
-import {createServerStorage} from './storage/serverStorage'
-import {type KeyValueStore, type KeyValueStoreValue} from './types'
-
-export function createServerKeyValueStore({client}: {client: SanityClient}): KeyValueStore {
-  const serverStorage = createServerStorage({client})
-
-  const events$ = new Subject<{
-    type: 'optimistic' | 'commit'
-    key: string
-    value: KeyValueStoreValue
-  }>()
-
-  function getKey(key: string) {
-    return serverStorage.getKey(key)
-  }
-
-  function setKey(key: string, value: KeyValueStoreValue) {
-    events$.next({type: 'optimistic', key, value})
-
-    /*
-     * The backend returns the result of the set operation, so we can just pass that along.
-     * Most utils do not use it (they will take advantage of local state first) but it reflects the
-     * backend function and could be useful for debugging.
-     */
-    return serverStorage.setKey(key, value).then((storedValue) => {
-      events$.next({type: 'commit', key, value: storedValue})
-      return storedValue
-    })
-  }
-
-  return {
-    getKey(key: string): Observable<KeyValueStoreValue | null> {
-      return concat(
-        getKey(key),
-        events$.pipe(
-          filter((event) => event.key === key),
-          map((event) => event.value),
-          distinctUntilChanged(isEqual),
-        ),
-      )
-    },
-    setKey,
-  }
-}

package/src/core/store/key-value/storage/localStoreStorage.ts

@@ -1,38 +0,0 @@
-import {supportsLocalStorage} from '../../../util/supportsLocalStorage'
-import {type KeyValueStoreValue} from '../types'
-import {createMemoryStorage} from './memoryStorage'
-
-function tryParse(val: string) {
-  try {
-    return JSON.parse(val)
-  } catch (err) {
-    // eslint-disable-next-line no-console
-    console.warn(`Failed to parse settings: ${err.message}`)
-    return null
-  }
-}
-
-function createLocalStoreStorage() {
-  if (!supportsLocalStorage) {
-    return createMemoryStorage()
-  }
-
-  function getKey(key: string): KeyValueStoreValue | null {
-    const val = localStorage.getItem(key)
-
-    return val === null ? null : tryParse(val)
-  }
-
-  const setKey = function (key: string, nextValue: KeyValueStoreValue) {
-    // Can't stringify undefined, and nulls are what
-    // `getItem` returns when key does not exist
-    if (typeof nextValue === 'undefined' || nextValue === null) {
-      localStorage.removeItem(key)
-    } else {
-      localStorage.setItem(key, JSON.stringify(nextValue))
-    }
-  }
-  return {getKey, setKey}
-}
-
-export const localStoreStorage = createLocalStoreStorage()

package/src/core/store/key-value/storage/memoryStorage.ts

@@ -1,13 +0,0 @@
-import {type KeyValueStoreValue} from '../types'
-
-export function createMemoryStorage() {
-  const DB = Object.create(null)
-  return {
-    getKey(key: string): KeyValueStoreValue | null {
-      return DB[key] || null
-    },
-    setKey(key: string, value: KeyValueStoreValue) {
-      DB[key] = value
-    },
-  }
-}

package/src/core/store/key-value/storage/serverStorage.ts

@@ -1,78 +0,0 @@
-import {type SanityClient} from '@sanity/client'
-import DataLoader from 'dataloader'
-
-import {DEFAULT_STUDIO_CLIENT_OPTIONS} from '../../../studioClient'
-import {type KeyValueStoreValue} from '../types'
-import {type KeyValuePair} from './types'
-
-/** @internal */
-export interface ServerStorageOptions {
-  client: SanityClient
-}
-
-export interface ServerStorage {
-  getKey: (key: string) => Promise<KeyValueStoreValue | null>
-  setKey: (key: string, nextValue: unknown) => Promise<KeyValueStoreValue>
-}
-
-/**
- * Backend uses the Sanity client to store and retrieve key-value pairs from the /users/me/keyvalue endpoint.
- * @internal
- */
-export function createServerStorage({client: _client}: ServerStorageOptions): ServerStorage {
-  const client = _client.withConfig(DEFAULT_STUDIO_CLIENT_OPTIONS)
-
-  const keyValueLoader = new DataLoader<string, KeyValueStoreValue | null>(async (keys) => {
-    const value = await client
-      .request<KeyValuePair[]>({
-        uri: `/users/me/keyvalue/${keys.join(',')}`,
-      })
-      .catch((error) => {
-        console.error('Error fetching data:', error)
-        return Array(keys.length).fill(null)
-      })
-
-    // there are instances where the valeu might be null
-    const keyValuePairs = (value || []).reduce(
-      (acc, next) => {
-        if (next?.key) {
-          acc[next.key] = next.value
-        }
-        return acc
-      },
-      {} as Record<string, KeyValueStoreValue | null>,
-    )
-
-    return keys.map((key) => keyValuePairs[key] || null)
-  })
-
-  const getKey = (key: string) => {
-    return keyValueLoader.load(key)
-  }
-
-  const setKey = (key: string, nextValue: unknown) => {
-    return client
-      .request<KeyValuePair[]>({
-        method: 'PUT',
-        uri: `/users/me/keyvalue`,
-        body: [{key, value: nextValue}],
-      })
-      .then(
-        (response) => {
-          const pair = response[0]
-          keyValueLoader.clear(pair.key)
-          keyValueLoader.prime(pair.key, pair.value)
-          return pair.value
-        },
-        (error) => {
-          console.error('Error setting data:', error)
-          return null
-        },
-      )
-  }
-
-  return {
-    getKey,
-    setKey,
-  }
-}

package/src/core/store/key-value/storage/types.ts

@@ -1,6 +0,0 @@
-import {type KeyValueStoreValue} from '../types'
-
-export interface KeyValuePair {
-  key: string
-  value: KeyValueStoreValue | null
-}

package/src/core/store/key-value/types.ts

@@ -1,16 +0,0 @@
-import {type Observable} from 'rxjs'
-
-type JsonObject = {[Key in string]: KeyValueStoreValue} & {
-  [Key in string]?: KeyValueStoreValue | undefined
-}
-type JsonArray = KeyValueStoreValue[] | readonly KeyValueStoreValue[]
-type JsonPrimitive = string | number | boolean | null
-
-/** @internal */
-export type KeyValueStoreValue = JsonPrimitive | JsonObject | JsonArray
-
-/** @internal */
-export interface KeyValueStore {
-  getKey(key: string): Observable<KeyValueStoreValue | null>
-  setKey(key: string, value: KeyValueStoreValue): Promise<KeyValueStoreValue>
-}

package/src/core/store/renderingContext/coreUiRenderingContext.test.ts

@@ -1,64 +0,0 @@
-import {expect, it} from 'vitest'
-
-import {coreUiRenderingContext} from './coreUiRenderingContext'
-
-const coreUiProductionContext = {
-  mode: 'core-ui',
-  env: 'production',
-}
-
-const coreUiStagingContext = {
-  mode: 'core-ui',
-  env: 'staging',
-}
-
-const coreUiUnsupportedContext = {
-  mode: 'evil-mode',
-  env: 'production',
-}
-
-it('ignores the `_context` URL search parameter if the mode is not "core-ui"', () => {
-  expect(() => coreUiRenderingContext(urlSearch(coreUiUnsupportedContext))).toMatchEmissions([
-    [undefined, undefined],
-  ])
-})
-
-it('parses the `_context` URL search parameter', () => {
-  expect(() => coreUiRenderingContext(urlSearch(coreUiProductionContext))).toMatchEmissions([
-    [
-      undefined,
-      {
-        name: 'coreUi',
-        metadata: {
-          environment: 'production',
-        },
-      },
-    ],
-  ])
-
-  expect(() => coreUiRenderingContext(urlSearch(coreUiStagingContext))).toMatchEmissions([
-    [
-      undefined,
-      {
-        name: 'coreUi',
-        metadata: {
-          environment: 'staging',
-        },
-      },
-    ],
-  ])
-})
-
-it('fails gracefully if the `_context` URL search parameter cannot be parsed', () => {
-  const invalidCoreUiContextString = urlSearch(coreUiProductionContext).slice(0, -10)
-
-  expect(() => coreUiRenderingContext(invalidCoreUiContextString)).toMatchEmissions([
-    [undefined, undefined],
-  ])
-})
-
-function urlSearch(context: unknown): string {
-  return new URLSearchParams({
-    _context: JSON.stringify(context),
-  }).toString()
-}

package/src/core/store/renderingContext/coreUiRenderingContext.ts

@@ -1,66 +0,0 @@
-import {
-  catchError,
-  distinctUntilChanged,
-  map,
-  of,
-  type OperatorFunction,
-  pipe,
-  switchMap,
-} from 'rxjs'
-
-import {isCoreUiRenderingContext, type StudioRenderingContext} from './types'
-
-// Core UI Rendering Context is provided via the URL query string, and remains static the entire
-// duration Studio is rendered inside the Core UI iframe.
-//
-// However, the URL query string is liable to be lost during Studio's lifecycle (for example, when
-// the user navigates to a different tool). Therefore, the URL query string is captured as soon as
-// this code is evaluated, and later referenced when a consumer subscribes to the store.
-const INITIAL_URL_SEARCH = typeof location === 'object' ? location.search : ''
-
-const CORE_UI_MODE_NAME = 'core-ui'
-const CORE_UI_CONTEXT_SEARCH_PARAM = '_context'
-
-/**
- * @internal
- */
-export function coreUiRenderingContext(
-  urlSearch: string = INITIAL_URL_SEARCH,
-): OperatorFunction<StudioRenderingContext | undefined, StudioRenderingContext | undefined> {
-  return pipe(
-    switchMap((renderingContext) => {
-      if (renderingContext) {
-        return of(renderingContext)
-      }
-
-      return of(urlSearch).pipe(
-        distinctUntilChanged(),
-        map((search) => new URLSearchParams(search).get(CORE_UI_CONTEXT_SEARCH_PARAM)),
-        map((serializedContext) => {
-          if (serializedContext === null) {
-            return undefined
-          }
-
-          const {mode, env} = JSON.parse(serializedContext)
-
-          const coreUirenderingContext = {
-            name: mode === CORE_UI_MODE_NAME ? 'coreUi' : undefined,
-            metadata: {
-              environment: env,
-            },
-          }
-
-          if (isCoreUiRenderingContext(coreUirenderingContext)) {
-            return coreUirenderingContext
-          }
-
-          return undefined
-        }),
-        catchError((error) => {
-          console.warn('Error parsing rendering context:', error)
-          return of(undefined)
-        }),
-      )
-    }),
-  )
-}

package/src/core/store/renderingContext/createRenderingContextStore.test.ts

@@ -1,22 +0,0 @@
-import {firstValueFrom} from 'rxjs'
-import {describe, expect, it} from 'vitest'
-
-import {createRenderingContextStore} from './createRenderingContextStore'
-
-describe('renderingContext', () => {
-  it('emits rendering context', async () => {
-    const {renderingContext} = createRenderingContextStore()
-
-    expect(await firstValueFrom(renderingContext)).toEqual({
-      name: 'default',
-      metadata: {},
-    })
-  })
-})
-
-describe('capabilities', () => {
-  it('emits capabilities', async () => {
-    const {capabilities} = createRenderingContextStore()
-    expect(await firstValueFrom(capabilities)).toEqual({})
-  })
-})

package/src/core/store/renderingContext/createRenderingContextStore.ts

@@ -1,30 +0,0 @@
-import {of, shareReplay} from 'rxjs'
-
-import {coreUiRenderingContext} from './coreUiRenderingContext'
-import {defaultRenderingContext} from './defaultRenderingContext'
-import {listCapabilities} from './listCapabilities'
-import {type RenderingContextStore} from './types'
-
-/**
- * Rendering Context Store provides information about where Studio is being rendered, and which
- * capabilities are provided by the rendering context.
- *
- * This can be used to adapt parts of the Studio UI that are provided by the rendering context,
- * such as the global user menu.
- *
- * @internal
- */
-export function createRenderingContextStore(): RenderingContextStore {
-  const renderingContext = of(undefined).pipe(
-    coreUiRenderingContext(),
-    defaultRenderingContext(),
-    shareReplay(1),
-  )
-
-  const capabilities = renderingContext.pipe(listCapabilities(), shareReplay(1))
-
-  return {
-    renderingContext,
-    capabilities,
-  }
-}

package/src/core/store/renderingContext/defaultRenderingContext.test.ts

@@ -1,34 +0,0 @@
-import {expect, it} from 'vitest'
-
-import {defaultRenderingContext} from './defaultRenderingContext'
-
-it("emits the subject if it's not `undefined`", () => {
-  expect(defaultRenderingContext).toMatchEmissions([
-    [
-      {
-        name: 'coreUi',
-        metadata: {
-          environment: 'production',
-        },
-      },
-      {
-        name: 'coreUi',
-        metadata: {
-          environment: 'production',
-        },
-      },
-    ],
-  ])
-})
-
-it('emits the the default context if the subject is `undefined`', () => {
-  expect(defaultRenderingContext).toMatchEmissions([
-    [
-      undefined,
-      {
-        name: 'default',
-        metadata: {},
-      },
-    ],
-  ])
-})

package/src/core/store/renderingContext/defaultRenderingContext.ts

@@ -1,18 +0,0 @@
-import {map, type OperatorFunction} from 'rxjs'
-
-import {type DefaultRenderingContext, type StudioRenderingContext} from './types'
-
-const DEFAULT_RENDERING_CONTEXT: DefaultRenderingContext = {
-  name: 'default',
-  metadata: {},
-}
-
-/**
- * @internal
- */
-export function defaultRenderingContext(): OperatorFunction<
-  StudioRenderingContext | undefined,
-  StudioRenderingContext
-> {
-  return map((renderingContext) => renderingContext ?? DEFAULT_RENDERING_CONTEXT)
-}

package/src/core/store/renderingContext/listCapabilities.ts

@@ -1,19 +0,0 @@
-import {map, type OperatorFunction} from 'rxjs'
-
-import {type CapabilityRecord, type StudioRenderingContext} from './types'
-
-const capabilitiesByRenderingContext: Record<StudioRenderingContext['name'], CapabilityRecord> = {
-  coreUi: {
-    globalUserMenu: true,
-    globalWorkspaceControl: true,
-    comlink: true,
-  },
-  default: {},
-}
-
-/**
- * @internal
- */
-export function listCapabilities(): OperatorFunction<StudioRenderingContext, CapabilityRecord> {
-  return map((renderingContext) => capabilitiesByRenderingContext[renderingContext.name])
-}

package/src/core/store/renderingContext/types.ts

@@ -1,76 +0,0 @@
-import {type Observable} from 'rxjs'
-
-/**
- * @internal
- */
-export type BaseStudioRenderingContext<
-  Name extends string = string,
-  Metadata = Record<PropertyKey, never>,
-> = {
-  name: Name
-  metadata: Metadata
-}
-
-/**
- * @internal
- */
-export type DefaultRenderingContext = BaseStudioRenderingContext<'default'>
-
-/**
- * @internal
- */
-export type CoreUiRenderingContext = BaseStudioRenderingContext<
-  'coreUi',
-  {
-    environment: string
-  }
->
-
-/**
- * @internal
- */
-export type StudioRenderingContext = DefaultRenderingContext | CoreUiRenderingContext
-
-/**
- * @internal
- */
-export const capabilities = ['globalUserMenu', 'globalWorkspaceControl', 'comlink'] as const
-
-/**
- * @internal
- */
-export type Capability = (typeof capabilities)[number]
-
-/**
- * @internal
- */
-export type CapabilityRecord = Partial<Record<Capability, boolean>>
-
-/**
- * @internal
- */
-export type RenderingContextStore = {
-  renderingContext: Observable<StudioRenderingContext>
-  capabilities: Observable<CapabilityRecord>
-}
-
-/**
- * Check whether the provided value satisfies the `CoreUiRenderingContext` type.
- *
- * @internal
- */
-export function isCoreUiRenderingContext(
-  maybeCoreUiRenderingContext: unknown,
-): maybeCoreUiRenderingContext is CoreUiRenderingContext {
-  return (
-    typeof maybeCoreUiRenderingContext === 'object' &&
-    maybeCoreUiRenderingContext !== null &&
-    'name' in maybeCoreUiRenderingContext &&
-    maybeCoreUiRenderingContext.name === 'coreUi' &&
-    'metadata' in maybeCoreUiRenderingContext &&
-    typeof maybeCoreUiRenderingContext.metadata === 'object' &&
-    maybeCoreUiRenderingContext.metadata !== null &&
-    'environment' in maybeCoreUiRenderingContext.metadata &&
-    typeof maybeCoreUiRenderingContext.metadata.environment === 'string'
-  )
-}

package/src/core/store/renderingContext/useRenderingContext.ts

@@ -1,9 +0,0 @@
-import {useObservable} from 'react-rx'
-
-import {useRenderingContextStore} from '../_legacy/datastores'
-
-export function useRenderingContext() {
-  const renderingContextStore = useRenderingContextStore()
-
-  return useObservable(renderingContextStore.renderingContext)
-}

package/src/core/store/translog/getTransactionsLogs.test.ts

@@ -1,118 +0,0 @@
-import {type SanityClient} from '@sanity/client'
-import {beforeEach, describe, expect, it, type Mock, vi} from 'vitest'
-
-import {getJsonStream} from '../_legacy/history/history/getJsonStream'
-import {getTransactionsLogs} from './getTransactionsLogs'
-
-vi.mock('../_legacy/history/history/getJsonStream', () => ({
-  getJsonStream: vi.fn(),
-}))
-
-const getJsonStreamMock = getJsonStream as Mock
-
-describe('getTransactionsLogs', () => {
-  const mockClient = {
-    config: vi.fn(() => ({
-      dataset: 'mockDataset',
-      token: 'mockToken',
-    })),
-    getUrl: vi.fn((path) => `https://mock.sanity.api${path}`),
-  } as unknown as SanityClient
-
-  const mockStream = {
-    getReader: vi.fn(() => ({
-      async read() {
-        return {done: true}
-      },
-    })),
-  }
-
-  beforeEach(() => {
-    vi.clearAllMocks()
-  })
-
-  it('should fetch transaction logs with default parameters', async () => {
-    getJsonStreamMock.mockResolvedValueOnce(mockStream)
-
-    const documentId = 'doc1'
-    const result = await getTransactionsLogs(mockClient, documentId, {})
-
-    expect(mockClient.getUrl).toHaveBeenCalledWith(
-      '/data/history/mockDataset/transactions/doc1?tag=sanity.studio.transactions-log&excludeContent=true&limit=50&includeIdentifiedDocumentsOnly=true',
-    )
-    expect(getJsonStream).toHaveBeenCalledWith(
-      'https://mock.sanity.api/data/history/mockDataset/transactions/doc1?tag=sanity.studio.transactions-log&excludeContent=true&limit=50&includeIdentifiedDocumentsOnly=true',
-      'mockToken',
-    )
-    expect(result).toEqual([])
-  })
-
-  it('should handle multiple document IDs', async () => {
-    getJsonStreamMock.mockResolvedValueOnce(mockStream)
-
-    const documentIds = ['doc1', 'doc2']
-    await getTransactionsLogs(mockClient, documentIds, {})
-
-    expect(mockClient.getUrl).toHaveBeenCalledWith(
-      '/data/history/mockDataset/transactions/doc1,doc2?tag=sanity.studio.transactions-log&excludeContent=true&limit=50&includeIdentifiedDocumentsOnly=true',
-    )
-    expect(getJsonStream).toHaveBeenCalledWith(
-      'https://mock.sanity.api/data/history/mockDataset/transactions/doc1,doc2?tag=sanity.studio.transactions-log&excludeContent=true&limit=50&includeIdentifiedDocumentsOnly=true',
-      'mockToken',
-    )
-  })
-
-  it('should override default parameters with user-provided params', async () => {
-    getJsonStreamMock.mockResolvedValueOnce(mockStream)
-
-    const documentId = 'doc1'
-    await getTransactionsLogs(mockClient, documentId, {
-      tag: 'sanity.studio.custom-tag',
-      limit: 100,
-      fromTransaction: 'tx1',
-      toTransaction: 'tx3',
-    })
-
-    expect(mockClient.getUrl).toHaveBeenCalledWith(
-      '/data/history/mockDataset/transactions/doc1?tag=sanity.studio.custom-tag&excludeContent=true&limit=100&includeIdentifiedDocumentsOnly=true&fromTransaction=tx1&toTransaction=tx3',
-    )
-  })
-
-  it('should throw an error if the stream contains an error', async () => {
-    const mockErrorStream = {
-      getReader: vi.fn(() => ({
-        async read() {
-          return {done: false, value: {error: {description: 'Error occurred'}}}
-        },
-      })),
-    }
-    getJsonStreamMock.mockResolvedValueOnce(mockErrorStream)
-
-    const documentId = 'doc1'
-
-    await expect(getTransactionsLogs(mockClient, documentId, {})).rejects.toThrow('Error occurred')
-  })
-
-  it('should collect transactions from the stream', async () => {
-    const mockDataStream = {
-      getReader: vi.fn(() => {
-        let callCount = 0
-        return {
-          async read() {
-            if (callCount < 3) {
-              callCount++
-              return {done: false, value: {id: `txn${callCount}`}}
-            }
-            return {done: true}
-          },
-        }
-      }),
-    }
-    getJsonStreamMock.mockResolvedValueOnce(mockDataStream)
-
-    const documentId = 'doc1'
-    const result = await getTransactionsLogs(mockClient as any, documentId, {})
-
-    expect(result).toEqual([{id: 'txn1'}, {id: 'txn2'}, {id: 'txn3'}])
-  })
-})