feat: init node application

cli/cli.go

@@ -17,11 +17,12 @@
 
 // defaultSFNFile is the default serverless file name
 const (
-	defaultSFNSourceFile     = "app.go"
-	defaultSFNSourceTSFile   = "app.ts"
-	defaultSFNTestSourceFile = "app_test.go"
-	defaultSFNCompliedFile   = "sfn.yomo"
-	defaultSFNWASIFile       = "sfn.wasm"
+	defaultSFNSourceFile       = "app.go"
+	defaultSFNSourceTSFile     = "app.ts"
+	defaultSFNTestSourceFile   = "app_test.go"
+	defaultSFNTestSourceTSFile = "app_test.ts"
+	defaultSFNCompliedFile     = "sfn.yomo"
+	defaultSFNWASIFile         = "sfn.wasm"
 )
 
 // GetRootPath get root path
@@ -91,3 +92,23 @@
 	opts.Filename = f
 	return nil
 }
+
+// DefaultSFNSourceFile returns the default source file name for the given language
+func DefaultSFNSourceFile(lang string) string {
+	switch lang {
+	case "node":
+		return defaultSFNSourceTSFile
+	default:
+		return defaultSFNSourceFile
+	}
+}
+
+// DefaultSFNTestSourceFile returns the default test source file name
+func DefaultSFNTestSourceFile(lang string) string {
+	switch lang {
+	case "node":
+		return defaultSFNTestSourceTSFile
+	default:
+		return defaultSFNTestSourceFile
+	}
+}

cli/init.go

@@ -16,25 +16,28 @@
 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/serverless"
+	"github.com/yomorun/yomo/cli/template"
 	"github.com/yomorun/yomo/pkg/file"
 	"github.com/yomorun/yomo/pkg/log"
 )
 
