Missing patch/update/set in signalStore api

[gmfun]

Which @ngrx/* package(s) are relevant/related to the feature request?

signals

Information

I understand that ngrx/signals is following functional apprach and thats why kept patchState as a separate function to update the signal value. But I feel this is a core feature and it should be part of signalStore itself.

Currently I am trying to migrate my exisitng implementation to use signalStore but I have lot of signal.set() usage in template. Now I have a create a method in the component to just set a value of signal. It is getting little cumbersome.
I can use withMethods to add methods to set value, but that is also similar.

Describe any alternatives/workarounds you're currently using

If core team of ngrx/signal do not want to expose patch from signalStore, one way to go about this is to add withPatchMethod or something like that, which will use withMethods under the hood and add set/patch/update methods to the signalStore without increasing the api surface of signalStore

I would be willing to submit a PR to fix this issue

• Yes
• No

[markostanimirovic]

Hi @gmfun,

This is by design. Main reasons:

• Encapsulation: In general, patchState should not be used outside of the SignalStore. State transitions should be handled via methods. As you mentioned, if the patchState method is needed publicly, we can easily create the withPatchState feature and reuse it.

function withPatchState<State extends object>() {
  return signalStoreFeature(
    { state: type<State>() },
    withMethods((store) => ({
      patchState(...updaters: Array<Partial<State> | PartialStateUpdater<State>>) {
        patchState(store, ...updaters);
      },
    }))
  );
}

const CounterStore = signalStore(
  withState({ count: 0 }),
  withPatchState(),
  withMethods(({ patchState }) => ({
    increment() {
      patchState(({ count }) => ({ count: count + 1 }));
    },
    decrement() {
      patchState(({ count }) => ({ count: count + 1 }));
    },
  }))
);

@Component({ /* ... */ })
class CounterComponent {
  constructor() {
    const store = inject(CounterStore);

    store.increment();
    store.decrement();
    store.patchState({ count: 0 });
  }
}

• Extensibility: When patchState is defined as a standalone function, we can easily create different 'versions' of patchState if needed. For instance, we can create the immerPatchState function to apply immutable updates in a mutable way:

const TodosStore = signalStore(
  withState({ todos: [] as Todo[] }),
  withMethods((store) => ({
    addTodo(todo: Todo) {
      immerPatchState(store, ({ todos }) => {
        todos.push(todo);
      });
    },
  }))
);

Hope this helps. Anyway, I'm going to convert this issue to discussion so other contributors can share their thoughts as well.