@sanity/sdk 2.18.0 → 3.0.0-rc.1

package/src/utils/buildQuery.test.ts

@@ -0,0 +1,14 @@
+import {describe, expect, it} from 'vitest'
+
+import {buildQuery} from './buildQuery'
+
+describe('buildQuery', () => {
+  it('stringifies scalars, drops undefined, and passes string arrays through', () => {
+    expect(buildQuery({a: true, b: 0, c: 'x', d: undefined, e: ['p', 'q']})).toEqual({
+      a: 'true',
+      b: '0',
+      c: 'x',
+      e: ['p', 'q'],
+    })
+  })
+})

package/src/utils/buildQuery.ts

@@ -0,0 +1,17 @@
+/**
+ * Serialises store options into a `@sanity/client` request query object.
+ * Scalars are stringified and `undefined` values dropped; string arrays pass
+ * through untouched so the client serialises them as repeated keys
+ * (`permissions=a&permissions=b`).
+ *
+ * @internal
+ */
+export function buildQuery(
+  params: Record<string, string | number | boolean | string[] | undefined>,
+): Record<string, string | string[]> {
+  return Object.fromEntries(
+    Object.entries(params)
+      .filter(([, value]) => value !== undefined)
+      .map(([key, value]) => [key, Array.isArray(value) ? value : String(value)]),
+  )
+}

package/src/utils/includeShape.ts

@@ -0,0 +1,36 @@
+/**
+ * A response field that the API embeds only when its `include` token was
+ * requested. Given the full set of tokens `All`, the token `Key` this field
+ * maps to, and the tokens actually `Requested`, it resolves to:
+ *
+ * - `unknown` (field absent) when nothing — or nothing matching `Key` — was requested
+ * - `Field` (present, as declared) when a literal request list contains `Key`
+ * - `Partial<Field>` (optional) when `Requested` is the wide `All` union, i.e.
+ *   an `include` array whose members aren't known at the type level
+ *
+ * Absent arms return `unknown` so they vanish under intersection. Mirrors the
+ * `boolean extends Flag` trick the organization/project types use, but for an
+ * include-token union rather than a boolean flag.
+ *
+ * @internal
+ */
+export type Included<All extends string, Key extends All, Requested extends All, Field> = [
+  All,
+] extends [Requested]
+  ? Partial<Field>
+  : [Key] extends [Requested]
+    ? Field
+    : unknown
+
+/**
+ * Whether the requested include tokens intersect a given set — used to decide
+ * whether a parent field (e.g. an application's `activeDeployment`) is present,
+ * when requesting any of several tokens forces it in.
+ *
+ * @internal
+ */
+export type IncludesAny<Requested extends string, Set extends string> = [Requested & Set] extends [
+  never,
+]
+  ? false
+  : true

package/src/utils/setCleanupTimeout.ts

@@ -1,3 +1,13 @@
+// Calls `.unref()` on a timer when running in Node.js. In Node.js, timers are
+// objects with an `unref()` method; in browsers they are numbers. Narrow at
+// runtime so this works in both environments without type assertions.
+function unref(timer: ReturnType<typeof setTimeout> | ReturnType<typeof setInterval>): void {
+  const t: unknown = timer
+  if (typeof t === 'object' && t !== null && 'unref' in t && typeof t.unref === 'function') {
+    t.unref()
+  }
+}
+
 /**
  * Like `setTimeout`, but calls `.unref()` on the timer when running in Node.js.
  *
@@ -11,14 +21,17 @@
  */
 export function setCleanupTimeout(fn: () => void, delay: number): ReturnType<typeof setTimeout> {
   const timer = setTimeout(fn, delay)
+  unref(timer)
+  return timer
+}
 