-var name string
+var lang string
 
 // initCmd represents the init command
 var initCmd = &cobra.Command{
 	Use:   "init",
 	Short: "Initialize a YoMo Stream function",
 	Long:  "Initialize a YoMo Stream function",
 	Run: func(cmd *cobra.Command, args []string) {
+		name := opts.Name
 		if len(args) >= 1 && args[0] != "" {
 			name = args[0]
 		}
@@ -46,21 +49,39 @@
 
 		log.PendingStatusEvent(os.Stdout, "Initializing the Stream Function...")
 		name = strings.ReplaceAll(name, " ", "_")
-		// create app.go
-		fname := filepath.Join(name, defaultSFNSourceFile)
-		contentTmpl := golang.InitTmpl
-		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)
+		filename := filepath.Join(name, DefaultSFNSourceFile(lang))
+		opts.Filename = filename
+		// serverless setup
+		err := serverless.Setup(&opts)
+		if err != nil {
+			log.FailureStatusEvent(os.Stdout, err.Error())
 			return
 		}
-
-		// create app_test.go
-		testName := filepath.Join(name, defaultSFNTestSourceFile)
-		if err := file.PutContents(testName, golang.InitTestTmpl); err != nil {
-			log.FailureStatusEvent(os.Stdout, "Write unittest tmpl into app_test.go file failure with the error: %v", err)
+		// create app source file
+		fname := filepath.Join(name, DefaultSFNSourceFile(lang))
+		contentTmpl, err := template.GetContent("init", "", lang, 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 %s file failure with the error: %v", fname, err)
+			return
+		}
+		// create app test file
+		testName := filepath.Join(name, DefaultSFNTestSourceFile(lang))
+		testTmpl, err := template.GetContent("init", "", lang, 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
 		fname = filepath.Join(name, ".env")
 		if err := file.PutContents(fname, []byte(fmt.Sprintf("YOMO_SFN_NAME=%s\nYOMO_SFN_ZIPPER=localhost:9000\n", name))); err != nil {
@@ -70,13 +91,13 @@
 
 		log.SuccessStatusEvent(os.Stdout, "Congratulations! You have initialized the stream function successfully.")
 		log.InfoStatusEvent(os.Stdout, "You can enjoy the YoMo Stream Function via the command: ")
-		log.InfoStatusEvent(os.Stdout, "\tStep 1: cd %s && yomo build", name)
-		log.InfoStatusEvent(os.Stdout, "\tStep 2: yomo run sfn.yomo")
+		log.InfoStatusEvent(os.Stdout, "\tcd %s && yomo run", name)
 	},
 }
 
 func init() {
 	rootCmd.AddCommand(initCmd)
 
-	initCmd.Flags().StringVarP(&name, "name", "n", "", "The name of Stream Function")
+	initCmd.Flags().StringVarP(&opts.Name, "name", "n", "", "The name of Stream Function")
+	initCmd.Flags().StringVarP(&lang, "lang", "l", "go", "The language of Stream Function, support go and node")
 }

cli/serverless/exec/serverless.go

@@ -15,6 +15,11 @@
 	target string
 }
 
+// Setup sets up the serverless
+func (s *ExecServerless) Setup(opts *serverless.Options) error {
+	return nil
+}
+
 // Init initializes the serverless
 func (s *ExecServerless) Init(opts *serverless.Options) error {
 	if !file.Exists(opts.Filename) {

cli/serverless/golang/serverless.go

@@ -29,6 +29,11 @@
 	tempDir string
 }
 
+// Setup sets up the serverless
+func (s *GolangServerless) Setup(opts *serverless.Options) error {
+	return nil
+}
+
 // Init initializes the serverless
 func (s *GolangServerless) Init(opts *serverless.Options) error {
 	s.opts = opts

cli/serverless/golang/template.go

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

cli/serverless/nodejs/runtime.go

@@ -142,3 +142,40 @@
 
 	return nil
 }
+
+// InitApp initializes the nodejs application
+func (w *NodejsWrapper) InitApp() error {
+	// init
+	cmd := exec.Command(w.npmPath, "init")
+	if w.npmPath == "npm" {
+		cmd.Args = append(cmd.Args, "-y")
+	}
+	cmd.Dir = w.workDir
+	cmd.Stderr = os.Stderr
+	cmd.Env = os.Environ()
+
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("run %s failed: %v", cmd.String(), err)
+	}
+	return nil
+}
+
+// InstallDeps installs the yomo dependencies
+func (w *NodejsWrapper) InstallDeps() error {
+	// @yomo/sfn
+	cmd := exec.Command(w.npmPath, "install", "@yomo/sfn")
+	cmd.Dir = w.workDir
+	cmd.Stderr = os.Stderr
+	cmd.Env = os.Environ()
+	err := cmd.Run()
+	if err != nil {
+		return fmt.Errorf("run %s failed: %v", cmd.String(), err)
+	}
+	// devDependencies
+	cmd = exec.Command(w.npmPath, "install", "-D", "@types/node", "ts-node")
+	err = cmd.Run()
+	if err != nil {
+		return fmt.Errorf("run %s failed: %v", cmd.String(), err)
+	}
+	return nil
+}

cli/serverless/nodejs/serverless.go

@@ -3,8 +3,11 @@
 
 import (
 	"os"
+	"path/filepath"
 
 	"github.com/yomorun/yomo/cli/serverless"
+	"github.com/yomorun/yomo/pkg/file"
+	"github.com/yomorun/yomo/pkg/log"
 	"github.com/yomorun/yomo/pkg/wrapper"
 )
 
@@ -16,6 +19,33 @@
 	wrapper    *NodejsWrapper
 }
 
