Useless (?) type property in createSlice

[Volper212]

When you create a slice, the reducers field is automatically split into all the action types so I don't see a reason to later include that property inside a function. Code could be a lot simpler if you could just have the second argument be the payload, not an object with both the action and the payload:

reducers: {
    remove: (state, id: ID) => adapter.removeOne(state, id),
}

instead of

reducers: {
    remove: (state, { payload: id }: PayloadAction<ID>) => adapter.removeOne(state, id),
}

If, in that rare case, you need the type in the action, why not just pass it as the third argument?

Redux Toolkit states on its website that it's simple, however it could be simpler (as in the first code block). To make this work in my project, I have this wrapper:

import {
    CaseReducer,
    createSlice,
    Draft,
    PayloadAction,
    ValidateSliceCaseReducers,
} from "@reduxjs/toolkit";

export function makeSlice<Name extends string, State, Reducers extends SliceReducers<State>>({
    name,
    initialState,
    reducers,
}: {
    name: Name;
    initialState: State;
    reducers: Reducers;
}) {
    return createSlice({
        name,
        initialState,
        reducers: Object.fromEntries(
            Object.entries(reducers).map(([name, reducer]) => [
                name,
                (state: Draft<State>, { payload }: PayloadAction<Payload>) =>
                    reducer(state, payload),
            ])
        ) as ValidateSliceCaseReducers<State, OutputReducers>,
    });

    type OutputReducers = {
        [K in keyof Reducers]: CaseReducer<State, PayloadAction<Parameters<Reducers[K]>[1]>>;
    };
}

type SliceReducers<State> = Record<string, Reducer<State>>;
type Reducer<State> = (state: Draft<State>, payload: Payload) => void | State | Draft<State>;

// eslint-disable-next-line @typescript-eslint/no-explicit-any
type Payload = any;

So users have a choice - write something weird like this or repetitively write PayloadAction in their reducers and take out the payload field from the object. Does it have to be like that? If you don't want to change this in Redux Toolkit because the field reducers would not fit the definition of a reducer anymore (that accepts state as one argument and the action as the second), you could call this actionHandlers or just handlers or something and have it be an opt-in alternative for reducers (just another optional field while keeping the old one).

[markerikson]

This is a topic we specifically discussed in the early alpha design phase:

#17 (comment)

We always pass the entire action object into the reducer, because there may be additional properties on it such as .meta and .error that your reducer logic may care about.

If you only care about .payload, you can destructure it in the declaration, but we even have code in RTK itself that specifically references action.meta, such as here:

redux-toolkit/packages/toolkit/src/query/core/buildSlice.ts

Line 315 in 4ab8c42

const { queryCacheKey } = action.meta.arg

[Volper212]

Can't you have them as the third and fourth argument?

[markerikson]

No. For one thing, it doesn't make any sense conceptually to take a single action object parameter, and suddenly start passing it as (state, payload, meta, error). Second, it would be a massive breaking change to the entire ecosystem, and to all of the very carefully constructed RTK TS types, and for no real benefit.

Like I said, if all you care about is payload, then just destructure it.