refactor: 文件按主类型划分，一个 struct 一个功能
约定：文件名 = 主类型名；同一个类型要拆多个文件时用 类型_子项.go。
engine.go 355 → 231 行。原来混了三件不相干的事
engine_globals.go ← bind / lazyGlobal / freeze / defineReadOnly（96 行）
它是「Go 值 → 只读 JS 全局」的转换层，跟脚本缓存毫无关系
engine_console.go ← console.go，跟上面是同一主题
script.go 325 → 100 行，只留公开方法
script_vm.go ← VM 的取、还、装载。上个 commit 合一的三条路径现在住一起
script_static.go ← static.go
errors.go 364 → 150 行
errors_goja.go ← goja 错误的翻译层
errors_hints.go ← missingGlobalHint，一份 JS 运行时知识库，跟错误分类是
两回事；拆出来之后 missing_global_test.go 才有对应源文件
bundle_finalize.go ← esmwrap.go
bundle.go 收下 validIdent / hashVersion（原来住在 engine.go）
Engine.New 原来排在所有私有函数之后，挪到导出方法那一段。
classify 83 → 54 行：四个 errors.As 分支各手搓一个 8 字段的 &Error{}，脚本上下文
那三行重复了 4 遍，抽出 gojaError 构造器。
顺带修四处注释漂移：
Session/会话 代码里叫 Instance，注释里大面积残留。engine_globals.go 那条
「注入会话全局对象失败」还是用户可见文案，而公开 API 里根本
没有「会话」这个概念
Extension 文档示例写 Module() string，接口是 Module() (path, source string)。
这是唯一一段教人写扩展的文档，照抄编译不过
doc.go 的 freeze 说白名单「逐层拷贝成只读对象，不会跨 VM 共享可变的 Go map」，
但那只对 map[string]any 成立。结构体指针和 slice 是**共享同一个
对象**的——扩展走的正是这条路，不该被当成隔离保证
This commit is contained in:
@@ -1,6 +1,8 @@
|
||||
package jscriptx
|
||||
|
||||
import (
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
@@ -159,3 +161,28 @@ func bundleError(filename string, errs []api.Message, resolveDir string) error {
|
||||
}
|
||||
return fmt.Errorf("%s", b.String())
|
||||
}
|
||||
|
||||
// validIdent 校验全局名是不是合法的 JS 标识符（只允许 ASCII 字母、数字、_ 和 $）。
|
||||
func validIdent(s string) bool {
|
||||
if s == "" {
|
||||
return false
|
||||
}
|
||||
for i, r := range s {
|
||||
switch {
|
||||
case r == '_' || r == '$':
|
||||
case r >= 'a' && r <= 'z', r >= 'A' && r <= 'Z':
|
||||
case r >= '0' && r <= '9':
|
||||
if i == 0 {
|
||||
return false
|
||||
}
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func hashVersion(source string) string {
|
||||
sum := sha256.Sum256([]byte(source))
|
||||
return hex.EncodeToString(sum[:8])
|
||||
}
|
||||
|
||||
@@ -117,8 +117,12 @@
|
||||
// # 安全边界
|
||||
//
|
||||
// 脚本能看见的东西，只有 WithGlobals 显式放行的那些，加上 JS 语言自带的内置对象
|
||||
// （goja 不提供文件、网络、require，也没有 setTimeout）。白名单对象注入时会逐层拷贝成
|
||||
// 只读 JS 对象，脚本改不动，也不会跨 VM 共享同一个可变的 Go map。
|
||||
// （goja 不提供文件、网络、require，也没有 setTimeout）。
|
||||
//
|
||||
// 注入时的拷贝**只对 map[string]any 成立**：那种值会逐层拷成只读 JS 对象，脚本改不动，
|
||||
// 各个 VM 拿到的也是各自的副本。放行的是结构体指针、slice 或别的 Go 对象时，
|
||||
// **各个 VM 共享的是同一个对象**，脚本通过它的方法改到的东西是真改了。要跨 VM 共享
|
||||
// 可变状态就该这么用（扩展走的正是这条路），但别把它当成隔离保证。
|
||||
//
|
||||
// 本库不预设放行哪些 API——那取决于你的框架。原则是只放行「不带数据库连接、不能自己
|
||||
// 发起查询」的纯构造器和常量：放行构造列名/表名/字面量的那些，不放行能凭空造出查询
|
||||
|
||||
@@ -2,8 +2,6 @@ package jscriptx
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
@@ -176,6 +174,20 @@ func (e *Engine) Close() {
|
||||
}
|
||||
}
|
||||
|
||||
// New 是 Script(name) + Script.New(ctx, args...) 的快捷方式：按名字取脚本，
|
||||
// 实例化它导出的 class，构造参数直接传给 constructor。
|
||||
//
|
||||
// ctrl, err := e.New(ctx, "PkgVersion/PkgImportController")
|
||||
// defer ctrl.Close()
|
||||
// got, err := ctrl.Call(ctx, "Init")
|
||||
func (e *Engine) New(ctx context.Context, name string, ctorArgs ...any) (*Instance, error) {
|
||||
s, err := e.Script(name)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return s.New(ctx, ctorArgs...)
|
||||
}
|
||||
|
||||
// compileLocked 编译并替换缓存里的同名脚本。调用方必须持有 e.mu。
|
||||
//
|
||||
// prepared 为 true 表示源码已经过打包（Loader 自己做过了），跳过这一步——
|
||||
@@ -217,139 +229,3 @@ func (e *Engine) compileLocked(name, source, version string, prepared bool) (*Sc
|
||||
e.scripts[name] = s
|
||||
return s, nil
|
||||
}
|
||||
|
||||
// bind 把白名单全局对象注入到一个新建的 VM 里。
|
||||
// extra 是这个 VM 专属的额外全局（作用域带来的扩展），可以为 nil；
|
||||
// 它跟白名单同样按只读注入，同名时以 extra 为准。
|
||||
//
|
||||
// 注入是**惰性**的：这里只装一个 getter，脚本第一次读到那个名字才把值转成
|
||||
// JS 对象。一个脚本通常只用得上少数几个扩展，而 freeze 要把每个方法都包装成
|
||||
// JS 函数——用不到的那些不该在每次建 VM 时都付一遍这个成本。见 lazyGlobal。
|
||||
func (e *Engine) bind(rt *goja.Runtime, script string, extra map[string]any) error {
|
||||
global := rt.GlobalObject()
|
||||
for name, val := range e.globals {
|
||||
if _, overridden := extra[name]; overridden {
|
||||
continue
|
||||
}
|
||||
if err := e.lazyGlobal(rt, global, name, val); err != nil {
|
||||
return newError(KindBind, script, "", err, "注入全局对象 %q 失败", name)
|
||||
}
|
||||
}
|
||||
for name, val := range extra {
|
||||
if err := e.lazyGlobal(rt, global, name, val); err != nil {
|
||||
return newError(KindBind, script, "", err, "注入会话全局对象 %q 失败", name)
|
||||
}
|
||||
}
|
||||
if e.logger != nil {
|
||||
_, taken := e.globals["console"]
|
||||
if _, t2 := extra["console"]; t2 {
|
||||
taken = true
|
||||
}
|
||||
if !taken {
|
||||
if err := e.lazyGlobal(rt, global, "console", newConsole(e.logger, script)); err != nil {
|
||||
return newError(KindBind, script, "", err, "注入 console 失败")
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// lazyGlobal 装一个惰性只读全局：脚本第一次读它才 freeze，之后复用。
|
||||
//
|
||||
// 为什么惰性：freeze 要把 map 里每个方法都包装成 JS 函数对象，而一个脚本通常只用
|
||||
// 得上少数几个扩展。急切注入的话，每建一个 VM 都要为**所有**扩展付这份成本——
|
||||
// 实测这是脚本层剩余开销里最大的一块。
|
||||
//
|
||||
// 缓存放在闭包里，不加锁：getter 只在脚本执行期间被调用，而那时这个 VM 是被独占的
|
||||
// （实例持着自己的锁，池化的 VM 同时只有一个借用者）。goja.Value 也跨不了 Runtime，
|
||||
// 所以这份缓存天然是每 VM 一份。
|
||||
//
|
||||
// 只给 getter 不给 setter，效果等同原来的 writable=false：脚本赋值时没有 setter 可调。
|
||||
// 产物跑在非严格模式下（见 compileLocked 那里的说明），所以赋值是**静默失败**——
|
||||
// 不抛错，值也不变。configurable 同样保持 false，删不掉也重定义不了。
|
||||
//
|
||||
// 代价是 freeze 的错误从"建 VM 时返回 Go 错误"变成"脚本读它时抛 JS 异常"。
|
||||
// freeze 只在属性名不合法时才会失败，而 New() 里的 validIdent 已经挡过一道，
|
||||
// 实际碰不到。
|
||||
func (e *Engine) lazyGlobal(rt *goja.Runtime, global *goja.Object, name string, val any) error {
|
||||
var (
|
||||
cached goja.Value
|
||||
failed error
|
||||
)
|
||||
getter := rt.ToValue(func(goja.FunctionCall) goja.Value {
|
||||
if cached == nil && failed == nil {
|
||||
cached, failed = e.freeze(rt, val)
|
||||
}
|
||||
if failed != nil {
|
||||
panic(rt.NewGoError(failed))
|
||||
}
|
||||
return cached
|
||||
})
|
||||
return global.DefineAccessorProperty(name, getter, nil, goja.FLAG_FALSE, goja.FLAG_TRUE)
|
||||
}
|
||||
|
||||
// freeze 把 map[string]any 递归转成只读的 JS 对象，其他值原样交给 goja 包装。
|
||||
//
|
||||
// 直接 rt.Set(name, someMap) 会把同一个 Go map 暴露给每个 VM：脚本一句
|
||||
// db.C = null 既能污染别的 VM，又是实打实的数据竞争。这里每个 VM 都拿到
|
||||
// 自己的一份不可写、不可重定义的对象。
|
||||
func (e *Engine) freeze(rt *goja.Runtime, val any) (goja.Value, error) {
|
||||
m, ok := val.(map[string]any)
|
||||
if !ok {
|
||||
return rt.ToValue(val), nil
|
||||
}
|
||||
obj := rt.NewObject()
|
||||
for k, v := range m {
|
||||
child, err := e.freeze(rt, v)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := defineReadOnly(obj, k, child); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
return obj, nil
|
||||
}
|
||||
|
||||
func defineReadOnly(obj *goja.Object, name string, v goja.Value) error {
|
||||
return obj.DefineDataProperty(name, v, goja.FLAG_FALSE, goja.FLAG_FALSE, goja.FLAG_TRUE)
|
||||
}
|
||||
|
||||
// validIdent 校验全局名是不是合法的 JS 标识符（只允许 ASCII 字母、数字、_ 和 $）。
|
||||
func validIdent(s string) bool {
|
||||
if s == "" {
|
||||
return false
|
||||
}
|
||||
for i, r := range s {
|
||||
switch {
|
||||
case r == '_' || r == '$':
|
||||
case r >= 'a' && r <= 'z', r >= 'A' && r <= 'Z':
|
||||
case r >= '0' && r <= '9':
|
||||
if i == 0 {
|
||||
return false
|
||||
}
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func hashVersion(source string) string {
|
||||
sum := sha256.Sum256([]byte(source))
|
||||
return hex.EncodeToString(sum[:8])
|
||||
}
|
||||
|
||||
// New 是 Script(name) + Script.New(ctx, args...) 的快捷方式：按名字取脚本，
|
||||
// 实例化它导出的 class，构造参数直接传给 constructor。
|
||||
//
|
||||
// ctrl, err := e.New(ctx, "PkgVersion/PkgImportController")
|
||||
// defer ctrl.Close()
|
||||
// got, err := ctrl.Call(ctx, "Init")
|
||||
func (e *Engine) New(ctx context.Context, name string, ctorArgs ...any) (*Instance, error) {
|
||||
s, err := e.Script(name)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return s.New(ctx, ctorArgs...)
|
||||
}
|
||||
|
||||
@@ -0,0 +1,108 @@
|
||||
package jscriptx
|
||||
|
||||
import "github.com/dop251/goja"
|
||||
|
||||
// Go 值 → 只读 JS 全局的转换层。
|
||||
//
|
||||
// 脚本能看见的全局只有这里放行的：WithGlobals 配的白名单，加上作用域带来的扩展。
|
||||
// 别的一概没有——没有 require、没有 fs、没有 process，goja 本身也不提供。
|
||||
//
|
||||
// 注入只在**建 VM 时**发生一次，对每次调用零开销；而且是惰性的（见 lazyGlobal），
|
||||
// 脚本没读到的全局根本不会被转换。
|
||||
|
||||
// bind 把白名单全局对象注入到一个新建的 VM 里。
|
||||
// extra 是这个 VM 专属的额外全局（作用域带来的扩展），可以为 nil；
|
||||
// 它跟白名单同样按只读注入，同名时以 extra 为准。
|
||||
//
|
||||
// 注入是**惰性**的：这里只装一个 getter，脚本第一次读到那个名字才把值转成
|
||||
// JS 对象。一个脚本通常只用得上少数几个扩展，而 freeze 要把每个方法都包装成
|
||||
// JS 函数——用不到的那些不该在每次建 VM 时都付一遍这个成本。见 lazyGlobal。
|
||||
func (e *Engine) bind(rt *goja.Runtime, script string, extra map[string]any) error {
|
||||
global := rt.GlobalObject()
|
||||
for name, val := range e.globals {
|
||||
if _, overridden := extra[name]; overridden {
|
||||
continue
|
||||
}
|
||||
if err := e.lazyGlobal(rt, global, name, val); err != nil {
|
||||
return newError(KindBind, script, "", err, "注入全局对象 %q 失败", name)
|
||||
}
|
||||
}
|
||||
for name, val := range extra {
|
||||
if err := e.lazyGlobal(rt, global, name, val); err != nil {
|
||||
return newError(KindBind, script, "", err, "注入作用域全局对象 %q 失败", name)
|
||||
}
|
||||
}
|
||||
if e.logger != nil {
|
||||
_, taken := e.globals["console"]
|
||||
if _, t2 := extra["console"]; t2 {
|
||||
taken = true
|
||||
}
|
||||
if !taken {
|
||||
if err := e.lazyGlobal(rt, global, "console", newConsole(e.logger, script)); err != nil {
|
||||
return newError(KindBind, script, "", err, "注入 console 失败")
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// lazyGlobal 装一个惰性只读全局：脚本第一次读它才 freeze，之后复用。
|
||||
//
|
||||
// 为什么惰性：freeze 要把 map 里每个方法都包装成 JS 函数对象，而一个脚本通常只用
|
||||
// 得上少数几个扩展。急切注入的话，每建一个 VM 都要为**所有**扩展付这份成本——
|
||||
// 实测这是脚本层剩余开销里最大的一块。
|
||||
//
|
||||
// 缓存放在闭包里，不加锁：getter 只在脚本执行期间被调用，而那时这个 VM 是被独占的
|
||||
// （实例持着自己的锁，池化的 VM 同时只有一个借用者）。goja.Value 也跨不了 Runtime，
|
||||
// 所以这份缓存天然是每 VM 一份。
|
||||
//
|
||||
// 只给 getter 不给 setter，效果等同原来的 writable=false：脚本赋值时没有 setter 可调。
|
||||
// 产物跑在非严格模式下（见 compileLocked 那里的说明），所以赋值是**静默失败**——
|
||||
// 不抛错，值也不变。configurable 同样保持 false，删不掉也重定义不了。
|
||||
//
|
||||
// 代价是 freeze 的错误从"建 VM 时返回 Go 错误"变成"脚本读它时抛 JS 异常"。
|
||||
// freeze 只在属性名不合法时才会失败，而 New() 里的 validIdent 已经挡过一道，
|
||||
// 实际碰不到。
|
||||
func (e *Engine) lazyGlobal(rt *goja.Runtime, global *goja.Object, name string, val any) error {
|
||||
var (
|
||||
cached goja.Value
|
||||
failed error
|
||||
)
|
||||
getter := rt.ToValue(func(goja.FunctionCall) goja.Value {
|
||||
if cached == nil && failed == nil {
|
||||
cached, failed = e.freeze(rt, val)
|
||||
}
|
||||
if failed != nil {
|
||||
panic(rt.NewGoError(failed))
|
||||
}
|
||||
return cached
|
||||
})
|
||||
return global.DefineAccessorProperty(name, getter, nil, goja.FLAG_FALSE, goja.FLAG_TRUE)
|
||||
}
|
||||
|
||||
// freeze 把 map[string]any 递归转成只读的 JS 对象，其他值原样交给 goja 包装。
|
||||
//
|
||||
// 直接 rt.Set(name, someMap) 会把同一个 Go map 暴露给每个 VM：脚本一句
|
||||
// db.C = null 既能污染别的 VM，又是实打实的数据竞争。这里每个 VM 都拿到
|
||||
// 自己的一份不可写、不可重定义的对象。
|
||||
func (e *Engine) freeze(rt *goja.Runtime, val any) (goja.Value, error) {
|
||||
m, ok := val.(map[string]any)
|
||||
if !ok {
|
||||
return rt.ToValue(val), nil
|
||||
}
|
||||
obj := rt.NewObject()
|
||||
for k, v := range m {
|
||||
child, err := e.freeze(rt, v)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := defineReadOnly(obj, k, child); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
return obj, nil
|
||||
}
|
||||
|
||||
func defineReadOnly(obj *goja.Object, name string, v goja.Value) error {
|
||||
return obj.DefineDataProperty(name, v, goja.FLAG_FALSE, goja.FLAG_FALSE, goja.FLAG_TRUE)
|
||||
}
|
||||
@@ -1,14 +1,11 @@
|
||||
package jscriptx
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"github.com/dop251/goja"
|
||||
)
|
||||
|
||||
// 哨兵错误，配合 errors.Is 使用。
|
||||
@@ -151,214 +148,3 @@ func newError(kind Kind, script, fn string, cause error, format string, a ...any
|
||||
Cause: cause,
|
||||
}
|
||||
}
|
||||
|
||||
// classify 把 goja 抛出来的各种错误翻译成 *Error 并补上脚本上下文。
|
||||
// 已经是 *Error 的（比如 invoke 自己造的类型错误）原样返回。
|
||||
func classify(err error, script, fn string, args []any) error {
|
||||
if err == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
var known *Error
|
||||
if errors.As(err, &known) {
|
||||
return err
|
||||
}
|
||||
|
||||
// 超时/取消：goja.Runtime.Interrupt 打断脚本后返回的就是这个。
|
||||
var interrupted *goja.InterruptedError
|
||||
if errors.As(err, &interrupted) {
|
||||
cause := interrupted.Unwrap()
|
||||
kind, msg := KindTimeout, "脚本执行超时，已强制中断"
|
||||
switch {
|
||||
case errors.Is(cause, context.Canceled):
|
||||
kind, msg = KindCanceled, "调用方 context 被取消，脚本已中断"
|
||||
case errors.Is(cause, context.DeadlineExceeded):
|
||||
cause = fmt.Errorf("%w (%w)", ErrTimeout, cause)
|
||||
case cause == nil:
|
||||
cause = ErrInterrupted
|
||||
}
|
||||
return &Error{
|
||||
Kind: kind,
|
||||
Script: script,
|
||||
Func: fn,
|
||||
Msg: msg,
|
||||
Args: summarize(args),
|
||||
Stack: framesOf(interrupted.Stack()),
|
||||
Cause: cause,
|
||||
}
|
||||
}
|
||||
|
||||
var overflow *goja.StackOverflowError
|
||||
if errors.As(err, &overflow) {
|
||||
return &Error{
|
||||
Kind: KindRuntime,
|
||||
Script: script,
|
||||
Func: fn,
|
||||
Msg: "脚本调用栈溢出（多半是无限递归）",
|
||||
Args: summarize(args),
|
||||
Stack: framesOf(overflow.Stack()),
|
||||
Cause: err,
|
||||
}
|
||||
}
|
||||
|
||||
// 脚本里没被 catch 的异常。
|
||||
var exception *goja.Exception
|
||||
if errors.As(err, &exception) {
|
||||
e := &Error{
|
||||
Kind: KindRuntime,
|
||||
Script: script,
|
||||
Func: fn,
|
||||
Msg: "脚本抛出异常",
|
||||
Args: summarize(args),
|
||||
Stack: framesOf(exception.Stack()),
|
||||
Cause: err,
|
||||
}
|
||||
if v := exception.Value(); v != nil {
|
||||
e.Msg = v.String()
|
||||
e.Value = v.Export()
|
||||
if hint := missingGlobalHint(e.Msg); hint != "" {
|
||||
e.Msg += "。" + hint
|
||||
}
|
||||
}
|
||||
// Go 侧函数返回的 error 透到 JS 又没被 catch 时，这里能把原始 Go error 取回来，
|
||||
// 让调用方的 errors.Is 还能匹配到自己的哨兵错误。
|
||||
if inner := exception.Unwrap(); inner != nil {
|
||||
e.Cause = inner
|
||||
}
|
||||
return e
|
||||
}
|
||||
|
||||
return &Error{
|
||||
Kind: KindRuntime,
|
||||
Script: script,
|
||||
Func: fn,
|
||||
Msg: err.Error(),
|
||||
Args: summarize(args),
|
||||
Cause: err,
|
||||
}
|
||||
}
|
||||
|
||||
func framesOf(stack []goja.StackFrame) []Frame {
|
||||
if len(stack) == 0 {
|
||||
return nil
|
||||
}
|
||||
out := make([]Frame, 0, len(stack))
|
||||
for i := range stack {
|
||||
pos := stack[i].Position()
|
||||
out = append(out, Frame{
|
||||
Source: stack[i].SrcName(),
|
||||
Func: stack[i].FuncName(),
|
||||
Line: pos.Line,
|
||||
Column: pos.Column,
|
||||
})
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
const (
|
||||
maxSummaryArgs = 8 // 最多记录几个参数
|
||||
maxSummaryLen = 256 // 单个参数摘要的最大长度
|
||||
)
|
||||
|
||||
// summarize 把调用参数压成可以安全写进日志的短字符串。
|
||||
// 只在出错路径上调用，正常调用不付这个格式化开销。
|
||||
func summarize(args []any) []string {
|
||||
if len(args) == 0 {
|
||||
return nil
|
||||
}
|
||||
n := min(len(args), maxSummaryArgs)
|
||||
out := make([]string, 0, n+1)
|
||||
for _, a := range args[:n] {
|
||||
s := fmt.Sprintf("%v", a)
|
||||
if len(s) > maxSummaryLen {
|
||||
s = s[:maxSummaryLen] + "…"
|
||||
}
|
||||
out = append(out, fmt.Sprintf("%T=%s", a, s))
|
||||
}
|
||||
if len(args) > n {
|
||||
out = append(out, fmt.Sprintf("…还有 %d 个参数", len(args)-n))
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// fatal 判断这个错误是否说明 VM 已处于不确定状态，不该再放回池子复用。
|
||||
func fatal(err error) bool {
|
||||
var e *Error
|
||||
if errors.As(err, &e) {
|
||||
switch e.Kind {
|
||||
case KindTimeout, KindCanceled, KindPanic:
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
var interrupted *goja.InterruptedError
|
||||
if errors.As(err, &interrupted) {
|
||||
return true
|
||||
}
|
||||
var overflow *goja.StackOverflowError
|
||||
return errors.As(err, &overflow)
|
||||
}
|
||||
|
||||
// toError 把 recover() 拿到的任意值转成 error。
|
||||
func toError(r any) error {
|
||||
if err, ok := r.(error); ok {
|
||||
return err
|
||||
}
|
||||
return fmt.Errorf("%v", r)
|
||||
}
|
||||
|
||||
// strconvQuote 是 strconv.Quote 的短名字，给错误信息拼接用。
|
||||
func strconvQuote(s string) string { return strconv.Quote(s) }
|
||||
|
||||
// missingGlobalHint 针对几个"goja 没有、但脚本作者以为一定有"的全局，
|
||||
// 在 ReferenceError 后面补一句人话。
|
||||
//
|
||||
// 为什么是补错误信息，而不是把这些全局定义成"一调就报错"的桩：
|
||||
// 库里 `typeof setTimeout !== "undefined"` 这种特性探测很常见，一旦定义了，
|
||||
// 探测就会走进定时器分支，本来能优雅降级的库反而被弄坏。让它保持 undefined，
|
||||
// 探测正常工作；真直接调用了，就在错误里说清楚。
|
||||
//
|
||||
// 只认两种原样输出：goja 的 "ReferenceError: xxx is not defined"，
|
||||
// 以及 esbuild 给动态 require 埋的那句运行期错误。
|
||||
func missingGlobalHint(msg string) string {
|
||||
// require 不会以 ReferenceError 的形式出现——esbuild 在打包期就接管了它：
|
||||
// 静态的 require("x") 直接当模块解析（解析不到就打包失败），
|
||||
// 动态的 require(变量) 换成下面这句运行期错误。
|
||||
if strings.HasPrefix(msg, "Error: Dynamic require of ") {
|
||||
return "脚本走的是 ES 模块，用 import 而不是 require；" +
|
||||
"而且 import 的路径必须是字面量，不能是变量拼出来的"
|
||||
}
|
||||
|
||||
const prefix = "ReferenceError: "
|
||||
const suffix = " is not defined"
|
||||
if !strings.HasPrefix(msg, prefix) || !strings.HasSuffix(msg, suffix) {
|
||||
return ""
|
||||
}
|
||||
name := msg[len(prefix) : len(msg)-len(suffix)]
|
||||
|
||||
switch name {
|
||||
case "setTimeout", "setInterval", "setImmediate",
|
||||
"clearTimeout", "clearInterval", "clearImmediate":
|
||||
return "脚本是同步的，没有事件循环——定时器用不了。" +
|
||||
"要延迟或周期执行，把这段逻辑放到 Go 侧的 Job / Cron；" +
|
||||
"如果是第三方库里的 debounce / throttle 之类，换一个不依赖定时器的实现"
|
||||
|
||||
case "structuredClone":
|
||||
return "goja 没有这个函数。深拷贝用 JSON.parse(JSON.stringify(x))，" +
|
||||
"或者换一个不依赖它的库（remeda 的 clone 就依赖它）"
|
||||
|
||||
case "module", "exports":
|
||||
return "脚本走的是 ES 模块，没有 CommonJS 那套；导出用 export default"
|
||||
|
||||
case "process", "Buffer", "__dirname", "__filename":
|
||||
return "脚本不跑在 Node 里，没有这些东西。要读配置用扩展提供的接口"
|
||||
|
||||
case "window", "document", "navigator", "localStorage":
|
||||
return "脚本不跑在浏览器里，没有 DOM"
|
||||
|
||||
case "fetch", "XMLHttpRequest", "WebSocket":
|
||||
return "脚本里发不了网络请求——那是异步的，而脚本是同步执行的。" +
|
||||
"要调外部服务，在 Go 侧做好再通过扩展交给脚本"
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
+158
@@ -0,0 +1,158 @@
|
||||
package jscriptx
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strconv"
|
||||
|
||||
"github.com/dop251/goja"
|
||||
)
|
||||
|
||||
// goja 抛出来的东西翻译成本库的 *Error。
|
||||
//
|
||||
// goja 的错误有四种形状（中断、栈溢出、脚本异常、其它），每种要摘的上下文都不一样，
|
||||
// 而调用方只想拿到「哪个脚本、哪个函数、脚本里哪一行」。这一层就干这件事。
|
||||
|
||||
// classify 把 goja 抛出来的各种错误翻译成 *Error 并补上脚本上下文。
|
||||
// 已经是 *Error 的（比如 invoke 自己造的类型错误）原样返回。
|
||||
// gojaError 是 classify 四个分支共用的骨架：脚本上下文（哪个脚本、哪个函数、
|
||||
// 什么参数）四处都一样，只有 kind / msg / stack / cause 各不相同。
|
||||
func gojaError(kind Kind, script, fn string, args []any, msg string, stack []Frame, cause error) *Error {
|
||||
return &Error{
|
||||
Kind: kind,
|
||||
Script: script,
|
||||
Func: fn,
|
||||
Msg: msg,
|
||||
Args: summarize(args),
|
||||
Stack: stack,
|
||||
Cause: cause,
|
||||
}
|
||||
}
|
||||
|
||||
func classify(err error, script, fn string, args []any) error {
|
||||
if err == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
var known *Error
|
||||
if errors.As(err, &known) {
|
||||
return err
|
||||
}
|
||||
|
||||
// 超时/取消：goja.Runtime.Interrupt 打断脚本后返回的就是这个。
|
||||
var interrupted *goja.InterruptedError
|
||||
if errors.As(err, &interrupted) {
|
||||
cause := interrupted.Unwrap()
|
||||
kind, msg := KindTimeout, "脚本执行超时，已强制中断"
|
||||
switch {
|
||||
case errors.Is(cause, context.Canceled):
|
||||
kind, msg = KindCanceled, "调用方 context 被取消，脚本已中断"
|
||||
case errors.Is(cause, context.DeadlineExceeded):
|
||||
cause = fmt.Errorf("%w (%w)", ErrTimeout, cause)
|
||||
case cause == nil:
|
||||
cause = ErrInterrupted
|
||||
}
|
||||
return gojaError(kind, script, fn, args, msg, framesOf(interrupted.Stack()), cause)
|
||||
}
|
||||
|
||||
var overflow *goja.StackOverflowError
|
||||
if errors.As(err, &overflow) {
|
||||
return gojaError(KindRuntime, script, fn, args,
|
||||
"脚本调用栈溢出（多半是无限递归）", framesOf(overflow.Stack()), err)
|
||||
}
|
||||
|
||||
// 脚本里没被 catch 的异常。
|
||||
var exception *goja.Exception
|
||||
if errors.As(err, &exception) {
|
||||
e := gojaError(KindRuntime, script, fn, args,
|
||||
"脚本抛出异常", framesOf(exception.Stack()), err)
|
||||
if v := exception.Value(); v != nil {
|
||||
e.Msg = v.String()
|
||||
e.Value = v.Export()
|
||||
if hint := missingGlobalHint(e.Msg); hint != "" {
|
||||
e.Msg += "。" + hint
|
||||
}
|
||||
}
|
||||
// Go 侧函数返回的 error 透到 JS 又没被 catch 时，这里能把原始 Go error 取回来，
|
||||
// 让调用方的 errors.Is 还能匹配到自己的哨兵错误。
|
||||
if inner := exception.Unwrap(); inner != nil {
|
||||
e.Cause = inner
|
||||
}
|
||||
return e
|
||||
}
|
||||
|
||||
return gojaError(KindRuntime, script, fn, args, err.Error(), nil, err)
|
||||
}
|
||||
|
||||
func framesOf(stack []goja.StackFrame) []Frame {
|
||||
if len(stack) == 0 {
|
||||
return nil
|
||||
}
|
||||
out := make([]Frame, 0, len(stack))
|
||||
for i := range stack {
|
||||
pos := stack[i].Position()
|
||||
out = append(out, Frame{
|
||||
Source: stack[i].SrcName(),
|
||||
Func: stack[i].FuncName(),
|
||||
Line: pos.Line,
|
||||
Column: pos.Column,
|
||||
})
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
const (
|
||||
maxSummaryArgs = 8 // 最多记录几个参数
|
||||
maxSummaryLen = 256 // 单个参数摘要的最大长度
|
||||
)
|
||||
|
||||
// summarize 把调用参数压成可以安全写进日志的短字符串。
|
||||
// 只在出错路径上调用，正常调用不付这个格式化开销。
|
||||
func summarize(args []any) []string {
|
||||
if len(args) == 0 {
|
||||
return nil
|
||||
}
|
||||
n := min(len(args), maxSummaryArgs)
|
||||
out := make([]string, 0, n+1)
|
||||
for _, a := range args[:n] {
|
||||
s := fmt.Sprintf("%v", a)
|
||||
if len(s) > maxSummaryLen {
|
||||
s = s[:maxSummaryLen] + "…"
|
||||
}
|
||||
out = append(out, fmt.Sprintf("%T=%s", a, s))
|
||||
}
|
||||
if len(args) > n {
|
||||
out = append(out, fmt.Sprintf("…还有 %d 个参数", len(args)-n))
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// fatal 判断这个错误是否说明 VM 已处于不确定状态，不该再放回池子复用。
|
||||
func fatal(err error) bool {
|
||||
var e *Error
|
||||
if errors.As(err, &e) {
|
||||
switch e.Kind {
|
||||
case KindTimeout, KindCanceled, KindPanic:
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
var interrupted *goja.InterruptedError
|
||||
if errors.As(err, &interrupted) {
|
||||
return true
|
||||
}
|
||||
var overflow *goja.StackOverflowError
|
||||
return errors.As(err, &overflow)
|
||||
}
|
||||
|
||||
// toError 把 recover() 拿到的任意值转成 error。
|
||||
func toError(r any) error {
|
||||
if err, ok := r.(error); ok {
|
||||
return err
|
||||
}
|
||||
return fmt.Errorf("%v", r)
|
||||
}
|
||||
|
||||
// strconvQuote 是 strconv.Quote 的短名字，给错误信息拼接用。
|
||||
func strconvQuote(s string) string { return strconv.Quote(s) }
|
||||
@@ -0,0 +1,64 @@
|
||||
package jscriptx
|
||||
|
||||
import "strings"
|
||||
|
||||
// 脚本作者最容易撞上的那几个「以为一定有、其实 goja 没有」的全局，
|
||||
// 在 ReferenceError 后面补一句人话。
|
||||
//
|
||||
// 为什么是补错误信息、而不是把这些全局定义成「一调就报错」的桩：库里
|
||||
// `typeof setTimeout !== "undefined"` 这种特性探测很常见，一旦定义了，
|
||||
// 探测就会走进定时器分支，本来能优雅降级的库反而被弄坏。让它保持 undefined，
|
||||
// 探测正常工作；真直接调用了，就在错误里说清楚。
|
||||
|
||||
// missingGlobalHint 针对几个"goja 没有、但脚本作者以为一定有"的全局，
|
||||
// 在 ReferenceError 后面补一句人话。
|
||||
//
|
||||
// 为什么是补错误信息，而不是把这些全局定义成"一调就报错"的桩：
|
||||
// 库里 `typeof setTimeout !== "undefined"` 这种特性探测很常见，一旦定义了，
|
||||
// 探测就会走进定时器分支，本来能优雅降级的库反而被弄坏。让它保持 undefined，
|
||||
// 探测正常工作；真直接调用了，就在错误里说清楚。
|
||||
//
|
||||
// 只认两种原样输出：goja 的 "ReferenceError: xxx is not defined"，
|
||||
// 以及 esbuild 给动态 require 埋的那句运行期错误。
|
||||
func missingGlobalHint(msg string) string {
|
||||
// require 不会以 ReferenceError 的形式出现——esbuild 在打包期就接管了它：
|
||||
// 静态的 require("x") 直接当模块解析（解析不到就打包失败），
|
||||
// 动态的 require(变量) 换成下面这句运行期错误。
|
||||
if strings.HasPrefix(msg, "Error: Dynamic require of ") {
|
||||
return "脚本走的是 ES 模块，用 import 而不是 require；" +
|
||||
"而且 import 的路径必须是字面量，不能是变量拼出来的"
|
||||
}
|
||||
|
||||
const prefix = "ReferenceError: "
|
||||
const suffix = " is not defined"
|
||||
if !strings.HasPrefix(msg, prefix) || !strings.HasSuffix(msg, suffix) {
|
||||
return ""
|
||||
}
|
||||
name := msg[len(prefix) : len(msg)-len(suffix)]
|
||||
|
||||
switch name {
|
||||
case "setTimeout", "setInterval", "setImmediate",
|
||||
"clearTimeout", "clearInterval", "clearImmediate":
|
||||
return "脚本是同步的，没有事件循环——定时器用不了。" +
|
||||
"要延迟或周期执行，把这段逻辑放到 Go 侧的 Job / Cron；" +
|
||||
"如果是第三方库里的 debounce / throttle 之类，换一个不依赖定时器的实现"
|
||||
|
||||
case "structuredClone":
|
||||
return "goja 没有这个函数。深拷贝用 JSON.parse(JSON.stringify(x))，" +
|
||||
"或者换一个不依赖它的库（remeda 的 clone 就依赖它）"
|
||||
|
||||
case "module", "exports":
|
||||
return "脚本走的是 ES 模块，没有 CommonJS 那套；导出用 export default"
|
||||
|
||||
case "process", "Buffer", "__dirname", "__filename":
|
||||
return "脚本不跑在 Node 里，没有这些东西。要读配置用扩展提供的接口"
|
||||
|
||||
case "window", "document", "navigator", "localStorage":
|
||||
return "脚本不跑在浏览器里，没有 DOM"
|
||||
|
||||
case "fetch", "XMLHttpRequest", "WebSocket":
|
||||
return "脚本里发不了网络请求——那是异步的，而脚本是同步执行的。" +
|
||||
"要调外部服务，在 Go 侧做好再通过扩展交给脚本"
|
||||
}
|
||||
return ""
|
||||
}
|
||||
+1
-1
@@ -24,7 +24,7 @@ package jscriptx
|
||||
// func (t *tx) Bindings() map[string]any {
|
||||
// return map[string]any{"commit": t.conn.Commit, "rollback": t.conn.Rollback}
|
||||
// }
|
||||
// func (t *tx) Module() string { return txTypings }
|
||||
// func (t *tx) Module() (path, source string) { return "@fsdpf/tx", txTypings }
|
||||
type Extension interface {
|
||||
// Name 是它在脚本里的全局名，必须是合法的 JS 标识符。
|
||||
// 跟白名单（WithGlobals）同名时以白名单为准。
|
||||
|
||||
@@ -67,7 +67,7 @@ func (s *Script) CallInto(ctx context.Context, fn string, out any, args ...any)
|
||||
return callInto(ctx, s, fn, out, args)
|
||||
}
|
||||
|
||||
// callAny 是 Call 的共用实现，*Script 和 *Session 都走这里。
|
||||
// callAny 是 Call 的共用实现，*Script / *Instance / staticTarget 三方都走这里。
|
||||
func callAny(ctx context.Context, r runner, fn string, args []any) (any, error) {
|
||||
var out any
|
||||
err := invoke(ctx, r, fn, args, func(f *frame) error {
|
||||
@@ -127,7 +127,7 @@ func callInto(ctx context.Context, r runner, fn string, out any, args []any) err
|
||||
}
|
||||
|
||||
// runner 抽象"这次调用用哪个 VM、用完怎么处理"：*Script 从池里借还，
|
||||
// *Session 独占一个 VM（acquire 会一直持锁到 finish，保证同一会话串行执行）。
|
||||
// *Instance 独占一个 VM（acquire 会一直持锁到 finish，保证同一实例串行执行）。
|
||||
type runner interface {
|
||||
owner() *Script
|
||||
acquire(ctx context.Context) (*vmHandle, error)
|
||||
|
||||
@@ -29,7 +29,7 @@ import (
|
||||
// 共享数据走扩展（Go 侧对象，注入到各个 VM 的是同一份引用），而不是共用 Runtime：
|
||||
// 共用 Runtime 会让所有脚本被迫串行，那才是真的并发瓶颈。
|
||||
//
|
||||
// 设备连接这类长期会话，业务侧自己拿 map 存 Instance 就行，跟 Go 版 controller 的
|
||||
// 设备连接这类长期存在的东西，业务侧自己拿 map 存 Instance 就行，跟 Go 版 controller 的
|
||||
// 写法一致；本库不代管这个生命周期。
|
||||
|
||||
type scopeCtxKey struct{}
|
||||
|
||||
@@ -2,7 +2,6 @@ package jscriptx
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"sync/atomic"
|
||||
|
||||
"github.com/dop251/goja"
|
||||
@@ -33,8 +32,9 @@ type Script struct {
|
||||
// vmHandle 是一个 VM：一个 goja.Runtime 加上它跑完脚本后的求值结果。
|
||||
// Runtime 不是并发安全的，同一时刻只能有一个 goroutine 持有它。
|
||||
//
|
||||
// 一个 VM 只跑一个脚本。会话下多个脚本要共享数据时靠 store（Go 侧对象，注入到各个 VM
|
||||
// 里的是同一份引用），而不是共用 Runtime——共用 Runtime 会让会话内的所有脚本被迫串行。
|
||||
// 一个 VM 只跑一个脚本。同一作用域下多个脚本要共享数据时靠扩展（Go 侧对象，注入到
|
||||
// 各个 VM 里的是同一份引用），而不是共用 Runtime——共用 Runtime 会让作用域内的所有
|
||||
// 脚本被迫串行。
|
||||
type vmHandle struct {
|
||||
rt *goja.Runtime
|
||||
defFn goja.Value // 脚本求值出的函数（单函数入口写法）
|
||||
@@ -99,227 +99,3 @@ func (s *Script) Close() {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// borrow 从池里取一个 VM；池空就新建一个。
|
||||
//
|
||||
// 刻意不阻塞等待：并发量超过池容量时宁可临时多造几个 VM，也不让请求在这里排队。
|
||||
// 池只是复用缓存，不承担限流职责。
|
||||
//
|
||||
// ctx 带了作用域时**不走池**：池是所有调用共享的，而作用域的扩展是这一次调用专属的
|
||||
// （store、当前请求……）。混用要么让脚本看不见扩展（顶层 import 直接 ReferenceError），
|
||||
// 要么把上一个作用域的对象漏给下一个。所以为它单造一个 VM，用完丢弃。
|
||||
//
|
||||
// 代价是这类调用每次约 5μs 建一个 VM。同一作用域下要反复调，用 New 拿实例更划算——
|
||||
// 实例把 VM 攥在手里，不必每次重建。
|
||||
func (s *Script) borrow(ctx context.Context) (*vmHandle, error) {
|
||||
// 有作用域就必然要单造：池里的 VM 没装这个作用域的扩展
|
||||
sc, scoped := scopeOf(ctx)
|
||||
if !scoped {
|
||||
select {
|
||||
case inst := <-s.pool:
|
||||
return inst, nil
|
||||
default:
|
||||
}
|
||||
}
|
||||
return s.newVM(ctx, sc, nil, false)
|
||||
}
|
||||
|
||||
// release 归还 VM。healthy 为 false（被中断过或 panic 过）时直接丢弃：
|
||||
// 脚本本来就不该有跨调用状态，重建一个 VM 远比拖着一个状态可疑的 VM 划算。
|
||||
func (s *Script) release(inst *vmHandle, healthy bool) {
|
||||
if inst == nil {
|
||||
return
|
||||
}
|
||||
if !healthy || s.closed.Load() || inst.scoped {
|
||||
// scoped 的 VM 带着某个作用域的扩展，回池就会漏给下一个调用
|
||||
s.dropped.Add(1)
|
||||
return
|
||||
}
|
||||
select {
|
||||
case s.pool <- inst:
|
||||
default:
|
||||
s.dropped.Add(1) // 池满，丢弃
|
||||
}
|
||||
}
|
||||
|
||||
// newVM 造一个新 VM 并在里面加载这个脚本：注入白名单 → 跑一遍脚本顶层代码 →
|
||||
// 记下求值结果。
|
||||
//
|
||||
// **取 VM 的唯一入口**。三条路径（池化 borrow、实例 ensure、静态 borrowStatic）
|
||||
// 都走它，作用域注入和 scoped 标记的规则才只有一份——这两件事分散过一次，
|
||||
// 结果就是 borrowStatic 漏标了 scoped。
|
||||
//
|
||||
// sc 是这个 VM 属于哪个作用域，nil 表示不属于任何作用域。**显式传而不是从 ctx 嗅**：
|
||||
// Instance 重建 VM 时要回到它**创建时**那个作用域，而不是当次调用 ctx 里的那个——
|
||||
// 对一个作用域实例调 Call(context.Background()) 不该把它的扩展弄丢。
|
||||
//
|
||||
// ctorArgs 传给 constructor；noInstance 为 true 时不构造实例，只想调静态方法时用，
|
||||
// 避免白跑一遍 constructor（那是每次调用的准备工作）。
|
||||
func (s *Script) newVM(ctx context.Context, sc *scope, ctorArgs []any, noInstance bool) (*vmHandle, error) {
|
||||
var extra map[string]any
|
||||
if sc != nil {
|
||||
extra = sc.vmGlobals()
|
||||
}
|
||||
|
||||
rt := goja.New()
|
||||
if s.engine.maxStack > 0 {
|
||||
rt.SetMaxCallStackSize(s.engine.maxStack)
|
||||
}
|
||||
if err := s.engine.bind(rt, s.name, extra); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
vm, err := s.load(ctx, rt, ctorArgs, noInstance)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
// 带作用域的 VM 装着那个作用域的扩展，绝不能回池——release 靠这个标志拒绝它
|
||||
vm.scoped = sc != nil
|
||||
return vm, nil
|
||||
}
|
||||
|
||||
// load 把脚本装进一个 VM。noInstance 为 true 时不构造实例——
|
||||
// 只想调静态方法时用，避免白跑一遍 constructor（那是每次调用的准备工作）。
|
||||
func (s *Script) load(ctx context.Context, rt *goja.Runtime, ctorArgs []any, noInstance bool) (h *vmHandle, err error) {
|
||||
stop := guard(ctx, rt, s.engine.timeout)
|
||||
defer stop()
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
h, err = nil, s.panicError(DefaultFunc, nil, r)
|
||||
}
|
||||
}()
|
||||
|
||||
v, err := rt.RunProgram(s.prog)
|
||||
if err != nil {
|
||||
return nil, classify(err, s.name, DefaultFunc, nil)
|
||||
}
|
||||
|
||||
h = &vmHandle{rt: rt}
|
||||
// 打包产物末尾的入口表达式求值出来的东西决定了脚本的形态：
|
||||
// class → 由这里 new 出实例，构造参数从 Go 侧传（export default class X {}）
|
||||
// 普通函数 → 单函数入口，用 DefaultFunc 调用（export default function(){}）
|
||||
// 非函数对象 → 直接当导出实例（export default {...}，或只有命名导出时的模块对象）
|
||||
if !empty(v) {
|
||||
switch {
|
||||
case isClass(rt, v):
|
||||
h.ctor = v.ToObject(rt)
|
||||
if noInstance {
|
||||
break // 只要静态方法，不跑 constructor
|
||||
}
|
||||
obj, err := construct(rt, v, ctorArgs)
|
||||
if err != nil {
|
||||
return nil, classify(err, s.name, "constructor", ctorArgs)
|
||||
}
|
||||
h.exports = obj
|
||||
case isCallable(v):
|
||||
h.defFn = v
|
||||
default:
|
||||
if obj, ok := v.(*goja.Object); ok {
|
||||
h.exports = obj
|
||||
}
|
||||
}
|
||||
}
|
||||
s.created.Add(1)
|
||||
return h, nil
|
||||
}
|
||||
|
||||
// classDetector 判断一个值是不是 class。goja 的 AssertConstructor 对普通 function
|
||||
// 也返回 true，区分不了；靠规范保证的差别来判：class 的 prototype 属性不可写，
|
||||
// 普通函数的可写，箭头函数和方法简写根本没有 prototype。
|
||||
var classDetector = goja.MustCompile("jscriptx:isclass", `(function (x) {
|
||||
if (typeof x !== "function") { return false }
|
||||
var d = Object.getOwnPropertyDescriptor(x, "prototype")
|
||||
return !!d && d.writable === false
|
||||
})`, true)
|
||||
|
||||
func isClass(rt *goja.Runtime, v goja.Value) bool {
|
||||
if _, ok := goja.AssertConstructor(v); !ok {
|
||||
return false
|
||||
}
|
||||
dv, err := rt.RunProgram(classDetector)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
detect, ok := goja.AssertFunction(dv)
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
res, err := detect(goja.Undefined(), v)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
return res.ToBoolean()
|
||||
}
|
||||
|
||||
func isCallable(v goja.Value) bool {
|
||||
_, ok := goja.AssertFunction(v)
|
||||
return ok
|
||||
}
|
||||
|
||||
// construct 从 Go 侧 new 一个 JS class 实例，构造参数按 goja 的规则转换。
|
||||
func construct(rt *goja.Runtime, class goja.Value, args []any) (*goja.Object, error) {
|
||||
ctor, ok := goja.AssertConstructor(class)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("不是构造器")
|
||||
}
|
||||
jsArgs := make([]goja.Value, len(args))
|
||||
for i, a := range args {
|
||||
jsArgs[i] = rt.ToValue(a)
|
||||
}
|
||||
return ctor(nil, jsArgs...)
|
||||
}
|
||||
|
||||
// lookup 找要调用的函数，同时给出调用时该绑定的 this。
|
||||
//
|
||||
// fn 为空取默认导出本身（export default function 那种）；否则找导出实例的方法，
|
||||
// this 绑定到实例，这样 class 里的 this.xxx 才有意义。
|
||||
//
|
||||
// 最后那层全局查找基本只是兜底：脚本经打包后是 IIFE，顶层声明进不了全局，
|
||||
// 只有脚本显式往 globalThis 上挂东西时才走得到。
|
||||
func (i *vmHandle) lookup(fn string) (callable goja.Callable, fnVal goja.Value, this goja.Value, ok bool) {
|
||||
if fn == DefaultFunc {
|
||||
if i.defFn == nil {
|
||||
return nil, nil, nil, false
|
||||
}
|
||||
callable, ok = goja.AssertFunction(i.defFn)
|
||||
return callable, i.defFn, goja.Undefined(), ok
|
||||
}
|
||||
|
||||
if i.exports != nil {
|
||||
// Get 会走原型链，class 方法定义在 prototype 上也找得到
|
||||
if v := i.exports.Get(fn); v != nil && !goja.IsUndefined(v) && !goja.IsNull(v) {
|
||||
if callable, ok = goja.AssertFunction(v); ok {
|
||||
return callable, v, i.exports, true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 静态方法挂在 class 自身上，不在实例的原型链上，所以实例那边找不到才轮到这里。
|
||||
// this 绑定到 class 本身，跟 JS 里 C.Startup() 的语义一致。
|
||||
if i.ctor != nil {
|
||||
if v := i.ctor.Get(fn); v != nil && !goja.IsUndefined(v) && !goja.IsNull(v) {
|
||||
if callable, ok = goja.AssertFunction(v); ok {
|
||||
return callable, v, i.ctor, true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
v := i.rt.Get(fn)
|
||||
if v == nil || goja.IsUndefined(v) || goja.IsNull(v) {
|
||||
return nil, nil, nil, false
|
||||
}
|
||||
if callable, ok = goja.AssertFunction(v); !ok {
|
||||
return nil, nil, nil, false
|
||||
}
|
||||
return callable, v, goja.Undefined(), true
|
||||
}
|
||||
|
||||
// notFoundHint 在找不到函数时给一句有用的话。最常见的原因是脚本压根没写 export：
|
||||
// 打包产物是 IIFE，没有导出的顶层代码会被当死代码摇掉，什么都不剩。
|
||||
func (s *Script) notFoundHint(inst *vmHandle) string {
|
||||
if inst.exports == nil && inst.defFn == nil {
|
||||
return "脚本没有任何导出。打包产物是 IIFE，不写 export 的顶层代码会被当死代码摇掉；" +
|
||||
"请用 export default 指明入口，或者用命名导出"
|
||||
}
|
||||
return "脚本里没有这个函数，或者它不是函数"
|
||||
}
|
||||
|
||||
+238
@@ -0,0 +1,238 @@
|
||||
package jscriptx
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
|
||||
"github.com/dop251/goja"
|
||||
)
|
||||
|
||||
// VM 的取、还、装载。
|
||||
//
|
||||
// 取 VM 只有 newVM 一个入口——三条路径（池化 borrow、实例 ensure、静态
|
||||
// borrowStatic）都走它，作用域注入和 scoped 标记的规则才只有一份。这两件事
|
||||
// 分散过一次，结果就是 borrowStatic 漏标了 scoped，带作用域的 VM 差点回池。
|
||||
|
||||
// borrow 从池里取一个 VM；池空就新建一个。
|
||||
//
|
||||
// 刻意不阻塞等待：并发量超过池容量时宁可临时多造几个 VM，也不让请求在这里排队。
|
||||
// 池只是复用缓存，不承担限流职责。
|
||||
//
|
||||
// ctx 带了作用域时**不走池**：池是所有调用共享的，而作用域的扩展是这一次调用专属的
|
||||
// （store、当前请求……）。混用要么让脚本看不见扩展（顶层 import 直接 ReferenceError），
|
||||
// 要么把上一个作用域的对象漏给下一个。所以为它单造一个 VM，用完丢弃。
|
||||
//
|
||||
// 代价是这类调用每次约 5μs 建一个 VM。同一作用域下要反复调，用 New 拿实例更划算——
|
||||
// 实例把 VM 攥在手里，不必每次重建。
|
||||
func (s *Script) borrow(ctx context.Context) (*vmHandle, error) {
|
||||
// 有作用域就必然要单造：池里的 VM 没装这个作用域的扩展
|
||||
sc, scoped := scopeOf(ctx)
|
||||
if !scoped {
|
||||
select {
|
||||
case inst := <-s.pool:
|
||||
return inst, nil
|
||||
default:
|
||||
}
|
||||
}
|
||||
return s.newVM(ctx, sc, nil, false)
|
||||
}
|
||||
|
||||
// release 归还 VM。healthy 为 false（被中断过或 panic 过）时直接丢弃：
|
||||
// 脚本本来就不该有跨调用状态，重建一个 VM 远比拖着一个状态可疑的 VM 划算。
|
||||
func (s *Script) release(inst *vmHandle, healthy bool) {
|
||||
if inst == nil {
|
||||
return
|
||||
}
|
||||
if !healthy || s.closed.Load() || inst.scoped {
|
||||
// scoped 的 VM 带着某个作用域的扩展，回池就会漏给下一个调用
|
||||
s.dropped.Add(1)
|
||||
return
|
||||
}
|
||||
select {
|
||||
case s.pool <- inst:
|
||||
default:
|
||||
s.dropped.Add(1) // 池满，丢弃
|
||||
}
|
||||
}
|
||||
|
||||
// newVM 造一个新 VM 并在里面加载这个脚本：注入白名单 → 跑一遍脚本顶层代码 →
|
||||
// 记下求值结果。
|
||||
//
|
||||
// **取 VM 的唯一入口**。三条路径（池化 borrow、实例 ensure、静态 borrowStatic）
|
||||
// 都走它，作用域注入和 scoped 标记的规则才只有一份——这两件事分散过一次，
|
||||
// 结果就是 borrowStatic 漏标了 scoped。
|
||||
//
|
||||
// sc 是这个 VM 属于哪个作用域，nil 表示不属于任何作用域。**显式传而不是从 ctx 嗅**：
|
||||
// Instance 重建 VM 时要回到它**创建时**那个作用域，而不是当次调用 ctx 里的那个——
|
||||
// 对一个作用域实例调 Call(context.Background()) 不该把它的扩展弄丢。
|
||||
//
|
||||
// ctorArgs 传给 constructor；noInstance 为 true 时不构造实例，只想调静态方法时用，
|
||||
// 避免白跑一遍 constructor（那是每次调用的准备工作）。
|
||||
func (s *Script) newVM(ctx context.Context, sc *scope, ctorArgs []any, noInstance bool) (*vmHandle, error) {
|
||||
var extra map[string]any
|
||||
if sc != nil {
|
||||
extra = sc.vmGlobals()
|
||||
}
|
||||
|
||||
rt := goja.New()
|
||||
if s.engine.maxStack > 0 {
|
||||
rt.SetMaxCallStackSize(s.engine.maxStack)
|
||||
}
|
||||
if err := s.engine.bind(rt, s.name, extra); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
vm, err := s.load(ctx, rt, ctorArgs, noInstance)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
// 带作用域的 VM 装着那个作用域的扩展，绝不能回池——release 靠这个标志拒绝它
|
||||
vm.scoped = sc != nil
|
||||
return vm, nil
|
||||
}
|
||||
|
||||
// load 把脚本装进一个 VM。noInstance 为 true 时不构造实例——
|
||||
// 只想调静态方法时用，避免白跑一遍 constructor（那是每次调用的准备工作）。
|
||||
func (s *Script) load(ctx context.Context, rt *goja.Runtime, ctorArgs []any, noInstance bool) (h *vmHandle, err error) {
|
||||
stop := guard(ctx, rt, s.engine.timeout)
|
||||
defer stop()
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
h, err = nil, s.panicError(DefaultFunc, nil, r)
|
||||
}
|
||||
}()
|
||||
|
||||
v, err := rt.RunProgram(s.prog)
|
||||
if err != nil {
|
||||
return nil, classify(err, s.name, DefaultFunc, nil)
|
||||
}
|
||||
|
||||
h = &vmHandle{rt: rt}
|
||||
// 打包产物末尾的入口表达式求值出来的东西决定了脚本的形态：
|
||||
// class → 由这里 new 出实例，构造参数从 Go 侧传（export default class X {}）
|
||||
// 普通函数 → 单函数入口，用 DefaultFunc 调用（export default function(){}）
|
||||
// 非函数对象 → 直接当导出实例（export default {...}，或只有命名导出时的模块对象）
|
||||
if !empty(v) {
|
||||
switch {
|
||||
case isClass(rt, v):
|
||||
h.ctor = v.ToObject(rt)
|
||||
if noInstance {
|
||||
break // 只要静态方法，不跑 constructor
|
||||
}
|
||||
obj, err := construct(rt, v, ctorArgs)
|
||||
if err != nil {
|
||||
return nil, classify(err, s.name, "constructor", ctorArgs)
|
||||
}
|
||||
h.exports = obj
|
||||
case isCallable(v):
|
||||
h.defFn = v
|
||||
default:
|
||||
if obj, ok := v.(*goja.Object); ok {
|
||||
h.exports = obj
|
||||
}
|
||||
}
|
||||
}
|
||||
s.created.Add(1)
|
||||
return h, nil
|
||||
}
|
||||
|
||||
// classDetector 判断一个值是不是 class。goja 的 AssertConstructor 对普通 function
|
||||
// 也返回 true，区分不了；靠规范保证的差别来判：class 的 prototype 属性不可写，
|
||||
// 普通函数的可写，箭头函数和方法简写根本没有 prototype。
|
||||
var classDetector = goja.MustCompile("jscriptx:isclass", `(function (x) {
|
||||
if (typeof x !== "function") { return false }
|
||||
var d = Object.getOwnPropertyDescriptor(x, "prototype")
|
||||
return !!d && d.writable === false
|
||||
})`, true)
|
||||
|
||||
func isClass(rt *goja.Runtime, v goja.Value) bool {
|
||||
if _, ok := goja.AssertConstructor(v); !ok {
|
||||
return false
|
||||
}
|
||||
dv, err := rt.RunProgram(classDetector)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
detect, ok := goja.AssertFunction(dv)
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
res, err := detect(goja.Undefined(), v)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
return res.ToBoolean()
|
||||
}
|
||||
|
||||
func isCallable(v goja.Value) bool {
|
||||
_, ok := goja.AssertFunction(v)
|
||||
return ok
|
||||
}
|
||||
|
||||
// construct 从 Go 侧 new 一个 JS class 实例，构造参数按 goja 的规则转换。
|
||||
func construct(rt *goja.Runtime, class goja.Value, args []any) (*goja.Object, error) {
|
||||
ctor, ok := goja.AssertConstructor(class)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("不是构造器")
|
||||
}
|
||||
jsArgs := make([]goja.Value, len(args))
|
||||
for i, a := range args {
|
||||
jsArgs[i] = rt.ToValue(a)
|
||||
}
|
||||
return ctor(nil, jsArgs...)
|
||||
}
|
||||
|
||||
// lookup 找要调用的函数，同时给出调用时该绑定的 this。
|
||||
//
|
||||
// fn 为空取默认导出本身（export default function 那种）；否则找导出实例的方法，
|
||||
// this 绑定到实例，这样 class 里的 this.xxx 才有意义。
|
||||
//
|
||||
// 最后那层全局查找基本只是兜底：脚本经打包后是 IIFE，顶层声明进不了全局，
|
||||
// 只有脚本显式往 globalThis 上挂东西时才走得到。
|
||||
func (i *vmHandle) lookup(fn string) (callable goja.Callable, fnVal goja.Value, this goja.Value, ok bool) {
|
||||
if fn == DefaultFunc {
|
||||
if i.defFn == nil {
|
||||
return nil, nil, nil, false
|
||||
}
|
||||
callable, ok = goja.AssertFunction(i.defFn)
|
||||
return callable, i.defFn, goja.Undefined(), ok
|
||||
}
|
||||
|
||||
if i.exports != nil {
|
||||
// Get 会走原型链，class 方法定义在 prototype 上也找得到
|
||||
if v := i.exports.Get(fn); v != nil && !goja.IsUndefined(v) && !goja.IsNull(v) {
|
||||
if callable, ok = goja.AssertFunction(v); ok {
|
||||
return callable, v, i.exports, true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 静态方法挂在 class 自身上，不在实例的原型链上，所以实例那边找不到才轮到这里。
|
||||
// this 绑定到 class 本身，跟 JS 里 C.Startup() 的语义一致。
|
||||
if i.ctor != nil {
|
||||
if v := i.ctor.Get(fn); v != nil && !goja.IsUndefined(v) && !goja.IsNull(v) {
|
||||
if callable, ok = goja.AssertFunction(v); ok {
|
||||
return callable, v, i.ctor, true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
v := i.rt.Get(fn)
|
||||
if v == nil || goja.IsUndefined(v) || goja.IsNull(v) {
|
||||
return nil, nil, nil, false
|
||||
}
|
||||
if callable, ok = goja.AssertFunction(v); !ok {
|
||||
return nil, nil, nil, false
|
||||
}
|
||||
return callable, v, goja.Undefined(), true
|
||||
}
|
||||
|
||||
// notFoundHint 在找不到函数时给一句有用的话。最常见的原因是脚本压根没写 export：
|
||||
// 打包产物是 IIFE，没有导出的顶层代码会被当死代码摇掉，什么都不剩。
|
||||
func (s *Script) notFoundHint(inst *vmHandle) string {
|
||||
if inst.exports == nil && inst.defFn == nil {
|
||||
return "脚本没有任何导出。打包产物是 IIFE，不写 export 的顶层代码会被当死代码摇掉；" +
|
||||
"请用 export default 指明入口，或者用命名导出"
|
||||
}
|
||||
return "脚本里没有这个函数，或者它不是函数"
|
||||
}
|
||||
Reference in New Issue
Block a user