CreateSlice serializability enforcement – missing constraint

CreateSlice serializability enforcement – missing constraint

createSlice does not validate that the initialState or reducer returns are serializable; it treats serializability as a developer responsibility.

Confirmed facts

• createSlice accepts any JavaScript value as initialState.
• Serializability warnings come only from the optional serializableCheck middleware.
• When that middleware is disabled, non‑serializable values can enter the store silently.
• Non‑serializable state breaks Redux DevTools time‑travel and causes JSON.stringify errors in persistence libraries such as redux‑persist.

How to enforce the contract at the slice level

1. Import the isSerializable utility from @reduxjs/toolkit (or write a simple recursive check).
2. Create a higher‑order function that wraps createSlice:

import { createSlice, isSerializable } from '@reduxjs/toolkit';

function serializableSlice(options) {
  if (!isSerializable(options.initialState)) {
    throw new Error('Slice initialState must be serializable');
  }
  const wrappedReducers = {};
  for (const [key, reducer] of Object.entries(options.reducers || {})) {
    wrappedReducers[key] = function(state, action) {
      const next = reducer(state, action);
      if (!isSerializable(next)) {
        throw new Error(`Reducer ${key} returned a non‑serializable value`);
      }
      return next;
    };
  }
  return createSlice({ ...options, reducers: wrappedReducers });
}

3. Use serializableSlice instead of createSlice when defining your slice.
4. Keep the standard serializableCheck middleware enabled in development; in production you may disable it because the wrapper already throws on violations.

Side‑effects when serializableCheck is off

• Redux DevTools will still display the state but time‑travel debugging will skip or corrupt actions that contain non‑serializable values.
• Persistence layers that rely on JSON.stringify (e.g., redux‑persist) will either drop the offending fields or throw, leading to incomplete or failed rehydration.
• Production builds that omit the middleware will not emit warnings, so the only defense is the slice‑level wrapper; without it, bugs remain silent.

If you are already using a persistence library, verify whether it performs its own serialization check; otherwise adopt the wrapper above to catch issues early.