Entity methods creator

docs/api/createEntityAdapter.mdx

@@ -239,7 +239,7 @@ In other words, they accept a state that looks like `{ids: [], entities: {}}`, a
 
 These CRUD methods may be used in multiple ways:
 
-- They may be passed as case reducers directly to `createReducer` and `createSlice`.
+- They may be passed as case reducers directly to `createReducer` and `createSlice`. (also see the [`create.entityMethods`](./createSlice#createentitymethods-entitymethodscreator) slice creator which can assist with this)
 - They may be used as "mutating" helper methods when called manually, such as a separate hand-written call to `addOne()` inside of an existing case reducer, if the `state` argument is actually an Immer `Draft` value.
 - They may be used as immutable update methods when called manually, if the `state` argument is actually a plain JS object or array.
 

docs/usage/custom-slice-creators.mdx

@@ -324,6 +324,105 @@ reducers: (create) => {
 
 :::
 
+##### `create.entityMethods` (`entityMethodsCreator`)
+
+Creates a set of reducers for managing a normalized entity state, based on a provided [adapter](./createEntityAdapter).
+
+```ts
+import {
+  createEntityAdapter,
+  buildCreateSlice,
+  entityMethodsCreator,
+} from '@reduxjs/toolkit'
+
+const createAppSlice = buildCreateSlice({
+  creators: { entityMethods: entityMethodsCreator },
+})
+
+interface Post {
+  id: string
+  text: string
+}
+
+const postsAdapter = createEntityAdapter<Post>()
+
+const postsSlice = createAppSlice({
+  name: 'posts',
+  initialState: postsAdapter.getInitialState(),
+  reducers: (create) => ({
+    ...create.entityMethods(postsAdapter),
+  }),
+})
+
+export const { setOne, upsertMany, removeAll, ...etc } = postsSlice.actions
+```
+
+:::caution
+
+Because this creator returns an object of multiple reducer definitions, it should be spread into the final object returned by the `reducers` callback.
+
+:::
+
+**Parameters**
+
+- **adapter** The [adapter](../api/createEntityAdapter) to use.
+- **config** The configuration object. (optional)
+
+The configuration object can contain some of the following options:
+
+**`selectEntityState`**
+
+A selector to retrieve the entity state from the slice state. Defaults to `state => state`, but should be provided if the entity state is nested.
+
+```ts no-transpile
+const postsSlice = createAppSlice({
+  name: 'posts',
+  initialState: { posts: postsAdapter.getInitialState() },
+  reducers: (create) => ({
+    ...create.entityMethods(postsAdapter, {
+      selectEntityState: (state) => state.posts,
+    }),
+  }),
+})
+```
+
+**`name`, `pluralName`**
+
+It's often desirable to modify the reducer names to be specific to the data type being used. These options allow you to do that simply.
+
+```ts no-transpile
+const postsSlice = createAppSlice({
+  name: 'posts',
+  initialState: postsAdapter.getInitialState(),
+  reducers: (create) => ({
+    ...create.entityMethods(postsAdapter, {
+      name: 'post',
+    }),
+  }),
+})
+
+const { addOnePost, upsertManyPosts, removeAllPosts, ...etc } =
+  postsSlice.actions
+```
+
+`pluralName` defaults to `name + 's'`, but can be provided if this isn't desired.
+
+```ts no-transpile
+const gooseSlice = createAppSlice({
+  name: 'geese',
+  initialState: gooseAdapter.getInitialState(),
+  reducers: (create) => ({
+    ...create.entityMethods(gooseAdapter, {
+      name: 'goose',
+      pluralName: 'geese',
+    }),
+  }),
+})
+
+const { addOneGoose, upsertManyGeese, removeAllGeese, ...etc } =
+  gooseSlice.actions
+```
+
 ## Writing your own creators
 
 In version v2.3.0, we introduced a system for including your own creators.
@@ -338,7 +437,7 @@ For example, the `create.preparedReducer` creator uses a definition that looks l
 
 The callback form of `reducers` should return an object of reducer definitions, by calling creators and nesting the result of each under a key.
 
-```js no-transpile
+```js
 reducers: (create) => ({
   addTodo: create.preparedReducer(
     (todo) => ({ payload: { id: nanoid(), ...todo } }),

packages/toolkit/src/asyncThunkCreator.ts

@@ -15,37 +15,6 @@ import type {
 import { ReducerType } from './createSlice'
 import type { Id } from './tsHelpers'
 
-export type AsyncThunkCreatorExposes<
-  State,
-  CaseReducers extends CreatorCaseReducers<State>,
-> = {
-  actions: {
-    [ReducerName in keyof CaseReducers]: CaseReducers[ReducerName] extends AsyncThunkSliceReducerDefinition<
-      State,
-      infer ThunkArg,
-      infer Returned,
-      infer ThunkApiConfig
-    >
-      ? AsyncThunk<Returned, ThunkArg, ThunkApiConfig>
-      : never
-  }
-  caseReducers: {
-    [ReducerName in keyof CaseReducers]: CaseReducers[ReducerName] extends AsyncThunkSliceReducerDefinition<
-      State,
-      any,
-      any,
-      any
-    >
-      ? Id<
-          Pick<
-            Required<CaseReducers[ReducerName]>,
-            'fulfilled' | 'rejected' | 'pending' | 'settled'
-          >
-        >
-      : never
-  }
-}
-
 export type AsyncThunkSliceReducerConfig<
   State,
   ThunkArg extends any,
@@ -145,6 +114,37 @@ export interface AsyncThunkCreator<
   >
 }
 
+export type AsyncThunkCreatorExposes<
+  State,
+  CaseReducers extends CreatorCaseReducers<State>,
+> = {
+  actions: {
+    [ReducerName in keyof CaseReducers]: CaseReducers[ReducerName] extends AsyncThunkSliceReducerDefinition<
+      State,
+      infer ThunkArg,
+      infer Returned,
+      infer ThunkApiConfig
+    >
+      ? AsyncThunk<Returned, ThunkArg, ThunkApiConfig>
+      : never
+  }
+  caseReducers: {
+    [ReducerName in keyof CaseReducers]: CaseReducers[ReducerName] extends AsyncThunkSliceReducerDefinition<
+      State,
+      any,
+      any,
+      any
+    >
+      ? Id<
+          Pick<
+            Required<CaseReducers[ReducerName]>,
+            'fulfilled' | 'rejected' | 'pending' | 'settled'
+          >
+        >
+      : never
+  }
+}
+
 export const asyncThunkCreator: ReducerCreator<ReducerType.asyncThunk> = {
   type: ReducerType.asyncThunk,
   create: /* @__PURE__ */ (() => {

packages/toolkit/src/createSlice.ts

@@ -20,6 +20,7 @@ import type {
   ReducerWithInitialState,
 } from './createReducer'
 import { createReducer, makeGetInitialState } from './createReducer'
+import type { EntityMethodsCreator } from './entities/slice_creator'
 import type { ActionReducerMapBuilder, TypedActionCreator } from './mapBuilders'
 import { executeReducerBuilderCallback } from './mapBuilders'
 import type {
@@ -36,6 +37,7 @@ export enum ReducerType {
   reducer = 'reducer',
   reducerWithPrepare = 'reducerWithPrepare',
   asyncThunk = 'asyncThunk',
+  entityMethods = 'entityMethods',
 }
 
 export type RegisteredReducerType = keyof SliceReducerCreators<
@@ -146,6 +148,7 @@ export interface SliceReducerCreators<
     AsyncThunkCreator<State>,
     AsyncThunkCreatorExposes<State, CaseReducers>
   >
+  [ReducerType.entityMethods]: ReducerCreatorEntry<EntityMethodsCreator<State>>
 }
 
 export type ReducerCreators<

packages/toolkit/src/entities/models.ts

@@ -1,8 +1,10 @@
+import type { UncheckedIndexedAccess } from '../uncheckedindexed'
 import type { Draft } from 'immer'
 import type { PayloadAction } from '../createAction'
-import type { CastAny, Id } from '../tsHelpers'
-import type { UncheckedIndexedAccess } from '../uncheckedindexed.js'
 import type { GetSelectorsOptions } from './state_selectors'
+import type { CastAny, Id } from '../tsHelpers'
+import type { CaseReducerDefinition } from '../createSlice'
+import type { CaseReducer } from '../createReducer'
 
 /**
  * @public
@@ -158,12 +160,53 @@ export interface EntityStateAdapter<T, Id extends EntityId> {
 /**
  * @public
  */
-export interface EntitySelectors<T, V, IdType extends EntityId> {
-  selectIds: (state: V) => IdType[]
-  selectEntities: (state: V) => Record<IdType, T>
-  selectAll: (state: V) => T[]
-  selectTotal: (state: V) => number
-  selectById: (state: V, id: IdType) => Id<UncheckedIndexedAccess<T>>
+export type EntitySelectors<
+  T,
+  V,
+  IdType extends EntityId,
+  Single extends string = '',
+  Plural extends string = DefaultPlural<Single>,
+> = Id<
+  {
+    [K in `select${Capitalize<Single>}Ids`]: (state: V) => IdType[]
+  } & {
+    [K in `select${Capitalize<Single>}Entities`]: (
+      state: V,
+    ) => Record<IdType, T>
+  } & {
+    [K in `selectAll${Capitalize<Plural>}`]: (state: V) => T[]
+  } & {
+    [K in `selectTotal${Capitalize<Plural>}`]: (state: V) => number
+  } & {
+    [K in `select${Capitalize<Single>}ById`]: (
+      state: V,
+      id: IdType,
+    ) => Id<UncheckedIndexedAccess<T>>
+  }
+>
+
+export type DefaultPlural<Single extends string> = Single extends ''
+  ? ''
+  : `${Single}s`
+
+export type EntityReducers<
+  T,
+  Id extends EntityId,
+  State = EntityState<T, Id>,
+  Single extends string = '',
+  Plural extends string = DefaultPlural<Single>,
+> = {
+  [K in keyof EntityStateAdapter<
+    T,
+    Id
+  > as `${K}${Capitalize<K extends `${string}One` ? Single : Plural>}`]: EntityStateAdapter<
+    T,
+    Id
+  >[K] extends (state: any) => any
+    ? CaseReducerDefinition<State, PayloadAction>
+    : EntityStateAdapter<T, Id>[K] extends CaseReducer<any, infer A>
+      ? CaseReducerDefinition<State, A>
+      : never
 }
 
 /**
@@ -187,12 +230,19 @@ export interface EntityAdapter<T, Id extends EntityId>
   extends EntityStateAdapter<T, Id>,
     EntityStateFactory<T, Id>,
     Required<EntityAdapterOptions<T, Id>> {
-  getSelectors(
+  getSelectors<
+    Single extends string = '',
+    Plural extends string = DefaultPlural<Single>,
+  >(
     selectState?: undefined,
-    options?: GetSelectorsOptions,
-  ): EntitySelectors<T, EntityState<T, Id>, Id>
-  getSelectors<V>(
+    options?: GetSelectorsOptions<Single, Plural>,
+  ): EntitySelectors<T, EntityState<T, Id>, Id, Single, Plural>
+  getSelectors<
+    V,
+    Single extends string = '',
+    Plural extends string = DefaultPlural<Single>,
+  >(
     selectState: (state: V) => EntityState<T, Id>,
-    options?: GetSelectorsOptions,
-  ): EntitySelectors<T, V, Id>
+    options?: GetSelectorsOptions<Single, Plural>,
+  ): EntitySelectors<T, V, Id, Single, Plural>
 }