Wasm integration

.github/workflows/testapp.yml

@@ -16,11 +16,11 @@ jobs:
       - name: Install dependencies
         run: go mod tidy
       - name: Build
-        run: go build -v ./...
+        run: go build -tags=cli -v ./...
       - name: Test with the Go CLI
         run: |
           go mod tidy
-          go build -o build/l2 -ldflags "-X main.version=`git tag --sort=-version:refname | head -n 1`" l2.go
-          go test -v ./tests/
+          go build -tags=cli -o build/l2 -ldflags "-X main.version=`git tag --sort=-version:refname | head -n 1`" l2.go
+          go test -tags=cli -v ./tests/
       - name: Deploy hexmos doc
         run: curl -X POST --fail -F token=${{ secrets.TRIGGER_TOKEN }} -F ref=main https://git.apps.hexmos.com/api/v4/projects/85/trigger/pipeline

.gitignore

@@ -1,3 +1,6 @@
 build/
 lama2
 .vscode
+buildAndPublish.sh
+static/
+.env

cmdexec/cmdexec.go

@@ -1,3 +1,5 @@
+//go:build cli
+
 // Package `cmdexec` provides a facility to execute
 // l2 commands, stream output to stdout, while also
 // providing ability to retrieve the command output as
@@ -11,7 +13,6 @@ import (
 
 	"github.com/HexmosTech/httpie-go"
 	"github.com/HexmosTech/lama2/utils"
-	"github.com/rs/zerolog/log"
 )
 
 // ExecCommand changes directory to the given `apiDir`
@@ -25,10 +26,8 @@ func ExecCommand(cmdSlice []string, stdinBody string, apiDir string) (httpie.ExR
 	utils.ChangeWorkingDir(apiDir)
 	resp, err := httpie.Lama2Entry(cmdSlice, strings.NewReader(stdinBody))
 	if err != nil {
-		log.Fatal().Str("Error from the API executor", err.Error()).Msg("")
 		return httpie.ExResponse{}, errors.New("Error from API executor: " + err.Error())
 	}
-	log.Debug().Str("Response body from API executor", resp.Body).Msg("")
 	utils.ChangeWorkingDir(oldDir)
 	return resp, nil
 }

cmdexec/cmdexec.wasm.go

@@ -0,0 +1,36 @@
+//go:build wasm
+
+// Package `cmdexec` provides a facility to execute
+// l2 commands, stream output to stdout, while also
+// providing ability to retrieve the command output as
+// a string.
+package cmdexec
+
+import (
+	"errors"
+	"fmt"
+	"os"
+
+	"strings"
+
+	"github.com/HexmosTech/httpie-go"
+)
+
+// ExecCommand changes directory to the given `apiDir`
+// and then executes the command specified in `cmdStr`
+// During command execution, ExecCommand streams output
+// to stdout.
+// Once execution finishes, previous CWD is restored,
+// and the command output is returned as a string
+func ExecCommand(cmdSlice []string, stdinBody string, apiDir string) (httpie.ExResponse, error) {
+	proxyURL := os.Getenv("PROXY_URL")
+	proxyUserName := os.Getenv("PROXY_USERNAME")
+	proxyUserPassword := os.Getenv("PROXY_PASSWORD")
+	allowRedirects := true
+	resp, err := httpie.Lama2Entry(cmdSlice, strings.NewReader(stdinBody), proxyURL, proxyUserName, proxyUserPassword, allowRedirects)
+	if err != nil {
+		fmt.Println("Got error while executing", err)
+		return httpie.ExResponse{}, errors.New("Error from API executor: " + err.Error())
+	}
+	return resp, nil
+}

cmdexec/js.go

