Add binding gen js for remote and local

.gitignore

@@ -0,0 +1,2 @@
+# ignore all .DS_Store files
+.DS_Store

bindings/fcl-js.go

@@ -0,0 +1,111 @@
+package bindings
+
+import (
+	"bytes"
+	"embed"
+	"sort"
+	"text/template"
+
+	"github.com/onflow/flixkit-go"
+	"github.com/stoewer/go-strcase"
+)
+
+type SimpleParameter struct {
+	Name        string
+	JsType      string
+	Description string
+	FclType     string
+	CadType     string
+}
+
+type TemplateData struct {
+	Version         string
+	Parameters      []SimpleParameter
+	Title           string
+	Description     string
+	Location        string
+	IsScript        bool
+	IsLocalTemplate bool
+}
+
+//go:embed templates/*.tmpl
+var templateFiles embed.FS
+
+type FclJSGenerator struct{}
+
+func (g FclJSGenerator) Generate(flix *flixkit.FlowInteractionTemplate, templateLocation string, isLocal bool) (string, error) {
+	tmpl, err := template.ParseFS(templateFiles, "templates/*.tmpl")
+	if err != nil {
+		return "", err
+	}
+
+	methodName := strcase.LowerCamelCase(flix.Data.Messages.GetTitleValue("Request"))
+	description := flix.GetDescription()
+	data := TemplateData{
+		Version:         flix.FVersion,
+		Parameters:      transformArguments(flix.Data.Arguments),
+		Title:           methodName,
+		Description:     description,
+		Location:        templateLocation,
+		IsScript:        flix.IsScript(),
+		IsLocalTemplate: isLocal,
+	}
+
+	var buf bytes.Buffer
+	err = tmpl.Execute(&buf, data)
+	return buf.String(), err
+}
+
+func transformArguments(args flixkit.Arguments) []SimpleParameter {
+	simpleArgs := []SimpleParameter{}
+	var keys []string
+	// get keys for sorting
+	for k := range args {
+		keys = append(keys, k)
+	}
+
+	sort.SliceStable(keys, func(i, j int) bool {
+		return args[keys[i]].Index < args[keys[j]].Index
+	})
+	for _, key := range keys {
+		arg := args[key]
+		isArray, cType, jsType := isArrayParameter(arg)
+		desciption := arg.Messages.GetTitleValue("")
+		if isArray {
+			simpleArgs = append(simpleArgs, SimpleParameter{Name: key, CadType: cType, JsType: jsType, FclType: "Array(t." + cType + ")", Description: desciption})
+		} else {
+			jsType := convertCadenceTypeToJS(arg.Type)
+			simpleArgs = append(simpleArgs, SimpleParameter{Name: key, CadType: arg.Type, JsType: jsType, FclType: arg.Type, Description: desciption})
+		}
+	}
+	return simpleArgs
+}
+
+func isArrayParameter(arg flixkit.Argument) (bool, string, string) {
+	if arg.Type == "" || arg.Type[0] != '[' {
+		return false, "", ""
+	}
+	cadenceType := arg.Type[1 : len(arg.Type)-1]
+	jsType := "Array<" + convertCadenceTypeToJS(cadenceType) + ">"
+	return true, cadenceType, jsType
+}
+
+func convertCadenceTypeToJS(cadenceType string) string {
+	// need to determine js type based on fcl supported types
+	// looking at fcl types and how arguments work as parameters
+	// https://github.com/onflow/fcl-js/blob/master/packages/types/src/types.js
+	switch cadenceType {
+	case "Bool":
+		return "boolean"
+	case "Void":
+		return "void" // return type only
+	case "Dictionary":
+		return "object" // TODO: support Collection type, test to see what fcl
+	case "Struct":
+		return "object" // TODO: support Composite type, test to see what fcl
+	case "Enum":
+		return "object" // TODO: support Composite type, test to see what fcl
+	default:
+		return "string"
+	}
+}

bindings/fcl-js_test.go

