Fix server resolution, module responses, and HTTP caching

server/build.go

@@ -582,10 +582,9 @@ func (ctx *BuildContext) buildModule(analyzeMode bool) (meta *BuildMeta, include
 					isSelfRef := specifier == ctx.esmPath.PkgName
 					if !isSelfRef && strings.HasPrefix(ctx.esmPath.PkgName, "@") {
 						_, baseName := utils.SplitByFirstByte(ctx.esmPath.PkgName[1:], '/')
-						specPkgName := toPackageName(specifier)
-						if specPkgName == baseName {
-							_, inDeps := pkgJson.Dependencies[specPkgName]
-							_, inPeerDeps := pkgJson.PeerDependencies[specPkgName]
+						if specifier == baseName {
+							_, inDeps := pkgJson.Dependencies[baseName]
+							_, inPeerDeps := pkgJson.PeerDependencies[baseName]
 							if !inDeps && !inPeerDeps {
 								isSelfRef = true
 							}

server/build_resolver.go

@@ -765,10 +765,9 @@ func (ctx *BuildContext) resolveExternalModule(specifier string, kind esbuild.Re
 	isSelfRef := specifier == pkgJson.Name || specifier == pkgJson.PkgName
 	if !isSelfRef && strings.HasPrefix(pkgJson.Name, "@") {
 		_, baseName := utils.SplitByFirstByte(pkgJson.Name[1:], '/')
-		specPkgName := toPackageName(specifier)
-		if specPkgName == baseName {
-			_, inDeps := pkgJson.Dependencies[specPkgName]
-			_, inPeerDeps := pkgJson.PeerDependencies[specPkgName]
+		if specifier == baseName {
+			_, inDeps := pkgJson.Dependencies[baseName]
+			_, inPeerDeps := pkgJson.PeerDependencies[baseName]
 			if !inDeps && !inPeerDeps {
 				isSelfRef = true
 			}
@@ -784,10 +783,9 @@ func (ctx *BuildContext) resolveExternalModule(specifier string, kind esbuild.Re
 		if ctx.pkgJson.SideEffectsFalse {
 			sideEffects = esbuild.SideEffectsFalse
 		} else if ctx.pkgJson.SideEffects.Len() > 0 {
-			sideEffects = esbuild.SideEffectsFalse
 			entry := ctx.resolveEntry(esmPath)
-			if entry.main != "" && !(ctx.pkgJson.SideEffects.Has(entry.main) || ctx.pkgJson.SideEffects.Has(strings.TrimPrefix(entry.main, "./"))) {
-				sideEffects = esbuild.SideEffectsTrue
+			if entry.main != "" && !ctx.pkgJson.SideEffects.Has(entry.main) && !ctx.pkgJson.SideEffects.Has(strings.TrimPrefix(entry.main, "./")) {
+				sideEffects = esbuild.SideEffectsFalse
 			}
 		}
 		resolvedPath = ctx.getImportPath(esmPath, ctx.getBuildArgsPrefix(false), ctx.externalAll)
@@ -823,10 +821,9 @@ func (ctx *BuildContext) resolveExternalModule(specifier string, kind esbuild.Re
 			if ctx.pkgJson.SideEffectsFalse {
 				sideEffects = esbuild.SideEffectsFalse
 			} else if ctx.pkgJson.SideEffects.Len() > 0 {
-				sideEffects = esbuild.SideEffectsFalse
 				entry := ctx.resolveEntry(subModule)
-				if entry.main != "" && !(ctx.pkgJson.SideEffects.Has(entry.main) || ctx.pkgJson.SideEffects.Has(strings.TrimPrefix(entry.main, "./"))) {
-					sideEffects = esbuild.SideEffectsTrue
+				if entry.main != "" && !ctx.pkgJson.SideEffects.Has(entry.main) && !ctx.pkgJson.SideEffects.Has(strings.TrimPrefix(entry.main, "./")) {
+					sideEffects = esbuild.SideEffectsFalse
 				}
 			}
 			if withTypeJSON {
@@ -1311,8 +1308,8 @@ func (ctx *BuildContext) lexer(entry *BuildEntry) (ret *BuildMeta, cjsExports []
 func matchAsteriskExport(exportName string, subModuleName string) (diff string, match bool) {
 	if strings.ContainsRune(exportName, '*') {
 		prefix, suffix := utils.SplitByLastByte(exportName, '*')
-		if strings.HasPrefix("./"+subModuleName, prefix) && strings.HasSuffix(subModuleName, suffix) {
-			return strings.TrimPrefix("./"+subModuleName, prefix), true
+		if name := "./" + subModuleName; len(name) >= len(prefix)+len(suffix) && strings.HasPrefix(name, prefix) && strings.HasSuffix(name, suffix) {
+			return name[len(prefix) : len(name)-len(suffix)], true
 		}
 	}
 	return "", false

server/build_resolver_test.go

@@ -0,0 +1,190 @@
+package server
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/esm-dev/esm.sh/internal/npm"
+	"github.com/esm-dev/esm.sh/internal/storage"
+	esbuild "github.com/ije/esbuild-internal/api"
+	"github.com/ije/gox/log"
+	"github.com/ije/gox/set"
+)
+
+func TestResolveExternalModuleSideEffects(t *testing.T) {
+	for _, specifier := range []string{"example", "example/init"} {
+		for _, tt := range []struct {
+			name    string
+			listed  []string
+			pure    bool
+			missing bool
+			keep    bool
+		}{
+			{name: "listed", listed: []string{"./init.js"}, keep: true},
+			{name: "listed without dot", listed: []string{"init.js"}, keep: true},
+			{name: "unlisted", listed: []string{"./other.js"}},
+			{name: "unspecified", keep: true},
+			{name: "false", pure: true},
+			{name: "unresolved", listed: []string{"./other.js"}, missing: true, keep: true},
+		} {
+			t.Run(specifier+"/"+tt.name, func(t *testing.T) {
+				wd := t.TempDir()
+				pkgDir := filepath.Join(wd, "node_modules", "example")
+				if err := os.MkdirAll(pkgDir, 0755); err != nil {
+					t.Fatal(err)
+				}
+				if !tt.missing {
+					if err := os.WriteFile(filepath.Join(pkgDir, "init.js"), []byte("globalThis.initialized = true; export {};"), 0644); err != nil {
+						t.Fatal(err)
+					}
+				}
+				ctx := &BuildContext{
+					wd: wd, target: "es2022", esmPath: EsmPath{PkgName: "example", PkgVersion: "1.0.0"},
+					pkgJson: &npm.PackageJSON{
+						Name: "example", Version: "1.0.0", Type: "module", Main: "./init.js",
+						SideEffects: *set.NewReadOnly(tt.listed...), SideEffectsFalse: tt.pure,
+					},
+				}
+				resolved, sideEffects, err := ctx.resolveExternalModule(specifier, esbuild.ResolveJSImportStatement, false, false)
+				if err != nil {
+					t.Fatal(err)
+				}
+				result := esbuild.Build(esbuild.BuildOptions{
+					Stdin:  &esbuild.StdinOptions{Contents: fmt.Sprintf("import %q; export const value = 1;", specifier)},
+					Bundle: true, Format: esbuild.FormatESModule,
+					Plugins: []esbuild.Plugin{{Name: "external", Setup: func(build esbuild.PluginBuild) {
+						build.OnResolve(esbuild.OnResolveOptions{Filter: ".*"}, func(args esbuild.OnResolveArgs) (esbuild.OnResolveResult, error) {
+							return esbuild.OnResolveResult{Path: resolved, External: true, SideEffects: sideEffects}, nil
+						})
+					}}},
+				})
+				if len(result.Errors) != 0 {
+					t.Fatal(result.Errors)
+				}
+				output := string(result.OutputFiles[0].Contents)
+				if strings.Contains(output, resolved) != tt.keep {
+					t.Fatalf("import retained = %v, want %v:\n%s", !tt.keep, tt.keep, output)
+				}
+			})
+		}
+	}
+}
+
+func TestResolveExternalModuleScopedFork(t *testing.T) {
+	for _, dependency := range []string{"", "dependencies", "peerDependencies"} {
+		for _, subpath := range []string{"", "/tsl"} {
+			t.Run(dependency+subpath, func(t *testing.T) {
+				pkg := &npm.PackageJSON{Name: "@scope/three", Version: "1.0.0"}
+				want := "/@scope/three@1.0.0/es2022/"
+				switch dependency {
+				case "dependencies":
+					pkg.Dependencies = map[string]string{"three": "2.0.0"}
+					want = "/three@2.0.0/es2022/"
+				case "peerDependencies":
+					pkg.PeerDependencies = map[string]string{"three": "2.0.0"}
+					want = "/three@2.0.0/es2022/"
+				}
+				if subpath == "" {
+					want += "three.mjs"
+				} else {
+					want += "tsl.mjs"
+				}
+				ctx := &BuildContext{target: "es2022", esmPath: EsmPath{PkgName: pkg.Name, PkgVersion: pkg.Version}, pkgJson: pkg}
+				got, _, err := ctx.resolveExternalModule("three"+subpath, esbuild.ResolveJSImportStatement, false, false)
+				if err != nil || got != want {
+					t.Fatalf("resolved = %q, %v; want %q", got, err, want)
+				}
+			})
+		}
+	}
+}
+
+func TestBuildModuleScopedForkSubpath(t *testing.T) {
+	wd := t.TempDir()
+	pkgDir := filepath.Join(wd, "node_modules", "@scope", "three")
+	if err := os.MkdirAll(pkgDir, 0755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(pkgDir, "addon.js"), []byte(`export { value } from "three/tsl";`), 0644); err != nil {
+		t.Fatal(err)
+	}
+	fs, err := storage.NewFSStorage(filepath.Join(wd, "storage"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	logger, err := log.New("")
+	if err != nil {
+		t.Fatal(err)
+	}
+	logger.SetOutput(io.Discard)
+	ctx := &BuildContext{
+		wd: wd, target: "es2022", storage: fs, logger: logger, npmrc: &NpmRC{},
+		esmPath: EsmPath{PkgName: "@scope/three", PkgVersion: "1.0.0", SubPath: "addon"},
+		pkgJson: &npm.PackageJSON{Name: "@scope/three", Version: "1.0.0", Type: "module", Types: "./index.d.ts"},
+	}
+	meta, _, err := ctx.buildModule(false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	f, _, err := fs.Get(ctx.getSavePath())
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f.Close()
+	output, err := io.ReadAll(f)
+	if err != nil {
+		t.Fatal(err)
+	}
+	const want = "/@scope/three@1.0.0/es2022/tsl.mjs"
+	if len(meta.Imports) != 1 || meta.Imports[0] != want || !strings.Contains(string(output), want) {
+		t.Fatalf("expected subpath import, got %v:\n%s", meta.Imports, output)
+	}
+}
+
+func TestResolveEntryWildcardSuffix(t *testing.T) {
+	wd := t.TempDir()
+	pkgDir := filepath.Join(wd, "node_modules", "example", "src")
+	if err := os.MkdirAll(pkgDir, 0755); err != nil {
+		t.Fatal(err)
+	}
+	for _, filename := range []string{"one.js", "one.d.ts"} {
+		if err := os.WriteFile(filepath.Join(pkgDir, filename), []byte("export {};"), 0644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, conditions := range []any{
+		"./src/*.js",
+		npm.NewJSONObject([]string{"types", "import"}, map[string]any{"types": "./src/*.d.ts", "import": "./src/*.js"}),
+	} {
+		esm := EsmPath{PkgName: "example", PkgVersion: "1.0.0", SubPath: "features/one-feature"}
+		ctx := &BuildContext{
+			wd: wd, target: "es2022", esmPath: esm,
+			pkgJson: &npm.PackageJSON{
+				Name: "example", Version: "1.0.0", Type: "module",
+				Exports: npm.NewJSONObject([]string{"./features/*-feature"}, map[string]any{"./features/*-feature": conditions}),
+			},
+		}
+		if entry := ctx.resolveEntry(esm); entry.main != "./src/one.js" || entry.types != "./src/one.d.ts" || !entry.module {
+			t.Fatalf("unexpected entry: %+v", entry)
+		}
+	}
+	for _, tt := range []struct {
+		pattern, subpath, want string
+		match                  bool
+	}{
+		{"./features/*", "features/one", "one", true},
+		{"./features/*-feature", "features/one-feature", "one", true},
+		{"./features/*-feature", "features/nested/one-feature", "nested/one", true},
+		{"./features/*-feature", "features/one", "", false},
+		{"./features/*-feature", "other/one-feature", "", false},
+		{"./features/*features", "features", "", false},
+	} {
+		if got, ok := matchAsteriskExport(tt.pattern, tt.subpath); got != tt.want || ok != tt.match {
+			t.Errorf("match(%q, %q) = %q, %v; want %q, %v", tt.pattern, tt.subpath, got, ok, tt.want, tt.match)
+		}
+	}
+}

server/config.go

@@ -256,16 +256,12 @@ func normalizeConfig(config *Config) {
 		config.NpmScopedRegistries = regs
 	}
 	if config.NpmQueryCacheTTL == 0 {
-		v := os.Getenv("NPM_QUERY_CACHE_TTL")
-		if v != "" {
-			i, e := strconv.Atoi(v)
-			if e == nil && i >= 0 {
+		config.NpmQueryCacheTTL = 600
+		if v := os.Getenv("NPM_QUERY_CACHE_TTL"); v != "" {
+			if i, err := strconv.ParseUint(v, 10, 32); err == nil {
 				config.NpmQueryCacheTTL = uint32(i)
-			} else {
-				config.NpmQueryCacheTTL = 600
 			}
 		}
-		config.NpmQueryCacheTTL = 600
 	}
 	config.Compress = !(bytes.Equal(config.CompressRaw, []byte("false")) || os.Getenv("COMPRESS") == "false")
 	config.SourceMap = !(bytes.Equal(config.SourceMapRaw, []byte("false")) || (os.Getenv("SOURCEMAP") == "false" || os.Getenv("SOURCE_MAP") == "false"))

server/config_test.go

@@ -4,6 +4,31 @@ import (
 	"testing"
 )
 
+func TestNpmQueryCacheTTL(t *testing.T) {
+	for _, test := range []struct {
+		env      string
+		setting  uint32
+		expected uint32
+	}{
+		{"", 0, 600},
+		{"30", 0, 30},
+		{"0", 0, 0},
+		{"invalid", 0, 600},
+		{"-1", 0, 600},
+		{"4294967296", 0, 600},
+		{"30", 90, 90},
+	} {
+		t.Run(test.env, func(t *testing.T) {
+			t.Setenv("NPM_QUERY_CACHE_TTL", test.env)
+			c := &Config{NpmQueryCacheTTL: test.setting}
+			normalizeConfig(c)
+			if c.NpmQueryCacheTTL != test.expected {
+				t.Fatalf("NpmQueryCacheTTL = %d, want %d", c.NpmQueryCacheTTL, test.expected)
+			}
+		})
+	}
+}
+
 func TestExtractPackageName(t *testing.T) {
 	type want struct {
 		packageId string

server/middleware.go

@@ -3,6 +3,7 @@ package server
 import (
 	"compress/gzip"
 	"io"
+	"mime"
 	"net"
 	"net/http"
 	"runtime/debug"
@@ -95,16 +96,44 @@ func (w *loggedResponseWriter) Unwrap() http.ResponseWriter {
 // or gzip if the client accepts it.
 func withCompress(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		brQuality, gzipQuality, wildcardQuality, identityQuality := -1.0, -1.0, 0.0, 0.0
+		for _, value := range r.Header.Values("Accept-Encoding") {
+			for part := range strings.SplitSeq(value, ",") {
+				coding, params, err := mime.ParseMediaType(part)
+				if err != nil {
+					continue
+				}
+				quality := 1.0
+				if q, ok := params["q"]; ok {
+					quality, err = strconv.ParseFloat(q, 64)
+					if err != nil || quality < 0 || quality > 1 {
+						quality = 0
+					}
+				}
+				switch coding {
+				case "br":
+					brQuality = quality
+				case "gzip":
+					gzipQuality = quality
+				case "*":
+					wildcardQuality = quality
+				case "identity":
+					identityQuality = quality
+				}
+			}
+		}
+		if brQuality < 0 {
+			brQuality = wildcardQuality
+		}
+		if gzipQuality < 0 {
+			gzipQuality = wildcardQuality
+		}
 		var encoding string
-		if acceptEncoding := r.Header.Get("Accept-Encoding"); strings.Contains(acceptEncoding, "br") {
+		if brQuality > 0 && brQuality >= gzipQuality && brQuality >= identityQuality {
 			encoding = "br"
-		} else if strings.Contains(acceptEncoding, "gzip") {
+		} else if gzipQuality > 0 && gzipQuality >= identityQuality {
 			encoding = "gzip"
 		}
-		if encoding == "" {
-			next.ServeHTTP(w, r)
-			return
-		}
 		wr := &compressResponseWriter{ResponseWriter: w, encoding: encoding}
 		defer wr.Close()
 		next.ServeHTTP(wr, r)
@@ -135,12 +164,14 @@ func (w *compressResponseWriter) WriteHeader(code int) {
 		}
 		if size < 0 || size >= compressMinSize {
 			appendVaryHeader(h, "Accept-Encoding")
-			h.Set("Content-Encoding", w.encoding)
-			h.Del("Content-Length")
-			if w.encoding == "br" {
-				w.zWriter = brotli.NewWriterLevel(w.ResponseWriter, brotli.BestSpeed)
-			} else {
-				w.zWriter, _ = gzip.NewWriterLevel(w.ResponseWriter, gzip.BestSpeed)
+			if w.encoding != "" {
+				h.Set("Content-Encoding", w.encoding)
+				h.Del("Content-Length")
+				if w.encoding == "br" {
+					w.zWriter = brotli.NewWriterLevel(w.ResponseWriter, brotli.BestSpeed)
+				} else {
+					w.zWriter, _ = gzip.NewWriterLevel(w.ResponseWriter, gzip.BestSpeed)
+				}
 			}
 		}
 	}