Develop

README.md

@@ -122,8 +122,7 @@ Explore tutorials that walk you through mocking different protocols and scenario
 - [LDAP](https://mokapi.io/docs/guides/ldap/overview)
 - [SMTP](https://mokapi.io/docs/guides/smtp/overview)
 - [Javascript API](https://mokapi.io/docs/javascript-api)
-- [Examples & Tutorials](https://mokapi.io/docs/resources)
-- [Blogs](https://mokapi.io/docs/blogs)
+- [Resources](https://mokapi.io/docs/resources)
 
 # ☕ Support
 

api/handler_schema_validate.go

@@ -13,6 +13,7 @@ import (
 	"mokapi/schema/json/parser"
 	jsonSchema "mokapi/schema/json/schema"
 	"net/http"
+	"strings"
 )
 
 type validateRequest struct {
@@ -89,6 +90,11 @@ func parseByOpenApi(data []byte, s *schema.Schema, ct media.ContentType) (interf
 	var v interface{}
 	var err error
 	if ct.IsXml() {
+		str := strings.TrimSpace(string(data))
+		if !strings.HasPrefix(str, "<") {
+			return nil, fmt.Errorf("input does not appear to be valid XML")
+		}
+
 		v, err = schema.UnmarshalXML(bytes.NewReader(data), s)
 		if err != nil {
 			return v, err

api/handler_schema_validate_test.go

@@ -168,6 +168,23 @@ func TestHandler_Schema_Validate(t *testing.T) {
 				)
 			},
 		},
+		{
+			name: "validating xml but send json data",
+			app: &runtime.App{
+				Monitor: monitor.New(),
+			},
+			fn: func(t *testing.T, h http.Handler, app *runtime.App) {
+				try.Handler(t,
+					http.MethodGet,
+					"http://foo.api/api/schema/validate",
+					nil,
+					`{ "schema": {"type": ["object"], "properties": { "foo":{ "type": ["string"] } }, "xml": { "name": "root" } }, "data":"{\"foo\":\"bar\"}", "format": "application/vnd.oai.openapi;version=3.0.0", "contentType": "application/xml" }`,
+					h,
+					try.HasBody(`["input does not appear to be valid XML"]`),
+					try.HasStatusCode(400),
+				)
+			},
+		},
 	}
 
 	for _, tc := range testcases {

docs/config.json

@@ -147,12 +147,20 @@
       "component": "examples",
       "hideNavigation": true,
       "hideInNavigation": true,
-      "title": "Learn with Mokapi's tutorials & examples",
-      "description": "Learn how to get started with Mokapi and simulate APIs that don't even exist yet."
+      "canonical": "/docs/resources",
+      "title": "Explore Mokapi Resources: Tutorials, Examples, and Blog Articles",
+      "description": "Explore Mokapi's resources including tutorials, examples, and blog articles. Learn to mock APIs, validate schemas, and streamline your development."
     },
     "items": {
       "Tutorials": {
-        "expanded": true,
+        "index": {
+          "component": "examples",
+          "hideNavigation": true,
+          "hideInNavigation": true,
+          "canonical": "/docs/resources",
+          "title": "Explore Mokapi Resources: Tutorials, Examples, and Blog Articles",
+          "description": "Explore Mokapi's resources including tutorials, examples, and blog articles. Learn to mock APIs, validate schemas, and streamline your development."
+        },
         "items": {
           "Get started with REST API": "resources/tutorials/simple-http-api.md",
           "Mock OpenAPI Authentication API Key & Bearer Token": "resources/tutorials/mock-openapi-auth-apikey-bearer.md",
@@ -167,26 +175,37 @@
         }
       },
       "Examples": {
-        "expanded": true,
+        "index": {
+          "component": "examples",
+          "hideNavigation": true,
+          "hideInNavigation": true,
+          "canonical": "/docs/resources",
+          "title": "Explore Mokapi Resources: Tutorials, Examples, and Blog Articles",
+          "description": "Explore Mokapi's resources including tutorials, examples, and blog articles. Learn to mock APIs, validate schemas, and streamline your development."
+        },
         "items": {
           "Mokapi behind Reverse Proxy": "resources/examples/mokapi-behind-proxy.md",
           "Mokapi with custom base image": "resources/examples/mokapi-with-custom-base-image.md"
         }
+      },
+      "Blogs": {
+        "index": {
+          "component": "examples",
+          "hideNavigation": true,
+          "hideInNavigation": true,
+          "canonical": "/docs/resources",
+          "title": "Explore Mokapi Resources: Tutorials, Examples, and Blog Articles",
+          "description": "Explore Mokapi's resources including tutorials, examples, and blog articles. Learn to mock APIs, validate schemas, and streamline your development."
+        },
+        "items": {
+          "Automation Testing in Agile Development": "resources/blogs/automation-testing-agile-development.md",
+          "Contract Testing": "resources/blogs/contract-testing.md",
+          "End to End Testing with Mocked APIs": "resources/blogs/end-to-end-testing-mocked-apis.md",
+          "Debugging Mokapi Scripts": "resources/blogs/debugging-mokapi-scripts.md"
+        }
       }
     }
   },
-  "Blogs": {
-    "index": {
-      "component": "blogs",
-      "hideInNavigation": true,
-      "title": "Mocking and Testing",
-      "description": "Learn about API mocking and contract testing. Improve your development skills."
-    },
-    "items": {
-      "Automation Testing in Agile Development": "blogs/automation-testing-agile-development.md",
-      "Contract Testing": "blogs/contract-testing.md"
-    }
-  },
   "References": {
     "items": {
       "Declarative Data": "references/declarative-data.md",

docs/configuration/dynamic/overview.md

@@ -1,17 +1,35 @@
 ---
-title: Configure your Mokapi with powerful providers
-description: Mokapi gathers configurations and scripts via providers.
+title: Configure your Mokapi with powerful configuration providers
+description: Learn how Mokapi gathers configurations and scripts using powerful providers. Customize your API mocks dynamically for flexible testing and development.
 ---
 
-# Providers
+# What Is Dynamic Configuration?
 
-Mokapi gathers configurations and scripts via providers.
+Dynamic configuration in Mokapi allows you to modify mock services, API behaviors, and test scenarios 
+in real-time without restarting the application. This capability is essential for agile 
+development and continuous integration workflows, enabling rapid iteration and testing of various 
+API responses.
 
-## Supported Providers
+## Features
 
-Below is the list of supported providers in Mokapi
+- **Live Updates:** Modify configurations on-the-fly to simulate different API behaviors. 
+- **Multi-Source Support:** Load configurations from various sources such as files, HTTP endpoints, Git repositories, or NPM packages. 
+- **JavaScript Integration:** Utilize embedded JavaScript to define dynamic behaviors, including conditional responses and simulated delays. 
+- **Patch-Based Changes:** Apply changes using patch configurations, preserving the original contract while customizing behaviors. 
+- **Dashboard Monitoring:** Visualize and manage configurations through an intuitive web interface.​
 
-- [File](/docs/configuration/dynamic/file.md)
-- [HTTP](/docs/configuration/dynamic/http.md)
-- [GIT](/docs/configuration/dynamic/git.md)
-- [NPM](/docs/configuration/dynamic/npm.md)
+## Configuration Sources
+
+Mokapi supports multiple configuration sources, providing flexibility in how you manage and deploy your mock services:
+
+- [**File System:**](/docs/configuration/dynamic/file.md) Store configurations locally for quick access and version control.
+- [**HTTP:**](/docs/configuration/dynamic/http.md) Fetch configurations from remote servers, facilitating centralized management. 
+- [**Git:**](/docs/configuration/dynamic/git.md) Integrate with Git to leverage version control and collaborative workflows. 
+- [**NPM Packages:**](/docs/configuration/dynamic/npm.md) Distribute and manage configurations as NPM packages for consistency across projects.
+
+## Best Practices
+
+- **Use Version Control:** Store your configuration files in a version control system like Git to track changes and collaborate effectively. 
+- **Modularize Configurations:** Break down configurations into modular components for reusability and easier maintenance. 
+- **Validate Configurations:** Regularly validate your configurations to ensure they meet the expected schema and behavior. 
+- **Monitor Changes:** Utilize Mokapi's dashboard to monitor configuration changes and their impact on mock services.

docs/configuration/introduction.md

@@ -1,6 +1,6 @@
 ---
-title: Introduction
-description: This page will introduce you to the startup and dynamic configurations.
+title: Introduction to Mokapi Configuration | Static & Dynamic Setup Explained
+description: Discover how to configure Mokapi using static files or dynamic updates. Learn startup options, hot-reloading, and flexible setup for your mocked APIs.
 ---
 # Introduction
 

docs/guides/get-started/running.md

@@ -1,6 +1,6 @@
 ---
-title: Running Your First Mocked REST API
-description: Learn how to mock a REST API and analyze HTTP request and response in the dashboard.
+title: Running Your First Mocked REST API with Mokapi
+description: Learn how to run your first mocked REST API using Mokapi. Monitor HTTP requests and responses in the dashboard—ideal for testing and debugging APIs.
 ---
 # Running Your First Mocked REST API with Mokapi
 

docs/guides/get-started/welcome.md

@@ -1,6 +1,6 @@
 ---
-title: "Getting Started with Mokapi: Mock APIs and Validate Against Schemas"
-description: Learn to set up Mokapi for mocking APIs, no account required, free and open-source.
+title: "Getting Started with Mokapi | Mock APIs & Validate with OpenAPI and AsyncAPI"
+description: Learn how to set up Mokapi to mock APIs and validate requests using OpenAPI or AsyncAPI. No account needed—free, open-source, and easy to use.
 cards:
   items:
     - title: Run your first mocked REST API

docs/guides/ldap/intro.md

@@ -1,6 +1,6 @@
 ---
 title: How to mock LDAP with Mokapi
-description: Integrate your App with a mock LDAP server
+description: Learn how to mock and test LDAP authentication using Mokapi. Simulate user login, group permissions, and directory structure for development and testing.
 cards:
   items:
     - title: Run your first mocked LDAP

docs/javascript-api/mokapi-http/args.md

@@ -1,6 +1,6 @@
 ---
-title: Args
-description: Args is an object used by functions in the module mokapi/http
+title: Args Object | Mokapi HTTP Module Function Parameters
+description: The Args object is used by functions in the Mokapi HTTP module to access request parameters, headers, body data, and more for API mocking logic.
 ---
 # Args
 

docs/javascript-api/mokapi-http/delete.md

@@ -1,6 +1,6 @@
 ---
-title: del( url, [body], [args] )
-description: Make an HTTP DELETE request
+title: del( url, [body], [args] ) - Mock HTTP DELETE Requests with Mokapi JavaScript API
+description: Use Mokapi's JavaScript API to mock HTTP DELETE requests. Customize responses, handle request data, and simulate APIs for testing and development.
 ---
 # del( url, [body], [args] )
 

docs/javascript-api/mokapi-http/get.md

@@ -1,6 +1,6 @@
 ---
-title: get( url, [args] )
-description: Make an HTTP GET request
+title: get( url, [args] ) - Mock HTTP GET Requests with Mokapi JavaScript API
+description: Use Mokapi's JavaScript API to mock HTTP GET requests. Customize responses, handle request data, and simulate APIs for testing and development.
 ---
 # get( url, [args] )
 

docs/javascript-api/mokapi-http/head.md

@@ -1,6 +1,6 @@
 ---
-title: head( url, [args] )
-description: Make an HTTP HEAD request
+title: head( url, [args] ) - Mock HTTP HEAD Requests with Mokapi JavaScript API
+description: Use Mokapi's JavaScript API to mock HTTP HEAD requests. Customize responses, handle request data, and simulate APIs for testing and development.
 ---
 # head( url, [args] )
 

docs/javascript-api/mokapi-http/httpresponse.md

@@ -1,6 +1,6 @@
 ---
-title: Response Object (mokapi/http)
-description: Returned by HTTP request methods in module mokapi/http.
+title: HTTP Response Object | Mokapi JavaScript API Reference (mokapi/http)
+description: Learn about the HTTP Response object returned by Mokapi's HTTP request methods. Access status, headers, and body for API mocking and testing.
 ---
 # Response
 

docs/javascript-api/mokapi-http/options.md

@@ -1,6 +1,6 @@
 ---
-title: options( url, [body], [args] )
-description: Make an HTTP OPTIONS request
+title: options( url, [body], [args] ) - Mock HTTP OPTIONS Requests with Mokapi JavaScript API
+description: Use Mokapi's JavaScript API to mock HTTP OPTIONS requests. Customize responses, handle request data, and simulate APIs for testing and development.
 ---
 # options( url, [body], [args] )
 

docs/javascript-api/mokapi-http/patch.md

@@ -1,6 +1,6 @@
 ---
-title: patch( url, [body], [args] )
-description: Make an HTTP PATCH request
+title: patch( url, [body], [args] ) - Mock HTTP PATCH Requests with Mokapi JavaScript API
+description: Use Mokapi's JavaScript API to mock HTTP PATCH requests. Customize responses, handle request data, and simulate APIs for testing and development.
 ---
 # patch( url, [body], [args] )
 

docs/javascript-api/mokapi-http/post.md

@@ -1,6 +1,6 @@
 ---
-title: post( url, [body], [args] )
-description: Make an HTTP POST request
+title: post( url, [body], [args] ) - Mock HTTP POST Requests with Mokapi JavaScript API
+description: Use Mokapi's JavaScript API to mock HTTP POST requests. Customize responses, handle request data, and simulate APIs for testing and development.
 ---
 # post( url, [body], [args] )
 

docs/javascript-api/mokapi-http/put.md

@@ -1,6 +1,6 @@
 ---
-title: put( url, [body], [args] )
-description: Make an HTTP PUT request
+title: put( url, [body], [args] ) - Mock HTTP PUT Requests with Mokapi JavaScript API
+description: Use Mokapi's JavaScript API to mock HTTP PUT requests. Customize responses, handle request data, and simulate APIs for testing and development.
 ---
 # put( url, [body], [args] )
 

docs/resources/blogs/debugging-mokapi-scripts.md

@@ -0,0 +1,86 @@
+---
+title: Debugging Mokapi JavaScript
+description: Learn how to debug your JavaScript code inside Mokapi using console.log, console.error, and event handler tracing.
+---
+
+# Debugging Mokapi JavaScript
+
+Mokapi makes it easy not only to mock APIs, LDAP servers, Kafka topics, and mail servers, but also to 
+customize behavior using JavaScript. To help you debug your JavaScript code inside Mokapi, it provides
+simple but powerful tools: `console.log`, `console.error`, and advanced event handler tracing.
+
+This article will walk you through how to effectively debug your JavaScript running in Mokapi.
+
+## Console Output: `console.log` and `console.error`
+
+Mokapi provides the familiar `console.log` and `console.error` functions that you know from the browser or Node.js. 
+These functions write directly to the Mokapi console output.
+
+Use `console.log` to output general debug information:
+```javascript
+console.log('Hello World');
+```
+
+Use `console.error` to report errors or unexpected behavior:
+```javascript
+console.error({ firstname:"John", lastname:"Doe" });
+```
+
+Everything you log will appear in the terminal or system where you run Mokapi, making 
+it easy to follow what your scripts are doing behind the scenes.
+
+``` box=tip
+There is also a function console.warn and console.debug
+```
+
+## Event Handler Tracing
+
+Sometimes you need even deeper insights into how Mokapi processes a request — especially when you 
+are using event handlers to customize behavior.
+
+If your event handler function returns `true`, Mokapi not only executes the event but also:
+
+- Logs the event handler data such as file, event type, event parameters 
+- Displays it in the Mokapi Dashboard under the request details
+
+This makes it very easy to see which handlers were involved in a request and in what order.
+
+Here's an example:
+```javascript
+import { on } from 'mokapi';
+
+export default () => {
+    on("http", (req, res) => {
+        console.log("Handling request for:", req.path);
+
+        if (req.path.startsWith("/admin")) {
+            console.log("Admin path detected");
+            return true; // Trace this handler
+        }
+        return false;
+    });
+}
+```
+
+In this case, because the handler returns true, Mokapi will:
+
+- Log that the onRequest handler was triggered 
+- List the handler in the dashboard under the request details
+
+This visibility is incredibly helpful when debugging complex request flows, especially if you have 
+multiple handlers reacting to a single request.
+
+## Best Practices for Debugging
+
+- Use console.log freely during development to trace values and decisions inside your scripts. 
+- Return true from important event handlers you want to trace in the dashboard. 
+- Use console.error for anything unexpected to separate normal logs from problems. 
+- Check the Dashboard for a clear overview of all event handlers triggered by a request.
+
+## Conclusion
+
+Debugging Mokapi JavaScript is straightforward with console.log, console.error, and event handler 
+tracing. Whether you're building complex mock logic or just getting started, these tools will help you 
+understand exactly what happens inside Mokapi when it processes your requests.
+
+Give it a try — and happy debugging!