feat: deploy functions from manifest file (#362)

* feat: deploy functions from manifest file

* chore: use `ioutil.WriteFile`

* chore: update test

* refactor: move functionsManifest to separate file

* chore: fix paths in test

* chore: fix Windows paths in tests

* chore: fix test message

* chore: update test messages

* refactor: throw error on malformed manifest file

* refactor: add error message

Co-authored-by: Marcus Weiner <[email protected]>

* refactor: add error handling

* refactor: wrap error message

Co-authored-by: Marcus Weiner <[email protected]>

Author: eduardoboucas

go/internal/data/hello-js-function-test.zip

@@ -583,6 +583,16 @@ func bundle(functionDir string, observer DeployObserver) (*deployFiles, error) {
 		return nil, nil
 	}
 
+	manifestFile, err := os.Open(filepath.Join(functionDir, "manifest.json"))
+
+	// If a `manifest.json` file is found, we extract the functions and their
+	// metadata from it.
+	if err == nil {
+		defer manifestFile.Close()
+
+		return bundleFromManifest(manifestFile, observer)
+	}
+
 	functions := newDeployFiles()
 
 	info, err := ioutil.ReadDir(functionDir)
@@ -626,6 +636,42 @@ func bundle(functionDir string, observer DeployObserver) (*deployFiles, error) {
 	return functions, nil
 }
 
+func bundleFromManifest(manifestFile *os.File, observer DeployObserver) (*deployFiles, error) {
+	manifestBytes, err := ioutil.ReadAll(manifestFile)
+
+	if err != nil {
+		return nil, err
+	}
+
+	var manifest functionsManifest
+
+	err = json.Unmarshal(manifestBytes, &manifest)
+
+	if err != nil {
+		return nil, fmt.Errorf("malformed functions manifest file: %w", err)
+	}
+
+	functions := newDeployFiles()
+
+	for _, function := range manifest.Functions {
+		fileInfo, err := os.Stat(function.Path)
+
+		if err != nil {
+			return nil, fmt.Errorf("manifest file specifies a function path that cannot be found: %s", function.Path)
+		}
+
+		file, err := newFunctionFile(function.Path, fileInfo, function.Runtime, observer)
+
+		if err != nil {
+			return nil, err
+		}
+
+		functions.Add(file.Name, file)
+	}
+
+	return functions, nil
+}
+
 func readZipRuntime(filePath string) (string, error) {
 	zf, err := zip.OpenReader(filePath)
 	if err != nil {

go/internal/data/hello-py-function-test.zip

@@ -3,11 +3,13 @@ package porcelain
 import (
 	"bytes"
 	gocontext "context"
+	"fmt"
 	"io/ioutil"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
 	"os"
+	"path"
 	"path/filepath"
 	"strings"
 	"testing"
@@ -200,6 +202,91 @@ func TestUploadFiles_Cancelation(t *testing.T) {
 	require.ErrorIs(t, err, gocontext.Canceled)
 }
 
+func TestBundle(t *testing.T) {
+	functions, err := bundle("../internal/data", mockObserver{})
+
+	if err != nil {
+		t.Fatalf("unexpected error bundling functions: %v", err)
+	}
+
+	if len(functions.Files) != 3 {
+		t.Fatalf("unexpected number of functions, expected=3, got=%d", len(functions.Files))
+	}
+
+	jsFunction := functions.Files["hello-js-function-test"]
+	pyFunction := functions.Files["hello-py-function-test"]
+	rsFunction := functions.Files["hello-rs-function-test"]
+
+	if jsFunction.Runtime != "js" {
+		t.Fatalf("unexpected runtime, expected='js', got='%v'", jsFunction.Runtime)
+	}
+
+	if pyFunction.Runtime != "py" {
+		t.Fatalf("unexpected runtime, expected='py', got='%v'", pyFunction.Runtime)
+	}
+
+	if rsFunction.Runtime != "rs" {
+		t.Fatalf("unexpected runtime, expected='rs', got='%v'", rsFunction.Runtime)
+	}
+}
+
+func TestBundleWithManifest(t *testing.T) {
+	cwd, _ := os.Getwd()
+	basePath := path.Join(filepath.Dir(cwd), "internal", "data")
+	jsFunctionPath := strings.Replace(filepath.Join(basePath, "hello-js-function-test.zip"), "\\", "/", -1)
+	pyFunctionPath := strings.Replace(filepath.Join(basePath, "hello-py-function-test.zip"), "\\", "/", -1)
+	manifestPath := path.Join(basePath, "manifest.json")
+	manifestFile := fmt.Sprintf(`{
+		"functions": [
+			{
+				"path": "%s",
+				"runtime": "a-runtime",
+				"mainFile": "/some/path/hello-js-function-test.js",
+				"name": "hello-js-function-test"
+			},
+			{
+				"path": "%s",
+				"runtime": "some-other-runtime",
+				"mainFile": "/some/path/hello-py-function-test",
+				"name": "hello-py-function-test"
+			}    
+		],
+		"version": 1
+	}`, jsFunctionPath, pyFunctionPath)
+
+	err := ioutil.WriteFile(manifestPath, []byte(manifestFile), 0644)
+	defer os.Remove(manifestPath)
+
+	if err != nil {
+		t.Fatal("could not create manifest file")
+	}
+
+	functions, err := bundle("../internal/data", mockObserver{})
+
+	t.Log(functions)
+
+	if err != nil {
+		t.Fatalf("unexpected error bundling functions: %v", err)
+	}
+
+	if len(functions.Files) != 2 {
+		t.Fatalf("unexpected number of functions, expected=2, got=%d", len(functions.Files))
+	}
+
+	jsFunction := functions.Files["hello-js-function-test"]
+	expectedJsFunctionRuntime := "a-runtime"
+	pyFunction := functions.Files["hello-py-function-test"]
+	expectedPyFunctionRuntime := "some-other-runtime"
+
+	if jsFunction.Runtime != expectedJsFunctionRuntime {
+		t.Fatalf("unexpected runtime, expected='%s', got='%v'", expectedJsFunctionRuntime, jsFunction.Runtime)
+	}
+
+	if pyFunction.Runtime != expectedPyFunctionRuntime {
+		t.Fatalf("unexpected runtime, expected='%s', got='%v'", expectedPyFunctionRuntime, pyFunction.Runtime)
+	}
+}
+
 func TestReadZipRuntime(t *testing.T) {
 	runtime, err := readZipRuntime("../internal/data/hello-rs-function-test.zip")
 	if err != nil {

go/porcelain/deploy.go

@@ -0,0 +1,14 @@
+package porcelain
+
+// https://github.com/netlify/zip-it-and-ship-it/blob/main/src/manifest.ts
+type functionsManifest struct {
+	Functions []functionsManifestEntry `json:"functions"`
+	Version   int                      `json:"version"`
+}
+
+type functionsManifestEntry struct {
+	MainFile string `json:"mainFile"`
+	Name     string `json:"name"`
+	Path     string `json:"path"`
+	Runtime  string `json:"runtime"`
+}