evan/poiesis
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

asd

Browse Source
This commit is contained in:
Evan Reichard
2026-01-27 16:20:46 -05:00
parent 7bf4f115b1
commit c3a16c9e92
21 changed files with 1192 additions and 577 deletions
Download Patch File Download Diff File Expand all files Collapse all files

463
internal/runtime/pkg/builtin/builtin.go
View File

@@ -1,463 +0,0 @@
package builtin
import (
"fmt"
"reflect"
"strings"
"sync"
"github.com/dop251/goja"
)
type Builtin struct {
Name string
Function func(*goja.Runtime) func(goja.FunctionCall) goja.Value
Definition string
isPromise bool
}
type EmptyArgs struct{}
type RegisterOption func(*Builtin) error
func WithPromise() RegisterOption {
return func(b *Builtin) error {
b.isPromise = true
return nil
}
}
var (
builtinRegistry = make(map[string]Builtin)
registryMutex sync.RWMutex
)
func RegisterBuiltin[T any, R any](name string, fn any, opts ...RegisterOption) {
var zeroT T
tType := reflect.TypeOf(zeroT)
if tType.Kind() != reflect.Struct {
panic(fmt.Sprintf("builtin %s: argument must be a struct type, got %v", name, tType))
}
fnType := reflect.TypeOf(fn)
isPromise := false
for _, opt := range opts {
if opt != nil {
isPromise = true
break
}
}
wrapper := createWrapper[T](fn, fnType, isPromise)
registryMutex.Lock()
b := Builtin{
Name: name,
Function: wrapper,
Definition: generateTypeScriptDefinition(name, tType, fnType, isPromise),
}
for _, opt := range opts {
if opt != nil {
if err := opt(&b); err != nil {
panic(fmt.Sprintf("builtin %s: option error: %v", name, err))
}
}
}
builtinRegistry[name] = b
registryMutex.Unlock()
}
func createWrapper[T any](fn any, fnType reflect.Type, isPromise bool) func(*goja.Runtime) func(goja.FunctionCall) goja.Value {
return func(vm *goja.Runtime) func(goja.FunctionCall) goja.Value {
return func(call goja.FunctionCall) goja.Value {
var args T
argsValue := reflect.ValueOf(&args).Elem()
for i := 0; i < argsValue.NumField() && i < len(call.Arguments); i++ {
jsArg := call.Arguments[i]
field := argsValue.Field(i)
if goja.IsUndefined(jsArg) || goja.IsNull(jsArg) {
if field.Kind() == reflect.Pointer {
continue
}
}
converted, err := convertJSValueToGo(vm, jsArg, field.Type())
if err != nil {
panic(fmt.Sprintf("argument %d (%s): %v", i, getFieldName(argsValue.Type().Field(i)), err))
}
if converted != nil {
field.Set(reflect.ValueOf(converted))
}
}
if defaults, ok := any(args).(interface{ Defaults() T }); ok {
args = defaults.Defaults()
}
fnValue := reflect.ValueOf(fn)
firstParamType := fnType.In(0)
argValue := reflect.ValueOf(args).Convert(firstParamType)
results := fnValue.Call([]reflect.Value{argValue})
if len(results) == 0 {
return goja.Undefined()
}
if err, isError := results[len(results)-1].Interface().(error); isError {
if err != nil {
if isPromise {
return createRejectedPromise(vm, err)
}
panic(err)
}
if len(results) == 1 {
if isPromise {
return createResolvedPromise(vm)
}
return goja.Undefined()
}
if isPromise {
return createResolvedPromise(vm, results[0])
}
return convertGoValueToJS(vm, results[0])
}
if isPromise {
return createResolvedPromise(vm, results[0])
}
return convertGoValueToJS(vm, results[0])
}
}
}
func createResolvedPromise(vm *goja.Runtime, value ...reflect.Value) goja.Value {
promise, resolve, _ := vm.NewPromise()
go func() {
if len(value) > 0 {
jsValue := convertGoValueToJS(vm, value[0])
_ = resolve(jsValue)
} else {
_ = resolve(goja.Undefined())
}
}()
return vm.ToValue(promise)
}
func createRejectedPromise(vm *goja.Runtime, err error) goja.Value {
promise, _, reject := vm.NewPromise()
go func() {
_ = reject(vm.ToValue(err.Error()))
}()
return vm.ToValue(promise)
}
func convertJSValueToGo(vm *goja.Runtime, jsValue goja.Value, targetType reflect.Type) (any, error) {
if goja.IsNull(jsValue) {
if targetType.Kind() == reflect.Pointer || targetType.Kind() == reflect.Map {
return nil, nil
}
return nil, fmt.Errorf("cannot convert null/undefined to %v", targetType)
}
if goja.IsUndefined(jsValue) {
if targetType.Kind() == reflect.Pointer || targetType.Kind() == reflect.Map {
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 goja.IsUndefined(jsValue) || goja.IsNull(jsValue) {
return nil, nil
}
if targetType.Key().Kind() == reflect.String {
obj := jsValue.ToObject(vm)
if obj == nil {
return nil, fmt.Errorf("not an object")
}
if targetType.Elem().Kind() == reflect.Interface {
result := make(map[string]any)
for _, key := range obj.Keys() {
result[key] = obj.Get(key).Export()
}
return result, nil
} else if targetType.Elem().Kind() == reflect.String {
result := make(map[string]string)
for _, key := range obj.Keys() {
v := obj.Get(key)
result[key] = v.String()
}
return result, nil
}
}
return nil, fmt.Errorf("unsupported map type: %v", targetType)
case reflect.Struct:
obj := jsValue.ToObject(vm)
if obj == nil {
return nil, fmt.Errorf("not an object")
}
result := reflect.New(targetType).Elem()
for i := 0; i < targetType.NumField(); i++ {
field := targetType.Field(i)
fieldName := getFieldName(field)
jsField := obj.Get(fieldName)
var err error
var converted any
func() {
defer func() {
if r := recover(); r != nil {
// goja.Value was zero - treat as undefined
err = nil
converted = nil
}
}()
converted, err = convertJSValueToGo(vm, jsField, field.Type)
}()
if err != nil {
return nil, fmt.Errorf("field %s: %v", fieldName, err)
}
if converted == nil {
if field.Type.Kind() == reflect.Pointer || field.Type.Kind() == reflect.Map {
continue
}
} else {
result.Field(i).Set(reflect.ValueOf(converted))
}
}
return result.Interface(), nil
case reflect.Pointer:
if goja.IsNull(jsValue) || goja.IsUndefined(jsValue) {
return nil, nil
}
elemType := targetType.Elem()
converted, err := convertJSValueToGo(vm, jsValue, elemType)
if err != nil {
return nil, err
}
ptr := reflect.New(elemType)
ptr.Elem().Set(reflect.ValueOf(converted))
return ptr.Interface(), nil
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, convertGoValueToJS(vm, reflect.ValueOf(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)
default:
if goValue.Kind() == reflect.Pointer {
if goValue.IsNil() {
return goja.Null()
}
return convertGoValueToJS(vm, goValue.Elem())
}
if goValue.Kind() == reflect.Struct {
obj := vm.NewObject()
for i := 0; i < goValue.NumField(); i++ {
field := goValue.Type().Field(i)
fieldName := getFieldName(field)
_ = obj.Set(fieldName, convertGoValueToJS(vm, goValue.Field(i)))
}
return obj
}
return vm.ToValue(v)
}
}
func getFieldName(field reflect.StructField) string {
jsonTag := field.Tag.Get("json")
if jsonTag != "" && jsonTag != "-" {
name, _, _ := strings.Cut(jsonTag, ",")
return name
}
return field.Name
}
func generateTypeScriptDefinition(name string, argsType reflect.Type, fnType reflect.Type, isPromise bool) string {
if argsType.Kind() != reflect.Struct {
return ""
}
var params []string
for i := 0; i < argsType.NumField(); i++ {
field := argsType.Field(i)
fieldName := getFieldName(field)
goType := field.Type
tsType := goTypeToTSType(goType, goType.Kind() == reflect.Pointer)
params = append(params, fmt.Sprintf("%s: %s", fieldName, tsType))
}
returnSignature := "any"
if fnType.Kind() == reflect.Func && 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), false)
}
} else {
returnSignature = goTypeToTSType(lastType, false)
}
}
if isPromise {
returnSignature = fmt.Sprintf("Promise<%s>", returnSignature)
}
return fmt.Sprintf("declare function %s(%s): %s;", name, strings.Join(params, ", "), returnSignature)
}
func goTypeToTSType(t reflect.Type, isPointer bool) string {
if isPointer {
if t.Kind() == reflect.Pointer {
return goTypeToTSType(t.Elem(), false) + " | null"
}
return goTypeToTSType(t, false) + " | null"
}
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:
return "any"
case reflect.Slice:
return fmt.Sprintf("%s[]", goTypeToTSType(t.Elem(), false))
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:
fields := make([]string, 0, t.NumField())
for i := 0; i < t.NumField(); i++ {
field := t.Field(i)
name := getFieldName(field)
tsType := goTypeToTSType(field.Type, field.Type.Kind() == reflect.Pointer)
if field.Type.Kind() == reflect.Pointer {
tsType = strings.TrimSuffix(tsType, " | null")
tsType += "?"
} else if strings.Contains(field.Tag.Get("json"), ",omitempty") {
tsType += "?"
}
fields = append(fields, fmt.Sprintf("%s: %s", name, tsType))
}
return fmt.Sprintf("{ %s }", strings.Join(fields, "; "))
case reflect.Pointer:
if t.Elem().Kind() == reflect.Struct {
return goTypeToTSType(t.Elem(), false)
}
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 {
_ = vm.Set(name, builtin.Function(vm))
}
}

