fix null reference error in patching OpenAPI responses

improve JavaScript event handler tracking when called console.log
add JavaScript shared memory feature
update NPM types

Author: marle3003

engine/common/host.go

@@ -45,6 +45,8 @@ type Host interface {
 
 	Lock()
 	Unlock()
+
+	Store() Store
 }
 
 type Logger interface {
@@ -168,3 +170,8 @@ type FakerNode interface {
 	Name() string
 	Fake(r *generator.Request) (interface{}, error)
 }
+
+type Store interface {
+	Get(string) any
+	Set(string, any)
+}

engine/engine.go

@@ -1,7 +1,6 @@
 package engine
 
 import (
-	"github.com/pkg/errors"
 	"mokapi/config/dynamic"
 	"mokapi/config/static"
 	"mokapi/engine/common"
@@ -10,6 +9,8 @@ import (
 	"mokapi/runtime/metrics"
 	"sync"
 
+	"github.com/pkg/errors"
+
 	log "github.com/sirupsen/logrus"
 )
 
@@ -27,6 +28,12 @@ type Engine struct {
 	cfgEvent    static.Event
 	jobCounter  *metrics.Counter
 	sm          *events.StoreManager
+	store       *Store
+}
+
+type Store struct {
+	data map[string]any
+	mu   sync.RWMutex
 }
 
 func New(reader dynamic.Reader, app *runtime.App, config *static.Config, parallel bool) *Engine {
@@ -41,6 +48,7 @@ func New(reader dynamic.Reader, app *runtime.App, config *static.Config, paralle
 		cfgEvent:    config.Event,
 		jobCounter:  app.Monitor.JobCounter,
 		sm:          app.Events,
+		store:       &Store{data: make(map[string]any)},
 	}
 }
 
@@ -153,3 +161,15 @@ func (e *Engine) Scripts() int {
 func (e *Engine) IsLevelEnabled(level string) bool {
 	return e.logger.IsLevelEnabled(level)
 }
+
+func (s *Store) Get(key string) any {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.data[key]
+}
+
+func (s *Store) Set(key string, value any) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.data[key] = value
+}

engine/enginetest/host.go

@@ -27,6 +27,12 @@ type Host struct {
 	OnFunc             func(event string, do func(args ...interface{}) (bool, error), tags map[string]string)
 	FindFakerNodeFunc  func(name string) *generator.Node
 	m                  sync.Mutex
+	StoreTest          *Store
+}
+
+type Store struct {
+	data map[string]any
+	m    sync.RWMutex
 }
 
 type HttpClient struct {
@@ -103,7 +109,7 @@ func (h *Host) On(event string, do func(args ...interface{}) (bool, error), tags
 	}
 }
 
-func (h *Host) Cancel(jobId int) error {
+func (h *Host) Cancel(_ int) error {
 	return nil
 }
 
@@ -126,14 +132,18 @@ func (h *Host) Unlock() {
 	h.m.Unlock()
 }
 
-func (h *Host) HttpClient(opts common.HttpClientOptions) common.HttpClient {
+func (h *Host) HttpClient(_ common.HttpClientOptions) common.HttpClient {
 	return h.HttpClientTest
 }
 
 func (h *Host) KafkaClient() common.KafkaClient {
 	return h.KafkaClientTest
 }
 
+func (h *Host) Store() common.Store {
+	return h.StoreTest
+}
+
 func (c *HttpClient) Do(request *http.Request) (*http.Response, error) {
 	c.LastRequest = request
 	if c.DoFunc != nil {
@@ -160,3 +170,21 @@ func mustParse(s string) *url.URL {
 	}
 	return u
 }
+
+func (s *Store) Get(name string) any {
+	s.m.RLock()
+	defer s.m.RUnlock()
+	if s.data == nil {
+		return nil
+	}
+	return s.data[name]
+}
+
+func (s *Store) Set(name string, value any) {
+	s.m.Lock()
+	defer s.m.Unlock()
+	if s.data == nil {
+		s.data = map[string]any{name: value}
+	}
+	s.data[name] = value
+}

engine/eventhandler_test.go

@@ -1,11 +1,12 @@
 package engine_test
 
 import (
-	"github.com/stretchr/testify/require"
 	"mokapi/engine"
 	"mokapi/engine/common"
 	"mokapi/engine/enginetest"
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func TestEventHandler(t *testing.T) {
@@ -42,6 +43,26 @@ export default () => {
 		console.log('a log message from event handler')
 	}, { track: true })
 }
+`,
+			run: func(evt common.EventEmitter) []*common.Action {
+				return evt.Emit("http")
+			},
+			test: func(t *testing.T, actions []*common.Action, err error) {
+				require.NoError(t, err)
+				require.Len(t, actions, 1)
+				require.Len(t, actions[0].Logs, 1)
+				require.Equal(t, "a log message from event handler", actions[0].Logs[0].Message)
+				require.Equal(t, "log", actions[0].Logs[0].Level)
+			},
+		},
+		{
+			name: "calling console.log tracks the event handler",
+			script: `import { on } from 'mokapi'
+export default () => {
+	on('http', () => {
+		console.log('a log message from event handler')
+	})
+}
 `,
 			run: func(evt common.EventEmitter) []*common.Action {
 				return evt.Emit("http")

engine/host.go

@@ -79,11 +79,12 @@ func (sh *scriptHost) RunEvent(event string, args ...interface{}) []*common.Acti
 		}
 		sh.startEventHandler(action.AppendLog)
 		start := time.Now()
+		logs := len(action.Logs)
 
 		if b, err := eh.handler(args...); err != nil {
 			log.Errorf("unable to execute event handler: %v", err)
 			action.Error = &common.Error{Message: err.Error()}
-		} else if !b {
+		} else if !b && logs == len(action.Logs) {
 			sh.Unlock()
 			continue
 		} else {
@@ -336,6 +337,10 @@ func (sh *scriptHost) Unlock() {
 	sh.m.Unlock()
 }
 
+func (sh *scriptHost) Store() common.Store {
+	return sh.engine.store
+}
+
 func getScriptPath(u *url.URL) string {
 	if len(u.Path) > 0 {
 		return u.Path

js/mokapi/mokapi.go

@@ -2,14 +2,15 @@ package mokapi
 
 import (
 	"fmt"
-	"github.com/dop251/goja"
 	"mokapi/engine/common"
 	"mokapi/js/eventloop"
 	"mokapi/js/faker"
 	"mokapi/media"
 	"mokapi/providers/openapi/schema"
 	"os"
 	"time"
+
+	"github.com/dop251/goja"
 )
 
 type Module struct {
@@ -28,16 +29,17 @@ func Require(vm *goja.Runtime, module *goja.Object) {
 		loop: loop,
 	}
 	obj := module.Get("exports").(*goja.Object)
-	obj.Set("sleep", f.Sleep)
-	obj.Set("every", f.Every)
-	obj.Set("cron", f.Cron)
-	obj.Set("on", f.On)
-	obj.Set("env", f.Env)
-	obj.Set("encoding", f.Marshal)
-	obj.Set("date", f.Date)
-	obj.Set("marshal", f.Marshal)
-	obj.Set("patch", patch)
-	obj.Set("Delete", Delete)
+	_ = obj.Set("sleep", f.Sleep)
+	_ = obj.Set("every", f.Every)
+	_ = obj.Set("cron", f.Cron)
+	_ = obj.Set("on", f.On)
+	_ = obj.Set("env", f.Env)
+	_ = obj.Set("encoding", f.Marshal)
+	_ = obj.Set("date", f.Date)
+	_ = obj.Set("marshal", f.Marshal)
+	_ = obj.Set("patch", patch)
+	_ = obj.Set("Delete", Delete)
+	_ = obj.Set("shared", NewSharedMemory(host.Store()))
 }
 
 func (m *Module) Sleep(i interface{}) {

js/mokapi/shared.go

@@ -0,0 +1,98 @@
+package mokapi
+
+import (
+	"mokapi/engine/common"
+	"sync"
+)
+
+type SharedMemory struct {
+	data  map[string]any
+	clear func()
+	m     sync.RWMutex
+}
+
+func NewSharedMemory(store common.Store) *SharedMemory {
+	v := store.Get("shared-memory")
+	var data map[string]any
+	if v != nil {
+		data = v.(map[string]any)
+	} else {
+		data = make(map[string]any)
+		store.Set("shared-memory", data)
+	}
+
+	return &SharedMemory{data: data}
+}
+
+func (m *SharedMemory) Get(key string) any {
+	m.m.RLock()
+	defer m.m.RUnlock()
+
+	return m.data[key]
+}
+
+func (m *SharedMemory) Has(key string) bool {
+	m.m.RLock()
+	defer m.m.RUnlock()
+
+	_, b := m.data[key]
+	return b
+}
+
+func (m *SharedMemory) Set(key string, value any) {
+	m.m.Lock()
+	defer m.m.Unlock()
+	m.data[key] = value
+}
+
+func (m *SharedMemory) Delete(key string) {
+	m.m.Lock()
+	defer m.m.Unlock()
+	delete(m.data, key)
+}
+
+func (m *SharedMemory) Clear() {
+	m.m.Lock()
+	defer m.m.Unlock()
+	for k := range m.data {
+		delete(m.data, k)
+	}
+}
+
+func (m *SharedMemory) Update(key string, fn func(v any) any) any {
+	m.m.Lock()
+	defer m.m.Unlock()
+	v := fn(m.data[key])
+	m.data[key] = v
+	return v
+}
+
+func (m *SharedMemory) Keys() []string {
+	m.m.RLock()
+	defer m.m.RUnlock()
+	var keys []string
+	for k := range m.data {
+		keys = append(keys, k)
+	}
+	return keys
+}
+
+func (m *SharedMemory) Namespace(name string) *SharedMemory {
+	m.m.Lock()
+	v, ok := m.data[name]
+	m.m.Unlock()
+	if ok {
+		ns, ok := v.(*SharedMemory)
+
+		if !ok {
+			return nil
+		}
+		return ns
+	}
+
+	m.m.Lock()
+	defer m.m.Unlock()
+	ns := &SharedMemory{data: make(map[string]any)}
+	m.data[name] = ns
+	return ns
+}