In NgRx, what does an entity adapter's getSelectors() return, and why pass it a selector for the board's feature state?

## What getSelectors gives you Every adapter made by `createEntityAdapter` carries a `getSelectors` method that builds the four reads almost every collection needs: - **`selectIds`** — the `ids` array, in the adapter's order. - **`selectEntities`** — the `entities` dictionary, for lookup by key. - **`selectAll`** — `ids` mapped to their records: the collection as an ordered array. - **`selectTotal`** — `ids.length`, the number of records. There is no selector for one record by key. That is the job of a selector you compose from `selectEntities` and whatever holds the key. ## The two overloads `getSelectors` has two call forms, and the difference is the source of the most common bug with it. | Call | Input each selector expects | Built with | Safe for `store.select` | |---|---|---|---| | `getSelectors()` | the `EntityState` slice itself | plain functions plus memoized `selectAll`/`selectTotal` | no | | `getSelectors(selectBoardState)` | the root state | `createSelector` from the parent | yes | With **no argument**, `selectIds` is simply `(state) => state.ids`. That is right when the caller already holds the board slice: inside a reducer file, or as the projector of a `createSelector` that starts from the slice, which is how the official guide wires them. With a **parent selector**, each of the four is wrapped as `createSelector(selectBoardState, ...)`, so it accepts the root state and is typed as a `MemoizedSelector`. The return types name the difference too. The no-argument form is typed `EntitySelectors<Card, EntityState<Card>>`: plain functions whose input is the slice. The parent-selector form is typed `MemoizedEntitySelectors<Card, V>`, where `V` is whatever state your parent selector reads, normally the root state. When a teammate asks which one to export from the feature file, the answer is the second, unless the only callers are other selectors that already start from the slice. ## The bug the overloads cause ```ts // Wrong: the store passes the root state, which has no ids this.store.select(cardAdapter.getSelectors().selectAll); ``` 1. `store.select` calls the selector with the **root** state object. 2. The slice-level `selectIds` reads `root.ids`, which is `undefined`. 3. `selectAll`'s projector calls `.map` on `undefined` and throws a `TypeError`. The fix is to pass the feature selector: `cardAdapter.getSelectors(selectBoardState).selectAll`. ## How memoization plays out on the board `selectAll` is built from `selectIds` and `selectEntities`, so it recomputes only when one of those references changes. Combined with how the adapter writes, that gives useful stability: - Changing `selectedCardKey` produces a new board slice, but `ids` and `entities` keep their references, so `selectAll` returns the **same array**. - Renaming a card creates a new `entities` map, so `selectAll` returns a new array, while `selectIds` returns the same one. - A write that changes nothing returns the original state, so nothing recomputes. ## Reading one card by key Because the adapter has no by-key selector, reading "the open card" is a small composition, and there are two common shapes: - **Key held in state.** Store `selectedCardKey` beside the collection and combine a selector for it with `selectEntities`. The result recomputes when either the key or the dictionary changes, which is what the code example below does. - **Key held elsewhere.** When the key comes from the route or from a component input, build a selector factory that takes the key and returns `createSelector(selectCardEntities, (entities) => entities[key])`. Either way the lookup is `entities[key]`, typed `Card | undefined`, so the template or the caller must handle a key that points at nothing: a card that is still loading, was archived, or never existed. ## Counting and grouping `selectTotal` is the cheap count of the whole collection. Counts per column are a derived selector over `selectAll`: 1. Start from `selectAllCards`. 2. Reduce it into a `Record<string, number>` keyed by `columnId`. 3. Export the result as `selectCardCountByColumn`, memoized like any other selector, so the counts recompute only when the collection changes. ## Wiring it up A typical board feature file exports the adapter selectors under domain names and composes the rest: - Destructure and rename: `selectAll: selectAllCards`, `selectTotal: selectCardCount`. - Build the selected card from `selectEntities` and a selector for `selectedCardKey`. - Build per-column lists by filtering `selectAllCards` on `columnId`; with a `sortComparer`, each column is already in order. - When the feature is declared with `createFeature`, spread `cardAdapter.getSelectors(selectBoardState)` into its `extraSelectors`, as the NgRx entity recipe does. Each call to `getSelectors` builds fresh selectors with their own caches, so call it once per feature and export the results rather than calling it inside components.