@automattic/data-stores 3.1.2 → 3.2.1

package/src/reader/queries/test/use-site-subscriptions-query.tsx

@@ -1,10 +1,13 @@
 /**
  * @jest-environment jsdom
  */
+import {
+	getSiteSubscriptionsQueryKey,
+	type SiteSubscriptionsInfiniteData,
+} from '@automattic/api-queries';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { renderHook, waitFor } from '@testing-library/react';
-import React from 'react';
-import { act } from 'react-dom/test-utils';
+import React, { act } from 'react';
 import { SiteSubscriptionsSortBy } from '../../constants';
 import {
 	SiteSubscriptionsQueryPropsProvider,
@@ -12,8 +15,10 @@ import {
 } from '../../contexts';
 import { callApi, getSubkey } from '../../helpers';
 import useSiteSubscriptionsQuery from '../../queries/use-site-subscriptions-query';
+import type { SiteSubscriptionItem } from '../../types';
 
 jest.mock( '../../helpers', () => ( {
+	...jest.requireActual( '../../helpers' ),
 	callApi: jest.fn(),
 	getSubkey: jest.fn(),
 } ) );
@@ -26,60 +31,140 @@ const wrapper = ( { children } ) => (
 	</QueryClientProvider>
 );
 
+const makeFollow = ( overrides: Partial< SiteSubscriptionItem > = {} ): SiteSubscriptionItem => ( {
+	ID: '1',
+	URL: 'https://site1.example.com',
+	feed_URL: 'https://site1.example.com/feed',
+	blog_ID: '1',
+	feed_ID: '11',
+	is_following: true,
+	name: 'Site 1',
+	date_subscribed: new Date( '2024-01-01T00:00:00Z' ),
+	last_updated: new Date( '2024-01-01T00:00:00Z' ),
+	...overrides,
+} );
+
+const makeApiSubscription = ( id: number ) => ( {
+	ID: String( id ),
+	URL: `https://site${ id }.example.com/feed`,
+	blog_ID: String( id ),
+	feed_ID: String( id + 1000 ),
+	name: `Site ${ id }`,
+} );
+
+const makeSiteSubscriptionsData = (
+	pages: SiteSubscriptionItem[][],
+	totalCount = pages.reduce( ( count, page ) => count + page.length, 0 )
+): SiteSubscriptionsInfiniteData => ( {
+	pages: pages.map( ( subscriptions, index ) => ( {
+		subscriptions,
+		totalCount,
+		page: index + 1,
+		number: 200,
+	} ) ),
+	pageParams: pages.map( ( _, index ) => index + 1 ),
+} );
+
+const seedSiteSubscriptions = ( pages: SiteSubscriptionItem[][], totalCount?: number ) => {
+	queryClient.setQueryData< SiteSubscriptionsInfiniteData >(
+		getSiteSubscriptionsQueryKey(),
+		makeSiteSubscriptionsData( pages, totalCount )
+	);
+};
+
 describe( 'useSiteSubscriptionsQuery hook', () => {
 	beforeEach( () => {
 		queryClient.clear();
 		jest.resetAllMocks();
 
 		( getSubkey as jest.Mock ).mockReturnValue( () => 'test-key' );
+		( callApi as jest.Mock ).mockResolvedValue( {
+			subscriptions: [],
+			total_subscriptions: 0,
+			page: 1,
+			number: 200,
+		} );
 	} );
 
-	it( 'fetches subscriptions data with multiple pages', async () => {
-		( callApi as jest.Mock ).mockResolvedValueOnce( {
-			subscriptions: [
-				{ id: '1', name: 'Site 1', URL: 'https://site1.example.com' },
-				{ id: '2', name: 'Site 2', URL: 'https://site2.example.com' },
+	it( 'derives subscriptions data from multiple cached pages', async () => {
+		seedSiteSubscriptions( [
+			[
+				makeFollow( { ID: '1', name: 'Site 1', URL: 'https://site1.example.com' } ),
+				makeFollow( { ID: '2', name: 'Site 2', URL: 'https://site2.example.com' } ),
 			],
-			page: 1,
-			total_subscriptions: 6,
-		} );
-		( callApi as jest.Mock ).mockResolvedValueOnce( {
-			subscriptions: [
-				{ id: '3', name: 'Site 3', URL: 'https://site3.example.com' },
-				{ id: '4', name: 'Site 4', URL: 'https://site4.example.com' },
+			[
+				makeFollow( { ID: '3', name: 'Site 3', URL: 'https://site3.example.com' } ),
+				makeFollow( { ID: '4', name: 'Site 4', URL: 'https://site4.example.com' } ),
 			],
-			page: 2,
-			total_subscriptions: 6,
-		} );
-		( callApi as jest.Mock ).mockResolvedValueOnce( {
-			subscriptions: [
-				{ id: '5', name: 'Site 5', URL: 'https://site5.example.com' },
-				{ id: '6', name: 'Site 6', URL: 'https://site6.example.com' },
+			[
+				makeFollow( { ID: '5', name: 'Site 5', URL: 'https://site5.example.com' } ),
+				makeFollow( { ID: '6', name: 'Site 6', URL: 'https://site6.example.com' } ),
 			],
-			page: 3,
-			total_subscriptions: 6,
-		} );
+		] );
 
-		const { result } = renderHook( () => useSiteSubscriptionsQuery( { number: 2 } ), {
+		const { result } = renderHook( () => useSiteSubscriptionsQuery(), {
 			wrapper,
 		} );
 
 		await waitFor( () => {
-			expect( callApi ).toHaveBeenCalledTimes( 3 );
 			expect( result.current.data.subscriptions.length ).toBe( 6 );
 			expect( result.current.data.totalCount ).toBe( 6 );
 		} );
 	} );
 
+	it( 'fetches additional pages through the subkey-aware API path', async () => {
+		// The server caps each page at 100 rows, so a full page is 100 items.
+		const firstPage = Array.from( { length: 100 }, ( _value, index ) =>
+			makeApiSubscription( index + 1 )
+		);
+		const secondPage = [ makeApiSubscription( 101 ) ];
+
+		( callApi as jest.Mock ).mockImplementation( ( { path, isLoggedIn } ) => {
+			expect( isLoggedIn ).toBe( false );
+
+			if ( path.includes( 'page=1' ) ) {
+				return Promise.resolve( {
+					subscriptions: firstPage,
+					total_subscriptions: 101,
+					page: 1,
+					number: 100,
+				} );
+			}
+
+			if ( path.includes( 'page=2' ) ) {
+				return Promise.resolve( {
+					subscriptions: secondPage,
+					total_subscriptions: 101,
+					page: 2,
+					number: 1,
+				} );
+			}
+
+			throw new Error( `Unexpected path ${ path }` );
+		} );
+
+		const { result } = renderHook( () => useSiteSubscriptionsQuery(), {
+			wrapper,
+		} );
+
+		await waitFor( () => expect( callApi ).toHaveBeenCalledTimes( 2 ) );
+		await waitFor( () => expect( result.current.data.subscriptions ).toHaveLength( 101 ) );
+		expect( ( callApi as jest.Mock ).mock.calls[ 0 ][ 0 ] ).toMatchObject( {
+			apiVersion: '1.2',
+			isLoggedIn: false,
+		} );
+		expect( ( callApi as jest.Mock ).mock.calls[ 0 ][ 0 ].path ).toContain(
+			'/read/following/mine'
+		);
+	} );
+
 	it( 'fetches subscriptions data with search term', async () => {
-		( callApi as jest.Mock ).mockResolvedValue( {
-			subscriptions: [
-				{ id: '1', name: 'Site 1', URL: 'https://site1.example.com' },
-				{ id: '2', name: 'Site 2', URL: 'https://site2.example.com' },
+		seedSiteSubscriptions( [
+			[
+				makeFollow( { ID: '1', name: 'Site 1', URL: 'https://site1.example.com' } ),
+				makeFollow( { ID: '2', name: 'Site 2', URL: 'https://site2.example.com' } ),
 			],
-			page: 1,
-			total_subscriptions: 2,
-		} );
+		] );
 
 		const { result } = renderHook(
 			() => {
@@ -97,12 +182,36 @@ describe( 'useSiteSubscriptionsQuery hook', () => {
 		act( () => result.current.setSearchTerm( 'te 1' ) );
 		await waitFor( () => expect( result.current.searchTerm ).toBe( 'te 1' ) );
 
-		expect( callApi ).toHaveBeenCalledTimes( 1 );
 		expect( result.current.data.subscriptions.length ).toBe( 1 );
 		expect( result.current.data.subscriptions[ 0 ].name ).toBe( 'Site 1' );
 		expect( result.current.data.totalCount ).toBe( 2 );
 	} );
 
+	it( 'reuses fresh cached follows when remounted', async () => {
+		seedSiteSubscriptions( [
+			[ makeFollow( { ID: '1', name: 'Site 1', URL: 'https://site1.example.com' } ) ],
+		] );
+
+		const firstRender = renderHook( () => useSiteSubscriptionsQuery(), {
+			wrapper,
+		} );
+
+		await waitFor( () => expect( firstRender.result.current.isLoading ).toBe( false ) );
+		expect( firstRender.result.current.data.subscriptions ).toHaveLength( 1 );
+
+		firstRender.unmount();
+
+		const secondRender = renderHook( () => useSiteSubscriptionsQuery(), {
+			wrapper,
+		} );
+
+		await waitFor( () =>
+			expect( secondRender.result.current.data.subscriptions ).toHaveLength( 1 )
+		);
+
+		expect( secondRender.result.current.data.subscriptions ).toHaveLength( 1 );
+	} );
+
 	it.each( [
 		{
 			sortTerm: SiteSubscriptionsSortBy.SiteName,
@@ -129,33 +238,31 @@ describe( 'useSiteSubscriptionsQuery hook', () => {
 			],
 		},
 	] )( 'Applies sorting to the subscriptions returned', async ( { sortTerm, expectedResult } ) => {
-		( callApi as jest.Mock ).mockResolvedValue( {
-			subscriptions: [
-				{
+		seedSiteSubscriptions( [
+			[
+				makeFollow( {
 					ID: '1',
 					name: "Zorro's site",
 					URL: 'https://site2.example.com',
-					date_subscribed: '2022-01-18T00:00:00+00:00',
-					last_updated: '2023-04-18T19:00:00+00:00',
-				},
-				{
+					date_subscribed: new Date( '2022-01-18T00:00:00+00:00' ),
+					last_updated: new Date( '2023-04-18T19:00:00+00:00' ),
+				} ),
+				makeFollow( {
 					ID: '3',
 					name: "Maciej's site",
 					URL: 'https://site2.example.com',
-					date_subscribed: '2023-04-18T17:00:00+00:00',
-					last_updated: '2023-04-18T17:00:00+00:00',
-				},
-				{
+					date_subscribed: new Date( '2023-04-18T17:00:00+00:00' ),
+					last_updated: new Date( '2023-04-18T17:00:00+00:00' ),
+				} ),
+				makeFollow( {
 					ID: '2',
 					name: "Arnold's site",
 					URL: 'https://site1.example.com',
-					date_subscribed: '2023-04-18T12:00:00+00:00',
-					last_updated: '2023-04-18T12:00:00+00:00',
-				},
+					date_subscribed: new Date( '2023-04-18T12:00:00+00:00' ),
+					last_updated: new Date( '2023-04-18T12:00:00+00:00' ),
+				} ),
 			],
-			page: 1,
-			total_subscriptions: 3,
-		} );
+		] );
 
 		const { result } = renderHook(
 			() => {
@@ -172,7 +279,6 @@ describe( 'useSiteSubscriptionsQuery hook', () => {
 		act( () => result.current.setSortTerm( sortTerm ) );
 		await waitFor( () => expect( result.current.sortTerm ).toBe( sortTerm ) );
 
-		expect( callApi ).toHaveBeenCalledTimes( 1 );
 		result.current.data.subscriptions.forEach( ( subscription, index ) => {
 			expect( subscription.ID ).toEqual( expectedResult[ index ].ID );
 		} );

package/src/reader/queries/use-site-subscriptions-query.ts

@@ -1,38 +1,38 @@
+import {
+	adaptSiteSubscriptionsResponse,
+	type SiteSubscriptionsApiResponse,
+} from '@automattic/api-core';
+import { siteSubscriptionsQuery, getSiteSubscriptionsQueryKey } from '@automattic/api-queries';
 import { useInfiniteQuery } from '@tanstack/react-query';
+import { addQueryArgs } from '@wordpress/url';
 import { useMemo, useEffect, useCallback } from 'react';
 import { SiteSubscriptionsFilterBy, SiteSubscriptionsSortBy } from '../constants';
 import { useSiteSubscriptionsQueryProps } from '../contexts';
 import { callApi } from '../helpers';
-import { useCacheKey, useIsLoggedIn, useIsQueryEnabled } from '../hooks';
-import type { SiteSubscriptionsResponseItem } from '../types';
+import { useIsLoggedIn, useIsQueryEnabled } from '../hooks';
+import type { SiteSubscriptionItem } from '../types';
 
-export const siteSubscriptionsQueryKeyPrefix = [ 'read', 'site-subscriptions' ];
+export const siteSubscriptionsQueryKeyPrefix = [ ...getSiteSubscriptionsQueryKey() ];
 
-type SubscriptionManagerSiteSubscriptions = {
-	subscriptions: SiteSubscriptionsResponseItem[];
-	page: number;
-	total_subscriptions: number;
-};
-
-type SubscriptionManagerSiteSubscriptionsQueryProps = {
-	number?: number;
-};
+// Must match the page size the shared `siteSubscriptionsQuery` (in
+// `@automattic/api-queries`) assumes for next-page detection. That query reasons
+// about how much offset it has covered, so requesting a different page size here
+// would make pagination stop early or over-fetch. The value mirrors the server
+// cap (`PER_PAGE_MAX = 100`) on `/read/following/mine`.
+const SITE_SUBSCRIPTIONS_PAGE_SIZE = 100;
 
-const sortByDateSubscribed = (
-	a: SiteSubscriptionsResponseItem,
-	b: SiteSubscriptionsResponseItem
-) =>
+const sortByDateSubscribed = ( a: SiteSubscriptionItem, b: SiteSubscriptionItem ) =>
 	a.date_subscribed instanceof Date && b.date_subscribed instanceof Date
 		? b.date_subscribed.getTime() - a.date_subscribed.getTime()
 		: 0;
 
-const sortByLastUpdated = ( a: SiteSubscriptionsResponseItem, b: SiteSubscriptionsResponseItem ) =>
+const sortByLastUpdated = ( a: SiteSubscriptionItem, b: SiteSubscriptionItem ) =>
 	a.last_updated instanceof Date && b.last_updated instanceof Date
 		? b.last_updated.getTime() - a.last_updated.getTime()
 		: 0;
 
-const sortBySiteName = ( a: SiteSubscriptionsResponseItem, b: SiteSubscriptionsResponseItem ) =>
-	a.name.localeCompare( b.name );
+const sortBySiteName = ( a: SiteSubscriptionItem, b: SiteSubscriptionItem ) =>
+	( a.name ?? '' ).localeCompare( b.name ?? '' );
 
 const getSortFunction = ( sortTerm: SiteSubscriptionsSortBy ) => {
 	switch ( sortTerm ) {
@@ -47,42 +47,38 @@ const getSortFunction = ( sortTerm: SiteSubscriptionsSortBy ) => {
 	}
 };
 
-const useSiteSubscriptionsQuery = ( {
-	number = 100,
-}: SubscriptionManagerSiteSubscriptionsQueryProps = {} ) => {
+const useSiteSubscriptionsQuery = () => {
 	const { isLoggedIn } = useIsLoggedIn();
 	const enabled = useIsQueryEnabled();
-	const cacheKey = useCacheKey( siteSubscriptionsQueryKeyPrefix );
 	const { searchTerm, filterOption, sortTerm } = useSiteSubscriptionsQueryProps();
 
-	const { data, fetchNextPage, hasNextPage, isFetchingNextPage, isFetching, ...rest } =
-		useInfiniteQuery< SubscriptionManagerSiteSubscriptions >( {
-			queryKey: cacheKey,
-			queryFn: async ( { pageParam } ) => {
-				const data = await callApi< SubscriptionManagerSiteSubscriptions >( {
-					path: `/read/following/mine?number=${ number }&page=${ pageParam }`,
-					isLoggedIn,
-					apiVersion: '1.2',
-				} );
-
-				return {
-					...data,
-					subscriptions: data.subscriptions
-						? data.subscriptions.map( ( subscription ) => ( {
-								...subscription,
-								last_updated: new Date( subscription.last_updated ),
-								date_subscribed: new Date( subscription.date_subscribed ),
-						  } ) )
-						: [],
-				};
-			},
-			enabled,
-			initialPageParam: 1,
-			getNextPageParam: ( lastPage, pages ) => {
-				return lastPage.page * number < lastPage.total_subscriptions ? pages.length + 1 : undefined;
-			},
-			refetchOnWindowFocus: false,
-		} );
+	const query = useInfiniteQuery( {
+		...siteSubscriptionsQuery(),
+		queryFn: async ( { pageParam } ) => {
+			const response = await callApi< SiteSubscriptionsApiResponse >( {
+				path: addQueryArgs( '/read/following/mine', {
+					page: pageParam,
+					number: SITE_SUBSCRIPTIONS_PAGE_SIZE,
+					meta: '',
+				} ),
+				apiVersion: '1.2',
+				isLoggedIn,
+			} );
+
+			return adaptSiteSubscriptionsResponse( response );
+		},
+		enabled,
+	} );
+	const {
+		data,
+		error,
+		fetchNextPage,
+		hasNextPage,
+		isFetchingNextPage,
+		isFetching,
+		isLoading,
+		refetch,
+	} = query;
 
 	const nextPage = hasNextPage && ! isFetching && data ? data.pages.length + 1 : null;
 
@@ -93,7 +89,7 @@ const useSiteSubscriptionsQuery = ( {
 	}, [ nextPage, fetchNextPage ] );
 
 	const filterFunction = useCallback(
-		( item: SiteSubscriptionsResponseItem ) => {
+		( item: SiteSubscriptionItem ) => {
 			switch ( filterOption ) {
 				case SiteSubscriptionsFilterBy.Paid:
 					return item.is_paid_subscription;
@@ -114,7 +110,7 @@ const useSiteSubscriptionsQuery = ( {
 		const flattenedData = data?.pages?.map( ( page ) => page.subscriptions ).flat();
 
 		const searchTermLowerCase = searchTerm.toLowerCase();
-		const searchFilter = ( item: SiteSubscriptionsResponseItem ) => {
+		const searchFilter = ( item: SiteSubscriptionItem ) => {
 			if ( searchTerm === '' ) {
 				return true;
 			}
@@ -131,17 +127,19 @@ const useSiteSubscriptionsQuery = ( {
 				flattenedData
 					?.filter( ( item ) => item !== null && filterFunction( item ) && searchFilter( item ) )
 					.sort( sort ) ?? [],
-			totalCount: data?.pages?.[ 0 ]?.total_subscriptions ?? 0,
+			totalCount: data?.pages?.[ 0 ]?.totalCount ?? 0,
 		};
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [ data?.pages, filterOption, searchTerm, sortTerm ] );
 
 	return {
 		data: resultData,
+		error,
 		isFetchingNextPage,
 		isFetching,
 		hasNextPage,
-		...rest,
+		isLoading,
+		refetch,
 	};
 };
 

package/src/reader/types/index.ts

@@ -1,4 +1,7 @@
 import { EmailDeliveryFrequency } from '../constants';
+import type { Railcar } from '@automattic/calypso-analytics';
+
+export type { SiteSubscriptionItem } from '@automattic/api-core';
 
 export type EmailFormatType = 'html' | 'text';
 
@@ -27,13 +30,6 @@ export type EmailSettingsAPIResponse = {
 	};
 };
 
-type SiteSubscriptionMeta = {
-	links: {
-		site: string;
-		feed: string;
-	};
-};
-
 export type SiteSubscriptionDeliveryMethods = {
 	email?: {
 		send_posts: boolean;
@@ -47,46 +43,6 @@ export type SiteSubscriptionDeliveryMethods = {
 	};
 };
 
-export type PagedQueryResult< TDataType, TKey extends string > = {
-	pages: {
-		[ K in TKey ]: TDataType[];
-	}[];
-	pageParams: number;
-};
-
-export type SiteSubscriptionsResponseItem = {
-	ID: string;
-	blog_ID: string;
-	feed_ID: string;
-	URL: string;
-	date_subscribed: Date;
-	delivery_methods: SiteSubscriptionDeliveryMethods;
-	name: string;
-	organization_id: number;
-	unseen_count: number;
-	last_updated: Date;
-	site_icon: string;
-	is_owner: boolean;
-	meta: SiteSubscriptionMeta;
-	is_wpforteams_site: boolean;
-	is_paid_subscription: boolean;
-	is_gift: boolean;
-	gift_id: number;
-	is_rss: boolean;
-	isDeleted: boolean;
-	resubscribed: boolean;
-};
-
-export type SiteSubscriptionPage = {
-	subscriptions: SiteSubscriptionsResponseItem[];
-	total_subscriptions: number;
-};
-
-export type SiteSubscriptionsPages = {
-	pageParams: [];
-	pages: SiteSubscriptionPage[];
-};
-
 export type PostSubscription = {
 	id: string;
 	blog_id: string;
@@ -166,7 +122,9 @@ export type SiteSubscriptionDetails< DateT = Date > = {
 };
 
 export type SiteSubscriptionPaymentDetails = {
-	is_gift: boolean;
+	is_comp: boolean;
+	/** @deprecated Legacy field from the API — plans with is_gift are filtered out. */
+	is_gift?: boolean;
 	ID: string;
 	site_id: string;
 	status: string;
@@ -202,3 +160,31 @@ export type SiteSubscriptionDetailsErrorResponse = ErrorResponse<
 export type SiteSubscriptionDetailsResponse< DateT = Date > =
 	| SiteSubscriptionDetails< DateT >
 	| SiteSubscriptionDetailsErrorResponse;
+
+export interface FeedItem {
+	ID: string;
+	URL: string;
+	blog_ID: string;
+	description: string;
+	feed_ID: string;
+	feed_URL: string;
+	image: string;
+	is_following: boolean;
+	last_checked: string;
+	last_update: string;
+	marked_for_refresh: boolean;
+	meta: {
+		links?: {
+			self: string;
+			[ key: string ]: string;
+		};
+	};
+	name: string;
+	next_refresh_time: string | null;
+	organization_id: number;
+	railcar?: Railcar;
+	subscribe_URL: string;
+	subscribers_count: number;
+	unseen_count: number;
+	subscription_id?: number; // Only present if the user is subscribed to the feed.
+}

package/src/shared-types.ts

@@ -18,3 +18,16 @@ declare global {
 		_currentSiteId: number;
 	}
 }
+
+export type Location = {
+	pathname: string;
+	search?: string;
+	hash?: string;
+	state?: unknown;
+	key?: string;
+};
+
+export interface APIFetchOptions {
+	global: boolean;
+	path: string;
+}

package/src/site/actions.ts

@@ -33,7 +33,7 @@ import type {
 } from './types';
 import type { WpcomClientCredentials } from '../shared-types';
 import type { RequestTemplate } from '../templates';
-import type { Design, DesignOptions } from '@automattic/design-picker/src/types'; // Import from a specific file directly to avoid the circular dependencies
+import type { Design, DesignOptions } from '@automattic/design-types';
 
 export function createActions( clientCreds: WpcomClientCredentials ) {
 	const fetchSite = () => ( {

package/src/site/queries/use-site-features.ts

@@ -1,5 +1,5 @@
 import { useQuery, type UseQueryResult } from '@tanstack/react-query';
-import wpcomRequest from 'wpcom-proxy-request';
+import wpcomRequest from '../../wpcom-request';
 import useQueryKeysFactory from './lib/use-query-keys-factory';
 import type { SiteFeatures } from '../types';
 

package/src/site/queries/use-site-media-storage.ts

@@ -1,5 +1,5 @@
 import { useQuery, type UseQueryResult } from '@tanstack/react-query';
-import wpcomRequest from 'wpcom-proxy-request';
+import wpcomRequest from '../../wpcom-request';
 import useQueryKeysFactory from './lib/use-query-keys-factory';
 import type { SiteMediaStorage, RawSiteMediaStorage } from '../types';
 

package/src/site/queries/use-site-user-query.ts

@@ -1,6 +1,6 @@
 import { useQuery } from '@tanstack/react-query';
-import wpcomRequest from 'wpcom-proxy-request';
 import { Member } from '../../users/types';
+import wpcomRequest from '../../wpcom-request';
 import useQueryKeysFactory from './lib/use-query-keys-factory';
 
 export function getUseSiteUserQueryOptions(

package/src/site/queries/use-site.ts

@@ -1,5 +1,5 @@
 import { useQuery, type UseQueryResult } from '@tanstack/react-query';
-import wpcomRequest from 'wpcom-proxy-request';
+import wpcomRequest from '../../wpcom-request';
 import useQueryKeysFactory from './lib/use-query-keys-factory';
 import type { SiteDetails } from '../types';
 

package/src/site/resolvers.ts

@@ -1,5 +1,5 @@
 // wpcomRequest is a temporary rename while we're working on migrating generators to thunks
-import wpcomRequest from 'wpcom-proxy-request';
+import wpcomRequest from '../wpcom-request';
 import type {
 	CurrentTheme,
 	SiteDetails,