mains: pass FS nils for Files() DSL; mark Files-only services as HTTP (fixes #223) (#224)

* Fix testing plugin to generate correct package-qualified result types

This fixes issue #206 where the testing plugin was generating invalid Go
syntax for method return types. The problem occurred when the result type
was an array or slice - the template was incorrectly placing the pointer
operator before the package qualifier and array brackets.

For example, a method returning []*AccessControl would generate:
  func GetAccessControl(...) (*bff.[]*AccessControl, error)

This is syntactically invalid. The correct syntax should be:
  func GetAccessControl(...) ([]*bff.AccessControl, error)

The fix:
- Added PkgResultRef field to clientMethodData to store the properly
  package-qualified result type reference
- Use Goa's GoFullTypeRef method to generate the package-qualified type
  reference, which correctly handles arrays, maps, primitives, and user
  types
- Updated the client_methods template to use PkgResultRef instead of
  manually constructing the type reference

This leverages Goa's existing codegen infrastructure which properly
handles all type cases including:
- Pointer types: *Result -> *pkg.Result
- Array/slice types: []*Result -> []*pkg.Result
- Map types: map[K]*Result -> map[K]*pkg.Result
- Nested types: []map[K]*Result -> []map[K]*pkg.Result

Fixes #206

* mains: append http.FileSystem args for Files() DSL; detect HasHTTP for file servers (fixes #223)

Author: raphael

mains/generate.go

@@ -34,6 +34,8 @@ type srvInfo struct {
     HasHTTP    bool
     HasGRPC    bool
     ServerName string
+    // FSCounts maps service name to the number of HTTP file servers.
+    FSCounts   map[string]int
 }
 
 // svcT provides template data for each service imported by a server.
@@ -50,6 +52,9 @@ type svcT struct {
     HasWebSocket bool
     HasHTTP      bool
     HasGRPC      bool
+    // FileServerNils is used by the template to emit one trailing
+    // nil argument per HTTP file server in the service.
+    FileServerNils []int
 }
 
 // Register the plugin for the example phase.
@@ -110,15 +115,26 @@ func generateExample(genpkg string, roots []eval.Root, files []*codegen.File) ([
         }
         if len(httpSvcs) == 0 { continue }
         var svcs []*service.Data
-        for _, sd := range httpSvcs { if sd != nil && sd.Service != nil { svcs = append(svcs, sd.Service) } }
+        fsCounts := map[string]int{}
+        for _, sd := range httpSvcs {
+            if sd == nil || sd.Service == nil {
+                continue
+            }
+            svcs = append(svcs, sd.Service)
+            if sd.FileServers != nil {
+                fsCounts[sd.Service.Name] = len(sd.FileServers)
+            }
+        }
         hasWS := httpcodegen.NeedDialer(httpSvcs)
         apipkg := apiPkgAlias(genpkg, roots)
         if info, ok := srvMap[dir]; ok {
             info.HasWS = hasWS
             info.HasHTTP = true
             if info.APIPkg == "" { info.APIPkg = apipkg }
+            if info.FSCounts == nil { info.FSCounts = map[string]int{} }
+            for k, v := range fsCounts { info.FSCounts[k] = v }
         } else {
-            srvMap[dir] = &srvInfo{Dir: dir, APIPkg: apipkg, Services: svcs, HasWS: hasWS, HasHTTP: true}
+            srvMap[dir] = &srvInfo{Dir: dir, APIPkg: apipkg, Services: svcs, HasWS: hasWS, HasHTTP: true, FSCounts: fsCounts}
         }
     }
     // Detect gRPC servers from grpc.go files
@@ -228,6 +244,12 @@ func generateExample(genpkg string, roots []eval.Root, files []*codegen.File) ([
                 hasAnyWS = true
             }
 
+            // Determine file server count: prefer extracted counts from example
+            // HTTP files, fallback to design counts when missing.
+            fsn, ok := info.FSCounts[sd.Name]
+            if !ok {
+                fsn = httpFileServerCounts(roots)[sd.Name]
+            }
             svcsData = append(svcsData, svcT{
                 Name:         sd.Name,
                 StructName:   sd.StructName,
@@ -241,6 +263,7 @@ func generateExample(genpkg string, roots []eval.Root, files []*codegen.File) ([
                 HasWebSocket: hws,
                 HasHTTP:      hasHTTP,
                 HasGRPC:      hasGRPC,
+                FileServerNils: func(n int) []int { if n <= 0 { return nil }; s := make([]int, n); for i := range s { s[i] = i }; return s }(fsn),
             })
         }
 
@@ -354,7 +377,7 @@ func httpServicesByName(roots []eval.Root) map[string]bool {
             continue
         }
         for _, svc := range root.API.HTTP.Services {
-            if len(svc.HTTPEndpoints) > 0 {
+            if len(svc.HTTPEndpoints) > 0 || len(svc.FileServers) > 0 {
                 hasHTTP[svc.Name()] = true
             }
         }
@@ -378,3 +401,22 @@ func grpcServicesByName(roots []eval.Root) map[string]bool {
     }
     return hasGRPC
 }
+
+// httpFileServerCounts returns a map from service name to the number of
+// HTTP Files() endpoints defined for that service.
+func httpFileServerCounts(roots []eval.Root) map[string]int {
+    counts := map[string]int{}
+    for _, r := range roots {
+        root, ok := r.(*expr.RootExpr)
+        if !ok || root.API == nil || root.API.HTTP == nil {
+            continue
+        }
+        for _, svc := range root.API.HTTP.Services {
+            if svc == nil {
+                continue
+            }
+            counts[svc.Name()] = len(svc.FileServers)
+        }
+    }
+    return counts
+}

mains/generate_test.go

@@ -1,11 +1,12 @@
 package mains
 
 import (
+    "bytes"
+    "regexp"
     "testing"
 
     "github.com/stretchr/testify/assert"
     "github.com/stretchr/testify/require"
-    "bytes"
     "goa.design/goa/v3/codegen"
     "goa.design/goa/v3/codegen/example"
     "goa.design/goa/v3/codegen/service"
@@ -94,3 +95,36 @@ func TestWebSocketMainIncludesUpgrader(t *testing.T) {
     assert.Contains(t, code, "github.com/gorilla/websocket")
     assert.Contains(t, code, "websocket.Upgrader")
 }
+
+func TestMainsAddsFileServerNils(t *testing.T) {
+    root := codegen.RunDSL(t, testdata.FileServerServiceDSL)
+    svcs := service.NewServicesData(root)
+    httpSvcs := httpcodegen.NewServicesData(svcs, root.API.HTTP)
+    files := append(example.ServerFiles("gen", root, svcs), httpcodegen.ExampleServerFiles("gen", httpSvcs)...)
+
+    out, err := Generate("gen", []eval.Root{root}, files)
+    require.NoError(t, err)
+
+    // Expect relocated main under services/static/cmd/static/main.go
+    var mainFile *codegen.File
+    for _, f := range out {
+        if f.Path == "services/static/cmd/static/main.go" {
+            mainFile = f
+            break
+        }
+    }
+    require.NotNil(t, mainFile)
+
+    // Render the mains section and look for exactly 2 (errhandler, formatter)
+    // + 3 (file servers) nil arguments at the end of the New(...) call.
+    sections := mainFile.Section("mains-main")
+    require.Greater(t, len(sections), 0)
+    var buf bytes.Buffer
+    require.NoError(t, sections[0].Write(&buf))
+    code := buf.String()
+
+    // Match a New(...) call that ends with five consecutive `, nil` args
+    // (2 standard + 3 file servers)
+    re := regexp.MustCompile(`New\([\s\S]*,\s*nil(?:,\s*nil){4}\)`) // total 5 nils
+    assert.Regexp(t, re, code)
+}

mains/templates/main.go.tpl

@@ -119,9 +119,9 @@ func main() {
     {{- if .HasHTTP }}
     // {{ .Name }} HTTP server
     {{- if .HasWebSocket }}
-    {{ .SrvVar }} := {{ .GenHTTPPkg }}.New({{ .EpVar }}, mux, goahttp.RequestDecoder, goahttp.ResponseEncoder, nil, nil, upgrader, nil)
+    {{ .SrvVar }} := {{ .GenHTTPPkg }}.New({{ .EpVar }}, mux, goahttp.RequestDecoder, goahttp.ResponseEncoder, nil, nil, upgrader, nil{{- range .FileServerNils }}, nil{{- end }})
     {{- else }}
-    {{ .SrvVar }} := {{ .GenHTTPPkg }}.New({{ .EpVar }}, mux, goahttp.RequestDecoder, goahttp.ResponseEncoder, nil, nil)
+    {{ .SrvVar }} := {{ .GenHTTPPkg }}.New({{ .EpVar }}, mux, goahttp.RequestDecoder, goahttp.ResponseEncoder, nil, nil{{- range .FileServerNils }}, nil{{- end }})
     {{- end }}
     {{ .GenHTTPPkg }}.Mount(mux, {{ .SrvVar }})
     for _, m := range {{ .SrvVar }}.Mounts {
@@ -234,4 +234,3 @@ func main() {
     wg.Wait()
     log.Printf(ctx, "exited")
 }
-

mains/testdata/dsls.go

@@ -63,3 +63,20 @@ var WebSocketServiceDSL = func() {
         })
     })
 }
+
+// Single service with only Files() endpoints; used to validate mains adds the
+// correct number of http.FileSystem arguments to the HTTP server constructor.
+var FileServerServiceDSL = func() {
+    API("fsapi", func() {
+        Server("edge", func() {
+            Services("static")
+            Host("dev", func() { URI("http://localhost:8080") })
+        })
+    })
+    Service("static", func() {
+        HTTP(func() { Path("/") })
+        Files("/f1.json", "/assets/f1.json")
+        Files("/f2.json", "/assets/f2.json")
+        Files("/f3.json", "/assets/f3.json")
+    })
+}