diff --git a/internal/datasource.go b/internal/datasource.go
index 3cead77..517772f 100644
--- a/internal/datasource.go
+++ b/internal/datasource.go
@@ -21,9 +21,6 @@
 	// GetImports returns a slice of import paths imported by the package
 	// specified by path and version.
 	GetImports(ctx context.Context, pkgPath, modulePath, version string) ([]string, error)
-	// GetModuleInfo returns the LegacyModuleInfo corresponding to modulePath and
-	// version.
-	GetModuleInfo(ctx context.Context, modulePath, version string) (*LegacyModuleInfo, error)
 	// GetPathInfo returns information about a path.
 	GetPathInfo(ctx context.Context, path, inModulePath, inVersion string) (outModulePath, outVersion string, isPackage bool, err error)
 	// GetPseudoVersionsForModule returns LegacyModuleInfo for all known
@@ -60,4 +57,7 @@
 	// GetPackagesInModule returns LegacyPackages contained in the module version
 	// specified by modulePath and version.
 	LegacyGetPackagesInModule(ctx context.Context, modulePath, version string) ([]*LegacyPackage, error)
+	// LegacyGetModuleInfo returns the LegacyModuleInfo corresponding to modulePath and
+	// version.
+	LegacyGetModuleInfo(ctx context.Context, modulePath, version string) (*LegacyModuleInfo, error)
 }
diff --git a/internal/frontend/latest_version.go b/internal/frontend/latest_version.go
index 67fc90e..8288e35 100644
--- a/internal/frontend/latest_version.go
+++ b/internal/frontend/latest_version.go
@@ -35,7 +35,7 @@
 	var mi *internal.LegacyModuleInfo
 	switch pageType {
 	case "mod":
-		mi, err = s.ds.GetModuleInfo(ctx, modulePath, internal.LatestVersion)
+		mi, err = s.ds.LegacyGetModuleInfo(ctx, modulePath, internal.LatestVersion)
 		if err != nil {
 			return "", err
 		}
diff --git a/internal/frontend/module.go b/internal/frontend/module.go
index 0c5b1c9..606b0d4 100644
--- a/internal/frontend/module.go
+++ b/internal/frontend/module.go
@@ -29,7 +29,7 @@
 	//     b. We have valid versions for this module path, but `version` isn't
 	//        one of them. Serve a 404 but recommend the other versions.
 	ctx := r.Context()
-	mi, err := s.ds.GetModuleInfo(ctx, modulePath, requestedVersion)
+	mi, err := s.ds.LegacyGetModuleInfo(ctx, modulePath, requestedVersion)
 	if err == nil {
 		return s.legacyServeModulePageWithModule(ctx, w, r, mi, requestedVersion)
 	}
@@ -37,7 +37,7 @@
 		return err
 	}
 	if requestedVersion != internal.LatestVersion {
-		_, err = s.ds.GetModuleInfo(ctx, modulePath, internal.LatestVersion)
+		_, err = s.ds.LegacyGetModuleInfo(ctx, modulePath, internal.LatestVersion)
 		if err == nil {
 			return pathFoundAtLatestError(ctx, "module", modulePath, displayVersion(requestedVersion, modulePath))
 		}
diff --git a/internal/frontend/search.go b/internal/frontend/search.go
index b8966cd..6393271 100644
--- a/internal/frontend/search.go
+++ b/internal/frontend/search.go
@@ -161,7 +161,7 @@
 		log.Errorf(ctx, "error getting package for %s: %v", requestedPath, err)
 		return ""
 	}
-	mi, err := ds.GetModuleInfo(ctx, requestedPath, internal.LatestVersion)
+	mi, err := ds.LegacyGetModuleInfo(ctx, requestedPath, internal.LatestVersion)
 	if err == nil {
 		return fmt.Sprintf("/mod/%s", mi.ModulePath)
 	} else if !errors.Is(err, derrors.NotFound) {
diff --git a/internal/postgres/details.go b/internal/postgres/details.go
index 7423ccf..12345b4 100644
--- a/internal/postgres/details.go
+++ b/internal/postgres/details.go
@@ -278,10 +278,10 @@
 	return importedby, nil
 }
 
-// GetModuleInfo fetches a Version from the database with the primary key
+// LegacyGetModuleInfo fetches a Version from the database with the primary key
 // (module_path, version).
