@sanity/sdk 3.0.0-rc.0 → 3.0.0-rc.1

package/src/utils/isImportError.test.ts

@@ -0,0 +1,72 @@
+import {describe, expect, test} from 'vitest'
+
+import {isImportError} from './isImportError'
+
+describe('isImportError', () => {
+  test('returns false for non-Error values', () => {
+    expect(isImportError(null)).toBe(false)
+    expect(isImportError(undefined)).toBe(false)
+    expect(isImportError('Loading chunk 5 failed.')).toBe(false)
+    expect(isImportError({message: 'Loading chunk 5 failed.'})).toBe(false)
+    expect(isImportError(42)).toBe(false)
+  })
+
+  test('returns false for unrelated Error instances', () => {
+    expect(isImportError(new Error('Something else went wrong'))).toBe(false)
+    expect(isImportError(new TypeError('Cannot read properties of undefined'))).toBe(false)
+  })
+
+  test('detects webpack ChunkLoadError by name', () => {
+    const err = new Error('arbitrary message')
+    err.name = 'ChunkLoadError'
+    expect(isImportError(err)).toBe(true)
+  })
+
+  test('detects webpack numeric chunk failure messages', () => {
+    expect(isImportError(new Error('Loading chunk 5 failed.'))).toBe(true)
+    expect(
+      isImportError(new Error('Loading chunk 42 failed. (missing: https://x.com/42.abc.js)')),
+    ).toBe(true)
+  })
+
+  test('detects webpack named chunk failure messages', () => {
+    expect(isImportError(new Error('Loading chunk vendors-foo failed.'))).toBe(true)
+    expect(isImportError(new Error('Loading chunk react_vendors failed.'))).toBe(true)
+  })
+
+  test('detects Vite "Failed to fetch dynamically imported module"', () => {
+    expect(
+      isImportError(
+        new TypeError(
+          'Failed to fetch dynamically imported module: https://example.com/assets/Home-abc123.js',
+        ),
+      ),
+    ).toBe(true)
+  })
+
+  test('detects Firefox "error loading dynamically imported module"', () => {
+    expect(
+      isImportError(
+        new TypeError(
+          'error loading dynamically imported module: http://localhost:8080/src/views/Dashboard/index.vue',
+        ),
+      ),
+    ).toBe(true)
+  })
+
+  test('detects Safari module-script failures with and without the "ing" suffix', () => {
+    expect(isImportError(new TypeError('Importing a module script failed.'))).toBe(true)
+    expect(isImportError(new TypeError('Import a module script failed.'))).toBe(true)
+  })
+
+  test('detects Vite CSS preload failures', () => {
+    expect(isImportError(new Error('Unable to preload CSS for /assets/App-BBLnt7oG.css'))).toBe(
+      true,
+    )
+  })
+
+  test('matches case-insensitively', () => {
+    expect(isImportError(new Error('loading chunk 1 FAILED'))).toBe(true)
+    expect(isImportError(new Error('FAILED TO FETCH DYNAMICALLY IMPORTED MODULE'))).toBe(true)
+  })
+})

package/src/utils/isImportError.ts

@@ -0,0 +1,34 @@
+/**
+ * Returns true when the given error looks like a dynamic-import or
+ * code-split chunk-loading failure.
+ *
+ * These errors typically surface when a user has a tab open against a
+ * previously-deployed version of an app and the JavaScript or CSS chunk
+ * filenames have since changed: a fresh deployment removes the hashed assets
+ * the open tab still references. Detecting them lets the SDK trigger an
+ * automatic reload so the user gets the new build without manual intervention.
+ *
+ * Recognized shapes (webpack ChunkLoadError, Vite "Failed to fetch
+ * dynamically imported module", Firefox "error loading dynamically imported
+ * module", Safari "Importing a module script failed", and Vite "Unable to
+ * preload CSS").
+ *
+ * @param error - The value to inspect. Anything that is not an Error
+ *   instance returns false.
+ * @returns True if the error matches a known import/chunk-load failure.
+ *
+ * @public
+ */
+export function isImportError(error: unknown): boolean {
+  if (!(error instanceof Error)) return false
+  if (error.name === 'ChunkLoadError') return true
+
+  const message = error.message || ''
+  return (
+    /Loading chunk [\w-]+ failed/i.test(message) ||
+    /Failed to fetch dynamically imported module/i.test(message) ||
+    /error loading dynamically imported module/i.test(message) ||
+    /Import(?:ing)? a module script failed/i.test(message) ||
+    /Unable to preload CSS/i.test(message)
+  )
+}

