internal/postgres: add GetModuleInfo function

GetModuleInfo returns the ModuleInfo for given module_path and version.
This will replace LegacyGetModuleInfo.

Fixes golang/go#40032

Change-Id: I9f24de94b93f9f21a29e4f8ca624efc0909d46d5
GitHub-Last-Rev: 5ea5b16
GitHub-Pull-Request: #2
Reviewed-on: https://go-review.googlesource.com/c/pkgsite/+/241038
Reviewed-by: Julie Qiu <[email protected]>

Author: namaggarwal

internal/datasource.go

@@ -21,6 +21,9 @@ type DataSource interface {
 	// 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 ModuleInfo corresponding to modulePath and
+	// version.
+	GetModuleInfo(ctx context.Context, modulePath, version string) (*ModuleInfo, 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

internal/postgres/details.go

@@ -277,7 +277,45 @@ func (db *DB) GetImportedBy(ctx context.Context, pkgPath, modulePath string, lim
 	return importedby, nil
 }
 
-// LegacyGetModuleInfo fetches a Version from the database with the primary key
+// GetModuleInfo fetches a module version from the database with the primary key
+// (module_path, version).
+func (db *DB) GetModuleInfo(ctx context.Context, modulePath string, version string) (_ *internal.ModuleInfo, err error) {
+	defer derrors.Wrap(&err, "GetModuleInfo(ctx, %q, %q)", modulePath, version)
+
+	query := `
+		SELECT
+			module_path,
+			version,
+			commit_time,
+			version_type,
+			source_info,
+			redistributable,
+			has_go_mod
+		FROM
+			modules
+		WHERE
+			module_path = $1
+			AND version = $2;`
+
+	args := []interface{}{modulePath, version}
+
+	var (
+		mi       internal.ModuleInfo
+		hasGoMod sql.NullBool
+	)
+	row := db.db.QueryRow(ctx, query, args...)
+	if err := row.Scan(&mi.ModulePath, &mi.Version, &mi.CommitTime, &mi.VersionType,
+		jsonbScanner{&mi.SourceInfo}, &mi.IsRedistributable, &hasGoMod); err != nil {
+		if err == sql.ErrNoRows {
+			return nil, fmt.Errorf("module version %s@%s: %w", modulePath, version, derrors.NotFound)
+		}
+		return nil, fmt.Errorf("row.Scan(): %v", err)
+	}
+	setHasGoMod(&mi, hasGoMod)
+	return &mi, nil
+}
+
+// LegacyGetModuleInfo fetches a module version from the database with the primary key
 // (module_path, 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)

internal/postgres/details_test.go

@@ -21,6 +21,77 @@ import (
 	"golang.org/x/pkgsite/internal/testing/sample"
 )
 
+func TestPostgres_GetModuleInfo(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), testTimeout)
+	defer cancel()
+
+	defer ResetTestDB(testDB, t)
+
+	testCases := []struct {
+		name, path, version string
+		modules             []*internal.Module
+		wantIndex           int // index into versions
+		wantErr             error
+	}{
+		{
+			name:    "version present",
+			path:    "mod.1",
+			version: "v1.0.2",
+			modules: []*internal.Module{
+				sample.Module("mod.1", "v1.1.0", sample.Suffix),
+				sample.Module("mod.1", "v1.0.2", sample.Suffix),
+				sample.Module("mod.1", "v1.0.0", sample.Suffix),
+			},
+			wantIndex: 1,
+		},
+		{
+			name:    "version not present",
+			path:    "mod.2",
+			version: "v1.0.3",
+			modules: []*internal.Module{
+				sample.Module("mod.2", "v1.1.0", sample.Suffix),
+				sample.Module("mod.2", "v1.0.2", sample.Suffix),
+				sample.Module("mod.2", "v1.0.0", sample.Suffix),
+			},
+			wantErr: derrors.NotFound,
+		},
+		{
+			name:    "no versions",
+			path:    "mod3",
+			version: "v1.2.3",
+			wantErr: derrors.NotFound,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			for _, v := range tc.modules {
+				if err := testDB.InsertModule(ctx, v); err != nil {
+					t.Error(err)
+				}
+			}
+
+			gotVI, err := testDB.GetModuleInfo(ctx, tc.path, tc.version)
+			if err != nil {
+				if tc.wantErr == nil {
+					t.Fatalf("got unexpected error %v", err)
+				}
+				if !errors.Is(err, tc.wantErr) {
+					t.Fatalf("got error %v, want Is(%v)", err, tc.wantErr)
+				}
+				return
+			}
+			if tc.wantIndex >= len(tc.modules) {
+				t.Fatal("wantIndex too large")
+			}
+			wantVI := &tc.modules[tc.wantIndex].ModuleInfo
+			if diff := cmp.Diff(wantVI, gotVI, cmpopts.EquateEmpty(), cmp.AllowUnexported(source.Info{})); diff != "" {
+				t.Errorf("mismatch (-want +got):\n%s", diff)
+			}
+		})
+	}
+}
+
 func TestPostgres_GetVersionInfo_Latest(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), testTimeout)
 	defer cancel()

internal/proxydatasource/datasource.go

@@ -219,6 +219,17 @@ func (ds *DataSource) GetTaggedVersionsForPackageSeries(ctx context.Context, pkg
 	return ds.listPackageVersions(ctx, pkgPath, false)
 }
 
+// GetModuleInfo returns the ModuleInfo as fetched from the proxy for module
+// version specified by modulePath and version.
+func (ds *DataSource) GetModuleInfo(ctx context.Context, modulePath, version string) (_ *internal.ModuleInfo, err error) {
+	defer derrors.Wrap(&err, "GetModuleInfo(%q, %q)", modulePath, version)
+	m, err := ds.getModule(ctx, modulePath, version)
+	if err != nil {
+		return nil, err
+	}
+	return &m.ModuleInfo, nil
+}
+
 // LegacyGetModuleInfo returns the LegacyModuleInfo as fetched from the proxy for module
 // version specified by modulePath and version.
 func (ds *DataSource) LegacyGetModuleInfo(ctx context.Context, modulePath, version string) (_ *internal.LegacyModuleInfo, err error) {

internal/proxydatasource/datasource_test.go

@@ -132,6 +132,18 @@ func TestDataSource_LegacyGetModuleInfo_Latest(t *testing.T) {
 	}
 }
 
+func TestDataSource_GetModuleInfo(t *testing.T) {
+	ctx, ds, teardown := setup(t)
+	defer teardown()
+	got, err := ds.GetModuleInfo(ctx, "foo.com/bar", "v1.2.0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if diff := cmp.Diff(&wantModuleInfo, got, cmpOpts...); diff != "" {
+		t.Errorf("GetModuleInfo diff (-want +got):\n%s", diff)
+	}
+}
+
 func TestDataSource_LegacyGetModuleLicenses(t *testing.T) {
 	ctx, ds, teardown := setup(t)
 	defer teardown()