-  // In Node.js, setTimeout returns an object with an `unref()` method.
-  // In browsers, it returns a number. We assign to `unknown` and narrow
-  // at runtime so this works in both environments without type assertions.
-  const t: unknown = timer
-  if (typeof t === 'object' && t !== null && 'unref' in t && typeof t.unref === 'function') {
-    t.unref()
-  }
-
+/**
+ * Like `setInterval`, but calls `.unref()` on the timer when running in Node.js
+ * so a recurring poll never keeps the process alive. See {@link setCleanupTimeout}
+ * for why cleanup and background timers must not block process exit.
+ */
+export function setCleanupInterval(fn: () => void, delay: number): ReturnType<typeof setInterval> {
+  const timer = setInterval(fn, delay)
+  unref(timer)
   return timer
 }

package/dist/_chunks-es/version.js

@@ -1,7 +0,0 @@
-import { getEnv } from "./createGroqSearchFilter.js";
-var version = "2.18.0";
-const CORE_SDK_VERSION = getEnv("PKG_VERSION") || `${version}-development`;
-export {
-  CORE_SDK_VERSION
-};
-//# sourceMappingURL=version.js.map

package/dist/_chunks-es/version.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"version.js","sources":["../../src/version.ts"],"sourcesContent":["import {version} from '../package.json'\nimport {getEnv} from './utils/getEnv'\n\n/**\n * This version is provided by pkg-utils at build time\n * @internal\n */\nexport const CORE_SDK_VERSION = getEnv('PKG_VERSION') || `${version}-development`\n"],"names":[],"mappings":";;AAOO,MAAM,mBAAmB,OAAO,aAAa,KAAK,GAAG,OAAO;"}

package/src/utils/defineIntent.test.ts