@@ -1,3 +1,5 @@
+//go:build cli
+
 package cmdexec
 
 import (
@@ -24,6 +26,9 @@ func GetJSVm() *goja.Runtime {
 // you reuse the vm for other operations, the state
 // from previous invocations carry over
 func RunVMCode(jsCode string, vm *goja.Runtime) {
+	if vm == nil {
+		vm = GetJSVm()
+	}
 	_, err := vm.RunString(jsCode)
 	if ex, ok := err.(*goja.Exception); ok {
 		log.Fatal().Str("Error executing JS processor block", ex.String()).Msg("")

cmdexec/js.wasm.go

@@ -0,0 +1,28 @@
+//go:build wasm
+
+package cmdexec
+
+import (
+	"syscall/js"
+
+	"github.com/dop251/goja"
+)
+
+func RunVMCode(jsCode string, vm *goja.Runtime) {
+	js.Global().Call("eval", jsCode)
+}
+
+//  The GenerateChainCode function creates a JavaScript code snippet
+//  that attempts to parse a given HTTP response body as JSON, logging
+//  success or failure, and stores the result accordingly.
+func GenerateChainCode(httpRespBody string) string {
+	code := `try {
+		result = JSON.parse(String.raw` + "`" + httpRespBody + "`" + `)	
+		console.log("Stored as JSON")
+	} catch (e) {
+		result = String.raw` + "`" + httpRespBody + "`" + ` 	
+		console.log(e)
+		console.log("Stored as string")
+	}`
+	return code
+}

cmdgen/cmdgen.cli.go

@@ -0,0 +1,14 @@
+//go:build cli
+
+package cmdgen
+
+import (
+	"github.com/HexmosTech/gabs/v2"
+	"github.com/HexmosTech/lama2/lama2cmd"
+)
+
+func ConstructCommand(parsedInput *gabs.Container, o *lama2cmd.Opts) ([]string, string) {
+	httpv, url, jsonObj, headers, multipartBool, formBool := ConstructCommandHelper(parsedInput)
+	res, stdinBody := assembleCmdString(httpv, url, jsonObj, headers, multipartBool, formBool, o)
+	return res, stdinBody
+}

cmdgen/cmdgen.go

@@ -12,40 +12,27 @@ import (
 
 	"github.com/HexmosTech/gabs/v2"
 	"github.com/HexmosTech/lama2/lama2cmd"
-	"github.com/rs/zerolog/log"
 )
 
+// The assembleCmdString function constructs a httpie 
+// command string for an HTTP request based on the provided 
+// HTTP method, URL, JSON object, headers, and options. It also
+//  handle multipart and form data.
 func assembleCmdString(httpv string, url string, jsonObj *gabs.Container, headers *gabs.Container, multipart bool, form bool, o *lama2cmd.Opts) ([]string, string) {
 	command := make([]string, 0)
-	log.Info().
-		Str("Type", "Construct Command").
-		Str("httpv", httpv).
-		Str("url", url).
-		Bool("multipart", multipart).
-		Bool("form", form).
-		Msg(fmt.Sprint("Construct parameters"))
-
-	log.Debug().
-		Str("JSONObj", jsonObj.String()).
-		Str("Headers", headers.String()).Msg("")
-
 	var files *gabs.Container
 	if multipart {
 		if jsonObj.ExistsP("@files") {
 			files = jsonObj.S("@files")
-			log.Debug().Str("Files", files.String()).Msg("")
 			jsonObj.Delete("@files")
-			log.Trace().Str("Shortened JsonObj", jsonObj.String()).Msg("")
 		}
 	}
 
 	jsonStr := ""
 	if jsonObj != nil && !multipart && !form {
 		dst := &bytes.Buffer{}
 		if err := json.Compact(dst, []byte(jsonObj.String())); err != nil {
-			log.Fatal().
-				Str("Error", err.Error()).
-				Msg("Couldn't minify JSON")
+			fmt.Println(err)
 		}
 		jsonStr = dst.String()
 	}
@@ -58,7 +45,7 @@ func assembleCmdString(httpv string, url string, jsonObj *gabs.Container, header
 		}*/
 
 	command = append(command, "ht ")
-	if o.Nocolor {
+	if o != nil && o.Nocolor {
 		command = append(command, "--pretty=none ")
 	}
 	if multipart || form {
@@ -70,7 +57,8 @@ func assembleCmdString(httpv string, url string, jsonObj *gabs.Container, header
 
 	if multipart {
 		for key, val := range jsonObj.Data().(*gabs.Container).ChildrenMap() {
-			command = append(command, "'"+key+"'='"+val.Data().(string)+"'  ")
+			keyValuePair := fmt.Sprintf("%s=%s", key, val.Data().(string))
+			command = append(command, keyValuePair)
 		}
 		for key, val := range files.ChildrenMap() {
 			command = append(command, key+"@"+val.Data().(string))
@@ -79,7 +67,7 @@ func assembleCmdString(httpv string, url string, jsonObj *gabs.Container, header
 
 	if form {
 		for key, val := range jsonObj.Data().(*gabs.Container).ChildrenMap() {
-			keyValuePair := fmt.Sprintf("'%s'='%s'  ", key, val.Data().(string))
+			keyValuePair := fmt.Sprintf("%s=%s", key, val.Data().(string))
 			command = append(command, keyValuePair)
 		}
 	}
@@ -104,20 +92,17 @@ func assembleCmdString(httpv string, url string, jsonObj *gabs.Container, header
 // API file inputs, figures out the type of target command
 // and finally generates a string representing the generated
 // command
-func ConstructCommand(parsedInput *gabs.Container, o *lama2cmd.Opts) ([]string, string) {
-	log.Info().Str("ParsedInput", parsedInput.String()).Msg("")
+func ConstructCommandHelper(parsedInput *gabs.Container) (string, string, *gabs.Container, *gabs.Container, bool, bool) {
 	httpv := parsedInput.S("verb", "value")
 	url := parsedInput.S("url", "value")
 	jsonObj := parsedInput.S("details", "ip_data")
 	headers := parsedInput.S("details", "headers")
 	multipart := parsedInput.S("multipart", "value")
+	form := parsedInput.S("form", "value")
 	multipartBool := false
 	if multipart != nil {
 		multipartBool = true
 	}
-	form := parsedInput.S("form", "value")
 	formBool := form != nil
-
-	res, stdinBody := assembleCmdString(httpv.Data().(string), url.Data().(string), jsonObj, headers, multipartBool, formBool, o)
-	return res, stdinBody
+	return httpv.Data().(string), url.Data().(string), jsonObj, headers, multipartBool, formBool
 }

cmdgen/cmdgen.wasm.go

@@ -0,0 +1,14 @@
+//go:build wasm
+
+package cmdgen
+
+import (
+	"github.com/HexmosTech/gabs/v2"
+	"github.com/HexmosTech/lama2/lama2cmd"
+)
+
+func ConstructCommand(parsedInput *gabs.Container, o *lama2cmd.Opts) ([]string, string) {
+	httpv, url, jsonObj, headers, multipartBool, formBool := ConstructCommandHelper(parsedInput)
+	res, stdinBody := assembleCmdString(httpv, url, jsonObj, headers, multipartBool, formBool, nil)
+	return res, stdinBody
+}

controller/controller.cli.go

@@ -0,0 +1,94 @@
+//go:build cli
+
+// Package controller coordinates all the other
+// components in the `Lama2` project. The high
+// level overview of command execution is easily
+// understood from this package
+package contoller
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/HexmosTech/gabs/v2"
+	"github.com/HexmosTech/httpie-go"
+	"github.com/HexmosTech/lama2/cmdexec"
+	"github.com/HexmosTech/lama2/codegen"
+	"github.com/HexmosTech/lama2/lama2cmd"
+	outputmanager "github.com/HexmosTech/lama2/outputManager"
+	"github.com/HexmosTech/lama2/parser"
+	"github.com/HexmosTech/lama2/preprocess"
+	"github.com/HexmosTech/lama2/prettify"
+	"github.com/HexmosTech/lama2/utils"
+	"github.com/dop251/goja"
+	"github.com/rs/zerolog/log"
+)
+
+func ExecuteProcessorBlock(block *gabs.Container, vm *goja.Runtime) httpie.ExResponse {
+	return ExecuteProcessorBlockHelper(block, vm)
+}
+
+// func ExecuteRequestorBlock(block *gabs.Container, vm *goja.Runtime, opts *lama2cmd.Opts, dir string) httpie.ExResponse {
+// 	return ExecuteRequestorBlockHelper(block, vm, opts, dir)
+// }
+
+func HandleParsedFile(parsedAPI *gabs.Container, o *lama2cmd.Opts, dir string) (httpie.ExResponse, *lama2cmd.Opts) {
+	vm := cmdexec.GetJSVm()
+	return HandleParsedFileHelper(parsedAPI, o, dir, vm)
+}
+
+// Process initiates the following tasks in the given order:
+// 1. Parse command line arguments
+// 2. Read API file contents
+// 3. Expand environment variables in API file
+// 4. Parse the API contents
+// 5. Generate API request command
+// 6. Execute command & retrieve results
+// 7. Optionally, post-process and write results to a JSON file
+func Process(version string) {
+	o := lama2cmd.GetAndValidateCmd(os.Args)
+	lama2cmd.ArgParsing(o, version)
+
+	apiContent := preprocess.GetLamaFileAsString(o.Positional.LamaAPIFile)
+	_, dir, _ := utils.GetFilePathComponents(o.Positional.LamaAPIFile)
+	oldDir, _ := os.Getwd()
+	utils.ChangeWorkingDir(dir)
+
+	preprocess.LoadEnvironments(dir)
+	utils.ChangeWorkingDir(oldDir)
+	p := parser.NewLama2Parser()
+	parsedAPI, e := p.Parse(apiContent)
+	if o.Convert != "" {
+		codegen.GenerateTargetCode(o.Convert, parsedAPI)
+		return
+	}
+
+	if o.Prettify {
+		prettify.Prettify(parsedAPI, p.Context, p.MarkRange, apiContent, o.Positional.LamaAPIFile)
+		return
+	}
+
+	if e != nil {
+		log.Fatal().
+			Str("Type", "Controller").
+			Str("LamaFile", o.Positional.LamaAPIFile).
+			Str("Error", e.Error()).
+			Msg("Parse Error")
+	}
+	log.Debug().Str("Parsed API", parsedAPI.String()).Msg("")
+	res, out := HandleParsedFile(parsedAPI, o, dir)
+	if out.Output != "" {
+		outputmanager.WriteJSONOutput(res, out.Output)
+	}
+}
+
+func ExecuteRequestorBlockHelper(resp httpie.ExResponse, headersString string, e1 error, vm *goja.Runtime) httpie.ExResponse {
+	if e1 == nil {
+		chainCode := cmdexec.GenerateChainCode(resp.Body)
+		cmdexec.RunVMCode(chainCode, vm)
+	} else {
+		fmt.Printf("Error from ExecCommand", e1)
+		os.Exit(1)
+	}
+	return resp
+}