NgRx state persistence de-serialization failure under production minification

Answer first

Angular production builds do not rename object property names used for NgRx state, so disabling minification is not required to protect serialized keys. The hydration failures you see in production are almost always prototype loss from JSON serialization and missing schema versioning, not property mangling.

Two practical fixes for this case:

1. Keep persisted state plain and JSON serializable. Use string literal keys for actions and selectors, and avoid storing class instances in the store.
2. Version the persisted envelope and run slice-scoped migrations in the meta-reducer before returning hydrated state.

Confirmed facts vs likely explanation

Confirmed

• Angular CLI production builds with Terser or esbuild preserve object property names. Keys written to localStorage are read back with the same names.
• NgRx has no built-in versioning for persisted state. Migrations must be implemented in your meta-reducer or persistence service.
• JSON.stringify / JSON.parse strips prototypes. Date, Map, Set and custom class instances become plain objects, which is commonly mistaken for a minification issue.

Likely explanation for your symptoms

• De-serialization logic that relies on constructor names, instanceof checks, or class revivers fails after JSON.parse.
• Stale persisted data from an older schema shape is hydrated without migration, causing runtime errors on initialization.

Protect keys without disabling minification

Verify the build first, then enforce plain state.

• Search the production bundle for a known state key to confirm it is preserved:

grep -o "userProfile" dist/*.js

• With source maps, inspect the minified meta-reducer to confirm no renaming occurred.
• Store only plain objects in NgRx. If a type discriminator is needed, add a stable string field like __type instead of relying on class names.
• Use a custom reviver only for known value types, e.g., ISO date strings, not for class reconstruction.

Partial state migrations in a meta-reducer

Store a versioned envelope and apply ordered, slice-scoped migrations.

// persisted shape: { version: number, state: RootState }

Meta-reducer pattern:

const CURRENT_VERSION = 2;

function migrate(stateEnvelope) {
  let version = stateEnvelope?.version ?? 0;
  let state = stateEnvelope?.state ?? {};
  if (version < 1) state = migrateV0toV1(state);
  if (version < 2) state = migrateV1toV2(state);
  return { version: CURRENT_VERSION, state };
}

• Keep each migration pure, idempotent, and scoped to the smallest feature slice that changed.
• Apply migration before returning hydrated state, and fall back to initial state if parsing fails.
• Unit test migrations with snapshots of old state shapes passed through JSON.parse.

One diagnostic that changes the recommendation: does your persisted payload contain class instances such as Date or custom models? If yes, the fix is serialization normalization, not key protection.