-func (db *DB) GetModuleInfo(ctx context.Context, modulePath string, version string) (_ *internal.LegacyModuleInfo, err error) {
-	defer derrors.Wrap(&err, "GetModuleInfo(ctx, %q, %q)", modulePath, version)
+func (db *DB) LegacyGetModuleInfo(ctx context.Context, modulePath string, version string) (_ *internal.LegacyModuleInfo, err error) {
+	defer derrors.Wrap(&err, "LegacyGetModuleInfo(ctx, %q, %q)", modulePath, version)
 
 	query := `
 		SELECT
diff --git a/internal/postgres/details_test.go b/internal/postgres/details_test.go
index 644ab1a..7e96b85 100644
--- a/internal/postgres/details_test.go
+++ b/internal/postgres/details_test.go
@@ -68,7 +68,7 @@
 				}
 			}
 
-			gotVI, err := testDB.GetModuleInfo(ctx, tc.path, internal.LatestVersion)
+			gotVI, err := testDB.LegacyGetModuleInfo(ctx, tc.path, internal.LatestVersion)
 			if err != nil {
 				if tc.wantErr == nil {
 					t.Fatalf("got unexpected error %v", err)
diff --git a/internal/postgres/insert_module_test.go b/internal/postgres/insert_module_test.go
index bdbbbe5..cd5612f 100644
--- a/internal/postgres/insert_module_test.go
+++ b/internal/postgres/insert_module_test.go
@@ -85,12 +85,12 @@
 }
 
 func checkModule(ctx context.Context, t *testing.T, want *internal.Module) {
-	got, err := testDB.GetModuleInfo(ctx, want.ModulePath, want.Version)
+	got, err := testDB.LegacyGetModuleInfo(ctx, want.ModulePath, want.Version)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if diff := cmp.Diff(want.LegacyModuleInfo, *got, cmp.AllowUnexported(source.Info{})); diff != "" {
-		t.Fatalf("testDB.GetModuleInfo(%q, %q) mismatch (-want +got):\n%s", want.ModulePath, want.Version, diff)
+		t.Fatalf("testDB.LegacyGetModuleInfo(%q, %q) mismatch (-want +got):\n%s", want.ModulePath, want.Version, diff)
 	}
 
 	for _, wantp := range want.LegacyPackages {
@@ -294,13 +294,13 @@
 	if err := testDB.InsertModule(ctx, v); err != nil {
 		t.Fatal(err)
 	}
-	if _, err := testDB.GetModuleInfo(ctx, v.ModulePath, v.Version); err != nil {
+	if _, err := testDB.LegacyGetModuleInfo(ctx, v.ModulePath, v.Version); err != nil {
 		t.Fatal(err)
 	}
 	if err := testDB.DeleteModule(ctx, v.ModulePath, v.Version); err != nil {
 		t.Fatal(err)
 	}
-	if _, err := testDB.GetModuleInfo(ctx, v.ModulePath, v.Version); !errors.Is(err, derrors.NotFound) {
+	if _, err := testDB.LegacyGetModuleInfo(ctx, v.ModulePath, v.Version); !errors.Is(err, derrors.NotFound) {
 		t.Errorf("got %v, want NotFound", err)
 	}
 	var x int
diff --git a/internal/proxydatasource/datasource.go b/internal/proxydatasource/datasource.go
index c946784..bcf6f83 100644
--- a/internal/proxydatasource/datasource.go
+++ b/internal/proxydatasource/datasource.go
@@ -216,10 +216,10 @@
 	return ds.listPackageVersions(ctx, pkgPath, false)
 }
 
-// GetModuleInfo returns the LegacyModuleInfo as fetched from the proxy for module
+// LegacyGetModuleInfo returns the LegacyModuleInfo as fetched from the proxy for module
 // version specified by modulePath and version.
-func (ds *DataSource) GetModuleInfo(ctx context.Context, modulePath, version string) (_ *internal.LegacyModuleInfo, err error) {
-	defer derrors.Wrap(&err, "GetModuleInfo(%q, %q)", modulePath, version)
+func (ds *DataSource) LegacyGetModuleInfo(ctx context.Context, modulePath, version string) (_ *internal.LegacyModuleInfo, err error) {
+	defer derrors.Wrap(&err, "LegacyGetModuleInfo(%q, %q)", modulePath, version)
 	m, err := ds.getModule(ctx, modulePath, version)
 	if err != nil {
 		return nil, err
diff --git a/internal/proxydatasource/datasource_test.go b/internal/proxydatasource/datasource_test.go
index 11736cc..82eae66 100644
--- a/internal/proxydatasource/datasource_test.go
+++ b/internal/proxydatasource/datasource_test.go
@@ -120,10 +120,10 @@
 	}
 }
 
-func TestDataSource_GetModuleInfo_Latest(t *testing.T) {
+func TestDataSource_LegacyGetModuleInfo_Latest(t *testing.T) {
 	ctx, ds, teardown := setup(t)
 	defer teardown()
-	got, err := ds.GetModuleInfo(ctx, "foo.com/bar", internal.LatestVersion)
+	got, err := ds.LegacyGetModuleInfo(ctx, "foo.com/bar", internal.LatestVersion)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -226,15 +226,15 @@
 	}
 }
 
-func TestDataSource_GetModuleInfo(t *testing.T) {
+func TestDataSource_LegacyGetModuleInfo(t *testing.T) {
 	ctx, ds, teardown := setup(t)
 	defer teardown()
-	got, err := ds.GetModuleInfo(ctx, "foo.com/bar", "v1.2.0")
+	got, err := ds.LegacyGetModuleInfo(ctx, "foo.com/bar", "v1.2.0")
 	if err != nil {
 		t.Fatal(err)
 	}
 	if diff := cmp.Diff(wantModuleInfo, got.ModuleInfo, cmpOpts...); diff != "" {
-		t.Errorf("GetModuleInfo diff (-want +got):\n%s", diff)
+		t.Errorf("LegacyGetModuleInfo diff (-want +got):\n%s", diff)
 	}
 }
 
diff --git a/internal/worker/fetch_test.go b/internal/worker/fetch_test.go
index 9139c23..73922f2 100644
--- a/internal/worker/fetch_test.go
+++ b/internal/worker/fetch_test.go
@@ -97,7 +97,7 @@
 	// Verify that the module status is recorded correctly, and that the version is in the DB.
 	checkStatus(http.StatusOK)
 
-	if _, err := testDB.GetModuleInfo(ctx, modulePath, version); err != nil {
+	if _, err := testDB.LegacyGetModuleInfo(ctx, modulePath, version); err != nil {
 		t.Fatal(err)
 	}
 
@@ -146,8 +146,8 @@
 	// - It shouldn't be in the modules table. That also covers licenses, packages and paths tables
 	//   via foreign key constraints with ON DELETE CASCADE.
 	// - It shouldn't be in other tables like search_documents and the various imports tables.
-	if _, err := testDB.GetModuleInfo(ctx, modulePath, version); !errors.Is(err, derrors.NotFound) {
-		t.Fatalf("GetModuleInfo: got %v, want NotFound", err)
+	if _, err := testDB.LegacyGetModuleInfo(ctx, modulePath, version); !errors.Is(err, derrors.NotFound) {
+		t.Fatalf("LegacyGetModuleInfo: got %v, want NotFound", err)
 	}
 
 	checkNotInTable := func(table, column string) {
@@ -192,7 +192,7 @@
 	if code != wantCode || !errors.Is(err, wantErr) {
 		t.Fatalf("got %d, %v; want %d, Is(err, %v)", code, err, wantCode, wantErr)
 	}
-	_, err = testDB.GetModuleInfo(ctx, modulePath, version)
+	_, err = testDB.LegacyGetModuleInfo(ctx, modulePath, version)
 	if !errors.Is(err, derrors.NotFound) {
 		t.Fatalf("got %v, want Is(NotFound)", err)
 	}
@@ -340,7 +340,7 @@
 	if code != wantCode || !errors.Is(err, wantErr) {
 		t.Fatalf("got %d, %v; want %d, Is(err, derrors.AlternativeModule)", code, err, wantCode)
 	}
-	_, err = testDB.GetModuleInfo(ctx, modulePath, version)
+	_, err = testDB.LegacyGetModuleInfo(ctx, modulePath, version)
 	if !errors.Is(err, derrors.NotFound) {
 		t.Fatalf("got %v, want Is(NotFound)", err)
 	}
@@ -1053,12 +1053,12 @@
 				t.Fatalf("FetchAndUpdateState(%q, %q, %v, %v, %v): %v", test.modulePath, test.version, proxyClient, sourceClient, testDB, err)
 			}
 
-			gotModuleInfo, err := testDB.GetModuleInfo(ctx, test.modulePath, test.version)
+			gotModuleInfo, err := testDB.LegacyGetModuleInfo(ctx, test.modulePath, test.version)
 			if err != nil {
 				t.Fatal(err)
 			}
 			if diff := cmp.Diff(test.want.LegacyModuleInfo, *gotModuleInfo, cmp.AllowUnexported(source.Info{})); diff != "" {
-				t.Fatalf("testDB.GetModuleInfo(ctx, %q, %q) mismatch (-want +got):\n%s", test.modulePath, test.version, diff)
+				t.Fatalf("testDB.LegacyGetModuleInfo(ctx, %q, %q) mismatch (-want +got):\n%s", test.modulePath, test.version, diff)
 			}
 
 			gotPkg, err := testDB.LegacyGetPackage(ctx, test.pkg, internal.UnknownModulePath, test.version)