Init

Author: akarashchuk

.editorconfig

@@ -0,0 +1,14 @@
+# editorconfig.org
+
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 4
+trim_trailing_whitespace = true
+
+[*.md]
+trim_trailing_whitespace = false

.github/workflows/build.yml

@@ -0,0 +1,28 @@
+name: build
+
+on:
+  push:
+    branches-ignore:
+      - master
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup Go
+        uses: actions/setup-go@v4
+        with:
+          go-version: '1.25.7'
+          cache: false
+
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Golangci Lint
+        uses: golangci/golangci-lint-action@v9
+
+      - name: Run tests
+        run: go test -race
+
+      - name: Check plugin
+        run: docker run --rm -v "$PWD/go.sum:/app/go.sum" -w /app krakend:2.13.1 krakend check-plugin -g 1.25.7 -l "MUSL-1.2.5_(alpine-3.23.3)" -s ./go.sum

.github/workflows/release.yml

@@ -0,0 +1,60 @@
+name: release
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup Go
+        uses: actions/setup-go@v4
+        with:
+          go-version: '1.25.7'
+          cache: false
+
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Golangci Lint
+        uses: golangci/golangci-lint-action@v9
+
+      - name: Run tests
+        run: go test -race
+
+      - name: Build project
+        run: |
+          docker run --rm -v "$PWD:/app" -w /app krakend/builder:2.13.1 go build -buildmode=plugin -o krakend-fallback.so .
+          docker run --rm -v "$PWD/krakend-fallback.so:/app/krakend-fallback.so" -w /app krakend:2.13.1 krakend test-plugin -sc krakend-fallback.so
+          zip ./krakend-fallback.zip ./krakend-fallback.so
+
+      - name: Bump version and push tag
+        id: bump_tag
+        uses: anothrNick/github-tag-action@1.61.0
+        env:
+          GITHUB_TOKEN: ${{ secrets.JENKSY_GITHUB_TOKEN }}
+          WITH_V: true
+
+      - name: Create Release
+        id: create_release
+        uses: actions/create-release@v1.0.0
+        env:
+          GITHUB_TOKEN: ${{ secrets.JENKSY_GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ steps.bump_tag.outputs.new_tag }}
+          release_name: Release ${{ steps.bump_tag.outputs.new_tag }}
+          draft: false
+          prerelease: false
+
+      - name: Upload Release Asset
+        id: upload-release-asset
+        uses: actions/upload-release-asset@v1.0.1
+        env:
+          GITHUB_TOKEN: ${{ secrets.JENKSY_GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: ./krakend-fallback.zip
+          asset_name: krakend-fallback.zip
+          asset_content_type: application/zip

backend_error.go

@@ -0,0 +1,56 @@
+package main
+
+import (
+	"bytes"
+	"io"
+	"net/http"
+	"sort"
+	"strings"
+
+	"github.com/mitchellh/mapstructure"
+)
+
+type BackendError struct {
+	Status   int    `mapstructure:"http_status_code"`
+	Body     string `mapstructure:"http_body"`
+	Encoding string `mapstructure:"http_body_encoding"`
+}
+
+func (e BackendError) ToResponse() *http.Response {
+	enc := e.Encoding
+	if enc == "" {
+		enc = "text/plain"
+	}
+	return &http.Response{
+		StatusCode:    e.Status,
+		Header:        http.Header{"Content-Type": []string{enc}},
+		Body:          io.NopCloser(bytes.NewBufferString(e.Body)),
+		ContentLength: int64(len(e.Body)),
+	}
+}
+
+func FindBackendError(body map[string]interface{}) (*http.Response, bool) {
+	keys := make([]string, 0, len(body))
+	for k := range body {
+		if strings.HasPrefix(k, "error_") {
+			keys = append(keys, k)
+		}
+	}
+	if len(keys) == 0 {
+		return nil, false
+	}
+
+	sort.Strings(keys)
+	v, ok := body[keys[0]]
+	if !ok {
+		return nil, false
+	}
+
+	var berr BackendError
+
+	if err := mapstructure.WeakDecode(v, &berr); err != nil {
+		return nil, false
+	}
+
+	return berr.ToResponse(), true
+}

backend_error_test.go

@@ -0,0 +1,83 @@
+package main
+
+import (
+	"io"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func readString(t *testing.T, rc io.ReadCloser) string {
+	t.Helper()
+	defer func(rc io.ReadCloser) {
+		err := rc.Close()
+		assert.NoError(t, err)
+	}(rc)
+	b, err := io.ReadAll(rc)
+	assert.NoError(t, err)
+	return string(b)
+}
+
+func TestFindBackendError_NoKeys(t *testing.T) {
+	resp, ok := FindBackendError(map[string]interface{}{
+		"product": map[string]interface{}{"id": 1},
+	})
+
+	assert.False(t, ok)
+	assert.Nil(t, resp)
+}
+
+func TestFindBackendError_PicksFirstSortedKey(t *testing.T) {
+	body := map[string]interface{}{
+		"error_2": map[string]interface{}{
+			"http_status_code":   502,
+			"http_body":          `{"message":"second"}`,
+			"http_body_encoding": "application/json",
+		},
+		"error_1": map[string]interface{}{
+			"http_status_code":   500,
+			"http_body":          `{"message":"first"}`,
+			"http_body_encoding": "application/json; charset=utf-8",
+		},
+		"product": map[string]interface{}{"id": 1},
+	}
+
+	resp, ok := FindBackendError(body)
+	assert.True(t, ok)
+	assert.NotNil(t, resp)
+
+	assert.Equal(t, 500, resp.StatusCode)
+	assert.Equal(t, "application/json; charset=utf-8", resp.Header.Get("Content-Type"))
+
+	gotBody := readString(t, resp.Body)
+	assert.Equal(t, `{"message":"first"}`, gotBody)
+	assert.Equal(t, int64(len(gotBody)), resp.ContentLength)
+}
+
+func TestFindBackendError_InvalidShape_ReturnsFalse(t *testing.T) {
+	body := map[string]interface{}{
+		"error_1": "not an object",
+	}
+
+	resp, ok := FindBackendError(body)
+	assert.False(t, ok)
+	assert.Nil(t, resp)
+}
+
+func TestFindBackendErrorMissingEncoding(t *testing.T) {
+	body := map[string]interface{}{
+		"error_1": map[string]interface{}{
+			"http_status_code": 503,
+			"http_body":        "service unavailable",
+		},
+	}
+
+	resp, ok := FindBackendError(body)
+	assert.True(t, ok)
+	assert.NotNil(t, resp)
+	assert.Equal(t, 503, resp.StatusCode)
+	assert.Equal(t, "text/plain", resp.Header.Get("Content-Type"))
+
+	got := readString(t, resp.Body)
+	assert.Equal(t, `service unavailable`, got)
+}

config.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"errors"
+
+	"github.com/mitchellh/mapstructure"
+)
+
+const Namespace = "onliner/krakend-fallback"
+
+type Config struct {
+	Routes []Route `mapstructure:"routes"`
+}
+
+type Route struct {
+	Path     string                 `mapstructure:"path"`
+	Required []string               `mapstructure:"required"`
+	Default  map[string]interface{} `mapstructure:"default"`
+}
+
+func NewConfig(input map[string]interface{}) (*Config, error) {
+	raw, ok := input[Namespace].(map[string]interface{})
+	if !ok {
+		return nil, errors.New("configuration not found")
+	}
+
+	var cfg Config
+
+	if err := mapstructure.WeakDecode(raw, &cfg); err != nil {
+		return nil, err
+	}
+
+	return &cfg, nil
+}
+
+func (cfg *Config) MatchRoute(path string) (Route, bool) {
+	for _, r := range cfg.Routes {
+		if MatchPathTemplate(r.Path, path) {
+			return r, true
+		}
+	}
+
+	return Route{}, false
+}

config_test.go

@@ -0,0 +1,84 @@
+package main
+
+import (
+	"encoding/json"
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewConfig_ConfigNotFound(t *testing.T) {
+	_, err := NewConfig(map[string]interface{}{})
+	assert.Error(t, errors.New("configuration not found"), err)
+}
+
+func TestNewConfig_DecodeOK(t *testing.T) {
+	raw := []byte(`{
+	  "onliner/krakend-fallback": {
+	    "routes": [
+	      {
+	        "path": "/products/{product}/positions",
+	        "required": ["product"],
+	        "default": {"positions": [], "shops": null}
+	      },
+	      {
+	        "path": "/health",
+	        "required": [],
+	        "default": {}
+	      }
+	    ]
+	  }
+	}`)
+
+	var input map[string]interface{}
+	err := json.Unmarshal(raw, &input)
+	assert.NoError(t, err)
+
+	cfg, err := NewConfig(input)
+	assert.NoError(t, err)
+	assert.NotNil(t, cfg)
+	assert.Equal(t, 2, len(cfg.Routes))
+
+	r0 := cfg.Routes[0]
+	assert.Equal(t, "/products/{product}/positions", r0.Path)
+	assert.Equal(t, len(r0.Required), 1)
+	assert.Equal(t, "product", r0.Required[0])
+
+	_, ok := r0.Default["positions"]
+	assert.True(t, ok)
+	_, ok = r0.Default["shops"]
+	assert.True(t, ok)
+}
+
+func TestConfig_MatchRoute_MatchesTemplate(t *testing.T) {
+	cfg := &Config{
+		Routes: []Route{
+			{
+				Path:     "/products/{product}/positions",
+				Required: []string{"product"},
+				Default:  map[string]interface{}{"positions": []interface{}{}},
+			},
+			{
+				Path:     "/health",
+				Required: nil,
+				Default:  nil,
+			},
+		},
+	}
+
+	route, ok := cfg.MatchRoute("/products/iphonex64s/positions")
+	assert.True(t, ok)
+	assert.Equal(t, "/products/{product}/positions", route.Path)
+}
+
+func TestConfig_MatchRoute_NoMatch(t *testing.T) {
+	cfg := &Config{
+		Routes: []Route{
+			{Path: "/a/{x}/b"},
+		},
+	}
+
+	_, ok := cfg.MatchRoute("/a/1/c")
+	assert.False(t, ok)
+}

go.mod

@@ -0,0 +1,14 @@
+module github.com/onliner/krakend-fallback
+
+go 1.25.7
+
+require (
+	github.com/mitchellh/mapstructure v1.5.0
+	github.com/stretchr/testify v1.11.1
+)
+
+require (
+	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)