musora-content-services 2.160.4 → 2.161.2

package/test/unit/infrastructure/sanity/SanityClient.test.ts

@@ -0,0 +1,140 @@
+import { SanityClient } from '../../../../src/infrastructure/sanity/SanityClient'
+import { ConfigProvider } from '../../../../src/infrastructure/sanity/interfaces/ConfigProvider'
+import { QueryExecutor } from '../../../../src/infrastructure/sanity/interfaces/QueryExecutor'
+import { SanityConfig } from '../../../../src/infrastructure/sanity/interfaces/SanityConfig'
+
+describe('SanityClient', () => {
+  const config: SanityConfig = {
+    projectId: 'p',
+    dataset: 'd',
+    version: '2021-06-07',
+    token: 't',
+  }
+  let mockConfigProvider: jest.Mocked<ConfigProvider>
+  let mockExecutor: jest.Mocked<QueryExecutor>
+  let client: SanityClient
+
+  beforeEach(() => {
+    mockConfigProvider = {
+      getConfig: jest.fn().mockReturnValue(config),
+    }
+    mockExecutor = {
+      execute: jest.fn(),
+    }
+    client = new SanityClient(mockConfigProvider, mockExecutor)
+  })
+
+  describe('fetchSingle', () => {
+    test('returns first item from result array', async () => {
+      mockExecutor.execute.mockResolvedValue({
+        result: [{ id: 1 }, { id: 2 }],
+        ms: 5,
+        query: 'q',
+      })
+      const result = await client.fetchSingle<{ id: number }>('*[_type=="x"]', { a: 1 })
+      expect(result).toEqual({ id: 1 })
+      expect(mockExecutor.execute).toHaveBeenCalledWith(
+        { query: '*[_type=="x"]', params: { a: 1 } },
+        config
+      )
+    })
+
+    test('returns null when result array is empty', async () => {
+      mockExecutor.execute.mockResolvedValue({ result: [], ms: 1, query: 'q' })
+      expect(await client.fetchSingle('q')).toBeNull()
+    })
+
+    test('returns null when result is not an array', async () => {
+      mockExecutor.execute.mockResolvedValue({ result: { id: 1 } as any, ms: 1, query: 'q' })
+      expect(await client.fetchSingle('q')).toBeNull()
+    })
+
+    test('rethrows SanityError unchanged and returns nothing useful', async () => {
+      const sanityError = { message: 'boom', query: 'q' }
+      mockExecutor.execute.mockRejectedValue(sanityError)
+      await expect(client.fetchSingle('q')).rejects.toEqual(sanityError)
+    })
+
+    test('wraps non-SanityError as SanityError including query and originalError', async () => {
+      const raw = new Error('network down')
+      mockExecutor.execute.mockRejectedValue(raw)
+      await expect(client.fetchSingle('myquery')).rejects.toMatchObject({
+        message: 'network down',
+        query: 'myquery',
+        originalError: raw,
+      })
+    })
+  })
+
+  describe('fetchList', () => {
+    test('returns result array', async () => {
+      const data = [{ id: 1 }, { id: 2 }]
+      mockExecutor.execute.mockResolvedValue({ result: data, ms: 1, query: 'q' })
+      const result = await client.fetchList('q')
+      expect(result).toEqual(data)
+    })
+
+    test('returns empty array when result is null/undefined', async () => {
+      mockExecutor.execute.mockResolvedValue({ result: null as any, ms: 1, query: 'q' })
+      expect(await client.fetchList('q')).toEqual([])
+    })
+
+    test('rethrows existing SanityError', async () => {
+      const sanityError = { message: 'boom', query: 'q' }
+      mockExecutor.execute.mockRejectedValue(sanityError)
+      await expect(client.fetchList('q')).rejects.toEqual(sanityError)
+    })
+
+    test('wraps non-SanityError as SanityError', async () => {
+      mockExecutor.execute.mockRejectedValue(new Error('fail'))
+      await expect(client.fetchList('q')).rejects.toMatchObject({
+        message: 'fail',
+        query: 'q',
+      })
+    })
+  })
+
+  describe('executeQuery', () => {
+    test('returns the raw result', async () => {
+      mockExecutor.execute.mockResolvedValue({ result: { count: 7 }, ms: 1, query: 'q' })
+      const result = await client.executeQuery<{ count: number }>('q')
+      expect(result).toEqual({ count: 7 })
+    })
+
+    test('returns null when result is missing', async () => {
+      mockExecutor.execute.mockResolvedValue({ result: null as any, ms: 1, query: 'q' })
+      expect(await client.executeQuery('q')).toBeNull()
+    })
+
+    test('rethrows wrapped error on failure', async () => {
+      mockExecutor.execute.mockRejectedValue(new Error('explode'))
+      await expect(client.executeQuery('q')).rejects.toMatchObject({
+        message: 'explode',
+        query: 'q',
+      })
+    })
+  })
+
+  describe('config caching', () => {
+    test('loads config once across multiple calls', async () => {
+      mockExecutor.execute.mockResolvedValue({ result: [], ms: 1, query: 'q' })
+      await client.fetchList('q1')
+      await client.fetchList('q2')
+      await client.fetchSingle('q3')
+      expect(mockConfigProvider.getConfig).toHaveBeenCalledTimes(1)
+    })
+
+    test('refreshConfig forces a reload on the next call', async () => {
+      mockExecutor.execute.mockResolvedValue({ result: [], ms: 1, query: 'q' })
+      await client.fetchList('q1')
+      client.refreshConfig()
+      await client.fetchList('q2')
+      expect(mockConfigProvider.getConfig).toHaveBeenCalledTimes(2)
+    })
+  })
+
+  test('falls back to default providers when none are supplied', () => {
+    const defaultClient = new SanityClient()
+    expect(defaultClient).toBeInstanceOf(SanityClient)
+  })
+})

