Add binding gen js for remote and local

.gitignore

@@ -0,0 +1,5 @@
+# Ignore cmd directory
+cmd/
+
+# ignore all .DS_Store files
+.DS_Store

binding_generator.go

@@ -0,0 +1,23 @@
+package flixkit
+
+import (
+	"fmt"
+	"log"
+)
+
+func Generate(lang string, flix *FlowInteractionTemplate, templateLocation string, isLocal bool) (string, error) {
+	var contents string
+	var err error
+	switch lang {
+		case "javascript", "js":
+			contents, err = GenerateJavaScript(flix, templateLocation, isLocal)
+		default:
+			return "", fmt.Errorf("language %s not supported", lang)
+	}
+
+    if err != nil {
+        log.Fatalf("Error generating JavaScript: %v", err)
+    }
+
+	return contents, err
+}

flixkit.go

@@ -7,63 +7,27 @@ import (
 	"io"
 	"log"
 	"net/http"
-	"regexp"
+	"os"
 )
 
-type Network struct {
-	Address        string `json:"address"`
-	FqAddress      string `json:"fq_address"`
-	Contract       string `json:"contract"`
-	Pin            string `json:"pin"`
-	PinBlockHeight uint64 `json:"pin_block_height"`
-}
-
-type Argument struct {
-	Index    int      `json:"index"`
-	Type     string   `json:"type"`
-	Messages Messages `json:"messages"`
-	Balance  string   `json:"balance"`
-}
-
-type Title struct {
-	I18N map[string]string `json:"i18n"`
-}
-
-type Description struct {
-	I18N map[string]string `json:"i18n"`
-}
-
-type Messages struct {
-	Title       *Title       `json:"title,omitempty"`
-	Description *Description `json:"description,omitempty"`
-}
-
-type Dependencies map[string]Contracts
-type Contracts map[string]Networks
-type Networks map[string]Network
-type Arguments map[string]Argument
-
-type Data struct {
-	Type         string       `json:"type"`
-	Interface    string       `json:"interface"`
-	Messages     Messages     `json:"messages"`
-	Cadence      string       `json:"cadence"`
-	Dependencies Dependencies `json:"dependencies"`
-	Arguments    Arguments    `json:"arguments"`
-}
-
-type FlowInteractionTemplate struct {
-	FType    string `json:"f_type"`
-	FVersion string `json:"f_version"`
-	ID       string `json:"id"`
-	Data     Data   `json:"data"`
-}
 
 type FlixService interface {
 	GetFlixRaw(ctx context.Context, templateName string) (string, error)
 	GetFlix(ctx context.Context, templateName string) (*FlowInteractionTemplate, error)
 	GetFlixByIDRaw(ctx context.Context, templateID string) (string, error)
 	GetFlixByID(ctx context.Context, templateID string) (*FlowInteractionTemplate, error)
+	GenFlixBinding(ctx context.Context, templateID string, lang string, isLocal bool) (string, error)
+}
+
+// OsFileReader is a real implementation that calls os.ReadFile.
+type OsFileReader struct{}
+
+func (o OsFileReader) ReadFile(filename string) ([]byte, error) {
+	return os.ReadFile(filename)
+}
+
+type FileReader interface {
+	ReadFile(filename string) ([]byte, error)
 }
 
 type flixServiceImpl struct {
@@ -72,13 +36,18 @@ type flixServiceImpl struct {
 
 type Config struct {
 	FlixServerURL string
+	FileReader   FileReader
 }
 
 func NewFlixService(config *Config) FlixService {
 	if config.FlixServerURL == "" {
 		config.FlixServerURL = "https://flix.flow.com/v1/templates"
 	}
 
+	if config.FileReader == nil {
+		config.FileReader = OsFileReader{}
+	}
+
 	return &flixServiceImpl{
 		config: config,
 	}
@@ -122,36 +91,29 @@ func (s *flixServiceImpl) GetFlixByID(ctx context.Context, templateID string) (*
 	return parsedTemplate, nil
 }
 
-func (t *FlowInteractionTemplate) IsScript() bool {
-	return t.Data.Type == "script"
-}
-
-func (t *FlowInteractionTemplate) IsTransaction() bool {
-	return t.Data.Type == "transaction"
-}
-
-func (t *FlowInteractionTemplate) GetAndReplaceCadenceImports(networkName string) (string, error) {
-	cadence := t.Data.Cadence
 
-	for dependencyAddress, contracts := range t.Data.Dependencies {
-		for contractName, networks := range contracts {
-			network, ok := networks[networkName]
-			if !ok {
-				return "", fmt.Errorf("network %s not found for contract %s", networkName, contractName)
-			}
+func (s *flixServiceImpl) GenFlixBinding(ctx context.Context, templateLocation string, lang string, isLocal bool) (string, error) {
+	var template string
+	var err error
+	if isLocal {
+		template, err = FetchFlixWithContextFromFile(s.config.FileReader, ctx, templateLocation)
+	} else {
+		template, err = FetchFlixWithContext(ctx, templateLocation)
+	}
 
-			pattern := fmt.Sprintf(`import\s*%s\s*from\s*%s`, contractName, dependencyAddress)
-			re, err := regexp.Compile(pattern)
-			if err != nil {
-				return "", fmt.Errorf("invalid regex pattern: %v", err)
-			}
+	if err != nil {
+		fmt.Println("can not get flix:", err)
+		return "", err
+	}
 
-			replacement := fmt.Sprintf("import %s from %s", contractName, network.Address)
-			cadence = re.ReplaceAllString(cadence, replacement)
-		}
+	parsedTemplate, err := ParseFlix(template)
+	if err != nil {
+		return "", err
 	}
 
-	return cadence, nil
+	contents, bindingErr := Generate(lang, parsedTemplate, templateLocation, isLocal)
+
+	return contents, bindingErr
 }
 
 func ParseFlix(template string) (*FlowInteractionTemplate, error) {
@@ -188,3 +150,11 @@ func FetchFlixWithContext(ctx context.Context, url string) (string, error) {
 
 	return string(body), nil
 }
+
+func FetchFlixWithContextFromFile(reader FileReader, ctx context.Context, url string) (string, error) {
+	body, err := reader.ReadFile(url)
+	if err != nil {
+		log.Fatalf("Failed to read file: %v", err)
+	}
+	return string(body), nil
+}

flixkit_test.go

@@ -2,13 +2,15 @@ package flixkit
 
 import (
 	"context"
-	"github.com/stretchr/testify/assert"
 	"net/http"
 	"net/http/httptest"
+	"strings"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
-var template = `{
+var flix_template = `{
 	  "f_type": "InteractionTemplate",
 	  "f_version": "1.0.0",
 	  "id": "290b6b6222b2a77b16db896a80ddf29ebd1fa3038c9e6625a933fa213fce51fa",
@@ -149,7 +151,7 @@ var parsedTemplate = &FlowInteractionTemplate{
 func TestParseFlix(t *testing.T) {
 	assert := assert.New(t)
 
-	parsedTemplate, err := ParseFlix(template)
+	parsedTemplate, err := ParseFlix(flix_template)
 	assert.NoError(err, "ParseTemplate should not return an error")
 	assert.NotNil(parsedTemplate, "Parsed template should not be nil")
 
@@ -270,7 +272,7 @@ func TestGetFlix(t *testing.T) {
 	assert := assert.New(t)
 
 	server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
-		rw.Write([]byte(template))
+		rw.Write([]byte(flix_template))
 	}))
 	defer server.Close()
 
@@ -302,7 +304,7 @@ func TestGetFlixByID(t *testing.T) {
 	assert := assert.New(t)
 
 	server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
-		rw.Write([]byte(template))
+		rw.Write([]byte(flix_template))
 	}))
 	defer server.Close()
 
@@ -313,3 +315,72 @@ func TestGetFlixByID(t *testing.T) {
 	assert.NotNil(flix, "GetParsedFlixByID should not return a nil Flix")
 	assert.Equal(parsedTemplate, flix, "GetParsedFlixByID should return the correct Flix")
 }
+
+// MockFileReader is a mock implementation for tests.
+type MockFileReader struct {
+	content []byte
+	err     error
+}
+
+func (m MockFileReader) ReadFile(filename string) ([]byte, error) {
+	return m.content, m.err
+}
+
+func TestGenFlixWrongLang(t *testing.T) {
+	assert := assert.New(t)
+
+	server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
+		rw.Write([]byte(flix_template))
+	}))
+	defer server.Close()
+
+	flixService := NewFlixService(&Config{FlixServerURL: server.URL, FileReader: MockFileReader{
+		content: []byte(flix_template),
+		err:     nil,
+	},})
+	ctx := context.Background()
+	contents, err := flixService.GenFlixBinding(ctx, "./templateID", "cobal", true)
+	assert.Error(err, "language cobal not supported")
+	assert.NotNil(contents, "")
+}
+func TestGenFlixJS(t *testing.T) {
+	assert := assert.New(t)
+
+	server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
+		rw.Write([]byte(flix_template))
+	}))
+	defer server.Close()
+
+	flixService := NewFlixService(&Config{FlixServerURL: server.URL, FileReader: MockFileReader{
+		content: []byte(flix_template),
+		err:     nil,
+	},})
+
+	ctx := context.Background()
+	templatePath := "./templateID"
+	contents, err := flixService.GenFlixBinding(ctx, templatePath, "javascript", true)
+	assert.NoError(err, "GenFlixBinding should not return an error")
+	assert.NotNil(contents, "GenFlixBinding should not return a nil Flix")
+	assert.True(strings.Contains(contents, templatePath), "Expected '%s'", templatePath)
+}
+
+func TestGenRemoteFlixJS(t *testing.T) {
+	assert := assert.New(t)
+
+	server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
+		rw.Write([]byte(flix_template))
+	}))
+	defer server.Close()
+
+	flixService := NewFlixService(&Config{FlixServerURL: server.URL, FileReader: MockFileReader{
+		content: []byte(flix_template),
+		err:     nil,
+	},})
+
+	ctx := context.Background()
+	endpoint := server.URL + "/tempateName"
+	contents, err := flixService.GenFlixBinding(ctx, endpoint, "javascript", false)
+	assert.NoError(err, "GenFlixBinding should not return an error")
+	assert.NotNil(contents, "GenFlixBinding should not return a nil Flix")
+	assert.True(strings.Contains(contents, endpoint), "Expected '%s'", endpoint)
+}

go.mod

@@ -2,9 +2,10 @@ module github.com/onflow/flixkit-go
 
 go 1.20
 
+require github.com/stretchr/testify v1.8.4
+
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/stretchr/testify v1.8.4 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -4,6 +4,7 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=