@@ -1,477 +0,0 @@
-import {describe, expect, test} from 'vitest'
-
-import {defineIntent, type Intent, type IntentFilter} from './defineIntent'
-
-describe('defineIntent', () => {
-  test('should return a valid intent object when all required fields are provided', () => {
-    const intent: Intent = {
-      id: 'viewHat',
-      action: 'view',
-      title: 'View a hat',
-      description: 'This lets you view a hat',
-      filters: [
-        {
-          projectId: 'some-project',
-          dataset: 'a-dataset',
-          types: ['hat'],
-        },
-      ],
-    }
-
-    const result = defineIntent(intent)
-
-    expect(result).toEqual(intent)
-    expect(result).toBe(intent)
-  })
-
-  test('should throw error when filters array is empty', () => {
-    const intent: Intent = {
-      id: 'globalIntent',
-      action: 'create',
-      title: 'Global Intent',
-      description: 'An intent with no filters',
-      filters: [],
-    }
-
-    expect(() => defineIntent(intent)).toThrow(
-      "Intent must have at least one filter. If you want to match everything, use {types: ['*']}",
-    )
-  })
-
-  test('should work with wildcard filter to match everything', () => {
-    const intent: Intent = {
-      id: 'globalIntent',
-      action: 'create',
-      title: 'Global Intent',
-      description: 'An intent that matches everything',
-      filters: [
-        {
-          types: ['*'],
-        },
-      ],
-    }
-
-    const result = defineIntent(intent)
-
-    expect(result).toEqual(intent)
-    expect(result.filters[0].types).toEqual(['*'])
-  })
-
-  test('should work with partial filters', () => {
-    const intent: Intent = {
-      id: 'partialFilter',
-      action: 'edit',
-      title: 'Partial Filter Intent',
-      description: 'An intent with partial filter criteria',
-      filters: [
-        {
-          projectId: 'some-project',
-          types: ['*'], // Add required types
-        },
-        {
-          types: ['document'],
-          // No projectId or dataset specified
-        },
-      ],
-    }
-
-    const result = defineIntent(intent)
-
-    expect(result).toEqual(intent)
-  })
-
-  test('should throw error when id is missing', () => {
-    const intent = {
-      action: 'view',
-      title: 'Test Intent',
-      description: 'Test description',
-      filters: [],
-    } as unknown as Intent
-
-    expect(() => defineIntent(intent)).toThrow('Intent must have an id')
-  })
-
-  test('should throw error when id is empty string', () => {
-    const intent: Intent = {
-      id: '',
-      action: 'view',
-      title: 'Test Intent',
-      description: 'Test description',
-      filters: [],
-    }
-
-    expect(() => defineIntent(intent)).toThrow('Intent must have an id')
-  })
-
-  test('should throw error when action is missing', () => {
-    const intent = {
-      id: 'test',
-      title: 'Test Intent',
-      description: 'Test description',
-      filters: [],
-    } as unknown as Intent
-
-    expect(() => defineIntent(intent)).toThrow('Intent must have an action')
-  })
-
-  test('should throw error when action is empty string', () => {
-    const intent = {
-      id: 'test',
-      action: '',
-      title: 'Test Intent',
-      description: 'Test description',
-      filters: [],
-    } as unknown as Intent
-
-    expect(() => defineIntent(intent)).toThrow('Intent must have an action')
-  })
-
-  test('should throw error when title is missing', () => {
-    const intent = {
-      id: 'test',
-      action: 'view',
-      description: 'Test description',
-      filters: [],
-    } as unknown as Intent
-
-    expect(() => defineIntent(intent)).toThrow('Intent must have a title')
-  })
-
-  test('should throw error when title is empty string', () => {
-    const intent: Intent = {
-      id: 'test',
-      action: 'view',
-      title: '',
-      description: 'Test description',
-      filters: [],
-    }
-
-    expect(() => defineIntent(intent)).toThrow('Intent must have a title')
-  })
-
-  test('should throw error when filters are missing', () => {
-    const intent = {
-      id: 'test',
-      action: 'view',
-      title: 'Test Intent',
-      description: 'Test description',
-    } as unknown as Intent
-
-    expect(() => defineIntent(intent)).toThrow('Intent must have a filters array')
-  })
-
-  test('should throw error when filters are not an array', () => {
-    const intent = {
-      id: 'test',
-      action: 'view',
-      title: 'Test Intent',
-      description: 'Test description',
-      filters: 'not an array',
-    } as unknown as Intent
-
-    expect(() => defineIntent(intent)).toThrow('Intent must have a filters array')
-  })
-
-  test('should work with complex filter combinations', () => {
-    const intent: Intent = {
-      id: 'complexIntent',
-      action: 'edit',
-      title: 'Complex Intent',
-      description: 'An intent with multiple complex filters',
-      filters: [
-        {
-          projectId: 'project-1',
-          dataset: 'production',
-          types: ['article', 'blogPost'],
-        },
-        {
-          projectId: 'project-2',
-          dataset: 'staging',
-          types: ['product'],
-        },
-        {
-          // Filter with only types
-          types: ['global-document'],
-        },
-      ],
-    }
-
-    const result = defineIntent(intent)
-
-    expect(result).toEqual(intent)
-    expect(result.filters).toHaveLength(3)
-    expect(result.filters[0].types).toEqual(['article', 'blogPost'])
-    expect(result.filters[2].projectId).toBeUndefined()
-    expect(result.filters[2].dataset).toBeUndefined()
-  })
-
-  // Filter validation tests
-  test('should throw error for empty filter object', () => {
-    const intent = {
-      id: 'test',
-      action: 'view',
-      title: 'Test Intent',
-      description: 'Test description',
-      filters: [{}],
-    } as unknown as Intent
-
-    expect(() => defineIntent(intent)).toThrow(
-      "Filter at index 0 must have a types property. Use ['*'] to match all document types.",
-    )
-  })
-
-  test('should throw error for non-object filter', () => {
-    const intent = {
-      id: 'test',
-      action: 'view',
-      title: 'Test Intent',
-      description: 'Test description',
-      filters: ['not an object'],
-    } as unknown as Intent
-
-    expect(() => defineIntent(intent)).toThrow('Filter at index 0 must be an object')
-  })
-
-  test('should throw error for non-string projectId', () => {
-    const intent = {
-      id: 'test',
-      action: 'view',
-      title: 'Test Intent',
-      description: 'Test description',
-      filters: [{projectId: 123, types: ['*']}],
-    } as unknown as Intent
-
-    expect(() => defineIntent(intent)).toThrow('Filter at index 0: projectId must be a string')
-  })
-
-  test('should throw error for empty projectId', () => {
-    const intent: Intent = {
-      id: 'test',
-      action: 'view',
-      title: 'Test Intent',
-      description: 'Test description',
-      filters: [{projectId: '', types: ['*']}],
-    }
-
-    expect(() => defineIntent(intent)).toThrow('Filter at index 0: projectId cannot be empty')
-  })
-
-  test('should throw error for whitespace-only projectId', () => {
-    const intent: Intent = {
-      id: 'test',
-      action: 'view',
-      title: 'Test Intent',
-      description: 'Test description',
-      filters: [{projectId: '   ', types: ['*']}],
-    }
-
-    expect(() => defineIntent(intent)).toThrow('Filter at index 0: projectId cannot be empty')
-  })
-
-  test('should throw error for non-string dataset', () => {
-    const intent = {
-      id: 'test',
-      action: 'view',
-      title: 'Test Intent',
-      description: 'Test description',
-      filters: [{projectId: 'test', dataset: 123, types: ['*']}],
-    } as unknown as Intent
-
-    expect(() => defineIntent(intent)).toThrow('Filter at index 0: dataset must be a string')
-  })
-
-  test('should throw error for empty dataset', () => {
-    const intent: Intent = {
-      id: 'test',
-      action: 'view',
-      title: 'Test Intent',
-      description: 'Test description',
-      filters: [{dataset: '', types: ['*']}],
-    }
-
-    expect(() => defineIntent(intent)).toThrow('Filter at index 0: dataset cannot be empty')
-  })
-
-  test('should throw error when dataset is specified without projectId', () => {
-    const intent: Intent = {
-      id: 'test',
-      action: 'view',
-      title: 'Test Intent',
-      description: 'Test description',
-      filters: [{dataset: 'production', types: ['*']}],
-    }
-
-    expect(() => defineIntent(intent)).toThrow(
-      'Filter at index 0: dataset cannot be specified without projectId',
-    )
-  })
-
-  test('should throw error when dataset is specified with empty projectId', () => {
-    const intent: Intent = {
-      id: 'test',
-      action: 'view',
-      title: 'Test Intent',
-      description: 'Test description',
-      filters: [{projectId: '', dataset: 'production', types: ['*']}],
-    }
-
-    expect(() => defineIntent(intent)).toThrow('Filter at index 0: projectId cannot be empty')
-  })
-
-  test('should work when dataset is specified with valid projectId', () => {
-    const intent: Intent = {
-      id: 'test',
-      action: 'view',
-      title: 'Test Intent',
-      description: 'Test description',
-      filters: [{projectId: 'my-project', dataset: 'production', types: ['*']}],
-    }
-
-    const result = defineIntent(intent)
-    expect(result).toEqual(intent)
-  })
-
-  test('should throw error for non-array types', () => {
-    const intent = {
-      id: 'test',
-      action: 'view',
-      title: 'Test Intent',
-      description: 'Test description',
-      filters: [{types: 'not-an-array'}],
-    } as unknown as Intent
-
-    expect(() => defineIntent(intent)).toThrow('Filter at index 0: types must be an array')
-  })
-
-  test('should throw error for empty types array', () => {
-    const intent: Intent = {
-      id: 'test',
-      action: 'view',
-      title: 'Test Intent',
-      description: 'Test description',
-      filters: [{types: []}],
-    }
-
-    expect(() => defineIntent(intent)).toThrow('Filter at index 0: types array cannot be empty')
-  })
-
-  test('should throw error for non-string type in types array', () => {
-    const intent = {
-      id: 'test',
-      action: 'view',
-      title: 'Test Intent',
-      description: 'Test description',
-      filters: [{types: ['valid', 123, 'also-valid']}],
-    } as unknown as Intent
-
-    expect(() => defineIntent(intent)).toThrow('Filter at index 0: types[1] must be a string')
-  })
-
-  test('should throw error for empty string in types array', () => {
-    const intent: Intent = {
-      id: 'test',
-      action: 'view',
-      title: 'Test Intent',
-      description: 'Test description',
-      filters: [{types: ['valid', '', 'also-valid']}],
-    }
-
-    expect(() => defineIntent(intent)).toThrow('Filter at index 0: types[1] cannot be empty')
-  })
-
-  test('should throw error for whitespace-only string in types array', () => {
-    const intent: Intent = {
-      id: 'test',
-      action: 'view',
-      title: 'Test Intent',
-      description: 'Test description',
-      filters: [{types: ['valid', '   ', 'also-valid']}],
-    }
-
-    expect(() => defineIntent(intent)).toThrow('Filter at index 0: types[1] cannot be empty')
-  })
-
-  test('should throw error when wildcard is mixed with other types', () => {
-    const intent: Intent = {
-      id: 'test',
-      action: 'view',
-      title: 'Test Intent',
-      description: 'Test description',
-      filters: [{types: ['*', 'document']}],
-    }
-
-    expect(() => defineIntent(intent)).toThrow(
-      "Filter at index 0: when using wildcard '*', it must be the only type in the array",
-    )
-  })
-
-  test('should throw error when wildcard appears with other types in different order', () => {
-    const intent: Intent = {
-      id: 'test',
-      action: 'view',
-      title: 'Test Intent',
-      description: 'Test description',
-      filters: [{types: ['document', 'article', '*']}],
-    }
-
-    expect(() => defineIntent(intent)).toThrow(
-      "Filter at index 0: when using wildcard '*', it must be the only type in the array",
-    )
-  })
-
-  test('should work with valid individual filter properties', () => {
-    const intent: Intent = {
-      id: 'test',
-      action: 'view',
-      title: 'Test Intent',
-      description: 'Test description',
-      filters: [
-        {projectId: 'my-project', types: ['*']},
-        {projectId: 'my-project', dataset: 'production', types: ['*']},
-        {types: ['document']},
-        {types: ['*']}, // Valid wildcard usage
-      ],
-    }
-
-    const result = defineIntent(intent)
-    expect(result).toEqual(intent)
-  })
-
-  test('should provide correct filter index in error messages for multiple filters', () => {
-    const intent: Intent = {
-      id: 'test',
-      action: 'view',
-      title: 'Test Intent',
-      description: 'Test description',
-      filters: [
-        {projectId: 'valid-project', types: ['*']},
-        {projectId: '', types: ['*']},
-      ],
-    }
-
-    expect(() => defineIntent(intent)).toThrow('Filter at index 1: projectId cannot be empty')
-  })
-})
-
-describe('IntentFilter interface', () => {
-  test('should require types property', () => {
-    // This is more of a TypeScript compile-time test
-    // but we can verify the structure is as expected
-    const filter1: IntentFilter = {types: ['*']} // types is now required
-    const filter2: IntentFilter = {projectId: 'test', types: ['*']} // types is now required
-    const filter3: IntentFilter = {dataset: 'test', types: ['*']} // types is now required
-    const filter4: IntentFilter = {types: ['test']}
-    const filter5: IntentFilter = {
-      projectId: 'test',
-      dataset: 'test',
-      types: ['test'],
-    }
-
-    // These should all be valid filter objects
-    expect(filter1).toBeDefined()
-    expect(filter2).toBeDefined()
-    expect(filter3).toBeDefined()
-    expect(filter4).toBeDefined()
-    expect(filter5).toBeDefined()
-  })
-})