refactor command template

cli/init.go

@@ -16,13 +16,14 @@ limitations under the License.
 package cli
 
 import (
+	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
 
 	"github.com/spf13/cobra"
-	"github.com/yomorun/yomo/cli/serverless/golang"
+	"github.com/yomorun/yomo/cli/template"
 	"github.com/yomorun/yomo/pkg/file"
 	"github.com/yomorun/yomo/pkg/log"
 )
@@ -49,32 +50,28 @@ var initCmd = &cobra.Command{
 		name = strings.ReplaceAll(name, " ", "_")
 		// create app.go
 		fname := filepath.Join(name, defaultSFNSourceFile)
-		// sfn content template
-		var contentTmpl, testTmpl []byte
-		// sfn type
-		switch sfnType {
-		case "llm":
-			contentTmpl = golang.InitLLMTmpl
-			testTmpl = golang.InitLLMTestTmpl
-		case "normal":
-			contentTmpl = golang.InitTmpl
-			testTmpl = golang.InitTestTmpl
-		default:
-			log.WarningStatusEvent(os.Stdout, "The type of Stream Function is not supported, use the default type: llm")
-			contentTmpl = golang.InitLLMTmpl
-			testTmpl = golang.InitLLMTestTmpl
-
+		contentTmpl, err := template.GetContent("init", sfnType, "", false)
+		if err != nil {
+			log.FailureStatusEvent(os.Stdout, err.Error())
+			return
 		}
 		if err := file.PutContents(fname, contentTmpl); err != nil {
-			log.FailureStatusEvent(os.Stdout, "Write stream function into app.go file failure with the error: %v", err)
+			log.FailureStatusEvent(os.Stdout, "Write stream function into %s file failure with the error: %v", fname, err)
 			return
 		}
-
 		// create app_test.go
 		testName := filepath.Join(name, defaultSFNTestSourceFile)
-		if err := file.PutContents(testName, testTmpl); err != nil {
-			log.FailureStatusEvent(os.Stdout, "Write unittest tmpl into app_test.go file failure with the error: %v", err)
-			return
+		testTmpl, err := template.GetContent("init", sfnType, "", true)
+		if err != nil {
+			if !errors.Is(err, template.ErrUnsupportedTest) {
+				log.FailureStatusEvent(os.Stdout, err.Error())
+				return
+			}
+		} else {
+			if err := file.PutContents(testName, testTmpl); err != nil {
+				log.FailureStatusEvent(os.Stdout, "Write unittest tmpl into %s file failure with the error: %v", testName, err)
+				return
+			}
 		}
 
 		// create .env

cli/serverless/golang/template.go

@@ -9,18 +9,6 @@ import (
 //go:embed templates/main.tmpl
 var MainFuncTmpl []byte
 
-//go:embed templates/init.tmpl
-var InitTmpl []byte
-
-//go:embed templates/init_llm.tmpl
-var InitLLMTmpl []byte
-
-//go:embed templates/init_test.tmpl
-var InitTestTmpl []byte
-
-//go:embed templates/init_llm_test.tmpl
-var InitLLMTestTmpl []byte
-
 //go:embed templates/wasi_main.tmpl
 var WasiMainFuncTmpl []byte
 

cli/template/template.go

@@ -0,0 +1,93 @@
+package template
+
+import (
+	"embed"
+	"errors"
+	"os"
+	"strings"
+)
+
+//go:embed go
+var fs embed.FS
+
+var (
+	ErrUnsupportedSfnType = errors.New("unsupported sfn type")
+	ErrorUnsupportedLang  = errors.New("unsupported lang")
+	ErrUnsupportedTest    = errors.New("unsupported test")
+)
+
+var (
+	SupportedSfnTypes = []string{"llm", "normal"}
+	SupportedLangs    = []string{"go", "node"}
+)
+
+// get template content
+func GetContent(command string, sfnType string, lang string, isTest bool) ([]byte, error) {
+	if command == "" {
+		command = "init"
+	}
+	sfnType, err := validateSfnType(sfnType)
+	if err != nil {
+		return nil, err
+	}
+	lang, err = validateLang(lang)
+	if err != nil {
+		return nil, err
+	}
+	sb := new(strings.Builder)
+	sb.WriteString(lang)
+	sb.WriteString("/")
+	sb.WriteString(command)
+	sb.WriteString("_")
+	sb.WriteString(sfnType)
+	if isTest {
+		sb.WriteString("_test")
+	}
+	sb.WriteString(".tmpl")
+
+	// valdiate the path exists
+	name := sb.String()
+	f, err := fs.Open(name)
+	if err != nil {
+		if os.IsNotExist(err) {
+			if isTest {
+				return nil, ErrUnsupportedTest
+			}
+			return nil, err
+		}
+		return nil, err
+	}
+	defer f.Close()
+	_, err = f.Stat()
+	if err != nil {
+		return nil, err
+	}
+
+	return fs.ReadFile(name)
+}
+
+func validateSfnType(sfnType string) (string, error) {
+	if sfnType == "" {
+		// default sfn type
+		return "llm", nil
+	}
+	for _, t := range SupportedSfnTypes {
+		if t == sfnType {
+			return sfnType, nil
+		}
+	}
+	return sfnType, ErrUnsupportedSfnType
+}
+
+func validateLang(lang string) (string, error) {
+	if lang == "" {
+		// default lang
+		return "go", nil
+	}
+	for _, l := range SupportedLangs {
+		if l == lang {
+			return lang, nil
+		}
+	}
+	return lang, ErrorUnsupportedLang
+}