(no tests) updated jsvm bindings

plugins/jsvm/binds.go

@@ -2,26 +2,212 @@ package jsvm
 
 import (
 	"encoding/json"
+	"errors"
 	"reflect"
+	"strings"
 
 	"github.com/dop251/goja"
 	validation "github.com/go-ozzo/ozzo-validation/v4"
 	"github.com/labstack/echo/v5"
 	"github.com/pocketbase/dbx"
 	"github.com/pocketbase/pocketbase/apis"
+	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/daos"
 	"github.com/pocketbase/pocketbase/forms"
 	"github.com/pocketbase/pocketbase/models"
 	"github.com/pocketbase/pocketbase/models/schema"
 	"github.com/pocketbase/pocketbase/tokens"
+	"github.com/pocketbase/pocketbase/tools/cron"
 	"github.com/pocketbase/pocketbase/tools/filesystem"
+	"github.com/pocketbase/pocketbase/tools/hook"
 	"github.com/pocketbase/pocketbase/tools/inflector"
+	"github.com/pocketbase/pocketbase/tools/list"
 	"github.com/pocketbase/pocketbase/tools/mailer"
 	"github.com/pocketbase/pocketbase/tools/security"
 	"github.com/pocketbase/pocketbase/tools/types"
 	"github.com/spf13/cobra"
 )
 
