musora-content-services 2.160.4 → 2.161.2

package/src/services/user/memberships.ts

@@ -4,22 +4,27 @@
 import './types.js'
 import { HttpClient } from '../../infrastructure/http/HttpClient'
 import { globalConfig } from '../config'
+import { MultiUserAccountResponse } from "../multi-user-accounts/multi-user-accounts";
 
 const baseUrl = `/api/user-memberships`
+// Magic stringed to MembershipController.php
+const multiUserAccountFeatureFlag = 'multi_user_account_feature_flag'
 
-/**
- * Represents a user membership object
- */
-export interface Membership {
-  id: number
-  user_id: number
-  membership_type: string
-  start_date: string
-  expiration_date: string | null
-  status: string
-  created_at: string
-  updated_at: string
-  [key: string]: any
+// Active Purchased Subscription Data
+export interface MembershipData {
+  type: string
+  name: string
+  expiration_date: string
+  is_in_trial: boolean
+  trial_duration: string
+  never_expires: boolean
+}
+
+export interface UserMembershipResponse {
+  user_membership_data: MembershipData[]
+  can_upgrade_membership: boolean // pre multiUserAccount data
+  sub_account_data: MultiUserAccountResponse // post multiUserAccount data
+  upgrade_options: UpgradeOption[] // post multiuser account data
 }
 
 /**
@@ -32,15 +37,28 @@ export interface RechargeTokens {
   storefront_access_token: string
 }
 
-/**
- * Represents the response from subscription upgrade
- */
 export interface UpgradeSubscriptionResponse {
   action: 'instant_upgrade' | 'shopify'
   message?: string
   url?: string
 }
 
+export interface UpgradeProduct {
+  id: number
+  name: string
+  sku: string
+  price: number
+  monthly_price: number
+  includes_trial: boolean
+}
+
+export interface UpgradeOption {
+  annual_savings: number
+  lowest_monthly_cost: number
+  products: UpgradeProduct[] // annual + monthly products, or solely annual product with the same configuration information
+}
+
+
 /**
  * Represents the response when user should create an account (no entitlements or user not found)
  */
@@ -93,21 +111,9 @@ export type RestorePurchasesResponse =
   | RestorePurchasesSuccessResponse
   | RestorePurchasesSetupAccountResponse
 
-/**
- * Fetches the authenticated user's memberships from the API.
- *
- * @returns {Promise<Array<Membership>>} - A promise that resolves to an array of membership objects.
- *
- * @throws {Error} - Throws an error if the request fails.
- *
- * @example
- * fetchMemberships()
- *   .then(memberships => console.log(memberships))
- *   .catch(error => console.error(error));
- */
-export async function fetchMemberships(): Promise<Membership[]> {
+export async function fetchMemberships(): Promise<UserMembershipResponse> {
   const httpClient = new HttpClient(globalConfig.baseUrl)
-  return httpClient.get<Membership[]>(`${baseUrl}/v1`)
+  return httpClient.get<UserMembershipResponse>(`${baseUrl}/v1`)
 }
 
 /**
@@ -134,6 +140,8 @@ export async function fetchRechargeTokens(): Promise<RechargeTokens> {
 /**
  * Upgrades the user's subscription or provides a prefilled add-to-cart URL.
  *
+ * @param {boolean} featureFlag - MultiUserAccount feature Flag - default false
+ *
  * @returns {Promise<UpgradeSubscriptionResponse>} A promise that resolves to an object containing either:
  *  - {string} action - The action performed (e.g., 'instant_upgrade').
  *  - {string} message - Success message if the subscription was upgraded immediately.
@@ -148,9 +156,10 @@ export async function fetchRechargeTokens(): Promise<RechargeTokens> {
  *   .then(response => console.log(response))
  *   .catch(error => console.error(error));
  */
-export async function upgradeSubscription(): Promise<UpgradeSubscriptionResponse> {
+export async function upgradeSubscription(featureFlag = false): Promise<UpgradeSubscriptionResponse> {
+  let featureFlagValue = featureFlag ? 1 : 0
   const httpClient = new HttpClient(globalConfig.baseUrl)
-  return httpClient.get<UpgradeSubscriptionResponse>(`${baseUrl}/v1/update-subscription`)
+  return httpClient.get<UpgradeSubscriptionResponse>(`${baseUrl}/v1/update-subscription?${multiUserAccountFeatureFlag}=${featureFlagValue}`)
 }
 
 /**
@@ -231,6 +240,8 @@ export async function restorePurchases(
  * Get the upgrade price from Basic to Plus membership.
  * Returns the price based on the user's subscription interval.
  *
+ * @param {boolean} featureFlag - MultiUserAccount feature Flag - default false
+ *
  * For monthly subscribers: Returns the monthly upgrade cost (difference between Plus and Base monthly prices, ~$5/month)
  * For yearly subscribers: Returns the monthly equivalent upgrade cost ($3.33/month from $40/year)
  * For lifetime subscribers: Returns the annual upgrade cost for songs add-on ($40/year)
@@ -254,9 +265,10 @@ export async function restorePurchases(
  *     console.error('Failed to fetch upgrade price:', error)
  *   })
  */
-export async function getUpgradePrice() {
+export async function getUpgradePrice(featureFlag = false) {
+  let featureFlagValue = featureFlag ? 1 : 0
   const httpClient = new HttpClient(globalConfig.baseUrl)
-  return  httpClient.get(`${baseUrl}/v1/upgrade-price`)
+  return  httpClient.get(`${baseUrl}/v1/upgrade-price?${multiUserAccountFeatureFlag}=${featureFlagValue}`)
 }
 
 /**

package/src/services/user/profile.ts

@@ -0,0 +1,66 @@
+/**
+ * @module UserProfile
+ */
+import { globalConfig } from '../config.js'
+import { GET, DELETE, HttpClient } from '../../infrastructure/http/HttpClient'
+import { calculateLongestStreaks } from '../userActivity.js'
+import { UserResource } from './account'
+
+const baseUrl = `/api/user-management-system`
+
+export interface StreakDTO {
+  type: 'day' | 'week'
+  length: number
+  start_date?: Date | null
+  end_date?: Date | null
+}
+
+export interface OtherStatsDTO {
+  longest_day_streak: StreakDTO
+  longest_week_streak: StreakDTO
+  total_practice_time: number
+  comment_likes: number
+  forum_post_likes: number
+  experience_points: number
+}
+
+interface UserStatisticsResponse {
+  comment_likes: number
+  forum_post_likes: number
+  experience_points: number
+  v1_practice_time?: number
+  [key: string]: unknown
+}
+
+export async function otherStats(
+  userId: number | null = globalConfig.sessionConfig.userId
+): Promise<OtherStatsDTO> {
+  const [stats, longestStreaks] = await Promise.all([
+    GET(`${baseUrl}/v1/users/${userId}/statistics`) as Promise<UserStatisticsResponse>,
+    calculateLongestStreaks(userId),
+  ])
+
+  return {
+    ...stats,
+    longest_day_streak: {
+      type: 'day',
+      length: longestStreaks.longestDailyStreak,
+    },
+    longest_week_streak: {
+      type: 'week',
+      length: longestStreaks.longestWeeklyStreak,
+    },
+    total_practice_time: longestStreaks.totalPracticeSeconds + (stats.v1_practice_time ?? 0),
+  } as OtherStatsDTO
+}
+
+export async function deleteProfilePicture(): Promise<void> {
+  const url = `${baseUrl}/v1/users/profile_picture`
+  await DELETE(url)
+}
+
+export async function updateProfileVisibility(isPublic: boolean): Promise<UserResource> {
+  const apiUrl = `${baseUrl}/v1/user/profile-visibility`
+  const httpClient = new HttpClient(globalConfig.baseUrl, globalConfig.sessionConfig.token)
+  return httpClient.post<UserResource>(apiUrl, { is_profile_public: isPublic })
+}

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

@@ -0,0 +1,168 @@
+import { ContentClient } from '../../../../src/infrastructure/sanity/clients/ContentClient'
+import { ConfigProvider } from '../../../../src/infrastructure/sanity/interfaces/ConfigProvider'
+import { QueryExecutor } from '../../../../src/infrastructure/sanity/interfaces/QueryExecutor'
+import { SanityConfig } from '../../../../src/infrastructure/sanity/interfaces/SanityConfig'
+import { SanityQuery } from '../../../../src/infrastructure/sanity/interfaces/SanityQuery'
+import { SanityResponse } from '../../../../src/infrastructure/sanity/interfaces/SanityResponse'
+
+describe('ContentClient', () => {
+  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: ContentClient
+  let capturedQueries: string[]
+
+  beforeEach(() => {
+    capturedQueries = []
+    mockConfigProvider = { getConfig: jest.fn().mockReturnValue(config) }
+    mockExecutor = {
+      execute: jest.fn().mockImplementation((q: SanityQuery) => {
+        capturedQueries.push(q.query)
+        return Promise.resolve({ result: [], ms: 1, query: q.query } as SanityResponse<any>)
+      }),
+    }
+    client = new ContentClient(mockConfigProvider, mockExecutor)
+  })
+
+  describe('fetchById', () => {
+    test('builds query with railcontent_id, _type and [0] suffix', async () => {
+      mockExecutor.execute.mockResolvedValueOnce({
+        result: [{ id: 42, title: 'Song' }],
+        ms: 1,
+        query: '',
+      } as any)
+      const result = await client.fetchById<{ id: number; title: string }>({
+        type: 'song',
+        id: 42,
+      })
+
+      expect(result).toEqual({ id: 42, title: 'Song' })
+      const q = mockExecutor.execute.mock.calls[0][0].query
+      expect(q).toContain('railcontent_id == 42')
+      expect(q).toContain("_type == 'song'")
+      expect(q).toContain("'id': railcontent_id")
+      expect(q.trim().endsWith('[0]')).toBe(true)
+    })
+
+    test('uses custom fields when provided', async () => {
+      mockExecutor.execute.mockResolvedValueOnce({ result: [{}], ms: 1, query: '' } as any)
+      await client.fetchById({
+        type: 'song',
+        id: 1,
+        fields: ['title', 'artist'],
+      })
+      const q = mockExecutor.execute.mock.calls[0][0].query
+      expect(q).toContain('{title,\n    artist}')
+      expect(q).not.toContain("'thumbnail'")
+    })
+
+    test('adds children fields when includeChildren is true', async () => {
+      mockExecutor.execute.mockResolvedValueOnce({ result: [{}], ms: 1, query: '' } as any)
+      await client.fetchById({
+        type: 'course',
+        id: 1,
+        includeChildren: true,
+      })
+      const q = mockExecutor.execute.mock.calls[0][0].query
+      expect(q).toContain('child_count')
+      expect(q).toContain('"lessons": child[]->{')
+    })
+
+    test('returns null when nothing matches', async () => {
+      mockExecutor.execute.mockResolvedValueOnce({ result: [], ms: 1, query: '' } as any)
+      const result = await client.fetchById({ type: 'song', id: 999 })
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('fetchByIds', () => {
+    test('returns empty array immediately when no ids supplied', async () => {
+      const result = await client.fetchByIds([])
+      expect(result).toEqual([])
+      expect(mockExecutor.execute).not.toHaveBeenCalled()
+    })
+
+    test('builds query with id list and optional type/brand filters', async () => {
+      mockExecutor.execute.mockResolvedValueOnce({ result: [], ms: 1, query: '' } as any)
+      await client.fetchByIds([1, 2, 3], 'song', 'drumeo')
+      const q = mockExecutor.execute.mock.calls[0][0].query
+      expect(q).toContain('railcontent_id in [1,2,3]')
+      expect(q).toContain("_type == 'song'")
+      expect(q).toContain('brand == "drumeo"')
+    })
+
+    test('omits type and brand filters when not provided', async () => {
+      mockExecutor.execute.mockResolvedValueOnce({ result: [], ms: 1, query: '' } as any)
+      await client.fetchByIds([10, 20])
+      const q = mockExecutor.execute.mock.calls[0][0].query
+      expect(q).toContain('railcontent_id in [10,20]')
+      expect(q).not.toContain('_type ==')
+      expect(q).not.toContain('brand ==')
+    })
+
+    test('sorts results to match input id order', async () => {
+      mockExecutor.execute.mockResolvedValueOnce({
+        result: [{ id: 3 }, { id: 1 }, { id: 2 }],
+        ms: 1,
+        query: '',
+      } as any)
+      const result = await client.fetchByIds<{ id: number }>([1, 2, 3])
+      expect(result.map((r) => r.id)).toEqual([1, 2, 3])
+    })
+
+    test('sorts by railcontent_id when id field is absent', async () => {
+      mockExecutor.execute.mockResolvedValueOnce({
+        result: [{ railcontent_id: 2 }, { railcontent_id: 1 }],
+        ms: 1,
+        query: '',
+      } as any)
+      const result = await client.fetchByIds<{ railcontent_id: number }>([1, 2])
+      expect(result.map((r) => r.railcontent_id)).toEqual([1, 2])
+    })
+  })
+
+  describe('fetchByBrandAndType', () => {
+    test('applies default limit, offset, sort', async () => {
+      mockExecutor.execute.mockResolvedValueOnce({ result: [], ms: 1, query: '' } as any)
+      await client.fetchByBrandAndType('drumeo', 'song')
+      const q = mockExecutor.execute.mock.calls[0][0].query
+      expect(q).toContain('brand == "drumeo"')
+      expect(q).toContain('_type == "song"')
+      expect(q).toContain('order(published_on desc)')
+      expect(q).toContain('[0...10]')
+    })
+
+    test('honours custom limit, offset, sort, fields', async () => {
+      mockExecutor.execute.mockResolvedValueOnce({ result: [], ms: 1, query: '' } as any)
+      await client.fetchByBrandAndType('pianote', 'course', {
+        limit: 5,
+        offset: 20,
+        sortBy: 'title asc',
+        fields: ['title'],
+      })
+      const q = mockExecutor.execute.mock.calls[0][0].query
+      expect(q).toContain('order(title asc)')
+      expect(q).toContain('[20...25]')
+      expect(q).toContain('{title}')
+    })
+
+    test('returns list from executor', async () => {
+      const items = [{ id: 1 }, { id: 2 }]
+      mockExecutor.execute.mockResolvedValueOnce({ result: items, ms: 1, query: '' } as any)
+      const result = await client.fetchByBrandAndType<{ id: number }>('drumeo', 'song')
+      expect(result).toEqual(items)
+    })
+
+    test('rethrows wrapped SanityError on executor failure', async () => {
+      mockExecutor.execute.mockRejectedValueOnce(new Error('boom'))
+      await expect(client.fetchByBrandAndType('drumeo', 'song')).rejects.toMatchObject({
+        message: 'boom',
+      })
+    })
+  })
+})

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

@@ -0,0 +1,93 @@
+import { DefaultConfigProvider } from '../../../../src/infrastructure/sanity/providers/DefaultConfigProvider'
+import { globalConfig } from '../../../../src/services/config.js'
+
+jest.mock('../../../../src/services/config.js', () => ({
+  globalConfig: {
+    sanityConfig: null,
+  },
+}))
+
+describe('DefaultConfigProvider', () => {
+  let provider: DefaultConfigProvider
+
+  beforeEach(() => {
+    provider = new DefaultConfigProvider()
+    ;(globalConfig as any).sanityConfig = null
+  })
+
+  test('throws when sanityConfig is missing from globalConfig', () => {
+    ;(globalConfig as any).sanityConfig = null
+    expect(() => provider.getConfig()).toThrow('Sanity configuration is not available in globalConfig')
+  })
+
+  test('throws when token is missing', () => {
+    ;(globalConfig as any).sanityConfig = {
+      projectId: 'p',
+      dataset: 'd',
+      version: 'v',
+    }
+    expect(() => provider.getConfig()).toThrow('Sanity token is missing in configuration')
+  })
+
+  test('throws when projectId is missing', () => {
+    ;(globalConfig as any).sanityConfig = {
+      token: 't',
+      dataset: 'd',
+      version: 'v',
+    }
+    expect(() => provider.getConfig()).toThrow('Sanity projectId is missing in configuration')
+  })
+
+  test('throws when dataset is missing', () => {
+    ;(globalConfig as any).sanityConfig = {
+      token: 't',
+      projectId: 'p',
+      version: 'v',
+    }
+    expect(() => provider.getConfig()).toThrow('Sanity dataset is missing in configuration')
+  })
+
+  test('throws when version is missing', () => {
+    ;(globalConfig as any).sanityConfig = {
+      token: 't',
+      projectId: 'p',
+      dataset: 'd',
+    }
+    expect(() => provider.getConfig()).toThrow('Sanity version is missing in configuration')
+  })
+
+  test('returns config with defaults when optional fields are absent', () => {
+    ;(globalConfig as any).sanityConfig = {
+      token: 't',
+      projectId: 'p',
+      dataset: 'd',
+      version: '2021-06-07',
+    }
+    const config = provider.getConfig()
+    expect(config).toEqual({
+      projectId: 'p',
+      dataset: 'd',
+      version: '2021-06-07',
+      token: 't',
+      perspective: 'published',
+      useCachedAPI: false,
+      debug: false,
+    })
+  })
+
+  test('passes through optional perspective, useCachedAPI, debug', () => {
+    ;(globalConfig as any).sanityConfig = {
+      token: 't',
+      projectId: 'p',
+      dataset: 'd',
+      version: '2021-06-07',
+      perspective: 'previewDrafts',
+      useCachedAPI: true,
+      debug: true,
+    }
+    const config = provider.getConfig()
+    expect(config.perspective).toBe('previewDrafts')
+    expect(config.useCachedAPI).toBe(true)
+    expect(config.debug).toBe(true)
+  })
+})

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

@@ -0,0 +1,174 @@
+import { FetchQueryExecutor } from '../../../../src/infrastructure/sanity/executors/FetchQueryExecutor'
+import { SanityConfig } from '../../../../src/infrastructure/sanity/interfaces/SanityConfig'
+
+describe('FetchQueryExecutor', () => {
+  const baseConfig: SanityConfig = {
+    projectId: 'proj',
+    dataset: 'prod',
+    version: '2021-06-07',
+    token: 'tok',
+  }
+
+  let fetchMock: jest.Mock
+  const originalFetch = global.fetch
+
+  beforeEach(() => {
+    fetchMock = jest.fn()
+    global.fetch = fetchMock as any
+  })
+
+  afterEach(() => {
+    global.fetch = originalFetch
+  })
+
+  function makeResponse(body: any, ok = true, status = 200, statusText = 'OK'): Response {
+    return {
+      ok,
+      status,
+      statusText,
+      json: async () => body,
+    } as any
+  }
+
+  test('posts to non-cached endpoint with default published perspective', async () => {
+    fetchMock.mockResolvedValue(makeResponse({ result: [], ms: 1, query: 'q' }))
+    const executor = new FetchQueryExecutor()
+    await executor.execute({ query: 'q', params: { a: 1 } }, baseConfig)
+
+    expect(fetchMock).toHaveBeenCalledTimes(1)
+    const [url, options] = fetchMock.mock.calls[0]
+    expect(url).toBe(
+      'https://proj.api.sanity.io/v2021-06-07/data/query/prod?perspective=published'
+    )
+    expect(options.method).toBe('POST')
+    expect(options.headers['Authorization']).toBe('Bearer tok')
+    expect(options.headers['Content-Type']).toBe('application/json')
+    expect(options.body).toBe(JSON.stringify({ query: 'q', params: { a: 1 } }))
+  })
+
+  test('uses apicdn endpoint when useCachedAPI is true', async () => {
+    fetchMock.mockResolvedValue(makeResponse({ result: [] }))
+    const executor = new FetchQueryExecutor()
+    await executor.execute({ query: 'q' }, { ...baseConfig, useCachedAPI: true })
+
+    expect(fetchMock.mock.calls[0][0]).toBe(
+      'https://proj.apicdn.sanity.io/v2021-06-07/data/query/prod?perspective=published&query=q'
+    )
+  })
+
+  test('uses GET with encoded query when no params and URL under length limit', async () => {
+    fetchMock.mockResolvedValue(makeResponse({ result: [] }))
+    const executor = new FetchQueryExecutor()
+    await executor.execute({ query: '*[_type == "foo"]' }, baseConfig)
+
+    const [url, options] = fetchMock.mock.calls[0]
+    expect(url).toBe(
+      'https://proj.api.sanity.io/v2021-06-07/data/query/prod?perspective=published&query=' +
+        encodeURIComponent('*[_type == "foo"]')
+    )
+    expect(options.method).toBe('GET')
+    expect(options.headers['Authorization']).toBe('Bearer tok')
+    expect(options.body).toBeUndefined()
+  })
+
+  test('falls back to POST when params are provided', async () => {
+    fetchMock.mockResolvedValue(makeResponse({ result: [] }))
+    const executor = new FetchQueryExecutor()
+    await executor.execute({ query: 'q', params: { id: 1 } }, baseConfig)
+
+    const [url, options] = fetchMock.mock.calls[0]
+    expect(url).toBe(
+      'https://proj.api.sanity.io/v2021-06-07/data/query/prod?perspective=published'
+    )
+    expect(options.method).toBe('POST')
+    expect(options.body).toBe(JSON.stringify({ query: 'q', params: { id: 1 } }))
+  })
+
+  test('falls back to POST when GET URL would exceed length limit', async () => {
+    fetchMock.mockResolvedValue(makeResponse({ result: [] }))
+    const executor = new FetchQueryExecutor()
+    const longQuery = 'a'.repeat(8001)
+    await executor.execute({ query: longQuery }, baseConfig)
+
+    const [url, options] = fetchMock.mock.calls[0]
+    expect(url).toBe(
+      'https://proj.api.sanity.io/v2021-06-07/data/query/prod?perspective=published'
+    )
+    expect(options.method).toBe('POST')
+    expect(options.body).toBe(JSON.stringify({ query: longQuery }))
+  })
+
+  test('honours custom perspective', async () => {
+    fetchMock.mockResolvedValue(makeResponse({ result: [] }))
+    const executor = new FetchQueryExecutor()
+    await executor.execute({ query: 'q' }, { ...baseConfig, perspective: 'previewDrafts' })
+
+    expect(fetchMock.mock.calls[0][0]).toContain('perspective=previewDrafts')
+  })
+
+  test('returns parsed response body on success', async () => {
+    const body = { result: [{ id: 1 }], ms: 4, query: 'q' }
+    fetchMock.mockResolvedValue(makeResponse(body))
+    const executor = new FetchQueryExecutor()
+    const out = await executor.execute({ query: 'q' }, baseConfig)
+    expect(out).toEqual(body)
+  })
+
+  test('throws SanityError using response body message when fetch is not ok', async () => {
+    fetchMock.mockResolvedValue(
+      makeResponse({ message: 'GROQ parse error' }, false, 400, 'Bad Request')
+    )
+    const executor = new FetchQueryExecutor()
+    await expect(executor.execute({ query: 'q', params: { a: 1 } }, baseConfig)).rejects.toMatchObject({
+      message: 'GROQ parse error',
+      query: 'q',
+      params: { a: 1 },
+    })
+  })
+
+  test('falls back to status/statusText when error body cannot be parsed', async () => {
+    const response = {
+      ok: false,
+      status: 500,
+      statusText: 'Server Error',
+      json: async () => {
+        throw new Error('not json')
+      },
+    } as any
+    fetchMock.mockResolvedValue(response)
+    const executor = new FetchQueryExecutor()
+    await expect(executor.execute({ query: 'q' }, baseConfig)).rejects.toMatchObject({
+      message: 'Sanity API error: 500 - Server Error',
+      query: 'q',
+    })
+  })
+
+  test('wraps thrown network errors as SanityError', async () => {
+    const networkErr = new Error('connection refused')
+    fetchMock.mockRejectedValue(networkErr)
+    const executor = new FetchQueryExecutor()
+    await expect(executor.execute({ query: 'q' }, baseConfig)).rejects.toMatchObject({
+      message: 'connection refused',
+      query: 'q',
+      originalError: networkErr,
+    })
+  })
+
+  test('does not re-wrap an existing SanityError', async () => {
+    const sanityErr = { message: 'already wrapped', query: 'q' }
+    fetchMock.mockRejectedValue(sanityErr)
+    const executor = new FetchQueryExecutor()
+    await expect(executor.execute({ query: 'q' }, baseConfig)).rejects.toEqual(sanityErr)
+  })
+
+  test('debug mode logs query and result', async () => {
+    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
+    const body = { result: [], ms: 1, query: 'q' }
+    fetchMock.mockResolvedValue(makeResponse(body))
+    const executor = new FetchQueryExecutor()
+    await executor.execute({ query: 'dbg' }, { ...baseConfig, debug: true })
+    expect(logSpy).toHaveBeenCalledWith('Sanity Query:', 'dbg')
+    expect(logSpy).toHaveBeenCalledWith('Sanity Results:', body)
+    logSpy.mockRestore()
+  })
+})