wip: also make resources available via tool

Author: marle3003

mcp/conditional-response.md

@@ -0,0 +1,61 @@
+# Scenario conditional-response
+
+HTTP mock handler for terminals.
+Demonstrates how to:
+- Access request parameters
+- Apply custom logic (e.g., lookup, filtering, updates)
+
+```typescript
+import { on } from "mokapi"
+
+interface Terminal {
+	id: string
+	compartments: {
+		id: string
+		doorState: 'open' | 'closed'
+	}[]
+}
+
+const terminals: Terminal[] = []
+
+export default function () {
+	on('http', (request, response) => {
+		switch(request.key) {
+			case '/terminals/{id}': {
+				const terminal = terminals.find(x => x.id === request.path.id)
+				if (!terminal) {
+					response.rebuild(404)
+					response.data = { error: 'terminal not found' }
+					return
+				}
+
+				if (request.method === 'GET') {
+					response.data = terminal
+				} else if (request.method === 'POST') {
+					// update the terminal
+					Object.assign(terminal, request.body)
+					// mokapi already set the success response, nothing to do
+				}
+				// do not raise an error if different method is used,
+				// maybe there is another event handler in a different file defined
+				return
+			}
+			case '/terminals': {
+				if (request.method === 'GET') {
+					response.data = terminals
+				} else if (request.method === 'POST') {
+					const terminal = terminals.find(x => x.id === request.path.id)
+					if (terminal) {
+						// console output will be displayed in the Mokapi's' dashboard
+						console.log('terminal already exists', request.body)
+						response.rebuild(400)
+					} else {
+						terminals.push(request.body)
+					}
+				}
+				return
+			}
+		}
+	})
+}
+```

mcp/delay-latency.md

@@ -0,0 +1,30 @@
+# Scenario delay-latency
+
+Simulate server latency by delaying the response. Useful to test scenarios:
+- frontend loading states
+- timeouts
+- high-load
+
+```typescript
+import { on } from "mokapi"
+
+let pets = [
+  { id: 1, name: 'Fluffy', status: 'available', category: { id: 1, name: 'Dogs' }, photoUrls: [], tags: [] },
+  { id: 3, name: 'Hedgie', status: 'pending', category: { id: 2, name: 'Small Animals' }, photoUrls: [], tags: [] }
+];
+
+export default function () {
+  on('http', async (request, response) => {
+    switch(request.key) {
+      case '/pets': {
+        if (request.method !== 'GET') return
+
+        // simulate network latency (e.g., 2 seconds)
+        sleep('2s')
+
+        response.data = pets
+      }
+    }
+  })
+}
+```

mcp/dynamic-error-simulation.md

@@ -0,0 +1,45 @@
+# Scenario dynamic-error-simulation
+
+Return error responses based on runtime conditions, such as missing resources, validation failures, or conflicting state.
+
+```typescript
+import { on } from "mokapi"
+
+const hotels = []
+
+export default function () {
+	on('http', (request, response) => {
+		switch(request.key) {
+			case '/bookings': {
+				const hotel = hotels.find(x => x.code === request.body?.hotel?.code)
+
+				if (!hotel) {
+				  console.log('hotel not found')
+				  response.rebuild(404)
+				  response.data = { error: 'hotel not found' }
+				  return
+				}
+
+				// simulate dynamic errors based on hotel simulation config
+				const type = hotel.simulation?.responseType
+				switch (type) {
+					case 'bad-request':
+						response.rebuild(400)
+						return
+					case 'unauthorized':
+						response.rebuild(401)
+						return
+					case 'forbidden':
+						response.rebuild(403)
+						return
+					case 'internal-server-error':
+						response.rebuild(500)
+						return
+				}
+				// success path: generate valid response
+				// ...
+			}
+		}
+	})
+}
+```

mcp/dynamic-path-params.md

@@ -0,0 +1,33 @@
+# Scenario dynamic-path-params
+
+HTTP mock handler to get a pet stored in an array list.
+Demonstrates how to:
+- Access request parameters
+- Apply custom logic (e.g., lookup, filtering)
+
+```typescript
+import { on } from "mokapi"
+
+let pets = [
+  { id: 1, name: 'Fluffy', status: 'available', category: { id: 1, name: 'Dogs' }, photoUrls: [], tags: [] },
+  { id: 3, name: 'Hedgie', status: 'pending', category: { id: 2, name: 'Small Animals' }, photoUrls: [], tags: [] }
+];
+
+export default function () {
+  on('http', async (request, response) => {
+    switch(request.key) {
+      case '/pets/{id}':
+        if (request.method !== 'GET') {
+          return
+        }
+        const pet = pets.find(x => x.id === request.path.id)
+        if (pet) {
+          response.data = pet
+        } else {
+          console.log('pet not found', request)
+          response.rebuild(404)
+        }
+	}
+  })
+}
+```

mcp/events.go

