Add package.json parsing

This will be necessary to determine what assets are browser assets in
order to reduce the amount we need to upload to Artifactory since
uploads are so slow.

Author: code-asher

storage/storage.go

@@ -2,6 +2,7 @@ package storage
 
 import (
 	"context"
+	"encoding/json"
 	"encoding/xml"
 	"fmt"
 	"io"
@@ -79,7 +80,8 @@ type VSIXAssets struct {
 type AssetType string
 
 const (
-	VSIXAssetType AssetType = "Microsoft.VisualStudio.Services.VSIXPackage"
+	ManifestAssetType AssetType = "Microsoft.VisualStudio.Code.Manifest" // This is the package.json.
+	VSIXAssetType     AssetType = "Microsoft.VisualStudio.Services.VSIXPackage"
 )
 
 // VSIXAsset implements XMLManifest.PackageManifest.Assets.Asset.
@@ -117,8 +119,8 @@ type Storage interface {
 	WalkExtensions(ctx context.Context, fn func(manifest *VSIXManifest, versions []string) error) error
 }
 
-// Read and parse an extension manifest from a vsix file.  If the manifest is
-// invalid it will be returned along with the validation error.
+// ReadVSIXManifest reads and parses an extension manifest from a vsix file.  If
+// the manifest is invalid it will be returned along with the validation error.
 func ReadVSIXManifest(vsix []byte) (*VSIXManifest, error) {
 	vmr, err := GetZipFileReader(vsix, "extension.vsixmanifest")
 	if err != nil {
@@ -128,18 +130,16 @@ func ReadVSIXManifest(vsix []byte) (*VSIXManifest, error) {
 	return parseVSIXManifest(vmr)
 }
 
-// Parse an extension manifest from a reader.  If the manifest is invalid it
-// will be returned along with the validation error.
+// parseVSIXManifest parses an extension manifest from a reader.  If the
+// manifest is invalid it will be returned along with the validation error.
 func parseVSIXManifest(reader io.Reader) (*VSIXManifest, error) {
 	var vm *VSIXManifest
-
 	decoder := xml.NewDecoder(reader)
 	decoder.Strict = false
 	err := decoder.Decode(&vm)
 	if err != nil {
 		return nil, err
 	}
-
 	return vm, validateManifest(vm)
 }
 
@@ -157,6 +157,28 @@ func validateManifest(manifest *VSIXManifest) error {
 	return nil
 }
 
+// VSIXPackageJSON partially implements Manifest.
+// https://github.com/microsoft/vscode-vsce/blob/main/src/manifest.ts#L40-L99
+type VSIXPackageJSON struct {
+	Browser string `json:"browser"`
+}
+
+// ReadVSIXPackageJSON reads and parses an extension's package.json from a vsix
+// file.
+func ReadVSIXPackageJSON(vsix []byte, packageJsonPath string) (*VSIXPackageJSON, error) {
+	vpjr, err := GetZipFileReader(vsix, packageJsonPath)
+	if err != nil {
+		return nil, err
+	}
+	defer vpjr.Close()
+	var pj *VSIXPackageJSON
+	err = json.NewDecoder(vpjr).Decode(&pj)
+	if err != nil {
+		return nil, err
+	}
+	return pj, nil
+}
+
 // ReadVSIX reads the bytes of a VSIX from the specified source.  The source
 // might be a URI or a local file path.
 func ReadVSIX(ctx context.Context, source string) ([]byte, error) {

storage/storage_test.go

@@ -357,22 +357,22 @@ func TestReadVSIXManifest(t *testing.T) {
 		{
 			name:  "MissingManifest",
 			error: "not found",
-			vsix:  testutil.CreateVSIX(t, nil),
+			vsix:  testutil.CreateVSIX(t, nil, nil),
 		},
 		{
 			name:  "EmptyManifest",
 			error: "EOF",
-			vsix:  testutil.CreateVSIX(t, []byte("")),
+			vsix:  testutil.CreateVSIX(t, []byte(""), nil),
 		},
 		{
 			name:  "TextFileManifest",
 			error: "EOF",
-			vsix:  testutil.CreateVSIX(t, []byte("just some random text")),
+			vsix:  testutil.CreateVSIX(t, []byte("just some random text"), nil),
 		},
 		{
 			name:  "ManifestSyntaxError",
 			error: "XML syntax error",
-			vsix:  testutil.CreateVSIX(t, []byte("<PackageManifest/PackageManifest>")),
+			vsix:  testutil.CreateVSIX(t, []byte("<PackageManifest/PackageManifest>"), nil),
 		},
 		{
 			name:  "ManifestMissingPublisher",
@@ -424,6 +424,74 @@ func TestReadVSIXManifest(t *testing.T) {
 	}
 }
 
+func TestReadVSIXPackageJson(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		// error is the expected error, if any.
+		error string
+		// json is the package.json from which to create the VSIX.  Use `vsix` to
+		// specify raw bytes instead.
+		json *storage.VSIXPackageJSON
+		// name is the name of the test.
+		name string
+		// vsix contains the raw bytes for the VSIX from which to read the manifest.
+		// If omitted it will be created from `manifest`.  For non-error cases
+		// always use `manifest` instead so the result can be checked.
+		vsix []byte
+	}{
+		{
+			name: "OK",
+			json: &storage.VSIXPackageJSON{},
+		},
+		{
+			name: "WithBrowser",
+			json: &storage.VSIXPackageJSON{
+				Browser: "foo",
+			},
+		},
+		{
+			name:  "MissingPackageJson",
+			error: "not found",
+			vsix:  testutil.CreateVSIX(t, nil, nil),
+		},
+		{
+			name:  "EmptyPackageJson",
+			error: "EOF",
+			vsix:  testutil.CreateVSIX(t, nil, []byte("")),
+		},
+		{
+			name:  "TextFilePackageJson",
+			error: "invalid character",
+			vsix:  testutil.CreateVSIX(t, nil, []byte("just some random text")),
+		},
+		{
+			name:  "PackageJsonSyntaxError",
+			error: "invalid character",
+			vsix:  testutil.CreateVSIX(t, nil, []byte("{\"foo\": bar}")),
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			vsix := test.vsix
+			if vsix == nil {
+				vsix = testutil.CreateVSIXFromPackageJSON(t, test.json)
+			}
+			json, err := storage.ReadVSIXPackageJSON(vsix, "extension/package.json")
+			if test.error != "" {
+				require.Error(t, err)
+				require.Regexp(t, test.error, err.Error())
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.json, json)
+			}
+		})
+	}
+}
+
 func TestAddExtension(t *testing.T) {
 	t.Parallel()
 

testutil/extensions.go

@@ -3,6 +3,7 @@ package testutil
 import (
 	"archive/zip"
 	"bytes"
+	"encoding/json"
 	"encoding/xml"
 	"fmt"
 	"os"
@@ -153,12 +154,15 @@ type file struct {
 }
 
 // createVSIX returns the bytes for a VSIX file containing the provided raw
-// manifest bytes (if not nil) and an icon.
-func CreateVSIX(t *testing.T, manifestBytes []byte) []byte {
+// manifest and package.json bytes (if not nil) and an icon.
+func CreateVSIX(t *testing.T, manifestBytes []byte, packageJSONBytes []byte) []byte {
 	files := []file{{"icon.png", []byte("fake icon")}}
 	if manifestBytes != nil {
 		files = append(files, file{"extension.vsixmanifest", manifestBytes})
 	}
+	if packageJSONBytes != nil {
+		files = append(files, file{"extension/package.json", packageJSONBytes})
+	}
 	buf := bytes.NewBuffer(nil)
 	zw := zip.NewWriter(buf)
 	for _, file := range files {
@@ -177,7 +181,13 @@ func CreateVSIX(t *testing.T, manifestBytes []byte) []byte {
 func CreateVSIXFromManifest(t *testing.T, manifest *storage.VSIXManifest) []byte {
 	manifestBytes, err := xml.Marshal(manifest)
 	require.NoError(t, err)
-	return CreateVSIX(t, manifestBytes)
+	return CreateVSIX(t, manifestBytes, nil)
+}
+
+func CreateVSIXFromPackageJSON(t *testing.T, packageJSON *storage.VSIXPackageJSON) []byte {
+	packageJSONBytes, err := json.Marshal(packageJSON)
+	require.NoError(t, err)
+	return CreateVSIX(t, nil, packageJSONBytes)
 }
 
 // CreateVSIXFromExtension returns the bytes for a VSIX file containing the