Merge pull request #47 from HexmosTech/Wasm

Wasm integration

Author: rogueloop

.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,6 @@
+//go:build cli
+
+
 package cmdexec
 
 import (
@@ -9,7 +12,7 @@ import (
 
 // GetJSVm creates a new goja runtime instance
 // with console.log enabled
-func GetJSVm() *goja.Runtime {
+func GetJSVm() interface{} {
 	vm := goja.New()
 	new(require.Registry).Enable(vm)
 	console.Enable(vm)
@@ -23,8 +26,11 @@ func GetJSVm() *goja.Runtime {
 // Note: the vm runtime remains modified; so if
 // you reuse the vm for other operations, the state
 // from previous invocations carry over
-func RunVMCode(jsCode string, vm *goja.Runtime) {
-	_, err := vm.RunString(jsCode)
+func RunVMCode(jsCode string, vm interface{}) {
+	if vm == nil {
+		vm = GetJSVm()
+	}
+	_, err := vm.(*goja.Runtime).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,44 @@
+//go:build wasm
+
+package cmdexec
+
+import (
+	"fmt"
+	"syscall/js"
+	"github.com/rs/zerolog/log"
+)
+
+// RunVMCode takes in a JS snippet as a string, executes the code in a JS VM using Web Worker
+func RunVMCode(jsCode string, vm interface{}) {
+	worker := vm.(js.Value)
+	resultChan := make(chan js.Value)
+	worker.Call("postMessage", map[string]interface{}{
+		"code": jsCode,
+	})
+
+	js.Global().Get("addEventListener").Invoke("message", js.FuncOf(func(this js.Value, args []js.Value) interface{} {
+		resultChan <- args[0].Get("data")
+		return nil
+	}))
+
+	result := <-resultChan
+	err := result.Get("error").String()
+	if err != "null" {
+		log.Fatal().Str("Error executing JS processor block", err).Msg("")
+	}
+}
+
+// GenerateChainCode takes in an HTTP response body and comes up with some JS code to define the "magic variable" result.
+func GenerateChainCode(httpRespBody string) string {
+	fmt.Println("WW: Value of httpRespBody is",httpRespBody)
+	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")
+	}`
+	log.Debug().Str("Chain code generated", code).Msg("")
+	return code
+}

cmdgen/cmdgen.cli.go

@@ -0,0 +1,16 @@
+//go:build cli
+
+package cmdgen
+
+import (
+	"github.com/HexmosTech/gabs/v2"
+	"github.com/HexmosTech/lama2/lama2cmd"
+	"github.com/rs/zerolog/log"
+)
+
+func ConstructCommand(parsedInput *gabs.Container, o *lama2cmd.Opts) ([]string, string) {
+	log.Info().Str("ParsedInput", parsedInput.String()).Msg("")
+	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 {
@@ -105,20 +92,20 @@ 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) {
+	fmt.Println("WW parsedInput:", parsedInput.StringIndent("", "  "))
 	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
+	fmt.Println("WW httpv:", httpv.Data().(string))
+	fmt.Println("WW url:", url.Data().(string))
+	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
+}

codegen/codegen.cli.go

@@ -0,0 +1,92 @@
+//go:build cli
+
+package codegen
+
+import (
+	"bytes"
+	_ "embed"
+	"fmt"
+	"strings"
+	"text/template"
+
+	"github.com/HexmosTech/gabs/v2"
+	"github.com/HexmosTech/lama2/cmdexec"
+	"github.com/atotto/clipboard"
+	"github.com/dop251/goja"
+	"github.com/rs/zerolog/log"
+)
+
+//go:embed httpsnippet.js
+var snippetcore string
+
+var globalVM interface{}
+
+func initialize() {
+	globalVM = cmdexec.GetJSVm()
+}
+
+var flag = 0
+
+func GenerateTargetCode(targetLangLib string, parsedAPI *gabs.Container) {
+	convertedSnippetFinal := generateConvertedSippet(targetLangLib, parsedAPI)
+	fmt.Println("Converted snippet:\n", convertedSnippetFinal)
+	clipboard.WriteAll(convertedSnippetFinal)
+	fmt.Println("Code copied to clipboard")
+}
+
+func PrepareHTTPSnippetGenerator(snippetArgs SnippetArgs) string {
+	var templOutput bytes.Buffer
+	templStr := `{{.SnippetCore}} 
+
+	const snippet = new window.HTTPSnippet({{.HARRequest}});
+	
+	convertedSnippet = snippet.convert('{{.Language}}'{{if .Library }}, '{{.Library}}'{{end}});
+	`
+	tmpl, _ := template.New("httpsnippet").Parse(templStr)
+	tmpl.Execute(&templOutput, snippetArgs)
+	return templOutput.String()
+}
+
+func generateConvertedSippet(targetLangLib string, parsedAPI *gabs.Container) string {
+	initialize()
+	parsedAPIblocks := parsedAPI.S("value").Data().(*gabs.Container).Children()
+	convertedSnippetList := make([]string, 0)
+	blockLength := len(parsedAPIblocks)
+	for i, block := range parsedAPIblocks {
+		log.Debug().Int("Block num", i).Msg("")
+		log.Debug().Str("Block getting processed", block.String()).Msg("")
+		blockType := block.S("type").Data().(string)
+		if blockType == "processor" {
+			snippet := block.S("value").Data().(*gabs.Container).Data().(string)
+			log.Debug().Str("Processor block incoming block", block.String()).Msg("")
+			convertedSnippetList = append(convertedSnippetList, snippet)
+		} else if blockType == "Lama2File" {
+			harRequest, flag := GetRequestHARString(block,targetLangLib)
+			snippetArgs := SnippetArgs{}
+			lang, lib := SplitLangLib(targetLangLib)
+			snippetArgs.Language = lang
+			snippetArgs.Library = lib
+			snippetArgs.HARRequest = harRequest
+			snippetArgs.SnippetCore = snippetcore
+			httpsnippetCode := PrepareHTTPSnippetGenerator(snippetArgs)
+			vm := cmdexec.GetJSVm()
+			_, e := vm.(*goja.Runtime).RunString(httpsnippetCode)
+			if e != nil {
+				log.Fatal().
+					Str("Type", "CodeGen").
+					Str("Error", e.Error()).
+					Msg("Code generator error")
+			}
+			convertedSnippet := vm.(*goja.Runtime).Get("convertedSnippet").String()
+			convertedSnippetWithPostProcessing := postprocessURL(convertedSnippet, flag)
+			flag = 0
+			convertedSnippetList = append(convertedSnippetList, convertedSnippetWithPostProcessing)
+		}
+		if i != blockLength-1 {
+			convertedSnippetList = append(convertedSnippetList, "\n---\n")
+		}
+	}
+
+	convertedSnippetFinal := strings.Join(convertedSnippetList, "\n")
+	return convertedSnippetFinal
+}