main.go

// Command example demonstrates the immutable-state-invariant middleware
// catching an in-place state mutation performed by a reducer.
//
// It is the Go port of the original example/src/index.js, which used redux's
// createStore + applyMiddleware. Go has no redux, so this file includes a
// tiny store shim providing just enough of the createStore/applyMiddleware
// contract for the middleware to run. The reducer mutates state in place on the
// ARRAY_MUTATION action, exactly like the JS example, so dispatching it trips
// the invariant and the program reports the detected mutation.
package main

import (
	"fmt"

	invariant "github.com/leoasis/redux-immutable-state-invariant"
)

// reducer mirrors the JS example reducer: on ARRAY_MUTATION it pushes the
// action's element onto state.stuff *in place* and returns the same state
// object (the mutation the middleware is designed to catch); otherwise it
// returns state unchanged.
func reducer(state *invariant.Obj, action invariant.Action) *invariant.Obj {
	act := action.(*invariant.Obj)
	typ, _ := act.Get("type")
	if typ == invariant.Str("ARRAY_MUTATION") {
		stuff, _ := state.Get("stuff")
		element, _ := act.Get("element")
		stuff.(*invariant.Arr).Push(element)
		return state
	}
	return state
}

// store is a minimal Redux-like store: it holds the current state, exposes
// GetState, and threads dispatch through the single configured middleware.
type store struct {
	state    *invariant.Obj
	dispatch invariant.Dispatch
}

// createStore wires the reducer together with the middleware, mirroring
// createStore(reducer, applyMiddleware(mw)).
func createStore(initial *invariant.Obj, mw invariant.Middleware) *store {
	s := &store{state: initial}

	api := invariant.MiddlewareAPI{GetState: func() invariant.Value { return s.state }}

	// base is the innermost dispatch: run the reducer and store the result.
	base := invariant.Dispatch(func(action invariant.Action) invariant.Value {
		s.state = reducer(s.state, action)
		return action
	})

	s.dispatch = mw(api)(base)
	return s
}

func main() {
	initialState := invariant.NewObj().Set("stuff", invariant.NewArr())

	s := createStore(initialState, invariant.New(nil))

	action := invariant.NewObj().
		Set("type", invariant.Str("ARRAY_MUTATION")).
		Set("element", invariant.NewObj().Set("a", invariant.Num(1)).Set("b", invariant.Num(2)))

	// The reducer mutates state in place, so the middleware detects it and
	// panics with an *InvariantError. Recover so the example prints the
	// detected mutation rather than crashing, demonstrating the middleware's
	// behavior end to end.
	defer func() {
		if r := recover(); r != nil {
			if err, ok := r.(*invariant.InvariantError); ok {
				fmt.Println("Mutation detected by middleware:")
				fmt.Println(err.Message)
				return
			}
			panic(r)
		}
	}()

	s.dispatch(action)

	fmt.Println("No mutation detected (unexpected for this example).")
}