修正函数返回值

支持 load 加载的服务热更新（需配置hotLoad）
增强唯一id获取（使用新算法，依赖Redis）
session支持基于细粒度权限匹配（传入支持的功能列表匹配）

.gitignore

@@ -2,8 +2,6 @@
 !.gitignore
 go.sum
 /build
-/node_modules
-/package.json
 /bak
 node_modules
 package.json

caller.go

@@ -22,7 +22,10 @@ func NewCaller(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
 
 func makeResult(r *httpclient.Result, vm *goja.Runtime) goja.Value {
 	if r.Error != nil {
-		panic(vm.NewGoError(r.Error))
+		// panic(vm.NewGoError(r.Error))
+		vm.SetData("_lastError", r.Error)
+		gojs.GetLogger(vm).Error(r.Error.Error())
+		return nil
 	}
 	headers := map[string]string{}
 	for k, v := range r.Response.Header {

go.mod

@@ -1,40 +1,54 @@
 module apigo.cc/gojs/service
 
-go 1.18
+go 1.24.0
 
 require (
-	apigo.cc/gojs v0.0.3
+	apigo.cc/gojs v0.0.32
-	apigo.cc/gojs/console v0.0.1
+	apigo.cc/gojs/console v0.0.4
-	apigo.cc/gojs/http v0.0.3
+	apigo.cc/gojs/file v0.0.7
-	apigo.cc/gojs/util v0.0.2
+	apigo.cc/gojs/http v0.0.8
+	apigo.cc/gojs/runtime v0.0.4
+	apigo.cc/gojs/task v0.0.8
+	apigo.cc/gojs/util v0.0.16
 	github.com/gorilla/websocket v1.5.3
-	github.com/ssgo/config v1.7.8
+	github.com/ssgo/config v1.7.10
-	github.com/ssgo/discover v1.7.9
+	github.com/ssgo/discover v1.7.10
 	github.com/ssgo/httpclient v1.7.8
-	github.com/ssgo/log v1.7.7
+	github.com/ssgo/log v1.7.10
-	github.com/ssgo/redis v1.7.7
+	github.com/ssgo/redis v1.7.8
-	github.com/ssgo/s v1.7.17
+	github.com/ssgo/s v1.7.25
 	github.com/ssgo/standard v1.7.7
-	github.com/ssgo/u v1.7.9
+	github.com/ssgo/u v1.7.23
 )
 
 require (
-	github.com/dlclark/regexp2 v1.11.4 // indirect
+	github.com/ZZMarquis/gm v1.3.2 // indirect
-	github.com/fsnotify/fsnotify v1.7.0 // indirect
+	github.com/dlclark/regexp2 v1.11.5 // indirect
+	github.com/emmansun/gmsm v0.40.0 // indirect
+	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-ole/go-ole v1.3.0 // indirect
+	github.com/go-rod/rod v0.116.2 // indirect
 	github.com/go-sourcemap/sourcemap v2.1.4+incompatible // indirect
 	github.com/gomodule/redigo v1.9.2 // indirect
-	github.com/google/pprof v0.0.0-20230207041349-798e818bf904 // indirect
+	github.com/google/pprof v0.0.0-20250903194437-c28834ac2320 // indirect
-	github.com/lufia/plan9stats v0.0.0-20240909124753-873cd0166683 // indirect
+	github.com/lufia/plan9stats v0.0.0-20250317134145-8bc96cf8fc35 // indirect
+	github.com/obscuren/ecies v0.0.0-20150213224233-7c0f4a9b18d9 // indirect
 	github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect
+	github.com/robfig/cron/v3 v3.0.1 // indirect
 	github.com/shirou/gopsutil/v3 v3.24.5 // indirect
 	github.com/shoenig/go-m1cpu v0.1.6 // indirect
-	github.com/ssgo/tool v0.4.27 // indirect
+	github.com/ssgo/tool v0.4.29 // indirect
-	github.com/tklauser/go-sysconf v0.3.14 // indirect
+	github.com/tklauser/go-sysconf v0.3.15 // indirect
-	github.com/tklauser/numcpus v0.9.0 // indirect
+	github.com/tklauser/numcpus v0.10.0 // indirect
+	github.com/ysmood/fetchup v0.2.3 // indirect
+	github.com/ysmood/goob v0.4.0 // indirect
+	github.com/ysmood/got v0.40.0 // indirect
+	github.com/ysmood/gson v0.7.3 // indirect
+	github.com/ysmood/leakless v0.9.0 // indirect
 	github.com/yusufpapurcu/wmi v1.2.4 // indirect
-	golang.org/x/net v0.30.0 // indirect
+	golang.org/x/crypto v0.46.0 // indirect
-	golang.org/x/sys v0.26.0 // indirect
+	golang.org/x/net v0.48.0 // indirect
-	golang.org/x/text v0.19.0 // indirect
+	golang.org/x/sys v0.39.0 // indirect
+	golang.org/x/text v0.32.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

request.go

@@ -91,7 +91,10 @@ func (r *Request) MakeURL(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value
 func (r *Request) ReadAll(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
 	data, err := io.ReadAll(r.req.Body)
 	if err != nil {
-		panic(vm.NewGoError(err))
+		// panic(vm.NewGoError(err))
+		vm.SetData("_lastError", err)
+		gojs.GetLogger(vm).Error(err.Error())
+		return nil
 	}
 	return vm.ToValue(data)
 }
@@ -102,7 +105,10 @@ func (r *Request) Read(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
 	data := make([]byte, size)
 	n, err := r.req.Body.Read(data)
 	if err != nil {
-		panic(vm.NewGoError(err))
+		// panic(vm.NewGoError(err))
+		vm.SetData("_lastError", err)
+		gojs.GetLogger(vm).Error(err.Error())
+		return nil
 	}
 	return vm.ToValue(data[0:n])
 }
@@ -110,7 +116,10 @@ func (r *Request) Read(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
 func (r *Request) Close(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
 	err := r.req.Body.Close()
 	if err != nil {
-		panic(vm.NewGoError(err))
+		// panic(vm.NewGoError(err))
+		vm.SetData("_lastError", err)
+		gojs.GetLogger(vm).Error(err.Error())
+		return nil
 	}
 	return nil
 }

response.go

@@ -93,7 +93,10 @@ func (r *Response) Write(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value
 	args := gojs.MakeArgs(&argsIn, vm).Check(1)
 	n, err := r.resp.Write(args.Bytes(0))
 	if err != nil {
-		panic(vm.NewGoError(err))
+		// panic(vm.NewGoError(err))
+		vm.SetData("_lastError", err)
+		gojs.GetLogger(vm).Error(err.Error())
+		return vm.ToValue(false)
 	}
 	return vm.ToValue(n)
 }
@@ -111,7 +114,7 @@ func (r *Response) SendFile(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Val
 
 func (r *Response) DownloadFile(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
 	args := gojs.MakeArgs(&argsIn, vm).Check(3)
-	r.resp.DownloadFile(args.Str(0), args.Str(1), args.Bytes(1))
+	r.resp.DownloadFile(args.Str(0), args.Str(1), args.Bytes(2))
 	return nil
 }
 

service.go

@@ -1,14 +1,19 @@
 package service
 
 import (
+	"bytes"
 	_ "embed"
 	"encoding/json"
 	"errors"
 	"fmt"
+	"os"
+	"path/filepath"
 	"reflect"
 	"regexp"
 	"strings"
 	"sync"
+	"syscall"
+	"text/template"
 	"time"
 
 	"apigo.cc/gojs"
@@ -32,12 +37,25 @@ var serviceMD string
 var server *s.AsyncServer
 
 var pools = map[string]*gojs.Pool{}
+var poolsMTime = map[string]int64{}
+var poolsConfig = map[string]gojs.PoolConfig{}
 
 var poolExists = map[string]bool{}
 var poolActionRegistered = map[string]bool{}
 var poolsLock = sync.RWMutex{}
 var waitChan chan bool
 
+type TplCache struct {
+	FileModTime map[string]int64
+	Tpl         *template.Template
+}
+
+// var tplFunc = map[string]any{}
+var tplReplaces = map[string]string{}
+var tplLock = sync.RWMutex{}
+
+// var tplCache = map[string]*TplCache{}
+
 type LimiterConfig struct {
 	From  string
 	Time  int
@@ -56,6 +74,8 @@ type Config struct {
 	LimitedMessage     string
 	Limiters           map[string]*LimiterConfig
 	LimiterRedis       string
+	HotLoad            int
+	TplSafePaths       []string
 
 	Proxy   map[string]string
 	Rewrite map[string]string
@@ -66,27 +86,33 @@ var serviceConfig Config
 var onStop goja.Callable
 
 var limiters = map[string]*s.Limiter{}
+var configed = false
 
-func init() {
+func initConfig(opt *gojs.Obj, logger *log.Logger, vm *goja.Runtime) {
-	obj := map[string]any{
+	configed = true
-		"config": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
+	s.InitConfig()
+	if startPath := vm.GetData("startPath"); startPath != nil {
+		s.SetWorkPath(u.String(startPath))
+	}
 	// 处理配置
-			args := gojs.MakeArgs(&argsIn, vm)
+	serviceConfig = Config{"Session", "Device", "Client", "id", "", 3600, "auth failed", "verify failed", "too many requests", nil, "", 0, []string{}, map[string]string{}, map[string]string{}, map[string]string{}}
-			serviceConfig = Config{"Session", "Device", "Client", "userId", "", 3600, "auth failed", "verify failed", "too many requests", nil, "", map[string]string{}, map[string]string{}, map[string]string{}}
+	if errs := config.LoadConfig("service", &serviceConfig); len(errs) > 0 {
-			if errs := config.LoadConfig("service", &serviceConfig); errs != nil && len(errs) > 0 {
+		// panic(vm.NewGoError(errs[0]))
-				panic(vm.NewGoError(errs[0]))
+		vm.SetData("_lastError", errs[0])
+		gojs.GetLogger(vm).Error(errs[0].Error())
+		return
 	}
 	config.LoadConfig("service", &discover.Config)
 	// var auth goja.Callable
-			if conf := args.Obj(0); conf != nil {
+	if opt != nil {
-				u.Convert(conf.O.Export(), &serviceConfig)
+		u.Convert(opt.O.Export(), &serviceConfig)
-				u.Convert(conf.O.Export(), &s.Config)
+		u.Convert(opt.O.Export(), &s.Config)
-				u.Convert(conf.O.Export(), &discover.Config)
+		u.Convert(opt.O.Export(), &discover.Config)
 		// auth = conf.Func("auth")
-				onStop = conf.Func("onStop")
+		onStop = opt.Func("onStop")
 
 		if serviceConfig.SessionProvider != "" {
-					sessionRedis = redis.GetRedis(serviceConfig.SessionProvider, args.Logger)
+			sessionRedis = redis.GetRedis(serviceConfig.SessionProvider, logger)
 		}
 		sessionTimeout = serviceConfig.SessionTimeout
 		if sessionTimeout < 0 {
@@ -117,13 +143,28 @@ func init() {
 					}
 				}
 			}
+
 			// 如果没有session中的authLevel验证失败，则使用Access-Token中的authLevel（服务间调用）
 			if authAccessToken && setAuthLevel < authLevel {
 				setAuthLevel = s.GetAuthTokenLevel(request.Header.Get("Access-Token"))
 			}
+
+			authOk := false
 			if setAuthLevel >= authLevel {
+				authOk = true // 默认通过
+				if options != nil && options.Ext != nil && options.Ext["funcs"] != nil {
+					if needFuncs, ok := options.Ext["funcs"].([]string); ok && len(needFuncs) > 0 {
+						// 指定了细化的权限验证要求
+						request.Set("funcs", needFuncs)
+						authOk = session.authFuncs(needFuncs)
+					}
+				}
+			}
+
+			if authOk {
 				return true, session
-					} else {
+			}
+
 			msg := serviceConfig.AuthFieldMessage
 			if strings.Contains(msg, "{{") {
 				msg = strings.ReplaceAll(msg, "{{TARGET_AUTHLEVEL}}", u.String(authLevel))
@@ -135,7 +176,6 @@ func init() {
 			} else {
 				return false, msg
 			}
-					}
 		})
 		s.Init()
 	}
@@ -144,7 +184,7 @@ func init() {
 	if serviceConfig.Limiters != nil {
 		var limiterRedis *redis.Redis
 		if serviceConfig.LimiterRedis != "" {
-					limiterRedis = redis.GetRedis(serviceConfig.LimiterRedis, args.Logger)
+			limiterRedis = redis.GetRedis(serviceConfig.LimiterRedis, logger)
 		}
 		for name, limiter := range serviceConfig.Limiters {
 			switch limiter.From {
@@ -162,11 +202,65 @@ func init() {
 			}
 		}
 	}
+
+	if serviceConfig.HotLoad > 0 {
+		s.NewTimerServer("hotload", time.Duration(serviceConfig.HotLoad)*time.Second, func(b *bool) {
+			tmpPoolsMTimes := map[string]int64{}
+			poolsLock.RLock()
+			for actionFile, mtime := range poolsMTime {
+				tmpPoolsMTimes[actionFile] = mtime
+			}
+			poolsLock.RUnlock()
+
+			for actionFile, mtime := range tmpPoolsMTimes {
+				fi := u.GetFileInfo(actionFile)
+				if fi == nil {
+					continue
+				}
+
+				newMtime := fi.ModTime.Unix()
+				if newMtime > mtime {
+					// 重新加载文件
+					actionCode := u.ReadFileN(actionFile)
+					if !strings.Contains(actionCode, "function main(") { // || !strings.Contains(actionCode, ".register(")
+						logger.Error("hotload file %s failed, must be a js file with main function", actionFile)
+						continue
+					}
+					poolsLock.RLock()
+					oldOpt := poolsConfig[actionFile]
+					poolsLock.RUnlock()
+
+					p := gojs.NewPoolByCode(actionCode, actionFile, oldOpt, logger)
+					poolsLock.Lock()
+					pools[actionFile] = p
+					poolsMTime[actionFile] = newMtime
+					poolsLock.Unlock()
+					logger.Info("hotload file %s success", actionFile, "mtime", fi.ModTime)
+				}
+			}
+		}, nil, nil)
+	}
+}
+
+func init() {
+	s.Config.KeepKeyCase = true
+	s.DontStartLogAuto = true
+	obj := map[string]any{
+		"config": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
+			args := gojs.MakeArgs(&argsIn, vm)
+			initConfig(args.Obj(0), args.Logger, vm)
 			return nil
 		},
 		"start": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
+			if !configed {
+				initConfig(nil, gojs.GetLogger(vm), vm)
+				// panic(vm.NewGoError(errors.New("must run service.config frist")))
+			}
 			if server != nil {
-				panic(vm.NewGoError(errors.New("server already started")))
+				// panic(vm.NewGoError(errors.New("server already started")))
+				vm.SetData("_lastError", errors.New("server already started"))
+				gojs.GetLogger(vm).Error("server already started")
+				return vm.ToValue(false)
 			}
 			// 处理静态文件
 			if len(serviceConfig.Static) > 0 {
@@ -181,15 +275,94 @@ func init() {
 				s.SetProxyBy(proxy)
 			}
 
+			// 处理Watch
+			if inWatch := vm.GetData("inWatch"); inWatch != nil && inWatch.(bool) {
+				onWatchConn := map[string]*websocket.Conn{}
+				onWatchLock := sync.Mutex{}
+				vm.SetData("onWatch", func(filename string) {
+					onWatchLock.Lock()
+					defer onWatchLock.Unlock()
+					for id, conn := range onWatchConn {
+						if err := conn.WriteMessage(websocket.TextMessage, []byte(filename)); err != nil {
+							delete(onWatchConn, id)
+						}
+					}
+				})
+				s.AddShutdownHook(func() {
+					for _, conn := range onWatchConn {
+						conn.Close()
+					}
+				})
+				s.RegisterSimpleWebsocket(0, "/_watch", func(request *s.Request, conn *websocket.Conn) {
+					onWatchLock.Lock()
+					onWatchConn[request.Id] = conn
+					onWatchLock.Unlock()
+				}, "")
+				s.SetOutFilter(func(in map[string]any, request *s.Request, response *s.Response, out any, logger *log.Logger) (newOut any, isOver bool) {
+					contentType := response.Header().Get("Content-Type")
+					outStr := u.String(out)
+					if strings.HasPrefix(contentType, "text/html") || (contentType == "" && strings.Contains(outStr, "<html")) {
+						if strings.Contains(outStr, "let _watchWS = null") {
+							return nil, false
+						}
+						// 注入自动刷新的代码
+						outStr = strings.ReplaceAll(outStr, "</html>", `<script>
+	let _watchWS = null
+	let _watchWSConnection = false
+	let _watchWSIsFirst = true
+    function connect() {
+		_watchWSConnection = true
+        let ws = new WebSocket(location.protocol.replace('http', 'ws') + '//' + location.host + '/_watch')
+        ws.onopen = () => {
+			_watchWS = ws
+			_watchWSConnection = false
+			if( !_watchWSIsFirst ) location.reload()
+			_watchWSIsFirst = false
+		}
+        ws.onmessage = () => {
+			location.reload()
+		}
+        ws.onclose = () => {
+			_watchWS = null
+			_watchWSConnection = false
+		}
+    }
+	setInterval(()=>{
+		if(_watchWS!= null){
+			try{
+				_watchWS.send("ping")
+			}catch(err){
+				_watchWS = null
+				_watchWSConnection = false
+			}
+		} else if(!_watchWSConnection){
+			connect()
+		}
+	}, 1000)
+    connect()
+</script>
+</html>`)
+						return []byte(outStr), false
+					}
+					return nil, false
+				})
+			}
+
 			// 启动服务
 			server = s.AsyncStart()
 			waitChan = make(chan bool, 1)
 			server.OnStop(func() {
+				configed = false
 				if onStop != nil {
 					onStop(nil)
 				}
 			})
 			server.OnStopped(func() {
+				ClearRewritesAndProxies()
+				pools = map[string]*gojs.Pool{}
+				poolExists = map[string]bool{}
+				poolActionRegistered = map[string]bool{}
+				server = nil
 				if waitChan != nil {
 					waitChan <- true
 				}
@@ -198,20 +371,131 @@ func init() {
 		},
 		"stop": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
 			if server == nil {
-				panic(vm.NewGoError(errors.New("server not started")))
+				// panic(vm.NewGoError(errors.New("server not started")))
+				vm.SetData("_lastError", errors.New("server not started"))
+				gojs.GetLogger(vm).Error("server not started")
+				return vm.ToValue(false)
 			}
 			server.Stop()
-			ClearRewritesAndProxies()
+			s.ResetAllSets()
-			pools = map[string]*gojs.Pool{}
+			return vm.ToValue(true)
-			server = nil
-			return nil
 		},
+		// "uniqueId": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
+		// 	args := gojs.MakeArgs(&argsIn, vm)
+		// 	size := args.Int(0)
+		// 	var id string
+		// 	if size >= 20 {
+		// 		id = s.UniqueId20()
+		// 	} else if size >= 16 {
+		// 		id = s.UniqueId16()
+		// 	} else if size >= 14 {
+		// 		id = s.UniqueId14()
+		// 	} else if size >= 12 {
+		// 		id = s.UniqueId14()[0:12]
+		// 	} else {
+		// 		id = s.UniqueId()
+		// 	}
+		// 	return vm.ToValue(id)
+		// },
+		// "uniqueIdL": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
+		// 	args := gojs.MakeArgs(&argsIn, vm)
+		// 	size := args.Int(0)
+		// 	var id string
+		// 	if size >= 20 {
+		// 		id = s.UniqueId20()
+		// 	} else if size >= 16 {
+		// 		id = s.UniqueId16()
+		// 	} else if size >= 14 {
+		// 		id = s.UniqueId14()
+		// 	} else if size >= 12 {
+		// 		id = s.UniqueId14()[0:12]
+		// 	} else {
+		// 		id = s.UniqueId()
+		// 	}
+		// 	return vm.ToValue(strings.ToLower(id))
+		// },
+		"id": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
+			args := gojs.MakeArgs(&argsIn, vm).Check(1)
+			size := args.Int(0)
+			if size == 0 {
+				size = 12
+			}
+			if size > 20 {
+				size = 20
+			}
+
+			rd := sessionRedis
+			if rd == nil {
+				// 使用u.Id
+				return vm.ToValue(u.UniqueId()[0:size])
+			}
+
+			tm := time.Now()
+			// 计算从2000年开始到现在的索引值（2000年时间戳：946656000）（5位62进制最小值：14776336）（可以表示901356495个，即142.9年至2142年）
+			secIndex := (tm.Unix()-946656000)/5 + 14776336
+			secTag := int(tm.UnixMicro() % 5)
+			uid := u.AppendInt(nil, uint64(secIndex))
+			secIndexKey := fmt.Sprintf("_SecIdx_%d", secIndex)
+			inSecIndex := rd.INCR(secIndexKey)
+			if inSecIndex == 1 {
+				rd.EXPIRE(secIndexKey, 6)
+			}
+			inSecIndexBytes := u.EncodeInt(uint64(inSecIndex))
+			uid = u.AppendInt(uid, uint64(secTag*12+len(inSecIndexBytes))) // 长度位，防止不同长度+随机值发生碰撞（用毫秒的%4*12位基础+位数可以随机表示12位长度，看起来有变化）
+			uid = append(uid, inSecIndexBytes...)
+
+			// 用随机数填充
+			uid = u.FillInt(uid, size)
+
+			// 交叉乱序
+			uid = u.ExchangeInt(uid)
+
+			// 散列乱序
+			uid = u.HashInt(uid)
+
+			return vm.ToValue(string(uid))
+		},
+		// "id": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
+		// 	args := gojs.MakeArgs(&argsIn, vm).Check(1)
+		// 	space := args.Str(0)
+		// 	size := args.Int(1)
+		// 	var id string
+		// 	if size >= 12 {
+		// 		id = s.Id12(space)
+		// 	} else if size >= 10 {
+		// 		id = s.Id10(space)
+		// 	} else if size >= 8 {
+		// 		id = s.Id8(space)
+		// 	} else {
+		// 		id = s.Id6(space)
+		// 	}
+		// 	return vm.ToValue(id)
+		// },
+		// "idL": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
+		// 	args := gojs.MakeArgs(&argsIn, vm).Check(1)
+		// 	space := args.Str(0)
+		// 	size := args.Int(1)
+		// 	var id string
+		// 	if size >= 12 {
+		// 		id = s.Id12(space)
+		// 	} else if size >= 10 {
+		// 		id = s.Id10(space)
+		// 	} else if size >= 8 {
+		// 		id = s.Id8(space)
+		// 	} else {
+		// 		id = s.Id6(space)
+		// 	}
+		// 	return vm.ToValue(strings.ToLower(id))
+		// },
 		"register": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
 			args := gojs.MakeArgs(&argsIn, vm).Check(2)
 			o := args.Obj(0)
 			action := args.Func(1)
 			if action == nil {
-				panic(vm.NewGoError(errors.New("action must be a callback function")))
+				// panic(vm.NewGoError(errors.New("action must be a callback function")))
+				vm.SetData("_lastError", errors.New("action must be a callback function"))
+				gojs.GetLogger(vm).Error("action must be a callback function")
+				return vm.ToValue(false)
 			}
 
 			authLevel := o.Int("authLevel")
@@ -225,6 +509,13 @@ func init() {
 					usedLimiters = append(usedLimiters, limiter1)
 				}
 			}
+			if requiresObj := o.Array("requires"); requiresObj != nil {
+				requires := make([]string, len(requiresObj))
+				for i, require := range requiresObj {
+					requires[i] = u.String(require)
+				}
+				vm.SetData(fmt.Sprint("REQUIRE_"+host, method, path), requires)
+			}
 			if verifiesObj := o.Obj("verifies"); verifiesObj != nil {
 				verifiesSet := map[string]func(any, *goja.Runtime) bool{}
 				for _, field := range verifiesObj.Keys() {
@@ -257,29 +548,29 @@ func init() {
 						}
 					}
 				}
-				vm.GoData[fmt.Sprint("VERIFY_"+host, method, path)] = verifiesSet
+				vm.SetData(fmt.Sprint("VERIFY_"+host, method, path), verifiesSet)
 			}
 
 			opt := s.WebServiceOptions{
 				NoBody:   o.Bool("noBody"),
 				NoLog200: o.Bool("noLog200"),
 				Host:     host,
-				//Ext:      nil,
+				Ext:      o.Map("ext"),
 				Limiters: usedLimiters,
 			}
 
-			startFile := u.String(vm.GoData["startFile"])
+			startFile := u.String(vm.GetData("startFile"))
 			poolsLock.RLock()
 			poolExist := poolExists[startFile]
 			poolsLock.RUnlock()
 			if poolExist {
 				// 从对象调用（支持并发）
 				actionKey := "REGISTER_" + host + method + path
-				vm.GoData[actionKey] = action
+				vm.SetData(actionKey, action)
-				vm.GoData[actionKey+"This"] = args.This
+				vm.SetData(actionKey+"This", args.This)
 				if method == "WS" {
-					vm.GoData[actionKey+"onMessage"] = o.Func("onMessage")
+					vm.SetData(actionKey+"onMessage", o.Func("onMessage"))
-					vm.GoData[actionKey+"onClose"] = o.Func("onClose")
+					vm.SetData(actionKey+"onClose", o.Func("onClose"))
 				}
 				poolsLock.Lock()
 				actionRegistered := poolActionRegistered[actionKey]
@@ -298,7 +589,7 @@ func init() {
 				// 无对象池，直接调用（单线程）
 				s.RestfulWithOptions(authLevel, method, path, makeInnerAction(action, vm, args.This), memo, opt)
 			}
-			return nil
+			return vm.ToValue(true)
 		},
 		"load": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
 			args := gojs.MakeArgs(&argsIn, vm).Check(1)
@@ -318,71 +609,273 @@ func init() {
 					mainArgs = mainArgs1
 				}
 			}
-			if !u.FileExists(actionFile) {
+			fi := u.GetFileInfo(actionFile)
-				panic(vm.NewGoError(errors.New("actionFile must be a js file path")))
+			if fi == nil {
+				fullActionFile, _ := filepath.Abs(actionFile)
+				// panic(vm.NewGoError(errors.New("actionFile must be a js file path: " + fullActionFile)))
+				vm.SetData("_lastError", errors.New("actionFile must be a js file path: "+fullActionFile))
+				gojs.GetLogger(vm).Error("actionFile must be a js file path: " + fullActionFile)
+				return vm.ToValue(false)
 			}
 			actionCode := u.ReadFileN(actionFile)
-			if !strings.Contains(actionCode, "function main(") || !strings.Contains(actionCode, ".register(") {
+			if !strings.Contains(actionCode, "function main(") { // || !strings.Contains(actionCode, ".register(")
-				panic(vm.NewGoError(errors.New("actionFile must be a js file with main function and call service.register")))
+				// panic(vm.NewGoError(errors.New("actionFile must be a js file with main function")))
+				vm.SetData("_lastError", errors.New("actionFile must be a js file with main function"))
+				gojs.GetLogger(vm).Error("actionFile must be a js file with main function")
+				return vm.ToValue(false)
 			}
 			poolsLock.Lock()
 			poolExists[actionFile] = true
 			poolsLock.Unlock()
-			p := gojs.NewPoolByCode(actionCode, actionFile, gojs.PoolConfig{
+			poolOpt := gojs.PoolConfig{
 				Min:   mi,
 				Max:   ma,
 				Idle:  idle,
 				Debug: debug,
 				Args:  mainArgs,
-			}, args.Logger)
+			}
+			p := gojs.NewPoolByCode(actionCode, actionFile, poolOpt, args.Logger)
 			//p := gojs.NewLBByCode(actionCode, actionFile, gojs.LBConfig{
 			//	Num:   num,
 			//	Debug: debug,
 			//	Args:  mainArgs,
 			//}, args.Logger)
+			mtime := fi.ModTime.Unix()
 			poolsLock.Lock()
 			pools[actionFile] = p
+			poolsMTime[actionFile] = mtime
+			poolsConfig[actionFile] = poolOpt
 			poolsLock.Unlock()
-			return nil
+			return vm.ToValue(true)
 		},
-		"task": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
+		// "task": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
+		// 	args := gojs.MakeArgs(&argsIn, vm).Check(1)
+		// 	taskFile := args.Path(0)
+		// 	interval := args.Int(1)
+		// 	if interval == 0 {
+		// 		interval = 1000
+		// 	}
+		// 	if interval < 100 {
+		// 		interval = 100
+		// 	}
+		// 	if !u.FileExists(taskFile) {
+		// 		panic(vm.NewGoError(errors.New("taskFile must be a js file path")))
+		// 	}
+		// 	rt := gojs.New()
+		// 	_, err := rt.RunFile(taskFile)
+		// 	if err != nil {
+		// 		panic(vm.NewGoError(err))
+		// 	}
+		// 	s.NewTimerServer(taskFile, time.Duration(interval)*time.Millisecond, func(isRunning *bool) {
+		// 		rt.RunCode("if(onRun)onRun()")
+		// 	}, func() {
+		// 		rt.RunCode("if(onStart)onStart()")
+		// 	}, func() {
+		// 		rt.RunCode("if(onStop)onStop()")
+		// 	})
+		// 	return nil
+		// },
+		// "setTplFunc": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
+		// 	args := gojs.MakeArgs(&argsIn, vm).Check(1)
+		// 	fnObj := args.Obj(0)
+		// 	if fnObj != nil {
+		// 		fnList := map[string]any{}
+		// 		for _, k := range fnObj.O.Keys() {
+		// 			if jsFunc := fnObj.Func(k); jsFunc != nil {
+		// 				fn := func(args ...any) any {
+		// 					jsArgs := make([]goja.Value, len(args))
+		// 					for i := 0; i < len(args); i++ {
+		// 						jsArgs[i] = vm.ToValue(args[i])
+		// 					}
+		// 					// vm.CallbackLocker.Lock()
+		// 					r, err := jsFunc(argsIn.This, jsArgs...)
+		// 					// vm.CallbackLocker.Unlock()
+		// 					if err == nil {
+		// 						return r.Export()
+		// 					} else {
+		// 						panic(vm.NewGoError(err))
+		// 					}
+		// 				}
+		// 				fnList[k] = fn
+		// 			}
+		// 		}
+		// 		if len(fnList) > 0 {
+		// 			tplLock.Lock()
+		// 			for k, v := range fnList {
+		// 				tplFunc[k] = v
+		// 			}
+		// 			tplLock.Unlock()
+		// 		}
+		// 	}
+		// 	return nil
+		// },
+		"setTplReplaces": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
 			args := gojs.MakeArgs(&argsIn, vm).Check(1)
-			taskFile := args.Path(0)
+			replaces := args.Map(0)
-			interval := args.Int(1)
+			tplLock.Lock()
-			if interval == 0 {
+			for k, v := range replaces {
-				interval = 1000
+				tplReplaces[k] = u.String(v)
 			}
-			if interval < 100 {
+			tplLock.Unlock()
-				interval = 100
-			}
-			if !u.FileExists(taskFile) {
-				panic(vm.NewGoError(errors.New("taskFile must be a js file path")))
-			}
-			rt := gojs.New()
-			_, err := rt.RunFile(taskFile)
-			if err != nil {
-				panic(vm.NewGoError(err))
-			}
-			println(u.BMagenta("taskFile: "), taskFile, interval)
-			s.NewTimerServer(taskFile, time.Duration(interval)*time.Millisecond, func(isRunning *bool) {
-				rt.RunCode("if(onRun)onRun()")
-			}, func() {
-				rt.RunCode("if(onStart)onStart()")
-			}, func() {
-				rt.RunCode("if(onStop)onStop()")
-			})
 			return nil
 		},
-		"dataSet":    DataSet,
+		"tpl": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
-		"dataGet":    DataGet,
+			args := gojs.MakeArgs(&argsIn, vm).Check(2)
-		"dataKeys":   DataKeys,
+			filename := args.Path(0)
-		"dataCount":  DataCount,
+			if !tplIsSafe(filename) {
-		"dataFetch":  DataFetch,
+				// panic(vm.NewGoError(errors.New("tpl file " + filename + " not in safe paths")))
-		"dataRemove": DataRemove,
+				vm.SetData("_lastError", errors.New("tpl file "+filename+" not in safe paths"))
-		"listPop":    ListPop,
+				gojs.GetLogger(vm).Error("tpl file " + filename + " not in safe paths")
-		"listPush":   ListPush,
+				return nil
-		"listCount":  ListCount,
+			}
-		"listRemove": ListRemove,
+
+			basepath := filepath.Dir(filename)
+			info := u.GetFileInfo(filename)
+			if info == nil {
+				// panic(vm.NewGoError(errors.New("tpl file " + filename + " not exists")))
+				vm.SetData("_lastError", errors.New("tpl file "+filename+" not exists"))
+				gojs.GetLogger(vm).Error("tpl file " + filename + " not exists")
+				return nil
+			}
+
+			data := args.Any(1)
+			// tplLock.RLock()
+			// t := tplCache[filename]
+			var t *TplCache
+			if t1 := vm.GetData("TPL_" + filename); t1 != nil {
+				if t2, ok := t1.(*TplCache); ok {
+					t = t2
+				}
+			}
+			// t := vm.GetData("TPL_" + filename).(*TplCache)
+			// tplLock.RUnlock()
+			if t != nil {
+				for f, tm := range t.FileModTime {
+					info := u.GetFileInfo(f)
+					if info == nil || info.ModTime.UnixMilli() != tm {
+						t = nil
+						break
+					}
+				}
+			}
+			if t == nil {
+				tpl := template.New(filename)
+				fnList := map[string]any{}
+				if fnObj := args.Obj(2); fnObj != nil {
+					for _, k := range fnObj.O.Keys() {
+						if jsFunc := fnObj.Func(k); jsFunc != nil {
+							fn := func(args ...any) any {
+								jsArgs := make([]goja.Value, len(args))
+								for i := 0; i < len(args); i++ {
+									jsArgs[i] = vm.ToValue(args[i])
+								}
+								r, err := jsFunc(argsIn.This, jsArgs...)
+								if err == nil {
+									return r.Export()
+								} else {
+									// panic(vm.NewGoError(err))
+									vm.SetData("_lastError", err)
+									gojs.GetLogger(vm).Error(err.Error())
+									return nil
+								}
+							}
+							fnList[k] = fn
+						}
+					}
+				}
+				if len(fnList) > 0 {
+					tpl = tpl.Funcs(fnList)
+				}
+
+				fileModTime := map[string]int64{
+					filename: info.ModTime.UnixMilli(),
+				}
+				var err error
+				code := tplReplace(u.ReadFileN(filename))
+				for _, m := range tplIncludeMatcher.FindAllStringSubmatch(code, -1) {
+					a := strings.SplitN(m[1], ":", 2)
+					includeFilename := a[0]
+					includeFilepath := filepath.Join(basepath, includeFilename)
+					if !tplIsSafe(includeFilepath) {
+						// panic(vm.NewGoError(errors.New("tpl file " + includeFilepath + " not in safe paths")))
+						vm.SetData("_lastError", errors.New("tpl file "+includeFilepath+" not in safe paths"))
+						gojs.GetLogger(vm).Error("tpl file " + includeFilepath + " not in safe paths")
+						return nil
+					}
+
+					// 每个被包含的文件只解析一次（统一修正）
+					if fileModTime[includeFilepath] == 0 {
+						info2 := u.GetFileInfo(includeFilepath)
+						if info2 != nil {
+							includeCode := tplReplace(u.ReadFileN(includeFilepath))
+							foundBlock := false
+							includeCode = tplDefineMatcher.ReplaceAllStringFunc(includeCode, func(str string) string {
+								if m := tplDefineMatcher.FindStringSubmatch(str); len(m) > 1 {
+									foundBlock = true
+									if m[1] == "main" {
+										return `{{ define "` + includeFilename + `" }}`
+									}
+									return `{{ define "` + includeFilename + ":" + m[1] + `" }}`
+								}
+								return str
+							})
+							if !foundBlock {
+								includeCode = `{{ define "` + includeFilename + `" }}` + includeCode + `{{ end }}`
+							}
+							tpl, err = tpl.Parse(includeCode)
+							if err != nil {
+								// panic(vm.NewGoError(err))
+								vm.SetData("_lastError", err)
+								gojs.GetLogger(vm).Error(err.Error())
+								return nil
+							}
+							fileModTime[includeFilepath] = info2.ModTime.UnixMilli()
+						} else {
+							// panic(vm.NewGoError(errors.New("tpl file " + includeFilepath + " not exists")))
+							vm.SetData("_lastError", errors.New("tpl file "+includeFilepath+" not exists"))
+							gojs.GetLogger(vm).Error("tpl file " + includeFilepath + " not exists")
+							return nil
+						}
+					}
+				}
+
+				tpl, err = tpl.Parse(code)
+				if err != nil {
+					// panic(vm.NewGoError(err))
+					vm.SetData("_lastError", err)
+					gojs.GetLogger(vm).Error(err.Error())
+					return nil
+				}
+				t = &TplCache{
+					Tpl:         tpl,
+					FileModTime: fileModTime,
+				}
+				// tplLock.Lock()
+				// tplCache[filename] = t
+				// tplLock.Unlock()
+				vm.SetData("TPL_"+filename, t)
+			}
+
+			buf := bytes.NewBuffer(make([]byte, 0))
+			err := t.Tpl.ExecuteTemplate(buf, filename, data)
+			if err != nil {
+				// panic(vm.NewGoError(err))
+				vm.SetData("_lastError", err)
+				gojs.GetLogger(vm).Error(err.Error())
+				return nil
+			}
+			return vm.ToValue(buf.String())
+		},
+		// "dataSet":    DataSet,
+		// "dataGet":    DataGet,
+		// "dataKeys":   DataKeys,
+		// "dataCount":  DataCount,
+		// "dataFetch":  DataFetch,
+		// "dataRemove": DataRemove,
+		// "listPop":    ListPop,
+		// "listPush":   ListPush,
+		// "listCount":  ListCount,
+		// "listRemove": ListRemove,
 		"newCaller": NewCaller,
 	}
 
@@ -390,6 +883,17 @@ func init() {
 		Object:  obj,
 		TsCode:  serviceTS,
 		Example: serviceMD,
+		OnKill: func() {
+			if server != nil {
+				server.Stop()
+			}
+		},
+		OnSignal: func(sig os.Signal) {
+			switch sig {
+			case syscall.SIGUSR1:
+
+			}
+		},
 		WaitForStop: func() {
 			if waitChan != nil {
 				<-waitChan
@@ -398,8 +902,53 @@ func init() {
 	})
 }
 
+var regexpCache = map[string]*regexp.Regexp{}
+var regexpLock = sync.RWMutex{}
+
+func getRegexp(regexpStr string) (*regexp.Regexp, error) {
+	regexpLock.RLock()
+	rx, ok := regexpCache[regexpStr]
+	regexpLock.RUnlock()
+	if ok {
+		return rx, nil
+	}
+	rx, err := regexp.Compile(regexpStr)
+	if err == nil {
+		regexpLock.Lock()
+		defer regexpLock.Unlock()
+		regexpCache[regexpStr] = rx
+	}
+	return rx, err
+}
+
+func tplReplace(code string) string {
+	for k, v := range tplReplaces {
+		if rx, err := getRegexp(k); err == nil {
+			code = rx.ReplaceAllString(code, v)
+		}
+	}
+	return code
+}
+
+func tplIsSafe(filename string) bool {
+	if len(serviceConfig.TplSafePaths) > 0 {
+		isSafe := false
+		for _, safePath := range serviceConfig.TplSafePaths {
+			if strings.HasPrefix(filename, safePath) {
+				isSafe = true
+				break
+			}
+		}
+		return isSafe
+	}
+	return true
+}
+
+var tplIncludeMatcher = regexp.MustCompile(`{{\s*template\s+"([^"]+)"`)
+var tplDefineMatcher = regexp.MustCompile(`{{\s*define\s+"([^"]+)"\s*}}`)
+
 func verifyRegexp(regexpStr string) func(any, *goja.Runtime) bool {
-	if rx, err := regexp.Compile(regexpStr); err != nil {
+	if rx, err := getRegexp(regexpStr); err != nil {
 		return func(value any, vm *goja.Runtime) bool {
 			return rx.MatchString(u.String(value))
 		}
@@ -485,8 +1034,17 @@ func runAction(action goja.Callable, vm *goja.Runtime, thisArg goja.Value, args
 	defer vm.CallbackLocker.Unlock()
 
 	// 验证请求参数的有效性
-	if verifies, ok := vm.GoData["VERIFY_"+u.String(request.Get("registerTag"))].(map[string]func(any, *goja.Runtime) bool); ok {
+	if verifies, ok := vm.GetData("VERIFY_" + u.String(request.Get("registerTag"))).(map[string]func(any, *goja.Runtime) bool); ok {
 		failedFields := make([]string, 0)
+		// 检查必填字段
+		if requires, ok := vm.GetData("REQUIRE_" + u.String(request.Get("registerTag"))).([]string); ok {
+			for _, requireField := range requires {
+				if _, ok := args[requireField]; !ok {
+					failedFields = append(failedFields, requireField)
+				}
+			}
+		}
+		// 验证数据有效性
 		for k, v := range args {
 			if verifier, ok1 := verifies[k]; ok1 {
 				if !verifier(v, vm) {
@@ -510,6 +1068,15 @@ func runAction(action goja.Callable, vm *goja.Runtime, thisArg goja.Value, args
 		}
 	}
 
+	// force set userId to vm
+	vmUserId := "_guest"
+	if session != nil {
+		if userId, ok := session.data[serviceConfig.UserIdKey]; ok {
+			vmUserId = u.String(userId)
+		}
+	}
+	vm.SetData("userId", vmUserId)
+
 	requestParams, resp := makeRequestParams(args, headers, request, response, client, caller, session, logger)
 	var r any
 

service.ts

@@ -6,18 +6,25 @@ export default {
 	stop,
 	register,
 	load,
-    task,
+	// task,
 	newCaller,
-    dataSet,
+	// dataSet,
-    dataGet,
+	// dataGet,
-    dataKeys,
+	// dataKeys,
-    dataCount,
+	// dataCount,
-    dataFetch,
+	// dataFetch,
-    dataRemove,
+	// dataRemove,
-    listPush,
+	// listPush,
-    listPop,
+	// listPop,
-    listCount,
+	// listCount,
-    listRemove,
+	// listRemove,
+	id,
+	// idL,
+	// uniqueId,
+	// uniqueIdL,
+	// setTplFunc,
+	setTplReplaces,
+	tpl,
 }
 
 function config(config?: Config): void { }
@@ -26,24 +33,31 @@ function stop(): void { }
 function register(option: RegisterOption, callback: (params: RequestParams) => void): any { return null }
 function load(serviceFile: string, poolConfig?: PoolConfig): void { }
 
-function task(taskFile: string, interval: number = 1000): void { }
+// function task(taskFile: string, interval: number = 1000): void { }
 
 function newCaller(): Caller { return null as any }
 
-function dataSet(scope: string, key: string, value: any): void { }
+// function dataSet(scope: string, key: string, value: any): void { }
-function dataGet(scope: string, key: string): any { return null }
+// function dataGet(scope: string, key: string): any { return null }
-function dataKeys(scope: string): string[] { return [] }
+// function dataKeys(scope: string): string[] { return [] }
-function dataCount(scope: string): number { return 0 }
+// function dataCount(scope: string): number { return 0 }
-function dataFetch(scope: string): Map<string, any> { return null as any }
+// function dataFetch(scope: string): Map<string, any> { return null as any }
-function dataRemove(scope: string, key?: string): void { }
+// function dataRemove(scope: string, key?: string): void { }
 
-function listPush(scope: string, key: string, value: any): void { }
+// function listPush(scope: string, key: string, value: any): void { }
-function listPop(scope: string, key: string): any { return null }
+// function listPop(scope: string, key: string): any { return null }
-function listCount(scope: string): number { return 0 }
+// function listCount(scope: string): number { return 0 }
-function listRemove(scope: string): void { }
+// function listRemove(scope: string): void { }
+function id(size?: number): string { return '' }
+// function id(space: string, size?: number): string { return '' }
+// function idL(space: string, size?: number): string { return '' }
+// function uniqueId(size?: number): string { return '' }
+// function uniqueIdL(size?: number): string { return '' }
+// function setTplFunc(fnList: Object): void { }
+function setTplReplaces(replaces: Object): void { }
+function tpl(file: string, data: Object, fnList?: Object): string { return '' }
 
-
+export interface Config {
-interface Config {
 	// github.com/ssgo/s 的配置参数
 	listen: string                              // 监听端口（|隔开多个监听）（,隔开多个选项）（如果不指定IP则监听在0.0.0.0，如果不指定端口则使用h2c协议监听在随机端口，80端口默认使用http协议，443端口默认使用https协议），例如 80,http|443|443:h2|127.0.0.1:8080,h2c
 	ssl: Map<string, CertSet>                   // SSL证书配置，key为域名，value为cert和key的文件路径
@@ -74,8 +88,10 @@ interface Config {
 	cpuLimitTimes: number                       // CPU超过最高占用值超过次数（1-100）将报警（如果CpuMonitor开启的话），默认6（即30秒内连续6次）
 	memoryLimitTimes: number                    // 内存超过最高占用值超过次数（1-100）将报警（如果MemoryMonitor开启的话），默认6（即30秒内连续6次）
 	cookieScope: string                         // 启用Session时Cookie的有效范围，host|domain|topDomain，默认值为host
+	sessionWithoutCookie: boolean               // Session禁用Cookie保持，默认使用Cookie
+	deviceWithoutCookie: boolean                // 设备ID禁用Cookie保持，默认使用Cookie
 	idServer: string                            // 用s.UniqueId、s.Id来生成唯一ID（雪花算法）时所需的redis服务器连接，如果不指定将不能实现跨服务的全局唯一
-    keepKeyCase: boolean                        // 是否保持Key的首字母大小写？默认一律使用小写
+	keepKeyCase: boolean                        // 是否保持Key的首字母大小写？默认保持，设置为false则自动将首字母转为小写
 	indexFiles: string[]                        // 访问静态文件时的索引文件，默认为 index.html
 	indexDir: boolean                           // 访问目录时显示文件列表
 	readTimeout: number                         // 读取请求的超时时间，单位ms
@@ -95,7 +111,7 @@ interface Config {
 	sessionKey: string                          // HTTP头和Cookie中SessionID的Key，客户端没有传递时服务端自动生成，Header的优先级高于Cookie，默认为 Session, 设置为空时表示不使用
 	deviceKey: string                           // 标识设备ID的Key，客户端没有传递时服务端自动生成，Header的优先级高于Cookie，默认为 Device， 设置为空时表示不使用
 	clientKey: string                           // 标识客户端的Key，默认为 Client，对应的Header头为 ClientName 和 ClientVersion
-    userIdKey: string                           // session中userID的Key，用于在日志中记录userId信息，默认为 userId
+	userIdKey: string                           // session中userID的Key，用于在日志中记录用户ID信息，默认为 id
 	sessionProvider: string                     // 指定一个redis连接（例如：redis://:sskey加密的密码@127.0.0.1:6379/15），默认使用内存存储
 	sessionTimeout: number                      // session过期时间，单位 秒，默认为 3600秒
 	authFieldMessage: string | Object           // 身份验证失败时的消息，默认为 auth failed，可以设置对象来返回JSON，可以使用模版 {{TARGET_AUTHLEVEL}}、{{USER_AUTHLEVEL}}
@@ -103,6 +119,8 @@ interface Config {
 	limitedMessage: string | Object             // 访问受限时的消息，默认为 too many requests，可以设置对象来返回JSON，可以使用模版 {{LIMITED_FROM}}、{{LIMITED_VALUE}}
 	limiterRedis: string                        // 限流器使用的Redis连接，默认使用内存存储
 	limiters: Map<string, LimiterConfig>        // 限流器配置，from 为数据来源，例如：ip、user、device、header.User-Agent、in.phone 等（in表示从请求参数中获取），time为时间间隔，单位ms，times为 时间间隔内允许访问的次数
+	hotLoad: number                             // 热加载配置，单位s，默认值：0，0表示不检测热加载
+	tplSafePaths: string[]                      // 模板文件的安全路径，默认不开启安全检查
 
 	// gateway 的配置参数
 	proxy: Map<string, string>                  // 代理配置，key为[host][path]，value为代理的目标应用或URL
@@ -119,24 +137,24 @@ interface Config {
 	ipPrefix: string                            // discover服务发现时指定使用的IP网段，默认排除 172.17.（Docker）
 }
 
-interface CertSet {
+export interface CertSet {
 	certFile: string
 	keyFile: string
 }
 
-interface PoolConfig {
+export interface PoolConfig {
 	min: number
 	max: string
 	idle: number
 }
 
-interface LimiterConfig {
+export interface LimiterConfig {
 	from: string
 	time: number
 	times: number
 }
 
-interface RegisterOption {
+export interface RegisterOption {
 	authLevel: number
 	host: string
 	method: string
@@ -145,11 +163,14 @@ interface RegisterOption {
 	noBody: boolean
 	noLog200: boolean
 	limiters: string[]
+	verifies: Object
+	requires: string[]
+	ext: Object
 	onMessage: (params: OnMessageParams) => void
 	onClose: (params: RequestParams) => void
 }
 
-interface RequestParams {
+export interface RequestParams {
 	args: Object
 	headers: Object
 	request: Request
@@ -160,7 +181,7 @@ interface RequestParams {
 	logger: Logger
 }
 
-interface OnMessageParams {
+export interface OnMessageParams {
 	type: string
 	data: string | Object
 	client: WSClient
@@ -168,7 +189,7 @@ interface OnMessageParams {
 	logger: Logger
 }
 
-interface WSClient {
+export interface WSClient {
 	id: string
 	read: () => WSMessage
 	write: (data: any) => void
@@ -177,12 +198,12 @@ interface WSClient {
 	close: () => void
 }
 
-interface WSMessage {
+export interface WSMessage {
 	type: string
 	data: string | Object
 }
 
-interface Session {
+export interface Session {
 	set: (key: string | Object, value?: any) => void
 	get: (...keys: string[]) => any | Object
 	remove: (...keys: string[]) => void
@@ -190,7 +211,7 @@ interface Session {
 	save: () => void
 }
 
-interface Caller {
+export interface Caller {
 	get(url: string, headers?: Object): Result
 	head(url: string, headers?: Object): Result
 	post(url: string, data: any, headers?: Object): Result
@@ -199,7 +220,7 @@ interface Caller {
 	do(method: string, url: string, data: any, callback?: (data: string) => void, headers?: Object): Result
 }
 
-interface Result {
+export interface Result {
 	status: string
 	statusCode: number
 	headers: Object
@@ -208,7 +229,7 @@ interface Result {
 	object(): Object
 }
 
-interface CookieOption {
+export interface CookieOption {
 	path: string
 	domain: string
 	expires: any
@@ -217,7 +238,7 @@ interface CookieOption {
 	httpOnly: boolean
 }
 
-interface Request {
+export interface Request {
 	id: string
 	proto: string
 	scheme: string
@@ -246,7 +267,7 @@ interface Request {
 	setUserID: (id: string) => void
 }
 
-interface Response {
+export interface Response {
 	id: string
 	setStatus: (code: number) => void
 	setCookie: (name: string, value: string, option?: CookieOption) => void
@@ -258,16 +279,17 @@ interface Response {
 	sendFile: (contentType: string, filename: string) => void
 	downloadFile: (contentType: string, filename: string, data: any) => void
 	location: (url: string) => void
+	end: (data: any) => void
 }
 
-interface Logger {
+export interface Logger {
 	debug: (message: string, info?: Object) => void
 	info: (message: string, info?: Object) => void
 	warn: (message: string, info?: Object) => void
 	error: (message: string, info?: Object) => void
 }
 
-interface UploadFile {
+export interface UploadFile {
 	name: string
 	size: number
 	data: any

session.go

@@ -2,6 +2,7 @@ package service
 
 import (
 	"reflect"
+	"strings"
 	"sync"
 	"time"
 
@@ -9,12 +10,14 @@ import (
 	"apigo.cc/gojs/goja"
 	"github.com/ssgo/log"
 	"github.com/ssgo/redis"
+	"github.com/ssgo/u"
 )
 
 type Session struct {
 	id            string
 	conn          *redis.Redis
 	data          map[string]any
+	funcAuthCache map[string]bool
 }
 
 var sessionRedis *redis.Redis
@@ -43,6 +46,7 @@ func NewSession(id string, logger *log.Logger) *Session {
 		id:            id,
 		conn:          conn,
 		data:          data,
+		funcAuthCache: map[string]bool{},
 	}
 }
 
@@ -102,6 +106,73 @@ func (session *Session) SetAuthLevel(argsIn goja.FunctionCall, vm *goja.Runtime)
 	return nil
 }
 
+func (session *Session) authFuncs(needFuncs []string) bool {
+	cacheKey := strings.Join(needFuncs, "; ")
+	if cachedResult, ok := session.funcAuthCache[cacheKey]; ok {
+		return cachedResult
+	}
+
+	normalAuthOk := 0
+	requiredAuthTotal := 0
+	requiredAuthOk := 0
+	isOk := false
+	if userFuncs, ok := session.data["funcs"].([]string); ok && len(userFuncs) > 0 {
+		if u.StringIn(userFuncs, "system.superAdmin.") {
+			isOk = true
+		} else {
+			// 统计必须有几个权限
+			for _, needFunc := range needFuncs {
+				if needFunc[0] == '&' {
+					requiredAuthTotal++
+				}
+			}
+
+			// 检查是否有匹配的权限（左匹配）
+			for _, needFunc := range needFuncs {
+				isRequired := false
+				if needFunc[0] == '&' {
+					// 必须有此权限
+					isRequired = true
+					needFunc = needFunc[1:]
+				}
+				for _, userFunc := range userFuncs {
+					if strings.HasPrefix(userFunc, needFunc) {
+						// 匹配成功
+						if isRequired {
+							// 必须有此权限并且匹配成功
+							requiredAuthOk++
+						} else {
+							// 普通权限匹配成功
+							normalAuthOk++
+						}
+						break
+					}
+				}
+				if normalAuthOk > 0 && requiredAuthOk == requiredAuthTotal {
+					// 普通权限匹配成功，并且必须有权限也匹配成功，直接返回
+					isOk = true
+					break
+				}
+			}
+		}
+	}
+	session.funcAuthCache[cacheKey] = isOk
+	return isOk
+}
+
+func (session *Session) AuthFuncs(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
+	args := gojs.MakeArgs(&argsIn, vm).Check(1)
+	var needFuncs []string
+	if args.Arguments[0].ExportType().Kind() == reflect.Slice {
+		// 第一个参数是数组
+		needFuncs = args.Arr(0).StrArray(0)
+	} else {
+		// 平铺的参数
+		needFuncs = args.StrArray(0)
+	}
+	return vm.ToValue(session.authFuncs(needFuncs))
+}
+
 func (session *Session) Save(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
 	if session.conn == nil {
 		now := time.Now().Unix()

task.go

@@ -1,162 +1,165 @@
 package service
 
-import (
+// type Task struct {
-	"container/list"
+// 	spec  string
-	"sync"
+// 	file  string
+// 	vm    *gojs.Runtime
+// 	lock  sync.RWMutex
+// 	mtime time.Time
+// 	// policy  string
+// }
+// var tasks []Task
+// var tasksLock = sync.RWMutex{}
 
-	"apigo.cc/gojs"
+// var taskData = map[string]map[string]any{}
-	"apigo.cc/gojs/goja"
+// var taskDataLock = sync.RWMutex{}
-)
 
-var taskData = map[string]map[string]any{}
+// var taskList = map[string]*list.List{}
-var taskDataLock = sync.RWMutex{}
+// var taskListLock = sync.RWMutex{}
 
-var taskList = map[string]*list.List{}
+// func DataSet(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
-var taskListLock = sync.RWMutex{}
+// 	args := gojs.MakeArgs(&argsIn, vm).Check(3)
+// 	scope := args.Str(0)
+// 	key := args.Str(1)
+// 	value := args.Any(2)
+// 	taskDataLock.Lock()
+// 	defer taskDataLock.Unlock()
+// 	if taskData[scope] == nil {
+// 		taskData[scope] = map[string]any{}
+// 	}
+// 	taskData[scope][key] = value
+// 	return nil
+// }
 
-func DataSet(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
+// func DataGet(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
-	args := gojs.MakeArgs(&argsIn, vm).Check(3)
+// 	args := gojs.MakeArgs(&argsIn, vm).Check(2)
-	scope := args.Str(0)
+// 	scope := args.Str(0)
-	key := args.Str(1)
+// 	key := args.Str(1)
-	value := args.Any(2)
+// 	taskDataLock.RLock()
-	taskDataLock.Lock()
+// 	defer taskDataLock.RUnlock()
-	defer taskDataLock.Unlock()
+// 	if taskData[scope] != nil {
-	if taskData[scope] == nil {
+// 		return vm.ToValue(taskData[scope][key])
-		taskData[scope] = map[string]any{}
+// 	}
-	}
+// 	return nil
-	taskData[scope][key] = value
+// }
-	return nil
-}
 
-func DataGet(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
+// func DataKeys(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
-	args := gojs.MakeArgs(&argsIn, vm).Check(2)
+// 	args := gojs.MakeArgs(&argsIn, vm).Check(1)
-	scope := args.Str(0)
+// 	scope := args.Str(0)
-	key := args.Str(1)
+// 	taskDataLock.RLock()
-	taskDataLock.RLock()
+// 	defer taskDataLock.RUnlock()
-	defer taskDataLock.RUnlock()
+// 	if taskData[scope] != nil {
-	if taskData[scope] != nil {
+// 		keys := make([]string, len(taskData[scope]))
-		return vm.ToValue(taskData[scope][key])
+// 		i := 0
-	}
+// 		for key := range taskData[scope] {
-	return nil
+// 			keys[i] = key
-}
+// 			i++
+// 		}
+// 		return vm.ToValue(keys)
+// 	}
+// 	return nil
+// }
 
-func DataKeys(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
+// func DataCount(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
-	args := gojs.MakeArgs(&argsIn, vm).Check(1)
+// 	args := gojs.MakeArgs(&argsIn, vm).Check(1)
-	scope := args.Str(0)
+// 	scope := args.Str(0)
-	taskDataLock.RLock()
+// 	taskDataLock.RLock()
-	defer taskDataLock.RUnlock()
+// 	defer taskDataLock.RUnlock()
-	if taskData[scope] != nil {
+// 	if taskData[scope] != nil {
-		keys := make([]string, len(taskData[scope]))
+// 		return vm.ToValue(len(taskData[scope]))
-		i := 0
+// 	}
-		for key := range taskData[scope] {
+// 	return vm.ToValue(0)
-			keys[i] = key
+// }
-			i++
-		}
-		return vm.ToValue(keys)
-	}
-	return nil
-}
 
-func DataCount(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
+// func DataFetch(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
-	args := gojs.MakeArgs(&argsIn, vm).Check(1)
+// 	args := gojs.MakeArgs(&argsIn, vm).Check(1)
-	scope := args.Str(0)
+// 	scope := args.Str(0)
-	taskDataLock.RLock()
+// 	taskDataLock.RLock()
-	defer taskDataLock.RUnlock()
+// 	defer taskDataLock.RUnlock()
-	if taskData[scope] != nil {
+// 	if taskData[scope] != nil {
-		return vm.ToValue(len(taskData[scope]))
+// 		all := make(map[string]any)
-	}
+// 		for k, v := range taskData[scope] {
-	return vm.ToValue(0)
+// 			all[k] = v
-}
+// 		}
+// 		return vm.ToValue(all)
+// 	}
+// 	return nil
+// }
 
-func DataFetch(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
+// func DataRemove(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
-	args := gojs.MakeArgs(&argsIn, vm).Check(1)
+// 	args := gojs.MakeArgs(&argsIn, vm).Check(1)
-	scope := args.Str(0)
+// 	scope := args.Str(0)
-	taskDataLock.RLock()
+// 	key := args.Str(1)
-	defer taskDataLock.RUnlock()
+// 	taskDataLock.Lock()
-	if taskData[scope] != nil {
+// 	defer taskDataLock.Unlock()
-		all := make(map[string]any)
+// 	if taskData[scope] != nil {
-		for k, v := range taskData[scope] {
+// 		if key != "" {
-			all[k] = v
+// 			delete(taskData[scope], key)
-		}
+// 		} else {
-		return vm.ToValue(all)
+// 			delete(taskData, scope)
-	}
+// 		}
-	return nil
+// 	}
-}
+// 	return nil
+// }
 
-func DataRemove(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
+// func ListPush(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
-	args := gojs.MakeArgs(&argsIn, vm).Check(1)
+// 	args := gojs.MakeArgs(&argsIn, vm).Check(2)
-	scope := args.Str(0)
+// 	scope := args.Str(0)
-	key := args.Str(1)
+// 	value := args.Any(1)
-	taskDataLock.Lock()
+// 	fromHead := args.Bool(2)
-	defer taskDataLock.Unlock()
+// 	taskListLock.Lock()
-	if taskData[scope] != nil {
+// 	defer taskListLock.Unlock()
-		if key != "" {
+// 	list1 := taskList[scope]
-			delete(taskData[scope], key)
+// 	if list1 == nil {
-		} else {
+// 		list1 = list.New()
-			delete(taskData, scope)
+// 		taskList[scope] = list1
-		}
+// 	}
-	}
+// 	if fromHead {
-	return nil
+// 		list1.PushFront(value)
-}
+// 	} else {
+// 		list1.PushBack(value)
+// 	}
+// 	return nil
+// }
 
-func ListPush(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
+// func ListPop(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
-	args := gojs.MakeArgs(&argsIn, vm).Check(2)
+// 	args := gojs.MakeArgs(&argsIn, vm).Check(1)
-	scope := args.Str(0)
+// 	scope := args.Str(0)
-	value := args.Any(1)
+// 	fromEnd := args.Bool(1)
-	fromHead := args.Bool(2)
+// 	taskListLock.Lock()
-	taskListLock.Lock()
+// 	var item *list.Element
-	defer taskListLock.Unlock()
+// 	defer taskListLock.Unlock()
-	list1 := taskList[scope]
+// 	list1 := taskList[scope]
-	if list1 == nil {
+// 	if list1 != nil {
-		list1 = list.New()
+// 		if fromEnd {
-		taskList[scope] = list1
+// 			item = list1.Front()
-	}
+// 		} else {
-	if fromHead {
+// 			item = list1.Back()
-		list1.PushFront(value)
+// 		}
-	} else {
+// 		if item != nil {
-		list1.PushBack(value)
+// 			list1.Remove(item)
-	}
+// 			return vm.ToValue(item.Value)
-	return nil
+// 		}
-}
+// 	}
+// 	return nil
+// }
 
-func ListPop(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
+// func ListCount(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
-	args := gojs.MakeArgs(&argsIn, vm).Check(1)
+// 	args := gojs.MakeArgs(&argsIn, vm).Check(1)
-	scope := args.Str(0)
+// 	scope := args.Str(0)
-	fromEnd := args.Bool(1)
+// 	taskListLock.RLock()
-	taskListLock.Lock()
+// 	defer taskListLock.RUnlock()
-	var item *list.Element
+// 	if taskList[scope] != nil {
-	defer taskListLock.Unlock()
+// 		return vm.ToValue(taskList[scope].Len())
-	list1 := taskList[scope]
+// 	}
-	if list1 != nil {
+// 	return vm.ToValue(0)
-		if fromEnd {
+// }
-			item = list1.Front()
-		} else {
-			item = list1.Back()
-		}
-		if item != nil {
-			list1.Remove(item)
-			return vm.ToValue(item.Value)
-		}
-	}
-	return nil
-}
 
-func ListCount(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
+// func ListRemove(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
-	args := gojs.MakeArgs(&argsIn, vm).Check(1)
+// 	args := gojs.MakeArgs(&argsIn, vm).Check(1)
-	scope := args.Str(0)
+// 	scope := args.Str(0)
-	taskListLock.RLock()
+// 	taskListLock.Lock()
-	defer taskListLock.RUnlock()
+// 	defer taskListLock.Unlock()
-	if taskList[scope] != nil {
+// 	delete(taskList, scope)
-		return vm.ToValue(taskList[scope].Len())
+// 	return nil
-	}
+// }
-	return vm.ToValue(0)
-}
-
-func ListRemove(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
-	args := gojs.MakeArgs(&argsIn, vm).Check(1)
-	scope := args.Str(0)
-	taskListLock.Lock()
-	defer taskListLock.Unlock()
-	delete(taskList, scope)
-	return nil
-}

tests/api/echo.js

@@ -1,13 +1,12 @@
 import service from "apigo.cc/gojs/service"
-import co from "apigo.cc/gojs/console"
+import rt from "apigo.cc/gojs/runtime"
-import u from "apigo.cc/gojs/util"
 
 function main() {
     service.register({ path: '/echo2', noLog200: true }, ({ args, response }) => {
         // setTimeout(() => {
         //     response.end(args.name)
         // }, 10)
-        u.sleep(10)
+        rt.sleep(10)
         return args.name
     })
 }

tests/api/ws.js

@@ -1,5 +1,6 @@
 import s from "apigo.cc/gojs/service"
 import co from "apigo.cc/gojs/console"
+import task from "apigo.cc/gojs/task"
 
 function main() {
     s.register({
@@ -9,11 +10,13 @@ function main() {
         },
         onClose: ({ client }) => {
             co.info('ws closed', client.id)
-            s.dataRemove('wsTest', client.id)
+            // s.dataRemove('wsTest', client.id)
+            task.remove('wsTest_' + client.id)
         }
     }, ({ client }) => {
         co.info('ws connected', client.id)
-        s.dataSet('wsTest', client.id, client)
+        // s.dataSet('wsTest', client.id, client)
+        task.set('wsTest_' + client.id, client)
         client.write('Hello, World!')
     })
 }

tests/service_pool_test.go

@@ -2,12 +2,14 @@ package service_test
 
 import (
 	"fmt"
+	"os"
 	"sync"
 	"time"
 
 	"apigo.cc/gojs"
 	_ "apigo.cc/gojs/console"
 	_ "apigo.cc/gojs/http"
+	_ "apigo.cc/gojs/runtime"
 	"apigo.cc/gojs/service"
 	_ "apigo.cc/gojs/service"
 	_ "apigo.cc/gojs/util"
@@ -38,6 +40,7 @@ func TestStartByPool(t *testing.T) {
 
 	gojs.ExportForDev()
 	rt2 = gojs.New()
+	u.CopyFile("api/echo.js", "api/echo_tmp.js")
 	err := rt2.StartFromFile("start.js")
 	if err != nil {
 		t.Fatal("start failed", err)
@@ -216,7 +219,7 @@ func TestStopByPool(t *testing.T) {
 		t.Fatal("stop failed", err)
 	}
 	gojs.WaitAll()
-
+	os.Remove("api/echo_tmp.js")
 	runtime.GC()
 	ms3 := runtime.MemStats{}
 	runtime.ReadMemStats(&ms3)

tests/service_test.go

@@ -1,14 +1,20 @@
 package service_test
 
 import (
+	"fmt"
+	"os"
+	"strings"
 	"testing"
 	"time"
 
 	"apigo.cc/gojs"
 	_ "apigo.cc/gojs/console"
+	_ "apigo.cc/gojs/file"
 	_ "apigo.cc/gojs/http"
+	_ "apigo.cc/gojs/runtime"
 	_ "apigo.cc/gojs/service"
 	_ "apigo.cc/gojs/util"
+	"github.com/ssgo/httpclient"
 	"github.com/ssgo/u"
 )
 
@@ -20,6 +26,7 @@ const runTimes = 100
 func TestStart(t *testing.T) {
 	gojs.ExportForDev()
 	rt = gojs.New()
+	u.CopyFile("api/echo.js", "api/echo_tmp.js")
 	err := rt.StartFromFile("start.js")
 	if err != nil {
 		t.Fatal("start failed", err)
@@ -41,80 +48,106 @@ func TestStatic(t *testing.T) {
 	}
 }
 
-// func TestJsEcho(t *testing.T) {
+func TestJsEcho(t *testing.T) {
-// 	for i := 0; i < runTimes; i++ {
+	for i := 0; i < runTimes; i++ {
-// 		name := u.UniqueId()
+		name := u.UniqueId()
-// 		r, err := rt.RunCode("test('" + name + "')")
+		r, err := rt.RunCode("test('" + name + "')")
-// 		if err != nil {
+		if err != nil {
-// 			t.Fatal("test js get failed, got error", err)
+			t.Fatal("test js get failed, got error", err)
-// 		} else if r != name {
+		} else if r != name {
-// 			t.Fatal("test js get failed, name not match", r, name)
+			t.Fatal("test js get failed, name not match", r, name)
-// 		}
+		}
-// 	}
+	}
-// }
+}
 
-// func TestGoEcho(t *testing.T) {
+func TestJsEcho2(t *testing.T) {
-// 	hc := httpclient.GetClientH2C(0)
+	for i := 0; i < runTimes; i++ {
-// 	for i := 0; i < runTimes; i++ {
+		name := u.UniqueId()
-// 		name := u.UniqueId()
+		r, err := rt.RunCode("test2('" + name + "')")
-// 		r := hc.Get("http://" + addr + "/echo?name=" + name)
+		if err != nil {
-// 		if r.Error != nil {
+			t.Fatal("test2 js get failed, got error", err)
-// 			t.Fatal("test go get failed, got error", r.Error)
+		} else if r != name {
-// 		} else if r.String() != name {
+			t.Fatal("test2 js get failed, name not match", r, name)
-// 			t.Fatal("test go get failed, name not match", r, name)
+		}
-// 		}
+	}
-// 	}
+	u.WriteFile("api/echo_tmp.js", strings.Replace(u.ReadFileN("api/echo.js"), "return args.name", "return args.name+'!!'", 1))
-// }
+}
 
-// func TestJsAsyncEcho(t *testing.T) {
+func TestGoEcho(t *testing.T) {
-// 	ch := make(chan bool, runTimes)
+	hc := httpclient.GetClientH2C(0)
-// 	t1 := time.Now().UnixMilli()
+	for i := 0; i < runTimes; i++ {
-// 	for i := 0; i < runTimes; i++ {
+		name := u.UniqueId()
-// 		go func() {
+		r := hc.Get("http://" + addr + "/echo?name=" + name)
-// 			name := u.UniqueId()
+		if r.Error != nil {
-// 			r, err := rt.RunCode("test('" + name + "')")
+			t.Fatal("test go get failed, got error", r.Error)
-// 			ch <- true
+		} else if r.String() != name {
-// 			if err != nil {
+			t.Fatal("test go get failed, name not match", r, name)
-// 				t.Fatal("test js async get failed, got error", err)
+		}
-// 			} else if r != name {
+	}
-// 				t.Fatal("test js async get failed, name not match", r, name)
+}
-// 			}
-// 		}()
-// 	}
-// 	for i := 0; i < runTimes; i++ {
-// 		<-ch
-// 	}
-// 	t2 := time.Now().UnixMilli() - t1
-// 	fmt.Println(u.BGreen("js async test time:"), t2, "ms")
-// }
 
-// func TestGoAsyncEcho(t *testing.T) {
+func TestJsAsyncEcho(t *testing.T) {
-// 	hc := httpclient.GetClientH2C(0)
+	ch := make(chan bool, runTimes)
-// 	ch := make(chan bool, runTimes*10)
+	t1 := time.Now().UnixMilli()
-// 	t1 := time.Now().UnixMilli()
+	for i := 0; i < runTimes; i++ {
-// 	lastName := ""
+		go func() {
-// 	lastResult := ""
+			name := u.UniqueId()
-// 	for i := 0; i < runTimes*10; i++ {
+			r, err := rt.RunCode("test('" + name + "')")
-// 		name := fmt.Sprint("N", i)
+			ch <- true
-// 		lastName = name
+			if err != nil {
-// 		go func() {
+				t.Fatal("test js async get failed, got error", err)
-// 			r := hc.Get("http://" + addr + "/echo?name=" + name)
+			} else if r != name {
-// 			lastResult = r.String()
+				t.Fatal("test js async get failed, name not match", r, name)
-// 			ch <- true
+			}
-// 			if r.Error != nil {
+		}()
-// 				t.Fatal("test go async get failed, got error", r.Error)
+	}
-// 			} else if r.String() != name {
+	for i := 0; i < runTimes; i++ {
-// 				t.Fatal("test go async get failed, name not match", r, name)
+		<-ch
-// 			}
+	}
-// 		}()
+	t2 := time.Now().UnixMilli() - t1
-// 	}
+	fmt.Println(u.BGreen("js async test time:"), t2, "ms")
-// 	for i := 0; i < runTimes*10; i++ {
+}
-// 		<-ch
+
-// 	}
+func TestGoAsyncEcho(t *testing.T) {
-// 	t2 := time.Now().UnixMilli() - t1
+	hc := httpclient.GetClientH2C(0)
-// 	fmt.Println(u.BGreen("go async test time:"), t2, "ms")
+	ch := make(chan bool, runTimes*10)
-// 	fmt.Println(u.BGreen("last name:"), lastName, lastResult)
+	t1 := time.Now().UnixMilli()
-// }
+	lastName := ""
+	lastResult := ""
+	for i := 0; i < runTimes*10; i++ {
+		name := fmt.Sprint("N", i)
+		lastName = name
+		go func() {
+			r := hc.Get("http://" + addr + "/echo?name=" + name)
+			lastResult = r.String()
+			ch <- true
+			if r.Error != nil {
+				t.Fatal("test go async get failed, got error", r.Error)
+			} else if r.String() != name {
+				t.Fatal("test go async get failed, name not match", r, name)
+			}
+		}()
+	}
+	for i := 0; i < runTimes*10; i++ {
+		<-ch
+	}
+	t2 := time.Now().UnixMilli() - t1
+	fmt.Println(u.BGreen("go async test time:"), t2, "ms")
+	fmt.Println(u.BGreen("last name:"), lastName, lastResult)
+}
+
+func TestJsEcho2WithHotLoad(t *testing.T) {
+	time.Sleep(time.Second)
+	for i := 0; i < runTimes; i++ {
+		name := u.UniqueId()
+		r, err := rt.RunCode("test2('" + name + "')")
+		if err != nil {
+			t.Fatal("test2 js get failed, got error", err)
+		} else if r != name+"!!" {
+			t.Fatal("test2 js get failed, name not match", r, name)
+		}
+	}
+}
 
 func TestStop(t *testing.T) {
 	go func() {
@@ -123,6 +156,7 @@ func TestStop(t *testing.T) {
 	}()
 	gojs.WaitAll()
 	time.Sleep(100 * time.Millisecond)
+	os.Remove("api/echo_tmp.js")
 	// if err != nil {
 	// 	t.Fatal("stop failed", err)
 	// }

tests/service_ws_test.go

@@ -6,7 +6,9 @@ import (
 	"apigo.cc/gojs"
 	_ "apigo.cc/gojs/console"
 	_ "apigo.cc/gojs/http"
+	_ "apigo.cc/gojs/runtime"
 	_ "apigo.cc/gojs/service"
+	_ "apigo.cc/gojs/task"
 	_ "apigo.cc/gojs/util"
 	"github.com/ssgo/u"
 
@@ -43,7 +45,9 @@ func TestWS(t *testing.T) {
 }
 
 func TestStopWSByPool(t *testing.T) {
-	_, err := rt3.RunCode("s.stop()")
+	fmt.Println(u.BGreen("stop ws"))
+	_, err := rt3.RunCode("s.stop();task.stop();")
+	fmt.Println(u.BGreen("stop ws ok"), err)
 	if err != nil {
 		t.Fatal("stop failed", err)
 	}

tests/start.js

@@ -1,7 +1,8 @@
 import s from "apigo.cc/gojs/service"
 import http from "apigo.cc/gojs/http"
-import u from "apigo.cc/gojs/util"
+import rt from "apigo.cc/gojs/runtime"
 import co from "apigo.cc/gojs/console"
+import file from "apigo.cc/gojs/file"
 
 let h2c = http
 let urlPrefix
@@ -33,16 +34,17 @@ function main() {
         },
         rewrite: {
             '/echo2.js': '/echo.js'
-        }
+        },
+        hotLoad: 1,
     })
     s.register({ path: '/echo', noLog200: true }, ({ args, response }) => {
         // setTimeout(() => {
         //     response.end(args.name)
         // }, 1)
-        u.sleep(1)
+        rt.sleep(1)
         return args.name
     })
-    s.load('api/echo.js', { min: 20, max: 1000, idle: 100 })
+    s.load('api/echo_tmp.js', { min: 20, max: 1000, idle: 100 })
     s.load('api/user.js')
     let host = s.start()
     h2c = http.newH2C({
@@ -89,7 +91,7 @@ function testUser() {
         if (r.statusCode != 429) {
             return r
         }
-        u.sleep(100)
+        rt.sleep(100)
 
         // 测试限流器过期后允许的 1 次请求
         r = h2c.get('/userInfo').object()

tests/start_ws.js

@@ -1,13 +1,16 @@
 import s from "apigo.cc/gojs/service"
 import http from "apigo.cc/gojs/http"
-import u from "apigo.cc/gojs/util"
+import rt from "apigo.cc/gojs/runtime"
 import co from "apigo.cc/gojs/console"
+import task from "apigo.cc/gojs/task"
 
 let hc = http
 let urlPrefix
 function main() {
     s.load('api/ws.js')
-    s.task('task.js', 100)
+    // s.task('task.js', 100)
+    task.addTask("@every 1s", 'task.js')
+    task.start()
     let host = s.start()
     hc = http.new({ baseURL: 'http://' + host })
     return host
@@ -31,7 +34,7 @@ function testWS() {
     co.info('test ws abc ok')
 
     // ws.ping()
-    u.sleep(10)
+    rt.sleep(10)
 
     let pc = ws.pingCount()
     co.info('test ws ping ok', pc.pingTimes, pc.pongTimes)
@@ -51,15 +54,13 @@ function testWS() {
         return r
     }
     co.info('test ws json ok')
-
+    rt.sleep(2000)
-    u.sleep(1000)
     for (let i = 0; i < 5; i++) {
         let j = ws.read()
         if (i !== j.data) {
             return j
         }
     }
-
     ws.close()
     return true
 }

tests/task.js

@@ -1,5 +1,6 @@
 import s from 'apigo.cc/gojs/service'
 import co from 'apigo.cc/gojs/console'
+import task from 'apigo.cc/gojs/task'
 
 function onStart() {
 	co.info('task start')
@@ -7,24 +8,24 @@ function onStart() {
 
 let i = 0
 function onRun() {
-    let connCount = s.dataCount('wsTest')
+	let keys = task.keys('wsTest_')
-    if (connCount > 0) {
+	// let connCount = s.dataCount('wsTest')
-        let conns = s.dataFetch('wsTest')
+	if (keys.length > 0) {
+		// let conns = s.dataFetch('wsTest')
+		let conns = task.getAll('wsTest_')
 		for (let id in conns) {
 			let conn = conns[id]
-            try {
+			if (!conn.write(i++)) {
-                conn.write(i++)
+				task.remove(id)
-            } catch (e) {
-                co.error(e)
-                s.dataRemove('wsTest', id)
 			}
 		}
 	}
-    co.info('task run', connCount)
+	co.info('task run', keys.length)
 }
 
 
 function onStop() {
-    s.dataRemove('wsTest')
+	// s.dataRemove('wsTest')
-    co.info('task stop', s.dataCount('wsTest'))
+	task.removeAll('wsTest_')
+	co.info('task stop')
 }

tests/tpl.js

@@ -0,0 +1,7 @@
+import s from "apigo.cc/gojs/service"
+
+function main(args) {
+	return s.tpl('tpl/page.html', { title: 'Abc' }, {
+		bb: text => { return '<b>' + text + '</b>' }
+	})
+}

tests/tpl/header.html

@@ -0,0 +1,3 @@
+<header>
+	<h1>Welcome to {{bb .title}}</h1>
+</header>

tests/tpl/page.html

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<meta http-equiv="X-UA-Compatible" content="ie=edge">
+	<title>{{.title}}</title>
+</head>
+
+<body>
+	{{template "header.html" .}}
+	<pre>
+      hello world
+    </pre>
+</body>
+
+</html>

tests/tpl_test.go

@@ -0,0 +1,20 @@
+package service_test
+
+import (
+	"strings"
+	"testing"
+
+	"apigo.cc/gojs"
+	_ "apigo.cc/gojs/service"
+	"github.com/ssgo/u"
+)
+
+func TestTpl(t *testing.T) {
+	r, err := gojs.RunFile("tpl.js")
+	if err != nil {
+		t.Fatal("test static failed, got error", err)
+	}
+	if !strings.Contains(u.String(r), "<h1>Welcome to <b>Abc</b></h1>") {
+		t.Fatal("test tpl failed, name not match", r)
+	}
+}

ws.go

@@ -18,7 +18,10 @@ func MakeWSClient(client *websocket.Conn, id string) gojs.Map {
 		"read": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
 			typ, data, err := readWSMessage(client)
 			if err != nil {
-				panic(vm.NewGoError(err))
+				// panic(vm.NewGoError(err))
+				vm.SetData("_lastError", err)
+				gojs.GetLogger(vm).Error(err.Error())
+				return vm.ToValue(false)
 			}
 			return vm.ToValue(gojs.Map{
 				"type": typ,
@@ -37,16 +40,22 @@ func MakeWSClient(client *websocket.Conn, id string) gojs.Map {
 				err = client.WriteMessage(websocket.TextMessage, u.JsonBytes(args.Any(0)))
 			}
 			if err != nil {
-				panic(vm.NewGoError(err))
+				// panic(vm.NewGoError(err))
+				vm.SetData("_lastError", err)
+				gojs.GetLogger(vm).Error(err.Error())
+				return vm.ToValue(false)
 			}
-			return nil
+			return vm.ToValue(true)
 		},
 		"ping": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
 			err := client.WriteMessage(websocket.PingMessage, nil)
 			if err != nil {
-				panic(vm.NewGoError(err))
+				// panic(vm.NewGoError(err))
+				vm.SetData("_lastError", err)
+				gojs.GetLogger(vm).Error(err.Error())
+				return vm.ToValue(false)
 			}
-			return nil
+			return vm.ToValue(true)
 		},
 		"writeMessage": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
 			args := gojs.MakeArgs(&argsIn, vm).Check(2)
@@ -68,16 +77,22 @@ func MakeWSClient(client *websocket.Conn, id string) gojs.Map {
 				err = client.WriteMessage(websocket.TextMessage, args.Bytes(1))
 			}
 			if err != nil {
-				panic(vm.NewGoError(err))
+				// panic(vm.NewGoError(err))
+				vm.SetData("_lastError", err)
+				gojs.GetLogger(vm).Error(err.Error())
+				return vm.ToValue(false)
 			}
-			return nil
+			return vm.ToValue(true)
 		},
 		"close": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
 			err := client.Close()
 			if err != nil {
-				panic(vm.NewGoError(err))
+				// panic(vm.NewGoError(err))
+				vm.SetData("_lastError", err)
+				gojs.GetLogger(vm).Error(err.Error())
+				return vm.ToValue(false)
 			}
-			return nil
+			return vm.ToValue(true)
 		},
 	}
 }