internal/api: implement package imported-by endpoint

- Implement ServePackageImportedBy handler and GetImportedBy and GetImportedByCount datasource methods.

Change-Id: I8c4cc65fbff7172eaf48e5426e4f3f41c82bd38e
Reviewed-on: https://go-review.googlesource.com/c/pkgsite/+/754865
Reviewed-by: Jonathan Amsterdam <jba@google.com>
kokoro-CI: kokoro <noreply+kokoro@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Auto-Submit: Ethan Lee <ethanalee@google.com>

2 files changed, 121 insertions, 0 deletions

diff --git a/internal/api/api.go b/internal/api/api.go
index b2be2327..8cfe2151 100644
--- a/internal/api/api.go
+++ b/internal/api/api.go
@@ -399,6 +399,67 @@ func ServePackageSymbols(w http.ResponseWriter, r *http.Request, ds internal.Dat
 	return serveJSON(w, http.StatusOK, resp)
 }
 
+// ServePackageImportedBy handles requests for the v1 package imported-by endpoint.
+func ServePackageImportedBy(w http.ResponseWriter, r *http.Request, ds internal.DataSource) (err error) {
+	defer derrors.Wrap(&err, "ServePackageImportedBy")
+
+	pkgPath := strings.TrimPrefix(r.URL.Path, "/v1/imported-by/")
+	if pkgPath == "" {
+		return serveErrorJSON(w, http.StatusBadRequest, "missing package path", nil)
+	}
+
+	var params ImportedByParams
+	if err := ParseParams(r.URL.Query(), &params); err != nil {
+		return serveErrorJSON(w, http.StatusBadRequest, err.Error(), nil)
+	}
+
+	requestedVersion := params.Version
+	if requestedVersion == "" {
+		requestedVersion = version.Latest
+	}
+
+	um, candidates, err := resolveModulePath(r, ds, pkgPath, params.Module, requestedVersion)
+	if err != nil {
+		if errors.Is(err, derrors.NotFound) {
+			return serveErrorJSON(w, http.StatusNotFound, err.Error(), nil)
+		}
+		return err
+	}
+	if len(candidates) > 0 {
+		return serveErrorJSON(w, http.StatusBadRequest, "ambiguous package path", candidates)
+	}
+	modulePath := um.ModulePath
+
+	limit := params.Limit
+	if limit <= 0 {
+		limit = 100
+	}
+
+	importedBy, err := ds.GetImportedBy(r.Context(), pkgPath, modulePath, limit)
+	if err != nil {
+		if errors.Is(err, derrors.NotFound) {
+			return serveErrorJSON(w, http.StatusNotFound, err.Error(), nil)
+		}
+		return err
+	}
+
+	count, err := ds.GetImportedByCount(r.Context(), pkgPath, modulePath)
+	if err != nil {
+		return err
+	}
+
+	resp := PackageImportedBy{
+		ModulePath: modulePath,
+		Version:    requestedVersion,
+		ImportedBy: PaginatedResponse[string]{
+			Items: importedBy,
+			Total: count,
+		},
+	}
+
+	return serveJSON(w, http.StatusOK, resp)
+}
+
 // resolveModulePath determines the correct module path for a given package path and version.
 // If the module path is not provided, it searches through potential candidate module paths
 // derived from the package path. If multiple valid modules contain the package, it returns
diff --git a/internal/api/api_test.go b/internal/api/api_test.go
index 90373b66..a0ded1d2 100644
--- a/internal/api/api_test.go
+++ b/internal/api/api_test.go
@@ -708,6 +708,66 @@ func TestServePackageSymbols(t *testing.T) {
 	}
 }
 
+func TestServePackageImportedBy(t *testing.T) {
+	ctx := context.Background()
+	ds := fakedatasource.New()
+
+	const (
+		pkgPath    = "example.com/pkg"
+		modulePath = "example.com"
+		version    = "v1.0.0"
+	)
+
+	ds.MustInsertModule(ctx, &internal.Module{
+		ModuleInfo: internal.ModuleInfo{ModulePath: modulePath, Version: version},
+		Units: []*internal.Unit{
+			{UnitMeta: internal.UnitMeta{Path: pkgPath, ModuleInfo: internal.ModuleInfo{ModulePath: modulePath, Version: version}}},
+			{
+				UnitMeta: internal.UnitMeta{Path: "example.com/other", ModuleInfo: internal.ModuleInfo{ModulePath: modulePath, Version: version}},
+				Imports:  []string{pkgPath},
+			},
+		},
+	})
+
+	for _, test := range []struct {
+		name       string
+		url        string
+		wantStatus int
+		wantCount  int
+	}{
+		{
+			name:       "all imported by",
+			url:        "/v1/imported-by/example.com/pkg?version=v1.0.0",
+			wantStatus: http.StatusOK,
+			wantCount:  1,
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			r := httptest.NewRequest("GET", test.url, nil)
+			w := httptest.NewRecorder()
+
+			err := ServePackageImportedBy(w, r, ds)
+			if err != nil && w.Code != test.wantStatus {
+				t.Fatalf("ServePackageImportedBy returned error: %v", err)
+			}
+
+			if w.Code != test.wantStatus {
+				t.Errorf("status = %d, want %d", w.Code, test.wantStatus)
+			}
+
+			if test.wantStatus == http.StatusOK {
+				var got PackageImportedBy
+				if err := json.Unmarshal(w.Body.Bytes(), &got); err != nil {
+					t.Fatalf("json.Unmarshal: %v", err)
+				}
+				if len(got.ImportedBy.Items) != test.wantCount {
+					t.Errorf("count = %d, want %d", len(got.ImportedBy.Items), test.wantCount)
+				}
+			}
+		})
+	}
+}
+
 // unmarshalResponse unmarshals an API response into either
 // a *T or an *Error.
 func unmarshalResponse[T any](data []byte) (any, error) {