defineMutation loses arguments passed to setup function

[hackel]

When I pass in arguments to a composable created using defineMutation, they are not passed along to the setup function, causing my mutation to fail.
Example:

export const useUpdateInputMapping = defineMutation(uploadTab => {
    const { errorToast, successToast } = useBvToast();
    const {
        isLoading: isSavingInputMapping,
        mutateAsync: saveInputMapping,
        ...mutation
    } = useMutation({
        mutation: inputMapping =>
            uploadTab.value.input_mappings?.[0]?.hash
                ? api.bidTool.inputMappings(uploadTab.value.input_mappings[0].hash).update(inputMapping)
                : api.bidTool.uploadTabs(uploadTab.hash).inputMappings.store(inputMapping),
        onSuccess() {
            successToast('Input mapping saved successfully');
        },
        onError(error) {
            console.error('Error saving input mapping:', error);
            errorToast('Error saving input mapping');
        },
    });

    return {
        ...mutation,
        isSavingInputMapping,
        saveInputMapping,
    };
});

In the above case, when I call useUpdateInputMapping(uploadTab), uploadTab is undefined inside the setup function. I'm aware that I could return a ref from the setup function, but that seems hacky as I would also have to add a watcher to update the ref whenever uploadTab changes.

[posva]

defineMutation() doesn't define a composable, it defines a singleton. In your case, you need a composable, so remove the defineMutation() and export the function directly.

[hackel]

D'oh, didn't even try that! So it's safe to use in multiple components because it doesn't maintain any state within the composable, right? And the same would be true for queries?

Thank you!

[posva]

It's different than queries. Mutations are not usually used across multiple components because while data is read simultaneously from multiple places it is only written by one component at a time.

So yes, it's safe to use in multiple components as long as they don't require shared state.

If you need to add parameters to queries, and these aren't global, then yes, you probably need a composable.