fix v2.0 integration merge conflicts

Author: Olesj-Bilous

packages/toolkit/src/entities/create_adapter.ts

@@ -1,4 +1,3 @@
-import type { Draft } from 'immer'
 import type {
   EntityDefinition,
   Comparer,

packages/toolkit/src/entities/models.ts

@@ -43,111 +43,109 @@ export interface EntityDefinition<T, Id extends EntityId> {
 export type PreventAny<S, T, Id extends EntityId> = CastAny<
   S,
   EntityState<T, Id>
->
+  >
 
-export type DraftableEntityState<T> = EntityState<T> | Draft<EntityState<T>>
-
-export type DraftableIdSelector<T> = IdSelector<T | Draft<T>>
+export type DraftableEntityState<T, Id extends EntityId> = EntityState<T, Id> | Draft<EntityState<T, Id>>
 
 /**
  * @public
  */
 export interface EntityStateAdapter<T, Id extends EntityId> {
-  addOne<S extends EntityState<T, Id>>(
+  addOne<S extends DraftableEntityState<T, Id>>(
     state: PreventAny<S, T, Id>,
     entity: T
   ): S
-  addOne<S extends EntityState<T, Id>>(
+  addOne<S extends DraftableEntityState<T, Id>>(
     state: PreventAny<S, T, Id>,
     action: PayloadAction<T>
   ): S
 
-  addMany<S extends EntityState<T, Id>>(
+  addMany<S extends DraftableEntityState<T, Id>>(
     state: PreventAny<S, T, Id>,
     entities: readonly T[] | Record<Id, T>
   ): S
-  addMany<S extends EntityState<T, Id>>(
+  addMany<S extends DraftableEntityState<T, Id>>(
     state: PreventAny<S, T, Id>,
     entities: PayloadAction<readonly T[] | Record<Id, T>>
   ): S
 
-  setOne<S extends EntityState<T, Id>>(
+  setOne<S extends DraftableEntityState<T, Id>>(
     state: PreventAny<S, T, Id>,
     entity: T
   ): S
-  setOne<S extends EntityState<T, Id>>(
+  setOne<S extends DraftableEntityState<T, Id>>(
     state: PreventAny<S, T, Id>,
     action: PayloadAction<T>
   ): S
-  setMany<S extends EntityState<T, Id>>(
+  setMany<S extends DraftableEntityState<T, Id>>(
     state: PreventAny<S, T, Id>,
     entities: readonly T[] | Record<Id, T>
   ): S
-  setMany<S extends EntityState<T, Id>>(
+  setMany<S extends DraftableEntityState<T, Id>>(
     state: PreventAny<S, T, Id>,
     entities: PayloadAction<readonly T[] | Record<Id, T>>
   ): S
-  setAll<S extends EntityState<T, Id>>(
+  setAll<S extends DraftableEntityState<T, Id>>(
     state: PreventAny<S, T, Id>,
     entities: readonly T[] | Record<Id, T>
   ): S
-  setAll<S extends EntityState<T, Id>>(
+  setAll<S extends DraftableEntityState<T, Id>>(
     state: PreventAny<S, T, Id>,
     entities: PayloadAction<readonly T[] | Record<Id, T>>
   ): S
 
-  removeOne<S extends EntityState<T, Id>>(
+  removeOne<S extends DraftableEntityState<T, Id>>(
     state: PreventAny<S, T, Id>,
     key: Id
   ): S
-  removeOne<S extends EntityState<T, Id>>(
+  removeOne<S extends DraftableEntityState<T, Id>>(
     state: PreventAny<S, T, Id>,
     key: PayloadAction<Id>
   ): S
 
-  removeMany<S extends EntityState<T, Id>>(
+  removeMany<S extends DraftableEntityState<T, Id>>(
     state: PreventAny<S, T, Id>,
     keys: readonly Id[]
   ): S
-  removeMany<S extends EntityState<T, Id>>(
+  removeMany<S extends DraftableEntityState<T, Id>>(
     state: PreventAny<S, T, Id>,
     keys: PayloadAction<readonly Id[]>
   ): S
 
-  removeAll<S extends EntityState<T, Id>>(state: PreventAny<S, T, Id>): S
+  removeAll<S extends DraftableEntityState<T, Id>>(state: PreventAny<S, T, Id>): S
 
-  updateOne<S extends EntityState<T, Id>>(
+  updateOne<S extends DraftableEntityState<T, Id>>(
     state: PreventAny<S, T, Id>,
     update: Update<T, Id>
   ): S
-  updateOne<S extends EntityState<T, Id>>(
+  updateOne<S extends DraftableEntityState<T, Id>>(
     state: PreventAny<S, T, Id>,
     update: PayloadAction<Update<T, Id>>
   ): S
 
-  updateMany<S extends EntityState<T, Id>>(
+  updateMany<S extends DraftableEntityState<T, Id>>(
     state: PreventAny<S, T, Id>,
     updates: ReadonlyArray<Update<T, Id>>
   ): S
-  updateMany<S extends EntityState<T, Id>>(
+  updateMany<S extends DraftableEntityState<T, Id>>(
     state: PreventAny<S, T, Id>,
     updates: PayloadAction<ReadonlyArray<Update<T, Id>>>
   ): S
 
-  upsertOne<S extends EntityState<T, Id>>(
+  upsertOne<S extends DraftableEntityState<T, Id>>(
     state: PreventAny<S, T, Id>,
     entity: T
   ): S
-  upsertOne<S extends EntityState<T, Id>>(
+  upsertOne<S extends DraftableEntityState<T, Id>>(
     state: PreventAny<S, T, Id>,
     entity: PayloadAction<T>
   ): S
 
-  upsertMany<S extends EntityState<T, Id>>(
+  upsertMany<S extends DraftableEntityState<T, Id>>(
     state: PreventAny<S, T, Id>,
     entities: readonly T[] | Record<Id, T>
   ): S
-  upsertMany<S extends EntityState<T, Id>>(
+  upsertMany<S extends DraftableEntityState<T, Id>>(
     state: PreventAny<S, T, Id>,
     entities: PayloadAction<readonly T[] | Record<Id, T>>
   ): S

packages/toolkit/src/entities/sorted_state_adapter.ts

@@ -1,13 +1,10 @@
-import type {Draft} from 'immer'
 import type {
-  EntityState,
   IdSelector,
   Comparer,
   EntityStateAdapter,
   Update,
   EntityId,
-  DraftableEntityState,
-  DraftableIdSelector,
+  DraftableEntityState
 } from './models'
 import { createStateOperator } from './state_adapter'
 import { createUnsortedStateAdapter } from './unsorted_state_adapter'
@@ -21,7 +18,7 @@ export function createSortedStateAdapter<T, Id extends EntityId>(
   selectId: IdSelector<T, Id>,
   sort: Comparer<T>
 ): EntityStateAdapter<T, Id> {
-  type R = EntityState<T, Id>
+  type R = DraftableEntityState<T, Id>
 
   const { removeOne, removeMany, removeAll } =
     createUnsortedStateAdapter(selectId)
@@ -81,7 +78,7 @@ export function createSortedStateAdapter<T, Id extends EntityId>(
     let appliedUpdates = false
 
     for (let update of updates) {
-      const entity: T | undefined = state.entities[update.id]
+      const entity: T | undefined = (state.entities as Record<Id, T>)[update.id]
       if (!entity) {
         continue
       }
@@ -91,8 +88,8 @@ export function createSortedStateAdapter<T, Id extends EntityId>(
       Object.assign(entity, update.changes)
       const newId = selectId(entity)
       if (update.id !== newId) {
-        delete state.entities[update.id]
-        state.entities[newId] = entity
+        delete (state.entities as Record<Id, T>)[update.id];
+        (state.entities as Record<Id, T>)[newId] = entity
       }
     }
 
@@ -136,7 +133,7 @@ export function createSortedStateAdapter<T, Id extends EntityId>(
   function merge(models: readonly T[], state: R): void {
     // Insert/overwrite all new/updated
     models.forEach((model) => {
-      state.entities[selectId(model)] = model
+      (state.entities as Record<Id, T>)[selectId(model)] = model
     })
 
     resortEntities(state)

packages/toolkit/src/entities/state_adapter.ts

@@ -1,30 +1,29 @@
 import { produce as createNextState, isDraft } from 'immer'
 import type {  Draft } from 'immer'
-import type { EntityId, DraftableEntityState, EntityState, PreventAny } from './models'
+import type { EntityId, DraftableEntityState, PreventAny } from './models'
 import type { PayloadAction } from '../createAction'
 import { isFSA } from '../createAction'
-import { IsAny } from '../tsHelpers'
 
 export const isDraftTyped = isDraft as <T>(value: T | Draft<T>) => value is Draft<T>
 
 export function createSingleArgumentStateOperator<T, Id extends EntityId>(
-  mutator: (state: EntityState<T, Id>) => void
+  mutator: (state: DraftableEntityState<T, Id>) => void
 ) {
   const operator = createStateOperator(
-    (_: undefined, state: EntityState<T, Id>) => mutator(state)
+    (_: undefined, state: DraftableEntityState<T, Id>) => mutator(state)
   )
 
-  return function operation<S extends EntityState<T, Id>>(
+  return function operation<S extends DraftableEntityState<T, Id>>(
     state: PreventAny<S, T, Id>
   ): S {
     return operator(state as S, undefined)
   }
 }
 
 export function createStateOperator<T, Id extends EntityId, R>(
-  mutator: (arg: R, state: EntityState<T, Id>) => void
+  mutator: (arg: R, state: DraftableEntityState<T, Id>) => void
 ) {
-  return function operation<S extends EntityState<T, Id>>(
+  return function operation<S extends DraftableEntityState<T, Id>>(
     state: S,
     arg: R | PayloadAction<R>
   ): S {
@@ -34,15 +33,15 @@ export function createStateOperator<T, Id extends EntityId, R>(
       return isFSA(arg)
     }
 
-    const runMutator = (draft: EntityState<T, Id>) => {
+    const runMutator = (draft: DraftableEntityState<T, Id>) => {
       if (isPayloadActionArgument(arg)) {
         mutator(arg.payload, draft)
       } else {
         mutator(arg, draft)
       }
     }
 
-    if (isDraftTyped<EntityState<V>>(state)) {
+    if (isDraftTyped<DraftableEntityState<T, Id>>(state)) {
       // we must already be inside a `createNextState` call, likely because
       // this is being wrapped in `createReducer` or `createSlice`.
       // It's safe to just pass the draft to the mutator.

packages/toolkit/src/entities/tests/entity_slice_enhancer.test.ts

@@ -1,44 +1,44 @@
 import { createEntityAdapter, createSlice } from "../..";
-import type { PayloadAction, Slice, SliceCaseReducers } from "../..";
-import type { DraftableIdSelector, EntityAdapter, EntityState, IdSelector } from "../models";
+import type { PayloadAction, Slice, SliceCaseReducers, UnknownAction } from "../..";
+import type { EntityId, EntityState, IdSelector } from "../models";
 import type { BookModel } from "./fixtures/book";
 
 describe('Entity Slice Enhancer', () => {
-  let slice: Slice<EntityState<BookModel>>;
+  let slice: Slice<EntityState<BookModel, BookModel['id']>>;
 
   beforeEach(() => {
     const indieSlice = entitySliceEnhancer({
       name: 'book',
-      selectDraftableId: (book: BookModel) => book.id
+      selectId: (book: BookModel) => book.id
     })
     slice = indieSlice
   })
 
   it('exposes oneAdded', () => {
-    const oneAdded = slice.reducer(undefined, slice.actions.oneAdded({
+    const book = {
       id: '0',
       title: 'Der Steppenwolf',
       author: 'Herman Hesse'
-    }))
-    expect(oneAdded.entities['0']?.id).toBe('0')
+    }
+    const action = slice.actions.oneAdded(book)
+    const oneAdded = slice.reducer(undefined, action as UnknownAction)
+    expect(oneAdded.entities['0']).toBe(book)
   })
 })
 
-interface EntitySliceArgs<T> {
+interface EntitySliceArgs<T, Id extends EntityId> {
   name: string
-  selectId?: IdSelector<T> // unusable
-  selectDraftableId?: DraftableIdSelector<T>
+  selectId: IdSelector<T, Id>
   modelReducer?: SliceCaseReducers<T>
 }
 
-function entitySliceEnhancer<T>({
+function entitySliceEnhancer<T, Id extends EntityId>({
   name,
-  selectId: unusableSelectId,
-  selectDraftableId,
+  selectId,
   modelReducer
-}: EntitySliceArgs<T>) {
+}: EntitySliceArgs<T, Id>) {
   const modelAdapter = createEntityAdapter({
-    selectId: selectDraftableId // unusableSelectId would give an interesting error
+    selectId
   });
 
   return createSlice({

packages/toolkit/src/entities/tests/entity_state.test.ts

@@ -6,7 +6,7 @@ import { createSlice } from '../../createSlice'
 import type { BookModel } from './fixtures/book'
 
 describe('Entity State', () => {
-  let adapter: EntityAdapter<string, BookModel>
+  let adapter: EntityAdapter<BookModel, string>
 
   beforeEach(() => {
     adapter = createEntityAdapter({