fix: template engine, chaos API, and Mockoon import bugs

- Case-insensitive faker resolution (faker.Name == faker.name)
- Add randomInt/randomString/randomFloat aliases and faker.url
- Add random.float/randomFloat to space-separated handler
- ChaosFaultConfig custom UnmarshalJSON absorbs flat config fields
- Mockoon import converts to dot-notation (request.pathParam.id)
- Mockoon import maps query/header/body to correct engine syntax
- Add mockoon format to import help text and docs

Author: zach-snell

pkg/api/types/responses.go

@@ -3,6 +3,7 @@
 package types
 
 import (
+	"encoding/json"
 	"time"
 
 	"github.com/getmockd/mockd/pkg/config"
@@ -237,6 +238,70 @@ type ChaosFaultConfig struct {
 	Config      map[string]any `json:"config,omitempty"`
 }
 
+// knownFaultFields lists the JSON keys that map to struct fields on ChaosFaultConfig.
+// Everything else is treated as a fault-specific config parameter and gets merged
+// into the Config map so users don't have to nest them under "config".
+var knownFaultFields = map[string]bool{
+	"type":        true,
+	"probability": true,
+	"config":      true,
+}
+
+// UnmarshalJSON accepts both the canonical format (config params nested under "config")
+// and the flat format (config params alongside "type" and "probability").
+//
+// Canonical:  {"type":"circuit_breaker","probability":1.0,"config":{"tripAfter":3}}
+// Flat:       {"type":"circuit_breaker","probability":1.0,"tripAfter":3}
+//
+// When both forms are present for the same key, the explicit "config" value wins.
+func (f *ChaosFaultConfig) UnmarshalJSON(data []byte) error {
+	// Use an alias to avoid infinite recursion.
+	type Alias ChaosFaultConfig
+	var alias Alias
+	if err := json.Unmarshal(data, &alias); err != nil {
+		return err
+	}
+
+	// Decode the full blob to catch any extra keys.
+	var raw map[string]json.RawMessage
+	if err := json.Unmarshal(data, &raw); err != nil {
+		return err
+	}
+
+	// Collect unknown top-level keys as config params.
+	var extras map[string]any
+	for key, val := range raw {
+		if knownFaultFields[key] {
+			continue
+		}
+		if extras == nil {
+			extras = make(map[string]any)
+		}
+		var decoded any
+		if err := json.Unmarshal(val, &decoded); err != nil {
+			return err
+		}
+		extras[key] = decoded
+	}
+
+	// Merge: extras form the base, explicit "config" keys override.
+	if len(extras) > 0 {
+		if alias.Config == nil {
+			alias.Config = extras
+		} else {
+			// Explicit "config" wins — layer it on top of the extras.
+			for k, v := range extras {
+				if _, exists := alias.Config[k]; !exists {
+					alias.Config[k] = v
+				}
+			}
+		}
+	}
+
+	*f = ChaosFaultConfig(alias)
+	return nil
+}
+
 // ChaosStats represents chaos injection statistics.
 type ChaosStats struct {
 	TotalRequests    int64            `json:"totalRequests"`

pkg/api/types/responses_test.go

@@ -221,3 +221,234 @@ func TestPaginatedResponse(t *testing.T) {
 	assert.Equal(t, 100, result.Total)
 	assert.Equal(t, []string{"a", "b", "c"}, result.Items)
 }
+
+// --- ChaosFaultConfig UnmarshalJSON Tests ---
+
+func TestChaosFaultConfig_UnmarshalJSON_Canonical(t *testing.T) {
+	t.Parallel()
+
+	input := `{"type":"circuit_breaker","probability":1.0,"config":{"tripAfter":3,"openDuration":"10s"}}`
+
+	var f ChaosFaultConfig
+	err := json.Unmarshal([]byte(input), &f)
+	require.NoError(t, err)
+
+	assert.Equal(t, "circuit_breaker", f.Type)
+	assert.Equal(t, 1.0, f.Probability)
+	assert.Equal(t, float64(3), f.Config["tripAfter"])
+	assert.Equal(t, "10s", f.Config["openDuration"])
+}
+
+func TestChaosFaultConfig_UnmarshalJSON_Flat(t *testing.T) {
+	t.Parallel()
+
+	// User sends config params at top level — the common mistake / natural format.
+	input := `{"type":"circuit_breaker","probability":1.0,"tripAfter":3,"openDuration":"10s"}`
+
+	var f ChaosFaultConfig
+	err := json.Unmarshal([]byte(input), &f)
+	require.NoError(t, err)
+
+	assert.Equal(t, "circuit_breaker", f.Type)
+	assert.Equal(t, 1.0, f.Probability)
+	assert.Equal(t, float64(3), f.Config["tripAfter"])
+	assert.Equal(t, "10s", f.Config["openDuration"])
+}
+
+func TestChaosFaultConfig_UnmarshalJSON_BothFlatAndNested(t *testing.T) {
+	t.Parallel()
+
+	// Explicit "config" value wins when both are present for the same key.
+	input := `{
+		"type": "circuit_breaker",
+		"probability": 1.0,
+		"tripAfter": 5,
+		"openStatusCode": 502,
+		"config": {
+			"tripAfter": 3,
+			"openDuration": "10s"
+		}
+	}`
+
+	var f ChaosFaultConfig
+	err := json.Unmarshal([]byte(input), &f)
+	require.NoError(t, err)
+
+	assert.Equal(t, "circuit_breaker", f.Type)
+	assert.Equal(t, 1.0, f.Probability)
+	// Explicit config wins for tripAfter
+	assert.Equal(t, float64(3), f.Config["tripAfter"])
+	// openDuration comes from config
+	assert.Equal(t, "10s", f.Config["openDuration"])
+	// openStatusCode comes from flat (not in config)
+	assert.Equal(t, float64(502), f.Config["openStatusCode"])
+}
+
+func TestChaosFaultConfig_UnmarshalJSON_NoExtras(t *testing.T) {
+	t.Parallel()
+
+	// Basic fault with no config params at all — Config stays nil.
+	input := `{"type":"timeout","probability":0.5}`
+
+	var f ChaosFaultConfig
+	err := json.Unmarshal([]byte(input), &f)
+	require.NoError(t, err)
+
+	assert.Equal(t, "timeout", f.Type)
+	assert.Equal(t, 0.5, f.Probability)
+	assert.Nil(t, f.Config)
+}
+
+func TestChaosFaultConfig_UnmarshalJSON_EmptyConfig(t *testing.T) {
+	t.Parallel()
+
+	input := `{"type":"latency","probability":0.3,"config":{}}`
+
+	var f ChaosFaultConfig
+	err := json.Unmarshal([]byte(input), &f)
+	require.NoError(t, err)
+
+	assert.Equal(t, "latency", f.Type)
+	assert.Equal(t, 0.3, f.Probability)
+	// Empty config stays as empty map (not nil) since it was explicitly provided.
+	assert.NotNil(t, f.Config)
+	assert.Empty(t, f.Config)
+}
+
+func TestChaosFaultConfig_UnmarshalJSON_RetryAfterFlat(t *testing.T) {
+	t.Parallel()
+
+	input := `{"type":"retry_after","probability":1.0,"statusCode":429,"retryAfter":"30s","body":"rate limited"}`
+
+	var f ChaosFaultConfig
+	err := json.Unmarshal([]byte(input), &f)
+	require.NoError(t, err)
+
+	assert.Equal(t, "retry_after", f.Type)
+	assert.Equal(t, float64(429), f.Config["statusCode"])
+	assert.Equal(t, "30s", f.Config["retryAfter"])
+	assert.Equal(t, "rate limited", f.Config["body"])
+}
+
+func TestChaosFaultConfig_UnmarshalJSON_ProgressiveDegradationFlat(t *testing.T) {
+	t.Parallel()
+
+	input := `{
+		"type": "progressive_degradation",
+		"probability": 1.0,
+		"initialDelay": "20ms",
+		"delayIncrement": "5ms",
+		"maxDelay": "5s",
+		"errorAfter": 100
+	}`
+
+	var f ChaosFaultConfig
+	err := json.Unmarshal([]byte(input), &f)
+	require.NoError(t, err)
+
+	assert.Equal(t, "progressive_degradation", f.Type)
+	assert.Equal(t, "20ms", f.Config["initialDelay"])
+	assert.Equal(t, "5ms", f.Config["delayIncrement"])
+	assert.Equal(t, "5s", f.Config["maxDelay"])
+	assert.Equal(t, float64(100), f.Config["errorAfter"])
+}
+
+func TestChaosFaultConfig_UnmarshalJSON_InvalidJSON(t *testing.T) {
+	t.Parallel()
+
+	input := `{"type":"circuit_breaker","probability":}`
+
+	var f ChaosFaultConfig
+	err := json.Unmarshal([]byte(input), &f)
+	assert.Error(t, err)
+}
+
+func TestChaosFaultConfig_UnmarshalJSON_NestedArray(t *testing.T) {
+	t.Parallel()
+
+	// ChaosRuleConfig.Faults is a slice of ChaosFaultConfig — ensure the
+	// custom UnmarshalJSON works correctly when deserialized as part of a parent struct.
+	input := `{
+		"pathPattern": "/api/.*",
+		"faults": [
+			{"type":"circuit_breaker","probability":1.0,"tripAfter":3},
+			{"type":"latency","probability":0.5,"config":{"min":"100ms","max":"500ms"}}
+		]
+	}`
+
+	var rule ChaosRuleConfig
+	err := json.Unmarshal([]byte(input), &rule)
+	require.NoError(t, err)
+
+	require.Len(t, rule.Faults, 2)
+
+	// First fault: flat format
+	assert.Equal(t, "circuit_breaker", rule.Faults[0].Type)
+	assert.Equal(t, float64(3), rule.Faults[0].Config["tripAfter"])
+
+	// Second fault: canonical format
+	assert.Equal(t, "latency", rule.Faults[1].Type)
+	assert.Equal(t, "100ms", rule.Faults[1].Config["min"])
+	assert.Equal(t, "500ms", rule.Faults[1].Config["max"])
+}
+
+func TestChaosFaultConfig_UnmarshalJSON_FullChaosConfig(t *testing.T) {
+	t.Parallel()
+
+	// End-to-end: full ChaosConfig with flat fault params, as a user would send it.
+	input := `{
+		"enabled": true,
+		"rules": [
+			{
+				"pathPattern": "/api/orders.*",
+				"faults": [
+					{
+						"type": "circuit_breaker",
+						"probability": 1.0,
+						"tripAfter": 3,
+						"openDuration": "10s",
+						"openStatusCode": 503
+					}
+				]
+			}
+		]
+	}`
+
+	var cfg ChaosConfig
+	err := json.Unmarshal([]byte(input), &cfg)
+	require.NoError(t, err)
+
+	require.True(t, cfg.Enabled)
+	require.Len(t, cfg.Rules, 1)
+	require.Len(t, cfg.Rules[0].Faults, 1)
+
+	fault := cfg.Rules[0].Faults[0]
+	assert.Equal(t, "circuit_breaker", fault.Type)
+	assert.Equal(t, 1.0, fault.Probability)
+	assert.Equal(t, float64(3), fault.Config["tripAfter"])
+	assert.Equal(t, "10s", fault.Config["openDuration"])
+	assert.Equal(t, float64(503), fault.Config["openStatusCode"])
+}
+
+func TestChaosFaultConfig_MarshalJSON_RoundTrip(t *testing.T) {
+	t.Parallel()
+
+	// Marshal always produces the canonical format with nested "config".
+	original := ChaosFaultConfig{
+		Type:        "circuit_breaker",
+		Probability: 1.0,
+		Config:      map[string]any{"tripAfter": float64(3), "openDuration": "10s"},
+	}
+
+	data, err := json.Marshal(original)
+	require.NoError(t, err)
+
+	var roundTripped ChaosFaultConfig
+	err = json.Unmarshal(data, &roundTripped)
+	require.NoError(t, err)
+
+	assert.Equal(t, original.Type, roundTripped.Type)
+	assert.Equal(t, original.Probability, roundTripped.Probability)
+	assert.Equal(t, original.Config["tripAfter"], roundTripped.Config["tripAfter"])
+	assert.Equal(t, original.Config["openDuration"], roundTripped.Config["openDuration"])
+}

pkg/cli/bridge.go

@@ -86,6 +86,7 @@ Supported Formats:
   postman    Postman Collection v2.x
   har        HTTP Archive (browser recordings)
   wiremock   WireMock JSON mappings
+  mockoon    Mockoon environment JSON
   curl       cURL command
   wsdl       WSDL 1.1 service definition (generates SOAP mocks)`,
 	Example: `  # Import from OpenAPI spec (auto-detected)
@@ -97,6 +98,9 @@ Supported Formats:
   # Import from HAR file including static assets
   mockd import recording.har --include-static
 
+  # Import from Mockoon environment
+  mockd import environment.json -f mockoon
+
   # Import from cURL command
   mockd import "curl -X POST https://api.example.com/users -H 'Content-Type: application/json' -d '{\"name\": \"test\"}'"
 

pkg/cli/doc.go

@@ -7,7 +7,7 @@
 //   - list: Display all configured mocks
 //   - get: Show details of a specific mock
 //   - delete: Remove a mock by ID
-//   - import: Import mocks from various formats (OpenAPI, Postman, HAR, WireMock, cURL)
+//   - import: Import mocks from various formats (OpenAPI, Postman, HAR, WireMock, Mockoon, cURL)
 //   - export: Export mocks to native format or OpenAPI
 //   - new: Create new mock collections from templates (blank, crud, auth, pagination, errors)
 //   - generate: AI-powered mock generation from OpenAPI specs or descriptions
@@ -48,6 +48,7 @@
 //   - postman: Postman Collection v2.x
 //   - har: HTTP Archive (browser recordings)
 //   - wiremock: WireMock JSON mappings
+//   - mockoon: Mockoon environment JSON
 //   - curl: cURL commands
 //
 // Export formats:

pkg/portability/mockoon.go

@@ -386,16 +386,16 @@ var mockoonHelperPatterns = []struct {
 	pattern     *regexp.Regexp
 	replacement string
 }{
-	// Request data helpers
-	{regexp.MustCompile(`\{\{urlParam\s+'(\w+)'\}\}`), `{{ request.pathParam "$1" }}`},
-	{regexp.MustCompile(`\{\{urlParam\s+"(\w+)"\}\}`), `{{ request.pathParam "$1" }}`},
-	{regexp.MustCompile(`\{\{queryParam\s+'(\w+)'\}\}`), `{{ request.queryParam "$1" }}`},
-	{regexp.MustCompile(`\{\{queryParam\s+"(\w+)"\}\}`), `{{ request.queryParam "$1" }}`},
-	{regexp.MustCompile(`\{\{header\s+'([^']+)'\}\}`), `{{ request.header "$1" }}`},
-	{regexp.MustCompile(`\{\{header\s+"([^"]+)"\}\}`), `{{ request.header "$1" }}`},
-	{regexp.MustCompile(`\{\{body\s+'([^']+)'\}\}`), `{{ request.body "$.$1" }}`},
-	{regexp.MustCompile(`\{\{body\s+"([^"]+)"\}\}`), `{{ request.body "$.$1" }}`},
-	{regexp.MustCompile(`\{\{bodyRaw\}\}`), `{{ request.rawBody }}`},
+	// Request data helpers — mockd uses dot-notation: {{request.pathParam.id}}, {{request.query.page}}, etc.
+	{regexp.MustCompile(`\{\{urlParam\s+'(\w+)'\}\}`), `{{request.pathParam.$1}}`},
+	{regexp.MustCompile(`\{\{urlParam\s+"(\w+)"\}\}`), `{{request.pathParam.$1}}`},
+	{regexp.MustCompile(`\{\{queryParam\s+'(\w+)'\}\}`), `{{request.query.$1}}`},
+	{regexp.MustCompile(`\{\{queryParam\s+"(\w+)"\}\}`), `{{request.query.$1}}`},
+	{regexp.MustCompile(`\{\{header\s+'([^']+)'\}\}`), `{{request.header.$1}}`},
+	{regexp.MustCompile(`\{\{header\s+"([^"]+)"\}\}`), `{{request.header.$1}}`},
+	{regexp.MustCompile(`\{\{body\s+'([^']+)'\}\}`), `{{request.body.$1}}`},
+	{regexp.MustCompile(`\{\{body\s+"([^"]+)"\}\}`), `{{request.body.$1}}`},
+	{regexp.MustCompile(`\{\{bodyRaw\}\}`), `{{request.rawBody}}`},
 
 	// Utility helpers
 	{regexp.MustCompile(`\{\{uuid\}\}`), `{{ uuid }}`},
@@ -412,7 +412,7 @@ var mockoonHelperPatterns = []struct {
 	{regexp.MustCompile(`\{\{faker\s+"person\.fullName"\}\}`), `{{ faker.name }}`},
 	{regexp.MustCompile(`\{\{faker\s+'internet\.email'\}\}`), `{{ faker.email }}`},
 	{regexp.MustCompile(`\{\{faker\s+"internet\.email"\}\}`), `{{ faker.email }}`},
-	{regexp.MustCompile(`\{\{faker\s+'internet\.url'\}\}`), `{{ faker.sentence }}`}, // no URL faker yet
+	{regexp.MustCompile(`\{\{faker\s+'internet\.url'\}\}`), `{{faker.url}}`},
 	{regexp.MustCompile(`\{\{faker\s+'internet\.ip'\}\}`), `{{ faker.ipv4 }}`},
 	{regexp.MustCompile(`\{\{faker\s+"internet\.ip"\}\}`), `{{ faker.ipv4 }}`},
 	{regexp.MustCompile(`\{\{faker\s+'internet\.ipv4'\}\}`), `{{ faker.ipv4 }}`},