Subscribe *Promise Pending Status

[gastraight]

Hi.
Please while having a *Promise exposed out of a js runtime environment into golang one in case of PromiseStatePending what would be the best option to wait/subscribe for event once it is naturally resolved/rejected within the initial runtime? (Except of just a periodical state check)

E.g.

        value, err := vm.RunString(`
			new Promise(resolve  => setTimeout(resolve, 1000))
	`)
	if err != nil {
		panic(err)
	}
	if p, ok := value.Export().(*goja.Promise); ok {
		switch p.State() {
		case goja.PromiseStateRejected:
			panic(p.Result().String())
		case goja.PromiseStateFulfilled:
			result = p.Result().Export()
		default:
			// how to get notified once it is resolved/rejected 
		}
	}

For the very same reason please clarify from the docs of NewPromise

The returned values are not goroutine-safe and must not be called in parallel with VM running. In order to make use of this method you need an event loop

Do I see it right that runtime.RunString and all the similar handles its own event loop under the hood. And once runtime.RunString execution is ended (returned a value) whether underling event loop still keep on further processing?

Thnx

[gastraight]

P.S. I mean whether it is possible to subscribe to a state change purely on a golang side without extra hack wrapping at js as

new Promise(resolve  => setTimeout(resolve, 1000)).then(goResolver, goRejector)

[matthewmueller]

I was wondering the same thing. Would it be possible to expose the promise job queue?

Ideally it could be driven with: https://github.com/dop251/goja_nodejs/blob/master/eventloop/eventloop.go, but you could make your own event loop.

[drdaeman]

I understand that *Promise is not goroutine-safe, but I think it would be really nice to have a way for a Go program to be notified in a goroutine-safe way (e.g. by using a channel) when the promise changes its state.

Right now I'm doing this hack:

func watchPromise(promise *goja.Promise, interval time.Duration) <-chan struct{} {
	doneChan := make(chan struct{})
	go func() {
		defer close(doneChan)
		for {
			// I'm assuming this particular call is goroutine-safe, as it's only a `return p.state`
			// under the hood, and `state` is effectively an `int` that can change only once.
			state := promise.State()
			if state != goja.PromiseStatePending {
				break
			}
			time.Sleep(interval)
		}
	}()
	return doneChan
}

I hope my assumption there is correct - please let me know if it's not. However, I don't like my code as it requires an extra goroutine for each *Promise I'm interested in, has some extra latency, and makes some assumptions about how *Promise works internally.

Obviously, accessing promise.Result() (and working with it) has to be done in a goroutine-safe manner on the event loop (e.g. using RunOnLoop), but waiting for a signal doesn't have to be bound by this requirement. E.g. (just a crude sketch):

	jsCode := `async function run() { return 2+2; }`
	loop := eventloop.NewEventLoop()

	// Set things up, call run() and obtain the promise
	var runPromise *goja.Promise
	loop.RunOnLoop(func(vm *goja.Runtime) {
		_, err := vm.RunString(jsCode)
		if err != nil {
			runPromise = newRejectedPromise(vm, err)
			return
		}

		if runFunc, ok := goja.AssertFunction(vm.Get("run")); ok {
			promiseValue, err := runFunc(goja.Undefined())
			if err == nil {
				if p, ok := promiseValue.Export().(*goja.Promise); ok {
					runPromise = p
					return
				}
			}
		}

		runPromise = newRejectedPromise(vm, "something went wrong")
	})

	loop.Start()

	// Wait until we got the promise
	for runPromise == nil {  // I'm just being lazy here, there are better ways to do this
		time.Sleep(100 * time.Millisecond)
	}

	// Wait until the promise is resolved, then schedule code to do something about it
	<-watchPromise(runPromise, 100*time.Millisecond)
	loop.RunOnLoop(func(vm *goja.Runtime) {
		switch runPromise.State() {
		case goja.PromiseStateFulfilled:
			fmt.Println("Promise resolved with result:", runPromise.Result())
		case goja.PromiseStateRejected:
			fmt.Println("Promise was rejected:", runPromise.Result())
		}
	})

If this is a viable approach, how about introducing something like func (p *Promise) Done() <-chan struct{} that would return a channel that closes when the promise is resolved?

Thanks a lot!

[pjebs]

Here is my solution. It works nicely. I just wish I could inject my own *Runtime into NewEventLoop. I haven't implemented context cancellation but it shouldn't be too hard. It's just a call to vm.Interrupt(ctx.Err()).

import "github.com/dop251/goja_nodejs/eventloop"

func await(promise *goja.Promise) (string, error) {
	done := make(chan struct{})
	go func() {
		defer close(done)
		for promise.State() == goja.PromiseStatePending {
			time.Sleep(50 * time.Millisecond)
		}
		return
	}()
	<-done
	switch promise.State() {
	case goja.PromiseStateFulfilled:
		return promise.Result().Export().(string), nil
	default: // case goja.PromiseStateRejected:
		return "", errors.New(promise.Result().Export().(string))
	}
}

func Preprocess(ctx context.Context, source string, preprocessor []PreprocessorGroup) (*Processed, error) {
	if ctx == nil {
		ctx = context.Background()
	}
	ctx, cancel := context.WithCancel(ctx)
	defer cancel()

	loop := eventloop.NewEventLoop()

	res := make(chan *goja.Promise)
	defer close(res)

	loop.RunOnLoop(func(vm *goja.Runtime) {
		_, err := vm.RunProgram(prog)
		if err != nil {
			panic(err)
		}

		v, err := vm.RunString(fmt.Sprintf(`preprocess(`+"`%s`)", source))
		if err != nil {
			panic(err)
		}

		res <- v.Export().(*goja.Promise)
	})

	loop.Start()
	defer loop.Stop()

	p, err := await(<-res)
	if err != nil {
		return nil, err
	}

	processed := &Processed{}
	panic(p)
	err = json.Unmarshal(unsafeBytes(p), processed)
	if err != nil {
		panic(err)
	}
	return processed, nil
}