package/test/unit/lib/sanity/decorators/base.test.ts

@@ -0,0 +1,368 @@
+import {
+  decorate,
+  decorateAll,
+  decorateAsync,
+  decorateAllAsync,
+  type Decoratable,
+  type FieldDecorator,
+  type FieldDecoratorAsync,
+} from '../../../../../src/lib/sanity/decorators/base'
+
+describe('base decorator', () => {
+  describe('decorate', () => {
+    test('sets field on single object', () => {
+      const item: Decoratable = { id: 1 }
+      decorate(item, 'mark', () => 'A')
+      expect(item.mark).toBe('A')
+    })
+
+    test('sets field on every item in array', () => {
+      const items: Decoratable[] = [{ id: 1 }, { id: 2 }, { id: 3 }]
+      decorate(items, 'mark', (i) => i.id)
+      expect(items.map((i) => i.mark)).toEqual([1, 2, 3])
+    })
+
+    test('returns the same reference it was given', () => {
+      const items: Decoratable[] = [{ id: 1 }]
+      const result = decorate(items, 'mark', () => true)
+      expect(result).toBe(items)
+    })
+
+    test('recurses children up to 3 levels deep', () => {
+      const tree: Decoratable = {
+        id: 1,
+        children: [
+          {
+            id: 2,
+            children: [
+              {
+                id: 3,
+                children: [{ id: 4 }],
+              },
+            ],
+          },
+        ],
+      }
+      decorate(tree, 'visited', () => true)
+
+      expect(tree.visited).toBe(true)
+      const lvl1 = (tree.children as Decoratable[])[0]
+      const lvl2 = (lvl1.children as Decoratable[])[0]
+      const lvl3 = (lvl2.children as Decoratable[])[0]
+      expect(lvl1.visited).toBe(true)
+      expect(lvl2.visited).toBe(true)
+      expect(lvl3.visited).toBeUndefined()
+    })
+
+    test('ignores missing or non-array children', () => {
+      const item: Decoratable = { id: 1 }
+      expect(() => decorate(item, 'mark', () => 1)).not.toThrow()
+      expect(item.mark).toBe(1)
+
+      const bad: Decoratable = { id: 1, children: 'not-an-array' as unknown as Decoratable[] }
+      expect(() => decorate(bad, 'mark', () => 1)).not.toThrow()
+      expect(bad.mark).toBe(1)
+    })
+
+    test('passes the visited item to the compute callback', () => {
+      const item: Decoratable = { id: 7, label: 'x' }
+      const compute = jest.fn(() => 'ok')
+      decorate(item, 'mark', compute)
+      expect(compute).toHaveBeenCalledTimes(1)
+      expect(compute).toHaveBeenCalledWith(item)
+    })
+  })
+
+  describe('decorateAll', () => {
+    test('applies every decorator on a single walk', () => {
+      const items: Decoratable[] = [{ id: 1, children: [{ id: 2 }] }]
+      const a: FieldDecorator<Decoratable> = { field: 'a', compute: () => 'A' }
+      const b: FieldDecorator<Decoratable> = { field: 'b', compute: () => 'B' }
+      decorateAll(items, [a, b])
+
+      expect(items[0].a).toBe('A')
+      expect(items[0].b).toBe('B')
+      const child = (items[0].children as Decoratable[])[0]
+      expect(child.a).toBe('A')
+      expect(child.b).toBe('B')
+    })
+
+    test('empty decorator list is a no-op', () => {
+      const items: Decoratable[] = [{ id: 1 }]
+      decorateAll(items, [])
+      expect(Object.keys(items[0])).toEqual(['id'])
+    })
+
+    test('visits each item exactly once even with multiple decorators', () => {
+      const items: Decoratable[] = [{ id: 1, children: [{ id: 2 }, { id: 3 }] }]
+      const seen: number[] = []
+      const probe: FieldDecorator<Decoratable> = {
+        field: 'probe',
+        compute: (item) => {
+          seen.push(item.id as number)
+          return true
+        },
+      }
+      decorateAll(items, [probe, probe])
+      expect(seen.sort()).toEqual([1, 1, 2, 2, 3, 3])
+    })
+
+    test('recurse:false decorator runs only at top level; recurse:true descends', () => {
+      const items: Decoratable[] = [{ id: 1, children: [{ id: 2 }, { id: 3 }] }]
+      const topOnlyHits: number[] = []
+      const everyHits: number[] = []
+      const topOnly: FieldDecorator<Decoratable> = {
+        field: 'top',
+        compute: (item) => {
+          topOnlyHits.push(item.id as number)
+          return true
+        },
+        recurse: false,
+      }
+      const every: FieldDecorator<Decoratable> = {
+        field: 'every',
+        compute: (item) => {
+          everyHits.push(item.id as number)
+          return true
+        },
+      }
+      decorateAll(items, [topOnly, every])
+      expect(topOnlyHits).toEqual([1])
+      expect(everyHits.sort()).toEqual([1, 2, 3])
+      expect(items[0].top).toBe(true)
+      const child = (items[0].children as Decoratable[])[0]
+      expect(child.top).toBeUndefined()
+      expect(child.every).toBe(true)
+    })
+
+    test('all decorators recurse:false → children untouched, walk skipped', () => {
+      const items: Decoratable[] = [{ id: 1, children: [{ id: 2 }] }]
+      const seen: number[] = []
+      const dec: FieldDecorator<Decoratable> = {
+        field: 'mark',
+        compute: (item) => {
+          seen.push(item.id as number)
+          return true
+        },
+        recurse: false,
+      }
+      decorateAll(items, [dec])
+      expect(seen).toEqual([1])
+      const child = (items[0].children as Decoratable[])[0]
+      expect(child.mark).toBeUndefined()
+    })
+  })
+
+  describe('decorateAsync', () => {
+    test('sets resolved value on single object', async () => {
+      const item: Decoratable = { id: 1 }
+      await decorateAsync(item, 'mark', async () => 'A')
+      expect(item.mark).toBe('A')
+    })
+
+    test('sets resolved value on every item in array', async () => {
+      const items: Decoratable[] = [{ id: 1 }, { id: 2 }, { id: 3 }]
+      await decorateAsync(items, 'mark', async (i) => i.id)
+      expect(items.map((i) => i.mark)).toEqual([1, 2, 3])
+    })
+
+    test('returns same reference it was given', async () => {
+      const items: Decoratable[] = [{ id: 1 }]
+      const result = await decorateAsync(items, 'mark', async () => true)
+      expect(result).toBe(items)
+    })
+
+    test('recurses children up to 3 levels deep', async () => {
+      const tree: Decoratable = {
+        id: 1,
+        children: [
+          {
+            id: 2,
+            children: [
+              {
+                id: 3,
+                children: [{ id: 4 }],
+              },
+            ],
+          },
+        ],
+      }
+      await decorateAsync(tree, 'visited', async () => true)
+
+      expect(tree.visited).toBe(true)
+      const lvl1 = (tree.children as Decoratable[])[0]
+      const lvl2 = (lvl1.children as Decoratable[])[0]
+      const lvl3 = (lvl2.children as Decoratable[])[0]
+      expect(lvl1.visited).toBe(true)
+      expect(lvl2.visited).toBe(true)
+      expect(lvl3.visited).toBeUndefined()
+    })
+
+    test('propagates rejection from compute', async () => {
+      const item: Decoratable = { id: 1 }
+      const failing = decorateAsync(item, 'mark', async () => {
+        throw new Error('boom')
+      })
+      await expect(failing).rejects.toThrow('boom')
+    })
+  })
+
+  describe('decorateAllAsync', () => {
+    test('applies every async decorator on a single walk', async () => {
+      const items: Decoratable[] = [{ id: 1, children: [{ id: 2 }] }]
+      const a: FieldDecoratorAsync<Decoratable> = {
+        field: 'a',
+        compute: async () => 'A',
+      }
+      const b: FieldDecoratorAsync<Decoratable> = {
+        field: 'b',
+        compute: async () => 'B',
+      }
+      await decorateAllAsync(items, [a, b])
+
+      expect(items[0].a).toBe('A')
+      expect(items[0].b).toBe('B')
+      const child = (items[0].children as Decoratable[])[0]
+      expect(child.a).toBe('A')
+      expect(child.b).toBe('B')
+    })
+
+    test('empty decorator list is a no-op', async () => {
+      const items: Decoratable[] = [{ id: 1 }]
+      await decorateAllAsync(items, [])
+      expect(Object.keys(items[0])).toEqual(['id'])
+    })
+
+    test('runs decorators for one item in parallel', async () => {
+      const items: Decoratable[] = [{ id: 1 }]
+      let active = 0
+      let peak = 0
+      const tracker = async () => {
+        active++
+        peak = Math.max(peak, active)
+        await new Promise((r) => setTimeout(r, 5))
+        active--
+        return true
+      }
+      await decorateAllAsync(items, [
+        { field: 'a', compute: tracker },
+        { field: 'b', compute: tracker },
+        { field: 'c', compute: tracker },
+      ])
+      expect(peak).toBe(3)
+    })
+
+    test('runs items in parallel', async () => {
+      const items: Decoratable[] = [{ id: 1 }, { id: 2 }, { id: 3 }]
+      let active = 0
+      let peak = 0
+      const tracker = async () => {
+        active++
+        peak = Math.max(peak, active)
+        await new Promise((r) => setTimeout(r, 5))
+        active--
+        return true
+      }
+      await decorateAllAsync(items, [{ field: 'mark', compute: tracker }])
+      expect(peak).toBe(3)
+    })
+
+    test('runs children in parallel', async () => {
+      const items: Decoratable[] = [
+        { id: 1, children: [{ id: 2 }, { id: 3 }, { id: 4 }] },
+      ]
+      let active = 0
+      let peak = 0
+      const tracker = async () => {
+        active++
+        peak = Math.max(peak, active)
+        await new Promise((r) => setTimeout(r, 5))
+        active--
+        return true
+      }
+      await decorateAllAsync(items, [{ field: 'mark', compute: tracker }])
+      expect(peak).toBeGreaterThanOrEqual(3)
+    })
+
+    test('visits each item exactly once with multiple decorators', async () => {
+      const items: Decoratable[] = [{ id: 1, children: [{ id: 2 }, { id: 3 }] }]
+      const seen: number[] = []
+      const probe: FieldDecoratorAsync<Decoratable> = {
+        field: 'probe',
+        compute: async (item) => {
+          seen.push(item.id as number)
+          return true
+        },
+      }
+      await decorateAllAsync(items, [probe, probe])
+      expect(seen.sort()).toEqual([1, 1, 2, 2, 3, 3])
+    })
+
+    test('rejects when any decorator throws', async () => {
+      const items: Decoratable[] = [{ id: 1 }]
+      const ok: FieldDecoratorAsync<Decoratable> = {
+        field: 'ok',
+        compute: async () => true,
+      }
+      const bad: FieldDecoratorAsync<Decoratable> = {
+        field: 'bad',
+        compute: async () => {
+          throw new Error('nope')
+        },
+      }
+      await expect(decorateAllAsync(items, [ok, bad])).rejects.toThrow('nope')
+    })
+
+    test('passes visited item to compute', async () => {
+      const item: Decoratable = { id: 7, label: 'x' }
+      const compute = jest.fn(async () => 'ok')
+      await decorateAllAsync(item, [{ field: 'mark', compute }])
+      expect(compute).toHaveBeenCalledTimes(1)
+      expect(compute).toHaveBeenCalledWith(item)
+    })
+
+    test('recurse:false decorator runs only at top level; recurse:true descends', async () => {
+      const items: Decoratable[] = [{ id: 1, children: [{ id: 2 }, { id: 3 }] }]
+      const topOnlyHits: number[] = []
+      const everyHits: number[] = []
+      const topOnly: FieldDecoratorAsync<Decoratable> = {
+        field: 'top',
+        compute: async (item) => {
+          topOnlyHits.push(item.id as number)
+          return true
+        },
+        recurse: false,
+      }
+      const every: FieldDecoratorAsync<Decoratable> = {
+        field: 'every',
+        compute: async (item) => {
+          everyHits.push(item.id as number)
+          return true
+        },
+      }
+      await decorateAllAsync(items, [topOnly, every])
+      expect(topOnlyHits).toEqual([1])
+      expect(everyHits.sort()).toEqual([1, 2, 3])
+      const child = (items[0].children as Decoratable[])[0]
+      expect(child.top).toBeUndefined()
+      expect(child.every).toBe(true)
+    })
+
+    test('all async decorators recurse:false → children untouched', async () => {
+      const items: Decoratable[] = [{ id: 1, children: [{ id: 2 }] }]
+      const seen: number[] = []
+      const dec: FieldDecoratorAsync<Decoratable> = {
+        field: 'mark',
+        compute: async (item) => {
+          seen.push(item.id as number)
+          return true
+        },
+        recurse: false,
+      }
+      await decorateAllAsync(items, [dec])
+      expect(seen).toEqual([1])
+      const child = (items[0].children as Decoratable[])[0]
+      expect(child.mark).toBeUndefined()
+    })
+  })
+})