Add Id type parameter to createEntityAdapter

Author: Matt-Ord

packages/rtk-query-codegen-openapi/.gitignore

@@ -137,3 +137,5 @@ yalc.lock
 lib
 yarn.lock
 test/tmp/example.ts
+test/tmp/emptyApi.ts
+test/tmp/out.ts

packages/toolkit/README.md

@@ -60,8 +60,8 @@ Redux Toolkit includes these APIs:
 - `configureStore()`: wraps `createStore` to provide simplified configuration options and good defaults. It can automatically combine your slice reducers, add whatever Redux middleware you supply, includes `redux-thunk` by default, and enables use of the Redux DevTools Extension.
 - `createReducer()`: lets you supply a lookup table of action types to case reducer functions, rather than writing switch statements. In addition, it automatically uses the [`immer` library](https://github.com/mweststrate/immer) to let you write simpler immutable updates with normal mutative code, like `state.todos[3].completed = true`.
 - `createAction()`: generates an action creator function for the given action type string. The function itself has `toString()` defined, so that it can be used in place of the type constant.
-- `createSlice()`: combines  `createReducer()` + `createAction()`. Accepts an object of reducer functions, a slice name, and an initial state value, and automatically generates a slice reducer with corresponding action creators and action types.
-- `createListenerMiddleware()`: lets you define "listener" entries that contain an "effect" callback with additional logic, and a way to specify when that callback should run based on dispatched actions or state changes. A lightweight alternative to Redux async middleware like sagas and observables. 
+- `createSlice()`: combines `createReducer()` + `createAction()`. Accepts an object of reducer functions, a slice name, and an initial state value, and automatically generates a slice reducer with corresponding action creators and action types.
+- `createListenerMiddleware()`: lets you define "listener" entries that contain an "effect" callback with additional logic, and a way to specify when that callback should run based on dispatched actions or state changes. A lightweight alternative to Redux async middleware like sagas and observables.
 - `createAsyncThunk()`: accepts an action type string and a function that returns a promise, and generates a thunk that dispatches `pending/resolved/rejected` action types based on that promise
 - `createEntityAdapter()`: generates a set of reusable reducers and selectors to manage normalized data in the store
 - The `createSelector()` utility from the [Reselect](https://github.com/reduxjs/reselect) library, re-exported for ease of use.

packages/toolkit/src/entities/create_adapter.ts

@@ -3,12 +3,27 @@ import type {
   Comparer,
   IdSelector,
   EntityAdapter,
+  EntityId,
 } from './models'
 import { createInitialStateFactory } from './entity_state'
 import { createSelectorsFactory } from './state_selectors'
 import { createSortedStateAdapter } from './sorted_state_adapter'
 import { createUnsortedStateAdapter } from './unsorted_state_adapter'
 
+export interface EntityAdapterOptions<T, Id extends EntityId> {
+  selectId?: IdSelector<T, Id>
+  sortComparer?: false | Comparer<T>
+}
+
+export function createEntityAdapter<T, Id extends EntityId>(options: {
+  selectId: IdSelector<T, Id>
+  sortComparer?: false | Comparer<T>
+}): EntityAdapter<T, Id>
+
+export function createEntityAdapter<T extends { id: EntityId }>(options?: {
+  sortComparer?: false | Comparer<T>
+}): EntityAdapter<T, T['id']>
+
 /**
  *
  * @param options
@@ -17,18 +32,18 @@ import { createUnsortedStateAdapter } from './unsorted_state_adapter'
  */
 export function createEntityAdapter<T>(
   options: {
-    selectId?: IdSelector<T>
+    selectId?: IdSelector<T, EntityId>
     sortComparer?: false | Comparer<T>
   } = {}
-): EntityAdapter<T> {
-  const { selectId, sortComparer }: EntityDefinition<T> = {
+): EntityAdapter<T, EntityId> {
+  const { selectId, sortComparer }: EntityDefinition<T, EntityId> = {
     sortComparer: false,
     selectId: (instance: any) => instance.id,
     ...options,
   }
 
-  const stateFactory = createInitialStateFactory<T>()
-  const selectorsFactory = createSelectorsFactory<T>()
+  const stateFactory = createInitialStateFactory<T, EntityId>()
+  const selectorsFactory = createSelectorsFactory<T, EntityId>()
   const stateAdapter = sortComparer
     ? createSortedStateAdapter(selectId, sortComparer)
     : createUnsortedStateAdapter(selectId)

packages/toolkit/src/entities/entity_state.ts

@@ -1,17 +1,20 @@
-import type { EntityState } from './models'
+import type { EntityId, EntityState } from './models'
 
-export function getInitialEntityState<V>(): EntityState<V> {
+export function getInitialEntityState<T, Id extends EntityId>(): EntityState<
+  T,
+  Id
+> {
   return {
     ids: [],
     entities: {},
   }
 }
 
-export function createInitialStateFactory<V>() {
-  function getInitialState(): EntityState<V>
+export function createInitialStateFactory<T, Id extends EntityId>() {
+  function getInitialState(): EntityState<T, Id>
   function getInitialState<S extends object>(
     additionalState: S
-  ): EntityState<V> & S
+  ): EntityState<T, Id> & S
   function getInitialState(additionalState: any = {}): any {
     return Object.assign(getInitialEntityState(), additionalState)
   }

packages/toolkit/src/entities/models.ts

@@ -14,158 +14,166 @@ export type Comparer<T> = (a: T, b: T) => number
 /**
  * @public
  */
-export type IdSelector<T> = (model: T) => EntityId
+export type IdSelector<T, Id extends EntityId> = (model: T) => Id
 
 /**
  * @public
  */
-export interface DictionaryNum<T> {
-  [id: number]: T | undefined
-}
-
-/**
- * @public
- */
-export interface Dictionary<T> extends DictionaryNum<T> {
-  [id: string]: T | undefined
-}
+export type Dictionary<T, Id extends EntityId> = Partial<Record<Id, T>>
 
 /**
  * @public
  */
-export type Update<T> = { id: EntityId; changes: Partial<T> }
+export type Update<T, Id extends EntityId> = { id: Id; changes: Partial<T> }
 
 /**
  * @public
  */
-export interface EntityState<T> {
-  ids: EntityId[]
-  entities: Dictionary<T>
+export interface EntityState<T, Id extends EntityId> {
+  ids: Id[]
+  entities: Dictionary<T, Id>
 }
 
 /**
  * @public
  */
-export interface EntityDefinition<T> {
-  selectId: IdSelector<T>
+export interface EntityDefinition<T, Id extends EntityId> {
+  selectId: IdSelector<T, Id>
   sortComparer: false | Comparer<T>
 }
 
-export type PreventAny<S, T> = IsAny<S, EntityState<T>, S>
+export type PreventAny<S, T, Id extends EntityId> = IsAny<
+  S,
+  EntityState<T, Id>,
+  S
+>
 
 /**
  * @public
  */
-export interface EntityStateAdapter<T> {
-  addOne<S extends EntityState<T>>(state: PreventAny<S, T>, entity: T): S
-  addOne<S extends EntityState<T>>(
-    state: PreventAny<S, T>,
+export interface EntityStateAdapter<T, Id extends EntityId> {
+  addOne<S extends EntityState<T, Id>>(
+    state: PreventAny<S, T, Id>,
+    entity: T
+  ): S
+  addOne<S extends EntityState<T, Id>>(
+    state: PreventAny<S, T, Id>,
     action: PayloadAction<T>
   ): S
 
-  addMany<S extends EntityState<T>>(
-    state: PreventAny<S, T>,
-    entities: readonly T[] | Record<EntityId, T>
+  addMany<S extends EntityState<T, Id>>(
+    state: PreventAny<S, T, Id>,
+    entities: readonly T[] | Record<Id, T>
   ): S
-  addMany<S extends EntityState<T>>(
-    state: PreventAny<S, T>,
-    entities: PayloadAction<readonly T[] | Record<EntityId, T>>
+  addMany<S extends EntityState<T, Id>>(
+    state: PreventAny<S, T, Id>,
+    entities: PayloadAction<readonly T[] | Record<Id, T>>
   ): S
 
-  setOne<S extends EntityState<T>>(state: PreventAny<S, T>, entity: T): S
-  setOne<S extends EntityState<T>>(
-    state: PreventAny<S, T>,
+  setOne<S extends EntityState<T, Id>>(
+    state: PreventAny<S, T, Id>,
+    entity: T
+  ): S
+  setOne<S extends EntityState<T, Id>>(
+    state: PreventAny<S, T, Id>,
     action: PayloadAction<T>
   ): S
-  setMany<S extends EntityState<T>>(
-    state: PreventAny<S, T>,
-    entities: readonly T[] | Record<EntityId, T>
+  setMany<S extends EntityState<T, Id>>(
+    state: PreventAny<S, T, Id>,
+    entities: readonly T[] | Record<Id, T>
   ): S
-  setMany<S extends EntityState<T>>(
-    state: PreventAny<S, T>,
-    entities: PayloadAction<readonly T[] | Record<EntityId, T>>
+  setMany<S extends EntityState<T, Id>>(
+    state: PreventAny<S, T, Id>,
+    entities: PayloadAction<readonly T[] | Record<Id, T>>
   ): S
-  setAll<S extends EntityState<T>>(
-    state: PreventAny<S, T>,
-    entities: readonly T[] | Record<EntityId, T>
+  setAll<S extends EntityState<T, Id>>(
+    state: PreventAny<S, T, Id>,
+    entities: readonly T[] | Record<Id, T>
   ): S
-  setAll<S extends EntityState<T>>(
-    state: PreventAny<S, T>,
-    entities: PayloadAction<readonly T[] | Record<EntityId, T>>
+  setAll<S extends EntityState<T, Id>>(
+    state: PreventAny<S, T, Id>,
+    entities: PayloadAction<readonly T[] | Record<Id, T>>
   ): S
 
-  removeOne<S extends EntityState<T>>(state: PreventAny<S, T>, key: EntityId): S
-  removeOne<S extends EntityState<T>>(
-    state: PreventAny<S, T>,
-    key: PayloadAction<EntityId>
+  removeOne<S extends EntityState<T, Id>>(
+    state: PreventAny<S, T, Id>,
+    key: Id
+  ): S
+  removeOne<S extends EntityState<T, Id>>(
+    state: PreventAny<S, T, Id>,
+    key: PayloadAction<Id>
   ): S
 
-  removeMany<S extends EntityState<T>>(
-    state: PreventAny<S, T>,
-    keys: readonly EntityId[]
+  removeMany<S extends EntityState<T, Id>>(
+    state: PreventAny<S, T, Id>,
+    keys: readonly Id[]
   ): S
-  removeMany<S extends EntityState<T>>(
-    state: PreventAny<S, T>,
-    keys: PayloadAction<readonly EntityId[]>
+  removeMany<S extends EntityState<T, Id>>(
+    state: PreventAny<S, T, Id>,
+    keys: PayloadAction<readonly Id[]>
   ): S
 
-  removeAll<S extends EntityState<T>>(state: PreventAny<S, T>): S
+  removeAll<S extends EntityState<T, Id>>(state: PreventAny<S, T, Id>): S
 
-  updateOne<S extends EntityState<T>>(
-    state: PreventAny<S, T>,
-    update: Update<T>
+  updateOne<S extends EntityState<T, Id>>(
+    state: PreventAny<S, T, Id>,
+    update: Update<T, Id>
   ): S
-  updateOne<S extends EntityState<T>>(
-    state: PreventAny<S, T>,
-    update: PayloadAction<Update<T>>
+  updateOne<S extends EntityState<T, Id>>(
+    state: PreventAny<S, T, Id>,
+    update: PayloadAction<Update<T, Id>>
   ): S
 
-  updateMany<S extends EntityState<T>>(
-    state: PreventAny<S, T>,
-    updates: ReadonlyArray<Update<T>>
+  updateMany<S extends EntityState<T, Id>>(
+    state: PreventAny<S, T, Id>,
+    updates: ReadonlyArray<Update<T, Id>>
   ): S
-  updateMany<S extends EntityState<T>>(
-    state: PreventAny<S, T>,
-    updates: PayloadAction<ReadonlyArray<Update<T>>>
+  updateMany<S extends EntityState<T, Id>>(
+    state: PreventAny<S, T, Id>,
+    updates: PayloadAction<ReadonlyArray<Update<T, Id>>>
   ): S
 
-  upsertOne<S extends EntityState<T>>(state: PreventAny<S, T>, entity: T): S
-  upsertOne<S extends EntityState<T>>(
-    state: PreventAny<S, T>,
+  upsertOne<S extends EntityState<T, Id>>(
+    state: PreventAny<S, T, Id>,
+    entity: T
+  ): S
+  upsertOne<S extends EntityState<T, Id>>(
+    state: PreventAny<S, T, Id>,
     entity: PayloadAction<T>
   ): S
 
-  upsertMany<S extends EntityState<T>>(
-    state: PreventAny<S, T>,
-    entities: readonly T[] | Record<EntityId, T>
+  upsertMany<S extends EntityState<T, Id>>(
+    state: PreventAny<S, T, Id>,
+    entities: readonly T[] | Record<Id, T>
   ): S
-  upsertMany<S extends EntityState<T>>(
-    state: PreventAny<S, T>,
-    entities: PayloadAction<readonly T[] | Record<EntityId, T>>
+  upsertMany<S extends EntityState<T, Id>>(
+    state: PreventAny<S, T, Id>,
+    entities: PayloadAction<readonly T[] | Record<Id, T>>
   ): S
 }
 
 /**
  * @public
  */
-export interface EntitySelectors<T, V> {
-  selectIds: (state: V) => EntityId[]
-  selectEntities: (state: V) => Dictionary<T>
+export interface EntitySelectors<T, V, Id extends EntityId> {
+  selectIds: (state: V) => Id[]
+  selectEntities: (state: V) => Dictionary<T, Id>
   selectAll: (state: V) => T[]
   selectTotal: (state: V) => number
-  selectById: (state: V, id: EntityId) => T | undefined
+  selectById: (state: V, id: Id) => T | undefined
 }
 
 /**
  * @public
  */
-export interface EntityAdapter<T> extends EntityStateAdapter<T> {
-  selectId: IdSelector<T>
+export interface EntityAdapter<T, Id extends EntityId>
+  extends EntityStateAdapter<T, Id> {
+  selectId: IdSelector<T, Id>
   sortComparer: false | Comparer<T>
-  getInitialState(): EntityState<T>
-  getInitialState<S extends object>(state: S): EntityState<T> & S
-  getSelectors(): EntitySelectors<T, EntityState<T>>
+  getInitialState(): EntityState<T, Id>
+  getInitialState<S extends object>(state: S): EntityState<T, Id> & S
+  getSelectors(): EntitySelectors<T, EntityState<T, Id>, Id>
   getSelectors<V>(
-    selectState: (state: V) => EntityState<T>
-  ): EntitySelectors<T, V>
+    selectState: (state: V) => EntityState<T, Id>
+  ): EntitySelectors<T, V, Id>
 }