package/src/utils/logger.test.ts

@@ -644,6 +644,7 @@ describe('logger', () => {
         instanceContext: {
           instanceId: 'abc123def456',
           projectId: 'my-project',
+          dataset: 'production',
         },
       })
 
@@ -653,6 +654,10 @@ describe('logger', () => {
         expect.stringContaining('[project:my-project]'),
         expect.any(Object),
       )
+      expect(mockHandler.info).toHaveBeenCalledWith(
+        expect.stringContaining('[dataset:production]'),
+        expect.any(Object),
+      )
       expect(mockHandler.info).toHaveBeenCalledWith(
         expect.stringContaining('[instance:abc123de]'), // Truncated to 8 chars
         expect.any(Object),
@@ -689,6 +694,7 @@ describe('logger', () => {
       const logger = createLogger('query', {
         instanceContext: {
           projectId: 'my-project',
+          // No dataset or instanceId
         },
       })
 
@@ -698,12 +704,17 @@ describe('logger', () => {
         expect.stringContaining('[project:my-project]'),
         expect.any(Object),
       )
+      expect(mockHandler.info).not.toHaveBeenCalledWith(
+        expect.stringContaining('[dataset:'),
+        expect.any(Object),
+      )
     })
 
     it('should return instance context', () => {
       const instanceContext = {
         instanceId: 'test-instance',
         projectId: 'test-project',
+        dataset: 'test-dataset',
       }
 
       const logger = createLogger('auth', {instanceContext})
@@ -727,6 +738,7 @@ describe('logger', () => {
       const logger = createLogger('document', {
         instanceContext: {
           projectId: 'my-project',
+          dataset: 'production',
         },
       })
 

package/src/utils/logger.ts

@@ -153,9 +153,9 @@ export interface LogContext {
 export interface InstanceContext {
   /** Unique instance ID */
   instanceId?: string
-  /** Project ID (derived from default resource) */
+  /** Project ID */
   projectId?: string
-  /** Dataset name (derived from default resource) */
+  /** Dataset name */
   dataset?: string
 }
 
@@ -520,9 +520,14 @@ function logRxJSOperator(namespace: string, operator: string, context?: LogConte
  * @internal
  */
 /* c8 ignore next 7 */
-function getInstanceContext(instance: {instanceId?: string}): InstanceContext {
+function getInstanceContext(instance: {
+  instanceId?: string
+  config?: {projectId?: string; dataset?: string}
+}): InstanceContext {
   return {
     instanceId: instance.instanceId,
+    projectId: instance.config?.projectId,
+    dataset: instance.config?.dataset,
   }
 }
 

package/src/utils/object.test.ts

@@ -0,0 +1,95 @@
+import {describe, expect, it} from 'vitest'
+
+import {isDeepEqual, isObject, omitProperty, pickProperties} from './object'
+
+describe('object utils', () => {
+  describe('isObject', () => {
+    it('returns true for objects and false for primitives', () => {
+      expect(isObject({foo: 'bar'})).toBe(true)
+      expect(isObject(null)).toBe(false)
+      expect(isObject('hello')).toBe(false)
+    })
+  })
+
+  describe('omitProperty', () => {
+    it('removes a property from an object copy', () => {
+      expect(omitProperty({foo: 'bar', baz: 1}, 'foo')).toEqual({baz: 1})
+    })
+
+    it('returns an empty object for undefined input', () => {
+      expect(omitProperty<{foo: string}, 'foo'>(undefined, 'foo')).toEqual({})
+    })
+  })
+
+  describe('pickProperties', () => {
+    it('copies only the requested own properties', () => {
+      expect(pickProperties({foo: 'bar', baz: 1}, ['foo'])).toEqual({foo: 'bar'})
+    })
+  })
+
+  describe('isDeepEqual', () => {
+    it('matches nested plain objects and arrays', () => {
+      expect(
+        isDeepEqual({foo: [{bar: 'baz'}], qux: {count: 2}}, {foo: [{bar: 'baz'}], qux: {count: 2}}),
+      ).toBe(true)
+    })
+
+    it('returns false for unequal nested plain objects and arrays', () => {
+      expect(
+        isDeepEqual(
+          {foo: [{bar: 'baz'}], qux: {count: 2}},
+          {foo: [{bar: 'nope'}], qux: {count: 2}},
+        ),
+      ).toBe(false)
+      expect(isDeepEqual([1, {foo: 'bar'}], [1, {foo: 'baz'}])).toBe(false)
+    })
+
+    it('matches sets and maps with equal contents', () => {
+      expect(isDeepEqual(new Set([{foo: 'bar'}, 'baz']), new Set(['baz', {foo: 'bar'}]))).toBe(true)
+
+      expect(
+        isDeepEqual(
+          new Map<string, unknown>([
+            ['foo', {bar: 'baz'}],
+            ['count', 2],
+          ]),
+          new Map<string, unknown>([
+            ['foo', {bar: 'baz'}],
+            ['count', 2],
+          ]),
+        ),
+      ).toBe(true)
+    })
+
+    it('compares dates by timestamp', () => {
+      expect(isDeepEqual(new Date('2024-01-01'), new Date('2024-01-01'))).toBe(true)
+      expect(isDeepEqual(new Date('2024-01-01'), new Date('2024-01-02'))).toBe(false)
+    })
+
+    it('compares regular expressions by source and flags', () => {
+      expect(isDeepEqual(/foo/gi, /foo/gi)).toBe(true)
+      expect(isDeepEqual(/foo/g, /foo/i)).toBe(false)
+      expect(isDeepEqual(/foo/g, /bar/g)).toBe(false)
+    })
+
+    it('returns false for cross-shape mismatches', () => {
+      expect(isDeepEqual({foo: 'bar'}, ['foo', 'bar'] as unknown as {foo: string})).toBe(false)
+      expect(
+        isDeepEqual(
+          new Map<string, unknown>([['foo', 'bar']]) as unknown as object,
+          new Set(['foo', 'bar']) as unknown as object,
+        ),
+      ).toBe(false)
+    })
+
+    it('treats non-plain objects as unequal unless they are the same reference', () => {
+      class Example {
+        constructor(public value: string) {}
+      }
+
+      expect(isDeepEqual(new Example('a'), new Example('a'))).toBe(false)
+      const instance = new Example('a')
+      expect(isDeepEqual(instance, instance)).toBe(true)
+    })
+  })
+})

package/src/utils/object.ts

@@ -0,0 +1,142 @@
+/**
+ * Returns true when the input is a non-null object.
+ *
+ * @internal
+ */
+export function isObject(value: unknown): value is object {
+  return typeof value === 'object' && value !== null
+}
+
+const hasOwn = (value: object, key: PropertyKey) => Object.prototype.hasOwnProperty.call(value, key)
+
+const isPlainObject = (value: unknown): value is Record<string, unknown> => {
+  if (!isObject(value)) return false
+
+  const prototype = Object.getPrototypeOf(value)
+  return prototype === Object.prototype || prototype === null
+}
+
+/**
+ * Creates a shallow copy without the provided property.
+ *
+ * @internal
+ */
+export function omitProperty<T extends object, K extends keyof T>(
+  value: T | null | undefined,
+  key: K,
+): Omit<T, K> {
+  if (!value) return {} as Omit<T, K>
+
+  const {[key]: _omitted, ...rest} = value
+  return rest
+}
+
+/**
+ * Creates a shallow copy containing only the provided properties.
+ *
+ * @internal
+ */
+export function pickProperties<T extends object, K extends keyof T>(
+  value: T,
+  keys: readonly K[],
+): Pick<T, K> {
+  const result = {} as Pick<T, K>
+
+  for (const key of keys) {
+    if (hasOwn(value, key)) {
+      result[key] = value[key]
+    }
+  }
+
+  return result
+}
+
+const areSetsEqual = (left: Set<unknown>, right: Set<unknown>): boolean => {
+  if (left.size !== right.size) return false
+
+  const unmatched = [...right]
+
+  outer: for (const leftValue of left) {
+    for (let index = 0; index < unmatched.length; index++) {
+      if (isDeepEqual(leftValue, unmatched[index])) {
+        unmatched.splice(index, 1)
+        continue outer
+      }
+    }
+
+    return false
+  }
+
+  return unmatched.length === 0
+}
+
+const areMapsEqual = (left: Map<unknown, unknown>, right: Map<unknown, unknown>): boolean => {
+  if (left.size !== right.size) return false
+
+  const unmatched = [...right.entries()]
+
+  outer: for (const [leftKey, leftValue] of left) {
+    for (let index = 0; index < unmatched.length; index++) {
+      const [rightKey, rightValue] = unmatched[index]
+
+      if (isDeepEqual(leftKey, rightKey) && isDeepEqual(leftValue, rightValue)) {
+        unmatched.splice(index, 1)
+        continue outer
+      }
+    }
+
+    return false
+  }
+
+  return unmatched.length === 0
+}
+
+/**
+ * Compares values deeply across the plain object, array, map, and set shapes used by the SDK.
+ * This helper is intended for acyclic SDK data structures and does not guard against circular
+ * references.
+ *
+ * @internal
+ */
+export function isDeepEqual<T>(left: T, right: T): boolean {
+  if (Object.is(left, right)) return true
+
+  if (!isObject(left) || !isObject(right)) return false
+
+  if (left instanceof Date && right instanceof Date) {
+    return left.getTime() === right.getTime()
+  }
+
+  if (left instanceof RegExp && right instanceof RegExp) {
+    return left.source === right.source && left.flags === right.flags
+  }
+
+  if (left instanceof Set && right instanceof Set) {
+    return areSetsEqual(left, right)
+  }
+
+  if (left instanceof Map && right instanceof Map) {
+    return areMapsEqual(left, right)
+  }
+
+  if (Array.isArray(left) || Array.isArray(right)) {
+    if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false
+
+    return left.every((value, index) => isDeepEqual(value, right[index]))
+  }
+
+  if (!isPlainObject(left) || !isPlainObject(right)) return false
+
+  const leftKeys = Object.keys(left)
+  const rightKeys = Object.keys(right)
+
+  if (leftKeys.length !== rightKeys.length) return false
+
+  for (const key of leftKeys) {
+    if (!hasOwn(right, key) || !isDeepEqual(left[key], right[key])) {
+      return false
+    }
+  }
+
+  return true
+}

package/src/utils/setCleanupTimeout.ts

@@ -0,0 +1,37 @@
+// 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.
+ *
+ * In Node.js, active timers prevent the process from exiting. Cleanup timers
+ * (e.g. deferred subscription removal) should not keep the process alive -
+ * `.unref()` lets the process exit naturally while still firing the timer if
+ * the process happens to still be running.
+ *
+ * In browsers, `setTimeout` returns a number and has no `.unref()` method,
+ * so this is a no-op there.
+ */
+export function setCleanupTimeout(fn: () => void, delay: number): ReturnType<typeof setTimeout> {
+  const timer = setTimeout(fn, delay)
+  unref(timer)
+  return timer
+}
+
+/**
+ * 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
+}