+// hooksBinds adds wrapped "on*" hook methods by reflecting on core.App.
+func hooksBinds(app core.App, loader *goja.Runtime, executors *vmsPool) {
+	fm := FieldMapper{}
+
+	appType := reflect.TypeOf(app)
+	appValue := reflect.ValueOf(app)
+	totalMethods := appType.NumMethod()
+	excludeHooks := []string{"OnBeforeServe"}
+
+	for i := 0; i < totalMethods; i++ {
+		method := appType.Method(i)
+		if !strings.HasPrefix(method.Name, "On") || list.ExistInSlice(method.Name, excludeHooks) {
+			continue // not a hook or excluded
+		}
+
+		jsName := fm.MethodName(appType, method)
+
+		// register the hook to the loader
+		loader.Set(jsName, func(callback string, tags ...string) {
+			pr := goja.MustCompile("", "{("+callback+").apply(undefined, __args)}", true)
+
+			tagsAsValues := make([]reflect.Value, len(tags))
+			for i, tag := range tags {
+				tagsAsValues[i] = reflect.ValueOf(tag)
+			}
+
+			hookInstance := appValue.MethodByName(method.Name).Call(tagsAsValues)[0]
+			addFunc := hookInstance.MethodByName("Add")
+
+			handlerType := addFunc.Type().In(0)
+
+			handler := reflect.MakeFunc(handlerType, func(args []reflect.Value) (results []reflect.Value) {
+				handlerArgs := make([]any, len(args))
+				for i, arg := range args {
+					handlerArgs[i] = arg.Interface()
+				}
+
+				err := executors.run(func(executor *goja.Runtime) error {
+					executor.Set("__args", handlerArgs)
+					res, err := executor.RunProgram(pr)
+					executor.Set("__args", goja.Undefined())
+
+					// check for returned hook.StopPropagation
+					if res != nil {
+						if v, ok := res.Export().(error); ok {
+							return v
+						}
+					}
+
+					// check for throwed hook.StopPropagation
+					if err != nil {
+						exception, ok := err.(*goja.Exception)
+						if ok && errors.Is(exception.Value().Export().(error), hook.StopPropagation) {
+							return hook.StopPropagation
+						}
+					}
+
+					return err
+				})
+
+				return []reflect.Value{reflect.ValueOf(&err).Elem()}
+			})
+
+			// register the wrapped hook handler
+			addFunc.Call([]reflect.Value{handler})
+		})
+	}
+}
+
+func cronBinds(app core.App, loader *goja.Runtime, executors *vmsPool) {
+	jobs := cron.New()
+
+	loader.Set("cronAdd", func(jobId, cronExpr, handler string) {
+		pr := goja.MustCompile("", "{("+handler+").apply(undefined)}", true)
+
+		err := jobs.Add(jobId, cronExpr, func() {
+			executors.run(func(executor *goja.Runtime) error {
+				_, err := executor.RunProgram(pr)
+				return err
+			})
+		})
+		if err != nil {
+			panic("[cronAdd] failed to register cron job " + jobId + ": " + err.Error())
+		}
+
+		// start the ticker (if not already)
+		if jobs.Total() > 0 && !jobs.HasStarted() {
+			jobs.Start()
+		}
+	})
+
+	loader.Set("cronRemove", func(jobId string) {
+		jobs.Remove(jobId)
+
+		// stop the ticker if there are no other jobs
+		if jobs.Total() == 0 {
+			jobs.Stop()
+		}
+	})
+}
+
+func routerBinds(app core.App, loader *goja.Runtime, executors *vmsPool) {
+	loader.Set("routerAdd", func(method string, path string, handler string, middlewares ...goja.Value) {
+		wrappedMiddlewares, err := wrapMiddlewares(executors, middlewares...)
+		if err != nil {
+			panic("[routerAdd] failed to wrap middlewares: " + err.Error())
+		}
+
+		pr := goja.MustCompile("", "{("+handler+").apply(undefined, __args)}", true)
+
+		app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
+			e.Router.Add(strings.ToUpper(method), path, func(c echo.Context) error {
+				return executors.run(func(executor *goja.Runtime) error {
+					executor.Set("__args", []any{c})
+					_, err := executor.RunProgram(pr)
+					executor.Set("__args", goja.Undefined())
+					return err
+				})
+			}, wrappedMiddlewares...)
+
+			return nil
+		})
+	})
+
+	loader.Set("routerUse", func(middlewares ...goja.Value) {
+		wrappedMiddlewares, err := wrapMiddlewares(executors, middlewares...)
+		if err != nil {
+			panic("[routerUse] failed to wrap middlewares: " + err.Error())
+		}
+
+		app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
+			e.Router.Use(wrappedMiddlewares...)
+			return nil
+		})
+	})
+
+	loader.Set("routerPre", func(middlewares ...goja.Value) {
+		wrappedMiddlewares, err := wrapMiddlewares(executors, middlewares...)
+		if err != nil {
+			panic("[routerPre] failed to wrap middlewares: " + err.Error())
+		}
+
+		app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
+			e.Router.Pre(wrappedMiddlewares...)
+			return nil
+		})
+	})
+}
+
+func wrapMiddlewares(executors *vmsPool, rawMiddlewares ...goja.Value) ([]echo.MiddlewareFunc, error) {
+	wrappedMiddlewares := make([]echo.MiddlewareFunc, len(rawMiddlewares))
+
+	for i, m := range rawMiddlewares {
+		switch v := m.Export().(type) {
+		case echo.MiddlewareFunc:
+			// "native" middleware - no need to wrap
+			wrappedMiddlewares[i] = v
+		case func(goja.FunctionCall) goja.Value, string:
+			pr := goja.MustCompile("", "{(("+m.String()+").apply(undefined, __args)).apply(undefined, __args2)}", true)
+
+			wrappedMiddlewares[i] = func(next echo.HandlerFunc) echo.HandlerFunc {
+				return func(c echo.Context) error {
+					return executors.run(func(executor *goja.Runtime) error {
+						executor.Set("__args", []any{next})
+						executor.Set("__args2", []any{c})
+						_, err := executor.RunProgram(pr)
+						executor.Set("__args", goja.Undefined())
+						executor.Set("__args2", goja.Undefined())
+						return err
+					})
+				}
+			}
+		default:
+			return nil, errors.New("unsupported goja middleware type")
+		}
+	}
+
+	return wrappedMiddlewares, nil
+}
+
 func baseBinds(vm *goja.Runtime) {
 	vm.SetFieldNameMapper(FieldMapper{})
 
@@ -48,7 +234,7 @@ func baseBinds(vm *goja.Runtime) {
 		}
 	`)
 
-	vm.Set("$arrayOf", func(model any) any {
+	vm.Set("arrayOf", func(model any) any {
 		mt := reflect.TypeOf(model)
 		st := reflect.SliceOf(mt)
 		elem := reflect.New(st).Elem()
@@ -147,6 +333,8 @@ func baseBinds(vm *goja.Runtime) {
 
 		return instanceValue
 	})
+
+	vm.Set("$stopPropagation", hook.StopPropagation)
 }
 
 func dbxBinds(vm *goja.Runtime) {
@@ -253,11 +441,6 @@ func apisBinds(vm *goja.Runtime) {
 	obj := vm.NewObject()
 	vm.Set("$apis", obj)
 
-	vm.Set("Route", func(call goja.ConstructorCall) *goja.Object {
-		instance := &echo.Route{}
-		return structConstructor(vm, call, instance)
-	})
-
 	// middlewares
 	obj.Set("requireRecordAuth", apis.RequireRecordAuth)
 	obj.Set("requireAdminAuth", apis.RequireAdminAuth)

plugins/jsvm/binds_test.go

@@ -38,7 +38,7 @@ func TestBaseBindsCount(t *testing.T) {
 	vm := goja.New()
 	baseBinds(vm)
 
-	testBindsCount(vm, "this", 14, t)
+	testBindsCount(vm, "this", 15, t)
 }
 
 func TestBaseBindsRecord(t *testing.T) {
@@ -682,48 +682,10 @@ func TestApisBindsCount(t *testing.T) {
 	vm := goja.New()
 	apisBinds(vm)
 
-	testBindsCount(vm, "this", 7, t)
+	testBindsCount(vm, "this", 6, t)
 	testBindsCount(vm, "$apis", 10, t)
 }
 
-func TestApisBindsRoute(t *testing.T) {
-	app, _ := tests.NewTestApp()
-	defer app.Cleanup()
-
-	vm := goja.New()
-	baseBinds(vm)
-	apisBinds(vm)
-
-	_, err := vm.RunString(`
-		let handlerCalls = 0;
-
-		const route = new Route({
-			method: "test_method",
-			path: "test_path",
-			handler: () => {
-				handlerCalls++;
-			}
-		});
-
-		route.handler();
-
-		if (handlerCalls != 1) {
-			throw new Error('Expected handlerCalls 1, got ' + handlerCalls);
-		}
-
-		if (route.method != "test_method") {
-			throw new Error('Expected method "test_method", got ' + route.method);
-		}
-
-		if (route.path != "test_path") {
-			throw new Error('Expected method "test_path", got ' + route.path);
-		}
-	`)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
 func TestApisBindsApiError(t *testing.T) {
 	app, _ := tests.NewTestApp()
 	defer app.Cleanup()
@@ -843,7 +805,7 @@ func TestLoadingArrayOf(t *testing.T) {
 	vm.Set("$app", app)
 
 	_, err := vm.RunString(`
-		let result = $arrayOf(new DynamicModel({
+		let result = arrayOf(new DynamicModel({
 			id:   "",
 			text: "",
 		}))

plugins/jsvm/internal/docs/docs.go

@@ -4,16 +4,96 @@ import (
 	"log"
 	"os"
 	"reflect"
+	"strings"
 
+	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/plugins/jsvm"
+	"github.com/pocketbase/pocketbase/tools/list"
 	"github.com/pocketbase/tygoja"
 )
 
 const heading = `
+// -------------------------------------------------------------------
+// routerBinds
+// -------------------------------------------------------------------
+
+/**
+ * RouterAdd registers a new route definition.
+ *
+ * Example:
+ *
+ * ` + "```" + `js
+ * routerAdd("GET", "/hello", (c) => {
+ *     return c.json(200, {"message": "Hello!"})
+ * }, $apis.requireAdminOrRecordAuth())
+ * ` + "```" + `
+ *
+ * _Note that this method is available only in pb_hooks context._
+ *
+ * @group PocketBase
+ */
+declare function routerAdd(
+  method: string,
+  path: string,
+  handler: echo.HandlerFunc,
+  ...middlewares: Array<string|echo.MiddlewareFunc>,
+): void;
+
+/**
+ * RouterUse registers one or more global middlewares that are executed
+ * along the handler middlewares after a matching route is found.
+ *
+ * Example:
+ *
+ * ` + "```" + `js
+ * routerUse((next) => {
+ *     return (c) => {
+ *         console.log(c.Path())
+ *         return next(c)
+ *     }
+ * })
+ * ` + "```" + `
+ *
+ * _Note that this method is available only in pb_hooks context._
+ *
+ * @group PocketBase
+ */
+declare function routerUse(...middlewares: Array<string|echo.MiddlewareFunc>): void;
+
+/**
+ * RouterPre registers one or more global middlewares that are executed
+ * BEFORE the router processes the request. It is usually used for making
+ * changes to the request properties, for example, adding or removing
+ * a trailing slash or adding segments to a path so it matches a route.
+ *
+ * NB! Since the router will not have processed the request yet,
+ * middlewares registered at this level won't have access to any path
+ * related APIs from echo.Context.
+ *
+ * Example:
+ *
+ * ` + "```" + `js
+ * routerPre((next) => {
+ *     return (c) => {
+ *         console.log(c.request().url)
+ *         return next(c)
+ *     }
+ * })
+ * ` + "```" + `
+ *
+ * _Note that this method is available only in pb_hooks context._
+ *
+ * @group PocketBase
+ */
+declare function routerPre(...middlewares: Array<string|echo.MiddlewareFunc>): void;
+
 // -------------------------------------------------------------------
 // baseBinds
 // -------------------------------------------------------------------
 
+// skip on* hook methods as they are registered via the global on* method
+type appWithoutHooks = Omit<pocketbase.PocketBase, ` + "`on${string}`" + `>
+
 /**
  * $app is the current running PocketBase instance that is globally
  * available in each .pb.js file.
@@ -21,23 +101,23 @@ const heading = `
  * @namespace
  * @group PocketBase
  */
-declare var $app: pocketbase.PocketBase
+declare var $app: appWithoutHooks
 
 /**
- * $arrayOf creates a placeholder array of the specified models.
+ * arrayOf creates a placeholder array of the specified models.
  * Usually used to populate DB result into an array of models.
  *
  * Example:
  *
  * ` + "```" + `js
- * const records = $arrayOf(new Record)
+ * const records = arrayOf(new Record)
  *
  * $app.dao().recordQuery(collection).limit(10).all(records)
  * ` + "```" + `
  *
  * @group PocketBase
  */
-declare function $arrayOf<T>(model: T): Array<T>;
+declare function arrayOf<T>(model: T): Array<T>;
 
 /**
  * DynamicModel creates a new dynamic model with fields from the provided data shape.
@@ -498,27 +578,6 @@ declare class TestS3FilesystemForm implements forms.TestS3Filesystem {
 // apisBinds
 // -------------------------------------------------------------------
 
-interface Route extends echo.Route{} // merge
-/**
- * Route specifies a new route definition.
- * This is usually used when registering routes with router.addRoute().
- *
- * ` + "```" + `js
- * const route = new Route({
- *     path: "/hello",
- *     handler: (c) => {
- *         c.string(200, "hello world!")
- *     },
- *     middlewares: [$apis.activityLogger($app)]
- * })
- * ` + "```" + `
- *
- * @group PocketBase
- */
-declare class Route implements echo.Route {
-  constructor(data?: Partial<echo.Route>)
-}
-
 interface ApiError extends apis.ApiError{} // merge
 /**
  * @inheritDoc
@@ -594,7 +653,7 @@ declare namespace $apis {
 /**
  * Migrate defines a single migration upgrade/downgrade action.
  *
- * Note that this method is available only in pb_migrations context.
+ * _Note that this method is available only in pb_migrations context._
  *
  * @group PocketBase
  */
@@ -604,8 +663,10 @@ declare function migrate(
 ): void;
 `
 
+var mapper = &jsvm.FieldMapper{}
+
 func main() {
-	mapper := &jsvm.FieldMapper{}
+	declarations := heading + hooksDeclarations()
 
 	gen := tygoja.New(tygoja.Config{
 		Packages: map[string][]string{
@@ -626,7 +687,7 @@ func main() {
 		},
 		Indent:               " ", // use only a single space to reduce slight the size
 		WithPackageFunctions: true,
-		Heading:              heading,
+		Heading:              declarations,
 	})
 
 	result, err := gen.Generate()
@@ -638,3 +699,45 @@ func main() {
 		log.Fatal(err)
 	}
 }
+
+func hooksDeclarations() string {
+	var result strings.Builder
+
+	excluded := []string{"OnBeforeServe"}
+	appType := reflect.TypeOf(struct{ core.App }{})
+	totalMethods := appType.NumMethod()
+
+	for i := 0; i < totalMethods; i++ {
+		method := appType.Method(i)
+		if !strings.HasPrefix(method.Name, "On") || list.ExistInSlice(method.Name, excluded) {
+			continue // not a hook or excluded
+		}
+
+		hookType := method.Type.Out(0)
+
+		withTags := strings.HasPrefix(hookType.String(), "*hook.TaggedHook")
+
+		addMethod, ok := hookType.MethodByName("Add")
+		if !ok {
+			continue
+		}
+
+		addHanlder := addMethod.Type.In(1)
+		eventTypeName := strings.TrimPrefix(addHanlder.In(0).String(), "*")
+
+		jsName := mapper.MethodName(appType, method)
+		result.WriteString("/** @group PocketBase */")
+		result.WriteString("declare function ")
+		result.WriteString(jsName)
+		result.WriteString("(handler: (e: ")
+		result.WriteString(eventTypeName)
+		result.WriteString(") => void")
+		if withTags {
+			result.WriteString(", ...tags: string[]")
+		}
+		result.WriteString("): void")
+		result.WriteString("\n")
+	}
+
+	return result.String()
+}

plugins/jsvm/jsvm.go

@@ -18,7 +18,6 @@ import (
 
 	"github.com/dop251/goja"
 	"github.com/dop251/goja_nodejs/console"
-	"github.com/dop251/goja_nodejs/eventloop"
 	"github.com/dop251/goja_nodejs/process"
 	"github.com/dop251/goja_nodejs/require"
 	"github.com/fatih/color"
@@ -49,6 +48,13 @@ type Config struct {
 	// If not set it fallbacks to a relative "pb_data/../pb_hooks" directory.
 	HooksDir string
 
+	// HooksPoolSize specifies how many goja.Runtime instances to preinit
+	// and keep for the JS app hooks gorotines execution.
+	//
+	// Zero or negative value means that it will create a new goja.Runtime
+	// on every fired goroutine.
+	HooksPoolSize int
+
 	// MigrationsDir specifies the JS migrations directory.
 	//
 	// If not set it fallbacks to a relative "pb_data/../pb_migrations" directory.
@@ -172,11 +178,10 @@ func (p *plugin) registerHooks() error {
 		}
 	}
 
-	registry := new(require.Registry) // this can be shared by multiple runtimes
+	// this is safe to be shared across multiple vms
+	registry := new(require.Registry)
 
-	loop := eventloop.NewEventLoop()
+	sharedBinds := func(vm *goja.Runtime) {
-
-	loop.Run(func(vm *goja.Runtime) {
 		registry.Enable(vm)
 		console.Enable(vm)
 		process.Enable(vm)
@@ -186,11 +191,25 @@ func (p *plugin) registerHooks() error {
 		securityBinds(vm)
 		formsBinds(vm)
 		apisBinds(vm)
-
 		vm.Set("$app", p.app)
+	}
+
+	// initiliaze the executor vms
+	executors := newPool(p.config.HooksPoolSize, func() *goja.Runtime {
+		executor := goja.New()
+		sharedBinds(executor)
+		return executor
+	})
+
+	// initialize the loader vm
+	loader := goja.New()
+	sharedBinds(loader)
+	hooksBinds(p.app, loader, executors)
+	cronBinds(p.app, loader, executors)
+	routerBinds(p.app, loader, executors)
 
 	for file, content := range files {
-			_, err := vm.RunString(string(content))
+		_, err := loader.RunString(string(content))
 		if err != nil {
 			if p.config.HooksWatch {
 				color.Red("Failed to execute %s: %v", file, err)
@@ -199,13 +218,8 @@ func (p *plugin) registerHooks() error {
 			}
 		}
 	}
-	})
-
-	loop.Start()
 
 	p.app.OnTerminate().Add(func(e *core.TerminateEvent) error {
-		loop.StopNoWait()
-
 		return nil
 	})
 
@@ -243,11 +257,12 @@ func (p *plugin) watchHooks() error {
 
 	// start listening for events.
 	go func() {
+		defer stopDebounceTimer()
+
 		for {
 			select {
 			case event, ok := <-watcher.Events:
 				if !ok {
-					stopDebounceTimer()
 					return
 				}
 
@@ -266,7 +281,6 @@ func (p *plugin) watchHooks() error {
 				})
 			case err, ok := <-watcher.Errors:
 				if !ok {
-					stopDebounceTimer()
 					return
 				}
 				color.Red("Watch error:", err)

plugins/jsvm/pool.go

@@ -0,0 +1,73 @@
+package jsvm
+
+import (
+	"sync"
+
+	"github.com/dop251/goja"
+)
+
+type poolItem struct {
+	mux  sync.Mutex
+	busy bool
+	vm   *goja.Runtime
+}
+
+type vmsPool struct {
+	mux     sync.RWMutex
+	factory func() *goja.Runtime
+	items   []*poolItem
+}
+
+// newPool creates a new pool with pre-warmed vms generated from the specified factory.
+func newPool(size int, factory func() *goja.Runtime) *vmsPool {
+	pool := &vmsPool{
+		factory: factory,
+		items:   make([]*poolItem, size),
+	}
+
+	for i := 0; i < size; i++ {
+		vm := pool.factory()
+		pool.items[i] = &poolItem{vm: vm}
+	}
+
+	return pool
+}
+
+// run executes "call" with a vm created from the pool
+// (either from the buffer or a new one if all buffered vms are busy)
+func (p *vmsPool) run(call func(vm *goja.Runtime) error) error {
+	p.mux.RLock()
+
+	// try to find a free item
+	var freeItem *poolItem
+	for _, item := range p.items {
+		item.mux.Lock()
+		if item.busy {
+			item.mux.Unlock()
+			continue
+		}
+		item.busy = true
+		item.mux.Unlock()
+		freeItem = item
+		break
+	}
+
+	p.mux.RUnlock()
+
+	// create a new one-off item if of all of the pool items are currently busy
+	//
+	// note: if turned out not efficient we may change this in the future
+	// by adding the created item in the pool with some timer for removal
+	if freeItem == nil {
+		return call(p.factory())
+	}
+
+	execErr := call(freeItem.vm)
+
+	// "free" the vm
+	freeItem.mux.Lock()
+	freeItem.busy = false
+	freeItem.mux.Unlock()
+
+	return execErr
+}