@sanity/sdk 3.0.0 → 3.2.0

package/src/store/createSanityInstance.test.ts

@@ -6,7 +6,7 @@ import {createSanityInstance} from './createSanityInstance'
 describe('createSanityInstance', () => {
   it('should create an instance with a unique instanceId and given config', () => {
     const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
-    expect(typeof instance.instanceId).toBe('string')
+    expect(instance.instanceId).toMatch(/^[a-zA-Z0-9]{16}$/)
     expect(instance.config).toEqual({projectId: 'proj1', dataset: 'ds1'})
     expect(instance.isDisposed()).toBe(false)
   })

package/src/store/createSanityInstance.ts

@@ -1,5 +1,5 @@
 import {type SanityConfig} from '../config/sanityConfig'
-import {insecureRandomId} from '../utils/ids'
+import {randomId} from '../utils/ids'
 import {createLogger, type InstanceContext} from '../utils/logger'
 
 /**
@@ -10,7 +10,7 @@ import {createLogger, type InstanceContext} from '../utils/logger'
 export interface SanityInstance {
   /**
    * Unique identifier for this instance
-   * @remarks Generated using crypto.randomUUID()
+   * @remarks Generated as a random 16-character alphanumeric ID
    */
   readonly instanceId: string
 
@@ -47,7 +47,7 @@ export interface SanityInstance {
  * @public
  */
 export function createSanityInstance(config: SanityConfig = {}): SanityInstance {
-  const instanceId = crypto.randomUUID()
+  const instanceId = randomId(16)
   const disposeListeners = new Map<string, () => void>()
   const disposed = {current: false}
 
@@ -99,7 +99,7 @@ export function createSanityInstance(config: SanityConfig = {}): SanityInstance
       logger.info('Instance disposed')
     },
     onDispose: (cb) => {
-      const listenerId = insecureRandomId()
+      const listenerId = randomId(16)
       disposeListeners.set(listenerId, cb)
       return () => {
         disposeListeners.delete(listenerId)

package/src/store/createStoreInstance.test.ts

@@ -8,11 +8,6 @@ describe('createStoreInstance', () => {
   let instance: ReturnType<typeof createSanityInstance>
 
   beforeEach(() => {
-    // Mock crypto for predictable instance IDs
-    vi.stubGlobal('crypto', {
-      randomUUID: () => 'test-uuid-1234',
-    })
-
     instance = createSanityInstance({projectId: 'test', dataset: 'test'})
   })
 

package/src/telemetry/telemetryManager.test.ts

@@ -280,7 +280,7 @@ describe('createTelemetryManager', () => {
       const result = await manager.checkConsent()
       expect(result).toBe(true)
       expect(mockClient.request).toHaveBeenCalledWith(
-        expect.objectContaining({uri: '/intake/telemetry-status'}),
+        expect.objectContaining({url: '/intake/telemetry-status'}),
       )
     })
 

package/src/telemetry/telemetryManager.ts

@@ -86,7 +86,7 @@ export function createTelemetryManager(options: TelemetryManagerOptions): Teleme
     try {
       const client = getClient()
       const result = await client.request<{status: ConsentStatus}>({
-        uri: '/intake/telemetry-status',
+        url: '/intake/telemetry-status',
         tag: CONSENT_TAG,
       })
       cachedConsent = result
@@ -120,7 +120,7 @@ export function createTelemetryManager(options: TelemetryManagerOptions): Teleme
     const client = getClient()
     log.debug('sending event batch', {batchSize: batch.length, environment})
     return client.request({
-      uri: '/intake/batch',
+      url: '/intake/batch',
       method: 'POST',
       body: {projectId, batch: enrichBatch(batch)},
       tag: BATCH_TAG,

package/src/typegen/defineProjection.test.ts

@@ -0,0 +1,17 @@
+import {describe, expect, expectTypeOf, it} from 'vitest'
+
+import {defineProjection} from './defineProjection'
+
+describe('defineProjection', () => {
+  it('returns the projection unchanged', () => {
+    const projection = '{name, "awardCount": count(awards)}'
+    expect(defineProjection(projection)).toBe(projection)
+    expectTypeOf(defineProjection(projection)).toEqualTypeOf<typeof projection>()
+  })
+
+  it('preserves whitespace used in existing generated projection keys', () => {
+    const projection = '{\n  name,\n  role\n}'
+    expect(defineProjection(projection)).toBe(projection)
+    expectTypeOf(defineProjection(projection)).toEqualTypeOf<typeof projection>()
+  })
+})

package/src/typegen/defineProjection.ts

@@ -0,0 +1,19 @@
+/**
+ * Preserves a projection string's literal type and returns the string unchanged.
+ * Use this import when migrating an app with existing experimental Typegen output.
+ *
+ * Current Typegen does not scan this helper. New or changed projections need an
+ * explicit result type until projection generation is supported.
+ *
+ * @example
+ * ```ts
+ * const preview = defineProjection('{title, "author": author->name}')
+ * ```
+ *
+ * @beta
+ */
+export function defineProjection<const TProjection extends string>(
+  projection: TProjection,
+): TProjection {
+  return projection
+}

package/src/typegen/groqCompat.ts

@@ -0,0 +1,122 @@
+/**
+ * Augments `groq` with the type surface of `groq@3.88.1-typegen-experimental.0`, the fork
+ * this package depended on before GA `groq`.
+ *
+ * A `sanity.types.ts` from the experimental Typegen flow imports these helpers from
+ * `groq` and augments these interfaces. GA `groq` exports only `defineQuery` and the
+ * template tag, so those files stop typechecking without this one.
+ *
+ * `defineProjection` is absent: it is a runtime function, and declaring it in a
+ * type-only augmentation turns a compile error into `undefined is not a function`.
+ * `@sanity/sdk` exports it instead.
+ *
+ * Keep these declarations while the SDK supports existing experimental generated files.
+ */
+
+/* eslint-disable @typescript-eslint/no-empty-object-type -- augmentation targets:
+   generated files merge entries in, so they stay empty interfaces here. */
+declare module 'groq' {
+  /**
+   * Brands a type with the resource it came from so one flat interface can hold entries
+   * from more than one schema; {@link PickSchema} narrows it back out.
+   */
+  export type SchemaOrigin<TBase, TSchemaId extends string> = TBase & {
+    /**
+     * @internal
+     * @deprecated typescript helper only
+     */
+    __schemaId?: TSchemaId
+  }
+
+  /**
+   * Brands a projection result with the document type it was evaluated against;
+   * {@link PickProjectionResult} narrows it back out.
+   */
+  export type ProjectionBase<TBase, TProjectionBaseTypeName extends string> = TBase & {
+    /**
+     * @internal
+     * @deprecated typescript helper only
+     */
+    __schemaTypeName?: TProjectionBaseTypeName
+  }
+
+  /** Extracts the members of `T` that came from the schema `TSchemaId`. */
+  export type PickSchema<T, TSchemaId extends string = string> = Extract<
+    T,
+    SchemaOrigin<T, TSchemaId>
+  >
+
+  /** Extracts the members of `T` projected from the document type `TProjectionBaseTypeName`. */
+  export type PickProjectionResult<T, TProjectionBaseTypeName extends string = string> = Extract<
+    T,
+    ProjectionBase<T, TProjectionBaseTypeName>
+  >
+
+  /** Augmented by generated files: resource key to the union of that schema's types. */
+  export interface SanitySchemas {}
+
+  /** Augmented by generated files: query string to its result type. */
+  export interface SanityQueries {}
+
+  /** Augmented by generated files: projection string to its result type. */
+  export interface SanityProjections {}
+
+  /**
+   * Indexes an augmented interface, falling back to the union of every registered value
+   * when the key is absent. Code generated against the fork relies on that fallback, so
+   * narrowing it to `never` changes what existing apps infer.
+   */
+  type SafeAccess<T, K extends string> = K extends keyof T ? T[K] : T[keyof T]
+
+  /** Fields Sanity adds to every document. */
+  interface SanityDocumentShape {
+    _id: string
+    _type: string
+    _createdAt: string
+    _updatedAt: string
+    _rev: string
+    [key: string]: unknown
+  }
+
+  /** All types registered for one resource. */
+  export type SanitySchema<TSchemaId extends string = string> = PickSchema<
+    SafeAccess<SanitySchemas, TSchemaId>,
+    TSchemaId
+  >
+
+  /** One schema type, selected by its `_type` and its resource. */
+  export type SanitySchemaType<
+    TSchemaTypeName extends string = string,
+    TSchemaId extends string = string,
+  > = Extract<SanitySchema<TSchemaId>, {_type: TSchemaTypeName}>
+
+  /** One document type, selected by its `_type` and its resource. */
+  export type SanityDocument<
+    TDocumentType extends string = string,
+    TSchemaId extends string = string,
+  > = Extract<
+    Extract<SanitySchema<TSchemaId>, SanityDocumentShape> | SanityDocumentShape,
+    {_type: TDocumentType}
+  >
+
+  /** The result of a registered query, for one resource. */
+  export type SanityQueryResult<
+    TQuery extends string = string,
+    TSchemaId extends string = string,
+  > = Extract<
+    SafeAccess<SanityQueries, TQuery>,
+    SchemaOrigin<SafeAccess<SanityQueries, TQuery>, TSchemaId>
+  >
+
+  /** The result of a registered projection, for one document type and one resource. */
+  export type SanityProjectionResult<
+    TProjection extends string = string,
+    TProjectionBaseTypeName extends string = string,
+    TSchemaId extends string = string,
+  > = PickSchema<
+    PickProjectionResult<SafeAccess<SanityProjections, TProjection>, TProjectionBaseTypeName>,
+    TSchemaId
+  >
+}
+
+export {}

package/src/typegen/resolve.ts

@@ -0,0 +1,37 @@
+import './groqCompat'
+
+import {type SanityDocument, type SanityProjectionResult, type SanityQueryResult} from 'groq'
+
+/**
+ * Resolves a document using declarations from experimental Typegen.
+ * Preserves the legacy lookup behavior while the SDK uses released `groq`.
+ *
+ * @beta
+ */
+export type ResolveDocument<
+  TDocumentType extends string = string,
+  TSchemaId extends string = string,
+> = SanityDocument<TDocumentType, TSchemaId>
+
+/**
+ * Resolves a query using declarations from experimental Typegen.
+ * For types generated by current Typegen, pass the result type to the hook explicitly.
+ *
+ * @beta
+ */
+export type ResolveQueryResult<
+  TQuery extends string = string,
+  TSchemaId extends string = string,
+> = SanityQueryResult<TQuery, TSchemaId>
+
+/**
+ * Resolves a projection using declarations from experimental Typegen.
+ * Selects the result by projection string, document type, and schema ID.
+ *
+ * @beta
+ */
+export type ResolveProjectionResult<
+  TProjection extends string = string,
+  TDocumentType extends string = string,
+  TSchemaId extends string = string,
+> = SanityProjectionResult<TProjection, TDocumentType, TSchemaId>

package/src/users/usersStore.test.ts

@@ -450,7 +450,7 @@ describe('usersStore', () => {
       )
       expect(specificRequest).toHaveBeenCalledWith({
         method: 'GET',
-        uri: `/users/${projectUserId}`,
+        url: `/users/${projectUserId}`,
         tag: 'users.get',
       })
 

package/src/users/usersStore.ts

@@ -30,7 +30,7 @@ import {bindActionGlobally} from '../store/createActionBinder'
 import {createStateSourceAction, type SelectorContext} from '../store/createStateSourceAction'
 import {type StoreState} from '../store/createStoreState'
 import {defineStore, type StoreContext} from '../store/defineStore'
-import {insecureRandomId} from '../utils/ids'
+import {randomId} from '../utils/ids'
 import {setCleanupTimeout} from '../utils/setCleanupTimeout'
 import {
   addSubscription,
@@ -130,7 +130,7 @@ const listenForLoadMoreAndFetch = ({state, instance}: StoreContext<UsersStoreSta
                 return client.observable
                   .request<PatchedSanityUserFromClient>({
                     method: 'GET',
-                    uri: `/users/${userId}`,
+                    url: `/users/${userId}`,
                     tag: 'users.get',
                   })
                   .pipe(
@@ -184,7 +184,7 @@ const listenForLoadMoreAndFetch = ({state, instance}: StoreContext<UsersStoreSta
               return client.observable
                 .request<SanityUser | SanityUserResponse>({
                   method: 'GET',
-                  uri: `access/${resourceType}/${resourceId}/users/${userId}`,
+                  url: `access/${resourceType}/${resourceId}/users/${userId}`,
                   tag: 'users.get',
                 })
                 .pipe(
@@ -253,7 +253,7 @@ const listenForLoadMoreAndFetch = ({state, instance}: StoreContext<UsersStoreSta
               switchMap(([[resource, client], cursor]) =>
                 client.observable.request<SanityUserResponse>({
                   method: 'GET',
-                  uri: `access/${resource.type}/${resource.id}/users`,
+                  url: `access/${resource.type}/${resource.id}/users`,
                   tag: 'users.list',
                   query: cursor
                     ? {nextCursor: cursor, limit: batchSize.toString()}
@@ -310,7 +310,7 @@ export const getUsersState = bindActionGlobally(
       },
     ),
     onSubscribe: ({instance, state}, options?: GetUsersOptions) => {
-      const subscriptionId = insecureRandomId()
+      const subscriptionId = randomId(16)
       const key = getUsersKey(instance, options)
       state.set('addSubscription', addSubscription(subscriptionId, key))
       return () => {

package/src/utils/createGroqSearchFilter.test.ts

@@ -31,6 +31,14 @@ describe('createGroqSearchFilter', () => {
     )
   })
 
+  test('should escape backslashes so they cannot escape the closing quote', () => {
+    expect(createGroqSearchFilter('hello\\')).toBe('[@] match text::query("hello\\\\*")')
+  })
+
+  test('should escape backslashes inside an exact match phrase', () => {
+    expect(createGroqSearchFilter('"a\\b"')).toBe('[@] match text::query("\\"a\\\\b\\"")')
+  })
+
   test('should return empty string for empty input', () => {
     expect(createGroqSearchFilter('')).toBe('')
   })

package/src/utils/createGroqSearchFilter.ts

@@ -34,7 +34,7 @@ function isExactMatchToken(token: string | undefined): boolean {
  * from a raw search query string.
  *
  * It applies wildcard ('*') logic to the last eligible token and escapes
- * double quotes within the search term.
+ * backslashes and double quotes within the search term.
  *
  * If the input query is empty or only whitespace, it returns an empty string.
  *
@@ -77,8 +77,11 @@ export function createGroqSearchFilter(query: string): string {
   // Join the tokens back into a space-separated string
   const wildcardSearch = processedTokens.join(' ')
 
-  // Escape double quotes within the final search term for the GROQ query
-  const escapedSearch = wildcardSearch.replace(/"/g, '\\"')
+  // Escape backslashes and double quotes within the final search term for the
+  // GROQ query. Backslashes go first, so the escapes added for quotes are not
+  // themselves escaped. Without this a trailing backslash would escape the
+  // closing quote and let the input break out of the string literal.
+  const escapedSearch = wildcardSearch.replace(/\\/g, '\\\\').replace(/"/g, '\\"')
 
   // Construct the final GROQ filter clause
   return `[@] match text::query("${escapedSearch}")`

package/src/utils/ids.test.ts

@@ -1,26 +1,51 @@
-import {describe, expect, it} from 'vitest'
+import {afterEach, describe, expect, it, vi} from 'vitest'
 
-import {insecureRandomId} from './ids'
+import {randomId, randomUuid} from './ids'
 
-describe('insecureRandomId', () => {
-  it('should generate 16-character string', () => {
-    expect(insecureRandomId()).toHaveLength(16)
+describe('randomId', () => {
+  it('should generate an 8-character base62 id by default', () => {
+    expect(randomId()).toMatch(/^[a-zA-Z0-9]{8}$/)
   })
 
-  it('should generate hex string', () => {
-    expect(insecureRandomId()).toMatch(/^[0-9a-f]{16}$/)
+  it('should generate an id of the given length', () => {
+    expect(randomId(16)).toMatch(/^[a-zA-Z0-9]{16}$/)
   })
 
   it('should generate different ids on each call', () => {
-    const id1 = insecureRandomId()
-    const id2 = insecureRandomId()
-    expect(id1).not.toBe(id2)
+    expect(randomId()).not.toBe(randomId())
+  })
+})
+
+describe('randomUuid', () => {
+  const uuidV4Pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('should generate a v4 UUID', () => {
+    expect(randomUuid()).toMatch(uuidV4Pattern)
+  })
+
+  it('should use crypto.randomUUID when available', () => {
+    vi.stubGlobal('crypto', {randomUUID: () => 'native-uuid'})
+    expect(randomUuid()).toBe('native-uuid')
+  })
+
+  it('should generate a v4 UUID when crypto.randomUUID is unavailable (insecure contexts)', () => {
+    const originalCrypto = globalThis.crypto
+    vi.stubGlobal('crypto', {
+      getRandomValues: (array: Uint8Array<ArrayBuffer>) => originalCrypto.getRandomValues(array),
+    })
+    expect(randomUuid()).toMatch(uuidV4Pattern)
   })
 
-  it('should generate properly formatted strings multiple times', () => {
-    for (let i = 0; i < 100; i++) {
-      const id = insecureRandomId()
-      expect(id).toMatch(/^[0-9a-f]{16}$/)
-    }
+  it('should generate unique ids when crypto.randomUUID is unavailable', () => {
+    const originalCrypto = globalThis.crypto
+    vi.stubGlobal('crypto', {
+      getRandomValues: (array: Uint8Array<ArrayBuffer>) => originalCrypto.getRandomValues(array),
+    })
+    const ids = new Set(Array.from({length: 100}, () => randomUuid()))
+    expect(ids.size).toBe(100)
   })
 })

package/src/utils/ids.ts

@@ -1,3 +1,48 @@
-export function insecureRandomId(): string {
-  return Array.from({length: 16}, () => Math.floor(Math.random() * 16).toString(16)).join('')
+const ID_ALPHABET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
+
+/**
+ * Generates a random ID of the given length from the alphabet `[a-zA-Z0-9]`, the same shape
+ * `@sanity/client` and Sanity Studio use for short IDs such as release IDs.
+ *
+ * Ported from `@sanity/client`'s `generateReleaseId`, which uses rejection sampling to keep
+ * the output unbiased. Uses `crypto.getRandomValues`, which unlike `crypto.randomUUID` is
+ * also available on insecure origins (plain http).
+ *
+ * @internal
+ */
+export function randomId(length: number = 8): string {
+  let id = ''
+  while (id.length < length) {
+    const bytes = crypto.getRandomValues(new Uint8Array(length - id.length))
+    for (const byte of bytes) {
+      const index = byte & 63
+      if (index < ID_ALPHABET.length) id += ID_ALPHABET.charAt(index)
+    }
+  }
+  return id
+}
+
+/**
+ * Generates a random v4 UUID.
+ *
+ * Prefers the native `crypto.randomUUID`, which is only available in secure contexts
+ * (https, localhost). Falls back to deriving the UUID from `crypto.getRandomValues`,
+ * which has no such restriction, so ID generation also works when an app is served over
+ * plain http, e.g. when testing from a phone on a local network.
+ *
+ * @internal
+ */
+export function randomUuid(): string {
+  // eslint-disable-next-line no-restricted-properties -- this is the sanctioned wrapper around crypto.randomUUID
+  if (typeof crypto.randomUUID === 'function') return crypto.randomUUID()
+
+  const bytes = crypto.getRandomValues(new Uint8Array(16))
+  const hex = Array.from(bytes, (byte, index) => {
+    // Set the version (4) and variant (RFC 4122) bits
+    if (index === 6) byte = (byte & 0x0f) | 0x40
+    if (index === 8) byte = (byte & 0x3f) | 0x80
+    return byte.toString(16).padStart(2, '0')
+  }).join('')
+
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`
 }

package/dist/authStore-C0o1NOxW.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"authStore-C0o1NOxW.d.ts","names":[],"sources":["../src/store/createStoreState.ts","../src/store/defineStore.ts","../src/store/createActionBinder.ts","../src/store/createStateSourceAction.ts","../src/store/fetcherStore.ts","../src/access/checkPermissions.ts","../src/utils/includeShape.ts","../src/applications/applications.ts","../src/auth/authStateType.ts","../src/project/organizationVerification.ts","../src/auth/getOrganizationVerificationState.ts","../src/auth/handleAuthCallback.ts","../src/auth/logout.ts","../src/client/clientStore.ts","../src/comments/types.ts","../src/comments/commentActions.ts","../src/comments/commentsStore.ts","../src/config/handles.ts","../src/utils/logger.ts","../src/config/loggingConfig.ts","../src/datasets/datasets.ts","../src/document/actions.ts","../src/document/patchOperations.ts","../src/document/processMutations.ts","../src/document/permissions.ts","../src/document/sharedListener.ts","../src/document/documentStore.ts","../src/document/reducers.ts","../src/document/events.ts","../src/document/applyDocumentActions.ts","../src/document/processActions/releaseUtil.ts","../src/favorites/favorites.ts","../src/installations/installations.ts","../src/organization/organization.ts","../src/organizations/organizations.ts","../src/users/types.ts","../src/presence/types.ts","../src/presence/presenceStore.ts","../src/projection/types.ts","../src/preview/types.ts","../src/project/project.ts","../src/projection/getProjectionState.ts","../src/projection/resolveProjection.ts","../src/projects/projects.ts","../src/query/queryStore.ts","../src/releases/releasesStore.ts","../src/releases/getPerspectiveState.ts","../src/users/usersStore.ts","../src/utils/getCorsErrorProjectId.ts","../src/utils/isImportError.ts","../src/version.ts","../src/_exports/index.ts","../src/auth/authStore.ts"],"mappings":"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"}