11
internal/runtime/runtime.go
View File

@@ -7,8 +7,7 @@ import (
"github.com/dop251/goja"
"github.com/evanw/esbuild/pkg/api"
"reichard.io/poiesis/internal/runtime/pkg/builtin"
_ "reichard.io/poiesis/internal/runtime/standard"
"reichard.io/poiesis/internal/builtin"
)
type Runtime struct {
@@ -18,12 +17,12 @@ type Runtime struct {
}
func New() *Runtime {
vm := goja.New()
r := &Runtime{vm: vm, stdout: os.Stdout, stderr: os.Stderr}
// Create Runtime
r := &Runtime{vm: goja.New(), stdout: os.Stdout, stderr: os.Stderr}
r.setupConsole()
builtin.RegisterBuiltins(vm)
// Register Builtins
builtin.RegisterBuiltins(r.vm)
return r
}

2
internal/runtime/runtime_test.go
View File

@@ -5,6 +5,8 @@ import (
"strings"
"testing"
_ "reichard.io/poiesis/internal/standard"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)

109
internal/runtime/standard/fetch.go
View File

@@ -1,109 +0,0 @@
package standard
import (
"fmt"
"io"
"maps"
"net/http"
"strings"
"reichard.io/poiesis/internal/runtime/pkg/builtin"
)
type FetchArgs struct {
Input string `json:"input"`
Init *FetchOptions `json:"init,omitempty"`
}
type FetchOptions struct {
Method string `json:"method,omitempty"`
Headers map[string]string `json:"headers,omitempty"`
Body *string `json:"body,omitempty"`
}
func (o *FetchOptions) Defaults() *FetchOptions {
if o.Method == "" {
o.Method = "GET"
}
return o
}
type FetchResult struct {
OK bool `json:"ok"`
Status int `json:"status"`
Body string `json:"body"`
Headers map[string]string `json:"headers"`
}
type AddArgs struct {
A int `json:"a"`
B int `json:"b"`
}
type GreetArgs struct {
Name string `json:"name"`
}
func Fetch(args FetchArgs) (*FetchResult, error) {
method := "GET"
headers := make(map[string]string)
if args.Init != nil {
method = args.Init.Method
if args.Init.Headers != nil {
maps.Copy(headers, args.Init.Headers)
}
}
req, err := http.NewRequest(method, args.Input, nil)
if err != nil {
return nil, fmt.Errorf("failed to create request: %w", err)
}
for k, v := range headers {
req.Header.Set(k, v)
}
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)
}
resultHeaders := make(map[string]string)
for key, values := range resp.Header {
if len(values) > 0 {
val := values[0]
resultHeaders[key] = val
resultHeaders[strings.ToLower(key)] = val
}
}
return &FetchResult{
OK: resp.StatusCode >= 200 && resp.StatusCode < 300,
Status: resp.StatusCode,
Body: string(body),
Headers: resultHeaders,
}, nil
}
func add(args AddArgs) int {
return args.A + args.B
}
func greet(args GreetArgs) string {
return fmt.Sprintf("Hello, %s!", args.Name)
}
func init() {
builtin.RegisterBuiltin[FetchArgs, *FetchResult]("fetch", Fetch, builtin.WithPromise())
builtin.RegisterBuiltin[AddArgs, int]("add", add)
builtin.RegisterBuiltin[GreetArgs, string]("greet", greet)
}