@@ -0,0 +1,213 @@
+package bindings
+
+import (
+	"testing"
+
+	"github.com/hexops/autogold/v2"
+	"github.com/onflow/flixkit-go"
+	"github.com/stretchr/testify/assert"
+)
+
+var parsedTemplateTX = &flixkit.FlowInteractionTemplate{
+	FType:    "InteractionTemplate",
+	FVersion: "1.0.0",
+	ID:       "290b6b6222b2a77b16db896a80ddf29ebd1fa3038c9e6625a933fa213fce51fa",
+	Data: flixkit.Data{
+		Type:      "transaction",
+		Interface: "",
+		Messages: flixkit.Messages{
+			Title: &flixkit.Title{
+				I18N: map[string]string{
+					"en-US": "Transfer Tokens",
+				},
+			},
+			Description: &flixkit.Description{
+				I18N: map[string]string{
+					"en-US": "Transfer tokens from one account to another",
+				},
+			},
+		},
+		Cadence: "import FungibleToken from 0xFUNGIBLETOKENADDRESS\ntransaction(amount: UFix64, to: Address) {\nlet vault: @FungibleToken.Vault\nprepare(signer: AuthAccount) {\nself.vault <- signer\n.borrow<&{FungibleToken.Provider}>(from: /storage/flowTokenVault)!\n.withdraw(amount: amount)\n}\nexecute {\ngetAccount(to)\n.getCapability(/public/flowTokenReceiver)!\n.borrow<&{FungibleToken.Receiver}>()!\n.deposit(from: <-self.vault)\n}\n}",
+		Dependencies: flixkit.Dependencies{
+			"0xFUNGIBLETOKENADDRESS": flixkit.Contracts{
+				"FungibleToken": flixkit.Networks{
+					"mainnet": flixkit.Network{
+						Address:        "0xf233dcee88fe0abe",
+						FqAddress:      "A.0xf233dcee88fe0abe.FungibleToken",
+						Contract:       "FungibleToken",
+						Pin:            "83c9e3d61d3b5ebf24356a9f17b5b57b12d6d56547abc73e05f820a0ae7d9cf5",
+						PinBlockHeight: 34166296,
+					},
+					"testnet": flixkit.Network{
+						Address:        "0x9a0766d93b6608b7",
+						FqAddress:      "A.0x9a0766d93b6608b7.FungibleToken",
+						Contract:       "FungibleToken",
+						Pin:            "83c9e3d61d3b5ebf24356a9f17b5b57b12d6d56547abc73e05f820a0ae7d9cf5",
+						PinBlockHeight: 74776482,
+					},
+				},
+			},
+		},
+		Arguments: flixkit.Arguments{
+			"amount": flixkit.Argument{
+				Index: 0,
+				Type:  "UFix64",
+				Messages: flixkit.Messages{
+					Title: &flixkit.Title{
+						I18N: map[string]string{
+							"en-US": "The amount of FLOW tokens to send",
+						},
+					},
+				},
+				Balance: "",
+			},
+			"to": flixkit.Argument{
+				Index: 1,
+				Type:  "Address",
+				Messages: flixkit.Messages{
+					Title: &flixkit.Title{
+						I18N: map[string]string{
+							"en-US": "The Flow account the tokens will go to",
+						},
+					},
+				},
+				Balance: "",
+			},
+		},
+	},
+}
+
+var parsedTemplateScript = &flixkit.FlowInteractionTemplate{
+	FType:    "InteractionTemplate",
+	FVersion: "1.0.0",
+	ID:       "290b6b6222b2a77b16db896a80ddf29ebd1fa3038c9e6625a933fa213fce51fa",
+	Data: flixkit.Data{
+		Type:      "script",
+		Interface: "",
+		Messages: flixkit.Messages{
+			Title: &flixkit.Title{
+				I18N: map[string]string{
+					"en-US": "Multiply Two Integers",
+				},
+			},
+			Description: &flixkit.Description{
+				I18N: map[string]string{
+					"en-US": "Multiply two numbers to another",
+				},
+			},
+		},
+		Cadence: "pub fun main(x: Int, y: Int): Int { return x * y }",
+		Arguments: flixkit.Arguments{
+			"x": flixkit.Argument{
+				Index: 0,
+				Type:  "Int",
+				Messages: flixkit.Messages{
+					Title: &flixkit.Title{
+						I18N: map[string]string{
+							"en-US": "number to be multiplied",
+						},
+					},
+				},
+				Balance: "",
+			},
+			"y": flixkit.Argument{
+				Index: 1,
+				Type:  "Int",
+				Messages: flixkit.Messages{
+					Title: &flixkit.Title{
+						I18N: map[string]string{
+							"en-US": "second number to be multiplied",
+						},
+					},
+				},
+				Balance: "",
+			},
+		},
+	},
+}
+
+var ArrayTypeScript = &flixkit.FlowInteractionTemplate{
+	FType:    "InteractionTemplate",
+	FVersion: "1.0.0",
+	ID:       "290b6b6222b2a77b16db896a80ddf29ebd1fa3038c9e6625a933fa213fce51fa",
+	Data: flixkit.Data{
+		Type:      "script",
+		Interface: "",
+		Messages: flixkit.Messages{
+			Title: &flixkit.Title{
+				I18N: map[string]string{
+					"en-US": "Multiply Numbers",
+				},
+			},
+			Description: &flixkit.Description{
+				I18N: map[string]string{
+					"en-US": "Multiply numbers in an array",
+				},
+			},
+		},
+		Cadence: "pub fun main(numbers: [Int]): Int { var total = 1; for x in numbers { total = total * x }; return total }",
+		Arguments: flixkit.Arguments{
+			"numbers": flixkit.Argument{
+				Index: 0,
+				Type:  "[Int]",
+				Messages: flixkit.Messages{
+					Title: &flixkit.Title{
+						I18N: map[string]string{
+							"en-US": "Array of numbers to be multiplied",
+						},
+					},
+				},
+				Balance: "",
+			},
+		},
+	},
+}
+
+var minimumTemplate = &flixkit.FlowInteractionTemplate{
+	FType:    "InteractionTemplate",
+	FVersion: "1.0.0",
+	ID:       "290b6b6222b2a77b16db896a80ddf29ebd1fa3038c9e6625a933fa213fce51fa",
+	Data: flixkit.Data{
+		Type:      "script",
+		Interface: "",
+		Cadence:   "pub fun main(numbers: [Int]): Int { var total = 1; for x in numbers { total = total * x }; return total }",
+		Arguments: flixkit.Arguments{
+			"numbers": flixkit.Argument{
+				Index: 0,
+				Type:  "[Int]",
+			},
+		},
+	},
+}
+
+func TestJSGenTransaction(t *testing.T) {
+	generator := FclJSGenerator{}
+	got, _ := generator.Generate(parsedTemplateTX, "./transfer_token.json", true)
+	autogold.ExpectFile(t, got)
+}
+
+func TestJSGenScript(t *testing.T) {
+	generator := FclJSGenerator{}
+	assert := assert.New(t)
+	got, err := generator.Generate(parsedTemplateScript, "./multiply_two_integers.template.json", true)
+	assert.NoError(err, "ParseTemplate should not return an error")
+	autogold.ExpectFile(t, got)
+}
+
+func TestJSGenArrayScript(t *testing.T) {
+	generator := FclJSGenerator{}
+	assert := assert.New(t)
+
+	out, err := generator.Generate(ArrayTypeScript, "./multiply-numbers.template.json", true)
+	assert.NoError(err, "ParseTemplate should not return an error")
+	autogold.ExpectFile(t, out)
+}
+
+func TestJSGenMinScript(t *testing.T) {
+	generator := FclJSGenerator{}
+	assert := assert.New(t)
+
+	out, err := generator.Generate(minimumTemplate, "./min.template.json", true)
+	assert.NoError(err, "ParseTemplate should not return an error")
+	autogold.ExpectFile(t, out)
+}