+// Setup sets up the nodejs serverless
+func (s *nodejsServerless) Setup(opts *serverless.Options) error {
+	wrapper, err := NewWrapper(opts.Name, opts.Filename)
+	if err != nil {
+		return err
+	}
+	// init package.json
+	err = file.Mkdir(wrapper.workDir)
+	if err != nil {
+		log.FailureStatusEvent(os.Stdout, "Create work dir failed: %v", err)
+		return err
+	}
+	if !file.Exists(filepath.Join(wrapper.workDir, "package.json")) {
+		err = wrapper.InitApp()
+		if err != nil {
+			return err
+		}
+	}
+	// install dependencies
+	err = wrapper.InstallDeps()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
 // Init initializes the nodejs serverless
 func (s *nodejsServerless) Init(opts *serverless.Options) error {
 	wrapper, err := NewWrapper(opts.Name, opts.Filename)

cli/serverless/serverless.go

@@ -16,6 +16,9 @@
 
 // Serverless defines the interface for serverless
 type Serverless interface {
+	// Setup sets up the serverless
+	Setup(opts *Options) error
+
 	// Init initializes the serverless
 	Init(opts *Options) error
 
@@ -69,3 +72,17 @@
 
 	return nil, fmt.Errorf(`serverless: unsupport "%s" source (forgotten import?)`, ext)
 }
+
+// Setup sets up the serverless
+func Setup(opts *Options) error {
+	ext := filepath.Ext(opts.Filename)
+
+	driversMu.RLock()
+	s, ok := drivers[ext]
+	driversMu.RUnlock()
+	if ok {
+		return s.Setup(opts)
+	}
+
+	return fmt.Errorf(`serverless: unsupport "%s" source (forgotten import?)`, ext)
+}

cli/serverless/wasm/serverless.go

@@ -24,6 +24,11 @@
 	mu           sync.Mutex
 }
 
+// Setup sets up the serverless
+func (s *wasmServerless) Setup(opts *cli.Options) error {
+	return nil
+}
+
 // Init initializes the serverless
 func (s *wasmServerless) Init(opts *cli.Options) error {
 	runtime, err := NewRuntime(opts.Runtime)

cli/template/go/init_llm_test.tmpl

@@ -0,0 +1,36 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/yomorun/yomo/serverless/mock"
+)
+
+func TestHandler(t *testing.T) {
+	tests := []struct {
+		name string
+		ctx  *mock.MockContext
+		// want is the expected result written by ctx.WriteLLMResult()
+		want string
+	}{
+		{
+			name: "get weather",
+			ctx:  mock.NewArgumentsContext(`{"city":"New York","latitude":40.7128,"longitude":-74.0060}`, 0x33),
+			want: "The current weather in New York (40.712800,-74.006000) is sunny",
+		},
+		// TODO: add more test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			Handler(tt.ctx)
+
+			records := tt.ctx.RecordsWritten()
+			got := records[0].LLMResult
+
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("TestHandler got: %v, want: %v", got, tt.want)
+			}
+		})
+	}
+}

cli/template/go/init_normal.tmpl

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/yomorun/yomo/serverless"
+)
+
+// Init is an optional function invoked during the initialization phase of the
+// sfn instance. It's designed for setup tasks like global variable
+// initialization, establishing database connections, or loading models into
+// GPU memory. If initialization fails, the sfn instance will halt and terminate.
+// This function can be omitted if no initialization tasks are needed.
+func Init() error {
+	return nil
+}
+
+// DataTags specifies the data tags to which this serverless function
+// subscribes, essential for data reception. Upon receiving data with these
+// tags, the Handler function is triggered.
+func DataTags() []uint32 {
+	return []uint32{0x33}
+}
+
+// Handler orchestrates the core processing logic of this function.
+// - ctx.Tag() identifies the tag of the incoming data.
+// - ctx.Data() accesses the raw data.
+// - ctx.Write() forwards processed data downstream.
+func Handler(ctx serverless.Context) {
+	data := ctx.Data()
+	fmt.Printf("<< sfn received[%d Bytes]: %s\n", len(data), data)
+	output := strings.ToUpper(string(data))
+	err := ctx.Write(0x34, []byte(output))
+	if err != nil {
+		fmt.Printf(">> sfn write error: %v\n", err)
+		return
+	}
+	fmt.Printf(">> sfn written[%d Bytes]: %s\n", len(output), output)
+}