107
internal/runtime/standard/fetch_test.go
View File

@@ -1,107 +0,0 @@
package standard
import (
"net/http"
"net/http/httptest"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestFetch(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
w.Header().Set("X-Custom-Header", "test-value")
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(`{"status":"ok","message":"Hello from httptest"}`))
}))
defer server.Close()
result, err := Fetch(FetchArgs{Input: server.URL})
require.NoError(t, err)
assert.True(t, result.OK)
assert.Equal(t, http.StatusOK, result.Status)
assert.Contains(t, result.Body, "Hello from httptest")
assert.Contains(t, result.Body, `"status":"ok"`)
assert.Equal(t, "application/json", result.Headers["Content-Type"])
assert.Equal(t, "test-value", result.Headers["X-Custom-Header"])
}
func TestFetchHTTPBin(t *testing.T) {
t.Skip("httpbin.org test is flaky")
result, err := Fetch(FetchArgs{Input: "https://httpbin.org/get"})
require.NoError(t, err)
assert.True(t, result.OK)
assert.Equal(t, http.StatusOK, result.Status)
assert.Contains(t, result.Body, `"args"`)
assert.Equal(t, "application/json", result.Headers["Content-Type"])
}
func TestFetchWith404(t *testing.T) {
result, err := Fetch(FetchArgs{Input: "https://httpbin.org/status/404"})
require.NoError(t, err)
assert.False(t, result.OK)
assert.Equal(t, http.StatusNotFound, result.Status)
}
func TestFetchWithInvalidURL(t *testing.T) {
_, err := Fetch(FetchArgs{Input: "http://this-domain-does-not-exist-12345.com"})
assert.Error(t, err)
assert.Contains(t, err.Error(), "failed to fetch")
}
func TestFetchWithHeaders(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
assert.Equal(t, "Bearer test-token", r.Header.Get("Authorization"))
assert.Equal(t, "GET", r.Method)
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(`ok`))
}))
defer server.Close()
headers := map[string]string{
"Authorization": "Bearer test-token",
}
options := &FetchOptions{
Method: "GET",
Headers: headers,
}
result, err := Fetch(FetchArgs{Input: server.URL, Init: options})
require.NoError(t, err)
assert.True(t, result.OK)
}
func TestFetchDefaults(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
assert.Equal(t, "GET", r.Method, "default method should be GET")
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(`ok`))
}))
defer server.Close()
options := &FetchOptions{}
result, err := Fetch(FetchArgs{Input: server.URL, Init: options})
require.NoError(t, err)
assert.True(t, result.OK)
}
func TestAdd(t *testing.T) {
result := add(AddArgs{A: 5, B: 10})
assert.Equal(t, 15, result)
result = add(AddArgs{A: -3, B: 7})
assert.Equal(t, 4, result)
}
func TestGreet(t *testing.T) {
result := greet(GreetArgs{Name: "World"})
assert.Equal(t, "Hello, World!", result)
result = greet(GreetArgs{Name: "Alice"})
assert.Equal(t, "Hello, Alice!", result)
}