@@ -0,0 +1,77 @@
+package mcp
+
+import (
+	"fmt"
+	"mokapi/js/util"
+	"mokapi/runtime/events"
+	"reflect"
+	"strings"
+
+	"github.com/dop251/goja"
+)
+
+func (m *mokapi) getEvents(vTraits goja.Value, vLimit goja.Value) ([]events.Event, error) {
+	traits, err := parseTraits(vTraits, m.vm)
+	if err != nil {
+		return nil, err
+	}
+
+	evts := m.app.Events.GetEvents(traits)
+
+	limit := 10
+	if vLimit != nil {
+		if vLimit.ExportType().Kind() != reflect.Float64 {
+			return nil, fmt.Errorf("unexpected type for apiType: %s", util.JsType(vLimit.ExportType()))
+		}
+		limit = int(vLimit.ToInteger())
+	}
+	if len(evts) > limit {
+		return evts[0:limit], nil
+	} else {
+		return evts, nil
+	}
+}
+
+func parseTraits(v goja.Value, vm *goja.Runtime) (events.Traits, error) {
+	traits := events.Traits{}
+
+	if v == nil {
+		return traits, nil
+	}
+
+	if v.ExportType().Kind() != reflect.Map {
+		return nil, fmt.Errorf("expect object but got: %v", util.JsType(v.Export()))
+	}
+
+	obj := v.ToObject(vm)
+	for _, k := range obj.Keys() {
+		switch k {
+		case "type":
+			val := obj.Get(k)
+			if val.ExportType().Kind() != reflect.String {
+				return nil, fmt.Errorf("unexpected type for type: %s", util.JsType(val.ExportType()))
+			}
+			traits.WithNamespace(val.String())
+		case "name":
+			val := obj.Get(k)
+			if val.ExportType().Kind() != reflect.String {
+				return nil, fmt.Errorf("unexpected type for name: %s", util.JsType(val.ExportType()))
+			}
+			traits.WithName(val.String())
+		case "method":
+			val := obj.Get(k)
+			if val.ExportType().Kind() != reflect.String {
+				return nil, fmt.Errorf("unexpected type for method: %s", util.JsType(val.ExportType()))
+			}
+			traits.With("method", strings.ToUpper(val.String()))
+		default:
+			val := obj.Get(k)
+			if val.ExportType().Kind() != reflect.String {
+				return nil, fmt.Errorf("unexpected type for %s: %s", k, util.JsType(val.ExportType()))
+			}
+			traits.With(k, val.String())
+		}
+	}
+
+	return traits, nil
+}

mcp/events_test.go

@@ -0,0 +1,108 @@
+package mcp_test
+
+import (
+	"context"
+	"mokapi/mcp"
+	"mokapi/runtime"
+	"mokapi/runtime/events"
+	"mokapi/runtime/runtimetest"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+type testEvent struct {
+	Name string
+}
+
+func (t *testEvent) Title() string {
+	return t.Name
+}
+
+func TestEvents(t *testing.T) {
+	testcases := []struct {
+		name string
+		app  *runtime.App
+		code string
+		test func(t *testing.T, evts []events.Event, err error)
+	}{
+		{
+			name: "without params should not error",
+			code: "mokapi.getEvents()",
+			app: runtimetest.NewApp(
+				runtimetest.WithEvent(events.NewTraits().WithNamespace("http"), &testEvent{Name: "test-1"}),
+			),
+			test: func(t *testing.T, evts []events.Event, err error) {
+				require.NoError(t, err)
+				require.Len(t, evts, 1)
+				require.Equal(t, &testEvent{Name: "test-1"}, evts[0].Data)
+			},
+		},
+		{
+			name: "filter by API type",
+			code: "mokapi.getEvents({ type: 'http' })",
+			app: runtimetest.NewApp(
+				runtimetest.WithEvent(events.NewTraits().WithNamespace("kafka"), &testEvent{Name: "test-1"}),
+				runtimetest.WithEvent(events.NewTraits().WithNamespace("http"), &testEvent{Name: "test-2"}),
+			),
+			test: func(t *testing.T, evts []events.Event, err error) {
+				require.NoError(t, err)
+				require.Len(t, evts, 1)
+				require.Equal(t, &testEvent{Name: "test-2"}, evts[0].Data)
+			},
+		},
+		{
+			name: "filter by API name",
+			code: "mokapi.getEvents({ name: 'bar' })",
+			app: runtimetest.NewApp(
+				runtimetest.WithEvent(events.NewTraits().WithNamespace("http").WithName("foo"), &testEvent{Name: "test-1"}),
+				runtimetest.WithEvent(events.NewTraits().WithNamespace("http").WithName("bar"), &testEvent{Name: "test-2"}),
+			),
+			test: func(t *testing.T, evts []events.Event, err error) {
+				require.NoError(t, err)
+				require.Len(t, evts, 1)
+				require.Equal(t, &testEvent{Name: "test-2"}, evts[0].Data)
+			},
+		},
+		{
+			name: "filter by path",
+			code: "mokapi.getEvents({ path: '/pets' })",
+			app: runtimetest.NewApp(
+				runtimetest.WithEvent(events.NewTraits().WithNamespace("http").With("path", "/users"), &testEvent{Name: "test-1"}),
+				runtimetest.WithEvent(events.NewTraits().WithNamespace("http").With("path", "/pets"), &testEvent{Name: "test-2"}),
+			),
+			test: func(t *testing.T, evts []events.Event, err error) {
+				require.NoError(t, err)
+				require.Len(t, evts, 1)
+				require.Equal(t, &testEvent{Name: "test-2"}, evts[0].Data)
+			},
+		},
+		{
+			name: "filter by method",
+			code: "mokapi.getEvents({ method: 'post' })",
+			app: runtimetest.NewApp(
+				runtimetest.WithEvent(events.NewTraits().WithNamespace("http").With("method", "GET"), &testEvent{Name: "test-1"}),
+				runtimetest.WithEvent(events.NewTraits().WithNamespace("http").With("method", "POST"), &testEvent{Name: "test-2"}),
+			),
+			test: func(t *testing.T, evts []events.Event, err error) {
+				require.NoError(t, err)
+				require.Len(t, evts, 1)
+				require.Equal(t, &testEvent{Name: "test-2"}, evts[0].Data)
+			},
+		},
+	}
+
+	for _, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			s := mcp.NewService(tc.app)
+
+			r, err := s.GetRunResponse(
+				context.Background(),
+				mcp.RunInput{Code: tc.code},
+			)
+			require.IsType(t, []events.Event{}, r.Result)
+
+			tc.test(t, r.Result.([]events.Event), err)
+		})
+	}
+}