368 lines
8.6 KiB
Go
368 lines
8.6 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"reflect"
|
|
"strings"
|
|
"sync"
|
|
|
|
"github.com/dop251/goja"
|
|
)
|
|
|
|
type Builtin struct {
|
|
Name string
|
|
Function any
|
|
Definition string
|
|
}
|
|
|
|
var (
|
|
builtinRegistry = make(map[string]Builtin)
|
|
registryMutex sync.RWMutex
|
|
)
|
|
|
|
func RegisterBuiltin(name string, fn any) {
|
|
fnValue := reflect.ValueOf(fn)
|
|
fnType := fnValue.Type()
|
|
|
|
wrapper := createGenericWrapper(fnValue, fnType)
|
|
definition := generateTypeScriptDefinition(name, fnType)
|
|
|
|
builtinRegistry[name] = Builtin{
|
|
Name: name,
|
|
Function: wrapper,
|
|
Definition: definition,
|
|
}
|
|
}
|
|
|
|
func createGenericWrapper(fnValue reflect.Value, fnType reflect.Type) any {
|
|
return func(vm *goja.Runtime) any {
|
|
return func(call goja.FunctionCall) goja.Value {
|
|
args := make([]reflect.Value, fnType.NumIn())
|
|
|
|
for i := 0; i < fnType.NumIn(); i++ {
|
|
argType := fnType.In(i)
|
|
var jsArg goja.Value
|
|
|
|
if i < len(call.Arguments) {
|
|
jsArg = call.Arguments[i]
|
|
} else {
|
|
jsArg = goja.Undefined()
|
|
}
|
|
|
|
if goja.IsUndefined(jsArg) || goja.IsNull(jsArg) {
|
|
if argType.Kind() == reflect.Map {
|
|
args[i] = reflect.MakeMap(argType)
|
|
continue
|
|
}
|
|
if argType.Kind() == reflect.Interface {
|
|
args[i] = reflect.Zero(argType)
|
|
continue
|
|
}
|
|
}
|
|
|
|
converted, err := convertJSValueToGo(vm, jsArg, argType)
|
|
if err != nil {
|
|
panic(fmt.Sprintf("argument %d: %v", i, err))
|
|
}
|
|
args[i] = reflect.ValueOf(converted)
|
|
}
|
|
|
|
results := fnValue.Call(args)
|
|
|
|
if len(results) == 0 {
|
|
return goja.Undefined()
|
|
}
|
|
|
|
lastResult := results[len(results)-1]
|
|
if lastResult.Type().Implements(reflect.TypeOf((*error)(nil)).Elem()) {
|
|
if !lastResult.IsNil() {
|
|
panic(fmt.Sprintf("error: %v", lastResult.Interface()))
|
|
}
|
|
if len(results) == 1 {
|
|
return goja.Undefined()
|
|
}
|
|
return convertGoValueToJS(vm, results[0])
|
|
}
|
|
|
|
return convertGoValueToJS(vm, results[0])
|
|
}
|
|
}
|
|
}
|
|
|
|
func convertJSValueToGo(vm *goja.Runtime, jsValue goja.Value, targetType reflect.Type) (any, error) {
|
|
if goja.IsUndefined(jsValue) || goja.IsNull(jsValue) {
|
|
if targetType.Kind() == reflect.Interface || targetType.Kind() == reflect.Pointer {
|
|
return nil, nil
|
|
}
|
|
return nil, fmt.Errorf("cannot convert null/undefined to %v", targetType)
|
|
}
|
|
|
|
switch targetType.Kind() {
|
|
case reflect.String:
|
|
return jsValue.String(), nil
|
|
|
|
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
|
n, ok := jsValue.Export().(int64)
|
|
if !ok {
|
|
return nil, fmt.Errorf("expected int, got %T", jsValue.Export())
|
|
}
|
|
return reflect.ValueOf(n).Convert(targetType).Interface(), nil
|
|
|
|
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
|
|
n, ok := jsValue.Export().(int64)
|
|
if !ok {
|
|
return nil, fmt.Errorf("expected uint, got %T", jsValue.Export())
|
|
}
|
|
return reflect.ValueOf(uint(n)).Convert(targetType).Interface(), nil
|
|
|
|
case reflect.Float32, reflect.Float64:
|
|
n, ok := jsValue.Export().(float64)
|
|
if !ok {
|
|
return nil, fmt.Errorf("expected float, got %T", jsValue.Export())
|
|
}
|
|
return reflect.ValueOf(n).Convert(targetType).Interface(), nil
|
|
|
|
case reflect.Bool:
|
|
return jsValue.ToBoolean(), nil
|
|
|
|
case reflect.Interface:
|
|
return jsValue.Export(), nil
|
|
|
|
case reflect.Map:
|
|
if targetType.Key().Kind() == reflect.String && targetType.Elem().Kind() == reflect.Interface {
|
|
obj := jsValue.ToObject(vm)
|
|
if obj == nil {
|
|
return nil, fmt.Errorf("not an object")
|
|
}
|
|
|
|
result := make(map[string]any)
|
|
for _, key := range obj.Keys() {
|
|
result[key] = obj.Get(key).Export()
|
|
}
|
|
return result, nil
|
|
}
|
|
return nil, fmt.Errorf("unsupported map type: %v", targetType)
|
|
|
|
default:
|
|
return nil, fmt.Errorf("unsupported type: %v", targetType)
|
|
}
|
|
}
|
|
|
|
func convertGoValueToJS(vm *goja.Runtime, goValue reflect.Value) goja.Value {
|
|
value := goValue.Interface()
|
|
|
|
switch v := value.(type) {
|
|
case string, int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64, bool:
|
|
return vm.ToValue(v)
|
|
|
|
case error:
|
|
return vm.ToValue(v.Error())
|
|
|
|
case map[string]string:
|
|
obj := vm.NewObject()
|
|
for key, val := range v {
|
|
_ = obj.Set(key, val)
|
|
}
|
|
return obj
|
|
|
|
case map[string]any:
|
|
obj := vm.NewObject()
|
|
for key, val := range v {
|
|
_ = obj.Set(key, val)
|
|
}
|
|
return obj
|
|
|
|
case []any:
|
|
arr := make([]goja.Value, len(v))
|
|
for i, item := range v {
|
|
arr[i] = convertGoValueToJS(vm, reflect.ValueOf(item))
|
|
}
|
|
return vm.ToValue(arr)
|
|
|
|
case FetchResult:
|
|
obj := vm.NewObject()
|
|
_ = obj.Set("ok", v.OK)
|
|
_ = obj.Set("status", v.Status)
|
|
_ = obj.Set("text", func() string {
|
|
return v.Body
|
|
})
|
|
|
|
headersObj := vm.NewObject()
|
|
headers := v.Headers
|
|
_ = headersObj.Set("get", func(c goja.FunctionCall) goja.Value {
|
|
if len(c.Arguments) < 1 {
|
|
return goja.Undefined()
|
|
}
|
|
key := c.Arguments[0].String()
|
|
return vm.ToValue(headers[key])
|
|
})
|
|
_ = obj.Set("headers", headersObj)
|
|
|
|
return obj
|
|
|
|
case *FetchResult:
|
|
if v == nil {
|
|
return goja.Null()
|
|
}
|
|
return convertGoValueToJS(vm, reflect.ValueOf(*v))
|
|
|
|
default:
|
|
return vm.ToValue(v)
|
|
}
|
|
}
|
|
|
|
func generateTypeScriptDefinition(name string, fnType reflect.Type) string {
|
|
if fnType.Kind() != reflect.Func {
|
|
return ""
|
|
}
|
|
|
|
var params []string
|
|
for i := 0; i < fnType.NumIn(); i++ {
|
|
paramName := fmt.Sprintf("arg%d", i)
|
|
if fnType.In(i).Kind() == reflect.Pointer {
|
|
ptrType := fnType.In(i).Elem()
|
|
if ptrType.Kind() == reflect.Struct {
|
|
if s, ok := extractStructParamName(ptrType); ok {
|
|
paramName = s
|
|
}
|
|
}
|
|
}
|
|
params = append(params, fmt.Sprintf("%s: %s", paramName, goTypeToTSType(fnType.In(i))))
|
|
}
|
|
|
|
returnSignature := "void"
|
|
if fnType.NumOut() > 0 {
|
|
lastIndex := fnType.NumOut() - 1
|
|
lastType := fnType.Out(lastIndex)
|
|
|
|
if lastType.Implements(reflect.TypeOf((*error)(nil)).Elem()) {
|
|
if fnType.NumOut() > 1 {
|
|
returnSignature = goTypeToTSType(fnType.Out(0))
|
|
} else {
|
|
returnSignature = "void"
|
|
}
|
|
} else {
|
|
returnSignature = goTypeToTSType(lastType)
|
|
}
|
|
}
|
|
|
|
return fmt.Sprintf("declare function %s(%s): %s;", name, strings.Join(params, ", "), returnSignature)
|
|
}
|
|
|
|
func extractStructParamName(structType reflect.Type) (string, bool) {
|
|
if structType.Name() != "" {
|
|
return strings.ToLower(structType.Name()), true
|
|
}
|
|
return "", false
|
|
}
|
|
|
|
func goTypeToTSType(t reflect.Type) string {
|
|
switch t.Kind() {
|
|
case reflect.String:
|
|
return "string"
|
|
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
|
return "number"
|
|
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
|
|
return "number"
|
|
case reflect.Float32, reflect.Float64:
|
|
return "number"
|
|
case reflect.Bool:
|
|
return "boolean"
|
|
case reflect.Interface, reflect.Pointer:
|
|
return "any"
|
|
case reflect.Slice:
|
|
return fmt.Sprintf("%s[]", goTypeToTSType(t.Elem()))
|
|
case reflect.Map:
|
|
if t.Key().Kind() == reflect.String && t.Elem().Kind() == reflect.Interface {
|
|
return "Record<string, any>"
|
|
}
|
|
return "Record<string, any>"
|
|
case reflect.Struct:
|
|
if t.Name() == "FetchResult" {
|
|
return "Response"
|
|
}
|
|
return "any"
|
|
default:
|
|
return "any"
|
|
}
|
|
}
|
|
|
|
func GetBuiltinsDeclarations() string {
|
|
registryMutex.RLock()
|
|
defer registryMutex.RUnlock()
|
|
|
|
var decls []string
|
|
for _, builtin := range builtinRegistry {
|
|
decls = append(decls, builtin.Definition)
|
|
}
|
|
return strings.Join(decls, "\n")
|
|
}
|
|
|
|
func RegisterBuiltins(vm *goja.Runtime) {
|
|
registryMutex.RLock()
|
|
defer registryMutex.RUnlock()
|
|
|
|
for name, builtin := range builtinRegistry {
|
|
if wrapperFactory, ok := builtin.Function.(func(*goja.Runtime) any); ok {
|
|
_ = vm.Set(name, wrapperFactory(vm))
|
|
} else {
|
|
_ = vm.Set(name, builtin.Function)
|
|
}
|
|
}
|
|
}
|
|
|
|
type FetchResult struct {
|
|
OK bool
|
|
Status int
|
|
Body string
|
|
Headers map[string]string
|
|
}
|
|
|
|
func Fetch(url string, options map[string]any) (*FetchResult, error) {
|
|
req, err := http.NewRequest("GET", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to create request: %w", err)
|
|
}
|
|
|
|
resp, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to fetch: %w", err)
|
|
}
|
|
defer func() {
|
|
_ = resp.Body.Close()
|
|
}()
|
|
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to read body: %w", err)
|
|
}
|
|
|
|
headers := make(map[string]string)
|
|
for key, values := range resp.Header {
|
|
if len(values) > 0 {
|
|
val := values[0]
|
|
headers[key] = val
|
|
headers[strings.ToLower(key)] = val
|
|
}
|
|
}
|
|
|
|
return &FetchResult{
|
|
OK: resp.StatusCode >= 200 && resp.StatusCode < 300,
|
|
Status: resp.StatusCode,
|
|
Body: string(body),
|
|
Headers: headers,
|
|
}, nil
|
|
}
|
|
|
|
func init() {
|
|
RegisterBuiltin("fetch", Fetch)
|
|
RegisterBuiltin("add", func(a, b int) int {
|
|
return a + b
|
|
})
|
|
RegisterBuiltin("greet", func(name string) string {
|
|
return fmt.Sprintf("Hello, %s!", name)
|
|
})
|
|
}
|