bindings/templates/js_fcl_main.tmpl

@@ -0,0 +1,39 @@
+/**
+    This binding file was auto generated based on FLIX template v{{.Version}}. 
+    Changes to this file might get overwritten 
+**/
+
+import * as fcl from "@onflow/fcl"
+{{- if .IsLocalTemplate }}
+import flixTemplate from "{{.Location}}"
+{{- else}}
+const flixTemplate = "{{.Location}}"
+{{- end}}
+
+// TODO: add runtime check for parameters consistency
+const parameterNames = [
+  {{- range $index, $ele := .Parameters -}}
+     {{if $index}}, {{end}}"{{$ele.Name}}"
+  {{- end -}}
+];
+ {{"\n"}}/**
+* {{.Description}}{{"\n"}}
+   {{- if gt (len .Parameters) 0 -}}
+* @param {Object} Parameters - parameters for the cadence
+    {{- range $index, $ele := .Parameters -}}
+{{"\n"}}* @param {{"{"}} {{$ele.JsType}} {{"}"}} Parameters.{{$ele.Name}} - {{$ele.Description}}: {{$ele.CadType}}
+    {{- end -}}
+ {{ end -}}
+ {{- if not .IsScript -}}
+{{"\n"}}* @returns {Promise<string>} - returns a promise which resolves to the transaction id
+ {{- end -}}
+{{"\n"}}*/
+
+{{if .IsScript}}
+{{- template "js_fcl_script.tmpl" .}}
+{{else}}
+{{- template "js_fcl_tx.tmpl" .}}
+{{- end}}
+
+
+

bindings/templates/js_fcl_script.tmpl

@@ -0,0 +1,20 @@
+export async function {{.Title}}({ 
+ {{- if len .Parameters -}}
+    {{- range $index, $ele := .Parameters -}}
+      {{if $index}}, {{end}}{{.Name}}
+    {{- end -}}
+  {{- end -}}
+}) {
+  const info = await fcl.query({
+    template: flixTemplate,
+    {{ if len .Parameters -}}
+    args: (arg, t) => [
+      {{- range $index, $ele := .Parameters -}}
+        {{if $index}}, {{end}}arg({{.Name}}, t.{{.FclType}})
+      {{- end -}}
+      ]
+    {{- end }}
+  });
+
+  return info
+}